#include <LibUtilities/BasicUtils/ErrorUtil.hpp>
#include <LibUtilities/Python/NekPyConfig.hpp>
#include <sstream>

Typedefs
using	NekError = Nektar::ErrorUtil::NekError

Functions
void	export_Basis ()
	Basis exports. More...

void	export_Comm ()
	Export for Comm communicator. More...

void	export_Interpreter ()

void	export_Equation ()

void	export_Points ()
	Points exports. More...

void	export_SessionReader ()
	SessionReader exports. More...

void	export_ShapeType ()
	Export for ShapeType enumeration. More...

template<typename T >
void	export_SharedArray ()

template<typename T >
void	export_NekMatrix ()

PyObject *	CreateExceptionClass (const char name, PyObject baseTypeObj=PyExc_Exception)

void	TranslateNekError (NekError const &e)

	BOOST_PYTHON_MODULE (_LibUtilities)

Variables
PyObject *	NekErrorType = nullptr

std::stringstream	errorStream

Typedef Documentation

◆ NekError

using NekError = Nektar::ErrorUtil::NekError

Definition at line 55 of file LibUtilities.cpp.

Function Documentation

◆ BOOST_PYTHON_MODULE()

BOOST_PYTHON_MODULE ( _LibUtilities )

Definition at line 79 of file LibUtilities.cpp.

 {
     np::initialize();
  
     // Register the NekError exception.
     NekErrorType = CreateExceptionClass("NekError");
     py::register_exception_translator<NekError>(&TranslateNekError);
  
     // Set a stringstream as an error sink to avoid duplicate output.
     Nektar::ErrorUtil::SetErrorStream(errorStream);
  
     export_Basis();
     export_Interpreter();
     export_Equation();
     export_Points();
     export_SessionReader();
     export_ShapeType();
     export_SharedArray<double>();
     export_NekMatrix<double>();
     export_Comm();
 }

References CreateExceptionClass(), errorStream, export_Basis(), export_Comm(), export_Equation(), export_Interpreter(), export_NekMatrix< double >(), export_Points(), export_SessionReader(), export_ShapeType(), export_SharedArray< double >(), NekErrorType, Nektar::ErrorUtil::SetErrorStream(), and TranslateNekError().

◆ CreateExceptionClass()

PyObject* CreateExceptionClass	(	const char *	name,
		PyObject *	baseTypeObj = `PyExc_Exception`
	)

Definition at line 57 of file LibUtilities.cpp.

 {
     std::string qualifiedName0 = std::string("NekPy.LibUtilities.") + name;
  
     PyObject *typeObj = PyErr_NewException(
         const_cast<char *>(qualifiedName0.c_str()), baseTypeObj, 0);
  
     if (!typeObj)
     {
         py::throw_error_already_set();
     }
  
     py::scope().attr(name) = py::handle<>(py::borrowed(typeObj));
     return typeObj;
 }

References CellMLToNektar.pycml::name.

Referenced by BOOST_PYTHON_MODULE().

◆ export_Basis()

void export_Basis ( )

Basis exports.

Definition at line 55 of file Python/Foundations/Basis.cpp.

 {
     // Enumerator for basis type
     NEKPY_WRAP_ENUM(BasisType, BasisTypeMap);
  
     py::class_<BasisKey>(
         "BasisKey", py::init<const BasisType &, const int, const PointsKey &>())
  
         .def("GetNumModes", &BasisKey::GetNumModes)
         .def("GetTotNumModes", &BasisKey::GetTotNumModes)
         .def("GetNumPoints", &BasisKey::GetNumPoints)
         .def("GetTotNumPoints", &BasisKey::GetTotNumPoints)
         .def("GetBasisType", &BasisKey::GetBasisType)
         .def("GetPointsKey", &BasisKey::GetPointsKey)
         .def("GetPointsType", &BasisKey::GetPointsType)
         .def("Collocation", &BasisKey::Collocation);
  
     py::class_<Basis, std::shared_ptr<Basis>>("Basis", py::no_init)
  
         .def("Create", &Basis_Create)
         .staticmethod("Create")
  
         .def("GetNumModes", &Basis::GetNumModes)
         .def("GetTotNumModes", &Basis::GetTotNumModes)
         .def("GetNumPoints", &Basis::GetNumPoints)
         .def("GetTotNumPoints", &Basis::GetTotNumPoints)
         .def("GetBasisType", &Basis::GetBasisType)
         .def("GetPointsKey", &Basis::GetPointsKey)
         .def("GetBasisKey", &Basis::GetBasisKey)
         .def("GetPointsType", &Basis::GetBasisType)
         .def("Initialize", &Basis::Initialize)
  
         .def("GetZ", &Basis::GetZ,
              py::return_value_policy<py::copy_const_reference>())
         .def("GetW", &Basis::GetW,
              py::return_value_policy<py::copy_const_reference>())
         .def("GetZW", &Basis_GetZW)
  
         .def("GetBdata", &Basis::GetBdata,
              py::return_value_policy<py::copy_const_reference>())
         .def("GetDbdata", &Basis::GetDbdata,
              py::return_value_policy<py::copy_const_reference>());
 }

Referenced by BOOST_PYTHON_MODULE().

◆ export_Comm()

void export_Comm ( )

Export for Comm communicator.

Definition at line 53 of file Python/Communication/Comm.cpp.

 {
     // Export ReduceOperator enum
     NEKPY_WRAP_ENUM(ReduceOperator, ReduceOperatorMap);
  
     py::class_<Comm, std::shared_ptr<Comm>, boost::noncopyable>("Comm",
                                                                 py::no_init)
         .def("GetSize", &Comm::GetSize)
         .def("GetRank", &Comm::GetRank)
         .def("GetType", &Comm::GetType,
              py::return_value_policy<py::copy_const_reference>())
         .def("AllReduce", &AllReduce<double>)
         .def("AllReduce", &AllReduce<int>)
         .def("AllReduce", &AllReduce<long>)
         .def("AllReduce", &AllReduce<Array<OneD, NekDouble>>);
 }

References AllReduce(), Nektar::LibUtilities::Comm::GetRank(), Nektar::LibUtilities::Comm::GetSize(), Nektar::LibUtilities::Comm::GetType(), NEKPY_WRAP_ENUM, and Nektar::LibUtilities::ReduceOperatorMap.

Referenced by BOOST_PYTHON_MODULE().

◆ export_Equation()

void export_Equation ( )

Definition at line 196 of file Python/BasicUtils/Equation.cpp.

 {
     py::class_<Equation, std::shared_ptr<Equation>, boost::noncopyable>(
         "Equation", py::no_init)
  
         .def("__init__", py::make_constructor(ConstructEquation))
  
         .def("Evaluate", Equation_Evaluate1)
         .def("Evaluate", Equation_Evaluate2)
         .def("Evaluate", Equation_Evaluate3)
         .def("Evaluate", Equation_Evaluate4)
         .def("Evaluate", Equation_Evaluate5)
  
         .def("SetParameter", &Equation::SetParameter)
         .def("SetConstants", py::raw_function(Equation_SetConstants))
         .def("GetExpression", &Equation::GetExpression)
         .def("GetVlist", &Equation::GetVlist)
  
         .def("GetTime", &Equation::GetTime);
 }

References ConstructEquation(), Equation_Evaluate1(), Equation_Evaluate2(), Equation_Evaluate3(), Equation_Evaluate4(), Equation_Evaluate5(), Equation_SetConstants(), Nektar::LibUtilities::Equation::GetExpression(), Nektar::LibUtilities::Equation::GetTime(), Nektar::LibUtilities::Equation::GetVlist(), and Nektar::LibUtilities::Equation::SetParameter().

Referenced by BOOST_PYTHON_MODULE().

◆ export_Interpreter()

void export_Interpreter ( )

Definition at line 226 of file Python/Interpreter/Interpreter.cpp.

 {
     py::class_<Interpreter, std::shared_ptr<Interpreter>, boost::noncopyable>(
         "Interpreter", py::init<>())
  
         .def("SetRandomSeed", &Interpreter::SetRandomSeed)
  
         .def("AddConstants", py::raw_function(Interpreter_AddConstants))
         .def("AddConstant", &Interpreter::AddConstant)
         .def("GetConstant", Interpreter_GetConstant)
  
         .def("SetParameters", py::raw_function(Interpreter_SetParameters))
         .def("SetParameter", &Interpreter::SetParameter)
         .def("GetParameter", Interpreter_GetParameter)
  
         .def("GetTime", &Interpreter::GetTime)
         .def("DefineFunction", &Interpreter::DefineFunction)
  
         .def("Evaluate", Interpreter_Evaluate)
         .def("Evaluate", Interpreter_Evaluate2)
         .def("Evaluate", Interpreter_Evaluate3)
         .def("Evaluate", Interpreter_Evaluate4)
  
         ;
 }

References Nektar::LibUtilities::Interpreter::AddConstant(), Nektar::LibUtilities::Interpreter::DefineFunction(), Nektar::LibUtilities::Interpreter::GetTime(), Interpreter_AddConstants(), Interpreter_Evaluate(), Interpreter_Evaluate2(), Interpreter_Evaluate3(), Interpreter_Evaluate4(), Interpreter_GetConstant(), Interpreter_GetParameter(), Interpreter_SetParameters(), Nektar::LibUtilities::Interpreter::SetParameter(), and Nektar::LibUtilities::Interpreter::SetRandomSeed().

Referenced by BOOST_PYTHON_MODULE().

◆ export_NekMatrix()

template<typename T >

void export_NekMatrix ( )

Definition at line 92 of file NekMatrix.cpp.

 {
     py::to_python_converter<std::shared_ptr<NekMatrix<T, StandardMatrixTag>>,
                             NekMatrixToPython<T>>();
 }

◆ export_Points()

void export_Points ( )

Points exports.

Definition at line 70 of file Python/Foundations/Points.cpp.

 {
     NEKPY_WRAP_ENUM_STRING_DOCS(
         PointsType, kPointsTypeStr,
         "Characterise the type of points.\n"
         "\n"
         "Sample usage: PointsType.GaussLobattoLegendre\n"
         "\n"
         "Available point types:\n"
         "\tNoPointsType: No points type.\n"
         "\tGaussGaussLegendre: 1D Gauss-Gauss-Legendre quadrature points.\n"
         "\tGaussRadauMLegendre: 1D Gauss-Radau-Legendre quadrature points,\n"
         "\t\tpinned at x=-1.\n"
         "\tGaussRadauPLegendre: 1D Gauss-Radau-Legendre quadrature points,\n"
         "\t\tpinned at x=1.\n"
         "\tGaussLobattoLegendre: 1D Gauss-Lobatto-Legendre quadrature points.\n"
         "\tGaussGaussChebyshev: 1D Gauss-Gauss-Chebyshev quadrature points.\n"
         "\tGaussRadauMChebyshev: 1D Gauss-Radau-Chebyshev quadrature points,\n"
         "\t\tpinned at x=-1.\n"
         "\tGaussRadauPChebyshev: 1D Gauss-Radau-Chebyshev quadrature points,\n"
         "\t\tpinned at x=1.\n"
         "\tGaussLobattoChebyshev: 1D Gauss-Lobatto-Legendre quadrature points\n"
         "\tGaussRadauMAlpha0Beta1: Gauss Radau pinned at x=-1,\n"
         "\t\talpha = 0, beta = 1\n"
         "\tGaussRadauMAlpha0Beta2: Gauss Radau pinned at x=-1,\n"
         "\t\talpha = 0, beta = 2\n"
         "\tGaussRadauMAlpha1Beta0: Gauss Radau pinned at x=-1,\n"
         "\t\talpha = 1, beta = 0\n"
         "\tGaussRadauMAlpha2Beta0: Gauss Radau pinned at x=-1,\n"
         "\t\talpha = 2, beta = 0\n"
         "\tGaussKronrodLegendre: 1D Gauss-Kronrod-Legendre quadrature points.\n"
         "\tGaussRadauKronrodMLegendre: 1D Gauss-Radau-Kronrod-Legendre "
         "quadrature\n"
         "\t\tpoints, pinned at x=-1.\n"
         "\tGaussRadauKronrodMAlpha1Beta0: 1D Gauss-Radau-Kronrod-Legendre\n"
         "\t\tpinned at x=-1, alpha = 1, beta = 0\n"
         "\tGaussLobattoKronrodLegendre: 1D Lobatto Kronrod quadrature points.\n"
         "\tPolyEvenlySpaced: 1D Evenly-spaced points using Lagrange "
         "polynomial.\n"
         "\tFourierEvenlySpaced: 1D Evenly-spaced points using Fourier Fit.\n"
         "\tFourierSingleModeSpaced: 1D Non Evenly-spaced points for Single "
         "Mode\n"
         "\t\tanalysis.\n"
         "\tBoundaryLayerPoints: 1D power law distribution for boundary layer "
         "points.\n"
         "\tBoundaryLayerPointsRev: 1D power law distribution for boundary "
         "layer\n"
         "\t\tpoints.\n"
         "\tNodalTriElec: 2D Nodal Electrostatic Points on a Triangle.\n"
         "\tNodalTriFekete: 2D Nodal Fekete Points on a Triangle.\n"
         "\tNodalTriEvenlySpaced: 2D Evenly-spaced points on a Triangle.\n"
         "\tNodalTetEvenlySpaced: 3D Evenly-spaced points on a Tetrahedron.\n"
         "\tNodalTetElec: 3D Nodal Electrostatic Points on a Tetrahedron.\n"
         "\tNodalPrismEvenlySpaced: 3D Evenly-spaced points on a Prism.\n"
         "\tNodalPrismElec: 3D electrostatically spaced points on a Prism.\n"
         "\tNodalTriSPI: 2D Nodal Symmetric positive internal triangle\n"
         "\t\t(Whitherden, Vincent).\n"
         "\tNodalTetSPI: 3D Nodal Symmetric positive internal tet\n"
         "\t\t(Whitherden, Vincent).\n"
         "\tNodalPrismSPI: 3D prism SPI.\n"
         "\tNodalQuadElec: 2D GLL for quad.\n"
         "\tNodalHexElec: 3D GLL for hex");
  
     py::class_<PointsKey>(
         "PointsKey",
         "Create a PointsKey which uniquely defines quadrature points.\n"
         "\n"
         "Args:\n"
         "\tnQuadPoints (integer): The number of quadrature points.\n"
         "\tpointsType (PointsType object): The type of quadrature points.",
         py::init<const int, const PointsType &>())
  
         .def("GetNumPoints", &PointsKey::GetNumPoints,
              "Get the number of quadrature points in PointsKey.\n"
              "\n"
              "Args:\n"
              "\tNone\n"
              "Returns:\n"
              "\tInteger defining the number of quadrature points in PointsKey.")
         .def("GetPointsType", &PointsKey::GetPointsType,
              "Get the type of points in PointsKey.\n"
              "\n"
              "Args:\n"
              "\tNone\n"
              "Returns:\n"
              "\tPointsType object specifying the type of points in PointsKey.")
         .def("GetPointsDim", &PointsKey::GetPointsDim,
              "Get the dimension of the PointsKey.\n"
              "\n"
              "Args:\n"
              "\tNone\n"
              "Returns:\n"
              "\tInteger characterising the dimension of the PointsKey (e.g. 2\n"
              "\tfor 2D PointsKey).")
         .def("GetTotNumPoints", &PointsKey::GetTotNumPoints,
              "Get the total number of points in PointsKey.\n"
              "\n"
              "Args:\n"
              "\tNone\n"
              "Returns:\n"
              "\tInteger defining the total number of points in PointsKey.");
  
     py::class_<Points<double>, std::shared_ptr<Points<double>>,
                boost::noncopyable>(
         "Points",
         "Create a set of points which can be used to calculate\n"
         "quadrature zeros, weights etc."
         "\n"
         "Args:\n"
         "\tNone",
         py::no_init)
         .def("Create", &Points_Create,
              "Create a Points object using PointsKey.\n"
              "\n"
              "Args:\n"
              "\tpointsKey (PointsKey object): The PointsKey to be used to\n"
              "\tcreate points.\n"
              "Returns:\n"
              "\tPoints object created with the given PointsKey.")
         .staticmethod("Create")
  
         .def("Initialise", &Points<double>::Initialize,
              "Initialise Points object by calculating points, weights\n"
              "and differentiation matrix.\n"
              "\n"
              "Args:\n"
              "\tNone\n"
              "Returns:\n"
              "\tNone")
         .def("GetPointsDim", &Points<double>::GetPointsDim,
              "Get the dimension of the Points object.\n"
              "\n"
              "Args:\n"
              "\tNone\n"
              "Returns:\n"
              "\tInteger characterising the dimension of the Points object\n"
              "\t(e.g. 2 for 2D Points object).")
         .def("GetPointsType", &Points<double>::GetPointsType,
              "Get the type of points in Points object.\n"
              "\n"
              "Args:\n"
              "\tNone\n"
              "Returns:\n"
              "\tPointsType object specifying the type of points in Points\n"
              "\tobject.")
         .def("GetNumPoints", &Points<double>::GetNumPoints,
              "Get the number of quadrature points in Points object.\n"
              "\n"
              "Args:\n"
              "\tNone\n"
              "Returns:\n"
              "\tInteger defining the number of quadrature points in Points\n"
              "\tobject.")
         .def("GetTotNumPoints", &Points<double>::GetTotNumPoints,
              "Get the total number of points in Points object.\n"
              "\n"
              "Args:\n"
              "\tNone\n"
              "Returns:\n"
              "\tInteger defining the total number of points in Points\n"
              "\tobject.")
  
         .def("GetZ", &Points<double>::GetZ,
              py::return_value_policy<py::copy_const_reference>(),
              "Get quadrature zeros.\n"
              "\n"
              "Args:\n"
              "\tNone\n"
              "Returns:\n"
              "\tNumPy ndarray of length equal to the number of quadrature\n"
              "\tpoints, containing quadrature zeros.")
         .def("GetW", &Points<double>::GetW,
              py::return_value_policy<py::copy_const_reference>(),
              "Get quadrature weights.\n"
              "\n"
              "Args:\n"
              "\tNone\n"
              "Returns:\n"
              "\tNumPy ndarray of length equal to the number of quadrature\n"
              "\tpoints, containing quadrature weights.")
         .def("GetZW", &Points_GetZW,
              "Get quadrature zeros and weights.\n"
              "\n"
              "Args:\n"
              "\tNone\n"
              "Returns:\n"
              "\tTuple containing the quadrature zeros and quadrature weights,\n"
              "\ti.e. (Points.GetZ(), Points.GetW()).")
         .def("GetD", &Points_GetD,
              "Get the differentiation matrix.\n"
              "\n"
              "Args:\n"
              "\tNone\n"
              "Returns:\n"
              "\tNumPy ndarray of n x n dimensions, where n is equal to\n"
              "\tthe number of quadrature points, containing the\n"
              "\tdifferentiation matrix.")
         .def("GetD", &Points_GetD2,
              "Get the differentiation matrix.\n"
              "\n"
              "Args:\n"
              "\tdir (Direction object): The direction of the desired\n"
              "\tdifferentiation matrix.\n"
              "Returns:\n"
              "\tNumPy ndarray of n x n dimensions, where n is equal to\n"
              "\tthe number of quadrature points containing the\n"
              "\tdifferentiation matrix.");
 }

References Nektar::LibUtilities::PointsKey::GetNumPoints(), Nektar::LibUtilities::PointsKey::GetPointsDim(), Nektar::LibUtilities::PointsKey::GetPointsType(), Nektar::LibUtilities::PointsKey::GetTotNumPoints(), Nektar::LibUtilities::kPointsTypeStr, NEKPY_WRAP_ENUM_STRING_DOCS, Points_Create(), Points_GetD(), Points_GetD2(), and Points_GetZW().

Referenced by BOOST_PYTHON_MODULE().

◆ export_SessionReader()

void export_SessionReader ( )

SessionReader exports.

Currently wrapped functions:

SessionReader::CreateInstance for creating objects
SessionReader::GetSessionName to return the session name
SessionReader::Finalise to deal with finalising things

Definition at line 136 of file Python/BasicUtils/SessionReader.cpp.

 {
     py::class_<SessionReader, std::shared_ptr<SessionReader>,
                boost::noncopyable>("SessionReader", py::no_init)
  
         .def("CreateInstance", SessionReader_CreateInstance)
         .staticmethod("CreateInstance")
  
         .def("GetSessionName", &SessionReader::GetSessionName,
              py::return_value_policy<py::copy_const_reference>())
  
         .def("Finalise", &SessionReader::Finalise)
  
         .def("DefinesParameter", &SessionReader::DefinesParameter)
         .def("GetParameter", &SessionReader::GetParameter,
              py::return_value_policy<py::return_by_value>())
  
         .def("SetParameter", SessionReader_SetParameterInt)
         .def("SetParameter", SessionReader_SetParameterDouble)
  
         .def("GetVariable", &SessionReader::GetVariable,
              py::return_value_policy<py::copy_const_reference>())
  
         .def("GetComm", &SessionReader::GetComm)
  
         .def("GetSharedFilesystem", &SessionReader::GetSharedFilesystem);
 }

References Nektar::LibUtilities::SessionReader::DefinesParameter(), Nektar::LibUtilities::SessionReader::Finalise(), Nektar::LibUtilities::SessionReader::GetComm(), Nektar::LibUtilities::SessionReader::GetParameter(), Nektar::LibUtilities::SessionReader::GetSessionName(), Nektar::LibUtilities::SessionReader::GetSharedFilesystem(), Nektar::LibUtilities::SessionReader::GetVariable(), SessionReader_CreateInstance(), SessionReader_SetParameterDouble(), and SessionReader_SetParameterInt().

Referenced by BOOST_PYTHON_MODULE().

◆ export_ShapeType()

void export_ShapeType ( )

Export for ShapeType enumeration.

Definition at line 44 of file ShapeType.cpp.

 {
     NEKPY_WRAP_ENUM(ShapeType, ShapeTypeMap)
 }

References NEKPY_WRAP_ENUM, and Nektar::LibUtilities::ShapeTypeMap.

Referenced by BOOST_PYTHON_MODULE().

◆ export_SharedArray()

template<typename T >

void export_SharedArray ( )

Definition at line 201 of file SharedArray.cpp.

 {
     py::to_python_converter<Array<OneD, const T>, OneDArrayToPython<const T>>();
     py::to_python_converter<Array<OneD, T>, OneDArrayToPython<T>>();
  
     PythonToOneDArray<const T>();
     PythonToOneDArray<T>();
 }

◆ TranslateNekError()

void TranslateNekError ( NekError const & e )

Definition at line 74 of file LibUtilities.cpp.

 {
     PyErr_SetString(NekErrorType, e.what());
 }

References NekErrorType.

Referenced by BOOST_PYTHON_MODULE().

Variable Documentation

◆ errorStream

std::stringstream errorStream

Definition at line 53 of file LibUtilities.cpp.

Referenced by BOOST_PYTHON_MODULE().

◆ NekErrorType

PyObject* NekErrorType = nullptr

Definition at line 52 of file LibUtilities.cpp.

Referenced by BOOST_PYTHON_MODULE(), and TranslateNekError().

Typedefs

Functions

Variables

Typedef Documentation

◆ NekError

Function Documentation

◆ BOOST_PYTHON_MODULE()

◆ CreateExceptionClass()

◆ export_Basis()

◆ export_Comm()

◆ export_Equation()

◆ export_Interpreter()

◆ export_NekMatrix()

◆ export_Points()

◆ export_SessionReader()

◆ export_ShapeType()

◆ export_SharedArray()

◆ TranslateNekError()

Variable Documentation

◆ errorStream

◆ NekErrorType