Nektar++
Functions
SpatialDomains.cpp File Reference
#include <LibUtilities/Python/NekPyConfig.hpp>

Go to the source code of this file.

Functions

void export_Geometry ()
 
void export_Curve ()
 
void export_MeshGraph ()
 MeshGraph exports. More...
 
void export_GeomElements ()
 
void export_Zones ()
 
void export_Interfaces ()
 
void export_Movement ()
 
 BOOST_PYTHON_MODULE (_SpatialDomains)
 

Function Documentation

◆ BOOST_PYTHON_MODULE()

BOOST_PYTHON_MODULE ( _SpatialDomains  )

Definition at line 45 of file SpatialDomains.cpp.

46{
47 np::initialize();
48
49 export_Geometry();
50 export_Curve();
51 export_MeshGraph();
52 export_GeomElements();
53 export_Zones();
54 export_Interfaces();
55 export_Movement();
56}
export_Geometry
void export_Geometry()
Definition: Python/Geometry.cpp:61
export_Movement
void export_Movement()
Definition: Python/Movement.cpp:61
export_GeomElements
void export_GeomElements()
Definition: GeomElements.cpp:122
export_Interfaces
void export_Interfaces()
Definition: Interfaces.cpp:54
export_MeshGraph
void export_MeshGraph()
MeshGraph exports.
Definition: Python/MeshGraph.cpp:98
export_Curve
void export_Curve()
Definition: Curve.cpp:61
export_Zones
void export_Zones()
Definition: Python/Zones.cpp:67

References export_Curve(), export_GeomElements(), export_Geometry(), export_Interfaces(), export_MeshGraph(), export_Movement(), and export_Zones().

◆ export_Curve()

void export_Curve ( )

Definition at line 61 of file Curve.cpp.

62{
63 py::class_<Curve, std::shared_ptr<Curve>>(
64 "Curve", py::init<int, LibUtilities::PointsType>())
65
66 .def_readwrite("curveID", &Curve::m_curveID)
67 .def_readwrite("ptype", &Curve::m_ptype)
68 .add_property("points", &Curve_GetPoints, &Curve_SetPoints);
69}
Curve_GetPoints
py::list Curve_GetPoints(CurveSharedPtr curve)
Definition: Curve.cpp:41
Curve_SetPoints
void Curve_SetPoints(CurveSharedPtr curve, py::list &pts)
Definition: Curve.cpp:51

References Curve_GetPoints(), and Curve_SetPoints().

Referenced by BOOST_PYTHON_MODULE().

◆ export_GeomElements()

void export_GeomElements ( )

Definition at line 122 of file GeomElements.cpp.

123{
124 // Geometry dimensioned base classes
125 py::class_<Geometry1D, py::bases<Geometry>, std::shared_ptr<Geometry1D>,
126 boost::noncopyable>("Geometry1D", py::no_init);
127 py::class_<Geometry2D, py::bases<Geometry>, std::shared_ptr<Geometry2D>,
128 boost::noncopyable>("Geometry2D", py::no_init)
129 .def("GetCurve", &Geometry2D::GetCurve);
130 py::class_<Geometry3D, py::bases<Geometry>, std::shared_ptr<Geometry3D>,
131 boost::noncopyable>("Geometry3D", py::no_init);
132
133 // Point geometries
134 py::class_<PointGeom, py::bases<Geometry>, std::shared_ptr<PointGeom>>(
135 "PointGeom", py::init<>())
136 .def(py::init<int, int, NekDouble, NekDouble, NekDouble>())
137 .def("GetCoordinates", &PointGeom_GetCoordinates);
138
139 // Segment geometries
140 py::class_<SegGeom, py::bases<Geometry>, std::shared_ptr<SegGeom>>(
141 "SegGeom", py::init<>())
142 .def("__init__",
143 py::make_constructor(&SegGeom_Init, py::default_call_policies(),
144 (py::arg("id"), py::arg("coordim"),
145 py::arg("points") = py::list(),
146 py::arg("curve") = py::object())))
147 .def("GetCurve", &SegGeom::GetCurve);
148
149 export_Geom_2d<TriGeom, SegGeom>("TriGeom");
150 export_Geom_2d<QuadGeom, SegGeom>("QuadGeom");
151 export_Geom_3d<TetGeom, TriGeom>("TetGeom");
152 export_Geom_3d<PrismGeom, Geometry2D>("PrismGeom");
153 export_Geom_3d<PyrGeom, Geometry2D>("PyrGeom");
154 export_Geom_3d<HexGeom, QuadGeom>("HexGeom");
155}
PointGeom_GetCoordinates
py::tuple PointGeom_GetCoordinates(const PointGeom &self)
Definition: GeomElements.cpp:117
SegGeom_Init
SegGeomSharedPtr SegGeom_Init(int id, int coordim, py::list &points, py::object &curve)
Definition: GeomElements.cpp:96

References PointGeom_GetCoordinates(), and SegGeom_Init().

Referenced by BOOST_PYTHON_MODULE().

◆ export_Geometry()

void export_Geometry ( )

Definition at line 61 of file Python/Geometry.cpp.

62{
63 py::class_<Geometry, std::shared_ptr<Geometry>, boost::noncopyable>(
64 "Geometry", py::no_init)
65
66 .def("GetCoordim", &Geometry::GetCoordim)
67 .def("GetGlobalID", &Geometry::GetGlobalID)
68 .def("SetGlobalID", &Geometry::SetGlobalID)
69
70 .def("Setup", &Geometry::Setup)
71 .def("FillGeom", &Geometry::FillGeom)
72 .def("GenGeomFactors", &Geometry_GenGeomFactors)
73 .def("IsValid", &Geometry_IsValid)
74
75 .def("ContainsPoint", &Geometry_ContainsPoint)
76
77 .def("GetVertex", &Geometry::GetVertex)
78 .def("GetEdge", &Geometry::GetEdge)
79 .def("GetFace", &Geometry::GetFace)
80 .def("GetVid", &Geometry::GetVid)
81 .def("GetEid", &Geometry::GetEid)
82 .def("GetFid", &Geometry::GetFid)
83 .def("GetTid", &Geometry::GetTid)
84
85 .def("GetNumVerts", &Geometry::GetNumVerts)
86 .def("GetNumEdges", &Geometry::GetNumEdges)
87 .def("GetNumFaces", &Geometry::GetNumFaces)
88 .def("GetShapeDim", &Geometry::GetShapeDim)
89 .def("GetShapeType", &Geometry::GetShapeType)
90 .def("GetEorient", &Geometry::GetEorient)
91 .def("GetForient", &Geometry::GetForient)
92
93 .def("GetXmap", &Geometry::GetXmap)
94 .def("GetCoeffs", &Geometry::GetCoeffs,
95 py::return_value_policy<py::copy_const_reference>());
96}
Geometry_IsValid
bool Geometry_IsValid(GeometrySharedPtr geom)
Definition: Python/Geometry.cpp:55
Geometry_GenGeomFactors
void Geometry_GenGeomFactors(GeometrySharedPtr geom)
Definition: Python/Geometry.cpp:50
Geometry_ContainsPoint
bool Geometry_ContainsPoint(GeometrySharedPtr geom, const Array< OneD, const NekDouble > &gloCoord)
Definition: Python/Geometry.cpp:44

References Geometry_ContainsPoint(), Geometry_GenGeomFactors(), and Geometry_IsValid().

Referenced by BOOST_PYTHON_MODULE().

◆ export_Interfaces()

void export_Interfaces ( )

Definition at line 54 of file Interfaces.cpp.

55{
56 py::class_<std::vector<unsigned int>>("UIntList")
57 .def(py::vector_indexing_suite<std::vector<unsigned int>, true>());
58
59 py::class_<Interface, std::shared_ptr<Interface>>("Interface", py::no_init)
60 .def("__init__", py::make_constructor(&Interface_Init))
61 .def<const std::map<int, GeometrySharedPtr> &(Interface::*)() const>(
62 "GetEdge", &Interface::GetEdge, py::return_internal_reference<>())
63 .def("IsEmpty", &Interface::IsEmpty)
64 .def("GetId", &Interface::GetId,
65 py::return_value_policy<py::copy_non_const_reference>())
66 .def("GetOppInterace", &Interface::GetOppInterface,
67 py::return_internal_reference<>())
68 .def("GetCompositeIDs", &Interface::GetCompositeIDs,
69 py::return_value_policy<py::copy_const_reference>());
70
71 py::class_<InterfacePair, std::shared_ptr<InterfacePair>>("InterfacePair",
72 py::no_init)
73 .def("__init__", py::make_constructor(&InterfacePair_Init))
74 .def("GetLeftInterface", &InterfacePair::GetLeftInterface,
75 py::return_value_policy<py::copy_const_reference>())
76 .def("GetRightInterface", &InterfacePair::GetRightInterface,
77 py::return_value_policy<py::copy_const_reference>());
78}
InterfacePair_Init
std::shared_ptr< InterfacePair > InterfacePair_Init(const InterfaceShPtr &leftInterface, const InterfaceShPtr &rightInterface)
Definition: Interfaces.cpp:48
Interface_Init
std::shared_ptr< Interface > Interface_Init(int indx, const CompositeMap &edge, bool skipCoordCheck)
Definition: Interfaces.cpp:42
Nektar::SpatialDomains::Interface
A interface which is a single edge on a zone for handling non-conformality.
Definition: InterfaceInterpolation.h:52

References Interface_Init(), and InterfacePair_Init().

Referenced by BOOST_PYTHON_MODULE().

◆ export_MeshGraph()

void export_MeshGraph ( )

MeshGraph exports.

Definition at line 98 of file Python/MeshGraph.cpp.

99{
100 py::class_<LibUtilities::FieldMetaDataMap>("FieldMetaDataMap")
101 .def(py::map_indexing_suite<LibUtilities::FieldMetaDataMap, true>());
102
103 py::class_<std::vector<GeometrySharedPtr>>("GeometryList")
104 .def(py::vector_indexing_suite<std::vector<GeometrySharedPtr>, true>());
105 py::class_<Composite, std::shared_ptr<Composite>>("Composite", py::init<>())
106 .def("__init__", py::make_constructor(&Composite_Init))
107 .def_readwrite("geometries", &Composite::m_geomVec);
108
109 py::class_<PointGeomMap>("PointGeomMap")
110 .def(py::map_indexing_suite<PointGeomMap, true>());
111 py::class_<SegGeomMap>("SegGeomMap")
112 .def(py::map_indexing_suite<SegGeomMap, true>());
113 py::class_<QuadGeomMap>("QuadGeomMap")
114 .def(py::map_indexing_suite<QuadGeomMap, true>());
115 py::class_<TriGeomMap>("TriGeomMap")
116 .def(py::map_indexing_suite<TriGeomMap, true>());
117 py::class_<TetGeomMap>("TetGeomMap")
118 .def(py::map_indexing_suite<TetGeomMap, true>());
119 py::class_<PrismGeomMap>("PrismGeomMap")
120 .def(py::map_indexing_suite<PrismGeomMap, true>());
121 py::class_<PyrGeomMap>("PyrGeomMap")
122 .def(py::map_indexing_suite<PyrGeomMap, true>());
123 py::class_<HexGeomMap>("HexGeomMap")
124 .def(py::map_indexing_suite<HexGeomMap, true>());
125 py::class_<CurveMap>("CurveMap")
126 .def(py::map_indexing_suite<CurveMap, true>());
127 py::class_<CompositeMap>("CompositeMap")
128 .def(py::map_indexing_suite<CompositeMap, true>());
129 py::class_<std::map<int, CompositeMap>>("DomainMap")
130 .def(py::map_indexing_suite<std::map<int, CompositeMap>, true>());
131
132 py::class_<MeshGraph, std::shared_ptr<MeshGraph>, boost::noncopyable>(
133 "MeshGraph", py::no_init)
134
135 .def("Read", MeshGraph_Read)
136 .staticmethod("Read")
137
138 .def("Write", &MeshGraph::WriteGeometry, py::default_call_policies(),
139 (py::arg("outfile"), py::arg("defaultExp") = false,
140 py::arg("metadata") = LibUtilities::NullFieldMetaDataMap))
141
142 .def("GetMeshDimension", &MeshGraph::GetMeshDimension)
143 .def("GetSpaceDimension", &MeshGraph::GetSpaceDimension)
144 .def("GetAllPointGeoms", &MeshGraph::GetAllPointGeoms,
145 py::return_internal_reference<>())
146 .def("GetAllSegGeoms", &MeshGraph::GetAllSegGeoms,
147 py::return_internal_reference<>())
148 .def("GetAllQuadGeoms", &MeshGraph::GetAllQuadGeoms,
149 py::return_internal_reference<>())
150 .def("GetAllTriGeoms", &MeshGraph::GetAllTriGeoms,
151 py::return_internal_reference<>())
152 .def("GetAllTetGeoms", &MeshGraph::GetAllTetGeoms,
153 py::return_internal_reference<>())
154 .def("GetAllPrismGeoms", &MeshGraph::GetAllPrismGeoms,
155 py::return_internal_reference<>())
156 .def("GetAllPyrGeoms", &MeshGraph::GetAllPyrGeoms,
157 py::return_internal_reference<>())
158 .def("GetAllHexGeoms", &MeshGraph::GetAllHexGeoms,
159 py::return_internal_reference<>())
160 .def("GetCurvedEdges", &MeshGraph::GetCurvedEdges,
161 py::return_internal_reference<>())
162 .def("GetCurvedFaces", &MeshGraph::GetCurvedFaces,
163 py::return_internal_reference<>())
164 .def("GetComposites", &MeshGraph::GetComposites,
165 py::return_internal_reference<>())
166 .def<std::map<int, CompositeMap> &(MeshGraph::*)()>(
167 "GetDomain", &MeshGraph::GetDomain,
168 py::return_internal_reference<>())
169
170 .def("GetMovement", &MeshGraph::GetMovement,
171 py::return_value_policy<py::return_by_value>())
172
173 .def("GetNumElements", &MeshGraph::GetNumElements)
174
175 .def("SetExpansionInfosToEvenlySpacedPoints",
176 &MeshGraph::SetExpansionInfoToEvenlySpacedPoints)
177 .def("SetExpansionInfosToPolyOrder",
178 &MeshGraph::SetExpansionInfoToNumModes)
179 .def("SetExpansionInfosToPointOrder",
180 &MeshGraph::SetExpansionInfoToPointOrder);
181
182 py::class_<MeshGraphXml, py::bases<MeshGraph>,
183 std::shared_ptr<MeshGraphXml>, boost::noncopyable>(
184 "MeshGraphXml", py::no_init)
185 .def("__init__", py::make_constructor(&MeshGraphXml_Init));
186
187 py::class_<MeshGraphXmlCompressed, py::bases<MeshGraphXml>,
188 std::shared_ptr<MeshGraphXmlCompressed>, boost::noncopyable>(
189 "MeshGraphXmlCompressed", py::no_init)
190 .def("__init__", py::make_constructor(&MeshGraphXmlCompressed_Init));
191}
MeshGraph_Read
MeshGraphSharedPtr MeshGraph_Read(const LibUtilities::SessionReaderSharedPtr &session)
Definition: Python/MeshGraph.cpp:50
Composite_Init
CompositeSharedPtr Composite_Init(py::list geometries)
Definition: Python/MeshGraph.cpp:60
MeshGraphXmlCompressed_Init
std::shared_ptr< MeshGraph > MeshGraphXmlCompressed_Init(int meshDim, int spatialDim)
Definition: Python/MeshGraph.cpp:87
MeshGraphXml_Init
std::shared_ptr< MeshGraph > MeshGraphXml_Init(int meshDim, int spatialDim)
Definition: Python/MeshGraph.cpp:76
Nektar::SpatialDomains::MeshGraph
Base class for a spectral/hp element mesh.
Definition: MeshGraph.h:181
Nektar::LibUtilities::NullFieldMetaDataMap
static FieldMetaDataMap NullFieldMetaDataMap
Definition: FieldIO.h:51

References Composite_Init(), MeshGraph_Read(), MeshGraphXml_Init(), MeshGraphXmlCompressed_Init(), and Nektar::LibUtilities::NullFieldMetaDataMap.

Referenced by BOOST_PYTHON_MODULE().

◆ export_Movement()

void export_Movement ( )

Definition at line 61 of file Python/Movement.cpp.

62{
63
64 py::class_<std::map<int, ZoneBaseShPtr>>("ZoneMap").def(
65 py::map_indexing_suite<std::map<int, ZoneBaseShPtr>, true>());
66
67 py::class_<Movement, std::shared_ptr<Movement>>("Movement", py::no_init)
68 .def("__init__", py::make_constructor(&Movement_Init))
69 .def("GetInterfaces", &GetInterfaces_wrapper)
70 .def("GetZones", &Movement::GetZones,
71 py::return_value_policy<py::copy_const_reference>())
72 .def("PerformMovement", &Movement::PerformMovement)
73 .def("AddZone", &Movement::AddZone)
74 .def("AddInterface", &Movement::AddInterface);
75}
GetInterfaces_wrapper
py::dict GetInterfaces_wrapper(MovementSharedPtr movement)
Definition: Python/Movement.cpp:45
Movement_Init
MovementSharedPtr Movement_Init()
Definition: Python/Movement.cpp:56

References GetInterfaces_wrapper(), and Movement_Init().

Referenced by BOOST_PYTHON_MODULE().

◆ export_Zones()

void export_Zones ( )

Definition at line 67 of file Python/Zones.cpp.

68{
69 NEKPY_WRAP_ENUM_STRING(MovementType, MovementTypeStr);
70
71 py::class_<ZoneBase, std::shared_ptr<ZoneBase>, boost::noncopyable>(
72 "ZoneBase", py::no_init)
73 .def("GetMovementType", &ZoneBase::GetMovementType)
74 .def("GetDomain", &ZoneBase::GetDomain)
75 .def("GetId", &ZoneBase::GetId,
76 py::return_value_policy<py::copy_non_const_reference>())
77 .def("GetDomainID", &ZoneBase::GetDomainID,
78 py::return_value_policy<py::copy_non_const_reference>())
79 .def("Move", &ZoneBase::Move)
80 .def("GetElements", &ZoneBase::GetElements,
81 py::return_internal_reference<>())
82 .def("GetMoved", &ZoneBase::GetMoved,
83 py::return_value_policy<py::copy_non_const_reference>())
84 .def("ClearBoundingBoxes", &ZoneBase::ClearBoundingBoxes);
85
86 py::class_<ZoneRotate, py::bases<ZoneBase>, std::shared_ptr<ZoneRotate>>(
87 "ZoneRotate", py::no_init)
88 .def("__init__", py::make_constructor(&ZoneRotate_Init))
89 .def("GetAngualrVel", &ZoneRotate::GetAngularVel)
90 .def("GetOrigin", &ZoneRotate::GetOrigin,
91 py::return_value_policy<py::copy_const_reference>())
92 .def("GetAxis", &ZoneRotate::GetAxis,
93 py::return_value_policy<py::copy_const_reference>())
94 .def("GetAngularVelEqn", &ZoneRotate::GetAngularVelEqn);
95
96 py::class_<ZoneTranslate, py::bases<ZoneBase>,
97 std::shared_ptr<ZoneTranslate>>("ZoneTranslate", py::no_init)
98 .def("__init__", py::make_constructor(&ZoneTranslate_Init))
99 .def("GetVelocityEquation", &ZoneTranslate::GetVelocityEquation)
100 .def("GetDisplacementEqn", &ZoneTranslate::GetDisplacementEquation);
101
102 py::class_<ZoneFixed, py::bases<ZoneBase>, std::shared_ptr<ZoneFixed>>(
103 "ZoneFixed", py::no_init)
104 .def("__init__", py::make_constructor(&ZoneFixed_Init));
105}
NEKPY_WRAP_ENUM_STRING
#define NEKPY_WRAP_ENUM_STRING(ENUMNAME, MAPNAME)
Definition: NekPyConfig.hpp:80
ZoneRotate_Init
ZoneRotateShPtr ZoneRotate_Init(int id, int domainID, const CompositeMap &domain, const int coordDim, const NekPoint< NekDouble > &origin, const DNekVec &axis, LibUtilities::EquationSharedPtr &angularVelEqn)
Definition: Python/Zones.cpp:42
ZoneFixed_Init
ZoneFixedShPtr ZoneFixed_Init(int id, int domainID, const CompositeMap &domain, const int coordDim)
Definition: Python/Zones.cpp:61
ZoneTranslate_Init
ZoneTranslateShPtr ZoneTranslate_Init(int id, int domainID, const CompositeMap &domain, const int coordDim, const Array< OneD, LibUtilities::EquationSharedPtr > &velocityEqns, const Array< OneD, LibUtilities::EquationSharedPtr > &displacementEqns)
Definition: Python/Zones.cpp:52
Nektar::SpatialDomains::MovementType
MovementType
Enum of zone movement type.
Definition: Zones.h:47
Nektar::SpatialDomains::MovementTypeStr
const std::string MovementTypeStr[]
Map of zone movement type to movement type string.
Definition: Zones.h:56

References Nektar::SpatialDomains::MovementTypeStr, NEKPY_WRAP_ENUM_STRING, ZoneFixed_Init(), ZoneRotate_Init(), and ZoneTranslate_Init().

Referenced by BOOST_PYTHON_MODULE().

Generated on Wed May 15 2024 07:37:01 for Nektar++ by doxygen 1.9.4