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

Go to the source code of this file.

Functions

void export_Geometry (py::module &m)
 
void export_Curve (py::module &m)
 
void export_MeshGraph (py::module &m)
 MeshGraph exports. More...
 
void export_MeshGraphIO (py::module &m)
 
void export_GeomElements (py::module &m)
 
void export_Zones (py::module &m)
 
void export_Interfaces (py::module &m)
 
void export_Movement (py::module &m)
 
 PYBIND11_MODULE (_SpatialDomains, m)
 

Function Documentation

◆ export_Curve()

void export_Curve ( py::module &  m)

Definition at line 61 of file Curve.cpp.

62{
63 py::class_<Curve, std::shared_ptr<Curve>>(m, "Curve")
64
65 .def(py::init<int, LibUtilities::PointsType>())
66
67 .def_readwrite("curveID", &Curve::m_curveID)
68 .def_readwrite("ptype", &Curve::m_ptype)
69 .def_property("points", &Curve_GetPoints, &Curve_SetPoints);
70}
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 PYBIND11_MODULE().

◆ export_GeomElements()

void export_GeomElements ( py::module &  m)

Definition at line 120 of file GeomElements.cpp.

121{
122 // Geometry dimensioned base classes
123 py::class_<Geometry1D, Geometry, std::shared_ptr<Geometry1D>>(m,
124 "Geometry1D");
125 py::class_<Geometry2D, Geometry, std::shared_ptr<Geometry2D>>(m,
126 "Geometry2D")
127 .def("GetCurve", &Geometry2D::GetCurve);
128 py::class_<Geometry3D, Geometry, std::shared_ptr<Geometry3D>>(m,
129 "Geometry3D");
130
131 // Point geometries
132 py::class_<PointGeom, Geometry, std::shared_ptr<PointGeom>>(m, "PointGeom")
133 .def(py::init<>())
134 .def(py::init<int, int, NekDouble, NekDouble, NekDouble>())
135 .def("GetCoordinates", &PointGeom_GetCoordinates);
136
137 // Segment geometries
138 py::class_<SegGeom, Geometry, std::shared_ptr<SegGeom>>(m, "SegGeom")
139 .def(py::init<>())
140 .def(py::init<>(&SegGeom_Init), py::arg("id"), py::arg("coordim"),
141 py::arg("points") = py::list(),
142 py::arg("curve") = CurveSharedPtr())
143 .def("GetCurve", &SegGeom::GetCurve);
144
145 export_Geom_2d<TriGeom, SegGeom>(m, "TriGeom");
146 export_Geom_2d<QuadGeom, SegGeom>(m, "QuadGeom");
147 export_Geom_3d<TetGeom, TriGeom>(m, "TetGeom");
148 export_Geom_3d<PrismGeom, Geometry2D>(m, "PrismGeom");
149 export_Geom_3d<PyrGeom, Geometry2D>(m, "PyrGeom");
150 export_Geom_3d<HexGeom, QuadGeom>(m, "HexGeom");
151}
PointGeom_GetCoordinates
py::tuple PointGeom_GetCoordinates(const PointGeom &self)
Definition: GeomElements.cpp:115
SegGeom_Init
SegGeomSharedPtr SegGeom_Init(int id, int coordim, py::list &points, CurveSharedPtr curve)
Definition: GeomElements.cpp:95
Nektar::SpatialDomains::CurveSharedPtr
std::shared_ptr< Curve > CurveSharedPtr
Definition: Curve.hpp:58

References PointGeom_GetCoordinates(), and SegGeom_Init().

Referenced by PYBIND11_MODULE().

◆ export_Geometry()

void export_Geometry ( py::module &  m)

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

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

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

Referenced by PYBIND11_MODULE().

◆ export_Interfaces()

void export_Interfaces ( py::module &  m)

Definition at line 54 of file Interfaces.cpp.

55{
56 py::bind_vector<std::vector<unsigned int>>(m, "UIntList");
57
58 py::class_<Interface, std::shared_ptr<Interface>>(m, "Interface")
59 .def(py::init<>(&Interface_Init))
60 .def<const std::map<int, GeometrySharedPtr> &(Interface::*)() const>(
61 "GetEdge", &Interface::GetEdge,
62 py::return_value_policy::reference_internal)
63 .def("IsEmpty", &Interface::IsEmpty)
64 .def("GetId", &Interface::GetId, py::return_value_policy::copy)
65 .def("GetOppInterace", &Interface::GetOppInterface,
66 py::return_value_policy::reference_internal)
67 .def("GetCompositeIDs", &Interface::GetCompositeIDs,
68 py::return_value_policy::copy);
69
70 py::class_<InterfacePair, std::shared_ptr<InterfacePair>>(m,
71 "InterfacePair")
72 .def(py::init<>(&InterfacePair_Init))
73 .def("GetLeftInterface", &InterfacePair::GetLeftInterface,
74 py::return_value_policy::copy)
75 .def("GetRightInterface", &InterfacePair::GetRightInterface,
76 py::return_value_policy::copy);
77}
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
CellMLToNektar.pycml.copy
def copy(self)
Definition: pycml.py:2663
Nektar::SpatialDomains::Interface
A interface which is a single edge on a zone for handling non-conformality.
Definition: InterfaceInterpolation.h:53

References CellMLToNektar.pycml::copy(), Interface_Init(), and InterfacePair_Init().

Referenced by PYBIND11_MODULE().

◆ export_MeshGraph()

void export_MeshGraph ( py::module &  m)

MeshGraph exports.

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

64{
65 py::bind_map<LibUtilities::FieldMetaDataMap>(m, "FieldMetaDataMap");
66 py::bind_vector<std::vector<GeometrySharedPtr>>(m, "GeometryList");
67
68 py::class_<Composite, std::shared_ptr<Composite>>(m, "Composite")
69 .def(py::init<>())
70 .def(py::init<>(&Composite_Init))
71 .def_readwrite("geometries", &Composite::m_geomVec);
72
73 py::bind_map<PointGeomMap>(m, "PointGeomMap");
74 py::bind_map<SegGeomMap>(m, "SegGeomMap");
75 py::bind_map<QuadGeomMap>(m, "QuadGeomMap");
76 py::bind_map<TriGeomMap>(m, "TriGeomMap");
77 py::bind_map<TetGeomMap>(m, "TetGeomMap");
78 py::bind_map<PrismGeomMap>(m, "PrismGeomMap");
79 py::bind_map<PyrGeomMap>(m, "PyrGeomMap");
80 py::bind_map<HexGeomMap>(m, "HexGeomMap");
81 py::bind_map<CurveMap>(m, "CurveMap");
82 py::bind_map<CompositeMap>(m, "CompositeMap");
83 py::bind_map<std::map<int, CompositeMap>>(m, "DomainMap");
84
85 py::class_<MeshGraph, std::shared_ptr<MeshGraph>>(m, "MeshGraph")
86 .def(py::init<>())
87
88 .def("Empty", &MeshGraph::Empty)
89
90 .def("GetMeshDimension", &MeshGraph::GetMeshDimension)
91 .def("GetSpaceDimension", &MeshGraph::GetSpaceDimension)
92
93 .def("SetMeshDimension", &MeshGraph::SetMeshDimension)
94 .def("SetSpaceDimension", &MeshGraph::SetSpaceDimension)
95
96 .def("GetAllPointGeoms", &MeshGraph::GetAllPointGeoms,
97 py::return_value_policy::reference_internal)
98 .def("GetAllSegGeoms", &MeshGraph::GetAllSegGeoms,
99 py::return_value_policy::reference_internal)
100 .def("GetAllQuadGeoms", &MeshGraph::GetAllQuadGeoms,
101 py::return_value_policy::reference_internal)
102 .def("GetAllTriGeoms", &MeshGraph::GetAllTriGeoms,
103 py::return_value_policy::reference_internal)
104 .def("GetAllTetGeoms", &MeshGraph::GetAllTetGeoms,
105 py::return_value_policy::reference_internal)
106 .def("GetAllPrismGeoms", &MeshGraph::GetAllPrismGeoms,
107 py::return_value_policy::reference_internal)
108 .def("GetAllPyrGeoms", &MeshGraph::GetAllPyrGeoms,
109 py::return_value_policy::reference_internal)
110 .def("GetAllHexGeoms", &MeshGraph::GetAllHexGeoms,
111 py::return_value_policy::reference_internal)
112 .def("GetCurvedEdges", &MeshGraph::GetCurvedEdges,
113 py::return_value_policy::reference_internal)
114 .def("GetCurvedFaces", &MeshGraph::GetCurvedFaces,
115 py::return_value_policy::reference_internal)
116 .def("GetComposites", &MeshGraph::GetComposites,
117 py::return_value_policy::reference_internal)
118 .def<std::map<int, CompositeMap> &(MeshGraph::*)()>(
119 "GetDomain", &MeshGraph::GetDomain,
120 py::return_value_policy::reference_internal)
121
122 .def("GetMovement", &MeshGraph::GetMovement,
123 py::return_value_policy::reference_internal)
124
125 .def("GetNumElements", &MeshGraph::GetNumElements)
126
127 .def("SetExpansionInfosToEvenlySpacedPoints",
128 &MeshGraph::SetExpansionInfoToEvenlySpacedPoints)
129 .def("SetExpansionInfosToPolyOrder",
130 &MeshGraph::SetExpansionInfoToNumModes)
131 .def("SetExpansionInfosToPointOrder",
132 &MeshGraph::SetExpansionInfoToPointOrder);
133}
Composite_Init
CompositeSharedPtr Composite_Init(py::list geometries)
Definition: Python/MeshGraph.cpp:48
Nektar::SpatialDomains::MeshGraph
Base class for a spectral/hp element mesh.
Definition: MeshGraph.h:181

References Composite_Init().

Referenced by PYBIND11_MODULE().

◆ export_MeshGraphIO()

void export_MeshGraphIO ( py::module &  m)

Definition at line 58 of file Python/MeshGraphIO.cpp.

59{
60 py::class_<MeshGraphIO, std::shared_ptr<MeshGraphIO>>(m, "MeshGraphIO")
61
62 .def("Write", &MeshGraphIO::WriteGeometry, py::arg("outfile"),
63 py::arg("defaultExp") = false,
64 py::arg("metadata") = LibUtilities::NullFieldMetaDataMap)
65
66 .def("SetMeshGraph", &MeshGraphIO::SetMeshGraph)
67
68 .def_static("Read", MeshGraphIO_Read)
69 .def_static("Create", MeshGraphIO_Create);
70}
MeshGraphIO_Read
MeshGraphSharedPtr MeshGraphIO_Read(const LibUtilities::SessionReaderSharedPtr &session)
Definition: Python/MeshGraphIO.cpp:47
MeshGraphIO_Create
MeshGraphIOSharedPtr MeshGraphIO_Create(std::string ioType)
Definition: Python/MeshGraphIO.cpp:53
Nektar::LibUtilities::NullFieldMetaDataMap
static FieldMetaDataMap NullFieldMetaDataMap
Definition: FieldIO.h:51

References MeshGraphIO_Create(), MeshGraphIO_Read(), and Nektar::LibUtilities::NullFieldMetaDataMap.

Referenced by PYBIND11_MODULE().

◆ export_Movement()

void export_Movement ( py::module &  m)

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

62{
63 py::bind_map<std::map<int, ZoneBaseShPtr>>(m, "ZoneMap");
64
65 py::class_<Movement, std::shared_ptr<Movement>>(m, "Movement")
66 .def(py::init<>(&Movement_Init))
67 .def("GetInterfaces", &GetInterfaces_wrapper)
68 .def("GetZones", &Movement::GetZones, py::return_value_policy::copy)
69 .def("PerformMovement", &Movement::PerformMovement)
70 .def("AddZone", &Movement::AddZone)
71 .def("AddInterface", &Movement::AddInterface);
72}
GetInterfaces_wrapper
py::dict GetInterfaces_wrapper(MovementSharedPtr movement)
Definition: Python/Movement.cpp:45
Movement_Init
MovementSharedPtr Movement_Init()
Definition: Python/Movement.cpp:56

References CellMLToNektar.pycml::copy(), GetInterfaces_wrapper(), and Movement_Init().

Referenced by PYBIND11_MODULE().

◆ export_Zones()

void export_Zones ( py::module &  m)

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

70{
71 NEKPY_WRAP_ENUM_STRING(m, MovementType, MovementTypeStr);
72
73 py::class_<ZoneBase, std::shared_ptr<ZoneBase>>(m, "ZoneBase")
74 .def("GetMovementType", &ZoneBase::GetMovementType,
75 py::return_value_policy::reference_internal)
76 .def("GetDomain", &ZoneBase::GetDomain,
77 py::return_value_policy::reference_internal)
78 .def("GetId", &ZoneBase::GetId, py::return_value_policy::copy)
79 .def("GetDomainID", &ZoneBase::GetDomainID,
80 py::return_value_policy::copy)
81 .def("Move", &ZoneBase::Move)
82 .def("GetElements", &ZoneBase::GetElements,
83 py::return_value_policy::reference_internal)
84 .def("GetMoved", &ZoneBase::GetMoved, py::return_value_policy::copy)
85 .def("ClearBoundingBoxes", &ZoneBase::ClearBoundingBoxes);
86
87 py::class_<ZoneRotate, ZoneBase, std::shared_ptr<ZoneRotate>>(m,
88 "ZoneRotate")
89 .def(py::init<>(&ZoneRotate_Init))
90 .def("GetAngualrVel", &ZoneRotate::GetAngularVel)
91 .def("GetOrigin", &ZoneRotate::GetOrigin, py::return_value_policy::copy)
92 .def("GetAxis", &ZoneRotate::GetAxis, py::return_value_policy::copy)
93 .def("GetAngularVelEqn", &ZoneRotate::GetAngularVelEqn);
94
95 py::class_<ZoneTranslate, ZoneBase, std::shared_ptr<ZoneTranslate>>(
96 m, "ZoneTranslate")
97 .def(py::init<>(&ZoneTranslate_Init))
98 .def("GetVelocityEquation", &ZoneTranslate::GetVelocityEquation)
99 .def("GetDisplacementEqn", &ZoneTranslate::GetDisplacementEquation);
100
101 py::class_<ZoneFixed, ZoneBase, std::shared_ptr<ZoneFixed>>(m, "ZoneFixed")
102 .def(py::init<>(&ZoneFixed_Init));
103}
NEKPY_WRAP_ENUM_STRING
#define NEKPY_WRAP_ENUM_STRING(MOD, ENUMNAME, MAPNAME)
Definition: NekPyConfig.hpp:62
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:44
ZoneFixed_Init
ZoneFixedShPtr ZoneFixed_Init(int id, int domainID, const CompositeMap &domain, const int coordDim)
Definition: Python/Zones.cpp:63
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:54
Nektar::SpatialDomains::MovementType
MovementType
Enum of zone movement type.
Definition: Zones.h:48
Nektar::SpatialDomains::MovementTypeStr
const std::string MovementTypeStr[]
Map of zone movement type to movement type string.
Definition: Zones.h:57

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

Referenced by PYBIND11_MODULE().

◆ PYBIND11_MODULE()

PYBIND11_MODULE ( _SpatialDomains  ,
m   
)

Definition at line 47 of file SpatialDomains.cpp.

48{
49 export_Geometry(m);
50 export_Curve(m);
51 export_MeshGraph(m);
52 export_MeshGraphIO(m);
53 export_GeomElements(m);
54 export_Zones(m);
55 export_Interfaces(m);
56 export_Movement(m);
57}
export_Zones
void export_Zones(py::module &m)
Definition: Python/Zones.cpp:69
export_Movement
void export_Movement(py::module &m)
Definition: Python/Movement.cpp:61
export_MeshGraph
void export_MeshGraph(py::module &m)
MeshGraph exports.
Definition: Python/MeshGraph.cpp:63
export_Curve
void export_Curve(py::module &m)
Definition: Curve.cpp:61
export_GeomElements
void export_GeomElements(py::module &m)
Definition: GeomElements.cpp:120
export_Interfaces
void export_Interfaces(py::module &m)
Definition: Interfaces.cpp:54
export_Geometry
void export_Geometry(py::module &m)
Definition: Python/Geometry.cpp:64
export_MeshGraphIO
void export_MeshGraphIO(py::module &m)
Definition: Python/MeshGraphIO.cpp:58

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

Generated on Wed May 28 2025 19:03:42 for Nektar++ by doxygen 1.9.4