pybind11::detail::standard_nekmatrix_caster< Type, T > Struct Template Reference

#include <NekMatrix.hpp>

Public Member Functions
	PYBIND11_TYPE_CASTER (Type, const_name("NekMatrix<T>"))
bool	load (handle src, bool)

Static Public Member Functions
static handle	cast (const Nektar::NekMatrix< T, Nektar::StandardMatrixTag > &src, return_value_policy, handle)

Detailed Description

template<typename Type, typename T>
struct pybind11::detail::standard_nekmatrix_caster< Type, T >

Definition at line 46 of file Python/LinearAlgebra/NekMatrix.hpp.

Member Function Documentation

cast()

template<typename Type , typename T >

static handle pybind11::detail::standard_nekmatrix_caster< Type, T >::cast ( const Nektar::NekMatrix< T, Nektar::StandardMatrixTag > &  src, return_value_policy  , handle    )

inlinestatic

Definition at line 82 of file Python/LinearAlgebra/NekMatrix.hpp.

    {
        using NMat = Nektar::NekMatrix<T, Nektar::StandardMatrixTag>;
 
        // Construct a new wrapper matrix to hold onto the data. Assign a
        // destructor so that the wrapper is cleaned up when the Python object
        // is deallocated.
        capsule c(new NMat(src.GetRows(), src.GetColumns(), src.GetPtr(),
                           Nektar::eWrapper),
                  [](void *ptr) {
                      NMat *mat = (NMat *)ptr;
                      delete mat;
                  });
 
        // Create the NumPy array, passing the capsule. When we go out of scope,
        // c's reference count will have been reduced by 1, but array increases
        // the reference count when it assigns the base to the array.
        array a({src.GetRows(), src.GetColumns()},
                {sizeof(T), src.GetRows() * sizeof(T)}, src.GetRawPtr(), c);
 
        // This causes the array to be released without decreasing its reference
        // count, which we do since if we just returned a, then the array would
        // be deallocated immediately when this function returns.
        return a.release();
    }

References Nektar::eWrapper.

load()

template<typename Type , typename T >

bool pybind11::detail::standard_nekmatrix_caster< Type, T >::load ( handle  src, bool    )

inline

Definition at line 51 of file Python/LinearAlgebra/NekMatrix.hpp.

    {
        // Perform some checks: the source should be an ndarray.
        if (!array_t<T>::check_(src))
        {
            return false;
        }
 
        // The array should be a c-style, contiguous array of type T.
        auto buf = array_t<T, array::c_style | array::forcecast>::ensure(src);
        if (!buf)
        {
            return false;
        }
 
        // There should be two dimensions.
        auto dims = buf.ndim();
        if (dims != 2)
        {
            return false;
        }
 
        // Copy data across from the Python array to C++.
        std::vector<size_t> shape = {buf.shape()[0], buf.shape()[1]};
        value = Nektar::NekMatrix<T, Nektar::StandardMatrixTag>(
            shape[0], shape[1], buf.data(), Nektar::eFULL, buf.data());
 
        return true;
    }

References Nektar::eFULL.

PYBIND11_TYPE_CASTER()

template<typename Type , typename T >

pybind11::detail::standard_nekmatrix_caster< Type, T >::PYBIND11_TYPE_CASTER	(	Type	,
		const_name("NekMatrix<T>")
	)