LibUtilities.cpp File Reference

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

Go to the source code of this file.

Typedefs
using	NekError = Nektar::ErrorUtil::NekError

Functions
void	export_Basis (py::module &)
	Basis exports. More...
void	export_Comm (py::module &)
	Export for Comm communicator. More...
void	export_Interpreter (py::module &)
void	export_Equation (py::module &)
void	export_Points (py::module &)
	Points exports. More...
void	export_SessionReader (py::module &)
	SessionReader exports. More...
void	export_ShapeType (py::module &)
	Export for ShapeType enumeration. More...
void	export_TimeIntegrationScheme (py::module &)
void	export_TimeIntegrationSchemeOperators (py::module &)
	PYBIND11_MODULE (_LibUtilities, m)

Variables
std::stringstream	errorStream

Typedef Documentation

NekError

using NekError = Nektar::ErrorUtil::NekError

Definition at line 54 of file LibUtilities.cpp.

Function Documentation

export_Basis()

void export_Basis

(

py::module &

m

)

Basis exports.

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

{
    // Enumerator for basis type
    NEKPY_WRAP_ENUM(m, BasisType, BasisTypeMap);
 
    py::class_<BasisKey>(m, "BasisKey")
 
        .def(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>>(m, "Basis")
 
        .def_static("Create", &Basis_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)
        .def("GetW", &Basis::GetW)
        .def("GetZW", &Basis_GetZW)
 
        .def("GetBdata", &Basis::GetBdata)
        .def("GetDbdata", &Basis::GetDbdata);
}

References Basis_Create(), Basis_GetZW(), Nektar::LibUtilities::BasisTypeMap, and NEKPY_WRAP_ENUM.

Referenced by PYBIND11_MODULE().

export_Comm()

void export_Comm

(

py::module &

m

)

Export for Comm communicator.

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

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

References AllReduce(), NEKPY_WRAP_ENUM, and Nektar::LibUtilities::ReduceOperatorMap.

Referenced by PYBIND11_MODULE().

export_Equation()

void export_Equation

(

py::module &

m

)

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

{
    py::class_<Equation, std::shared_ptr<Equation>>(m, "Equation")
 
        .def(py::init(&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", &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(), and Equation_SetConstants().

Referenced by PYBIND11_MODULE().

export_Interpreter()

void export_Interpreter

(

py::module &

m

)

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

{
    py::class_<Interpreter, std::shared_ptr<Interpreter>>(m, "Interpreter")
 
        .def(py::init<>())
 
        .def("SetRandomSeed", &Interpreter::SetRandomSeed)
 
        .def("AddConstants", &Interpreter_AddConstants)
        .def("AddConstant", &Interpreter::AddConstant)
        .def("GetConstant", Interpreter_GetConstant)
 
        .def("SetParameters", &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 Interpreter_AddConstants(), Interpreter_Evaluate(), Interpreter_Evaluate2(), Interpreter_Evaluate3(), Interpreter_Evaluate4(), Interpreter_GetConstant(), Interpreter_GetParameter(), and Interpreter_SetParameters().

Referenced by PYBIND11_MODULE().

export_Points()

void export_Points

(

py::module &

m

)

Points exports.

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

{
    NEKPY_WRAP_ENUM_STRING_DOCS(
        m, 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>(
        m, "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.")
 
        .def(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>>>(
        m, "Points",
        "Create a set of points which can be used to calculate\n"
        "quadrature zeros, weights etc."
        "\n"
        "Args:\n"
        "\tNone")
        .def_static(
            "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.")
 
        .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,
             "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,
             "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, py::return_value_policy::reference,
             "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, py::return_value_policy::reference,
             "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::kPointsTypeStr, NEKPY_WRAP_ENUM_STRING_DOCS, Points_Create(), Points_GetD(), Points_GetD2(), and Points_GetZW().

Referenced by PYBIND11_MODULE().

export_SessionReader()

void export_SessionReader

(

py::module &

m

)

SessionReader exports.

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

{
    py::class_<SessionReader, std::shared_ptr<SessionReader>>(m,
                                                              "SessionReader")
 
        .def_static("CreateInstance", SessionReader_CreateInstance)
 
        .def("GetSessionName", &SessionReader::GetSessionName,
             py::return_value_policy::copy)
 
        .def("InitSession", &SessionReader::InitSession,
             py::arg("filenames") = py::list())
 
        .def("Finalise", &SessionReader::Finalise)
 
        .def("DefinesParameter", &SessionReader::DefinesParameter)
        .def("GetParameter", &SessionReader::GetParameter,
             py::return_value_policy::copy)
        .def("GetParameters", &SessionReader::GetParameters)
 
        .def("SetParameter", py::overload_cast<const std::string &, int &>(
                                 &SessionReader::SetParameter))
        .def("SetParameter", py::overload_cast<const std::string &, double &>(
                                 &SessionReader::SetParameter))
        .def("SetParameter", py::overload_cast<const std::string &, size_t &>(
                                 &SessionReader::SetParameter))
 
        .def("DefinesSolverInfo", &SessionReader::DefinesSolverInfo)
        .def("GetSolverInfo", &SessionReader::GetSolverInfo,
             py::return_value_policy::copy)
        .def("SetSolverInfo", &SessionReader::SetSolverInfo)
 
        .def("GetVariable", &SessionReader::GetVariable,
             py::return_value_policy::copy)
        .def("GetVariables", &SessionReader::GetVariables)
 
        .def("GetFunction",
             py::overload_cast<const std::string &, const std::string &,
                               const int>(&SessionReader::GetFunction,
                                          py::const_),
             py::arg("name"), py::arg("var"), py::arg("domain") = 0)
        .def("GetFunction",
             py::overload_cast<const std::string &, const unsigned int &,
                               const int>(&SessionReader::GetFunction,
                                          py::const_),
             py::arg("name"), py::arg("var"), py::arg("domain") = 0)
 
        .def("GetComm", &SessionReader::GetComm)
 
        .def("GetSharedFilesystem", &SessionReader::GetSharedFilesystem);
}

References CellMLToNektar.pycml::copy(), Gs::Finalise(), and SessionReader_CreateInstance().

Referenced by PYBIND11_MODULE().

export_ShapeType()

void export_ShapeType

(

py::module &

m

)

Export for ShapeType enumeration.

Definition at line 44 of file ShapeType.cpp.

{
    NEKPY_WRAP_ENUM(m, ShapeType, ShapeTypeMap)
}

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

Referenced by PYBIND11_MODULE().

export_TimeIntegrationScheme()

void export_TimeIntegrationScheme

(

py::module &

m

)

Definition at line 50 of file Python/TimeIntegration/TimeIntegrationScheme.cpp.

{
    // Very lightweight class around the time-integration scheme. Mostly this is
    // here for debugging purposes rather than to provide a full wrapper around
    // this class.
    py::class_<TIS_Deletable, std::shared_ptr<TIS_Deletable>>(
        m, "TimeIntegrationScheme")
        .def("GetFullName", &TimeIntegrationScheme::GetFullName)
        .def("GetName", &TimeIntegrationScheme::GetName)
        .def("GetVariant", &TimeIntegrationScheme::GetVariant)
        .def("GetOrder", &TimeIntegrationScheme::GetOrder)
 
        .def("GetTimeStability", &TimeIntegrationScheme::GetTimeStability)
        .def("GetNumIntegrationPhases",
             &TimeIntegrationScheme::GetNumIntegrationPhases);
}

Referenced by PYBIND11_MODULE().

export_TimeIntegrationSchemeOperators()

void export_TimeIntegrationSchemeOperators

(

py::module &

m

)

Definition at line 141 of file TimeIntegrationSchemeOperators.cpp.

{
    py::class_<TimeIntegrationSchemeOperators,
               std::shared_ptr<TimeIntegrationSchemeOperators>>(
        m, "TimeIntegrationSchemeOperators")
        .def("DefineOdeRhs", &TimeIntegrationSchemeOperators_DefineOdeRhs)
        .def("DefineProjection",
             &TimeIntegrationSchemeOperators_DefineProjection)
        .def("DefineImplicitSolve",
             &TimeIntegrationSchemeOperators_DefineImplicitSolve);
}

References TimeIntegrationSchemeOperators_DefineImplicitSolve(), TimeIntegrationSchemeOperators_DefineOdeRhs(), and TimeIntegrationSchemeOperators_DefineProjection().

Referenced by PYBIND11_MODULE().

PYBIND11_MODULE()

PYBIND11_MODULE	(	_LibUtilities	,
		m
	)

Definition at line 56 of file LibUtilities.cpp.

{
    // Register the NekError exception.
    py::register_exception<NekError>(m, "NekError");
 
    // Set a stringstream as an error sink to avoid duplicate output.
    Nektar::ErrorUtil::SetErrorStream(errorStream);
 
    export_Basis(m);
    export_Comm(m);
    export_Equation(m);
    export_Interpreter(m);
    export_Points(m);
    export_SessionReader(m);
    export_ShapeType(m);
    export_TimeIntegrationScheme(m);
    export_TimeIntegrationSchemeOperators(m);
}

References errorStream, export_Basis(), export_Comm(), export_Equation(), export_Interpreter(), export_Points(), export_SessionReader(), export_ShapeType(), export_TimeIntegrationScheme(), export_TimeIntegrationSchemeOperators(), and Nektar::ErrorUtil::SetErrorStream().

Variable Documentation

errorStream

std::stringstream errorStream

Definition at line 52 of file LibUtilities.cpp.

Referenced by PYBIND11_MODULE().