Nektar++
Typedefs | Functions | Variables
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

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.

57{
58 // Enumerator for basis type
60
61 py::class_<BasisKey>(m, "BasisKey")
62
63 .def(py::init<const BasisType &, const int, const PointsKey &>())
64
65 .def("GetNumModes", &BasisKey::GetNumModes)
66 .def("GetTotNumModes", &BasisKey::GetTotNumModes)
67 .def("GetNumPoints", &BasisKey::GetNumPoints)
68 .def("GetTotNumPoints", &BasisKey::GetTotNumPoints)
69 .def("GetBasisType", &BasisKey::GetBasisType)
70 .def("GetPointsKey", &BasisKey::GetPointsKey)
71 .def("GetPointsType", &BasisKey::GetPointsType)
72 .def("Collocation", &BasisKey::Collocation);
73
74 py::class_<Basis, std::shared_ptr<Basis>>(m, "Basis")
75
76 .def_static("Create", &Basis_Create)
77
78 .def("GetNumModes", &Basis::GetNumModes)
79 .def("GetTotNumModes", &Basis::GetTotNumModes)
80 .def("GetNumPoints", &Basis::GetNumPoints)
81 .def("GetTotNumPoints", &Basis::GetTotNumPoints)
82 .def("GetBasisType", &Basis::GetBasisType)
83 .def("GetPointsKey", &Basis::GetPointsKey)
84 .def("GetBasisKey", &Basis::GetBasisKey)
85 .def("GetPointsType", &Basis::GetBasisType)
86 .def("Initialize", &Basis::Initialize)
87
88 .def("GetZ", &Basis::GetZ)
89 .def("GetW", &Basis::GetW)
90 .def("GetZW", &Basis_GetZW)
91
92 .def("GetBdata", &Basis::GetBdata)
93 .def("GetDbdata", &Basis::GetDbdata);
94}
#define NEKPY_WRAP_ENUM(MOD, ENUMNAME, MAPNAME)
Definition: NekPyConfig.hpp:53
BasisSharedPtr Basis_Create(const BasisKey &pts)
py::tuple Basis_GetZW(BasisSharedPtr pts)
const char *const BasisTypeMap[]
Definition: Foundations.hpp:44

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.

57{
58 // Export ReduceOperator enum
60
61 py::class_<Comm, std::shared_ptr<Comm>>(m, "Comm")
62 .def("GetSize", &Comm::GetSize)
63 .def("GetRank", &Comm::GetRank)
64 .def("GetType", &Comm::GetType, py::return_value_policy::reference)
65 .def("AllReduce", &AllReduce<double>)
66 .def("AllReduce", &AllReduce<int>)
67 .def("AllReduce", &AllReduce<long>)
68 .def("AllReduce", &AllReduce<Array<OneD, NekDouble>>);
69}
T AllReduce(CommSharedPtr &comm, T toReduce, ReduceOperator oper)
const char *const ReduceOperatorMap[]
Definition: Comm.h:72
ReduceOperator
Type of operation to perform in AllReduce.
Definition: Comm.h:65

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.

187{
188 py::class_<Equation, std::shared_ptr<Equation>>(m, "Equation")
189
190 .def(py::init(&ConstructEquation))
191
192 .def("Evaluate", Equation_Evaluate1)
193 .def("Evaluate", Equation_Evaluate2)
194 .def("Evaluate", Equation_Evaluate3)
195 .def("Evaluate", Equation_Evaluate4)
196 .def("Evaluate", Equation_Evaluate5)
197
198 .def("SetParameter", &Equation::SetParameter)
199 .def("SetConstants", &Equation_SetConstants)
200 .def("GetExpression", &Equation::GetExpression)
201 .def("GetVlist", &Equation::GetVlist)
202
203 .def("GetTime", &Equation::GetTime);
204}
void Equation_SetConstants(std::shared_ptr< Equation > equation, py::args args, const py::kwargs &kwargs)
Wrapper for Equation::SetConstants.
Array< OneD, NekDouble > Equation_Evaluate5(std::shared_ptr< Equation > equation, const Array< OneD, const NekDouble > &x, const Array< OneD, const NekDouble > &y, const Array< OneD, const NekDouble > &z, const Array< OneD, const NekDouble > &t)
Wrapper for Equation::Evaluate (overloaded for Array parameters + Array time).
NekDouble Equation_Evaluate2(std::shared_ptr< Equation > equation, const NekDouble x, const NekDouble y=0, const NekDouble z=0, const NekDouble t=0)
Wrapper for Equation::Evaluate (overloaded for constant parameters).
NekDouble Equation_Evaluate1(std::shared_ptr< Equation > equation)
Wrapper for Equation::Evaluate (overloaded for no parameters).
std::shared_ptr< Equation > ConstructEquation(std::shared_ptr< Interpreter > interp, std::string expr, std::string vlist)
Construct an equation object from an expression string expr and a list of variables vlist.
Array< OneD, NekDouble > Equation_Evaluate4(std::shared_ptr< Equation > equation, const Array< OneD, const NekDouble > &x, const Array< OneD, const NekDouble > &y, const Array< OneD, const NekDouble > &z, const NekDouble t)
Wrapper for Equation::Evaluate (overloaded for Array parameters + constant time).
Array< OneD, NekDouble > Equation_Evaluate3(std::shared_ptr< Equation > equation, const Array< OneD, const NekDouble > &x, const Array< OneD, const NekDouble > &y, const Array< OneD, const NekDouble > &z)
Wrapper for Equation::Evaluate (overloaded for Array parameters).

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.

213{
214 py::class_<Interpreter, std::shared_ptr<Interpreter>>(m, "Interpreter")
215
216 .def(py::init<>())
217
218 .def("SetRandomSeed", &Interpreter::SetRandomSeed)
219
220 .def("AddConstants", &Interpreter_AddConstants)
221 .def("AddConstant", &Interpreter::AddConstant)
222 .def("GetConstant", Interpreter_GetConstant)
223
224 .def("SetParameters", &Interpreter_SetParameters)
225 .def("SetParameter", &Interpreter::SetParameter)
226 .def("GetParameter", Interpreter_GetParameter)
227
228 .def("GetTime", &Interpreter::GetTime)
229 .def("DefineFunction", &Interpreter::DefineFunction)
230
231 .def("Evaluate", Interpreter_Evaluate)
232 .def("Evaluate", Interpreter_Evaluate2)
233 .def("Evaluate", Interpreter_Evaluate3)
234 .def("Evaluate", Interpreter_Evaluate4)
235
236 ;
237}
NekDouble Interpreter_Evaluate2(std::shared_ptr< Interpreter > interpreter, const int id, const NekDouble x, const NekDouble y, const NekDouble z, const NekDouble t)
Wrapper for Interpreter::Evaluate (only constant parameters).
Array< OneD, NekDouble > Interpreter_Evaluate4(std::shared_ptr< Interpreter > interpreter, const int expression_id, const std::vector< Array< OneD, const NekDouble > > &points)
Wrapper for Interpreter::Evaluate (zero or more arrays).
NekDouble Interpreter_Evaluate(std::shared_ptr< Interpreter > interpreter, const int id)
Wrapper for Interpreter::Evaluate (only constant or parameter).
NekDouble Interpreter_GetParameter(std::shared_ptr< Interpreter > interpreter, std::string paramName)
Wrapper for Interpreter::GetParameter.
Array< OneD, NekDouble > Interpreter_Evaluate3(std::shared_ptr< Interpreter > interpreter, const int id, const Array< OneD, const NekDouble > &x, const Array< OneD, const NekDouble > &y, const Array< OneD, const NekDouble > &z, const Array< OneD, const NekDouble > &t)
Wrapper for Interpreter::Evaluate (vectorised version of the evaluation method that will allow the sa...
NekDouble Interpreter_GetConstant(std::shared_ptr< Interpreter > interpreter, std::string constantName)
Wrapper for Interpreter::GetConstant.
void Interpreter_SetParameters(std::shared_ptr< Interpreter > interpreter, py::args args, const py::kwargs &kwargs)
Wrapper for Interpreter::SetParameters.
void Interpreter_AddConstants(std::shared_ptr< Interpreter > interpreter, py::args args, const py::kwargs &kwargs)
Wrapper for Interpreter::AddConstants.

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.

73{
76 "Characterise the type of points.\n"
77 "\n"
78 "Sample usage: PointsType.GaussLobattoLegendre\n"
79 "\n"
80 "Available point types:\n"
81 "\tNoPointsType: No points type.\n"
82 "\tGaussGaussLegendre: 1D Gauss-Gauss-Legendre quadrature points.\n"
83 "\tGaussRadauMLegendre: 1D Gauss-Radau-Legendre quadrature points,\n"
84 "\t\tpinned at x=-1.\n"
85 "\tGaussRadauPLegendre: 1D Gauss-Radau-Legendre quadrature points,\n"
86 "\t\tpinned at x=1.\n"
87 "\tGaussLobattoLegendre: 1D Gauss-Lobatto-Legendre quadrature points.\n"
88 "\tGaussGaussChebyshev: 1D Gauss-Gauss-Chebyshev quadrature points.\n"
89 "\tGaussRadauMChebyshev: 1D Gauss-Radau-Chebyshev quadrature points,\n"
90 "\t\tpinned at x=-1.\n"
91 "\tGaussRadauPChebyshev: 1D Gauss-Radau-Chebyshev quadrature points,\n"
92 "\t\tpinned at x=1.\n"
93 "\tGaussLobattoChebyshev: 1D Gauss-Lobatto-Legendre quadrature points\n"
94 "\tGaussRadauMAlpha0Beta1: Gauss Radau pinned at x=-1,\n"
95 "\t\talpha = 0, beta = 1\n"
96 "\tGaussRadauMAlpha0Beta2: Gauss Radau pinned at x=-1,\n"
97 "\t\talpha = 0, beta = 2\n"
98 "\tGaussRadauMAlpha1Beta0: Gauss Radau pinned at x=-1,\n"
99 "\t\talpha = 1, beta = 0\n"
100 "\tGaussRadauMAlpha2Beta0: Gauss Radau pinned at x=-1,\n"
101 "\t\talpha = 2, beta = 0\n"
102 "\tGaussKronrodLegendre: 1D Gauss-Kronrod-Legendre quadrature points.\n"
103 "\tGaussRadauKronrodMLegendre: 1D Gauss-Radau-Kronrod-Legendre "
104 "quadrature\n"
105 "\t\tpoints, pinned at x=-1.\n"
106 "\tGaussRadauKronrodMAlpha1Beta0: 1D Gauss-Radau-Kronrod-Legendre\n"
107 "\t\tpinned at x=-1, alpha = 1, beta = 0\n"
108 "\tGaussLobattoKronrodLegendre: 1D Lobatto Kronrod quadrature points.\n"
109 "\tPolyEvenlySpaced: 1D Evenly-spaced points using Lagrange "
110 "polynomial.\n"
111 "\tFourierEvenlySpaced: 1D Evenly-spaced points using Fourier Fit.\n"
112 "\tFourierSingleModeSpaced: 1D Non Evenly-spaced points for Single "
113 "Mode\n"
114 "\t\tanalysis.\n"
115 "\tBoundaryLayerPoints: 1D power law distribution for boundary layer "
116 "points.\n"
117 "\tBoundaryLayerPointsRev: 1D power law distribution for boundary "
118 "layer\n"
119 "\t\tpoints.\n"
120 "\tNodalTriElec: 2D Nodal Electrostatic Points on a Triangle.\n"
121 "\tNodalTriFekete: 2D Nodal Fekete Points on a Triangle.\n"
122 "\tNodalTriEvenlySpaced: 2D Evenly-spaced points on a Triangle.\n"
123 "\tNodalTetEvenlySpaced: 3D Evenly-spaced points on a Tetrahedron.\n"
124 "\tNodalTetElec: 3D Nodal Electrostatic Points on a Tetrahedron.\n"
125 "\tNodalPrismEvenlySpaced: 3D Evenly-spaced points on a Prism.\n"
126 "\tNodalPrismElec: 3D electrostatically spaced points on a Prism.\n"
127 "\tNodalTriSPI: 2D Nodal Symmetric positive internal triangle\n"
128 "\t\t(Whitherden, Vincent).\n"
129 "\tNodalTetSPI: 3D Nodal Symmetric positive internal tet\n"
130 "\t\t(Whitherden, Vincent).\n"
131 "\tNodalPrismSPI: 3D prism SPI.\n"
132 "\tNodalQuadElec: 2D GLL for quad.\n"
133 "\tNodalHexElec: 3D GLL for hex");
134
135 py::class_<PointsKey>(
136 m, "PointsKey",
137 "Create a PointsKey which uniquely defines quadrature points.\n"
138 "\n"
139 "Args:\n"
140 "\tnQuadPoints (integer): The number of quadrature points.\n"
141 "\tpointsType (PointsType object): The type of quadrature points.")
142
143 .def(py::init<const int, const PointsType &>())
144
145 .def("GetNumPoints", &PointsKey::GetNumPoints,
146 "Get the number of quadrature points in PointsKey.\n"
147 "\n"
148 "Args:\n"
149 "\tNone\n"
150 "Returns:\n"
151 "\tInteger defining the number of quadrature points in PointsKey.")
152 .def("GetPointsType", &PointsKey::GetPointsType,
153 "Get the type of points in PointsKey.\n"
154 "\n"
155 "Args:\n"
156 "\tNone\n"
157 "Returns:\n"
158 "\tPointsType object specifying the type of points in PointsKey.")
159 .def("GetPointsDim", &PointsKey::GetPointsDim,
160 "Get the dimension of the PointsKey.\n"
161 "\n"
162 "Args:\n"
163 "\tNone\n"
164 "Returns:\n"
165 "\tInteger characterising the dimension of the PointsKey (e.g. 2\n"
166 "\tfor 2D PointsKey).")
167 .def("GetTotNumPoints", &PointsKey::GetTotNumPoints,
168 "Get the total number of points in PointsKey.\n"
169 "\n"
170 "Args:\n"
171 "\tNone\n"
172 "Returns:\n"
173 "\tInteger defining the total number of points in PointsKey.");
174
175 py::class_<Points<double>, std::shared_ptr<Points<double>>>(
176 m, "Points",
177 "Create a set of points which can be used to calculate\n"
178 "quadrature zeros, weights etc."
179 "\n"
180 "Args:\n"
181 "\tNone")
182 .def_static(
183 "Create", &Points_Create,
184 "Create a Points object using PointsKey.\n"
185 "\n"
186 "Args:\n"
187 "\tpointsKey (PointsKey object): The PointsKey to be used to\n"
188 "\tcreate points.\n"
189 "Returns:\n"
190 "\tPoints object created with the given PointsKey.")
191
192 .def("Initialise", &Points<double>::Initialize,
193 "Initialise Points object by calculating points, weights\n"
194 "and differentiation matrix.\n"
195 "\n"
196 "Args:\n"
197 "\tNone\n"
198 "Returns:\n"
199 "\tNone")
200 .def("GetPointsDim", &Points<double>::GetPointsDim,
201 "Get the dimension of the Points object.\n"
202 "\n"
203 "Args:\n"
204 "\tNone\n"
205 "Returns:\n"
206 "\tInteger characterising the dimension of the Points object\n"
207 "\t(e.g. 2 for 2D Points object).")
208 .def("GetPointsType", &Points<double>::GetPointsType,
209 "Get the type of points in Points object.\n"
210 "\n"
211 "Args:\n"
212 "\tNone\n"
213 "Returns:\n"
214 "\tPointsType object specifying the type of points in Points\n"
215 "\tobject.")
216 .def("GetNumPoints", &Points<double>::GetNumPoints,
217 "Get the number of quadrature points in Points object.\n"
218 "\n"
219 "Args:\n"
220 "\tNone\n"
221 "Returns:\n"
222 "\tInteger defining the number of quadrature points in Points\n"
223 "\tobject.")
224 .def("GetTotNumPoints", &Points<double>::GetTotNumPoints,
225 "Get the total number of points in Points object.\n"
226 "\n"
227 "Args:\n"
228 "\tNone\n"
229 "Returns:\n"
230 "\tInteger defining the total number of points in Points\n"
231 "\tobject.")
232
233 .def("GetZ", &Points<double>::GetZ,
234 "Get quadrature zeros.\n"
235 "\n"
236 "Args:\n"
237 "\tNone\n"
238 "Returns:\n"
239 "\tNumPy ndarray of length equal to the number of quadrature\n"
240 "\tpoints, containing quadrature zeros.")
241 .def("GetW", &Points<double>::GetW,
242 "Get quadrature weights.\n"
243 "\n"
244 "Args:\n"
245 "\tNone\n"
246 "Returns:\n"
247 "\tNumPy ndarray of length equal to the number of quadrature\n"
248 "\tpoints, containing quadrature weights.")
249 .def("GetZW", &Points_GetZW,
250 "Get quadrature zeros and weights.\n"
251 "\n"
252 "Args:\n"
253 "\tNone\n"
254 "Returns:\n"
255 "\tTuple containing the quadrature zeros and quadrature weights,\n"
256 "\ti.e. (Points.GetZ(), Points.GetW()).")
257 .def("GetD", &Points_GetD, py::return_value_policy::reference,
258 "Get the differentiation matrix.\n"
259 "\n"
260 "Args:\n"
261 "\tNone\n"
262 "Returns:\n"
263 "\tNumPy ndarray of n x n dimensions, where n is equal to\n"
264 "\tthe number of quadrature points, containing the\n"
265 "\tdifferentiation matrix.")
266 .def("GetD", &Points_GetD2, py::return_value_policy::reference,
267 "Get the differentiation matrix.\n"
268 "\n"
269 "Args:\n"
270 "\tdir (Direction object): The direction of the desired\n"
271 "\tdifferentiation matrix.\n"
272 "Returns:\n"
273 "\tNumPy ndarray of n x n dimensions, where n is equal to\n"
274 "\tthe number of quadrature points containing the\n"
275 "\tdifferentiation matrix.");
276}
#define NEKPY_WRAP_ENUM_STRING_DOCS(MOD, ENUMNAME, MAPNAME, DOCSTRING)
Definition: NekPyConfig.hpp:71
NekMatrix< NekDouble > & Points_GetD(PointsSharedPtr pts)
py::tuple Points_GetZW(PointsSharedPtr pts)
NekMatrix< NekDouble > & Points_GetD2(PointsSharedPtr pts, Direction dir)
PointsSharedPtr Points_Create(const PointsKey &pts)
Stores a set of points of datatype DataT, defined by a PointKey.
Definition: Points.h:235
const std::string kPointsTypeStr[]
Definition: Foundations.hpp:52

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.

97{
98 py::class_<SessionReader, std::shared_ptr<SessionReader>>(m,
99 "SessionReader")
100
101 .def_static("CreateInstance", SessionReader_CreateInstance)
102
103 .def("GetSessionName", &SessionReader::GetSessionName,
105
106 .def("InitSession", &SessionReader::InitSession,
107 py::arg("filenames") = py::list())
108
109 .def("Finalise", &SessionReader::Finalise)
110
111 .def("DefinesParameter", &SessionReader::DefinesParameter)
112 .def("GetParameter", &SessionReader::GetParameter,
114 .def("GetParameters", &SessionReader::GetParameters)
115
116 .def("SetParameter", py::overload_cast<const std::string &, int &>(
117 &SessionReader::SetParameter))
118 .def("SetParameter", py::overload_cast<const std::string &, double &>(
119 &SessionReader::SetParameter))
120 .def("SetParameter", py::overload_cast<const std::string &, size_t &>(
121 &SessionReader::SetParameter))
122
123 .def("DefinesSolverInfo", &SessionReader::DefinesSolverInfo)
124 .def("GetSolverInfo", &SessionReader::GetSolverInfo,
126 .def("SetSolverInfo", &SessionReader::SetSolverInfo)
127
128 .def("GetVariable", &SessionReader::GetVariable,
130 .def("GetVariables", &SessionReader::GetVariables)
131
132 .def("GetFunction",
133 py::overload_cast<const std::string &, const std::string &,
134 const int>(&SessionReader::GetFunction,
135 py::const_),
136 py::arg("name"), py::arg("var"), py::arg("domain") = 0)
137 .def("GetFunction",
138 py::overload_cast<const std::string &, const unsigned int &,
139 const int>(&SessionReader::GetFunction,
140 py::const_),
141 py::arg("name"), py::arg("var"), py::arg("domain") = 0)
142
143 .def("GetComm", &SessionReader::GetComm)
144
145 .def("GetSharedFilesystem", &SessionReader::GetSharedFilesystem);
146}
SessionReaderSharedPtr SessionReader_CreateInstance(py::list &ns)
def copy(self)
Definition: pycml.py:2663
static void Finalise(gs_data *pGsh)
Deallocates the GSLib mapping data.
Definition: GsLib.hpp:248

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.

45{
47}
const char *const ShapeTypeMap[SIZE_ShapeType]
Definition: ShapeType.hpp:75

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.

51{
52 // Very lightweight class around the time-integration scheme. Mostly this is
53 // here for debugging purposes rather than to provide a full wrapper around
54 // this class.
55 py::class_<TIS_Deletable, std::shared_ptr<TIS_Deletable>>(
56 m, "TimeIntegrationScheme")
57 .def("GetFullName", &TimeIntegrationScheme::GetFullName)
58 .def("GetName", &TimeIntegrationScheme::GetName)
59 .def("GetVariant", &TimeIntegrationScheme::GetVariant)
60 .def("GetOrder", &TimeIntegrationScheme::GetOrder)
61
62 .def("GetTimeStability", &TimeIntegrationScheme::GetTimeStability)
63 .def("GetNumIntegrationPhases",
64 &TimeIntegrationScheme::GetNumIntegrationPhases);
65}

Referenced by PYBIND11_MODULE().

◆ export_TimeIntegrationSchemeOperators()

void export_TimeIntegrationSchemeOperators ( py::module &  m)

Definition at line 141 of file TimeIntegrationSchemeOperators.cpp.

142{
144 std::shared_ptr<TimeIntegrationSchemeOperators>>(
145 m, "TimeIntegrationSchemeOperators")
147 .def("DefineProjection",
149 .def("DefineImplicitSolve",
151}
void TimeIntegrationSchemeOperators_DefineOdeRhs(TimeIntegrationSchemeOperatorsSharedPtr op, py::object callback)
void TimeIntegrationSchemeOperators_DefineImplicitSolve(TimeIntegrationSchemeOperatorsSharedPtr op, py::object callback)
void TimeIntegrationSchemeOperators_DefineProjection(TimeIntegrationSchemeOperatorsSharedPtr op, py::object callback)
Binds a set of functions for use by time integration schemes.

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

Referenced by PYBIND11_MODULE().

◆ PYBIND11_MODULE()

PYBIND11_MODULE ( _LibUtilities  ,
 
)

Definition at line 56 of file LibUtilities.cpp.

57{
58 // Register the NekError exception.
59 py::register_exception<NekError>(m, "NekError");
60
61 // Set a stringstream as an error sink to avoid duplicate output.
63
64 export_Basis(m);
65 export_Comm(m);
73}
void export_ShapeType(py::module &)
Export for ShapeType enumeration.
Definition: ShapeType.cpp:44
void export_Comm(py::module &)
Export for Comm communicator.
void export_Points(py::module &)
Points exports.
void export_Basis(py::module &)
Basis exports.
void export_SessionReader(py::module &)
SessionReader exports.
std::stringstream errorStream
void export_TimeIntegrationScheme(py::module &)
void export_Equation(py::module &)
void export_TimeIntegrationSchemeOperators(py::module &)
void export_Interpreter(py::module &)
static void SetErrorStream(std::ostream &o)
Definition: ErrorUtil.hpp:71

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().