Geom Module¶

Unstructured mesh, CGNS I/O, element types, and partitioning.

Namespace Overview¶

namespace Geom

Typedefs

using tPy_AutoAppendName2ID = py_class_ssp<AutoAppendName2ID>

using t_FBCName_2_ID = std::function<t_index(const std::string&)>

using t_FBCID_2_Name = std::function<std::string(t_index)>

using t_index = int32_t

using t_real = double

using tPoint = Eigen::Vector3d

using tJacobi = Eigen::Matrix3d

using tGPoint = Eigen::Matrix3d

using tPointMap = Eigen::Map<tPoint, Eigen::Unaligned>

using tPointConstMap = Eigen::Map<const tPoint, Eigen::Unaligned>

using tGPointMap = Eigen::Map<tGPoint, Eigen::Unaligned>

using tGPointConstMap = Eigen::Map<const tGPoint, Eigen::Unaligned>

using tSmallCoords = Eigen::Matrix<real, 3, Eigen::Dynamic>

using tLocalMatStruct = std::vector<std::vector<index>>

template<rowsize _row_size, rowsize _row_max = _row_size, rowsize _align = NoAlign> using tPy_AdjPairTracked = py_class_ssp<AdjPairTracked<ArrayAdjacencyPair<_row_size, _row_max, _align>>>

using tFDataFieldName = std::function<std::string(int)>

using tFDataFieldQuery = tFGetData

using tPy_ElemInfo = py_class_ssp<ElemInfo>

using tPy_UnstructuredMesh = py_class_ssp<UnstructuredMesh>

using tPy_UnstructuredMeshSerialRW = py_class_ssp<UnstructuredMeshSerialRW>

using tAdjPair = DNDS::ArrayAdjacencyPair<DNDS::NonUniformSize>

using tAdj = decltype(tAdjPair::father)

using tPbiPair = ArrayPair<ArrayNodePeriodicBits<DNDS::NonUniformSize>>

using tPbi = decltype(tPbiPair::father)

using tAdj1Pair = DNDS::ArrayAdjacencyPair<1>

using tAdj1 = decltype(tAdj1Pair::father)

using tAdj2Pair = DNDS::ArrayAdjacencyPair<2>

using tAdj2 = decltype(tAdj2Pair::father)

using tAdj3Pair = DNDS::ArrayAdjacencyPair<3>

using tAdj3 = decltype(tAdj3Pair::father)

using tAdj4Pair = DNDS::ArrayAdjacencyPair<4>

using tAdj4 = decltype(tAdj4Pair::father)

using tAdj8Pair = DNDS::ArrayAdjacencyPair<8>

using tAdj8 = decltype(tAdj8Pair::father)

using tCoordPair = DNDS::ArrayPair<DNDS::ArrayEigenVector<3>>

using tCoord = decltype(tCoordPair::father)

using tElemInfoArrayPair = DNDS::ArrayPair<DNDS::ParArray<ElemInfo>>

using tElemInfoArray = DNDS::ssp<DNDS::ParArray<ElemInfo>>

using tIndPair = DNDS::ArrayPair<DNDS::ArrayIndex>

using tInd = decltype(tIndPair::father)

using tFGetName = std::function<std::string(int)>

using tFGetData = std::function<DNDS::real(int, DNDS::index)>

using tFGetVecData = std::function<DNDS::real(int, DNDS::index, DNDS::rowsize)>

using tIndexMapFunc = std::function<index(index)>

using AdjVariant = std::variant<tAdjPair, tAdj1Pair, tAdj2Pair, tAdj3Pair, tAdj4Pair, tAdj8Pair>

using OwnershipResolverMulti = std::function<OwnershipDecision(const std::vector<index> &parents, const std::vector<MPI_int> &parentRanks, index nLocalParents)>

using OwnershipResolver2 = std::function<OwnershipDecision(index parentL, index parentR, index nLocalParents)>

using InterpolateGlobalResult = InterpolateGlobalResultT<>

using InterpolateResult = InterpolateResultT<>

using InterpolateDistributedResult = InterpolateDistributedResultT<>

using AdjRemapFn = std::function<void(const PermutationTransfer::LookupResult &lookup)>

using AdjRelocateFn = std::function<void(const PermutationTransfer &transfer, const MPIInfo &mpi)>

template<rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign> using ArrayNodePeriodicBitsPair = ArrayPair<ArrayNodePeriodicBits<_row_size, _row_max, _align>>

Enums

enum class MeshLoc : uint8_t

Values:

enumerator Unknown

enumerator Node

enumerator Face

enumerator Cell

enum MeshReaderMode

Values:

enumerator UnknownMode

enumerator SerialReadAndDistribute

enumerator SerialOutput

enum MeshAdjState

Values:

enumerator Adj_Unknown

enumerator Adj_PointToLocal

enumerator Adj_PointToGlobal

enum MeshElevationState

Values:

enumerator Elevation_Untouched

enumerator Elevation_O1O2

enum class EntityKind : int8_t

Values:

enumerator Cell

enumerator Face

enumerator Edge

enumerator Node

enumerator Bnd

enumerator NUM_KINDS

enum class AdjAction

Values:

enumerator SKIP

enumerator RELOCATE

enumerator REMAP

enumerator RELOCATE_REMAP

enumerator SELF

Functions

inline void pybind11_AutoAppendName2ID_define(py::module_ &m)

inline auto GetFaceName2IDDefault()

inline DNDS_DEVICE_CALLABLE bool FaceIDIsExternalBC (t_index id)

inline DNDS_DEVICE_CALLABLE bool FaceIDIsInternal (t_index id)

inline DNDS_DEVICE_CALLABLE bool FaceIDIsTrueInternal (t_index id)

inline DNDS_DEVICE_CALLABLE bool FaceIDIsPeriodic (t_index id)

inline DNDS_DEVICE_CALLABLE bool FaceIDIsPeriodic1 (t_index id)

inline DNDS_DEVICE_CALLABLE bool FaceIDIsPeriodic2 (t_index id)

inline DNDS_DEVICE_CALLABLE bool FaceIDIsPeriodic3 (t_index id)

inline DNDS_DEVICE_CALLABLE bool FaceIDIsPeriodicMain (t_index id)

inline DNDS_DEVICE_CALLABLE bool FaceIDIsPeriodicDonor (t_index id)

constexpr Elem::ElemType _getElemTypeFromCGNSType(ElementType_t cgns_et)

constexpr ElementType_t _getCGNSTypeFromElemType(Elem::ElemType et)

inline std::vector<real> JacobiToSTDVector(const tJacobi &j)

inline tJacobi STDVectorToJacobi(const std::vector<real> &v)

inline std::vector<real> VectorToSTDVector(const Eigen::VectorXd &v)

inline Eigen::VectorXd STDVectorToVector(const std::vector<real> &v)

template<int d> inline tPoint FacialJacobianToNormVec(const tJacobi &J)

template<int dim> inline Eigen::Matrix<real, dim, dim> NormBuildLocalBaseV(const Eigen::Ref<const Eigen::Vector<real, dim>> &uNorm)

inline tGPoint RotZ(real theta)

inline tGPoint RotX(real theta)

inline tGPoint RotY(real theta)

inline tGPoint RotateAxis(const tPoint &axis)

inline tGPoint CrossVecToMat(const tPoint &axn)

inline tPoint CrossMatToVec(const tGPoint &axnM)

template<int dim> tPoint ToThreeDim(const Eigen::Vector<real, dim> &v)

inline void GetTanhDistributionBilateral(real x0, real x1, index NInterval, real d0, Eigen::Vector<real, Eigen::Dynamic> &d)

template<rowsize _row_size, rowsize _row_max = _row_size, rowsize _align = NoAlign> std::string pybind11_AdjPairTracked_name()

inline void pybind11_MeshAdjState_define(py::module_ &m)

inline void pybind11_AdjIndexInfo_define(py::module_ &m)

template<rowsize _row_size, rowsize _row_max = _row_size, rowsize _align = NoAlign> tPy_AdjPairTracked<_row_size, _row_max, _align> pybind11_AdjPairTracked_declare(py::module_ &m)

template<rowsize _row_size, rowsize _row_max = _row_size, rowsize _align = NoAlign> void pybind11_AdjPairTracked_define(py::module_ &m)

void PushInfo2Serial2Global(std::vector<DNDS::index> &serial2Global, DNDS::index localSize, const std::vector<DNDS::index> &pushIndex, const std::vector<DNDS::index> &pushIndexStart, const DNDS::MPIInfo &mpi)

inline void pybind11_ElemInfo_define(py::module_ &m)

inline void pybind11_ArrayElemInfo_define(py::module_ &m)

inline void pybind11_MeshLocDefine(py::module_ &m)

inline void pybind11_UnstructuredMesh_define(py::module_ &m)

inline void pybind11_UnstructuredMeshSerialRW_define(py::module_ &m)

static tPoint HermiteInterpolateMidPointOnLine2WithNorm(tPoint c0, tPoint c1, tPoint n0, tPoint n1)

static tPoint HermiteInterpolateMidPointOnQuad4WithNorm(tPoint c0, tPoint c1, tPoint c2, tPoint c3, tPoint n0, tPoint n1, tPoint n2, tPoint n3)

inline std::optional<SmoothSolverSetup> PrepareSmoothSolverSetup(UnstructuredMesh &mesh)

inline void BuildGhostPrimary(UnstructuredMesh &mesh, int nGhostLayers = 1)

inline void ReadMeshFromCGNS(ssp<UnstructuredMesh> &mesh, ssp<UnstructuredMeshSerialRW> &reader, const std::string &meshFile, const PartitionOptions &partOpts = {}, real periodicTol = 1e-9, int elevation = 0, int bisect = 0, std::function<t_index(const std::string&)> nameMapper = nullptr)

inline void ReadMeshFromH5(UnstructuredMesh &mesh, Serializer::SerializerFactory factory, const std::string &h5Path, const PartitionOptions &partOpts = {})

inline void ReadMeshFromH5Parallel(UnstructuredMesh &mesh, Serializer::SerializerFactory factory, const std::string &h5Path)

inline void PrepareMesh(UnstructuredMesh &mesh, UnstructuredMeshSerialRW &reader, const PrepareMeshOptions &opts = {})

inline void BuildBndMesh(UnstructuredMesh &mesh, UnstructuredMesh &meshBnd, UnstructuredMeshSerialRW &readerBnd, bool buildSerialOut = true)

inline void SerializeMesh(UnstructuredMesh &mesh, const std::string &outputPath, Serializer::SerializerFactory &factory)

inline std::string MeshH5Path(const std::string &base, int mpiSize, int elevation = 0, int bisect = 0)

static void GeneralCell2NodeToNode2Cell(tCoordPair &coords, tAdjPair &cell2node, tAdjPair &node2cell, const tIndexMapFunc &CellIndexLocal2Global_NoSon, const tIndexMapFunc &NodeIndexLocal2Global_NoSon)

template<class TPartitionIdx> void Partition2LocalIdx(const std::vector<TPartitionIdx> &partition, std::vector<DNDS::index> &localPush, std::vector<DNDS::index> &localPushStart, const DNDS::MPIInfo &mpi)

template<class TPartitionIdx> void Partition2Serial2Global(const std::vector<TPartitionIdx> &partition, std::vector<DNDS::index> &serial2Global, const DNDS::MPIInfo &mpi, DNDS::MPI_int nPart)

template<class TAdj = tAdj1> void ConvertAdjSerial2Global(TAdj &arraySerialAdj, const std::vector<DNDS::index> &partitionJSerial2Global, const DNDS::MPIInfo &mpi)

template<class TArr = tAdj1> void TransferDataSerial2Global(TArr &arraySerial, TArr &arrayDist, const std::vector<DNDS::index> &pushIndex, const std::vector<DNDS::index> &pushIndexStart, const DNDS::MPIInfo &mpi)

static void GetViolentNodeDeduplication(index nNode, const std::vector<tPoint> &nodesExtra, tCoordPair &coordOut, std::vector<index> &nodeDedu2Old, std::vector<index> &nodeOld2Dedu)

static void updateVTKSeries(std::string seriesName, std::string fname, real tSimu)

static void H5_WriteDataset(hid_t loc, const char *name, index nGlobal, index nOffset, index nLocal, hid_t file_dataType, hid_t mem_dataType, hid_t plist_id, hid_t dcpl_id, void *buf, int dim2 = -1)

template<class TArray> static void EvenSplitReadFather(ssp<TArray> &father, ssp<TArray> &son, const MPIInfo &mpi, Serializer::SerializerBaseSSP serializerP, const std::string &name)

template<class TArray> static void EvenSplitReadFather(ssp<TArray> &father, ssp<TArray> &son, const MPIInfo &mpi, Serializer::SerializerBaseSSP serializerP, const std::string &name, MPI_Datatype commType, int commMult)

template<rowsize f2l_rs> static std::vector<MPI_int> ComputeFollowMapFromAdj(const ArrayAdjacencyPair<f2l_rs> &follower2leader, index nFollower, const ssp<GlobalOffsetsMapping> &leaderGM, const std::vector<MPI_int> &leaderTargetRanks, const MPIInfo &mpi)

static std::vector<index> put_perm_back_to_local_parts(const std::vector<index> &new2old, const std::vector<index> &localPartStarts)

static void check_permutations(const std::vector<index> &new2old, const std::vector<index> &old2new, const std::vector<index> &localPartStarts)

std::string adjKindName(const AdjKind &kind)

inline int entityDepth(EntityKind kind, int dim)

inline const char *entityKindName(EntityKind kind)

template<class TPair> static ssp<AdjVariant> makeAdjVariant(TPair &&pair)

template<class TPair> static ssp<AdjVariant> makeAdjVariant()

template<rowsize target_rs, rowsize source_rs = NonUniformSize> static void narrowAdjToFixed(const ArrayAdjacencyPair<source_rs> &source, ArrayAdjacencyPair<target_rs> &target, index nRows, index fill = UnInitIndex)

static void insertChainIntoTrie(std::vector<GhostTreeNode> &roots, const GhostChain &chain)

static void collectRequiredAdjsHelper(const GhostTreeNode &node, std::unordered_set<AdjKind, AdjKindHash> &out)

static void collectCollectedKindsHelper(const GhostTreeNode &node, std::unordered_set<EntityKind> &out)

static void dumpNode(const GhostTreeNode &node, std::ostringstream &oss, int indent)

static void sortedMergeInto(std::vector<index> &dst, const std::vector<index> &src)

template<class TAdjPair> static std::vector<index> traverseHopImpl(const std::vector<index> &parentSet, const TAdjPair &adj, bool assertFound)

static std::vector<index> traverseHop(const std::vector<index> &parentSet, const AdjVariant &adjVar, bool assertFound)

static std::vector<index> filterNonOwned(const std::vector<index> &set, index ownedStart, index ownedEnd)

template<rowsize cone_rs = NonUniformSize, class ToPair> AdjPairTracked<tAdjPair> CheckedInverse(const AdjPairTracked<ArrayAdjacencyPair<cone_rs>> &cone, const ToPair &toPair, index nToLocal, const MPIInfo &mpi)

template<rowsize rs_AB = NonUniformSize, rowsize rs_BC = NonUniformSize, rowsize out_rs = NonUniformSize, class Predicate, class ...TArgs> AdjPairTracked<ArrayAdjacencyPair<out_rs>> CheckedComposeFiltered(const AdjPairTracked<ArrayAdjacencyPair<rs_AB>> &AB, const AdjPairTracked<ArrayAdjacencyPair<rs_BC>> &BC, const std::unordered_map<index, index> &bGlobal2Local, Predicate &&pred, TArgs&&... args)

template<rowsize p2n_rs = NonUniformSize, rowsize e2p_rs = NonUniformSize> auto CheckedInterpolateGlobal(const AdjPairTracked<ArrayAdjacencyPair<p2n_rs>> &parent2node, const tPbiPair &parent2nodePbi, const OffsetAscendIndexMapping &parentGhostMapping, const GlobalOffsetsMapping &parentGlobalMapping, const OffsetAscendIndexMapping &nodeGhostMapping, const SubEntityQueryPbi &query, index nLocalParents, index nTotalParents, index nNode, const OwnershipResolverMulti &resolver, const MPIInfo &mpi)

inline AdjAction classifyAdj(AdjKind adj, const std::unordered_set<EntityKind> &reorderedKinds)

std::vector<index> ReorderSerialAdj_PartitionMetisC(tLocalMatStruct::iterator mat_begin, tLocalMatStruct::iterator mat_end, std::vector<index>::iterator i_new2old_begin, std::vector<index>::iterator i_new2old_end, int nParts, index ind_offset, bool do_rcm, index &bwOldM, index &bwNewM, tLocalMatStruct::iterator full_mat_begin, index full_n_elem)

inline auto PartitionSerialAdj_Metis(tLocalMatStruct::const_iterator mat_begin, tLocalMatStruct::const_iterator mat_end, int nPart, index ind_offset = 0, std::string metisType = "KWAY", int metisNcuts = 3, int metisUfactor = 5, int metisSeed = 0)

inline std::pair<std::vector<index>, std::vector<index>> ReorderSerialAdj_Metis(const tLocalMatStruct &mat)

inline std::pair<std::vector<index>, std::vector<index>> ReorderSerialAdj_BoostMMD(const tLocalMatStruct &mat)

inline std::pair<std::vector<index>, std::vector<index>> ReorderSerialAdj_BoostRCM(const tLocalMatStruct &mat, index &bandWidthOld, index &bandWidthNew)

inline std::pair<std::vector<index>, std::vector<index>> ReorderSerialAdj_CorrectRCM(tLocalMatStruct::const_iterator mat_begin, tLocalMatStruct::const_iterator mat_end, index &bandWidthOld, index &bandWidthNew, index offset = 0)

inline bool isCollaborativeNodePeriodicBits(const std::vector<NodePeriodicBits> &a, const std::vector<NodePeriodicBits> &b)

Variables

static const t_index BC_ID_INTERNAL = 0

static const t_index BC_ID_PERIODIC_1 = -1

static const t_index BC_ID_PERIODIC_2 = -2

static const t_index BC_ID_PERIODIC_3 = -3

static const t_index BC_ID_PERIODIC_1_DONOR = -4

static const t_index BC_ID_PERIODIC_2_DONOR = -5

static const t_index BC_ID_PERIODIC_3_DONOR = -6

static const t_index BC_ID_NULL = 1

static const t_index BC_ID_DEFAULT_WALL = 2

static const t_index BC_ID_DEFAULT_FAR = 3

static const t_index BC_ID_DEFAULT_WALL_INVIS = 4

static const t_index BC_ID_DEFAULT_SPECIAL_DMR_FAR = 11

static const t_index BC_ID_DEFAULT_SPECIAL_RT_FAR = 12

static const t_index BC_ID_DEFAULT_SPECIAL_IV_FAR = 13

static const t_index BC_ID_DEFAULT_SPECIAL_2DRiemann_FAR = 14

static const t_index BC_ID_DEFAULT_MAX = 20

static const t_FBCName_2_ID FBC_Name_2_ID_Default = [](const std::string &name) -> t_index { auto n2id_map = GetFaceName2IDDefault(); if(n2id_map.count(name))return n2id_map.at(name);return BC_ID_NULL;}

const t_index invalid_index = INT32_MAX

static const t_index INTERNAL_ZONE = -1

static const NodePeriodicBits nodePB1 = {0x01U}

static const NodePeriodicBits nodePB2 = {0x02U}

static const NodePeriodicBits nodePB3 = {0x04U}

struct AdjEntry

Public Members

AdjRemapFn remapFn

AdjRelocateFn relocateFn

struct AdjIndexInfo

Public Functions

inline const t_pLGhostMapping &mapping() const

inline void markGlobal()

inline void markLocal()

inline void wireTargetMapping(const t_pLGhostMapping &mapping)

template<class TAdj> inline void toLocal(TAdj &adj, index nRows)

template<class TAdj> inline void toGlobal(TAdj &adj, index nRows)

template<class TAdj> inline void toLocalOMP(TAdj &adj, index nRows)

template<class TAdj> inline void toGlobalOMP(TAdj &adj, index nRows)

template<class TAdj> inline void bootstrapToLocal(const t_pLGhostMapping &mapping, TAdj &adj, index nRows)

template<class TAdj> inline void bootstrapToLocalOMP(const t_pLGhostMapping &mapping, TAdj &adj, index nRows)

Public Static Functions

static inline t_pLGhostMapping makeFatherOnlyMapping(const ssp<GlobalOffsetsMapping> &globalMapping, index fatherSize, const MPIInfo &mpi)

struct AdjIndexInfoDeviceView

struct AdjKind

Public Functions

inline constexpr AdjKind(EntityKind from_, EntityKind to_)

inline constexpr AdjKind(EntityKind from_, EntityKind to_, EntityKind via_)

inline constexpr bool isIntraLevel() const

inline constexpr bool isDirect() const

inline constexpr bool operator==(const AdjKind &o) const

Public Members

EntityKind via = {EntityKind::Node}

struct AdjKindHash

template<class TPair> struct AdjPairTracked : public TPair

Public Functions

inline void bootstrapToLocal(const t_pLGhostMapping &mapping)

inline bool isBuilt() const

inline void reset()

template<DeviceBackend B> inline auto deviceView()

template<DeviceBackend B, class TArray> struct AdjPairTrackedDeviceView : public DNDS::ArrayPairDeviceView<B, TArray>

template<DeviceBackend B, class TArray> struct AdjPairTrackedDeviceViewConst : public DNDS::ArrayPairDeviceViewConst<B, TArray>

template<rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign> class ArrayNodePeriodicBits : public DNDS::ParArray<NodePeriodicBits, 1, 1, NoAlign>

struct AutoAppendName2ID

class BCName_2_ID

struct CompanionEntry

Public Members

EntityKind kind

AdjRelocateFn fn

struct CompiledGhostTree

Public Functions

std::unordered_set<AdjKind, AdjKindHash> requiredAdjs() const

std::vector<AdjKind> checkAvailable(const MeshConnectivity &dag) const

std::unordered_set<EntityKind> collectedKinds() const

std::string dump() const

Public Members

int maxLevel = {0}

int totalNodes = {0}

std::vector<std::vector<LevelEntry>> levels

Public Static Functions

static CompiledGhostTree compile(const GhostSpec &spec)

struct ConeAdj

Public Functions

inline tAdjPair &asAdj()

inline tAdj2Pair &asAdj2()

template<class TPair> inline TPair &as()

inline index fatherSize() const

inline bool initialized() const

inline bool hasPbi() const

Public Members

int fromDepth = {-1}

int toDepth = {-1}

ssp<AdjVariant> adj

tPbiPair pbi

struct CoordPairDOF : public DNDS::ArrayPair<DNDS::ArrayEigenVector<3>>, public DNDS::ArrayPair<DNDS::ArrayEigenVector<3>>

struct ElemInfo

Public Members

t_index zone = INTERNAL_ZONE

struct EntityReorderMap

Public Members

std::vector<MPI_int> targetRanks

struct FollowSpec

Public Members

EntityKind follower = {}

EntityKind leader = {}

AdjKind follower2leader

struct GhostChain

Public Members

EntityKind anchor

std::vector<AdjKind> hops

EntityKind target

struct GhostResult

Public Functions

inline bool hasGhosts(EntityKind kind) const

inline index totalGhosts() const

Public Members

std::unordered_map<EntityKind, std::vector<index>> ghostIndices

std::unordered_set<EntityKind> activeKinds

struct GhostSpec

Public Static Functions

static inline GhostSpec defaultPrimary()

static GhostSpec defaultPrimary(int nLayers)

struct GhostTreeNode

Public Members

EntityKind kind

AdjKind hop

bool collect = {false}

int level = {0}

int id = {-1}

int parentId = {-1}

template<rowsize p2e_rs = NonUniformSize, rowsize e2n_rs = NonUniformSize, rowsize e2p_rs = 2> struct InterpolateDistributedResultT

Public Members

ArrayAdjacencyPair<p2e_rs> parent2entity

ArrayAdjacencyPair<e2n_rs> entity2node

ArrayAdjacencyPair<e2p_rs> entity2parent

tElemInfoArrayPair entityElemInfo

index nOwnedEntities = {0}

template<rowsize e2p_rs = NonUniformSize> struct InterpolateGlobalResultT

Public Members

tAdjPair parent2entity

tPbiPair parent2entityPbi

tAdjPair entity2node

ArrayAdjacencyPair<e2p_rs> entity2parent

tPbiPair entity2nodePbi

tElemInfoArrayPair entityElemInfo

index nOwnedEntities = {0}

template<rowsize p2e_rs = NonUniformSize, rowsize e2n_rs = NonUniformSize, rowsize e2p_rs = NonUniformSize> struct InterpolateResultT

Public Members

ArrayAdjacencyPair<p2e_rs> parent2entity

ArrayAdjacencyPair<e2n_rs> entity2node

ArrayAdjacencyPair<e2p_rs> entity2parent

std::vector<ElemInfo> entityElemInfo

std::vector<std::vector<NodePeriodicBits>> parent2entityPbi

index nEntities = {0}

struct LevelEntry

Public Members

int nodeId = {}

int parentId = {}

EntityKind kind = {}

AdjKind hop

bool collect = {}

bool hasChildren = {}

struct MeshConnectivity

Public Functions

void registerAdj(AdjKind kind, ssp<AdjVariant> adjPtr)

template<class TPair> inline void registerAdj(AdjKind kind, TPair &pair)

template<class TPair> inline void registerAdj(AdjKind kind, const TPair &pair)

template<class TPair> inline void registerAdj(AdjKind kind, AdjPairTracked<TPair> &pair)

template<class TPair> inline void registerAdj(AdjKind kind, const AdjPairTracked<TPair> &pair)

void registerGlobalMapping(EntityKind kind, const ssp<GlobalOffsetsMapping> &gm)

ssp<AdjVariant> resolveAdj(AdjKind kind) const

const ssp<GlobalOffsetsMapping> &getGlobalMapping(EntityKind kind) const

bool hasAdj(AdjKind kind) const

ConeAdj &addCone(int fromDepth, int toDepth)

ConeAdj *findCone(int fromDepth, int toDepth)

SupportAdj &addSupport(int fromDepth, int toDepth)

SupportAdj *findSupport(int fromDepth, int toDepth)

GhostResult evaluateGhostTree(const CompiledGhostTree &tree, const MPIInfo &mpi) const

Public Members

std::unordered_map<AdjKind, ssp<AdjVariant>, AdjKindHash> adjRegistry

std::unordered_map<EntityKind, ssp<GlobalOffsetsMapping>> globalMappings

Public Static Functions

template<rowsize cone_rs = NonUniformSize> static tAdjPair Inverse(const ArrayAdjacencyPair<cone_rs> &cone, index nToLocal, const MPIInfo &mpi, const std::function<index(index)> &fromLocal2Global, const std::function<index(index)> &toLocal2Global, const ssp<GlobalOffsetsMapping> &toGlobalMapping)

template<rowsize rs_AB = NonUniformSize, rowsize rs_BC = NonUniformSize, rowsize out_rs = NonUniformSize> static ArrayAdjacencyPair<out_rs> Compose(const ArrayAdjacencyPair<rs_AB> &AB, const ArrayAdjacencyPair<rs_BC> &BC, index nALocal, const std::unordered_map<index, index> &bGlobal2Local, const std::function<index(index)> &aLocal2Global, bool removeSelf = false)

template<rowsize rs_AB = NonUniformSize, rowsize rs_BC = NonUniformSize, rowsize out_rs = NonUniformSize, class Predicate = SharedCountPredicate> static ArrayAdjacencyPair<out_rs> ComposeFiltered(const ArrayAdjacencyPair<rs_AB> &AB, const ArrayAdjacencyPair<rs_BC> &BC, index nALocal, const std::unordered_map<index, index> &bGlobal2Local, const std::function<index(index)> &aLocal2Global, Predicate &&pred, const std::function<bool(index aLocal, index cGlobal, const std::vector<index> &sharedBGlobals)> &matchExtra = nullptr)

template<rowsize p2n_rs = NonUniformSize> static InterpolateResult Interpolate(const ArrayAdjacencyPair<p2n_rs> &parent2node, const SubEntityQuery &query, index nParent, index nNode, const MPIInfo &mpi)

template<rowsize p2n_rs = NonUniformSize> static InterpolateDistributedResult InterpolateDistributed(const ArrayAdjacencyPair<p2n_rs> &parent2node, const OffsetAscendIndexMapping &parentGhostMapping, const SubEntityQuery &query, index nLocalParents, index nTotalParents, index nNode, const OwnershipResolver2 &resolver, const OffsetAscendIndexMapping &nodeGhostMapping, const MPIInfo &mpi)

template<rowsize p2n_rs = NonUniformSize, rowsize e2p_rs = NonUniformSize> static InterpolateGlobalResultT<e2p_rs> InterpolateGlobal(const ArrayAdjacencyPair<p2n_rs> &parent2node, const tPbiPair &parent2nodePbi, const OffsetAscendIndexMapping &parentGhostMapping, const GlobalOffsetsMapping &parentGlobalMapping, const OffsetAscendIndexMapping &nodeGhostMapping, const SubEntityQueryPbi &query, index nLocalParents, index nTotalParents, index nNode, const OwnershipResolverMulti &resolver, const MPIInfo &mpi)

struct NodeIndexPBI

struct NodePeriodicBits

class NodePeriodicBitsRow

class Octree

template<class T> class OffsetIterator

template<class T> class OffsetRange

struct OwnershipDecision

Public Members

bool owned

std::vector<MPI_int> peerRanks

struct PartitionOptions

struct Periodicity

Subclassed by DNDS::Geom::Base::CFVPeriodicity

Public Functions

template<int dim, int nVec> inline DNDS_DEVICE_CALLABLE Eigen::Matrix< real, dim, nVec > TransVector (const Eigen::Matrix< real, dim, nVec > &v, t_index id)

struct PointCloudFunctional

Public Types

using coord_t = real

struct PointCloudKDTree

Public Types

using coord_t = real

struct PointCloudKDTreeCoordPair

Public Types

using coord_t = real

struct PrepareMeshOptions

Public Members

int reorderCells = 0

int reorderParts = 1

bool buildSerialOut = true

struct ReorderInput

Public Members

std::vector<EntityReorderMap> explicitMaps

std::vector<FollowSpec> follows

std::unordered_set<EntityKind> destroyKinds

struct ReorderPlan

Public Functions

void apply(ReorderRegistry &registry, const MPIInfo &mpi) const

template<class TPair> inline void remapEntries(TPair &pair, EntityKind targetKind) const

template<class TPair> inline void relocateRows(TPair &pair, EntityKind sourceKind, const MPIInfo &mpi) const

Public Members

std::unordered_map<EntityKind, PermutationTransfer> transfers

std::unordered_map<EntityKind, PermutationTransfer::LookupResult> lookups

std::unordered_set<EntityKind> reorderedKinds

bool isLocalOnly = {false}

Public Static Functions

static ReorderPlan build(const ReorderInput &input, const ReorderRegistry &registry, const MPIInfo &mpi)

struct ReorderRegistry

Public Functions

inline void registerAdj(AdjKind kind, AdjRemapFn remap, AdjRelocateFn relocate, std::string name = {})

inline void registerCompanion(EntityKind kind, AdjRelocateFn fn, std::string name = {})

inline void registerGlobalMapping(EntityKind kind, ssp<GlobalOffsetsMapping> gm)

inline ssp<GlobalOffsetsMapping> getGlobalMapping(EntityKind kind) const

Public Members

std::vector<AdjEntry> adjs

std::vector<CompanionEntry> companions

std::unordered_map<EntityKind, ssp<GlobalOffsetsMapping>> globalMappings

std::unordered_map<EntityKind, std::vector<index>> pullSets

struct SharedCountPredicate

struct SmallCoordsAsVector : public tSmallCoords

struct SmoothSolverSetup

struct SubEntityDesc

Public Members

int nVertices = {0}

int nNodes = {0}

t_index typeTag = {0}

struct SubEntityQuery

Subclassed by DNDS::Geom::SubEntityQueryPbi

Public Members

std::function<int(index iParent)> numSubEntities

std::function<SubEntityDesc(index iParent, int iSub)> describe

std::function<void(index iParent, int iSub, const std::function<index(int)> &parentNodes, index *out)> extractNodes

std::function<bool(index iParent, int iSub, index iCandEntity, index candidateParent, int candidateSub)> matchExtra

struct SubEntityQueryPbi : public DNDS::Geom::SubEntityQuery

Public Members

std::function<void(index iParent, int iSub, const std::function<NodePeriodicBits(int)> &parentPbi, NodePeriodicBits *out)> extractPbi

struct SupportAdj

Public Functions

inline tAdjPair &asAdj()

template<class TPair> inline TPair &as()

Public Members

int fromDepth = {-1}

int toDepth = {-1}

ssp<AdjVariant> adj

struct tGPointPortable

struct tPointPortable

struct UnstructuredMesh : public DNDS::DeviceTransferable<UnstructuredMesh>

Public Functions

template<class TPair> inline void EnsureGhostMapping(TPair &pair)

template<class TPair> inline index IndexGlobal2Local(TPair &pair, DNDS::index iGlobal)

template<class TPair> inline index IndexLocal2Global(TPair &pair, DNDS::index iLocal)

template<class TPair> inline index IndexLocal2Global_NoSon(TPair &pair, index iLocal)

template<class TPair> inline index IndexGlobal2Local_NoSon(TPair &pair, index iGlobal)

void RecoverNode2CellAndNode2Bnd()

void RecoverCell2CellAndBnd2Cell()

void BuildGhostPrimary(int nGhostLayers = 1)

void fillRegistry(MeshConnectivity &dag) const

ReorderRegistry buildReorderRegistry(const std::unordered_set<EntityKind> &destroyKinds = {})

void ReorderEntities(const ReorderInput &input)

ReorderPlan buildReorderPlan(const ReorderInput &input)

ReorderInput resolveFollows(const ReorderInput &input, const ReorderRegistry &reg)

tLocalMatStruct GetCell2CellFaceVLocal(bool onLocalPartition = false)

void ReorderLocalCells(int nParts = 1, int nPartsInner = 1)

void ReorderLocalCellsLegacy(int nParts = 1, int nPartsInner = 1)

inline index NumCellGlobal()

inline index NumNodeGlobal()

inline index NumFaceGlobal()

inline index NumBndGlobal()

template<class tC2n> inline void _detail_GetCoords(const tC2n &c2n, tSmallCoords &cs)

template<class tC2n, class tCoordExt> inline void _detail_GetCoords(const tC2n &c2n, tSmallCoords &cs, tCoordExt &coo)

template<class tC2n, class tC2nPbi> inline void _detail_GetCoordsOnElem(const tC2n &c2n, const tC2nPbi &c2nPbi, tSmallCoords &cs)

template<class tC2n, class tC2nPbi, class tCoordExt> inline void _detail_GetCoordsOnElem(const tC2n &c2n, const tC2nPbi &c2nPbi, tSmallCoords &cs, tCoordExt &coo)

template<class FA, class FB, class F0 = std::function<void(void)>> inline auto CellOtherCellPeriodicHandle(index iFace, rowsize if2c, FA &&fA, FB &&fB, F0 &&f0 = []() {})

void ReadSerializeAndDistribute(Serializer::SerializerBaseSSP serializerP, const std::string &name, const PartitionOptions &partitionOptions)

Public Members

tCoordPair coords

tPbiPair cell2nodePbi

AdjPairTracked<tAdjPair> node2cell

AdjPairTracked<tAdjPair> cell2face

tPbiPair face2nodePbi

AdjPairTracked<tAdjPair> cell2cellFace

std::vector<index> node2parentNode

std::vector<index> vtkCell2nodeOffsets

tCoordPair coordsElevDisp

tLocalMatStruct cell2cellFaceVLocalParts

tCoordPair nodeWallDist

Public Static Functions

template<class TAdj, class TFn> static inline void ConvertAdjEntries(TAdj &adj, index nRows, TFn &&fn)

template<class TAdj, class TFn> static inline void ConvertAdjEntriesOMP(TAdj &adj, index nRows, TFn &&fn)

template<class TPair, class TFn> static inline void PermuteRows(TPair &pair, index nRows, TFn &&old2new)

struct ElevationInfo

struct HDF5OutSetting

struct WallDistOptions

template<DeviceBackend B> struct UnstructuredMeshDeviceView

Public Functions

template<class FA, class FB, class F0> inline DNDS_DEVICE_CALLABLE auto CellOtherCellPeriodicHandle(index iFace, rowsize if2c, FA &&fA, FB &&fB, F0 &&f0 = []() {})

template<class tC2n> inline DNDS_DEVICE_CALLABLE void _detail_GetCoords (const tC2n &c2n, tSmallCoords &cs)

template<class tC2n, class tCoordExt> inline DNDS_DEVICE_CALLABLE void _detail_GetCoords (const tC2n &c2n, tSmallCoords &cs, tCoordExt &coo)

template<class tC2n, class tC2nPbi> inline DNDS_DEVICE_CALLABLE void _detail_GetCoordsOnElem (const tC2n &c2n, const tC2nPbi &c2nPbi, tSmallCoords &cs)

template<class tC2n, class tC2nPbi, class tCoordExt> inline DNDS_DEVICE_CALLABLE void _detail_GetCoordsOnElem (const tC2n &c2n, const tC2nPbi &c2nPbi, tSmallCoords &cs, tCoordExt &coo)

Public Members

tCoordPair::t_deviceView<B> coords

tPbiPair::t_deviceView<B> cell2nodePbi

AdjPairTrackedDeviceView<B, tAdjPair::t_arr> cell2face

tPbiPair::t_deviceView<B> face2nodePbi

struct UnstructuredMeshSerialRW

Public Functions

template<class tC2n, class tCoordExt> inline void _detail_GetCoordsSerial(const tC2n &c2n, tSmallCoords &cs, tCoordExt &coo)

template<class tC2n, class tC2nPbi, class tCoordExt> inline void _detail_GetCoordsOnElemSerial(const tC2n &c2n, const tC2nPbi &c2nPbi, tSmallCoords &cs, tCoordExt &coo)

inline void GetCoordsOnCellSerial(index iCell, tSmallCoords &cs, tCoord &coo)

void ReadFromCGNSSerial(const std::string &fName, const t_FBCName_2_ID &FBCName_2_ID)

void BuildCell2Cell()

void BuildSerialOut()

void PrintSerialPartPltBinaryDataArray(std::string fname, int arraySiz, int arraySizPoint, const tFGetName &names, const tFGetData &data, const tFGetName &namesPoint, const tFGetData &dataPoint, double t, int flag)

void PrintSerialPartVTKDataArray(std::string fname, std::string seriesName, int arraySiz, int vecArraySiz, int arraySizPoint, int vecArraySizPoint, const tFGetName &names, const tFGetData &data, const tFGetName &vectorNames, const tFGetVecData &vectorData, const tFGetName &namesPoint, const tFGetData &dataPoint, const tFGetName &vectorNamesPoint, const tFGetVecData &vectorDataPoint, double t, int flag = 0)

namespace Adj

Variables

constexpr AdjKind Cell2Node = {EntityKind::Cell, EntityKind::Node}

constexpr AdjKind Cell2Face = {EntityKind::Cell, EntityKind::Face}

constexpr AdjKind Cell2Edge = {EntityKind::Cell, EntityKind::Edge}

constexpr AdjKind Face2Node = {EntityKind::Face, EntityKind::Node}

constexpr AdjKind Face2Edge = {EntityKind::Face, EntityKind::Edge}

constexpr AdjKind Edge2Node = {EntityKind::Edge, EntityKind::Node}

constexpr AdjKind Bnd2Node = {EntityKind::Bnd, EntityKind::Node}

constexpr AdjKind Node2Cell = {EntityKind::Node, EntityKind::Cell}

constexpr AdjKind Node2Face = {EntityKind::Node, EntityKind::Face}

constexpr AdjKind Node2Edge = {EntityKind::Node, EntityKind::Edge}

constexpr AdjKind Node2Bnd = {EntityKind::Node, EntityKind::Bnd}

constexpr AdjKind Face2Cell = {EntityKind::Face, EntityKind::Cell}

constexpr AdjKind Edge2Face = {EntityKind::Edge, EntityKind::Face}

constexpr AdjKind Edge2Cell = {EntityKind::Edge, EntityKind::Cell}

constexpr AdjKind Bnd2Cell = {EntityKind::Bnd, EntityKind::Cell}

constexpr AdjKind Bnd2Face = {EntityKind::Bnd, EntityKind::Face}

constexpr AdjKind Face2Bnd = {EntityKind::Face, EntityKind::Bnd}

constexpr AdjKind Cell2Cell = {EntityKind::Cell, EntityKind::Cell, EntityKind::Node}

constexpr AdjKind Bnd2Bnd = {EntityKind::Bnd, EntityKind::Bnd, EntityKind::Node}

constexpr AdjKind Face2Face = {EntityKind::Face, EntityKind::Face, EntityKind::Node}

constexpr AdjKind Cell2CellFace = {EntityKind::Cell, EntityKind::Cell, EntityKind::Face}

namespace Base

Typedefs

using t_diffOpIJK2I = std::tuple<int, std::array<int, 3>, std::array<std::array<int, 3>, 3>, std::array<std::array<std::array<int, 3>, 3>, 3>>

Functions

template<int dim> constexpr int ndiffSizS(int i)

template<int dim> constexpr int ndiff2order(int rows)

template<int dim, int NDiffC> constexpr t_diffOpIJK2I _get_diffOperatorIJK2I(const std::array<std::array<int, 3>, NDiffC> &diffOps)

template<int dim> constexpr auto &getDiffOperatorIJK2I()

inline real iPow(int p, real x)

template<int dim, int order> constexpr int PolynomialNDOF()

static inline real FPolynomial3D(int px, int py, int pz, int dx, int dy, int dz, real x, real y, real z)

template<class TDIBJ> void FPolynomialFill2D(TDIBJ &T, real x, real y, real z, real lx, real ly, real lz, int rows, int cols)

template<class TDIBJ> void FPolynomialFill3D(TDIBJ &T, real x, real y, real z, real lx, real ly, real lz, int rows, int cols)

template<int dim> inline int GetNDof(int maxOrder)

template<int dim = 3, int rank = 0, int powV = 1, class VLe, class VRi> real NormSymDiffOrderTensorV(VLe &&Le, VRi &&Ri)

template<int dim, int rank, class VLe, class Trans> void TransSymDiffOrderTensorV(VLe &&Le, Trans &&trans)

template<int dim, class TMat> inline void ConvertDiffsLinMap(TMat &&mat, const Geom::tGPoint &dXijdXi)

template<int dim, class TMat, class TDiBjB> inline void ConvertDiffsFullMap(TMat &&mat, TDiBjB &&DxiDx)

template<int dim, int maxDiff, class TDiBjA, class TDiBjB> void DxDxi2DxiDx(TDiBjA &&DxDxi, TDiBjB &&DxiDx)

Variables

static const int ndiff = 3

static const int ndiffSiz = 20

static const int ndiffSiz2D = 10

static const std::array<int, ndiff + 1> ndiffSizC = {1, 4, 10, 20}

static const std::array<int, ndiff + 1> ndiffSizC2D = {1, 3, 6, 10}

static const std::array<std::array<int, 3>, ndiffSiz> diffOperatorOrderList{{{{0, 0, 0}}, {{1, 0, 0}}, {{0, 1, 0}}, {{0, 0, 1}}, {{2, 0, 0}}, {{0, 2, 0}}, {{0, 0, 2}}, {{1, 1, 0}}, {{0, 1, 1}}, {{1, 0, 1}}, {{3, 0, 0}}, {{0, 3, 0}}, {{0, 0, 3}}, {{2, 1, 0}}, {{1, 2, 0}}, {{0, 2, 1}}, {{0, 1, 2}}, {{1, 0, 2}}, {{2, 0, 1}}, {{1, 1, 1}},}}

static const std::array<std::array<int, 3>, ndiffSiz2D> diffOperatorOrderList2D = {{{{0, 0, 0}}, {{1, 0, 0}}, {{0, 1, 0}}, {{2, 0, 0}}, {{1, 1, 0}}, {{0, 2, 0}}, {{3, 0, 0}}, {{2, 1, 0}}, {{1, 2, 0}}, {{0, 3, 0}},}}

static const std::array<std::array<int, ndiff>, ndiffSiz> diffOperatorDimList{{{{}}, {{0}}, {{1}}, {{2}}, {{0, 0}}, {{1, 1}}, {{2, 2}}, {{0, 1}}, {{1, 2}}, {{0, 2}}, {{0, 0, 0}}, {{1, 1, 1}}, {{2, 2, 2}}, {{0, 0, 1}}, {{0, 1, 1}}, {{1, 1, 2}}, {{1, 2, 2}}, {{0, 2, 2}}, {{0, 0, 2}}, {{0, 1, 2}},}}

static const std::array<std::array<int, ndiff>, ndiffSiz2D> diffOperatorDimList2D = {{{{}}, {{0}}, {{1}}, {{0, 0}}, {{0, 1}}, {{1, 1}}, {{0, 0, 0}}, {{0, 0, 1}}, {{0, 1, 1}}, {{1, 1, 1}},}}

static const t_diffOpIJK2I diffOperatorIJK2I = _get_diffOperatorIJK2I<3, ndiffSiz>(diffOperatorOrderList)

static const t_diffOpIJK2I diffOperatorIJK2I2D = _get_diffOperatorIJK2I<2, ndiffSiz2D>(diffOperatorOrderList2D)

static const std::array<std::array<int, ndiff + 1>, ndiff + 1> dFactorials = {{{1, 0, 0, 0}, {1, 1, 0, 0}, {1, 2, 2, 0}, {1, 3, 6, 6}}}

static const std::array<int, ndiff * 3 + 1> factorials = {1, 1, 1 * 2, 1 * 2 * 3, 1 * 2 * 3 * 4, 1 * 2 * 3 * 4 * 5, 1 * 2 * 3 * 4 * 5 * 6, 1 * 2 * 3 * 4 * 5 * 6 * 7, 1 * 2 * 3 * 4 * 5 * 6 * 7 * 8, 1 * 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9,}

static const std::array<int, ndiffSiz2D> diffNCombs2D{1, 1, 1, 1, 2, 1, 1, 3, 3, 1}

static const std::array<int, ndiffSiz> diffNCombs{1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 3, 3, 3, 3, 3, 3, 6}

class CFVPeriodicity : public DNDS::Geom::Periodicity

namespace detail

Functions

inline CellPermutationResult ComputeCellPermutation(tLocalMatStruct &cell2cellFaceV, const tAdjPair &cell2cell, index nCell, int nParts, int nPartsInner)

struct CellPermutationResult

namespace Elem

Typedefs

using tNj = Eigen::RowVector<t_real, Eigen::Dynamic>

using tD1Nj = Eigen::Matrix<t_real, 3, Eigen::Dynamic>

using tD01Nj = Eigen::Matrix<t_real, 4, Eigen::Dynamic>

using tDiNj = Eigen::Matrix<t_real, Eigen::Dynamic, Eigen::Dynamic>

using tPy_ElemType = py::enum_<ElemType>

using tElevSpan = std::array<t_index, elevSpanMaxWidth>

using tBisectSub = std::array<t_index, bisectSubMaxNodes>

using tEdgeNodes = std::array<t_index, edgeNodeMaxWidth>

using tVTKNodeOrder = std::array<int, vtkNodeOrderMax>

Enums

enum ElemType

Values:

enumerator UnknownElem

enumerator Line2

enumerator Line3

enumerator Tri3

enumerator Tri6

enumerator Quad4

enumerator Quad9

enumerator Tet4

enumerator Tet10

enumerator Hex8

enumerator Hex27

enumerator Prism6

enumerator Prism18

enumerator Pyramid5

enumerator Pyramid14

enumerator ElemType_NUM

enum ParamSpace

Values:

enumerator UnknownPSpace

enumerator LineSpace

enumerator TriSpace

enumerator QuadSpace

enumerator TetSpace

enumerator HexSpace

enumerator PrismSpace

enumerator PyramidSpace

enumerator ParamSpace_NUM

Functions

Eigen::Matrix<t_real, 3, Eigen::Dynamic> GetStandardCoord(ElemType t)

DNDS_DEVICE_CALLABLE constexpr ParamSpace ElemType_to_ParamSpace (const ElemType t)

DNDS_DEVICE_CALLABLE constexpr ElemType GetFaceType (ElemType t_v, t_index iFace)

DNDS_DEVICE_CALLABLE constexpr t_index GetNumEdges (ElemType t_v)

DNDS_DEVICE_CALLABLE constexpr ElemType GetEdgeType (ElemType t_v, t_index iEdge)

DNDS_DEVICE_CALLABLE constexpr t_real ParamSpaceVol (ParamSpace ps)

DNDS_DEVICE_CALLABLE constexpr int GetElemElevation_O1O2_NumNode (ElemType t)

DNDS_DEVICE_CALLABLE constexpr ElemType GetElemElevation_O1O2_ElevatedType (ElemType t)

DNDS_DEVICE_CALLABLE constexpr ElemType GetElemElevation_O1O2_NodeSpanType (ElemType t, t_index ine)

DNDS_DEVICE_CALLABLE constexpr ElemType GetElemO1 (ParamSpace ps)

DNDS_DEVICE_CALLABLE constexpr t_index GetO2ElemBisectNum (ElemType t)

DNDS_DEVICE_CALLABLE constexpr ElemType GetO2ElemBisectElem (ElemType t, t_index i)

static DNDS_DEVICE_CALLABLE constexpr real _iipow (real x, int y)

template<int diffOrder, class TPoint, class TArray> DNDS_DEVICE_CALLABLE void ShapeFunc_DiNj (ElemType t, const TPoint &p, TArray &&v)

inline bool cellsAreFaceConnected(const std::vector<DNDS::index> &nodes_A, const std::vector<DNDS::index> &nodes_B, Element eA, Element eB)

inline bool cellsAreFaceConnected(const std::vector<DNDS::index> &verts_A, const std::vector<DNDS::index> &nodes_B)

template<class tCoordsIn> tJacobi ShapeJacobianCoordD01Nj(const tCoordsIn &cs, Eigen::Ref<const tD01Nj> DiNj)

template<class tCoordsIn> tPoint PPhysicsCoordD01Nj(const tCoordsIn &cs, Eigen::Ref<const tD01Nj> DiNj)

template<int dim> real JacobiDetFace(Eigen::Ref<const tJacobi> J)

inline tPoint GetElemNodeMajorSpan(const tSmallCoords &coords)

inline t_index GetO2ElemBisectVariant(Element e, const tSmallCoords &coords)

template<class TIn> std::pair<int, std::vector<index>> ToVTKVertsAndData(Element e, const TIn &vin)

inline void pybind11_ElemType_define(py::module_ &m)

DNDS_DEVICE_CALLABLE constexpr t_real ParamSpaceVolume (ParamSpace ps)

DNDS_DEVICE_CALLABLE constexpr ElemType ParamSpaceO1Elem (ParamSpace ps)

template<typename Func> DNDS_DEVICE_CALLABLE constexpr decltype(auto) DispatchElementType (ElemType t, Func &&func)

inline auto GetQuadPatches(Quadrature &q)

template<int dim> real CellJacobianDet(const Geom::tSmallCoords &coordsCell, const Geom::Elem::tD01Nj &DiNj)

inline real CellJacobianDet(int dim, const Geom::tSmallCoords &coordsCell, const Geom::Elem::tD01Nj &DiNj)

template<int dim> real FaceJacobianDet(const Geom::tSmallCoords &coords, const Geom::Elem::tD01Nj &DiNj)

inline real FaceJacobianDet(int dim, const Geom::tSmallCoords &coords, const Geom::Elem::tD01Nj &DiNj)

constexpr t_index GetQuadratureScheme(ParamSpace ps, int int_order)

template<class TPoint> inline void GetQuadraturePoint(ParamSpace ps, t_index scheme, int iG, TPoint &pParam, t_real &w)

Variables

static constexpr int elevSpanMaxWidth = 8

static constexpr int bisectSubMaxNodes = 8

static constexpr int edgeNodeMaxWidth = 3

static constexpr int vtkNodeOrderMax = 27

static const int CellNumNodeMax = 27

static const t_index INT_SCHEME_Line_1 = 1

static const t_index INT_SCHEME_Line_2 = 2

static const t_index INT_SCHEME_Line_3 = 3

static const t_index INT_SCHEME_Line_4 = 4

static const t_index INT_SCHEME_Quad_1 = 1

static const t_index INT_SCHEME_Quad_4 = 4

static const t_index INT_SCHEME_Quad_9 = 9

static const t_index INT_SCHEME_Quad_16 = 16

static const t_index INT_SCHEME_Tri_1 = 1

static const t_index INT_SCHEME_Tri_3 = 3

static const t_index INT_SCHEME_Tri_6 = 6

static const t_index INT_SCHEME_Tri_7 = 7

static const t_index INT_SCHEME_Tri_12 = 12

static const t_index INT_SCHEME_Tet_1 = 1

static const t_index INT_SCHEME_Tet_4 = 4

static const t_index INT_SCHEME_Tet_8 = 8

static const t_index INT_SCHEME_Tet_14 = 14

static const t_index INT_SCHEME_Tet_24 = 24

static const t_index INT_SCHEME_Hex_1 = 1

static const t_index INT_SCHEME_Hex_8 = 8

static const t_index INT_SCHEME_Hex_27 = 27

static const t_index INT_SCHEME_Hex_64 = 64

static const t_index INT_SCHEME_Prism_1 = 1 * 1

static const t_index INT_SCHEME_Prism_6 = 3 * 2

static const t_index INT_SCHEME_Prism_18 = 6 * 3

static const t_index INT_SCHEME_Prism_21 = 7 * 3

static const t_index INT_SCHEME_Prism_48 = 12 * 4

static const t_index INT_SCHEME_Pyramid_1 = 1

static const t_index INT_SCHEME_Pyramid_8 = 8

static const t_index INT_SCHEME_Pyramid_27 = 27

static const t_index INT_SCHEME_Pyramid_64 = 64

static const int INT_ORDER_MAX = 6

struct Element

Public Functions

inline DNDS_DEVICE_CALLABLE constexpr t_index GetNumEdges () const

inline DNDS_DEVICE_CALLABLE constexpr Element ObtainEdge (t_index iEdge) const

template<class TIn, class TOut> inline void ExtractEdgeNodes(t_index iEdge, const TIn &nodes, TOut &edgeNodesOut)

template<class TIn, class TOut> inline void ExtractFaceNodes(t_index iFace, const TIn &nodes, TOut &faceNodesOut)

inline DNDS_DEVICE_CALLABLE void GetNj (const tPoint &pParam, tNj &Nj) const

inline DNDS_DEVICE_CALLABLE void GetD1Nj (const tPoint &pParam, tD1Nj &D1Nj) const

inline void GetD01Nj(const tPoint &pParam, tD01Nj &D01Nj) const

inline void GetDiNj(const tPoint &pParam, tDiNj &DiNj, int maxOrder) const

template<ElemType t> struct ElementTraits

template<> struct ElementTraits<Hex27>

template<> struct ElementTraits<Hex8>

template<> struct ElementTraits<Line2>

template<> struct ElementTraits<Line3>

template<> struct ElementTraits<Prism18>

template<> struct ElementTraits<Prism6>

template<> struct ElementTraits<Pyramid14>

template<> struct ElementTraits<Pyramid5>

template<> struct ElementTraits<Quad4>

template<> struct ElementTraits<Quad9>

template<> struct ElementTraits<Tet10>

template<> struct ElementTraits<Tet4>

template<> struct ElementTraits<Tri3>

template<> struct ElementTraits<Tri6>

struct Quadrature

Public Functions

template<class TAcc, class TFunc> inline DNDS_DEVICE_CALLABLE void Integration (TAcc &buf, TFunc &&f)

template<class TAcc, class TFunc> inline DNDS_DEVICE_CALLABLE std::enable_if_t< std::is_invocable_v< TFunc, TAcc &, int > > IntegrationSimple (TAcc &buf, TFunc &&f)

template<class TAcc, class TFunc> inline DNDS_DEVICE_CALLABLE std::enable_if_t< std::is_invocable_v< TFunc, TAcc &, int, real > > IntegrationSimple (TAcc &buf, TFunc &&f)

template<ElemType> struct ShapeFuncImpl

template<> struct ShapeFuncImpl<Hex27>

template<> struct ShapeFuncImpl<Hex8>

template<> struct ShapeFuncImpl<Line2>

template<> struct ShapeFuncImpl<Line3>

template<> struct ShapeFuncImpl<Prism18>

template<> struct ShapeFuncImpl<Prism6>

template<> struct ShapeFuncImpl<Pyramid14>

template<> struct ShapeFuncImpl<Pyramid5>

template<> struct ShapeFuncImpl<Quad4>

template<> struct ShapeFuncImpl<Quad9>

template<> struct ShapeFuncImpl<Tet10>

template<> struct ShapeFuncImpl<Tet4>

template<> struct ShapeFuncImpl<Tri3>

template<> struct ShapeFuncImpl<Tri6>

class SummationNoOp

namespace detail

Variables

static struct DNDS::Geom::Elem::detail::TNBufferAtQuadrature NBufferAtQuadrature

static constexpr std::array<std::array<t_real, 1>, 2> GaussJacobi_01A2B0_1{{{{0.250000000000000}}, {{0.333333333333333}}}}

static constexpr std::array<std::array<t_real, 2>, 2> GaussJacobi_01A2B0_2{{{{0.122514822655441, 0.544151844011225}}, {{0.232547451253508, 0.100785882079825}}}}

static constexpr std::array<std::array<t_real, 3>, 2> GaussJacobi_01A2B0_3{{{{0.072994024073150, 0.347003766038352, 0.705002209888499}}, {{0.157136361064887, 0.146246269259866, 0.029950703008581}}}}

static constexpr std::array<std::array<t_real, 4>, 2> GaussJacobi_01A2B0_4{{{{0.048500549446997, 0.238600737551862, 0.517047295104367, 0.795851417896773}}, {{0.110888415611278, 0.143458789799214, 0.068633887172923, 0.010352240749918}}}}

static constexpr std::array<std::array<t_real, 5>, 2> GaussJacobi_01A2B0_5{{{{0.034578939918215, 0.173480320771696, 0.389886387065519, 0.634333472630887, 0.851054212947016}}, {{0.081764784285771, 0.126198961899911, 0.089200161221590, 0.032055600722962, 0.004113825203099}}}}

static constexpr std::array<std::array<t_real, 1>, 2> GaussLegendre_1{{{{0}}, {{2}}}}

static constexpr std::array<std::array<t_real, 2>, 2> GaussLegendre_2{{{{-0.577350269189626, 0.577350269189626}}, {{1, 1}}}}

static constexpr std::array<std::array<t_real, 3>, 2> GaussLegendre_3{{{{-0.774596669241483, 0, 0.774596669241483}}, {{0.555555555555555, 0.888888888888889, 0.555555555555555}}}}

static constexpr std::array<std::array<t_real, 4>, 2> GaussLegendre_4{{{{-0.861136311594053, -0.339981043584856, 0.339981043584856, 0.861136311594053}}, {{0.347854845137454, 0.652145154862546, 0.652145154862546, 0.347854845137454}}}}

static constexpr std::array<std::array<t_real, 5>, 2> GaussLegendre_5{{{{-0.906179845938664, -0.538469310105683, 0, 0.538469310105683, 0.906179845938664}}, {{0.236926885056189, 0.478628670499366, 0.568888888888889, 0.478628670499366, 0.236926885056189}}}}

static constexpr std::array<std::array<t_real, 1>, 4> HammerTet_1{{{{0.25}}, {{0.25}}, {{0.25}}, {{0.1666666666666667}}}}

static constexpr std::array<std::array<t_real, 4>, 4> HammerTet_4{{{{0.1381966011250105, 0.1381966011250105, 0.5854101966249685, 0.1381966011250105}}, {{0.1381966011250105, 0.5854101966249684, 0.1381966011250105, 0.1381966011250105}}, {{0.5854101966249684, 0.1381966011250105, 0.1381966011250105, 0.1381966011250105}}, {{0.04166666666666666, 0.04166666666666666, 0.04166666666666666, 0.04166666666666666}}}}

static constexpr std::array<std::array<t_real, 8>, 4> HammerTet_8{{{{0.1069940147705369, 0.1069940147705369, 0.6790179556883893, 0.1069940147705369, 0.3280585716625127, 0.3280585716625127, 0.01582428501246191, 0.3280585716625127}}, {{0.1069940147705369, 0.6790179556883893, 0.1069940147705369, 0.1069940147705369, 0.3280585716625127, 0.01582428501246191, 0.3280585716625127, 0.3280585716625127}}, {{0.6790179556883893, 0.1069940147705369, 0.1069940147705369, 0.1069940147705369, 0.01582428501246191, 0.3280585716625127, 0.3280585716625127, 0.3280585716625127}}, {{0.01859314997209119, 0.01859314997209119, 0.01859314997209119, 0.01859314997209119, 0.02307351669457548, 0.02307351669457548, 0.02307351669457548, 0.02307351669457548}}}}

static constexpr std::array<std::array<t_real, 14>, 4> HammerTet_14{{{{0.09273525031089125, 0.09273525031089125, 0.7217942490673263, 0.09273525031089125, 0.3108859192633008, 0.3108859192633008, 0.06734224221009777, 0.3108859192633008, 0.04550370412564952, 0.4544962958743505, 0.04550370412564952, 0.04550370412564952, 0.4544962958743505, 0.4544962958743505}}, {{0.09273525031089125, 0.7217942490673263, 0.09273525031089125, 0.09273525031089125, 0.3108859192633008, 0.06734224221009777, 0.3108859192633008, 0.3108859192633008, 0.4544962958743505, 0.04550370412564952, 0.04550370412564952, 0.4544962958743505, 0.04550370412564952, 0.4544962958743505}}, {{0.7217942490673263, 0.09273525031089125, 0.09273525031089125, 0.09273525031089125, 0.06734224221009777, 0.3108859192633008, 0.3108859192633008, 0.3108859192633008, 0.4544962958743505, 0.4544962958743505, 0.4544962958743505, 0.04550370412564952, 0.04550370412564952, 0.04550370412564952}}, {{0.01224884051939367, 0.01224884051939367, 0.01224884051939367, 0.01224884051939367, 0.01878132095300264, 0.01878132095300264, 0.01878132095300264, 0.01878132095300264, 0.0070910034628469, 0.0070910034628469, 0.0070910034628469, 0.0070910034628469, 0.0070910034628469, 0.0070910034628469}}}}

static constexpr std::array<std::array<t_real, 24>, 4> HammerTet_24{{{{0.2146028712591523, 0.2146028712591523, 0.3561913862225431, 0.2146028712591523, 0.3223378901422754, 0.3223378901422754, 0.0329863295731736, 0.3223378901422754, 0.04067395853461131, 0.04067395853461131, 0.8779781243961661, 0.04067395853461131, 0.6030056647916491, 0.6030056647916491, 0.06366100187501755, 0.2696723314583158, 0.06366100187501755, 0.06366100187501755, 0.2696723314583158, 0.06366100187501755, 0.06366100187501755, 0.06366100187501755, 0.2696723314583158, 0.6030056647916491}}, {{0.2146028712591523, 0.3561913862225431, 0.2146028712591523, 0.2146028712591523, 0.3223378901422754, 0.0329863295731736, 0.3223378901422754, 0.3223378901422754, 0.04067395853461131, 0.8779781243961661, 0.04067395853461131, 0.04067395853461131, 0.06366100187501755, 0.06366100187501755, 0.06366100187501755, 0.6030056647916491, 0.2696723314583158, 0.6030056647916491, 0.06366100187501755, 0.2696723314583158, 0.06366100187501755, 0.6030056647916491, 0.06366100187501755, 0.2696723314583158}}, {{0.3561913862225431, 0.2146028712591523, 0.2146028712591523, 0.2146028712591523, 0.0329863295731736, 0.3223378901422754, 0.3223378901422754, 0.3223378901422754, 0.8779781243961661, 0.04067395853461131, 0.04067395853461131, 0.04067395853461131, 0.2696723314583158, 0.06366100187501755, 0.6030056647916491, 0.06366100187501755, 0.6030056647916491, 0.06366100187501755, 0.6030056647916491, 0.06366100187501755, 0.2696723314583158, 0.2696723314583158, 0.06366100187501755, 0.06366100187501755}}, {{0.006653791709694545, 0.006653791709694545, 0.006653791709694545, 0.006653791709694545, 0.009226196923942479, 0.009226196923942479, 0.009226196923942479, 0.009226196923942479, 0.001679535175886773, 0.001679535175886773, 0.001679535175886773, 0.001679535175886773, 0.008035714285714285, 0.008035714285714285, 0.008035714285714285, 0.008035714285714285, 0.008035714285714285, 0.008035714285714285, 0.008035714285714285, 0.008035714285714285, 0.008035714285714285, 0.008035714285714285, 0.008035714285714285, 0.008035714285714285}}}}

static constexpr std::array<std::array<t_real, 1>, 3> HammerTri_1{{{{1. / 3.}}, {{1. / 3.}}, {{1. / 2.}}}}

static constexpr std::array<std::array<t_real, 3>, 3> HammerTri_3{{{{2. / 3., 1. / 6., 1. / 6.}}, {{1. / 6., 2. / 3., 1. / 6.}}, {{1. / 6., 1. / 6., 1. / 6.}}}}

static constexpr std::array<std::array<t_real, 6>, 3> HammerTri_6{{{{0.09157621350977102, 0.8168475729804585, 0.09157621350977052, 0.445948490915965, 0.10810301816807, 0.445948490915965}}, {{0.09157621350977102, 0.09157621350977052, 0.8168475729804585, 0.445948490915965, 0.445948490915965, 0.10810301816807}}, {{0.054975871827661, 0.054975871827661, 0.054975871827661, 0.1116907948390057, 0.1116907948390057, 0.1116907948390057}}}}

static constexpr std::array<std::array<t_real, 7>, 3> HammerTri_7{{{{0.3333333333333335, 0.470142064105115, 0.05971587178977, 0.470142064105115, 0.1012865073234565, 0.7974269853530875, 0.1012865073234565}}, {{0.3333333333333335, 0.470142064105115, 0.470142064105115, 0.05971587178977, 0.1012865073234565, 0.1012865073234565, 0.7974269853530875}}, {{0.1125, 0.066197076394253, 0.066197076394253, 0.066197076394253, 0.0629695902724135, 0.0629695902724135, 0.0629695902724135}}}}

static constexpr std::array<std::array<t_real, 12>, 3> HammerTri_12{{{{0.2492867451709105, 0.501426509658179, 0.2492867451709105, 0.063089014491502, 0.8738219710169954, 0.063089014491502, 0.3103524510337845, 0.05314504984481699, 0.6365024991213986, 0.05314504984481699, 0.6365024991213986, 0.3103524510337845}}, {{0.2492867451709105, 0.2492867451709105, 0.501426509658179, 0.063089014491502, 0.063089014491502, 0.8738219710169954, 0.05314504984481699, 0.3103524510337845, 0.05314504984481699, 0.6365024991213986, 0.3103524510337845, 0.6365024991213986}}, {{0.05839313786318975, 0.05839313786318975, 0.05839313786318975, 0.0254224531851035, 0.0254224531851035, 0.0254224531851035, 0.04142553780918675, 0.04142553780918675, 0.04142553780918675, 0.04142553780918675, 0.04142553780918675, 0.04142553780918675}}}}

struct TNBufferAtQuadrature

namespace OpenFOAM

Functions

inline int passOpenFOAMSpaces(std::istream &in)

inline bool getUntil(std::istream &in, char v, std::string &buf)

inline void readOpenFOAMList(std::istream &in, const std::function<void(std::istream&)> &readOneItem)

inline void readOpenFOAMObj(std::istream &in, const std::function<void(const std::string&)> &readOneItemLine)

inline std::vector<std::string> readOpenFOAMHeader(std::istream &in)

inline std::tuple<Elem::ElemType, std::vector<index>> ExtractTopologicalElementFromPolyMeshCell(const std::vector<std::vector<index>> &facesIn, const std::vector<int> &ownIn)

struct OpenFOAMBoundaryCondition

struct OpenFOAMConverter

struct OpenFOAMReader

namespace RBF

Enums

enum RBFKernelType

Values:

enumerator UnknownRBFKernel

enumerator Distance

enumerator DistanceA1

enumerator InversedDistanceA1

enumerator InversedDistanceA1Compact

enumerator Gaussian

enumerator CPC2

enumerator CPC0

Functions

DNDS_DEFINE_ENUM_JSON (RBFKernelType, { {RBFKernelType::UnknownRBFKernel, nullptr}, {RBFKernelType::Distance, "Distance"}, {RBFKernelType::DistanceA1, "DistanceA1"}, {RBFKernelType::InversedDistanceA1, "InversedDistanceA1"}, {RBFKernelType::InversedDistanceA1Compact, "InversedDistanceA1Compact"}, {RBFKernelType::Gaussian, "Gaussian"}, {RBFKernelType::CPC2, "CPC2"}, {RBFKernelType::CPC0, "CPC0"}, }) inline bool KernelIsCompact(RBFKernelType t)

inline real GetMaxRij(const tSmallCoords &cent, const tSmallCoords &xs)

template<class TIn> inline MatrixXR FRBFBasis(TIn RiXj, RBFKernelType kernel)

template<class Tcent, class Tx> inline MatrixXR RBFCPC2(Tcent cent, Tx xs, real R, RBFKernelType kernel = Gaussian)

template<class TF> inline MatrixXR RBFInterpolateSolveCoefs(const tSmallCoords &xs, const TF fs, real R, RBFKernelType kernel = Gaussian)

template<class TF> inline MatrixXR RBFInterpolateSolveCoefsNoPoly(const tSmallCoords &xs, const TF fs, real R, RBFKernelType kernel = Gaussian)

Key Classes¶

Warning

doxygenclass: Cannot find class “DNDS::Geom::UnstructuredMesh” in doxygen xml output for project “DNDSR” from directory: /home/runner/work/DNDSR/DNDSR/build/docs/xml