DNDS Core

Core infrastructure: MPI arrays, serialization, profiling, and device support.

Key Classes

struct MPIInfo

Lightweight bundle of an MPI communicator and the calling rank’s coordinates.

The canonical “where am I in the parallel world” object passed almost everywhere in DNDSR. Cheap to copy (three ints). Two-phase construction is supported:

• default-construct, then call setWorld (or the MPI_Comm ctor) once MPI_Init has run.

Comparison (operator==) tests exact equality of the triple (comm, rank, size).

Public Functions

inline MPIInfo(MPI_Comm ncomm)

Wrap an existing MPI communicator; queries rank and size.

inline MPIInfo(MPI_Comm nc, int r, int s)

Low-level constructor for callers that already know (rank, size).

Warning

Bug: the fourth argument stores r into size too; callers currently pass matching values. Prefer the single-arg MPI_Comm ctor.

inline void setWorld()

Initialise the object to MPI_COMM_WORLD. Requires MPI_Init to have run.

inline bool operator==(const MPIInfo &r) const

Exact triple equality.

Public Members

MPI_Comm comm = MPI_COMM_NULL

The underlying MPI communicator handle.

int rank = -1

This rank’s 0-based index within comm (-1 until initialised).

int size = -1

Number of ranks in comm (-1 until initialised).

template<class T, rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
class Array : public DNDS::ArrayLayout<T, 1, 1, NoAlign>, public DNDS::ObjectNaming

Inheritance diagram for DNDS::Array:

Collaboration diagram for DNDS::Array:

Core 2D variable-length array container, the storage foundation of DNDSR.

Array is a single template that unifies five distinct storage layouts used throughout the CFD code base (cell volumes, conservative variables, mesh connectivity, reconstruction coefficients, etc.). The layout is chosen at compile time by combining _row_size and _row_max:

Subclassed by DNDS::ParArray< index, 1, 1, NoAlign >, DNDS::ParArray< real, __OneMatGetRowSize< 1, 1 >(), __OneMatGetRowSize< 1, 1 >(), NoAlign >, DNDS::ParArray< real, NonUniformSize >, DNDS::ParArray< real, NonUniformSize, NonUniformSize, NoAlign >, DNDS::ParArray< real, 1, 1, NoAlign >, DNDS::ParArray< index, _row_size, _row_size, NoAlign >, DNDS::ParArray< NodePeriodicBits, 1, 1, NoAlign >, DNDS::ParArray< real, __OneMatGetRowSize< _mat_ni, _mat_nj >(), __OneMatGetRowSize< _mat_ni, _mat_nj >(), NoAlign >, DNDS::ParArray< T, _row_size, _row_max, _align >

Public Functions

inline t_pRowStart getRowStart()

Shared pointer to the row-start index (CSR layout only).

_pRowStart->at(i) gives the flat-buffer offset of row i. Size is Size()+1; the sentinel at the end equals DataSize().

inline t_pRowSizes getRowSizes()

Shared pointer to the per-row size vector (TABLE_Max / TABLE_StaticMax).

For padded layouts, records the number of “used” columns in each row.

Array() = default

Default-constructed array: empty, no storage.

inline explicit Array(ObjName objName)

Named constructor: sets the object name for tracing/debugging. Delegates to the default constructor, then sets the name.

inline index Size() const

Number of rows currently stored. O(1).

inline rowsize RowSize() const

Uniform row width for fixed layouts (no row index needed).

Valid only for TABLE_Fixed and TABLE_StaticFixed; asserts otherwise.

Returns:

Width in number of T elements.

inline rowsize DataStride() const

Number of T elements per row in flat storage (data stride). For TABLE_StaticMax/TABLE_Max, this is _row_max (padded), not RowSize (used). Not valid for CSR (variable stride per row).

inline rowsize RowSize(index iRow) const

Width used by row iRow in number of T elements.

Works for every layout:

• TABLE_*Fixed: returns the uniform row width (iRow ignored for value);

• TABLE_*Max: returns _pRowSizes->at(iRow);

• CSR: returns pRowStart[iRow+1] - pRowStart[iRow] when compressed, else the nested vector size.

Parameters:

iRow – Row index in [0, Size()). Asserted in non-fixed layouts.

inline rowsize RowSizeMax() const

Maximum allowed row width for TABLE_Max / TABLE_StaticMax.

Returns the compile-time rm for TABLE_StaticMax or the dynamic max (_row_size_dynamic) for TABLE_Max. Asserts for other layouts.

inline rowsize RowSizeField() const

“Logical” row-field width used by derived (Eigen) arrays: max for padded layouts, uniform width for fixed layouts. Not valid for CSR.

inline rowsize RowSizeField(index iRow) const

Per-row “field” size for CSR (= actual row width). Invalid elsewhere.

inline bool IfCompressed() const

(CSR only) Whether the array is in packed / flat form.

true means data sits in a single _data buffer plus _pRowStart; false means rows live in a vector<vector<T>> (_dataUncompressed), which allows per-row ResizeRow(). MPI / serialization / CUDA require the compressed form &#8212; call Compress() first.

inline void CSRDecompress()

(CSR only) Switch to the uncompressed (nested vector) representation.

Copies each row out of the flat buffer into an entry of _dataUncompressed, then clears the flat buffer. No-op if already uncompressed. After this, ResizeRow and ReserveRow may be used to reshape individual rows.

inline void CSRCompress()

(CSR only) Pack the nested-vector representation into a flat buffer plus _pRowStart. No-op if already compressed.

Row widths are frozen; further per-row resizing requires another Decompress. Mandatory before MPI ghost exchange, CUDA transfer, or serialization.

inline void Compress()

Layout-polymorphic compress: no-op for non-CSR, calls CSRCompress for CSR.

inline void Decompress()

Layout-polymorphic decompress: no-op for non-CSR, calls CSRDecompress for CSR.

inline t_Data &RawDataVector()

Access to the underlying flat buffer (host_device_vector<T>).

For CSR, asserts that the array is compressed. Mutating the buffer bypasses all row-size bookkeeping &#8212; use with care.

inline void Resize(index nSize, rowsize nRow_size_dynamic)

Resize the array, setting a uniform or maximum row width.

Invalidates all existing data and resets row-size metadata.

Layout-specific semantics:

• TABLE_StaticFixed: nRow_size_dynamic must equal rs.

• TABLE_StaticMax: nRow_size_dynamic must equal rm.

• TABLE_Fixed: sets the runtime uniform row width.

• TABLE_Max: sets the runtime maximum row width (per-row sizes start at 0).

• CSR: requires the array to be decompressed; allocates nSize empty rows (nested vectors sized to nRow_size_dynamic).

Parameters:

• nSize – New number of rows.

• nRow_size_dynamic – Row width (uniform layouts) or max width (padded layouts) or initial row length (CSR).

inline void Resize(index nSize)

Resize using only the row count (layouts with an implicit row width).

Valid for:

• TABLE_StaticFixed / TABLE_StaticMax (width comes from template params);

• CSR decompressed (rows start empty, grow via ResizeRow). Asserts for other layouts &#8212; use the two-argument overload instead.

Parameters:

nSize – New number of rows.

template<class TFRowSize>
inline void Resize(index nSize, TFRowSize &&FRowSize)

Resize a CSR array directly to the compressed form via a width functor.

CSR-only. Allocates nSize+1 _pRowStart entries populated from the prefix sum of FRowSize(i), then sizes the flat buffer to match. No nested-vector intermediate step; the array is compressed on return.

Template Parameters:

TFRowSize – Callable with signature rowsize(index).

Parameters:

• nSize – New number of rows.

• FRowSize – Width-of-row-i functor.

inline void ResizeRow(index iRow, rowsize nRowSize)

Change the width of a single row.

Valid for CSR (decompressed only) and TABLE_*Max. For TABLE_*Max, the new size must not exceed the configured maximum and the per-row-size vector is copied-on-write if shared with another array. For CSR, the array must be uncompressed; call Decompress first.

Parameters:

• iRow – Row index in [0, Size()).

• nRowSize – New width in T elements.

inline void ReserveRow(index iRow, rowsize nRowSize)

Reserve capacity for a CSR decompressed row without changing its size.

Analogous to std::vector::reserve for the nested row buffer. CSR-only, decompressed-only.

inline t_View view()

Produce a lightweight, device-agnostic view onto the array.

The returned ArrayView captures pointers and sizes but does not own any storage. It is the type that implements actual operator[] indexing for all layouts; it is also host/device-callable and is the building block for ArrayDeviceView on CUDA.

inline const T &at(index iRow, rowsize iCol) const

Bounds-checked element access.

Asserts that iRow and iCol are in range (taking the used row size into account, not just the stride). Works for every layout.

Parameters:

• iRow – Row index in [0, Size()).

• iCol – Column index in [0, RowSize(iRow)).

inline T &operator()(index iRow, rowsize iCol = 0)

Bounds-checked 2D element access (writable).

Convenience wrapper around at. iCol defaults to 0 so arr(i) accesses the first column, useful for single-column layouts.

inline const T &operator()(index iRow, rowsize iCol = 0) const

Bounds-checked 2D element access (read-only).

inline T *operator[](index iRow)

Return a raw pointer to the start of row iRow.

Fast, untyped access used by stencil loops. Derived classes (e.g. ArrayEigenVector, ArrayEigenMatrix) override this to return typed Eigen maps instead of T*.

Parameters:

iRow – Row index. For CSR compressed, iRow == Size() is allowed and returns the past-the-end pointer, useful for computing the flat buffer end in sweeps.

Returns:

Pointer to the first element of row iRow.

inline const T *operator[](index iRow) const

Const row pointer, see the non-const overload.

inline T *data(DeviceBackend B = DeviceBackend::Unknown)

Raw pointer to the flat data buffer.

Parameters:

B – Target device. DeviceBackend::Unknown (default) returns the host pointer; otherwise returns the device pointer (must match the array’s current device).

inline size_t DataSize() const

Total number of T elements currently stored in the flat buffer.

For CSR, requires the array to be compressed.

inline size_t DataSizeBytes() const

Flat buffer size in bytes (= DataSize() * sizeof(T)).

inline void CopyRowFrom(index dstRow, const self_type &src, index srcRow)

Copy raw row data from another Array of the same type. Works for all layouts (StaticFixed, Fixed, CSR, etc.) and is not hidden by derived types that make operator()/operator[] private.

template<class TRowSizeFunc>
inline void ResizeRowsAndCompress(TRowSizeFunc &&rowSizeFunc)

Set per-row sizes from a source, applying an index mapping, then compress. For CSR layout only. rowSizeFunc(i) returns the desired row size for row i. Not hidden by derived types that make ResizeRow private.

inline size_t FullSizeBytes() const

Total footprint in bytes including structural arrays.

Sums the flat data buffer, _pRowStart (if any), and _pRowSizes (if any). Approximate because shared-ownership of row structures is not deduplicated.

inline std::size_t hash()

Combined hash of size, structural arrays, and data.

Byte-hashes non-hashable elements. Intended for testing / equality diagnostics; not guaranteed cryptographically strong.

inline constexpr DataLayout GetDataLayout()

Runtime accessor for the layout tag (constexpr-folded).

inline void clone(const self_type &R)

Shallow clone: copies all metadata and shares structural/data storage.

Copies _size, _row_size_dynamic, device backend, and the nested-vector storage. The _data, _pRowStart, _pRowSizes members are host_device_vector / shared_ptr, so they share ownership with the source; subsequent modifications to one may affect the other.

inline void CopyData(const self_type &R)

Deep copy alias. Currently delegates to clone; kept for API compatibility and to allow a future true deep-copy implementation.

inline self_type &operator=(const self_type &R)

Copy-assignment; implemented via clone with self-assign guard.

inline Array(const self_type &R)

Copy constructor (same semantics as clone).

inline void SwapData(self_type &R)

Swap the storage of two arrays in-place.

Both arrays must already have identical logical size and flat-buffer size. Swaps only what the current layout uses (flat buffer plus structural pointers, or the nested vectors for CSR decompressed).

inline void WriteSerializer(Serializer::SerializerBaseSSP serializerP, const std::string &name, Serializer::ArrayGlobalOffset offset, Serializer::ArrayGlobalOffset dataOffset = Serializer::ArrayGlobalOffset_Unknown)

Serialize (write) array data to a serializer.

Writes metadata (array_sig, array_type, size, row_size_dynamic), structural data (pRowStart for CSR, pRowSizes for TABLE_Max/StaticMax), and the flat data buffer into a sub-path name under the serializer’s current path.

This method is called by ParArray::WriteSerializer. Users should call the ParArray version, which handles MPI coordination and CSR global offsets.

Parameters:

• serializerP – Serializer instance (JSON per-rank or H5 collective).

• name – Sub-path name under which the array is stored.

• offset – [in] Row-level partitioning offset. Typically Parts (serializer computes per-rank offsets automatically).

• dataOffset – [in] Element-level data range for this rank.

  • Per-rank or non-CSR: Unknown (default). Array writes pRowStart in local coordinates.

  • Collective CSR: must be isDist() = {localDataCount, globalDataStart}, computed by ParArray via MPI_Scan. Array skips pRowStart (ParArray writes it separately in global coordinates). Asserted for collective CSR.

inline void ReadSerializer(Serializer::SerializerBaseSSP serializerP, const std::string &name, Serializer::ArrayGlobalOffset &offset)

Convenience overload that discards the dataOffset output.

See also

ReadSerializer(SerializerBaseSSP, const std::string&, ArrayGlobalOffset&, ArrayGlobalOffset&)

inline void ReadSerializer(Serializer::SerializerBaseSSP serializerP, const std::string &name, Serializer::ArrayGlobalOffset &offset, Serializer::ArrayGlobalOffset &dataOffset)

Deserialize (read) array data from a serializer.

Reads metadata (array_sig, size, row_size_dynamic), structural data (pRowStart for CSR, pRowSizes for TABLE_Max/StaticMax), and the flat data buffer from a sub-path name under the serializer’s current path.

This method is called by ParArray::ReadSerializer. Users should call the ParArray version, which handles EvenSplit resolution and CSR offset computation.

Input offset must NOT be EvenSplit; ParArray resolves that before calling.

Parameters:

• serializerP – Serializer instance (JSON per-rank or H5 collective).

• name – Sub-path name for this array.

• offset – [in/out] Row-level offset.

  • In: Unknown (same-np, serializer uses rank_offsets) or isDist({localRows, globalRowStart}).

  • Out: updated to the resolved row-level position after reading (derived from dataOffset / DataStride for non-CSR).

• dataOffset – [out] Element-level data offset resolved during the read.

  • Per-rank or Unknown offset: stays Unknown.

  • Collective isDist non-CSR: {localRows * DataStride(), globalRowStart * DataStride()}.

  • Collective CSR: {localDataCount, globalDataStart}, derived from the stored global pRowStart.

inline ReadSerializerMetaResult ReadSerializerMeta(Serializer::SerializerBaseSSP serializerP, const std::string &name)

Reads only metadata from a serialized array without reading data.

Navigates to sub-path name and reads array_sig, row_size_dynamic, and size. Does NOT read structural data (pRowStart, pRowSizes) or the flat data buffer. The array’s internal state is not modified.

Derived types (ArrayEigenMatrix, ArrayEigenUniMatrixBatch) override this method to also read their own extra metadata and to call the base version with the “array” sub-path they wrap around the base Array serialization.

Parameters:

• serializerP – Serializer instance.

• name – Sub-path name for this array.

Returns:

Metadata: array_sig, row_size_dynamic, size (local size for per-rank; 0 for collective without ParArray).

inline void __ReadSerializerStructuralAndResolveDataOffset(const Serializer::SerializerBaseSSP &serializerP, Serializer::ArrayGlobalOffset &offset, Serializer::ArrayGlobalOffset &dataOffset)

Reads structural data (pRowStart / pRowSizes) and resolves dataOffset.

After metadata has been read and _size / _row_size_dynamic set, this method reads layout-specific structural data from the serializer and computes the element-level dataOffset from the row-level offset.

Parameters:

• serializerP – Serializer instance (already at the array’s sub-path).

• offset – [in/out] Row-level offset; updated for non-CSR if dataOffset could be derived.

• dataOffset – [out] Element-level data offset resolved from structural data (CSR: from global pRowStart; non-CSR: offset * DataStride).

inline void __ReadSerializerDataAndPropagateOffset(const Serializer::SerializerBaseSSP &serializerP, Serializer::ArrayGlobalOffset &offset, Serializer::ArrayGlobalOffset &dataOffset)

Reads flat data and propagates resolved offsets back to the caller.

Parameters:

• serializerP – Serializer instance (already at the array’s sub-path).

• offset – [in/out] Row-level offset; updated from dataOffset for non-CSR.

• dataOffset – [in/out] Element-level data offset; may be updated from Unknown to Parts-resolved by __ReadSerializerData.

inline void to_host()

Mirror the flat/structural buffers back to host memory.

CSR arrays must be compressed before calling. After this the array still has a device mirror unless clear_device is also called.

inline void to_device(DeviceBackend backend = DeviceBackend::Host)

Mirror the flat/structural buffers to a target device (e.g. CUDA).

CSR arrays must be compressed. backend must match a supported backend from DeviceBackend; see DeviceStorage.hpp.

inline void clear_device()

Release any device-side mirror of this array’s buffers.

template<DeviceBackend B>
inline t_deviceView<B> deviceView()

Mutable device-callable view (Eigen::Map-style row access on GPU).

Template Parameters:

B – Device backend; must either match the array’s current device or be DeviceBackend::Host (which yields a host-backed view).

template<DeviceBackend B>
inline t_deviceViewConst<B> deviceView() const

Const device-callable view. See non-const overload.

inline DeviceBackend device() const

Current device backend the data is mirrored on, or Unknown if host-only.

template<DeviceBackend B>
inline iterator<B> begin()

Iterator to the first row, viewed on device backend B.

template<DeviceBackend B>
inline iterator<B> end()

Iterator one past the last row, viewed on device backend B.

Public Static Functions

static inline constexpr DataLayout GetDataLayoutStatic()

Compile-time layout tag (one of TABLE_StaticFixed, TABLE_Fixed, TABLE_StaticMax, TABLE_Max, CSR).

Friends

inline friend std::ostream &operator<<(std::ostream &o, const Array<T, _row_size, _row_max, _align> &A)

Pretty-print rows, one per line, tab-separated.

template<DeviceBackend B>
class iterator : public DNDS::ArrayIteratorBase<iterator<B>>

Inheritance diagram for DNDS::Array::iterator:

Collaboration diagram for DNDS::Array::iterator:

Random-access iterator over rows for a given device backend.

operator* yields a RowView {pointer, rowSize}. Used by std::transform / CUDA kernels that sweep over rows.

struct ReadSerializerMetaResult

Inheritance diagram for DNDS::Array::ReadSerializerMetaResult:

Collaboration diagram for DNDS::Array::ReadSerializerMetaResult:

Result type for ReadSerializerMeta.

Derived array types can extend this struct to carry additional metadata fields (e.g., mat_nRow_dynamic from ArrayEigenMatrix).

Subclassed by DNDS::ArrayEigenUniMatrixBatch< _n_row, _n_col >::ReadSerializerMetaResult

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

Inheritance diagram for DNDS::ParArray:

Collaboration diagram for DNDS::ParArray:

MPI-aware Array: adds a communicator, rank, and global index mapping.

Inherits everything from Array and layers on:

• an MPIInfo mpi context;

• a GlobalOffsetsMapping pLGlobalMapping that maps local row indices to the global index space (populated by createGlobalMapping);

• collective serialization I/O that coordinates writes / reads across ranks.

Typical usage:

auto father = std::make_shared<ParArray<real, 5>>(mpi);
father->Resize(nLocal);
father->createGlobalMapping();         // collective
index nGlobal = father->globalSize();  // total rows across ranks

Ghost (halo) data is not managed here; pair with ArrayTransformer or wrap in an ArrayPair for that.

See also

ArrayTransformer, ArrayPair, docs/architecture/array_infrastructure.md.

Subclassed by DNDS::ArrayAdjacency< 1 >, DNDS::ArrayEigenMatrix< nVarsFixed, nVarsFixed >, DNDS::ArrayAdjacency< _row_size, _row_max, _align >, DNDS::ArrayEigenMatrix< _mat_ni, _mat_nj, _mat_ni_max, _mat_nj_max, _align >, DNDS::ArrayEigenVector< _vec_size, _row_max, _align >, DNDS::Geom::ArrayNodePeriodicBits< _row_size, _row_max, _align >

Public Functions

inline void clone(const t_self &R)

Copy-assign from another ParArray. Shallow copy semantics (mirrors Arrayclone): shares structural/data buffers.

inline void WriteSerializer(Serializer::SerializerBaseSSP serializerP, const std::string &name, Serializer::ArrayGlobalOffset offset)

Serialize (write) the parallel array with MPI-aware metadata.

Delegates to Array::WriteSerializer for metadata, structure, and data. Additionally for collective (H5) serializers:

• Writes sizeGlobal (sum of all ranks’ _size) as a scalar attribute.

• For CSR: computes global data offsets via MPI_Scan and writes pRowStart in global data coordinates as a contiguous (nRowsGlobal+1) dataset. Non-last ranks write nRows entries (dropping the redundant tail), last rank writes nRows+1 (including the global data total).

Asserts MPI context consistency with the serializer.

Parameters:

• serializerP – Serializer instance.

• name – Sub-path name for this array.

• offset – [in] Row-level partitioning (typically ArrayGlobalOffset_Parts).

inline void ReadSerializer(Serializer::SerializerBaseSSP serializerP, const std::string &name, Serializer::ArrayGlobalOffset &offset)

Deserialize (read) the parallel array with MPI-aware metadata.

Resolves the input offset before delegating to Array::ReadSerializer:

• EvenSplit: reads sizeGlobal, computes even-split range, resolves to isDist({localRows, globalRowStart}).

• CSR with collective serializer: reads per-rank size, computes row offset via MPI_Scan, resolves to isDist. This is required because CSR pRowStart is stored in global coordinates.

• Otherwise: passes offset through unchanged.

Asserts MPI context consistency with the serializer.

Parameters:

• serializerP – Serializer instance.

• name – Sub-path name for this array.

• offset – [in/out] Row-level offset. EvenSplit is resolved here. After return, reflects the resolved row-level position.

inline MPI_Datatype getDataType()

MPI element datatype used for ghost exchange (deduced from T).

inline MPI_int getTypeMult()

Per-element count multiplier that goes with getDataType.

inline void setMPI(const MPIInfo &n_mpi)

Install the MPI context after default construction.

Calls AssertDataType to verify the deduced datatype / multiplier match sizeof(T).

inline MPIInfo &getMPI()

Mutable MPI context accessor.

inline const MPIInfo &getMPI() const

Read-only MPI context accessor.

inline void setDataType(MPI_Datatype n_dType, MPI_int n_TypeMult)

Override the deduced MPI datatype and element multiplier (advanced; needed for custom compound element types).

ParArray() = default

Default-construct an uninitialised ParArray; call setMPI and Resize later.

inline ParArray(const MPIInfo &n_mpi)

Construct a ParArray bound to the given MPI context.

inline ParArray(MPI_Datatype n_dType, MPI_int n_TypeMult, const MPIInfo &n_mpi)

Construct with a custom (MPI datatype, multiplier) pair.

Useful for element types whose in-memory layout differs from the default BasicType_To_MPIIntType<T>() deduction.

template<typename ...Args>
inline ParArray(ObjName objName, Args&&... args)

Named constructor: sets the object name for tracing/debugging. All existing constructor overloads are supported via perfect forwarding. Inherited by derived classes (ArrayAdjacency, ArrayEigenVector, etc.) through using t_base::t_base.

Usage: ParArray<index> arr(ObjName{“cell2node”}, mpi); ArrayAdjacency<> adj(ObjName{“cell2cell”}, mpi);

inline void AssertDataType()

Assert the MPI datatype matches sizeof(T) exactly.

Called from constructors / setMPI / setDataType. Guards against size mismatches that would silently corrupt comms.

inline bool AssertConsistent()

Check array consistency across all ranks.

Uses MPI_Allgather to verify that row sizes (for TABLE_Fixed and TABLE_Max layouts) and MPI type multipliers are the same on every rank. Intended as a post-setup sanity check before entering ghost exchange.

Warning

Must be called collectively. O(nRanks) memory and communication.

Returns:

true Always (failures are reported via DNDS_check_throw_info).

inline void createGlobalMapping()

Collective: build the global offsets table.

Every rank broadcasts its local Size(); after the call, pLGlobalMapping holds the full GlobalOffsetsMapping::RLengths / GlobalOffsetsMapping::ROffsets on every rank. Must be invoked before globalSize, ArrayTransformercreateFatherGlobalMapping, or any CSR collective serialization.

Warning

Must be called collectively on mpi.comm.

inline index globalSize() const

Returns the total global size (sum of sizes across all ranks).

Note

This method was previously collective (using MPI_Allreduce) but is now non-collective. It requires that the global mapping has been created first (which is done via the collective createGlobalMapping() method on the underlying ParArray).

Pre:

createGlobalMapping() must have been called on the underlying array.

Returns:

index The global size (cached from global mapping).

Array() = default

Default-constructed array: empty, no storage.

inline explicit Array(ObjName objName)

Named constructor: sets the object name for tracing/debugging. Delegates to the default constructor, then sets the name.

inline Array(const self_type &R)

Copy constructor (same semantics as clone).

Public Members

t_pLGlobalMapping pLGlobalMapping

Shared pointer to the global-offsets table. Populated by createGlobalMapping; may be pointed at an existing table to skip the collective setup.

MPIInfo mpi

MPI context associated with this array (must be set before collectives).

template<class T, rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
class ArrayTransformer

Collaboration diagram for DNDS::ArrayTransformer:

Ghost-communication engine for a father / son ParArray pair.

Distributed-mesh stencil schemes need data from cells owned by other ranks. ArrayTransformer stores two ParArray pointers &#8212; the father (owned rows) and the son (incoming ghost rows) &#8212; plus the MPI machinery to move data between them.

Public Functions

inline TSelf &operator=(const TSelf &R)

Copy-assign the transformer state. Persistent requests are re-created rather than shared because they point to different memory than the source object.

ArrayTransformer() = default

Default-construct an empty transformer; attach arrays later via setFatherSon.

inline ArrayTransformer(const TSelf &R)

Copy-construct via operator=.

inline void setFatherSon(const t_pArray &n_father, const t_pArray &n_son)

Attach father and son arrays. First setup step.

Both arrays must share the same MPI context and element MPI datatype. The transformer cannot be used until the remaining setup calls (createFatherGlobalMapping, createGhostMapping, createMPITypes) have run.

Parameters:

• n_father – Owned-side array (must not be null).

• n_son – Ghost-side array (must not be null).

template<class TRArrayTrans>
inline void BorrowGGIndexing(const TRArrayTrans &RArrayTrans)

Borrow the ghost and global mapping from another transformer.

Intended for the common case where several arrays share the same partition (e.g., the DOF array and the gradient array both live on the same cell partitioning). Copies the shared pointers &#8212; no collective work is performed. After this call, createMPITypes still needs to be invoked because the element size differs.

Template Parameters:

TRArrayTrans – A compatible transformer type; must expose father, pLGhostMapping, pLGlobalMapping.

inline void createFatherGlobalMapping()

Collective: build the global offsets table on the father array.

Thin wrapper over father->createGlobalMapping() that also caches the pointer in this transformer. Second setup step.

template<class TPullSet>
inline void createGhostMapping(TPullSet &&pullingIndexGlobal)

create ghost by pulling data

pulling data indicates the data put in son (received in pulling operation) pullingIndexGlobal is the global indices in son pullingIndexGlobal should be mutually different, otherwise behavior undefined

Warning

pullingIndexGlobal is sorted and deduplicated in-place by OffsetAscendIndexMapping. After this call the input vector’s element order is destroyed. If you need to keep the original order (e.g., for a redistribution mapping), save a copy before calling this method. The son array after pullOnce() will contain data in the sorted order of pullingIndexGlobal, NOT in the original input order.

template<class TPushSet, class TPushStart>
inline void createGhostMapping(TPushSet &&pushingIndexLocal, TPushStart &&pushStarts)

Create the ghost mapping from a push specification. Collective.

Each rank supplies, grouped per receiver, the local indices it will push to that receiver. Row i of this rank’s father will be sent to every rank listed for i across the CSR (pushingIndexLocal, pushStarts). The son array is resized to hold the incoming entries on return from createMPITypes.

Warning

Each local index must appear at most once across the entire CSR, otherwise the resulting ghost layout is undefined.

Parameters:

• pushingIndexLocal – Flat vector of local indices to push, grouped by receiver in ascending rank order.

• pushStarts – Prefix-sum offsets into pushingIndexLocal, size mpi.size + 1.

inline void createMPITypes()

Collective: build the MPI derived datatypes (or in-situ buffers) that describe the ghost send/recv layout. Resizes the son array.

Fourth (and final) setup step. Consumes the per-rank push sizes and the ghost mapping produced by createGhostMapping, then:

• for HIndexed: builds MPI_Type_create_hindexed types that describe the scattered memory layout of the rows being sent and received;

• for InSituPack: allocates contiguous pack buffers.

Also resizes son to hold exactly the incoming ghost rows.

Pre:

father, son, pLGlobalMapping, pLGhostMapping are set.

Post:

pPullTypeVec and pPushTypeVec (or the in-situ buffers) are valid; son has been resized.

inline void initPersistentPush(DeviceBackend B = DeviceBackend::Unknown)

Initialise persistent, non-blocking, non-buffered MPI requests for the push direction (son -> father).

Once persistent requests are created, many push cycles may be run via startPersistentPush / waitPersistentPush without re-posting sends and receives.

Warning

After init, the raw data pointers of both father and son must remain stable until clearPersistentPush is called.

Parameters:

B – Device backend for the send/recv buffers (DeviceBackend::Unknown to use host; requires CUDA-aware MPI for non-host backends).

Pre:

createMPITypes has been called; pPullTypeVec and pPushTypeVec are valid.

Post:

PushReqVec is populated with MPI_Send_init / MPI_Recv_init requests.

inline void initPersistentPull(DeviceBackend B = DeviceBackend::Unknown)

Initialise persistent, non-blocking MPI requests for the pull direction (father -> son). Counterpart to initPersistentPush.

Warning

Raw data pointers for both father and son must remain stable until clearPersistentPull.

Parameters:

B – Device backend for the send/recv buffers.

Pre:

createMPITypes has been called; pPullTypeVec and pPushTypeVec are valid.

Post:

PullReqVec is populated.

inline void startPersistentPush(DeviceBackend B = DeviceBackend::Unknown)

Start all persistent push requests (MPI_Startall).

Parameters:

B – Device backend; must match the one passed to initPersistentPush.

inline void startPersistentPull(DeviceBackend B = DeviceBackend::Unknown)

Start all persistent pull requests (MPI_Startall).

After this call the sends/recvs are in flight; call waitPersistentPull to consume the incoming ghost data.

Parameters:

B – Device backend; must match the one passed to initPersistentPull.

inline void waitPersistentPush(DeviceBackend B = DeviceBackend::Unknown)

Wait for all outstanding persistent push requests to complete.

inline void waitPersistentPull(DeviceBackend B = DeviceBackend::Unknown)

Wait for all outstanding persistent pull requests. After this returns, the son array holds fresh ghost data.

inline void clearPersistentPush()

Wait on outstanding push requests then free them.

inline void clearPersistentPull()

Wait on outstanding pull requests then free them.

inline void clearMPITypes()

Release the MPI derived datatypes built by createMPITypes. Rebuild with another call if you wish to continue using the transformer.

inline void clearGlobalMapping()

Drop the shared pointer to the global offsets table.

inline void clearGhostMapping()

Drop the ghost mapping (pLGhostMapping).

inline void pullOnce()

Convenience: init + start + wait + clear a single pull.

Suitable when ghosts are updated only once (e.g., post-restart); use the persistent API in hot loops.

inline void pushOnce()

Convenience: init + start + wait + clear a single push.

inline void reInitPersistentPullPush()

Re-initialise persistent requests; useful after rebuilding MPI types but wanting to resume persistent comms. Idempotent w.r.t. whichever direction(s) were previously initialised.

Public Members

MPIInfo mpi

MPI context; copied from the attached father array.

t_pLGhostMapping pLGhostMapping

Ghost index mapping (rank-local layout). Populated by createGhostMapping.

t_pArray father

The “owned” side of the father/son pair.

t_pArray son

The “ghost” side of the father/son pair (receives from other ranks).

t_pLGlobalMapping pLGlobalMapping

Shared pointer to the global offsets table (shared with father).

ssp<tMPI_typePairVec> pPushTypeVec

Cached (count, MPI_Datatype) pairs for push (son -> father).

ssp<tMPI_typePairVec> pPullTypeVec

Cached (count, MPI_Datatype) pairs for pull (father -> son).

ssp<MPIReqHolder> PushReqVec

Persistent request handles for push.

ssp<MPIReqHolder> PullReqVec

Persistent request handles for pull.

DeviceBackend pushDevice = DeviceBackend::Unknown

Device currently holding push buffers (Unknown if not initialised).

DeviceBackend pullDevice = DeviceBackend::Unknown

Device currently holding pull buffers (Unknown if not initialised).

MPI_int nRecvPushReq = {-1}

Number of receive requests in PushReqVec (the rest are sends).

MPI_int nRecvPullReq = {-1}

Number of receive requests in PullReqVec.

tMPI_statVec PushStatVec

Status buffer for push completion.

tMPI_statVec PullStatVec

Status buffer for pull completion.

MPI_Aint pushSendSize

Total bytes sent per push call (for buffer sizing).

MPI_Aint pullSendSize

Total bytes sent per pull call.

tMPI_intVec pushingSizes

temp: per-peer count for createMPITypes.

tMPI_AintVec pushingDisps

temp: per-peer byte displacements for createMPITypes.

std::vector<index> pushingIndexLocal

for InSituPack strategy

std::vector<std::vector<T>> inSituBuffer

for InSituPack strategy

Warning

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

Namespace Overview

namespace DNDS

Typedefs

template<class T, rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
using tPy_Array = py_class_ssp<Array<T, _row_size, _row_max, _align>>

template<class T, rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
using tPy_ParArray = py_class_ssp<ParArray<T, _row_size, _row_max, _align>>

template<class TArray>
using tPy_ArrayTransformer = py_class_ssp<ArrayTransformerType_t<TArray>>

template<class T, rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
using tPy_ParArrayPair = py_class_ssp<ArrayPair<ParArray<T, _row_size, _row_max, _align>>>

template<rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
using tPy_ArrayAdjacency = py_class_ssp<ArrayAdjacency<_row_size, _row_max, _align>>

template<rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
using tPy_ArrayAdjacencyPair = py_class_ssp<ArrayAdjacencyPair<_row_size, _row_max, _align>>

template<rowsize _mat_ni = 1, rowsize _mat_nj = 1, rowsize _mat_ni_max = _mat_ni, rowsize _mat_nj_max = _mat_nj, rowsize _align = NoAlign>
using tPy_ArrayEigenMatrix = py_class_ssp<ArrayEigenMatrix<_mat_ni, _mat_nj, _mat_ni_max, _mat_nj_max, _align>>

template<rowsize _mat_ni = 1, rowsize _mat_nj = 1, rowsize _mat_ni_max = _mat_ni, rowsize _mat_nj_max = _mat_nj, rowsize _align = NoAlign>
using tPy_ArrayEigenMatrixPair = py_class_ssp<ArrayEigenMatrixPair<_mat_ni, _mat_nj, _mat_ni_max, _mat_nj_max, _align>>

using tPy_ArrayEigenMatrixBatch = py_class_ssp<ArrayEigenMatrixBatch>

using tPy_ArrayEigenMatrixBatchPair = py_class_ssp<ArrayEigenMatrixBatchPair>

template<int _n_row, int _n_col>
using tPy_ArrayEigenUniMatrixBatch = py_class_ssp<ArrayEigenUniMatrixBatch<_n_row, _n_col>>

template<int _n_row, int _n_col>
using tPy_ArrayEigenUniMatrixBatchPair = py_class_ssp<ArrayEigenUniMatrixBatchPair<_n_row, _n_col>>

template<rowsize _vec_size = 1, rowsize _row_max = _vec_size, rowsize _align = NoAlign>
using tPy_ArrayEigenVector = py_class_ssp<ArrayEigenVector<_vec_size, _row_max, _align>>

template<rowsize _vec_size = 1, rowsize _row_max = _vec_size, rowsize _align = NoAlign>
using tPy_ArrayEigenVectorPair = py_class_ssp<ArrayEigenVectorPair<_vec_size, _row_max, _align>>

template<int n_m, int n_n>
using tPy_ArrayDOF = py_class_ssp<ArrayDof<n_m, n_n>>

template<rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
using ArrayAdjacencyPair = ArrayPair<ArrayAdjacency<_row_size, _row_max, _align>>

template<rowsize _vec_size = 1, rowsize _row_max = _vec_size, rowsize _align = NoAlign>
using ArrayEigenVectorPair = ArrayPair<ArrayEigenVector<_vec_size, _row_max, _align>>

template<rowsize _mat_ni = 1, rowsize _mat_nj = 1, rowsize _mat_ni_max = _mat_ni, rowsize _mat_nj_max = _mat_nj, rowsize _align = NoAlign>
using ArrayEigenMatrixPair = ArrayPair<ArrayEigenMatrix<_mat_ni, _mat_nj, _mat_ni_max, _mat_nj_max, _align>>

using ArrayEigenMatrixBatchPair = ArrayPair<ArrayEigenMatrixBatch>

template<int _n_row, int _n_col>
using ArrayEigenUniMatrixBatchPair = ArrayPair<ArrayEigenUniMatrixBatch<_n_row, _n_col>>

using t_pLGlobalMapping = ssp<GlobalOffsetsMapping>

using t_pLGhostMapping = ssp<OffsetAscendIndexMapping>

template<class TArray>
using ArrayTransformerType_t = typename ArrayTransformerType<TArray>::Type

using CrossFieldCheck = std::function<CheckResult(const void *obj)>

using ContextualCheck = std::function<CheckResult(const void *obj, const ConfigContext &ctx)>

using tLogSimpleDIValueMap = std::map<std::string, LogSimpleDIValue>

using real = double

using index = int64_t

using rowsize = int32_t

using real_sized_index = int64_t

using real_half_sized_index = int32_t

template<typename T>
using ssp = std::shared_ptr<T>

template<typename T>
using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>

using t_RowsizeVec = std::vector<rowsize>

using t_IndexVec = std::vector<index>

using t_pIndexVec = ssp<t_IndexVec>

using t_indexerPair = std::tuple<index, index>

using tDiFj = Eigen::Matrix<real, -1, -1, Eigen::RowMajor>

using MatrixXR = Eigen::Matrix<real, Eigen::Dynamic, Eigen::Dynamic>

using VectorXR = Eigen::Vector<real, Eigen::Dynamic>

using RowVectorXR = Eigen::RowVector<real, Eigen::Dynamic>

template<class T>
using py_class_ssp = py::classh<T>

using t_supDeviceStorageBase = std::unique_ptr<DeviceStorageBase, std::function<void(DeviceStorageBase*)>>

using t_sspDeviceStorageBase = std::shared_ptr<DeviceStorageBase>

using symbol_table_t = exprtk::symbol_table<real>

using expression_t = exprtk::expression<real>

using parser_t = exprtk::parser<real>

using tExprVars = std::map<std::string, real>

using tExprVarVecs = std::map<std::string, Eigen::Vector<real, Eigen::Dynamic>>

using t_jsonconfig = nlohmann::ordered_json

using MPI_int = int

using MPI_index = MPI_Aint

using tMPI_sizeVec = std::vector<MPI_int>

using tMPI_intVec = tMPI_sizeVec

using tMPI_indexVec = std::vector<MPI_index>

using tMPI_AintVec = tMPI_indexVec

using tMPI_statVec = std::vector<MPI_Status>

using tMPI_reqVec = std::vector<MPI_Request>

using tMPI_typePairVec = std::vector<std::pair<MPI_int, MPI_Datatype>>

using tpMPITypePairHolder = ssp<MPITypePairHolder>

template<class T>
using host_device_vector = host_device_vector_r1<T>

Enums

enum DataLayout

Values:

enumerator ErrorLayout

enumerator TABLE_StaticFixed

enumerator TABLE_Fixed

enumerator TABLE_Max

enumerator TABLE_StaticMax

enumerator CSR

enum class ConfigTypeTag

Values:

enumerator Bool

enumerator Int

enumerator Real

enumerator String

enumerator Enum

enumerator Array

enumerator Object

enumerator ArrayOfObjects

enumerator MapOfObjects

enumerator Json

enum class DeviceBackend

Values:

enumerator Unknown

enumerator Host

enumerator Custom1

Functions

void pybind11_bind_Array_All(py::module_ m)

template<class T, rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
std::string pybind11_Array_name_appends()

template<class T, rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
std::string pybind11_Array_name()

template<class T, rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
std::string pybind11_ParArray_name()

template<class TArray>
std::string pybind11_ArrayTransformer_name()

template<class T, rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
std::string pybind11_ParArrayPair_name()

template<class T, rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
tPy_Array<T, _row_size, _row_max, _align> pybind11_Array_declare(py::module_ &m)

template<class T, rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
tPy_Array<T, _row_size, _row_max, _align> pybind11_Array_get_class(py::module_ &m)

template<class T, rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
void pybind11_Array_define(py::module_ &m)

template<class T, rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
void _pybind11_Array_define_dispatch(py::module_ &m)

template<class T, rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
tPy_ParArray<T, _row_size, _row_max, _align> pybind11_ParArray_declare(py::module_ &m)

template<class T, rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
tPy_ParArray<T, _row_size, _row_max, _align> pybind11_ParArray_get_class(py::module_ &m)

template<class T, rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
void pybind11_ParArray_define(py::module_ &m)

template<class T, rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
void _pybind11_ParArray_define_dispatch(py::module_ &m)

template<class T, rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
tPy_ParArrayPair<T, _row_size, _row_max, _align> pybind11_ParArrayPair_declare(py::module_ &m)

template<class T, rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
tPy_ParArrayPair<T, _row_size, _row_max, _align> pybind11_ParArrayPair_get_class(py::module_ &m)

template<class TPair, class TPy_Pair>
void pybind11_ArrayPairGenericBindBasics(TPy_Pair &Pair_)

template<class T, rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
void pybind11_ParArrayPair_define(py::module_ &m)

template<class T, rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
void _pybind11_ParArrayPair_define_dispatch(py::module_ &m)

template<class TArray>
tPy_ArrayTransformer<TArray> pybind11_ArrayTransformer_declare(py::module_ &m)

template<class TArray>
tPy_ArrayTransformer<TArray> pybind11_ArrayTransformer_get_class(py::module_ &m)

template<class TArray>
void pybind11_ArrayTransformer_define(py::module_ &m)

template<class T, rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
void _pybind11_ArrayTransformer_define_dispatch(py::module_ &m)

template<int offset = 0>
constexpr auto _get_pybind11_arrayRowsizeInstantiationList()

template<class T, size_t N, std::array<int, N> const &Arr, size_t... Is>
void __pybind11_callBindArrays_rowsizes_sequence(py::module_ &m, std::index_sequence<Is...>)

template<class T, int offset = 0>
void pybind11_callBindArrays_rowsizes(py::module_ &m)

template<class T, size_t N, std::array<int, N> const &Arr, size_t... Is>
void __pybind11_callBindParArrays_rowsizes_sequence(py::module_ &m, std::index_sequence<Is...>)

template<class T, int offset = 0>
void pybind11_callBindParArrays_rowsizes(py::module_ &m)

template<class T, size_t N, std::array<int, N> const &Arr, size_t... Is>
void __pybind11_callBindArrayTransformers_rowsizes_sequence(py::module_ &m, std::index_sequence<Is...>)

template<class T, int offset = 0>
void pybind11_callBindArrayTransformers_rowsizes(py::module_ &m)

template<class T, size_t N, std::array<int, N> const &Arr, size_t... Is>
void __pybind11_callBindParArrayPairs_rowsizes_sequence(py::module_ &m, std::index_sequence<Is...>)

template<class T, int offset = 0>
void pybind11_callBindParArrayPairs_rowsizes(py::module_ &m)

pybind11_bind_Array_All_X_declare (1)

pybind11_bind_Array_All_X_declare (2)

pybind11_bind_Array_All_X_declare (3)

pybind11_bind_Array_All_X_declare (4)

pybind11_bind_Array_All_X_declare (5)

pybind11_bind_Array_All_X_declare (6)

pybind11_bind_Array_All_X_declare (7)

inline void pybind11_bind_Array_Offsets(py::module_ m)

constexpr bool isTABLE(DataLayout lo)

constexpr bool isTABLE_Fixed(DataLayout lo)

constexpr bool isTABLE_Max(DataLayout lo)

constexpr bool isTABLE_Static(DataLayout lo)

constexpr bool isTABLE_Dynamic(DataLayout lo)

template<class T>
constexpr bool array_comp_acceptable()

void pybind11_bind_ArrayAdjacency_All(py::module_ &m)

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

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

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

template<class TArray = ArrayAdjacency<1>>
auto pybind11_ArrayAdjacency_setitem(TArray &self, index index_, py::buffer row)

template<class TArray = ArrayAdjacency<1>>
auto pybind11_ArrayAdjacency_getitem(TArray &self, index index_)

template<rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
tPy_ArrayAdjacency<_row_size, _row_max, _align> pybind11_ArrayAdjacency_declare(py::module_ &m)

template<rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
tPy_ArrayAdjacency<_row_size, _row_max, _align> pybind11_ArrayAdjacency_get_class(py::module_ &m)

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

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

template<rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
tPy_ArrayAdjacencyPair<_row_size, _row_max, _align> pybind11_ArrayAdjacencyPair_declare(py::module_ &m)

template<rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
tPy_ArrayAdjacencyPair<_row_size, _row_max, _align> pybind11_ArrayAdjacencyPair_get_class(py::module_ &m)

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

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

template<size_t N, std::array<int, N> const &Arr, size_t... Is>
void __pybind11_callBindArrayAdjacencys_rowsizes_sequence(py::module_ &m, std::index_sequence<Is...>)

inline void pybind11_callBindArrayAdjacencys_rowsizes(py::module_ &m)

void pybind11_bind_ArrayEigenMatrix_All(py::module_ &m)

template<rowsize _mat_ni = 1, rowsize _mat_nj = 1, rowsize _mat_ni_max = _mat_ni, rowsize _mat_nj_max = _mat_nj, rowsize _align = NoAlign>
std::string pybind11_ArrayEigenMatrix_name_appends()

template<rowsize _mat_ni = 1, rowsize _mat_nj = 1, rowsize _mat_ni_max = _mat_ni, rowsize _mat_nj_max = _mat_nj, rowsize _align = NoAlign>
std::string pybind11_ArrayEigenMatrix_name()

template<rowsize _mat_ni = 1, rowsize _mat_nj = 1, rowsize _mat_ni_max = _mat_ni, rowsize _mat_nj_max = _mat_nj, rowsize _align = NoAlign>
std::string pybind11_ArrayEigenMatrixPair_name()

template<class TArrayEigenMatrix = ArrayEigenMatrix<3, 3>>
auto pybind11_ArrayEigenMatrix_getitem(TArrayEigenMatrix &self, index index_)

template<class TArrayEigenMatrix = ArrayEigenMatrix<3, 3>>
auto pybind11_ArrayEigenMatrix_setitem(TArrayEigenMatrix &self, index index_, py::buffer row)

template<rowsize _mat_ni = 1, rowsize _mat_nj = 1, rowsize _mat_ni_max = _mat_ni, rowsize _mat_nj_max = _mat_nj, rowsize _align = NoAlign>
tPy_ArrayEigenMatrix<_mat_ni, _mat_nj, _mat_ni_max, _mat_nj_max, _align> pybind11_ArrayEigenMatrix_declare(py::module_ &m)

template<rowsize _mat_ni = 1, rowsize _mat_nj = 1, rowsize _mat_ni_max = _mat_ni, rowsize _mat_nj_max = _mat_nj, rowsize _align = NoAlign>
tPy_ArrayEigenMatrix<_mat_ni, _mat_nj, _mat_ni_max, _mat_nj_max, _align> pybind11_ArrayEigenMatrix_get_class(py::module_ &m)

template<rowsize _mat_ni = 1, rowsize _mat_nj = 1, rowsize _mat_ni_max = _mat_ni, rowsize _mat_nj_max = _mat_nj, rowsize _align = NoAlign>
void pybind11_ArrayEigenMatrix_define(py::module_ &m)

template<rowsize _mat_ni = 1, rowsize _mat_nj = 1, rowsize _mat_ni_max = _mat_ni, rowsize _mat_nj_max = _mat_nj, rowsize _align = NoAlign>
void _pybind11_ArrayEigenMatrix_define_dispatch(py::module_ &m)

template<rowsize _mat_ni = 1, rowsize _mat_nj = 1, rowsize _mat_ni_max = _mat_ni, rowsize _mat_nj_max = _mat_nj, rowsize _align = NoAlign>
tPy_ArrayEigenMatrixPair<_mat_ni, _mat_nj, _mat_ni_max, _mat_nj_max, _align> pybind11_ArrayEigenMatrixPair_declare(py::module_ &m)

template<rowsize _mat_ni = 1, rowsize _mat_nj = 1, rowsize _mat_ni_max = _mat_ni, rowsize _mat_nj_max = _mat_nj, rowsize _align = NoAlign>
tPy_ArrayEigenMatrixPair<_mat_ni, _mat_nj, _mat_ni_max, _mat_nj_max, _align> pybind11_ArrayEigenMatrixPair_get_class(py::module_ &m)

template<rowsize _mat_ni = 1, rowsize _mat_nj = 1, rowsize _mat_ni_max = _mat_ni, rowsize _mat_nj_max = _mat_nj, rowsize _align = NoAlign>
void pybind11_ArrayEigenMatrixPair_define(py::module_ &m)

template<rowsize _mat_ni = 1, rowsize _mat_nj = 1, rowsize _mat_ni_max = _mat_ni, rowsize _mat_nj_max = _mat_nj, rowsize _align = NoAlign>
void _pybind11_ArrayEigenMatrixPair_define_dispatch(py::module_ &m)

template<rowsize mat_n, size_t N, std::array<int, N> const &Arr, size_t... Is>
void __pybind11_callBindArrayEigenMatrixs_rowsizes_sequence(py::module_ &m, std::index_sequence<Is...>)

template<rowsize mat_n>
void pybind11_callBindArrayEigenMatrixs_rowsizes(py::module_ &m)

template void pybind11_callBindArrayEigenMatrixs_rowsizes< 1 > (py::module_ &m)

template void pybind11_callBindArrayEigenMatrixs_rowsizes< 2 > (py::module_ &m)

template void pybind11_callBindArrayEigenMatrixs_rowsizes< 3 > (py::module_ &m)

template void pybind11_callBindArrayEigenMatrixs_rowsizes< 4 > (py::module_ &m)

template void pybind11_callBindArrayEigenMatrixs_rowsizes< 5 > (py::module_ &m)

template void pybind11_callBindArrayEigenMatrixs_rowsizes< 6 > (py::module_ &m)

template void pybind11_callBindArrayEigenMatrixs_rowsizes< 7 > (py::module_ &m)

template void pybind11_callBindArrayEigenMatrixs_rowsizes< 8 > (py::module_ &m)

template void pybind11_callBindArrayEigenMatrixs_rowsizes< DynamicSize > (py::module_ &m)

template void pybind11_callBindArrayEigenMatrixs_rowsizes< NonUniformSize > (py::module_ &m)

template<rowsize _mat_ni, rowsize _mat_nj>
constexpr rowsize __OneMatGetRowSize()

inline std::string pybind11_ArrayEigenMatrixBatch_name()

inline std::string pybind11_ArrayEigenMatrixBatchPair_name()

inline auto pybind11_ArrayEigenMatrixBatch_setitem_row(ArrayEigenMatrixBatch &self, index i, const py::list &matList)

inline auto pybind11_ArrayEigenMatrixBatch_getitem_row(ArrayEigenMatrixBatch &self, index index_)

inline auto pybind11_ArrayEigenMatrixBatch_getitem(ArrayEigenMatrixBatch &self, std::tuple<index, rowsize> index_)

inline auto pybind11_ArrayEigenMatrixBatch_setitem(ArrayEigenMatrixBatch &self, std::tuple<index, rowsize> index_, py::buffer row)

inline tPy_ArrayEigenMatrixBatch pybind11_ArrayEigenMatrixBatch_declare(py::module_ &m)

inline tPy_ArrayEigenMatrixBatch pybind11_ArrayEigenMatrixBatch_get_class(py::module_ &m)

inline void pybind11_ArrayEigenMatrixBatch_define(py::module_ &m)

inline tPy_ArrayEigenMatrixBatchPair pybind11_ArrayEigenMatrixBatchPair_declare(py::module_ &m)

inline tPy_ArrayEigenMatrixBatchPair pybind11_ArrayEigenMatrixBatchPair_get_class(py::module_ &m)

inline void pybind11_ArrayEigenMatrixBatchPair_define(py::module_ &m)

inline void pybind11_bind_ArrayEigenMatrixBatch_All(py::module_ &m)

void pybind11_bind_ArrayEigenUniMatrixBatch_All(py::module_ &m)

template<int _n_row, int _n_col>
std::string pybind11_ArrayEigenUniMatrixBatch_name()

template<int _n_row, int _n_col>
std::string pybind11_ArrayEigenUniMatrixBatchPair_name()

template<class TArrayEigenUniMatrixBatch = ArrayEigenUniMatrixBatch<3, 3>>
auto pybind11_ArrayEigenUniMatrixBatch_getitem(TArrayEigenUniMatrixBatch &self, std::tuple<index, rowsize> index_)

template<class TArrayEigenUniMatrixBatch = ArrayEigenUniMatrixBatch<3, 3>>
auto pybind11_ArrayEigenUniMatrixBatch_setitem(TArrayEigenUniMatrixBatch &self, std::tuple<index, rowsize> index_, py::buffer row)

template<class TArrayEigenUniMatrixBatch = ArrayEigenUniMatrixBatch<3, 3>>
auto pybind11_ArrayEigenUniMatrixBatch_getitem_row(TArrayEigenUniMatrixBatch &self, index index_)

template<class TArrayEigenUniMatrixBatch = ArrayEigenUniMatrixBatch<3, 3>>
auto pybind11_ArrayEigenUniMatrixBatch_setitem_row(TArrayEigenUniMatrixBatch &self, index index_, py::buffer row)

template<int _n_row, int _n_col>
tPy_ArrayEigenUniMatrixBatch<_n_row, _n_col> pybind11_ArrayEigenUniMatrixBatch_declare(py::module_ &m)

template<int _n_row, int _n_col>
tPy_ArrayEigenUniMatrixBatch<_n_row, _n_col> pybind11_ArrayEigenUniMatrixBatch_get_class(py::module_ &m)

template<int _n_row, int _n_col>
void pybind11_ArrayEigenUniMatrixBatch_define(py::module_ &m)

template<int _n_row, int _n_col>
void _pybind11_ArrayEigenUniMatrixBatch_define_dispatch(py::module_ &m)

template<int _n_row, int _n_col>
tPy_ArrayEigenUniMatrixBatchPair<_n_row, _n_col> pybind11_ArrayEigenUniMatrixBatchPair_declare(py::module_ &m)

template<int _n_row, int _n_col>
tPy_ArrayEigenUniMatrixBatchPair<_n_row, _n_col> pybind11_ArrayEigenUniMatrixBatchPair_get_class(py::module_ &m)

template<int _n_row, int _n_col>
void pybind11_ArrayEigenUniMatrixBatchPair_define(py::module_ &m)

template<int _n_row, int _n_col>
void _pybind11_ArrayEigenUniMatrixBatchPair_define_dispatch(py::module_ &m)

template<rowsize mat_n, size_t N, std::array<int, N> const &Arr, size_t... Is>
void __pybind11_callBindArrayEigenUniMatrixBatchs_rowsizes_sequence(py::module_ &m, std::index_sequence<Is...>)

template<rowsize mat_n>
void pybind11_callBindArrayEigenUniMatrixBatchs_rowsizes(py::module_ &m)

template void pybind11_callBindArrayEigenUniMatrixBatchs_rowsizes< 1 > (py::module_ &m)

template void pybind11_callBindArrayEigenUniMatrixBatchs_rowsizes< 2 > (py::module_ &m)

template void pybind11_callBindArrayEigenUniMatrixBatchs_rowsizes< 3 > (py::module_ &m)

template void pybind11_callBindArrayEigenUniMatrixBatchs_rowsizes< 4 > (py::module_ &m)

template void pybind11_callBindArrayEigenUniMatrixBatchs_rowsizes< 5 > (py::module_ &m)

template void pybind11_callBindArrayEigenUniMatrixBatchs_rowsizes< 6 > (py::module_ &m)

template void pybind11_callBindArrayEigenUniMatrixBatchs_rowsizes< 7 > (py::module_ &m)

template void pybind11_callBindArrayEigenUniMatrixBatchs_rowsizes< 8 > (py::module_ &m)

template void pybind11_callBindArrayEigenUniMatrixBatchs_rowsizes< DynamicSize > (py::module_ &m)

template<int a, int b>
constexpr rowsize EigenSize_Mul_RowSize()

void pybind11_bind_ArrayEigenVector_All(py::module_ &m)

template<rowsize _vec_size = 1, rowsize _row_max = _vec_size, rowsize _align = NoAlign>
std::string pybind11_ArrayEigenVector_name_appends()

template<rowsize _vec_size = 1, rowsize _row_max = _vec_size, rowsize _align = NoAlign>
std::string pybind11_ArrayEigenVector_name()

template<rowsize _vec_size = 1, rowsize _row_max = _vec_size, rowsize _align = NoAlign>
std::string pybind11_ArrayEigenVectorPair_name()

template<class TArrayEigenVector = ArrayEigenVector<1>>
auto pybind11_ArrayEigenVector_getitem(TArrayEigenVector &self, index index_)

template<class TArrayEigenVector = ArrayEigenVector<1>>
auto pybind11_ArrayEigenVector_setitem(TArrayEigenVector &self, index index_, py::buffer row)

template<rowsize _vec_size = 1, rowsize _row_max = _vec_size, rowsize _align = NoAlign>
tPy_ArrayEigenVector<_vec_size, _row_max, _align> pybind11_ArrayEigenVector_declare(py::module_ &m)

template<rowsize _vec_size = 1, rowsize _row_max = _vec_size, rowsize _align = NoAlign>
tPy_ArrayEigenVector<_vec_size, _row_max, _align> pybind11_ArrayEigenVector_get_class(py::module_ &m)

template<rowsize _vec_size = 1, rowsize _row_max = _vec_size, rowsize _align = NoAlign>
void pybind11_ArrayEigenVector_define(py::module_ &m)

template<rowsize _vec_size = 1, rowsize _row_max = _vec_size, rowsize _align = NoAlign>
void _pybind11_ArrayEigenVector_define_dispatch(py::module_ &m)

template<rowsize _vec_size = 1, rowsize _row_max = _vec_size, rowsize _align = NoAlign>
tPy_ArrayEigenVectorPair<_vec_size, _row_max, _align> pybind11_ArrayEigenVectorPair_declare(py::module_ &m)

template<rowsize _vec_size = 1, rowsize _row_max = _vec_size, rowsize _align = NoAlign>
tPy_ArrayEigenVector<_vec_size, _row_max, _align> pybind11_ArrayEigenVectorPair_get_class(py::module_ &m)

template<rowsize _vec_size = 1, rowsize _row_max = _vec_size, rowsize _align = NoAlign>
void pybind11_ArrayEigenVectorPair_define(py::module_ &m)

template<rowsize _vec_size = 1, rowsize _row_max = _vec_size, rowsize _align = NoAlign>
void _pybind11_ArrayEigenVectorPair_define_dispatch(py::module_ &m)

template<size_t N, std::array<int, N> const &Arr, size_t... Is>
void __pybind11_callBindArrayEigenVectors_rowsizes_sequence(py::module_ &m, std::index_sequence<Is...>)

inline void pybind11_callBindArrayEigenVectors_rowsizes(py::module_ &m)

void pybind11_bind_ArrayDOF_All(py::module_ &m)

template<int n_m, int n_n>
std::string pybind11_ArrayDOF_name()

template<int n_m, int n_n>
tPy_ArrayDOF<n_m, n_n> pybind11_ArrayDOF_declare(py::module_ &m)

template<int n_m, int n_n>
tPy_ArrayDOF<n_m, n_n> pybind11_ArrayDOF_get_class(py::module_ &m)

template<int n_m, int n_n>
void pybind11_ArrayDOF_define(py::module_ &m)

template<int n_m, int n_n>
void _pybind11_ArrayDOF_define_dispatch(py::module_ &m)

template<rowsize mat_n, size_t N, std::array<int, N> const &Arr, size_t... Is>
void __pybind11_callBindArrayDOFs_rowsizes_sequence(py::module_ &m, std::index_sequence<Is...>)

template<rowsize mat_n>
void pybind11_callBindArrayDOF_rowsizes(py::module_ &m)

template void pybind11_callBindArrayDOF_rowsizes< 1 > (py::module_ &m)

template void pybind11_callBindArrayDOF_rowsizes< 2 > (py::module_ &m)

template void pybind11_callBindArrayDOF_rowsizes< 3 > (py::module_ &m)

template void pybind11_callBindArrayDOF_rowsizes< 4 > (py::module_ &m)

template void pybind11_callBindArrayDOF_rowsizes< 5 > (py::module_ &m)

template void pybind11_callBindArrayDOF_rowsizes< 6 > (py::module_ &m)

template void pybind11_callBindArrayDOF_rowsizes< 7 > (py::module_ &m)

template void pybind11_callBindArrayDOF_rowsizes< 8 > (py::module_ &m)

template void pybind11_callBindArrayDOF_rowsizes< DynamicSize > (py::module_ &m)

template void pybind11_callBindArrayDOF_rowsizes< NonUniformSize > (py::module_ &m)

inline std::vector<index> BuildRedistributionPullingIndex(const MPIInfo &mpi, const std::vector<index> &readOrigIndex, const std::vector<index> &newOrigIndex, const ssp<GlobalOffsetsMapping> &readGlobalMapping)

template<class TArray>
void RedistributeArrayWithTransformer(const MPIInfo &mpi, ssp<TArray> readFather, const std::vector<index> &readOrigIndex, const std::vector<index> &newOrigIndex, ssp<TArray> outFather)

inline std::string schemaTypeString(ConfigTypeTag tag)

bool ostreamIsTTY(std::ostream &ostream)

std::ostream &log()

bool logIsTTY()

void setLogStream(ssp<std::ostream> nstream)

void setLogStreamCout()

int get_terminal_width()

void print_progress(std::ostream &os, double progress)

std::string getStringForceWString(const std::wstring &v)

int get_env_OMP_NUM_THREADS()

int get_env_DNDS_DIST_OMP_NUM_THREADS()

std::string GetSetVersionName(const std::string &ver = "")

inline void RegisterSignalHandler()

inline std::pair<index, index> EvenSplitRange(int rank, int nRanks, index nGlobal)

inline bool IsUnInitReal(real v)

template<typename T, typename ...Args>
ssp<T> make_ssp(Args&&... args)

template<typename T, typename ...Args>
ssp<T> make_ssp(ObjName objName, Args&&... args)

constexpr int RowSize_To_EigenSize(rowsize rs)

inline std::string RowSize_To_PySnippet(rowsize rs)

inline std::string Align_To_PySnippet(rowsize al)

template<typename T>
bool signedIntWillAddOverflow(T value, T increment)

template<typename T>
T signedIntSafeAdd(T value, T increment)

template<typename T>
T size_t_to_signed(size_t v)

inline index size_to_index(size_t v)

inline rowsize size_to_rowsize(size_t v)

template<class TtRowsizeVec, class TtIndexVec>
inline void AccumulateRowSize(const TtRowsizeVec &rowsizes, TtIndexVec &rowstarts)

template<class T>
inline bool checkUniformVector(const std::vector<T> &dat, T &value)

template<class T, class TP = T>
inline void PrintVec(const std::vector<T> &dat, std::ostream &out)

template<class TL, class TR>
constexpr auto divCeil(TL l, TR r)

template<typename T>
constexpr T sqr(const T &a)

template<typename T>
constexpr T cube(const T &a)

constexpr real sign(real a)

constexpr real signTol(real a, real tol)

constexpr real signP(real a)

constexpr real signM(real a)

template<typename T>
constexpr T mod(T a, T b)

template<typename T>
constexpr T divide_ceil(T a, T b)

inline real float_mod(real a, real b)

template<class tIt1, class tIt1end, class tIt2, class tIt2end, class tF>
bool iterateIdentical(tIt1 it1, tIt1end it1end, tIt2 it2, tIt2end it2end, tF F)

inline int32_t checkedIndexTo32(index v)

inline std::string getStringForcePath(const std::filesystem::path::string_type &v)

inline std::vector<std::string> splitSString(const std::string &str, char delim)

inline std::vector<std::string> splitSStringClean(const std::string &str, char delim)

inline bool sstringHasSuffix(const std::string &str, const std::string &suffix)

template<class T>
bool py_buffer_contains_T(const py::buffer_info &info)

inline bool py_buffer_is_contigious_c(const py::buffer_info &info)

inline bool py_buffer_is_contigious_f(const py::buffer_info &info)

inline std::tuple<ssize_t, char> py_buffer_get_contigious_size(const py::buffer_info &info)

template<typename T>
py::memoryview py_vector_as_memory_view(std::vector<T> &vec, bool readonly)

inline void pybind11_bind_defines(py::module_ &m)

void deviceStorageBase_deleter(DeviceStorageBase *p)

inline const char *device_backend_name(DeviceBackend B)

inline DeviceBackend device_backend_name_to_enum(std::string_view s)

inline t_supDeviceStorageBase null_supDeviceStorageBase()

inline t_supDeviceStorageBase device_storage_create(DeviceBackend backend, size_t n_bytes)

inline void pybind11_bind_deviceStorage(py::module_ &m)

inline void pybind11_bind_device_controls(py::module_ &m)

template<DeviceBackend B, class T, rowsize _row_size, rowsize _row_max, rowsize _align>
auto ArrayDeviceView_build(index n_size, T *n_data, index n_data_size, const index *n_rowstart, index n_rowstart_size, const rowsize *n_rowsizes, index n_rowsizes_size, rowsize n_row_size_dynamic, T *n_data_device, const index *n_rowstart_device, const rowsize *n_rowsizes_device)

template<class dir>
std::string to_string(const Eigen::DenseBase<dir> &v, int precision = 5, bool scientific = false)

std::string getTraceString()

inline void assert_false(const char *expr, const char *file, int line)

inline void assert_false_info(const char *expr, const char *file, int line, const std::string &info)

inline void assert_false_infof(const char *expr, const char *file, int line, const char *info, ...)

template<class TException = std::runtime_error>
void assert_false_info_throw(const char *expr, const char *file, int line, const std::string &info)

inline hid_t DNDS_H5T_INDEX()

inline hid_t DNDS_H5T_ROWSIZE()

inline hid_t DNDS_H5T_REAL()

inline auto pybind11_GlobalOffsetsMapping_declare(py::module_ m)

inline auto pybind11_GlobalOffsetsMapping_get_class(py::module_ m)

inline void pybind11_GlobalOffsetsMapping_define(py::module_ m)

inline auto pybind11_OffsetAscendIndexMapping_declare(py::module_ m)

inline auto pybind11_OffsetAscendIndexMapping_get_class(py::module_ m)

inline void pybind11_OffsetAscendIndexMapping_define(py::module_ m)

inline void pybind11_bind_IndexMapping_All(py::module_ m)

inline Eigen::VectorXd JsonGetEigenVector(const nlohmann::json &arr)

inline Eigen::VectorFMTSafe<real, -1> JsonGetEigenVectorFMTSafe(const nlohmann::json &arr)

inline auto EigenVectorGetJson(const Eigen::VectorXd &ve)

inline auto EigenVectorFMTSafeGetJson(const Eigen::VectorFMTSafe<real, -1> &ve)

inline void to_json(nlohmann::ordered_json &j, const host_device_vector<real> &v)

inline void from_json(const nlohmann::ordered_json &j, host_device_vector<real> &v)

void assert_false_info_mpi(const char *expr, const char *file, int line, const std::string &info, const DNDS::MPIInfo &mpi)

std::string getTimeStamp(const MPIInfo &mpi)

template<class Tbasic>
constexpr MPI_Datatype __DNDSToMPITypeInt()

template<class Tbasic>
constexpr MPI_Datatype __DNDSToMPITypeFloat()

template<class T>
std::pair<MPI_Datatype, MPI_int> BasicType_To_MPIIntType_Custom()

template<class T>
std::pair<MPI_Datatype, MPI_int> BasicType_To_MPIIntType()

inline MPI_int MPIWorldSize()

inline MPI_int MPIWorldRank()

template<class F>
inline void MPISerialDo(const MPIInfo &mpi, F f)

inline void InsertCheck(const MPIInfo &mpi, const std::string &info = "", const std::string &FUNCTION = "", const std::string &FILE = "", int LINE = -1)

void pybind11_MPIInfo(py::module_ &m)

void pybind11_bind_MPI_All(py::module_ &m)

inline MPI_Datatype py_get_buffer_basic_mpi_datatype(const py::buffer_info &info)

inline MPI_Op py_get_simple_mpi_op_by_name(const std::string &op)

template<typename TList, typename F>
void for_each_member_list(TList &&obj_member_list, F &&f)

template<typename T>
MemberRef(T&, const char*) -> MemberRef<T>

template<typename Class, typename TList, typename F>
void for_each_member_ptr_list(Class &obj, TList &&obj_member_ptr_list, F &&f)

template<typename TList, typename F>
void for_each_member_ptr_list_raw(TList &&obj_member_ptr_list, F &&f)

template<typename Class, typename T>
MemberPtr(T Class::*, const char*) -> MemberPtr<Class, T>

inline PerformanceTimer &Timer()

template<class TBlkSiz, class TDisp, class TSizeof>
auto optimize_hindexed_layout(index o_size, TBlkSiz *blk_sizes, TDisp *disps, TSizeof sizeofElem)

Variables

static constexpr auto pybind11_arrayRowsizeInstantiationList = _get_pybind11_arrayRowsizeInstantiationList()

ssp<std::ostream> logStream

bool useCout = true

static const char *outputDelim = "\t"

template<typename T>
constexpr bool is_ssp_v = is_ssp<T>::value

DNDS_CONSTANT const index indexMin   = INT64_MIN

DNDS_CONSTANT const real UnInitReal   = NAN

DNDS_CONSTANT const index UnInitIndex   = INT64_MIN

DNDS_CONSTANT const rowsize UnInitRowsize   = INT32_MIN

DNDS_CONSTANT const real veryLargeReal   = 3e200

DNDS_CONSTANT const real largeReal   = 3e10

DNDS_CONSTANT const real verySmallReal   = 1e-200

DNDS_CONSTANT const real smallReal   = 1e-10

DNDS_CONSTANT const real pi   = DNDS_E_PI

DNDS_CONSTANT const rowsize DynamicSize   = -1

DNDS_CONSTANT const rowsize NonUniformSize   = -2

DNDS_CONSTANT const rowsize NoAlign   = -1024

static const auto EigenAll = Eigen::all

static const auto EigenLast = Eigen::last

const char *__EigenPCH = "EigenPCH"

const char *__ExprtkPCH = "ExprtkPCH"

std::mutex HDF_mutex

const MPI_Datatype DNDS_MPI_INDEX = __DNDSToMPITypeInt<index>()

const MPI_Datatype DNDS_MPI_REAL = __DNDSToMPITypeFloat<real>()

template<typename index_T = index>
class AdjacencyRow

Public Functions

DNDS_DEVICE_CALLABLE AdjacencyRow() = default

inline DNDS_DEVICE_CALLABLE AdjacencyRow(index_T *ptr, rowsize siz)

inline DNDS_DEVICE_CALLABLE index_T & operator[] (rowsize j)

inline operator std::vector<index>() const

inline void operator=(const std::vector<index> &r)

inline DNDS_DEVICE_CALLABLE void operator= (const AdjacencyRow &r)

inline DNDS_DEVICE_CALLABLE rowsize size () const

template<class T, rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
class Array : public DNDS::ArrayLayout<T, 1, 1, NoAlign>, public DNDS::ObjectNaming

Subclassed by DNDS::ParArray< index, 1, 1, NoAlign >, DNDS::ParArray< real, __OneMatGetRowSize< 1, 1 >(), __OneMatGetRowSize< 1, 1 >(), NoAlign >, DNDS::ParArray< real, NonUniformSize >, DNDS::ParArray< real, NonUniformSize, NonUniformSize, NoAlign >, DNDS::ParArray< real, 1, 1, NoAlign >, DNDS::ParArray< index, _row_size, _row_size, NoAlign >, DNDS::ParArray< NodePeriodicBits, 1, 1, NoAlign >, DNDS::ParArray< real, __OneMatGetRowSize< _mat_ni, _mat_nj >(), __OneMatGetRowSize< _mat_ni, _mat_nj >(), NoAlign >, DNDS::ParArray< T, _row_size, _row_max, _align >

Public Functions

inline t_pRowStart getRowStart()

inline t_pRowSizes getRowSizes()

Array() = default

inline explicit Array(ObjName objName)

inline index Size() const

inline rowsize RowSize() const

inline rowsize DataStride() const

inline rowsize RowSize(index iRow) const

inline rowsize RowSizeMax() const

inline rowsize RowSizeField() const

inline rowsize RowSizeField(index iRow) const

inline bool IfCompressed() const

inline void CSRDecompress()

inline void CSRCompress()

inline void Compress()

inline void Decompress()

inline t_Data &RawDataVector()

inline void Resize(index nSize, rowsize nRow_size_dynamic)

inline void Resize(index nSize)

template<class TFRowSize>
inline void Resize(index nSize, TFRowSize &&FRowSize)

inline void ResizeRow(index iRow, rowsize nRowSize)

inline void ReserveRow(index iRow, rowsize nRowSize)

inline t_View view()

inline const T &at(index iRow, rowsize iCol) const

inline T &operator()(index iRow, rowsize iCol = 0)

inline const T &operator()(index iRow, rowsize iCol = 0) const

inline T *operator[](index iRow)

inline const T *operator[](index iRow) const

inline T *data(DeviceBackend B = DeviceBackend::Unknown)

inline size_t DataSize() const

inline size_t DataSizeBytes() const

inline void CopyRowFrom(index dstRow, const self_type &src, index srcRow)

template<class TRowSizeFunc>
inline void ResizeRowsAndCompress(TRowSizeFunc &&rowSizeFunc)

inline size_t FullSizeBytes() const

inline std::size_t hash()

inline constexpr DataLayout GetDataLayout()

inline void clone(const self_type &R)

inline void CopyData(const self_type &R)

inline self_type &operator=(const self_type &R)

inline Array(const self_type &R)

inline void SwapData(self_type &R)

inline void WriteSerializer(Serializer::SerializerBaseSSP serializerP, const std::string &name, Serializer::ArrayGlobalOffset offset, Serializer::ArrayGlobalOffset dataOffset = Serializer::ArrayGlobalOffset_Unknown)

inline void ReadSerializer(Serializer::SerializerBaseSSP serializerP, const std::string &name, Serializer::ArrayGlobalOffset &offset)

inline void ReadSerializer(Serializer::SerializerBaseSSP serializerP, const std::string &name, Serializer::ArrayGlobalOffset &offset, Serializer::ArrayGlobalOffset &dataOffset)

inline ReadSerializerMetaResult ReadSerializerMeta(Serializer::SerializerBaseSSP serializerP, const std::string &name)

inline void __ReadSerializerStructuralAndResolveDataOffset(const Serializer::SerializerBaseSSP &serializerP, Serializer::ArrayGlobalOffset &offset, Serializer::ArrayGlobalOffset &dataOffset)

inline void __ReadSerializerDataAndPropagateOffset(const Serializer::SerializerBaseSSP &serializerP, Serializer::ArrayGlobalOffset &offset, Serializer::ArrayGlobalOffset &dataOffset)

inline void to_host()

inline void to_device(DeviceBackend backend = DeviceBackend::Host)

inline void clear_device()

template<DeviceBackend B>
inline t_deviceView<B> deviceView()

template<DeviceBackend B>
inline t_deviceViewConst<B> deviceView() const

inline DeviceBackend device() const

template<DeviceBackend B>
inline iterator<B> begin()

template<DeviceBackend B>
inline iterator<B> end()

Public Static Functions

static inline constexpr DataLayout GetDataLayoutStatic()

Friends

inline friend std::ostream &operator<<(std::ostream &o, const Array<T, _row_size, _row_max, _align> &A)

template<DeviceBackend B>
class iterator : public DNDS::ArrayIteratorBase<iterator<B>>

struct ReadSerializerMetaResult

Subclassed by DNDS::ArrayEigenUniMatrixBatch< _n_row, _n_col >::ReadSerializerMetaResult

template<typename T, std::size_t s>
struct array_hash

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

Public Functions

inline void clone(const t_self &R)

inline AdjacencyRow<index> operator[](index i)

inline AdjacencyRow<const index> operator[](index i) const

inline index *rowPtr(index i)

template<DeviceBackend B>
class iterator : public DNDS::ArrayIteratorBase<iterator<B>>

template<DeviceBackend B, typename index_T, rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
class ArrayAdjacencyDeviceView : public DNDS::ArrayDeviceView<B, index, 1, 1, NoAlign>

template<DeviceBackend B, class T, rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
class ArrayDeviceView : public DNDS::ArrayView<T, 1, 1, NoAlign>

Subclassed by DNDS::ArrayAdjacencyDeviceView< B >, DNDS::ArrayEigenVectorDeviceView< B >, DNDS::ArrayAdjacencyDeviceView< B, index_T, _row_size, _row_max, _align >, DNDS::ArrayEigenMatrixDeviceView< B, real_T, _mat_ni, _mat_nj, _mat_ni_max, _mat_nj_max, _align >, DNDS::ArrayEigenVectorDeviceView< B, real_T, _vec_size, _row_max, _align >

template<class T, rowsize _row_size, rowsize _row_max, rowsize _align>
class ArrayDeviceView<DeviceBackend::Host, T, _row_size, _row_max, _align> : public DNDS::ArrayView<T, _row_size, _row_max, _align>

template<int n_m, int n_n>
class ArrayDof : public DNDS::ArrayPair<n_m, n_n>

Subclassed by DNDS::Euler::ArrayDOFV< 1 >, DNDS::Euler::ArrayDOFV< nVarsFixed >, DNDS::Euler::ArrayGRADV< nVarsFixed, gDim >, DNDS::Euler::ArrayRECV< nVarsFixed >

Public Types

template<DeviceBackend B>
using t_deviceView = ArrayDofDeviceView<B, n_m, n_n>

template<DeviceBackend B>
using t_deviceViewConst = ArrayDofDeviceViewConst<B, n_m, n_n>

template<DeviceBackend B>
using t_ops = ArrayDofOp<B, n_m, n_n>

using t_element_mat = Eigen::Matrix<real, RowSize_To_EigenSize(n_m), RowSize_To_EigenSize(n_n)>

Public Functions

template<DeviceBackend B>
inline t_deviceView<B> deviceView()

template<DeviceBackend B>
inline t_deviceViewConst<B> deviceView() const

inline void clone(const t_self &R)

inline void setConstant(real R)

inline void setConstant(const Eigen::Ref<const t_element_mat> &R)

inline void operator+=(const t_self &R)

inline void operator+=(real R)

inline void operator+=(const Eigen::Ref<const t_element_mat> &R)

inline void operator-=(const t_self &R)

inline void operator*=(real R)

template<int n_m_T = n_m>
inline std::enable_if_t<!(n_m_T == 1 && n_n == 1)> operator*=(const ArrayDof<1, 1> &R)

inline void operator*=(const Eigen::Ref<const t_element_mat> &R)

inline void operator*=(const t_self &R)

inline void operator/=(const t_self &R)

inline void operator=(const t_self &R)

inline void addTo(const t_self &R, real r)

inline real norm2()

inline real norm2(const t_self &R)

inline real min()

inline real max()

inline real sum()

inline t_element_mat componentWiseNorm1()

inline t_element_mat componentWiseNorm1(const t_self &R)

inline real dot(const t_self &R)

inline void to_device(DeviceBackend backend)

inline void to_host()

template<DeviceBackend B, int n_m, int n_n>
class ArrayDofDeviceView : public DNDS::ArrayPairDeviceView<B, ArrayEigenMatrix<n_m, n_n>>

template<DeviceBackend B, int n_m, int n_n>
class ArrayDofDeviceViewConst : public DNDS::ArrayPairDeviceViewConst<B, ArrayEigenMatrix<n_m, n_n>>

template<DeviceBackend B, int n_m, int n_n>
class ArrayDofOp

template<int n_m, int n_n>
class ArrayDofOp<DeviceBackend::Host, n_m, n_n>

class ArrayDofSinglePack

template<rowsize _mat_ni = 1, rowsize _mat_nj = 1, rowsize _mat_ni_max = _mat_ni, rowsize _mat_nj_max = _mat_nj, rowsize _align = NoAlign>
class ArrayEigenMatrix : public DNDS::ParArray<real, __OneMatGetRowSize<1, 1>(), __OneMatGetRowSize<1, 1>(), NoAlign>

Public Functions

inline size_t FullSizeBytes() const

inline void WriteSerializer(Serializer::SerializerBaseSSP serializerP, const std::string &name, Serializer::ArrayGlobalOffset offset)

template<DeviceBackend B, bool is_const = false>
class iterator : public DNDS::ArrayIteratorBase<iterator<B>>

struct ReadSerializerMetaResult : public t_base::ReadSerializerMetaResult

class ArrayEigenMatrixBatch : public DNDS::ParArray<real, NonUniformSize>

Public Types

template<DeviceBackend B>
using t_deviceView = ArrayEigenMatrixBatchDeviceView<B, real>

template<DeviceBackend B>
class iterator : public DNDS::ArrayIteratorBase<iterator<B>>

template<DeviceBackend B, class real_T>
class ArrayEigenMatrixBatchDeviceView : public DNDS::ArrayDeviceView<B, real_T, NonUniformSize>

template<DeviceBackend B, class real_T, rowsize _mat_ni = 1, rowsize _mat_nj = 1, rowsize _mat_ni_max = _mat_ni, rowsize _mat_nj_max = _mat_nj, rowsize _align = NoAlign>
class ArrayEigenMatrixDeviceView : public DNDS::ArrayDeviceView<B, real_T, __OneMatGetRowSize<1, 1>(), __OneMatGetRowSize<1, 1>(), NoAlign>

template<int _n_row, int _n_col>
class ArrayEigenUniMatrixBatch : public DNDS::ParArray<real, NonUniformSize, NonUniformSize, NoAlign>

Public Functions

inline void ResizeMatrix(int r = -1, int c = -1)

template<DeviceBackend B>
class iterator : public DNDS::ArrayIteratorBase<iterator<B>>

struct ReadSerializerMetaResult : public DNDS::Array<T, _row_size, _row_max, _align>::ReadSerializerMetaResult

template<DeviceBackend B>
class UniMatrixRowView

template<DeviceBackend B, class real_T, int _n_row, int _n_col>
class ArrayEigenUniMatrixBatchDeviceView : public DNDS::ArrayDeviceView<B, real_T, NonUniformSize>

Public Types

using t_self = ArrayEigenUniMatrixBatchDeviceView<B, real_T, _n_row, _n_col>

template<rowsize _vec_size = 1, rowsize _row_max = _vec_size, rowsize _align = NoAlign>
class ArrayEigenVector : public DNDS::ParArray<real, 1, 1, NoAlign>

Public Types

using t_EigenVector = typename t_deviceView<DeviceBackend::Host>::t_EigenVector

using t_EigenMap = typename t_deviceView<DeviceBackend::Host>::t_EigenMap

using t_EigenMap_Const = typename t_deviceView<DeviceBackend::Host>::t_EigenMap_Const

using t_copy = t_EigenVector

Public Functions

inline void clone(const t_self &R)

inline t_EigenMap operator[](index i)

inline t_EigenMap_Const operator[](index i) const

template<DeviceBackend B>
inline auto deviceView()

template<DeviceBackend B>
inline auto deviceView() const

inline void ReadSerializer(Serializer::SerializerBaseSSP serializerP, const std::string &name, Serializer::ArrayGlobalOffset &offset)

inline void WriteSerializer(Serializer::SerializerBaseSSP serializerP, const std::string &name, Serializer::ArrayGlobalOffset offset)

template<DeviceBackend B>
class iterator : public DNDS::ArrayIteratorBase<iterator<B>>

template<DeviceBackend B, class real_T, rowsize _vec_size = 1, rowsize _row_max = _vec_size, rowsize _align = NoAlign>
class ArrayEigenVectorDeviceView : public DNDS::ArrayDeviceView<B, real_T, 1, 1, NoAlign>

class ArrayIndex : public DNDS::ArrayAdjacency<1>

Public Functions

inline index &operator[](index i)

inline index *rowPtr(index i)

template<class Derived>
class ArrayIteratorBase

template<class T, rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
class ArrayLayout

Subclassed by DNDS::Array< index, _row_size, _row_max, _align >, DNDS::Array< real, _row_size, _row_max, _align >, DNDS::Array< real, _row_size, _row_size, NoAlign >, DNDS::Array< NodePeriodicBits, _row_size, _row_max, _align >, DNDS::ArrayView< index, _row_size, _row_max, _align >, DNDS::ArrayView< real_T, _row_size, _row_size, NoAlign >, DNDS::ArrayView< real_T, _row_size, _row_max, _align >, DNDS::Array< T, _row_size, _row_max, _align >, DNDS::ArrayView< T, _row_size, _row_max, _align >

Public Static Functions

static inline constexpr DataLayout _GetDataLayout()

static inline std::string GetArrayName()

static inline std::string GetArraySignature()

static inline std::string GetArraySignatureRelaxed()

static inline std::tuple<int, int, int, int> ParseArraySignatureTuple(const std::string &v)

static inline bool ArraySignatureIsCompatible(const std::string &v)

template<class TArray = ParArray<real, 1>>
struct ArrayPair

Subclassed by DNDS::ArrayDof< 1, 1 >, DNDS::ArrayDof< nVarsFixed, dim >, DNDS::ArrayDof< nVarsFlow, 1 >, DNDS::ArrayDof< n_m, n_n >

Public Types

template<DeviceBackend B>
using t_deviceView = ArrayPairDeviceView<B, TArray>

template<DeviceBackend B>
using t_deviceViewConst = ArrayPairDeviceViewConst<B, TArray>

Public Functions

inline void clone(const t_self &R)

inline decltype(father->(index(0))) operator[](index i) const

inline decltype(father->(index(0))) operator[](index i)

template<class ...TOthers>
inline decltype(auto) operator()(index i, TOthers... aOthers)

template<class ...TOthers>
inline decltype(auto) operator()(index i, TOthers... aOthers) const

template<class TF>
inline auto runFunctionAppendedIndex(index i, TF &&F)

inline auto RowSize() const

inline auto RowSize(index i) const

inline void ResizeRow(index i, rowsize rs)

template<class ...TOthers>
inline void ResizeRow(index i, TOthers... aOthers)

inline index Size() const

inline void TransAttach()

template<typename ...Args>
inline void InitPair(const std::string &name, Args&&... args)

template<class TPrimaryPair>
inline void BorrowAndPull(TPrimaryPair &primary)

template<class TPrimaryPair>
inline void BorrowSetup(TPrimaryPair &primary)

inline void CompressBoth()

inline void CopyFather(t_self &R)

inline void SwapDataFatherSon(t_self &R)

inline std::size_t hash()

inline void WriteSerialize(Serializer::SerializerBaseSSP serializerP, const std::string &name, bool includePIG = true, bool includeSon = true)

inline void WriteSerialize(Serializer::SerializerBaseSSP serializerP, const std::string &name, const std::vector<index> &origIndex, bool includePIG = true, bool includeSon = true)

inline void ReadSerialize(Serializer::SerializerBaseSSP serializerP, const std::string &name, bool includePIG = true, bool includeSon = true)

inline void ReadSerializeRedistributed(Serializer::SerializerBaseSSP serializerP, const std::string &name, const std::vector<index> &newOrigIndex)

template<DeviceBackend B>
inline auto deviceView()

template<DeviceBackend B>
inline auto deviceView() const

inline void to_device(DeviceBackend backend)

inline void to_host()

Public Members

ssp<TArray> father

ssp<TArray> son

TTrans trans

Public Static Functions

static inline constexpr bool IsCSR()

template<DeviceBackend B, class TArray = ParArray<real, 1>>
struct ArrayPairDeviceView : public DNDS::ArrayPairDeviceView_Base<ArrayPairDeviceView<B, ParArray<real, 1>>>

template<class Derived>
struct ArrayPairDeviceView_Base

Subclassed by DNDS::ArrayPairDeviceView< B, ArrayEigenMatrix< n_m, n_n > >, DNDS::ArrayPairDeviceViewConst< B, ArrayEigenMatrix< n_m, n_n > >, DNDS::ArrayPairDeviceView< B, TArray >, DNDS::ArrayPairDeviceViewConst< B, TArray >

Public Functions

inline DNDS_DEVICE_CALLABLE index Size () const

inline DNDS_DEVICE_CALLABLE auto RowSize() const

inline DNDS_DEVICE_CALLABLE auto RowSize(index i) const

inline DNDS_DEVICE_CALLABLE auto operator[](index i) const

inline DNDS_DEVICE_CALLABLE auto operator[](index i)

template<class ...TOthers>
inline DNDS_DEVICE_CALLABLE decltype(auto) operator()(index i, TOthers... aOthers)

template<class ...TOthers>
inline DNDS_DEVICE_CALLABLE decltype(auto) operator()(index i, TOthers... aOthers) const

template<DeviceBackend B, class TArray = ParArray<real, 1>>
struct ArrayPairDeviceViewConst : public DNDS::ArrayPairDeviceView_Base<ArrayPairDeviceViewConst<B, ParArray<real, 1>>>

Public Members

t_arrayDeviceView father

template<class T, rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
class ArrayTransformer

Public Functions

inline TSelf &operator=(const TSelf &R)

ArrayTransformer() = default

inline ArrayTransformer(const TSelf &R)

inline void setFatherSon(const t_pArray &n_father, const t_pArray &n_son)

template<class TRArrayTrans>
inline void BorrowGGIndexing(const TRArrayTrans &RArrayTrans)

inline void createFatherGlobalMapping()

template<class TPullSet>
inline void createGhostMapping(TPullSet &&pullingIndexGlobal)

template<class TPushSet, class TPushStart>
inline void createGhostMapping(TPushSet &&pushingIndexLocal, TPushStart &&pushStarts)

inline void createMPITypes()

inline void initPersistentPush(DeviceBackend B = DeviceBackend::Unknown)

inline void initPersistentPull(DeviceBackend B = DeviceBackend::Unknown)

inline void startPersistentPush(DeviceBackend B = DeviceBackend::Unknown)

inline void startPersistentPull(DeviceBackend B = DeviceBackend::Unknown)

inline void waitPersistentPush(DeviceBackend B = DeviceBackend::Unknown)

inline void waitPersistentPull(DeviceBackend B = DeviceBackend::Unknown)

inline void clearPersistentPush()

inline void clearPersistentPull()

inline void clearMPITypes()

inline void clearGlobalMapping()

inline void clearGhostMapping()

inline void pullOnce()

inline void pushOnce()

inline void reInitPersistentPullPush()

Public Members

MPIInfo mpi

t_pLGhostMapping pLGhostMapping

t_pArray father

t_pArray son

t_pLGlobalMapping pLGlobalMapping

ssp<tMPI_typePairVec> pPushTypeVec

ssp<tMPI_typePairVec> pPullTypeVec

ssp<MPIReqHolder> PushReqVec

ssp<MPIReqHolder> PullReqVec

DeviceBackend pushDevice = DeviceBackend::Unknown

DeviceBackend pullDevice = DeviceBackend::Unknown

MPI_int nRecvPushReq = {-1}

MPI_int nRecvPullReq = {-1}

tMPI_statVec PushStatVec

tMPI_statVec PullStatVec

MPI_Aint pushSendSize

MPI_Aint pullSendSize

tMPI_intVec pushingSizes

tMPI_AintVec pushingDisps

std::vector<index> pushingIndexLocal

std::vector<std::vector<T>> inSituBuffer

template<class TArray>
struct ArrayTransformerType

template<class T, rowsize _row_size = 1, rowsize _row_max = _row_size, rowsize _align = NoAlign>
class ArrayView : public DNDS::ArrayLayout<T, 1, 1, NoAlign>

Subclassed by DNDS::ArrayDeviceView< B, index, 1, 1, NoAlign >, DNDS::ArrayDeviceView< B, real_T, NonUniformSize >, DNDS::ArrayDeviceView< B, real_T, __OneMatGetRowSize< 1, 1 >(), __OneMatGetRowSize< 1, 1 >(), NoAlign >, DNDS::ArrayDeviceView< B, real_T, 1, 1, NoAlign >, DNDS::ArrayDeviceView< B >, DNDS::ArrayDeviceView< B, T, _row_size, _row_max, _align >

Public Functions

inline DNDS_DEVICE_CALLABLE ArrayView(index n_size, T *n_data, index n_data_size, const index *n_rowstart, index n_rowstart_size, const rowsize *n_rowsizes, index n_rowsizes_size, rowsize n_row_size_dynamic, bool n_isCompressed, t_dataUncompressed *n_p_dataUncompressed)

inline DNDS_DEVICE_CALLABLE bool isCompressed () const

inline DNDS_DEVICE_CALLABLE index Size () const

inline DNDS_DEVICE_CALLABLE rowsize RowSize () const

inline DNDS_DEVICE_CALLABLE rowsize RowSize (index iRow) const

inline DNDS_DEVICE_CALLABLE rowsize RowSizeMax () const

inline DNDS_DEVICE_CALLABLE rowsize RowSizeField () const

inline DNDS_DEVICE_CALLABLE rowsize RowSizeField (index iRow) const

inline const T &at(index iRow, rowsize iCol) const

inline T &operator()(index iRow, rowsize iCol = 0)

inline const T &operator()(index iRow, rowsize iCol = 0) const

inline T *operator[](index iRow)

inline const T *operator[](index iRow) const

inline DNDS_DEVICE_CALLABLE T * data ()

inline DNDS_DEVICE_CALLABLE size_t DataSize () const

inline DNDS_DEVICE_CALLABLE bool operator== (const self_type &R) const

class RowView

struct CheckResult

struct ConfigContext

Public Members

int nVars = -1

int dim = -1

int gDim = -1

int modelCode = -1

template<typename T>
class ConfigRegistry

Public Static Functions

static inline bool registerField(FieldMeta meta)

static inline bool registerCheck(CrossFieldCheck check)

static inline bool registerContextualCheck(ContextualCheck check)

static inline void registerPostReadHook(std::function<void(T&)> hook)

static inline const std::vector<FieldMeta> &fields()

static inline const std::vector<CrossFieldCheck> &checks()

static inline const std::vector<ContextualCheck> &contextualChecks()

static inline void readFromJson(const nlohmann::ordered_json &j, T &obj)

static inline void writeToJson(nlohmann::ordered_json &j, const T &obj)

static inline nlohmann::ordered_json emitSchema(const std::string &sectionDescription = "")

static inline std::vector<CheckResult> validate(const T &obj)

static inline std::vector<CheckResult> validateWithContext(const T &obj, const ConfigContext &ctx)

static inline void validateKeys(const nlohmann::ordered_json &userJson)

template<typename T>
class ConfigSectionBuilder

Public Functions

template<typename V, typename ...Tags>
inline void field(V T::* member, const char *jsonKey, const char *desc, Tags&&... tags)

template<typename V, typename ...Tags>
inline void field_alias(V T::* member, const char *jsonKey, const char *desc, Tags&&... tags)

template<typename S, typename ...Tags>
inline void field_section(S T::* member, const char *jsonKey, const char *desc, Tags&&... tags)

template<typename S, typename ...Tags>
inline void field_array_of(std::vector<S> T::* member, const char *jsonKey, const char *desc, Tags&&... tags)

template<typename S, typename ...Tags>
inline void field_map_of(std::map<std::string, S> T::* member, const char *jsonKey, const char *desc, Tags&&... tags)

template<typename ...Tags>
inline void field_json(nlohmann::ordered_json T::* member, const char *jsonKey, const char *desc, Tags&&... tags)

template<typename FSchema, typename ...Tags>
inline void field_json_schema(nlohmann::ordered_json T::* member, const char *jsonKey, const char *desc, FSchema &&schemaFn, Tags&&... tags)

template<typename F>
inline auto check(F &&f) -> decltype(f(std::declval<const T&>()), void())

template<typename F>
inline void check(const char *msg, F &&pred)

template<typename F>
inline auto check_ctx(F &&f) -> decltype(f(std::declval<const T&>(), std::declval<const ConfigContext&>()), void())

template<typename F>
inline void post_read(F &&f)

template<typename T, typename Enable = void>
struct ConfigTypeTagOf

template<>
struct ConfigTypeTagOf<bool>

template<>
struct ConfigTypeTagOf<nlohmann::ordered_json>

template<typename T, std::size_t N>
struct ConfigTypeTagOf<std::array<T, N>>

template<>
struct ConfigTypeTagOf<std::string>

template<typename T>
struct ConfigTypeTagOf<std::vector<T>>

template<typename T>
struct ConfigTypeTagOf<T, std::enable_if_t<detail::is_eigen_type<T>::value>>

template<typename T>
struct ConfigTypeTagOf<T, std::enable_if_t<std::is_enum_v<T>>>

template<typename T>
struct ConfigTypeTagOf<T, std::enable_if_t<std::is_floating_point_v<T>>>

template<typename T>
struct ConfigTypeTagOf<T, std::enable_if_t<std::is_integral_v<T> && !std::is_same_v<T, bool>>>

class CsvLog

Public Functions

template<class T_titles>
inline CsvLog(T_titles &&n_titles, std::unique_ptr<std::ostream> n_pOs)

template<class T_titles>
inline CsvLog(T_titles &&n_titles, const std::string &n_log_name_bare, const std::string &n_log_name_suffix = ".csv", int64_t n_n_line_max = 10000)

template<class TMap>
inline void WriteLine(TMap &&title_to_value, int nPrecision)

inline void WriteTitle()

template<class T, class Derived>
class data_vector_base

Subclassed by DNDS::host_device_vector_r1< value_type >, DNDS::host_device_vector_r1< real >, DNDS::host_device_vector_r1< DNDS::EulerP::BC_DeviceView< B > >, DNDS::host_device_vector_r1< TUScalar::t_deviceView< B > >, DNDS::host_device_vector_r1< TUScalarGrad::t_deviceView< B > >, DNDS::host_device_vector_r1< t_scalar >, DNDS::host_device_vector_r1< TView >

template<DeviceBackend B>
struct device_storage_factory

template<>
struct device_storage_factory<DeviceBackend::Host>

class DeviceHostSingleAllocationBase

Subclassed by DNDS::DeviceHostSingleAllocationDirect

Public Functions

virtual void allocate(size_t bytes, DeviceBackend B = DeviceBackend::Unknown) = 0

virtual void free() = 0

virtual uint8_t *get() = 0

virtual size_t bytes() const = 0

virtual DeviceBackend device() = 0

virtual void copy_from_host(uint8_t *host_src, size_t n) = 0

virtual void copy_to_host(uint8_t *host_dst, size_t n) = 0

virtual std::unique_ptr<DeviceHostSingleAllocationBase> clone() = 0

class DeviceHostSingleAllocationDirect : public DNDS::DeviceHostSingleAllocationBase

Public Functions

inline virtual void allocate(size_t bytes, DeviceBackend B = DeviceBackend::Unknown) override

inline virtual void free() override

inline virtual size_t bytes() const override

inline virtual uint8_t *get() override

inline virtual DeviceBackend device() override

inline virtual void copy_to_host(uint8_t *host_dst, size_t n) override

inline virtual void copy_from_host(uint8_t *host_src, size_t n) override

inline virtual std::unique_ptr<DeviceHostSingleAllocationBase> clone() override

template<DeviceBackend B>
class DeviceStorage

template<>
class DeviceStorage<DeviceBackend::Host> : public DNDS::DeviceStorageBase

Public Functions

inline virtual uint8_t *raw_ptr() override

inline virtual void copy_host_to_device(uint8_t *host_ptr, size_t n_bytes) override

inline virtual void copy_device_to_host(uint8_t *host_ptr, size_t n_bytes) override

inline virtual void copy_to_device(uint8_t *device_ptr_dst, size_t n_bytes) override

inline virtual size_t bytes() const override

inline virtual DeviceBackend backend() const override

class DeviceStorageBase

Subclassed by DNDS::DeviceStorage< DeviceBackend::Host >

Public Functions

virtual uint8_t *raw_ptr() = 0

virtual void copy_host_to_device(uint8_t *host_ptr, size_t n_bytes) = 0

virtual void copy_device_to_host(uint8_t *host_ptr, size_t n_bytes) = 0

virtual void copy_to_device(uint8_t *device_ptr_dst, size_t n_bytes) = 0

virtual size_t bytes() const = 0

virtual DeviceBackend backend() const = 0

template<typename Derived>
class DeviceTransferable

Public Functions

inline void to_device(DeviceBackend B)

inline void to_host()

inline DeviceBackend device()

inline index getDeviceArrayBytes()

template<class TView, DeviceBackend B>
struct deviceViewVector

Public Functions

template<class TGetView>
inline deviceViewVector(int32_t nViews, TGetView &&GetView)

inline auto deviceView()

Public Members

host_device_vector<TView> views

template<DeviceBackend B, typename t_scalar, int M, int N>
class EigenMatrixView

struct Empty

struct EmptyNoDefault

class ExprtkWrapperEvaluator

Public Functions

inline void AddScalar(const std::string &name, real init = 0)

inline void AddVector(const std::string &name, int size)

inline real &Var(const std::string &name)

inline real &VarVec(const std::string &name, int i)

inline index VarVecSize(const std::string &name)

inline bool Compiled() const

void Compile(const std::string &expr)

real Evaluate()

void Clear()

struct FieldMeta

Public Members

std::string name

std::string description

ConfigTypeTag typeTag

std::function<void(const nlohmann::ordered_json &j, void *obj)> readField

std::function<void(nlohmann::ordered_json &j, const void *obj)> writeField

std::function<nlohmann::ordered_json()> schemaEntry

std::vector<std::string> enumValues

std::optional<double> minimum

std::optional<double> maximum

std::map<std::string, std::string> auxInfo

class GlobalOffsetsMapping

Public Functions

inline t_IndexVec &RLengths()

inline t_IndexVec &ROffsets()

inline index globalSize() const

inline void setMPIAlignBcast(const MPIInfo &mpi, index myLength)

inline index operator()(MPI_int rank, index val) const

inline bool search(index globalQuery, MPI_int &rank, index &val) const

template<typename T, typename = void>
struct has_static_CommMult : public std::false_type

template<typename T>
struct has_static_CommMult<T, std::void_t<decltype(T::CommMult())>> : public std::true_type

template<typename T, typename = void>
struct has_static_CommType : public std::false_type

template<typename T>
struct has_static_CommType<T, std::void_t<decltype(T::CommType())>> : public std::true_type

template<typename T>
struct host_device_vector_r0 : public std::vector<T>

template<typename T>
class host_device_vector_r1 : public DNDS::data_vector_base<T, host_device_vector_r1<T>>

template<typename t_scalar, int M, int N>
class HostDeviceEigenMatrix

template<typename T>
struct is_ssp : public std::false_type

template<typename T>
struct is_ssp<ssp<T>> : public std::true_type

struct LogSimpleDIValue

template<class real_T = real>
class MatrixBatch

struct UInt16QuadIn64

struct UInt32PairIn64

template<typename Class, typename T>
struct MemberPtr

template<typename T>
struct MemberRef

class MPIBufferHandler

Public Functions

inline MPI_int size()

inline void claim(MPI_Aint cs, int reportRank = 0)

inline void unclaim(MPI_int cs)

inline void *getBuf()

Public Static Functions

static MPIBufferHandler &Instance()

struct MPIInfo

Public Functions

inline MPIInfo(MPI_Comm ncomm)

inline MPIInfo(MPI_Comm nc, int r, int s)

inline void setWorld()

inline bool operator==(const MPIInfo &r) const

Public Members

MPI_Comm comm = MPI_COMM_NULL

int rank = -1

int size = -1

struct MPIReqHolder : public std::vector<MPI_Request>, public std::enable_shared_from_this<MPIReqHolder>

Public Functions

template<typename ...Args>
inline MPIReqHolder(shared_ctor_guard g, Args&&... args)

inline void clear()

Public Static Functions

template<typename ...Args>
static inline ssp<MPIReqHolder> create(Args&&... args)

MPITypePairHolder : public std::vector< MPI_int, MPI_Datatype > > , public std::enable_shared_from_this< MPITypePairHolder >

Public Functions

template<typename ...Args>
inline MPITypePairHolder(shared_ctor_guard g, Args&&... args)

inline void clear()

Public Static Functions

template<typename ...Args>
static inline ssp<MPITypePairHolder> create(Args&&... args)

class ObjectNaming

Subclassed by DNDS::Array< index, _row_size, _row_max, _align >, DNDS::Array< real, _row_size, _row_max, _align >, DNDS::Array< real, _row_size, _row_size, NoAlign >, DNDS::Array< NodePeriodicBits, _row_size, _row_max, _align >, DNDS::Array< T, 1, 1, NoAlign >, DNDS::Array< T, _row_size, _row_max, _align >

Public Functions

inline std::string getObjectIdentity(const std::string &sig) const

template<class T = int>
class ObjectPool

Public Functions

inline ObjectPool()

inline size_t size()

template<class ..._CtorArgs>
inline void resize(size_t N, _CtorArgs&&... __ctorArgs)

template<class TFInit, class ..._CtorArgs>
inline void resizeInit(size_t N, TFInit &&FInit, _CtorArgs&&... __ctorArgs)

inline ObjectPoolAllocated get()

template<class ..._CtorArgs>
inline ObjectPoolAllocated getAlloc(_CtorArgs&&... __ctorArgs)

template<class TFInit, class ..._CtorArgs>
inline ObjectPoolAllocated getAllocInit(TFInit &&FInit, _CtorArgs&&... __ctorArgs)

Public Members

std::shared_ptr<Pool> pPool

class ObjectPoolAllocated

Public Functions

inline operator bool() const

inline uPtrResource &operator->()

struct Pool

Public Functions

inline void recycle(uPtrResource p)

struct ObjName

class OffsetAscendIndexMapping

Public Functions

template<class TpullSet>
inline OffsetAscendIndexMapping(index nmainOffset, index nmainSize, TpullSet &&pullingIndexGlobal, const GlobalOffsetsMapping &LGlobalMapping, const MPIInfo &mpi)

template<class TpushSet, class TpushStart>
inline OffsetAscendIndexMapping(index nmainOffset, index nmainSize, TpushSet &&pushingIndexesLocal, TpushStart &&pushingStarts, const GlobalOffsetsMapping &LGlobalMapping, const MPIInfo &mpi)

inline void sort()

inline index &ghostAt(MPI_int rank, index ighost)

inline bool searchInMain(index globalQuery, index &val) const

inline bool searchInGhost(index globalQuery, MPI_int rank, index &val) const

inline bool searchInAllGhost(index globalQuery, MPI_int &rank, index &val) const

inline bool search(index globalQuery, MPI_int &rank, index &val) const

inline std::tuple<bool, MPI_int, index> search(index globalQuery) const

inline bool search_indexAppend(index globalQuery, MPI_int &rank, index &val) const

inline std::tuple<bool, MPI_int, index> search_indexAppend(index globalQuery) const

inline bool search_indexRank(index globalQuery, MPI_int &rank, index &val) const

inline std::tuple<bool, MPI_int, index> search_indexRank(index globalQuery) const

inline index operator()(MPI_int rank, index val) const

Public Members

tMPI_intVec ghostSizes

t_IndexVec ghostIndex

t_MapIndexVec ghostStart

tMPI_intVec pushIndexSizes

t_MapIndexVec pushIndexStarts

t_IndexVec pushingIndexGlobal

t_IndexVec pullingRequestLocal

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

Subclassed by DNDS::ArrayAdjacency< 1 >, DNDS::ArrayEigenMatrix< nVarsFixed, nVarsFixed >, DNDS::ArrayAdjacency< _row_size, _row_max, _align >, DNDS::ArrayEigenMatrix< _mat_ni, _mat_nj, _mat_ni_max, _mat_nj_max, _align >, DNDS::ArrayEigenVector< _vec_size, _row_max, _align >, DNDS::Geom::ArrayNodePeriodicBits< _row_size, _row_max, _align >

Public Functions

inline void clone(const t_self &R)

inline void WriteSerializer(Serializer::SerializerBaseSSP serializerP, const std::string &name, Serializer::ArrayGlobalOffset offset)

inline void ReadSerializer(Serializer::SerializerBaseSSP serializerP, const std::string &name, Serializer::ArrayGlobalOffset &offset)

inline MPI_Datatype getDataType()

inline MPI_int getTypeMult()

inline void setMPI(const MPIInfo &n_mpi)

inline MPIInfo &getMPI()

inline const MPIInfo &getMPI() const

inline void setDataType(MPI_Datatype n_dType, MPI_int n_TypeMult)

ParArray() = default

inline ParArray(const MPIInfo &n_mpi)

inline ParArray(MPI_Datatype n_dType, MPI_int n_TypeMult, const MPIInfo &n_mpi)

template<typename ...Args>
inline ParArray(ObjName objName, Args&&... args)

inline void AssertDataType()

inline bool AssertConsistent()

inline void createGlobalMapping()

inline index globalSize() const

Array() = default

inline explicit Array(ObjName objName)

inline Array(const self_type &R)

Public Members

t_pLGlobalMapping pLGlobalMapping

MPIInfo mpi

class PerformanceTimer

Public Types

enum TimerType

Values:

enumerator Unknown

enumerator RHS

enumerator Dt

enumerator Reconstruction

enumerator ReconstructionCR

enumerator Limiter

enumerator LimiterA

enumerator LimiterB

enumerator Basis

enumerator Comm

enumerator Comm1

enumerator Comm2

enumerator Comm3

enumerator LinSolve

enumerator LinSolve1

enumerator LinSolve2

enumerator LinSolve3

enumerator Positivity

enumerator PositivityOuter

enumerator __EndTimerType

Public Functions

void StartTimer(TimerType t)

void StartTimer(int t)

void StopTimer(TimerType t)

void StopTimer(int t)

real getTimer(TimerType t)

real getTimerCollective(TimerType t, const MPIInfo &mpi)

template<typename T>
inline real getTimerColOrLoc(T t, const MPIInfo &mpi, bool col)

void clearTimer(TimerType t)

void clearAllTimer()

Public Static Functions

static PerformanceTimer &Instance()

class ScalarStatistics

Public Functions

inline void clear()

inline ScalarStatistics &update(real v)

inline std::tuple<real, real> get()

inline real getSum() const

template<class T>
class ScopedValueAlternator

Public Functions

template<class TAssign>
inline ScopedValueAlternator(T &ref, TAssign &&vAssign)

template<DeviceBackend B, typename T, typename TSize = int64_t>
class vector_DeviceView

template<typename T>
struct vector_hash

namespace CFV

Typedefs

using tPy_FiniteVolume = py_class_ssp<FiniteVolume>

using tPy_ModelEvaluator = py_class_ssp<ModelEvaluator>

template<int dim = 2>
using tPy_VariationalReconstruction = py_class_ssp<VariationalReconstruction<dim>>

using tCoeffPair = DNDS::ArrayPair<DNDS::ArrayEigenVector<NonUniformSize>>

using tCoeff = decltype(tCoeffPair::father)

using t3VecsPair = DNDS::ArrayPair<DNDS::ArrayEigenUniMatrixBatch<3, 1>>

using t3Vecs = decltype(t3VecsPair::father)

using t3VecPair = Geom::tCoordPair

using t3Vec = Geom::tCoord

using t3MatPair = DNDS::ArrayPair<DNDS::ArrayEigenMatrix<3, 3>>

using t3Mat = decltype(t3MatPair::father)

using tVVecPair = ::DNDS::ArrayPair<DNDS::ArrayEigenVector<DynamicSize>>

using tVVec = decltype(tVVecPair::father)

using tMatsPair = DNDS::ArrayPair<DNDS::ArrayEigenUniMatrixBatch<DynamicSize, DynamicSize>>

using tMats = decltype(tMatsPair::father)

using tVecsPair = DNDS::ArrayPair<DNDS::ArrayEigenUniMatrixBatch<DynamicSize, 1>>

using tVecs = decltype(tVecsPair::father)

using tVMatPair = DNDS::ArrayPair<DNDS::ArrayEigenMatrix<DynamicSize, DynamicSize>>

using tVMat = decltype(tVMatPair::father)

using tRecAtrPair = DNDS::ArrayPair<DNDS::ParArray<RecAtr, 1>>

using tRecAtr = decltype(tRecAtrPair::father)

template<int nVarsFixed>
using tURec = ArrayDof<DynamicSize, nVarsFixed>

template<int nVarsFixed>
using tUDof = ArrayDof<nVarsFixed, 1>

template<int nVarsFixed, int gDim>
using tUGrad = ArrayDof<gDim, nVarsFixed>

using tScalarPair = DNDS::ArrayPair<DNDS::ArrayEigenVector<1>>

using tScalar = decltype(tScalarPair::father)

using tPy_RecAtr = py::classh<RecAtr>

Functions

template<>
void finiteVolumeCellOpTest_run<B>(FiniteVolume::t_deviceView<B> &fv, tUDof<DynamicSize>::t_deviceView<B> &u, tUGrad<DynamicSize, 3>::t_deviceView<B> &u_grad, int nIter, const t_jsonconfig &settings)

template<DeviceBackend B, bool iVarOne = false> DNDS_DEVICE_CALLABLE void finiteVolumeCellOpTest (FiniteVolume::t_deviceView< B > &fv, tUDof< DynamicSize >::t_deviceView< B > &u, tUGrad< DynamicSize, 3 >::t_deviceView< B > &u_grad, index iCell, real *local_buf, int iVar=UnInitRowsize)

template<DeviceBackend B>
void finiteVolumeCellOpTest_run(FiniteVolume::t_deviceView<B> &fv, tUDof<DynamicSize>::t_deviceView<B> &u, tUGrad<DynamicSize, 3>::t_deviceView<B> &u_grad, int nIter, const t_jsonconfig &settings)

template<DeviceBackend B>
void finiteVolumeCellOpTest_main(FiniteVolume &fv, tUDof<DynamicSize> &u, tUGrad<DynamicSize, 3> &u_grad, int nIter, const t_jsonconfig &settings)

template<DeviceBackend B, int nVarsFixed, bool iVarOne = false> DNDS_DEVICE_CALLABLE void finiteVolumeCellOpTest_Fixed (FiniteVolume::t_deviceView< B > &fv, typename tUDof< nVarsFixed >::template t_deviceView< B > &u, typename tUGrad< nVarsFixed, 3 >::template t_deviceView< B > &u_grad, index iCell, int iVar=UnInitRowsize)

template<DeviceBackend B, int nVarsFixed>
void finiteVolumeCellOpTest_Fixed_main(FiniteVolume &fv, tUDof<nVarsFixed> &u, tUGrad<nVarsFixed, 3> &u_grad, int nIter, const t_jsonconfig &settings)

template<DeviceBackend B, int nVarsFixed, bool iVarOne = false> DNDS_DEVICE_CALLABLE void finiteVolumeCellOpTest_SOA_ver0 (FiniteVolume::t_deviceView< B > &fv, std::array< tUDof< 1 >::t_deviceView< B >, nVarsFixed > &u, std::array< tUGrad< 1, 3 >::t_deviceView< B >, nVarsFixed > &u_grad, index iCell, int iVar=UnInitRowsize)

template<DeviceBackend B, int nVarsFixed>
void finiteVolumeCellOpTest_SOA_ver0_main(FiniteVolume &fv, std::array<tUDof<1>, nVarsFixed> &u, std::array<tUGrad<1, 3>, nVarsFixed> &u_grad, int nIter, const t_jsonconfig &settings)

template<DeviceBackend B>
void pybind11_BenchmarkFiniteVolume_define(py::module_ &m)

template<DeviceBackend B, int nVarsFixed>
void pybind11_BenchmarkFiniteVolume_define_Fixed(py::module_ &m)

template<DeviceBackend B, int nVarsFixed>
void pybind11_BenchmarkFiniteVolume_define_SOA_ver0(py::module_ &m)

template<int nVarsFixed = 1>
void BuildUDofOnMesh(tUDof<nVarsFixed> &u, const std::string &name, const MPIInfo &mpi, const ssp<Geom::UnstructuredMesh> &mesh, int nVars, bool buildSon = true, bool buildTrans = true, Geom::MeshLoc varloc = Geom::MeshLoc::Cell)

template<int nVarsFixed, int dim>
void BuildUGradDOnMesh(tUGrad<nVarsFixed, dim> &u, const std::string &name, const MPIInfo &mpi, const ssp<Geom::UnstructuredMesh> &mesh, int nVars, bool buildSon = true, bool buildTrans = true, Geom::MeshLoc varloc = Geom::MeshLoc::Cell)

void pybind11_FiniteVolume_define(py::module_ &m)

template<int dim, typename ThetaArray>
inline Eigen::ArrayXd PolynomialSquaredNorm(const ThetaArray &theta)

template<int dim, typename ThetaArray1, typename ThetaArray2>
inline Eigen::ArrayXd PolynomialDotProduct(const ThetaArray1 &theta1, const ThetaArray2 &theta2)

template<typename TinOthers, typename Tout>
static inline void FWBAP_L2_Multiway_Polynomial2D(const TinOthers &uOthers, int Nother, Tout &uOut, real n1 = 1)

template<typename Tcenter, typename TinOthers, typename Tout>
static inline void FMEMM_Multiway_Polynomial2D(const Tcenter &u, const TinOthers &uOthers, int Nother, Tout &uOut, real n1 = 1)

template<typename TinOthers, typename Tout>
static inline void FWBAP_L2_Multiway_PolynomialOrth(const TinOthers &uOthers, int Nother, Tout &uOut, real n1 = 1)

template<typename TinOthers, typename Tout>
inline void FWBAP_L2_Multiway(const TinOthers &uOthers, int Nother, Tout &uOut, real n1 = 1.0)

template<typename Tin1, typename Tin2, typename Tout>
inline void FWBAP_L2_Biway(const Tin1 &u1, const Tin2 &u2, Tout &uOut, real n)

template<typename Tin1, typename Tin2, typename Tout>
inline void FWBAP_L2_Cut_Biway(const Tin1 &u1, const Tin2 &u2, Tout &uOut, real n)

template<typename Tin1, typename Tin2, typename Tout>
inline void FMINMOD_Biway(const Tin1 &u1, const Tin2 &u2, Tout &uOut, real n)

template<typename Tin1, typename Tin2, typename Tout>
inline void FVanLeer_Biway(const Tin1 &u1, const Tin2 &u2, Tout &uOut, real n)

template<int dim, int nVarsFixed, typename Tin1, typename Tin2, typename Tout>
inline void FWBAP_L2_Biway_PolynomialNorm(const Tin1 &u1, const Tin2 &u2, Tout &uOut, real n)

template<int dim, int nVarsFixed, typename Tin1, typename Tin2, typename Tout>
inline void FMEMM_Biway_PolynomialNorm(const Tin1 &u1, const Tin2 &u2, Tout &uOut, real n)

template<typename Tin1, typename Tin2, typename Tout>
inline void FWBAP_L2_Biway_PolynomialOrth(const Tin1 &u1, const Tin2 &u2, Tout &uOut, real n)

void pybind11_ModelEvaluator_define(py::module_ &m)

template<int dim, int powV = 1, class TDiffI, class TDiffJ>
inline void AccumulateDiffOrderContributions(const Eigen::MatrixBase<TDiffI> &DiffI, const Eigen::MatrixBase<TDiffJ> &DiffJ, MatrixXR &Conj, const Eigen::Vector<real, Eigen::Dynamic> &wgd, int cnDiffs, real faceL)

template<int dim = 2>
void pybind11_VariationalReconstruction_define(py::module_ &m)

template<int dim, int nVarsFixed, typename Tin1, typename Tin2, typename Tout>
inline void DispatchBiwayLimiter(int limiterBiwayAlter, const Tin1 &uThis, const Tin2 &uOther, Tout &uOut, real n)

DNDS_SWITCH_INTELLISENSE (template< int dim > template< int nVarsFixed >, template<> template<>) auto VariationalReconstruction< dim >

template<int dim>
inline std::pair<int, int> GetRecDOFRange(int pOrder)

template<int nVarsFixed>
inline void pybind11_define_tURec_alias(py::module_ &m, py::module_ &m_dnds)

template<int nVarsFixed>
inline void pybind11_define_tUDof_alias(py::module_ &m, py::module_ &m_dnds)

template<int nVarsFixed>
inline void pybind11_define_tUGrad_alias(py::module_ &m, py::module_ &m_dnds)

inline void pybind11_define_tVVecPair_alias(py::module_ &m, py::module_ &m_dnds)

inline void pybind11_define_tMatsPair_alias(py::module_ &m, py::module_ &m_dnds)

inline void pybind11_define_RecAtr(py::module_ &m)

inline void pybind11_define_RecAtrArrayPair_and_alias(py::module_ &m)

inline void pybind11_VRDefines_define(py::module_ &m, py::module_ &m_dnds)

DNDS_DEFINE_ENUM_JSON (VRSettings::FunctionalSettings::ScaleType, {{VRSettings::FunctionalSettings::ScaleType::UnknownScale, nullptr}, {VRSettings::FunctionalSettings::ScaleType::MeanAACBB, "MeanAACBB"}, {VRSettings::FunctionalSettings::ScaleType::BaryDiff, "BaryDiff"}, {VRSettings::FunctionalSettings::ScaleType::CellMax, "CellMax"}}) DNDS_DEFINE_ENUM_JSON(VRSettings

DNDS_DEFINE_ENUM_JSON (VRSettings::FunctionalSettings::GeomWeightScheme, {{VRSettings::FunctionalSettings::GeomWeightScheme::UnknownGeomWeight, nullptr}, {VRSettings::FunctionalSettings::GeomWeightScheme::GWNone, "GWNone"}, {VRSettings::FunctionalSettings::GeomWeightScheme::HQM_SD, "HQM_SD"}, {VRSettings::FunctionalSettings::GeomWeightScheme::SD_Power, "SD_Power"}}) DNDS_DEFINE_ENUM_JSON(VRSettings

Variables

static const DeviceBackend B = DeviceBackend::Host

static const int dim = 3

static const int nVarsFixed = 6

class FiniteVolume : public DNDS::DeviceTransferable<FiniteVolume>

Subclassed by DNDS::CFV::VariationalReconstruction< dim >

Public Functions

template<class TArrayPair, class ...TOthers>
inline void MakePairDefaultOnCell(TArrayPair &aPair, const std::string &name, TOthers... others)

template<class TArrayPair, class ...TOthers>
inline void MakePairDefaultOnFace(TArrayPair &aPair, const std::string &name, TOthers... others)

template<DeviceBackend B, int nVarsFixed>
struct finiteVolumeCellOpTest_Fixed_entry

template<int nVarsFixed>
struct finiteVolumeCellOpTest_Fixed_entry<DeviceBackend::Host, nVarsFixed>

template<DeviceBackend B, int nVarsFixed>
struct finiteVolumeCellOpTest_SOA_ver0_entry

template<int nVarsFixed>
struct finiteVolumeCellOpTest_SOA_ver0_entry<DeviceBackend::Host, nVarsFixed>

template<DeviceBackend B>
class FiniteVolumeDeviceView

struct FiniteVolumeSettings

Subclassed by DNDS::CFV::VRSettings

Public Functions

inline DNDS_HOST void WriteIntoJson (json &jsonSetting) const

inline DNDS_HOST void ParseFromJson (const json &jsonSetting)

Public Members

int intOrder = {1}

bool ignoreMeshGeometryDeficiency = false

class ModelEvaluator

Public Functions

inline TU generateBoundaryValue(TU &ULxy, const TU &ULMeanXy, index iCell, index iFace, int iG, const TVec &uNorm, const TMat &normBase, const Geom::tPoint &pPhysics, real t, Geom::t_index btype, bool fixUL = false, int geomMode = 0, int linMode = 0)

struct EvaluateRHSOptions

struct ModelSettings

struct RecAtr

template<int dim = 2>
class VariationalReconstruction : public DNDS::CFV::FiniteVolume

Public Functions

inline void parseSettings(VRSettings::json &j)

template<typename ...Ts>
inline void ApplyPeriodicTransform(int if2c, Geom::t_index faceID, Ts&... data) const

template<class TOut>
inline void FDiffBaseValue(TOut &DiBj, const Geom::tPoint &pPhy, index iCell, index iFace, int iG, int flag = 0)

template<class TList>
inline MatrixXR GetIntPointDiffBaseValue(index iCell, index iFace, rowsize if2c, int iG, TList &&diffList = EigenAll, uint8_t maxDiff = UINT8_MAX)

inline auto GetMatrixSecondary(index iCell, index iFace, index if2c)

template<int nVarsFixed = 5>
void DoReconstruction2ndGrad(tUGrad<nVarsFixed, dim> &uRec, tUDof<nVarsFixed> &u, const TFBoundary<nVarsFixed> &FBoundary, int method)

template<int nVarsFixed = 5>
void DoReconstruction2nd(tURec<nVarsFixed> &uRec, tUDof<nVarsFixed> &u, const TFBoundary<nVarsFixed> &FBoundary, int method, const std::vector<int> &mask)

template<int nVarsFixed = 5>
void DoReconstructionIter(tURec<nVarsFixed> &uRec, tURec<nVarsFixed> &uRecNew, tUDof<nVarsFixed> &u, const TFBoundary<nVarsFixed> &FBoundary, bool putIntoNew = false, bool recordInc = false, bool uRecIsZero = false)

template<int nVarsFixed = 5>
void DoReconstructionIterDiff(tURec<nVarsFixed> &uRec, tURec<nVarsFixed> &uRecDiff, tURec<nVarsFixed> &uRecNew, tUDof<nVarsFixed> &u, const TFBoundaryDiff<nVarsFixed> &FBoundaryDiff)

template<int nVarsFixed = 5>
void DoReconstructionIterSOR(tURec<nVarsFixed> &uRec, tURec<nVarsFixed> &uRecInc, tURec<nVarsFixed> &uRecNew, tUDof<nVarsFixed> &u, const TFBoundaryDiff<nVarsFixed> &FBoundaryDiff, bool reverse = false)

template<int nVarsFixed>
void DoLimiterWBAP_C(tUDof<nVarsFixed> &u, tURec<nVarsFixed> &uRec, tURec<nVarsFixed> &uRecNew, tURec<nVarsFixed> &uRecBuf, tScalarPair &si, bool ifAll, const tFMEig<nVarsFixed> &FM, const tFMEig<nVarsFixed> &FMI, bool putIntoNew = false)

template<int nVarsFixed>
void DoLimiterWBAP_3(tUDof<nVarsFixed> &u, tURec<nVarsFixed> &uRec, tURec<nVarsFixed> &uRecNew, tURec<nVarsFixed> &uRecBuf, tScalarPair &si, bool ifAll, const tFMEig<nVarsFixed> &FM, const tFMEig<nVarsFixed> &FMI, bool putIntoNew = false)

struct VRSettings : public DNDS::CFV::FiniteVolumeSettings

Public Functions

inline void WriteIntoJson(json &jsonSetting) const

inline void ParseFromJson(const json &jsonSetting)

Public Members

int intOrderVRBC = {-2}

bool cacheDiffBase = false

uint8_t cacheDiffBaseSize = UINT8_MAX

bool SORInstead = true

real smoothThreshold = 0.01

real WBAP_nStd = 10

bool normWBAP = false

int limiterBiwayAlter = 0

int subs2ndOrder = 0

int subs2ndOrderGGScheme = 1

real svdTolerance = 0

real bcWeight = 1

struct BaseSettings

struct FunctionalSettings

namespace _Limiters_Internal

Functions

inline real W12n1(real u1, real u2)

inline real W12center(real *u, const int J, real n)

namespace Config

Functions

inline RangeTag range(double min)

inline RangeTag range(double min, double max)

inline InfoTag info(std::string key, std::string value)

inline EnumValuesTag enum_values(std::vector<std::string> vals)

struct EnumValuesTag

struct InfoTag

struct RangeTag

namespace Debug

Functions

bool IsDebugged()

void MPIDebugHold(const MPIInfo &mpi)

void pybind11_Debug(py::module_ &m)

Variables

bool isDebugging = false

namespace detail

Functions

template<typename EnumType>
std::vector<std::string> extractEnumStrings(std::initializer_list<EnumStringPair<EnumType>> pairs)

inline void applyTag(FieldMeta &meta, const Config::RangeTag &tag)

inline void applyTag(FieldMeta &meta, const Config::InfoTag &tag)

inline void applyTag(FieldMeta &meta, const Config::EnumValuesTag &tag)

inline void applyTags(FieldMeta&)

template<typename Tag, typename ...Rest>
void applyTags(FieldMeta &meta, Tag &&tag, Rest&&... rest)

template<typename T, typename V>
std::function<nlohmann::ordered_json()> makeSchemaEntry(V T::* member, const char *desc, const FieldMeta &meta)

template<typename T, typename V>
std::function<void(const nlohmann::ordered_json&, const char*)> makeRangeChecker(const FieldMeta &meta)

template<typename EnumType>
struct EnumStringPair

template<typename T, typename = void>
struct is_eigen_type : public std::false_type

template<typename T>
struct is_eigen_type<T, std::void_t<typename T::Scalar, decltype(static_cast<int>(T::RowsAtCompileTime)), decltype(static_cast<int>(T::ColsAtCompileTime))>> : public std::true_type

namespace Direct

struct DirectPrecControl

template<class Derived, class tComponent, class tVec>
struct LocalLDLTBase

Subclassed by TestBlockLDLT

template<class Derived, class tComponent, class tVec>
struct LocalLUBase

Subclassed by TestBlockLU

struct SerialSymLUStructure

Public Functions

template<class TAdj>
inline void ObtainSymmetricSymbolicFactorization(const TAdj &cell2cellFaceV, const std::vector<index> localPartStarts_in, int iluCode)

namespace ETensor

Functions

template<typename T, Index d0, Index d1, Index d2>
std::ostream &operator<<(std::ostream &out, ETensorR3<T, d0, d1, d2> &R)

template<typename T, Index d0, Index d1, Index d2>
std::ostream &operator<<(std::ostream &out, ETensorR3<T, d0, d1, d2> &&R)

template<typename T, Index d0, Index d1, Index d2>
class ETensorR3

namespace Euler

Typedefs

using tCellScalarFGet = std::function<real(index)>

using tCellScalarList = std::vector<std::tuple<std::string, const tCellScalarFGet>>

Enums

enum EulerModel

Values:

enumerator NS

enumerator NS_SA

enumerator NS_2D

enumerator NS_3D

enumerator NS_SA_3D

enumerator NS_2EQ

enumerator NS_2EQ_3D

enumerator NS_EX

enumerator NS_EX_3D

enum RANSModel

Values:

enumerator RANS_Unknown

enumerator RANS_None

enumerator RANS_SA

enumerator RANS_KOWilcox

enumerator RANS_KOSST

enumerator RANS_RKE

enum EulerBCType

Values:

enumerator BCUnknown

enumerator BCFar

enumerator BCWall

enumerator BCWallInvis

enumerator BCWallIsothermal

enumerator BCOut

enumerator BCOutP

enumerator BCIn

enumerator BCInPsTs

enumerator BCSym

enumerator BCSpecial

Functions

DNDS_DEFINE_ENUM_JSON (RANSModel, { {RANS_Unknown, nullptr}, {RANS_None, "RANS_None"}, {RANS_SA, "RANS_SA"}, {RANS_KOWilcox, "RANS_KOWilcox"}, {RANS_KOSST, "RANS_KOSST"}, {RANS_RKE, "RANS_RKE"}, }) const expr static inline int getnVarsFixed(const EulerModel model)

static inline constexpr int getNVars(EulerModel model)

static inline constexpr int getDim_Fixed(const EulerModel model)

static inline constexpr int getGeomDim_Fixed(const EulerModel model)

template<int nVarsFixed, int mul>
static inline constexpr int nvarsFixedMultiply()

DNDS_DEFINE_ENUM_JSON (EulerBCType, { {BCUnknown, nullptr}, {BCFar, "BCFar"}, {BCWall, "BCWall"}, {BCWallIsothermal, "BCWallIsothermal"}, {BCWallInvis, "BCWallInvis"}, {BCOut, "BCOut"}, {BCOutP, "BCOutP"}, {BCIn, "BCIn"}, {BCInPsTs, "BCInPsTs"}, {BCSym, "BCSym"}, {BCSpecial, "BCSpecial"}, }) inline std

inline nlohmann::ordered_json bcSettingsSchema()

DNDS_SWITCH_INTELLISENSE (template< EulerModel model >,) void EulerEvaluator< model >

DNDS_SWITCH_INTELLISENSE (template< EulerModel model >, template<>) void EulerEvaluator< model >

void paste_read_restart_with_cell_ordering(EulerSolver<model> &self, typename EulerSolver<model>::TDof &u, typename EulerSolver<model>::TDof &uRead, Serializer::SerializerBaseSSP serializerP)

static inline constexpr const char *getSingleBlockAppName(const EulerModel model)

template<EulerModel model>
int RunSingleBlockConsoleApp(int argc, char *argv[])

Variables

static const auto model = NS_SA

static const auto model = NS_SA

static const auto model = NS_SA

static const auto model = NS_SA

static const auto model = NS_SA

static const auto model = NS

template<int nVarsFixed>
struct AnchorPointRecorder

Public Types

using TU = Eigen::Vector<real, nVarsFixed>

Public Functions

inline AnchorPointRecorder(const MPIInfo &_mpi)

inline void Reset()

inline void AddAnchor(const TU &vin, real nDist)

inline void ObtainAnchorMPI()

Public Members

MPIInfo mpi

TU val

real dist = {veryLargeReal}

template<int nVarsFixed>
class ArrayDOFV : public DNDS::ArrayDof<nVarsFixed>

Public Types

using t_self = ArrayDOFV<nVarsFixed>

using t_base = CFV::tUDof<nVarsFixed>

using t_element_mat = typename t_base::t_element_mat

Public Functions

inline void setConstant(real R)

inline void setConstant(const Eigen::Ref<const t_element_mat> &R)

inline void operator+=(const t_self &R)

inline void operator-=(const t_self &R)

inline void operator*=(real R)

inline void operator=(const t_self &R)

inline void addTo(const t_self &R, real r)

inline void operator*=(const std::vector<real> &R)

template<int nVarsFixed_T = nVarsFixed>
inline std::enable_if_t<!(nVarsFixed_T == 1)> operator*=(const ArrayDOFV<1> &R)

inline void operator+=(const Eigen::Vector<real, nVarsFixed> &R)

inline void operator+=(real R)

inline void operator*=(const Eigen::Vector<real, nVarsFixed> &R)

inline void operator*=(const t_self &R)

inline void operator/=(const t_self &R)

inline real norm2()

inline Eigen::Vector<real, nVarsFixed> componentWiseNorm1()

inline Eigen::Vector<real, nVarsFixed> min()

inline real dot(const t_self &R)

template<class TMultL, class TMultR>
inline real dot(const t_self &R, TMultL &&mL, TMultR &&mR)

template<class TR>
inline void setMaxWith(TR R)

template<int nVarsFixed, int gDim>
class ArrayGRADV : public DNDS::ArrayDof<nVarsFixed, gDim>

Public Types

using t_self = ArrayGRADV<nVarsFixed, gDim>

using t_base = CFV::tUGrad<nVarsFixed, gDim>

Public Functions

inline void setConstant(real R)

template<class TR>
inline void setConstant(const TR &R)

inline void operator+=(t_self &R)

inline void operator-=(t_self &R)

inline void operator*=(real R)

inline void operator*=(std::vector<real> &R)

inline void operator*=(ArrayDOFV<1> &R)

inline void operator*=(const Eigen::Array<real, 1, nVarsFixed> &R)

inline void operator=(t_self &R)

template<int nVarsFixed>
class ArrayRECV : public DNDS::ArrayDof<nVarsFixed>

Public Types

using t_self = ArrayRECV<nVarsFixed>

using t_base = CFV::tURec<nVarsFixed>

Public Functions

inline void setConstant(real R)

template<class TR>
inline void setConstant(const TR &R)

inline void operator+=(const t_self &R)

inline void operator-=(const t_self &R)

inline void operator*=(real R)

inline void operator*=(const std::vector<real> &R)

inline void operator*=(const ArrayDOFV<1> &R)

inline void operator*=(const Eigen::Array<real, 1, nVarsFixed> &R)

inline void operator=(const t_self &R)

inline void addTo(const t_self &R, const Eigen::Array<real, 1, nVarsFixed> &r)

inline void addTo(const t_self &R, real r)

inline real norm2()

inline real dot(const t_self &R)

inline auto dotV(const t_self &R)

template<EulerModel model>
class BoundaryHandler

Public Types

using TU_R = Eigen::Vector<real, nVarsFixed>

using TU = Eigen::VectorFMTSafe<real, nVarsFixed>

using TFlags = std::map<std::string, uint32_t>

Public Functions

inline BoundaryHandler(int _nVars)

inline std::vector<std::string> GetAllNames()

inline Geom::t_index size()

inline void RenewID2name()

inline void PushBCWithJson(const json &gS)

inline Geom::t_index GetIDFromName(const std::string &name)

inline auto GetNameFormID(Geom::t_index id)

inline EulerBCType GetTypeFromID(Geom::t_index id)

inline TU GetValueFromID(Geom::t_index id)

inline Eigen::Vector<real, Eigen::Dynamic> GetValueExtraFromID(Geom::t_index id)

inline uint32_t GetFlagFromID(Geom::t_index id, const std::string &key)

inline uint32_t GetFlagFromIDSoft(Geom::t_index id, const std::string &key)

Public Static Attributes

static const int nVarsFixed = getnVarsFixed(model)

Friends

inline friend void from_json(const json &j, BoundaryHandler<model> &bc)

inline friend void to_json(json &j, const BoundaryHandler<model> &bc)

class CLDriver

Public Functions

inline CLDriver(const CLDriverSettings &settingsIn)

inline real GetAOA()

inline void Update(index iter, real CL, const MPIInfo &mpi)

inline bool ConvergedAtTarget()

inline Geom::tGPoint GetAOARotation()

inline Geom::tPoint GetCL0Direction()

inline Geom::tPoint GetCD0Direction()

inline real GetForce2CoeffRatio()

struct CLDriverSettings

Public Members

real AOAInit = 0.0

std::string AOAAxis = "z"

std::string CL0Axis = "y"

std::string CD0Axis = "x"

real refArea = 1.0

real refDynamicPressure = 0.5

real targetCL = 0.0

real CLIncrementRelax = 0.25

real thresholdTargetRatio = 0.5

index nIterStartDrive = INT32_MAX

index nIterConvergeMin = 50

real CLconvergeThreshold = 1e-3

index CLconvergeWindow = 10

index CLconvergeLongWindow = 100

real CLconvergeLongThreshold = 1e-4

bool CLconvergeLongStrictAoA = false

template<EulerModel model = NS>
class EulerEvaluator

RHS evaluation flags (bitwise OR combinable)

static const uint64_t RHS_No_Flags = 0x0ull

static const uint64_t RHS_Ignore_Viscosity = 0x1ull << 0

static const uint64_t RHS_Dont_Update_Integration = 0x1ull << 1

static const uint64_t RHS_Dont_Record_Bud_Flux = 0x1ull << 2

static const uint64_t RHS_Direct_2nd_Rec = 0x1ull << 8

static const uint64_t RHS_Direct_2nd_Rec_1st_Conv = 0x1ull << 9

static const uint64_t RHS_Direct_2nd_Rec_use_limiter = 0x1ull << 10

static const uint64_t RHS_Direct_2nd_Rec_already_have_uGradBufNoLim = 0x1ull << 11

static const uint64_t RHS_Recover_IncFScale = 0x1ull << 12

Limiter flags

static const uint64_t LIMITER_UGRAD_No_Flags = 0x0ull

static const uint64_t LIMITER_UGRAD_Disable_Shock_Limiter = 0x1ull << 0

Public Types

using Traits = EulerModelTraits<model>

typedef Eigen::VectorFMTSafe<real, dim> TVec

typedef Eigen::MatrixFMTSafe<real, dim, Eigen::Dynamic, Eigen::ColMajor, dim, MaxBatch> TVec_Batch

typedef Eigen::MatrixFMTSafe<real, dim, dim> TMat

typedef Eigen::MatrixFMTSafe<real, dim, Eigen::Dynamic, Eigen::ColMajor, dim, MaxBatchMult(3)> TMat_Batch

typedef Eigen::VectorFMTSafe<real, nVarsFixed> TU

typedef Eigen::MatrixFMTSafe<real, nVarsFixed, Eigen::Dynamic, Eigen::ColMajor, nVarsFixed, MaxBatch> TU_Batch

typedef Eigen::MatrixFMTSafe<real, 1, Eigen::Dynamic, Eigen::RowMajor, 1, MaxBatch> TReal_Batch

typedef Eigen::MatrixFMTSafe<real, nVarsFixed, nVarsFixed> TJacobianU

typedef Eigen::MatrixFMTSafe<real, dim, nVarsFixed> TDiffU

typedef Eigen::MatrixFMTSafe<real, Eigen::Dynamic, nVarsFixed, Eigen::ColMajor, MaxBatchMult(3)> TDiffU_Batch

typedef Eigen::MatrixFMTSafe<real, nVarsFixed, dim> TDiffUTransposed

typedef ArrayDOFV<nVarsFixed> TDof

typedef ArrayRECV<nVarsFixed> TRec

typedef ArrayRECV<1> TScalar

typedef CFV::VariationalReconstruction<gDim> TVFV

typedef ssp<CFV::VariationalReconstruction<gDim>> TpVFV

typedef ssp<BoundaryHandler<model>> TpBCHandler

using tFCompareField = std::function<TU(const Geom::tPoint&, real)>

using tFCompareFieldWeight = std::function<real(const Geom::tPoint&, real)>

Public Functions

inline void setPassiveDiscardSource(bool n)

inline int GetAxisSymmetric()

inline EulerEvaluator(const decltype(mesh) &Nmesh, const decltype(vfv) &Nvfv, const decltype(pBCHandler) &npBCHandler, const EulerEvaluatorSettings<model> &nSettings, int n_nVars = getNVars(model))

void GetWallDist()

void EvaluateDt(ArrayDOFV<1> &dt, ArrayDOFV<nVarsFixed> &u, ArrayRECV<nVarsFixed> &uRec, real CFL, real &dtMinall, real MaxDt, bool UseLocaldt, real t, uint64_t flags = DT_No_Flags)

void EvaluateRHS(ArrayDOFV<nVarsFixed> &rhs, JacobianDiagBlock<nVarsFixed> &JSource, ArrayDOFV<nVarsFixed> &u, ArrayRECV<nVarsFixed> &uRecUnlim, ArrayRECV<nVarsFixed> &uRec, ArrayDOFV<1> &uRecBeta, ArrayDOFV<1> &cellRHSAlpha, bool onlyOnHalfAlpha, real t, uint64_t flags = RHS_No_Flags)

void LUSGSMatrixInit(JacobianDiagBlock<nVarsFixed> &JDiag, JacobianDiagBlock<nVarsFixed> &JSource, ArrayDOFV<1> &dTau, real dt, real alphaDiag, ArrayDOFV<nVarsFixed> &u, ArrayRECV<nVarsFixed> &uRec, int jacobianCode, real t)

void LUSGSMatrixVec(real alphaDiag, real t, ArrayDOFV<nVarsFixed> &u, ArrayDOFV<nVarsFixed> &uInc, JacobianDiagBlock<nVarsFixed> &JDiag, ArrayDOFV<nVarsFixed> &AuInc)

void LUSGSMatrixToJacobianLU(real alphaDiag, real t, ArrayDOFV<nVarsFixed> &u, JacobianDiagBlock<nVarsFixed> &JDiag, JacobianLocalLU<nVarsFixed> &jacLU)

void UpdateLUSGSForward(real alphaDiag, real t, ArrayDOFV<nVarsFixed> &rhs, ArrayDOFV<nVarsFixed> &u, ArrayDOFV<nVarsFixed> &uInc, JacobianDiagBlock<nVarsFixed> &JDiag, ArrayDOFV<nVarsFixed> &uIncNew)

void UpdateLUSGSBackward(real alphaDiag, real t, ArrayDOFV<nVarsFixed> &rhs, ArrayDOFV<nVarsFixed> &u, ArrayDOFV<nVarsFixed> &uInc, JacobianDiagBlock<nVarsFixed> &JDiag, ArrayDOFV<nVarsFixed> &uIncNew)

void UpdateSGS(real alphaDiag, real t, ArrayDOFV<nVarsFixed> &rhs, ArrayDOFV<nVarsFixed> &u, ArrayDOFV<nVarsFixed> &uInc, ArrayDOFV<nVarsFixed> &uIncNew, JacobianDiagBlock<nVarsFixed> &JDiag, bool forward, bool gsUpdate, TU &sumInc, bool uIncIsZero = false)

void LUSGSMatrixSolveJacobianLU(real alphaDiag, real t, ArrayDOFV<nVarsFixed> &rhs, ArrayDOFV<nVarsFixed> &u, ArrayDOFV<nVarsFixed> &uInc, ArrayDOFV<nVarsFixed> &uIncNew, ArrayDOFV<nVarsFixed> &bBuf, JacobianDiagBlock<nVarsFixed> &JDiag, JacobianLocalLU<nVarsFixed> &jacLU, bool uIncIsZero, TU &sumInc)

void UpdateSGSWithRec(real alphaDiag, real t, ArrayDOFV<nVarsFixed> &rhs, ArrayDOFV<nVarsFixed> &u, ArrayRECV<nVarsFixed> &uRec, ArrayDOFV<nVarsFixed> &uInc, ArrayRECV<nVarsFixed> &uRecInc, JacobianDiagBlock<nVarsFixed> &JDiag, bool forward, TU &sumInc)

void FixUMaxFilter(ArrayDOFV<nVarsFixed> &u)

void TimeAverageAddition(ArrayDOFV<nVarsFixed> &w, ArrayDOFV<nVarsFixed> &wAveraged, real dt, real &tCur)

void MeanValueCons2Prim(ArrayDOFV<nVarsFixed> &u, ArrayDOFV<nVarsFixed> &w)

void MeanValuePrim2Cons(ArrayDOFV<nVarsFixed> &w, ArrayDOFV<nVarsFixed> &u)

void EvaluateNorm(Eigen::Vector<real, -1> &res, ArrayDOFV<nVarsFixed> &rhs, index P = 1, bool volWise = false, bool average = false)

void EvaluateRecNorm(Eigen::Vector<real, -1> &res, ArrayDOFV<nVarsFixed> &u, ArrayRECV<nVarsFixed> &uRec, index P = 1, bool compare = false, const tFCompareField &FCompareField = [](const Geom::tPoint &p, real t) { return TU::Zero();}, const tFCompareFieldWeight &FCompareFieldWeight = [](const Geom::tPoint &p, real t) { return 1.0;}, real t = 0)

void LimiterUGrad(ArrayDOFV<nVarsFixed> &u, ArrayGRADV<nVarsFixed, gDim> &uGrad, ArrayGRADV<nVarsFixed, gDim> &uGradNew, uint64_t flags = LIMITER_UGRAD_No_Flags)

void EvaluateURecBeta(ArrayDOFV<nVarsFixed> &u, ArrayRECV<nVarsFixed> &uRec, ArrayDOFV<1> &uRecBeta, index &nLim, real &betaMin, int flag)

bool AssertMeanValuePP(ArrayDOFV<nVarsFixed> &u, bool panic)

void EvaluateCellRHSAlpha(ArrayDOFV<nVarsFixed> &u, ArrayRECV<nVarsFixed> &uRec, ArrayDOFV<1> &uRecBeta, ArrayDOFV<nVarsFixed> &res, ArrayDOFV<1> &cellRHSAlpha, index &nLim, real &alphaMin, real relax, int compress = 1, int flag = 0)

void EvaluateCellRHSAlphaExpansion(ArrayDOFV<nVarsFixed> &u, ArrayRECV<nVarsFixed> &uRec, ArrayDOFV<1> &uRecBeta, ArrayDOFV<nVarsFixed> &res, ArrayDOFV<1> &cellRHSAlpha, index &nLim, real alphaMin)

void MinSmoothDTau(ArrayDOFV<1> &dTau, ArrayDOFV<1> &dTauNew)

inline real muEff(const TU &U, real T)

inline real getMuTur(const TU &uMean, const TDiffU &GradUMeanXY, real muRef, real muf, index iFace)

inline void visFluxTurVariable(const TU &UMeanXYC, const TDiffU &DiffUxyPrimC, real muRef, real mufPhy, real muTur, const TVec &uNormC, index iFace, TU &VisFlux)

inline void UFromCell2Face(TU &u, index iFace, index iCell, rowsize if2c)

inline void UFromFace2Cell(TU &u, index iFace, index iCell, rowsize if2c)

inline void UFromOtherCell(TU &u, index iFace, index iCell, index iCellOther, rowsize if2c)

inline void DiffUFromCell2Face(TDiffU &u, index iFace, index iCell, rowsize if2c, bool reverse = false)

void fluxFace(const TU_Batch &ULxy, const TU_Batch &URxy, const TU &ULMeanXy, const TU &URMeanXy, const TDiffU_Batch &DiffUxy, const TDiffU_Batch &DiffUxyPrim, const TVec_Batch &unitNorm, const TVec_Batch &vg, const TVec &unitNormC, const TVec &vgC, TU_Batch &FLfix, TU_Batch &FRfix, TU_Batch &finc, TReal_Batch &lam0V, TReal_Batch &lam123V, TReal_Batch &lam4V, Geom::t_index btype, typename Gas::RiemannSolverType rsType, index iFace, bool ignoreVis)

TU source(const TU &UMeanXy, const TDiffU &DiffUxy, const Geom::tPoint &pPhy, TJacobianU &jacobian, index iCell, index ig, int Mode)

inline auto fluxJacobian0_Right(TU &UR, const TVec &uNorm, Geom::t_index btype)

inline TU fluxJacobian0_Right_Times_du(const TU &U, const TU &UOther, const TVec &n, const TVec &vg, Geom::t_index btype, const TU &dU, real lambdaMain, real lambdaC, real lambdaVis, real lambda0, real lambda123, real lambda4, int useRoeTerm, int incFsign = -1, int omitF = 0)

inline TVec GetFaceVGrid(index iFace, index iG)

inline TVec GetFaceVGrid(index iFace, index iG, const Geom::tPoint &pPhy)

inline TVec GetFaceVGridFromCell(index iFace, index iCell, int if2c, index iG)

inline void TransformVelocityRotatingFrame(TU &U, const Geom::tPoint &pPhysics, int direction)

inline void TransformURotatingFrame(TU &U, const Geom::tPoint &pPhysics, int direction)

inline void TransformURotatingFrame_ABS_VELO(TU &U, const Geom::tPoint &pPhysics, int direction)

inline void updateBCAnchors(ArrayDOFV<nVarsFixed> &u, ArrayRECV<nVarsFixed> &uRec)

void updateBCProfiles(ArrayDOFV<nVarsFixed> &u, ArrayRECV<nVarsFixed> &uRec)

void updateBCProfilesPressureRadialEq()

TU generateBoundaryValue(TU &ULxy, const TU &ULMeanXy, index iCell, index iFace, int iG, const TVec &uNorm, const TMat &normBase, const Geom::tPoint &pPhysics, real t, Geom::t_index btype, bool fixUL = false, int geomMode = 0, int linMode = 0)

inline void PrintBCProfiles(const std::string &name, ArrayDOFV<nVarsFixed> &u, ArrayRECV<nVarsFixed> &uRec)

inline void ConsoleOutputBndIntegrations()

inline void BndIntegrationLogWriteLine(const std::string &name, index step, index stage, index iter)

inline std::tuple<real, real, real> CLDriverGetIntegrationUpdate(index iter)

inline TU CompressRecPart(const TU &umean, const TU &uRecInc, bool &compressed)

inline TU CompressInc(const TU &u, const TU &uInc)

inline void FixIncrement(ArrayDOFV<nVarsFixed> &cx, ArrayDOFV<nVarsFixed> &cxInc, real alpha = 1.0)

inline void AddFixedIncrement(ArrayDOFV<nVarsFixed> &cx, ArrayDOFV<nVarsFixed> &cxInc, real alpha = 1.0)

inline void CentralSmoothResidual(ArrayDOFV<nVarsFixed> &r, ArrayDOFV<nVarsFixed> &rs, ArrayDOFV<nVarsFixed> &rtemp, int nStep = 0)

void InitializeUDOF(ArrayDOFV<nVarsFixed> &u)

void InitializeOutputPicker(OutputPicker &op, OutputOverlapDataRefs dataRefs)

Public Members

ssp<Geom::UnstructuredMesh> mesh

ssp<BoundaryHandler<model>> pBCHandler

int kAv = 0

std::vector<real> lambdaFace

std::vector<real> lambdaFaceC

std::vector<real> lambdaFaceVis

std::vector<real> lambdaFace0

std::vector<real> lambdaFace123

std::vector<real> lambdaFace4

std::vector<real> deltaLambdaFace

ArrayDOFV<1> deltaLambdaCell

std::vector<TDiffU> gradUFix

std::vector<Eigen::Vector<real, Eigen::Dynamic>> dWall

std::vector<real> dWallFace

std::map<Geom::t_index, AnchorPointRecorder<nVarsFixed>> anchorRecorders

std::map<Geom::t_index, OneDimProfile<nVarsFixed>> profileRecorders

std::map<Geom::t_index, IntegrationRecorder> bndIntegrations

std::map<Geom::t_index, std::ofstream> bndIntegrationLogs

std::set<Geom::t_index> cLDriverBndIDs

std::unique_ptr<CLDriver> pCLDriver

ArrayGRADV<nVarsFixed, gDim> uGradBufNoLim

Eigen::Vector<real, -1> fluxWallSum

std::vector<TU> fluxBnd

std::vector<TVec> fluxBndForceT

index nFaceReducedOrder = 0

ssp<Direct::SerialSymLUStructure> symLU

EulerEvaluatorSettings<model> settings

Public Static Functions

static inline constexpr int MaxBatchMult(int n)

static inline void InitializeFV(ssp<Geom::UnstructuredMesh> &mesh, TpVFV vfv, TpBCHandler pBCHandler)

Public Static Attributes

static const int nVarsFixed = getnVarsFixed(model)

static const int dim = getDim_Fixed(model)

static const int gDim = getGeomDim_Fixed(model)

static const auto I4 = dim + 1

static const int MaxBatch = 16

static const uint64_t DT_No_Flags = 0x0ull

static const uint64_t DT_Dont_update_lambda01234 = 0x1ull << 0

static const int EvaluateURecBeta_DEFAULT = 0x00

static const int EvaluateURecBeta_COMPRESS_TO_MEAN = 0x01

static const int EvaluateCellRHSAlpha_DEFAULT = 0x00

static const int EvaluateCellRHSAlpha_MIN_IF_NOT_ONE = 0x01

static const int EvaluateCellRHSAlpha_MIN_ALL = 0x02

struct OutputOverlapDataRefs

Public Members

ArrayDOFV<nVarsFixed> &u

ArrayRECV<nVarsFixed> &uRec

ArrayDOFV<1> &betaPP

ArrayDOFV<1> &alphaPP

template<EulerModel model>
struct EulerEvaluatorSettings

Jacobian Options

bool useScalarJacobian = false

bool useRoeJacobian = false

bool noRsOnWall = false

bool noGRPOnWall = false

bool ignoreSourceTerm = false

Reconstruction

int direct2ndRecMethod = 1

int specialBuiltinInitializer = 0

real uRecAlphaCompressPower = 1

real uRecBetaCompressPower = 1

bool forceVolURecBeta = true

bool ppEpsIsRelaxed = false

Riemann Solver Configuration

Gas::RiemannSolverType rsType = Gas::Roe

Gas::RiemannSolverType rsTypeAux = Gas::UnknownRS

Gas::RiemannSolverType rsTypeWall = Gas::UnknownRS

real rsFixScale = 1

real rsIncFScale = 1

int rsMeanValueEig = 0

int rsRotateScheme = 0

Wall-Distance Computation

real minWallDist = 1e-12

int wallDistExection = 0

real wallDistRefineMax = 1

int wallDistScheme = 0

int wallDistCellLoadSize = 1024 * 32

int wallDistIter = 1000

int wallDistLinSolver = 0

real wallDistResTol = 1e-4

int wallDistIterStart = 100

int wallDistPoissonP = 2

real wallDistDTauScale = 100.

int wallDistNJacobiSweep = 10

RANS / DES Configuration

real SADESScale = veryLargeReal

int SADESMode = 1

RANSModel ransModel = RANSModel::RANS_None

int ransUseQCR = 0

int ransSARotCorrection = 1

int ransEigScheme = 0

int ransForce2nd = 0

int ransSource2nd = 0

Viscous Flux and Source Options

int source2nd = 0

int usePrimGradInVisFlux = 0

int useSourceGradFixGG = 0

int nCentralSmoothStep = 0

real centralSmoothEps = 0.5

Eigen::Vector<real, 3> constMassForce = Eigen::Vector<real, 3>{0, 0, 0}

Public Types

using Traits = EulerModelTraits<model>

Public Functions

EulerEvaluatorSettings() = default

inline EulerEvaluatorSettings(int nVars)

inline void finalize()

Public Members

real RANSBottomLimit = 0.01

struct DNDS::Euler::EulerEvaluatorSettings::FrameConstRotation frameConstRotation

CLDriverSettings cLDriverSettings

std::vector<std::string> cLDriverBCNames

Eigen::Vector<real, -1> farFieldStaticValue = Eigen::Vector<real, 5>{1, 0, 0, 0, 2.5}

std::vector<BoxInitializer> boxInitializers

std::vector<PlaneInitializer> planeInitializers

std::vector<ExprtkInitializer> exprtkInitializers

struct DNDS::Euler::EulerEvaluatorSettings::IdealGasProperty idealGasProperty

int _nVars = 0

Eigen::Vector<real, -1> refU

Eigen::Vector<real, -1> refUPrim

Public Static Attributes

static const int nVarsFixed = getnVarsFixed(model)

static const int dim = getDim_Fixed(model)

static const int gDim = getGeomDim_Fixed(model)

static const auto I4 = dim + 1

struct BoxInitializer

Public Members

real z1 = {0}

Eigen::Vector<real, -1> v

struct ExprtkInitializer

Public Functions

inline std::string GetExpr() const

Public Members

std::vector<std::string> exprs

struct FrameConstRotation

Public Functions

inline real Omega()

inline Geom::tPoint vOmega()

inline Geom::tPoint rVec(const Geom::tPoint &r)

inline Geom::tGPoint rtzFrame(const Geom::tPoint &r)

Public Members

bool enabled = false

Geom::tPoint axis = Geom::tPoint{0, 0, 1}

Geom::tPoint center = Geom::tPoint{0, 0, 0}

real rpm = 0

struct IdealGasProperty

Public Functions

inline void recomputeDerived()

Public Members

real gamma = 1.4

real Rgas = 1

real muGas = 1

real prGas = 0.72

real CpGas = Rgas * gamma / (gamma - 1)

real TRef = 273.15

real CSutherland = 110.4

int muModel = 1

struct PlaneInitializer

Public Members

real h = {0}

Eigen::Vector<real, -1> v

template<EulerModel model>
struct EulerModelTraits

Public Static Attributes

static constexpr int nVarsFixed = getnVarsFixed(model)

static constexpr int dim = getDim_Fixed(model)

static constexpr int gDim = getGeomDim_Fixed(model)

static constexpr bool hasSA = (model == NS_SA || model == NS_SA_3D)

static constexpr bool has2EQ = (model == NS_2EQ || model == NS_2EQ_3D)

static constexpr bool hasRANS = hasSA || has2EQ

static constexpr int nRANSVars = hasSA ? 1 : (has2EQ ? 2 : 0)

static constexpr bool isExtended = (model == NS_EX || model == NS_EX_3D)

static constexpr bool isPlainNS = !hasRANS && !isExtended

static constexpr bool isGeom2D = (gDim == 2)

static constexpr bool isGeom3D = (gDim == 3)

template<EulerModel model>
class EulerSolver

Accessors

inline auto getMPI() const

inline auto getMesh() const

inline auto getVFV() const

Test accessors (for unit testing the evaluator pipeline)

inline auto &getU()

inline auto &getURec()

inline auto &getURecNew()

inline auto &getURecLimited()

inline auto &getEval()

inline auto &getConfiguration()

inline auto &getJSource()

inline auto &getBetaPP()

inline auto &getAlphaPP()

inline auto &getDTauTmp()

inline auto &getIfUseLimiter()

inline auto &getBCHandler()

Public Types

enum PrintDataMode

Values:

enumerator PrintDataLatest

enumerator PrintDataTimeAverage

typedef EulerEvaluator<model> TEval

typedef TEval::TU TU

typedef TEval::TDiffU TDiffU

typedef TEval::TJacobianU TJacobianU

typedef TEval::TVec TVec

typedef TEval::TMat TMat

typedef TEval::TDof TDof

typedef TEval::TRec TRec

typedef TEval::TScalar TScalar

typedef TEval::TVFV TVFV

typedef TEval::TpVFV TpVFV

using tGMRES_u = Linear::GMRES_LeftPreconditioned<TDof>

using tGMRES_uRec = Linear::GMRES_LeftPreconditioned<TRec>

using tPCG_uRec = Linear::PCG_PreconditionedRes<TRec, Eigen::Array<real, 1, Eigen::Dynamic>>

using tAdditionalCellScalarList = tCellScalarList

Public Functions

inline EulerSolver(const MPIInfo &nmpi, int n_nVars = getNVars(model))

inline ~EulerSolver()

inline void ConfigureFromJson(const std::string &jsonName, bool read = false, const std::string &jsonMergeName = "", const std::vector<std::string> &overwriteKeys = {}, const std::vector<std::string> &overwriteValues = {})

void ReadMeshAndInitialize()

inline void PrintConfig(bool updateCommit = false)

void ReadRestart(std::string fname)

void ReadRestartOtherSolver(std::string fname, const std::vector<int> &dimStore)

void PrintRestart(std::string fname)

void PrintData(const std::string &fname, const std::string &fnameSeries, const tCellScalarFGet &odeResidualF, tAdditionalCellScalarList &additionalCellScalars, TEval &eval, real TSimu = -1.0, PrintDataMode mode = PrintDataLatest)

inline void WriteSerializer(Serializer::SerializerBaseSSP serializerP, const std::string &name)

template<class TVal>
inline std::enable_if_t<std::is_arithmetic_v<std::remove_reference_t<TVal>>> FillLogValue(tLogSimpleDIValueMap &v_map, const std::string &name, TVal &&val)

template<class TVal>
inline std::enable_if_t<!std::is_arithmetic_v<std::remove_reference_t<TVal>>> FillLogValue(tLogSimpleDIValueMap &v_map, const std::string &name, TVal &&val)

inline std::tuple<std::unique_ptr<CsvLog>, tLogSimpleDIValueMap> LogErrInitialize()

void RunImplicitEuler()

void InitializeRunningEnvironment(RunningEnvironment &env)

void solveLinear(real alphaDiag, real t, TDof &cres, TDof &cx, TDof &cxInc, TRec &uRecC, TRec uRecIncC, JacobianDiagBlock<nVarsFixed> &JDC, tGMRES_u &gmres, int gridLevel)

void doPrecondition(real alphaDiag, real t, TDof &crhs, TDof &cx, TDof &cxInc, TDof &uTemp, JacobianDiagBlock<nVarsFixed> &JDC, TU &sgsRes, bool &inputIsZero, bool &hasLUDone, int gridLevel)

bool functor_fstop(int iter, ArrayDOFV<nVarsFixed> &cres, int iStep, RunningEnvironment &env)

bool functor_fmainloop(RunningEnvironment &env)

Public Members

nlohmann::ordered_json gSetting

std::string output_stamp = ""

Public Static Attributes

static const int nVarsFixed = TEval::nVarsFixed

static const int dim = TEval::dim

static const int gDim = TEval::gDim

static const int I4 = TEval::I4

struct Configuration

Public Functions

inline void ReadWriteJson(nlohmann::ordered_json &jsonObj, int nVars, bool read)

Public Members

EulerEvaluatorSettings<model> eulerSettings

CFV::VRSettings vfvSettings

nlohmann::ordered_json bcSettings = nlohmann::ordered_json::array()

std::map<std::string, std::string> bcNameMapping

struct BoundaryDefinition

struct ConvergenceControl

struct DataIOControl

struct ImplicitCFLControl

struct ImplicitReconstructionControl

struct LimiterControl

struct LinearSolverControl

struct CoarseGridLinearSolverControl

struct Others

struct OutputControl

struct RestartState

struct TimeAverageControl

struct TimeMarchControl

struct RunningEnvironment

struct IntegrationRecorder

Public Functions

inline IntegrationRecorder(const MPIInfo &_nmpi, int siz)

inline void Reset()

template<class TU>
inline void Add(TU &&add, real dAdd)

inline void Reduce()

Public Members

Eigen::Vector<real, Eigen::Dynamic> v

real div

MPIInfo mpi

template<int nVarsFixed>
class JacobianDiagBlock

Public Types

using TU = Eigen::Vector<real, nVarsFixed>

using tComponent = Eigen::Matrix<real, nVarsFixed, nVarsFixed>

using tComponentDiag = Eigen::Vector<real, nVarsFixed>

Public Functions

inline JacobianDiagBlock()

inline void SetModeAndInit(int mode, int nVarsC, ArrayDOFV<nVarsFixed> &mock)

inline bool isBlock() const

inline auto getBlock(index iCell)

inline auto getDiag(index iCell)

inline tComponent getValue(index iCell) const

inline index Size()

inline void GetInvert()

template<class TV>
inline TU MatVecLeft(index iCell, TV v)

template<class TV>
inline TU MatVecLeftInvert(index iCell, TV v)

inline void clearValues()

template<int nVarsFixed>
struct JacobianLocalLDLT : public DNDS::Direct::LocalLDLTBase<JacobianLocalLDLT<nVarsFixed>, Eigen::Matrix<real, nVarsFixed, nVarsFixed>, ArrayDOFV<nVarsFixed>>

Public Types

using tLocalMat = ArrayEigenUniMatrixBatch<nVarsFixed, nVarsFixed>

using tComponent = Eigen::Matrix<real, nVarsFixed, nVarsFixed>

using tVec = ArrayDOFV<nVarsFixed>

using tBase = Direct::LocalLDLTBase<JacobianLocalLDLT<nVarsFixed>, Eigen::Matrix<real, nVarsFixed, nVarsFixed>, ArrayDOFV<nVarsFixed>>

Public Functions

inline JacobianLocalLDLT(const ssp<Direct::SerialSymLUStructure> &nMesh, int nVarsC)

inline void setZero()

inline auto GetDiag(index i)

inline auto GetLower(index i, int iInLow)

inline void PrintLog()

inline tComponent InvertDiag(const tComponent &v)

Public Members

tLocalMat LDU

template<int nVarsFixed>
struct JacobianLocalLU : public DNDS::Direct::LocalLUBase<JacobianLocalLU<nVarsFixed>, Eigen::Matrix<real, nVarsFixed, nVarsFixed>, ArrayDOFV<nVarsFixed>>

Public Types

using tLocalMat = ArrayEigenUniMatrixBatch<nVarsFixed, nVarsFixed>

using tComponent = Eigen::Matrix<real, nVarsFixed, nVarsFixed>

using tVec = ArrayDOFV<nVarsFixed>

using tBase = Direct::LocalLUBase<JacobianLocalLU<nVarsFixed>, Eigen::Matrix<real, nVarsFixed, nVarsFixed>, ArrayDOFV<nVarsFixed>>

Public Functions

inline JacobianLocalLU(const ssp<Direct::SerialSymLUStructure> &nMesh, int nVarsC)

inline void setZero()

inline auto GetDiag(index i)

inline auto GetLower(index i, int iInLow)

inline auto GetUpper(index i, int iInUpp)

inline void PrintLog()

inline tComponent InvertDiag(const tComponent &v)

Public Members

tLocalMat LDU

template<int nVarsFixed>
class JacobianValue

Public Types

enum Type

Values:

enumerator Diagonal

enumerator DiagonalBlock

enumerator Full

Public Functions

inline void SetDiagonal(ArrayDOFV<nVarsFixed> &uDof)

inline void SetDiagonalBlock(ArrayDOFV<nVarsFixed> &uDof)

inline void SetFull(ArrayDOFV<nVarsFixed> &uDof, Geom::tAdjPair &cell2cell)

inline void InverseDiag()

Public Members

ArrayDOFV<nVarsFixed> diag

ArrayDOFV<nVarsFixed> diagInv

ArrayEigenMatrix<nVarsFixed, nVarsFixed> diagBlock

ArrayEigenMatrix<nVarsFixed, nVarsFixed> diagBlockInv

ArrayRECV<nVarsFixed> offDiagBlock

template<int nVarsFixed>
struct OneDimProfile

Public Functions

inline OneDimProfile(const MPIInfo &_mpi)

inline void SortNodes()

inline index Size() const

inline real Len(index i)

inline void GenerateUniform(index size, int nvars, real minV, real maxV)

inline void GenerateTanh(index size, int nvars, real minV, real maxV, real d0)

inline void SetZero()

template<class TU>
inline void AddSimpleInterval(TU vmean, real divV, real lV, real rV)

inline void Reduce()

inline Eigen::Vector<real, nVarsFixed> Get(index i) const

inline Eigen::Vector<real, nVarsFixed> GetPlain(real v) const

inline void OutProfileCSV(std::ostream &o, bool title = true, int precision = 16)

Public Members

MPIInfo mpi

Eigen::Vector<real, Eigen::Dynamic> nodes

Eigen::Matrix<real, nVarsFixed, Eigen::Dynamic> v

Eigen::RowVector<real, Eigen::Dynamic> div

class OutputPicker

Public Types

using tMap = std::map<std::string, tCellScalarFGet>

Public Functions

inline void setMap(const tMap &v)

inline tCellScalarList getSubsetList(const std::vector<std::string> &names)

template<class TU>
struct TU_P_Reduction

namespace Gas

Typedefs

using tVec = Eigen::Vector3d

using tVec2 = Eigen::Vector2d

Enums

enum RiemannSolverType

Values:

enumerator UnknownRS

enumerator Roe

enumerator HLLC

enumerator HLLEP

enumerator HLLEP_V1

enumerator Roe_M1

enumerator Roe_M2

enumerator Roe_M3

enumerator Roe_M4

enumerator Roe_M5

enumerator Roe_M6

enumerator Roe_M7

enumerator Roe_M8

enumerator Roe_M9

Functions

DNDS_DEFINE_ENUM_JSON (RiemannSolverType, { {UnknownRS, "UnknownRS"}, {Roe, "Roe"}, {HLLC, "HLLC"}, {HLLEP, "HLLEP"}, {HLLEP_V1, "HLLEP_V1"}, {Roe_M1, "Roe_M1"}, {Roe_M2, "Roe_M2"}, {Roe_M3, "Roe_M3"}, {Roe_M4, "Roe_M4"}, {Roe_M5, "Roe_M5"}, {Roe_M6, "Roe_M6"}, {Roe_M7, "Roe_M7"}, {Roe_M8, "Roe_M8"}, {Roe_M9, "Roe_M9"}, }) template< int dim

class TeV inline void EulerGasRightEigenVector (const TVec &velo, real Vsqr, real H, real a, TeV &ReV)

template<int dim = 3, class TVec, class TeV>
inline void EulerGasLeftEigenVector(const TVec &velo, real Vsqr, real H, real a, real gamma, TeV &LeV)

inline void IdealGasThermal(real E, real rho, real vSqr, real gamma, real &p, real &asqr, real &H)

template<int dim = 3, typename TULm, typename TURm, typename TFdumpInfo>
RoePreamble<dim> ComputeRoePreamble(const TULm &ULm, const TURm &URm, real gamma, const TFdumpInfo &dumpInfo)

template<int dim = 3, class TCons, class TPrim>
inline void IdealGasThermalConservative2Primitive(const TCons &U, TPrim &prim, real gamma)

template<int dim = 3, class TCons, class TPrim>
inline void IdealGasThermalPrimitive2Conservative(const TPrim &prim, TCons &U, real gamma)

template<int dim = 3, class TPrim>
std::tuple<real, real> IdealGasThermalPrimitiveGetP0T0(const TPrim &prim, real gamma, real rg)

template<int dim = 3, typename TU, typename TF, class TVec, class TVecVG>
inline void GasInviscidFlux(const TU &U, const TVec &velo, const TVecVG &vg, real p, TF &F)

template<int dim = 3, typename TU, typename TF, class TVec, class TVecN, class TVecVG>
inline void GasInviscidFlux_XY(const TU &U, const TVec &velo, const TVecVG &vg, const TVecN &n, real p, TF &F)

template<int dim = 3, typename TU, typename TF, class TVec, class TVecVG, class TP>
inline void GasInviscidFlux_Batch(const TU &U, const TVec &velo, const TVecVG &vg, TP &&p, TF &F)

template<int dim = 3, typename TU, typename TF, class TVec, class TVecVG, class TVecN, class TP>
inline void GasInviscidFlux_XY_Batch(const TU &U, const TVec &velo, const TVecVG &vg, const TVecN &n, TP &&p, TF &F)

template<int dim = 3, typename TU, class TVec>
inline void IdealGasUIncrement(const TU &U, const TU &dU, const TVec &velo, real gamma, TVec &dVelo, real &dp)

template<int dim = 3, typename TU, typename TF, class TVec, class TVecVG>
inline void GasInviscidFluxFacialIncrement(const TU &U, const TU &dU, const TVec &unitNorm, const TVecVG &velo, const TVec &dVelo, const TVec &vg, real dp, real p, TF &F)

template<int dim = 3, typename TU>
inline auto IdealGas_EulerGasRightEigenVector(const TU &U, real gamma)

template<int dim = 3, typename TU>
inline auto IdealGas_EulerGasLeftEigenVector(const TU &U, real gamma)

template<int dim = 3, int type = 0, typename TUL, typename TUR, typename TULm, typename TURm, typename TVecVG, typename TVecN, typename TF, typename TFdumpInfo>
void HLLEPFlux_IdealGas(const TUL &UL, const TUR &UR, const TULm &ULm, const TURm &URm, const TVecVG &vg, const TVecN &n, real gamma, TF &F, real dLambda, real fixScale, const TFdumpInfo &dumpInfo, real &lam0, real &lam123, real &lam4)

template<int dim = 3, typename TUL, typename TUR, typename TULm, typename TURm, typename TVecVG, typename TVecN, typename TF, typename TFdumpInfo>
void HLLCFlux_IdealGas_HartenYee(const TUL &UL, const TUR &UR, const TULm &ULm, const TURm &URm, const TVecVG &vg, const TVecN &n, real gamma, TF &F, real dLambda, real fixScale, const TFdumpInfo &dumpInfo, real &lam0, real &lam123, real &lam4)

template<int eigScheme>
void Roe_EntropyFixer(const real aL, const real aR, const real aAve, const real uL, const real uR, const real uAve, const real VL, const real VR, const real VAve, real dLambda, real fixScale, real incFScale, real &lam0, real &lam123, real &lam4)

template<int dim = 3, int eigScheme = 0, typename TUL, typename TUR, typename TULm, typename TURm, typename TVecVG, typename TVecN, typename TF, typename TFdumpInfo>
void RoeFlux_IdealGas_HartenYee(const TUL &UL, const TUR &UR, const TULm &ULm, const TURm &URm, const TVecVG &vg, const TVecN &n, real gamma, TF &F, real dLambda, real fixScale, real incFScale, const TFdumpInfo &dumpInfo, real &lam0, real &lam123, real &lam4)

template<int dim = 3, typename TUL, typename TUR, typename TVecV, typename TUOut>
void GetRoeAverage(const TUL &UL, const TUR &UR, real gamma, TVecV &veloRoe, real &vsqrRoe, real &aRoe, real &asqrRoe, real &HRoe, TUOut &UOut)

template<int dim = 3, typename TDU, typename TDF, typename TVecV, typename TVecN>
void RoeFluxIncFDiff(const TDU &incU, const TVecN &n, const TVecV &veloRoe, real vsqrRoe, real aRoe, real asqrRoe, real HRoe, real lam0, real lam123, real lam4, real gamma, TDF &incF)

template<int dim = 3, int eigScheme = 0, typename TUL, typename TUR, typename TULm, typename TURm, typename TVecVG, typename TVecVGm, typename TVecN, typename TVecNm, typename TF, typename TFdumpInfo>
void RoeFlux_IdealGas_HartenYee_Batch(const TUL &UL, const TUR &UR, const TULm &ULm, const TURm &URm, const TVecVG &vg, const TVecVGm &vgm, const TVecN &n, const TVecNm &nm, real gamma, TF &F, real dLambda, real fixScale, real incFScale, const TFdumpInfo &dumpInfo, real &lam0, real &lam123, real &lam4)

template<int dim = 3, typename TUL, typename TUR, typename TULm, typename TURm, typename TVecVG, typename TVecN, typename TF, typename TFdumpInfo>
void InviscidFlux_IdealGas_Dispatcher(RiemannSolverType type, TUL &&UL, TUR &&UR, TULm &&ULm, TURm &&URm, TVecVG &&vg, TVecN &&n, real gamma, TF &&F, real dLambda, real fixScale, real incFScale, TFdumpInfo &&dumpInfo, real &lam0, real &lam123, real &lam4)

template<int dim = 3, typename TUL, typename TUR, typename TULm, typename TURm, typename TVecVG, typename TVecVGm, typename TVecN, typename TVecNm, typename TF, typename TFdumpInfo>
void InviscidFlux_IdealGas_Batch_Dispatcher(RiemannSolverType type, TUL &&UL, TUR &&UR, TULm &&ULm, TURm &&URm, TVecVG &&vg, TVecVGm &&vgm, TVecN &&n, TVecNm &&nm, real gamma, TF &&F, real dLambda, real fixScale, real incFScale, TFdumpInfo &dumpInfo, real &lam0, real &lam123, real &lam4)

template<int dim = 3, typename TU, typename TGradU, typename TFlux, typename TNorm>
void ViscousFlux_IdealGas(const TU &U, const TGradU &GradUPrim, TNorm norm, bool adiabatic, real gamma, real mu, real mutRatio, bool mutQCRFix, real k, real Cp, TFlux &Flux)

template<int dim = 3, typename TU, typename TGradU, typename TGradUPrim>
void GradientCons2Prim_IdealGas(const TU &U, const TGradU &GradU, TGradUPrim &GradUPrim, real gamma)

template<int dim, typename TU, typename TGradU>
auto GetGradVelo(const TU &U, const TGradU &GradU)

template<int dim = 3, int scheme = 0, int nVarsFixed, typename TU, typename TUInc>
real IdealGasGetCompressionRatioPressure(const TU &u, const TUInc &uInc, real newrhoEinteralNew)

Variables

static const int MaxBatch = 16

static constexpr real kScaleHartenYee = IdealGas::kScaleHartenYee

static constexpr real kScaleLD = IdealGas::kScaleLD

static constexpr real kScaleHFix = IdealGas::kScaleHFix

template<int dim>
struct RoePreamble

Public Members

TVec veloRm

real HRm

real vsqrRm

TVec veloRoe

real sqrtRhoRm

real aRoe

namespace RANS

Functions

template<int dim, class TU, class TDiffU>
real GetMut_RealizableKe(TU &&UMeanXy, TDiffU &&DiffUxy, real muf, real d)

template<int dim, class TU, class TN, class TDiffU, class TVFlux>
void GetVisFlux_RealizableKe(TU &&UMeanXy, TDiffU &&DiffUxyPrim, TN &&uNorm, real mut, real d, real muPhy, TVFlux &vFlux)

template<int dim, class TU, class TDiffU, class TSource>
void GetSource_RealizableKe(TU &&UMeanXy, TDiffU &&DiffUxy, real muf, real d, TSource &source, int mode)

template<int dim, class TU>
std::tuple<real, real> SolveZeroGradEquilibrium(TU &u, real muPhy)

template<int dim, class TU, class TDiffU, class TSource>
void GetSourceJacobianDiag_RealizableKe(TU &&UMeanXy, TDiffU &&DiffUxy, real muf, TSource &source)

template<int dim, class TU, class TDiffU, class TSource>
void GetSourceJacobianDiag_RealizableKe_ND(TU &&UMeanXy, TDiffU &&DiffUxy, real muf, TSource &source)

template<int dim, class TU, class TDiffU>
real GetMut_SST(TU &&UMeanXy, TDiffU &&DiffUxy, real muf, real d)

template<int dim, class TU, class TN, class TDiffU, class TVFlux>
void GetVisFlux_SST(TU &&UMeanXy, TDiffU &&DiffUxyPrim, TN &&uNorm, real mutIn, real d, real muf, TVFlux &vFlux)

template<int dim, class TU, class TDiffU, class TSource>
void GetSource_SST(TU &&UMeanXy, TDiffU &&DiffUxy, real muf, real d, real lLES, TSource &source, int mode)

template<int dim, class TU, class TDiffU>
real GetMut_KOWilcox(TU &&UMeanXy, TDiffU &&DiffUxy, real muf, real d)

template<int dim, class TU, class TN, class TDiffU, class TVFlux>
void GetVisFlux_KOWilcox(TU &&UMeanXy, TDiffU &&DiffUxyPrim, TN &&uNorm, real mutIn, real d, real muf, TVFlux &vFlux)

template<int dim, class TU, class TDiffU, class TSource>
void GetSource_KOWilcox(TU &&UMeanXy, TDiffU &&DiffUxy, real muf, real d, TSource &source, int mode)

template<int dim, class TU, class TDiffU, class TSource>
void GetSource_SA(TU &&UMeanXy, TDiffU &&DiffUxy, real muRef, real mufPhy, real gamma, real d, real lLES, real hMax, int DESMode, TSource &source, int rotCor, int mode)

Variables

static constexpr real kWallOmegaCoeff = 800.0

namespace SA

Variables

static constexpr real cnu1 = 7.1

static constexpr real cn1 = 16.0

static constexpr real sigma = 2.0 / 3.0

namespace SpecialFields

Functions

template<EulerModel model = NS>
auto IsentropicVortex10(EulerEvaluator<model> &eval, const Geom::tPoint &x, real t, int cnVars, real chi)

template<EulerModel model = NS>
auto IsentropicVortex30(EulerEvaluator<model> &eval, const Geom::tPoint &x, real t, int cnVars)

template<EulerModel model = NS>
auto IsentropicVortexCent(EulerEvaluator<model> &eval, const Geom::tPoint &x, real t, int cnVars)

namespace EulerP

Typedefs

using TU = Eigen::Vector<real, nVarsFlow>

using TDiffU = Eigen::Matrix<real, 3, nVarsFlow>

using TUFull = Eigen::Vector<real, Eigen::Dynamic>

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

using TUFullMap = Eigen::Map<TUFull>

using TDiffUFullMap = Eigen::Map<TDiffUFull>

using TUDof = ArrayDof<nVarsFlow, 1>

using TUGrad = ArrayDof<3, nVarsFlow>

using TUScalar = ArrayDof<1, 1>

using TUScalarGrad = ArrayDof<3, 1>

using TUScalar2 = ArrayDof<2, 1>

using TUVec = ArrayDof<3, 1>

using TUVecGrad = ArrayDof<3, 3>

using TFiniteVolume = CFV::FiniteVolume

Enums

enum class BCType : uint8_t

Values:

enumerator Unknown

enumerator Far

enumerator Wall

enumerator WallInvis

enumerator WallIsothermal

enumerator Out

enumerator OutP

enumerator In

enumerator InPsTs

enumerator Sym

enumerator Special

Functions

template<class TU> DNDS_DEVICE_CALLABLE DNDS_FORCEINLINE auto U123 (TU &&v)

template<class TU> DNDS_DEVICE_CALLABLE DNDS_FORCEINLINE auto U012 (TU &&v)

inline DNDS_DEVICE_CALLABLE void RoeEigenValueFixer (real aL, real aR, real vnL, real vnR, real dLambda, real fixScale, real &lam0, real &lam123, real &lam4)

template<DeviceBackend B, class TUL, class TUR, class TULPrim, class TURPrim> DNDS_DEVICE_CALLABLE void RoeAverageNS (TUL &&UL, TUR &&UR, TULPrim &&ULPrim, TURPrim &&URPrim, int nVars, real pL, real pR, PhysicsDeviceView< B > &phy, Geom::tPoint &veloRoe, real &vsqrRoe, real &HRoe, real &rhoRoe, real &aSqrRoe)

template<DeviceBackend B> DNDS_DEVICE_CALLABLE void RoeFluxFlow (const TU &UL, const TU &UR, real pL, real pR, const Geom::tPoint &veloRoe, real vsqrRoe, real vgn, const Geom::tPoint &n, real asqrRoe, real aRoe, real HRoe, PhysicsDeviceView< B > &phy, real lam0, real lam123, real lam4, TU &F)

DNDS_DEFINE_ENUM_JSON (BCType, { {BCType::Unknown, nullptr}, {BCType::Far, "Far"}, {BCType::Wall, "Wall"}, {BCType::WallInvis, "WallInvis"}, {BCType::WallIsothermal, "WallIsothermal"}, {BCType::Out, "Out"}, {BCType::OutP, "OutP"}, {BCType::In, "In"}, {BCType::InPsTs, "InPsTs"}, {BCType::Sym, "Sym"}, {BCType::Special, "Special"}, }) template< DeviceBackend B > using BCStorageVecDeviceView

inline void pybind11_BCType_define(py::module_ &m)

inline void pybind11_BCInput_define(py::module_ &m)

inline void pybind11_BC_define(py::module_ &m)

inline void pybind11_BCHandler_define(py::module_ &m)

inline void pybind11_BC_bind(py::module_ &m)

inline void pybind11_Evaluator_define(py::module_ &m)

inline void pybind11_Evaluator_bind(py::module_ &m)

template<DeviceBackend B = DeviceBackend::Host> DNDS_DEVICE void RecGradient_GGRec_Kernel_BndVal (EvaluatorDeviceView< B > &self_view, typename Evaluator_impl< B >::RecGradient_Arg::Portable &arg, index iBnd, index iBndEnd, int nVars, int nVarsScalar)

template DNDS_DEVICE void RecGradient_GGRec_Kernel_BndVal< DeviceBackend::Host > (EvaluatorDeviceView< DeviceBackend::Host > &self_view, typename Evaluator_impl< DeviceBackend::Host >::RecGradient_Arg::Portable &arg, index iBnd, index iBndEnd, int nVars, int nVarsScalar)

template<DeviceBackend B = DeviceBackend::Host> DNDS_DEVICE void RecGradient_GGRec_Kernel_GG (EvaluatorDeviceView< B > &self_view, typename Evaluator_impl< B >::RecGradient_Arg::Portable &arg, index iCell, index iCellEnd, int nVars, int nVarsScalar)

template DNDS_DEVICE void RecGradient_GGRec_Kernel_GG< DeviceBackend::Host > (EvaluatorDeviceView< DeviceBackend::Host > &self_view, typename Evaluator_impl< DeviceBackend::Host >::RecGradient_Arg::Portable &arg, index iCell, index iCellEnd, int nVars, int nVarsScalar)

template<DeviceBackend B = DeviceBackend::Host> DNDS_DEVICE void RecGradient_BarthLimiter_Kernel_FlowPart (EvaluatorDeviceView< B > &self_view, typename Evaluator_impl< B >::RecGradient_Arg::Portable &arg, index iCell, index iCellEnd, int nVars, int nVarsScalar)

template DNDS_DEVICE void RecGradient_BarthLimiter_Kernel_FlowPart< DeviceBackend::Host > (EvaluatorDeviceView< DeviceBackend::Host > &self_view, typename Evaluator_impl< DeviceBackend::Host >::RecGradient_Arg::Portable &arg, index iCell, index iCellEnd, int nVars, int nVarsScalar)

template<DeviceBackend B = DeviceBackend::Host> DNDS_DEVICE void RecGradient_BarthLimiter_Kernel_ScalarPart (EvaluatorDeviceView< B > &self_view, typename Evaluator_impl< B >::RecGradient_Arg::Portable &arg, index iCell, index iCellEnd, int nVars, int nVarsScalar)

template DNDS_DEVICE void RecGradient_BarthLimiter_Kernel_ScalarPart< DeviceBackend::Host > (EvaluatorDeviceView< DeviceBackend::Host > &self_view, typename Evaluator_impl< DeviceBackend::Host >::RecGradient_Arg::Portable &arg, index iCell, index iCellEnd, int nVars, int nVarsScalar)

template<DeviceBackend B = DeviceBackend::Host> DNDS_DEVICE void Cons2PrimMu_Kernel (EvaluatorDeviceView< B > &self_view, typename Evaluator_impl< B >::Cons2PrimMu_Arg::Portable &arg, index iPt, index iPtEnd, int nVars, int nVarsScalar)

template DNDS_DEVICE void Cons2PrimMu_Kernel< DeviceBackend::Host > (EvaluatorDeviceView< DeviceBackend::Host > &self_view, typename Evaluator_impl< DeviceBackend::Host >::Cons2PrimMu_Arg::Portable &arg, index iPt, index iPtEnd, int nVars, int nVarsScalar)

template<DeviceBackend B = DeviceBackend::Host> DNDS_DEVICE void Cons2Prim_Kernel (EvaluatorDeviceView< B > &self_view, typename Evaluator_impl< B >::Cons2Prim_Arg::Portable &arg, index iPt, index iPtEnd, int nVars, int nVarsScalar)

template DNDS_DEVICE void Cons2Prim_Kernel< DeviceBackend::Host > (EvaluatorDeviceView< DeviceBackend::Host > &self_view, typename Evaluator_impl< DeviceBackend::Host >::Cons2Prim_Arg::Portable &arg, index iPt, index iPtEnd, int nVars, int nVarsScalar)

template<DeviceBackend B = DeviceBackend::Host> DNDS_DEVICE void EstEigenDt_GetFaceLam_Kernel (EvaluatorDeviceView< B > &self_view, typename Evaluator_impl< B >::EstEigenDt_Arg::Portable &arg, index iFace, index iFaceEnd, int nVars, int nVarsScalar)

template DNDS_DEVICE void EstEigenDt_GetFaceLam_Kernel< DeviceBackend::Host > (EvaluatorDeviceView< DeviceBackend::Host > &self_view, typename Evaluator_impl< DeviceBackend::Host >::EstEigenDt_Arg::Portable &arg, index iFace, index iFaceEnd, int nVars, int nVarsScalar)

template<DeviceBackend B = DeviceBackend::Host> DNDS_DEVICE void EstEigenDt_FaceLam2CellDt_Kernel (EvaluatorDeviceView< B > &self_view, typename Evaluator_impl< B >::EstEigenDt_Arg::Portable &arg, index iCell, index iCellEnd, int nVars, int nVarsScalar)

template DNDS_DEVICE void EstEigenDt_FaceLam2CellDt_Kernel< DeviceBackend::Host > (EvaluatorDeviceView< DeviceBackend::Host > &self_view, typename Evaluator_impl< DeviceBackend::Host >::EstEigenDt_Arg::Portable &arg, index iCell, index iCellEnd, int nVars, int nVarsScalar)

template<DeviceBackend B = DeviceBackend::Host> DNDS_DEVICE void RecFace2nd_Kernel (EvaluatorDeviceView< B > &self_view, typename Evaluator_impl< B >::RecFace2nd_Arg::Portable &arg, index iFace, index iFaceEnd, int nVars, int nVarsScalar)

template DNDS_DEVICE void RecFace2nd_Kernel< DeviceBackend::Host > (EvaluatorDeviceView< DeviceBackend::Host > &self_view, typename Evaluator_impl< DeviceBackend::Host >::RecFace2nd_Arg::Portable &arg, index iFace, index iFaceEnd, int nVars, int nVarsScalar)

template<DeviceBackend B = DeviceBackend::Host> DNDS_DEVICE void Flux2nd_Kernel_FluxFace (EvaluatorDeviceView< B > &self_view, typename Evaluator_impl< B >::Flux2nd_Arg::Portable &arg, index iFace, index iFaceEnd, int nVars, int nVarsScalar)

template DNDS_DEVICE void Flux2nd_Kernel_FluxFace< DeviceBackend::Host > (EvaluatorDeviceView< DeviceBackend::Host > &self_view, typename Evaluator_impl< DeviceBackend::Host >::Flux2nd_Arg::Portable &arg, index iFace, index iFaceEnd, int nVars, int nVarsScalar)

template<DeviceBackend B = DeviceBackend::Host> DNDS_DEVICE void Flux2nd_Kernel_Face2Cell (EvaluatorDeviceView< B > &self_view, typename Evaluator_impl< B >::Flux2nd_Arg::Portable &arg, index iCell, index iCellEnd, int nVars, int nVarsScalar)

template DNDS_DEVICE void Flux2nd_Kernel_Face2Cell< DeviceBackend::Host > (EvaluatorDeviceView< DeviceBackend::Host > &self_view, typename Evaluator_impl< DeviceBackend::Host >::Flux2nd_Arg::Portable &arg, index iCell, index iCellEnd, int nVars, int nVarsScalar)

template<typename TU, typename TF, class TVecN> inline DNDS_DEVICE_CALLABLE void GasInviscidFlux_XY (TU &&U, int nVars, real vn, real vgn, TVecN &&n, real p, TF &F)

inline void pybind11_Physics_bind(py::module_ &m)

Variables

static constexpr int nVarsFlow = 5

static constexpr int I4 = 4

static constexpr DeviceBackend B = DeviceBackend::Host

class BC

Public Types

template<DeviceBackend B>
using t_deviceView = BC_DeviceView<B>

Public Functions

inline Geom::t_index getId() const

inline void setId(Geom::t_index n_id)

inline BCType getType() const

inline void setType(BCType n_type)

inline int32_t getNValues() const

inline real value(int i) const

inline void setValues(const std::vector<real> &v)

inline auto getValues() const

inline void to_host()

inline void to_device(DeviceBackend B)

inline DeviceBackend device()

template<DeviceBackend B>
inline t_deviceView<B> deviceView()

template<DeviceBackend B>
class BC_DeviceView

Public Functions

inline DNDS_DEVICE_CALLABLE BC_DeviceView(BCStorageVecDeviceView<B> n_values, Geom::t_index n_id, BCType n_type)

inline DNDS_DEVICE_CALLABLE Geom::t_index getId () const

inline DNDS_DEVICE_CALLABLE BCType getType () const

inline DNDS_DEVICE_CALLABLE int32_t getNValues () const

inline DNDS_DEVICE_CALLABLE real value (int32_t i) const

template<class tU, class tUOut, class tx, class tn> inline DNDS_DEVICE_CALLABLE void apply (tU &&U, tUOut &&UOut, int32_t uSiz, tx &&x, tn &&n, PhysicsDeviceView< B > &phy)

template<DeviceBackend B, BCType T>
struct BCFunc_Impl

template<DeviceBackend B>
struct BCFunc_Impl<B, BCType::Far>

template<DeviceBackend B>
struct BCFunc_Impl<B, BCType::In>

template<DeviceBackend B>
struct BCFunc_Impl<B, BCType::InPsTs>

template<DeviceBackend B>
struct BCFunc_Impl<B, BCType::Out>

template<DeviceBackend B>
struct BCFunc_Impl<B, BCType::OutP>

template<DeviceBackend B>
struct BCFunc_Impl<B, BCType::Special>

template<DeviceBackend B>
struct BCFunc_Impl<B, BCType::Sym>

template<DeviceBackend B>
struct BCFunc_Impl<B, BCType::Wall>

template<DeviceBackend B>
struct BCFunc_Impl<B, BCType::WallInvis>

template<DeviceBackend B>
struct BCFunc_Impl<B, BCType::WallIsothermal>

class BCHandler

Public Functions

inline BCHandler(const std::vector<BCInput> &bc_inputs, Geom::AutoAppendName2ID &name2id)

inline BC &id2bc(Geom::t_index id)

inline void to_host()

inline void to_device(DeviceBackend B)

inline DeviceBackend device()

template<DeviceBackend B>
inline t_deviceView<B> deviceView()

template<DeviceBackend B>
struct t_deviceView

Public Functions

t_deviceView(t_deviceView &&R) noexcept = default

Public Members

host_device_vector<BC_DeviceView<B>> bcs_device_view

BCHandlerDeviceView<B> view

template<DeviceBackend B>
class BCHandlerDeviceView

Public Functions

inline DNDS_DEVICE_CALLABLE BCHandlerDeviceView(vector_DeviceView<B, BC_DeviceView<B>, int32_t> n_bcs)

inline DNDS_DEVICE_CALLABLE BC_DeviceView< B > & id2bc (Geom::t_index id)

struct BCInput

Public Members

BCType type

std::string name

std::vector<real> value

class Evaluator

Public Functions

inline const t_jsonconfig &get_config()

template<typename Tc>
inline void set_config(Tc &&config_in)

inline void BuildFaceBufferDof(TUDof &u)

inline void BuildFaceBufferDofScalar(TUScalar &u)

inline void PrepareFaceBuffer(int nVarsScalar)

inline Evaluator(t_fv n_fv, t_bcHandler n_bcHandler, t_physics n_physics)

void PrintDataVTKHDF(std::string fname, std::string series_name, std::vector<ssp<TUScalar>> &arrCellCentScalar, const std::vector<std::string> &arrCellCentScalar_names_in, std::vector<ssp<TUVec>> &arrCellCentVec, const std::vector<std::string> &arrCellCentVec_names_in, std::vector<ssp<TUScalar>> &arrNodeScalar, const std::vector<std::string> &arrNodeScalar_names_in, std::vector<ssp<TUVec>> &arrNodeVec, const std::vector<std::string> &arrNodeVec_names_in, ssp<TUDof> uPrimCell, ssp<TUDof> uPrimNode, double t)

inline DeviceBackend device()

template<DeviceBackend B>
inline t_deviceView<B> deviceView()

inline void to_host()

inline void to_device(DeviceBackend B)

template<class TPair>
inline void checkValidUDof(const ssp<TPair> &u, const std::string &name = "unknown", int varloc = 0, bool includeSon = true, DeviceBackend B = DeviceBackend::Unknown, bool optional = false)

void RecGradient(RecGradient_Arg &arg)

void Cons2PrimMu(Cons2PrimMu_Arg &arg)

void Cons2Prim(Cons2Prim_Arg &arg)

void EstEigenDt(EstEigenDt_Arg &arg)

void RecFace2nd(RecFace2nd_Arg &arg)

void Flux2nd(Flux2nd_Arg &arg)

Public Members

t_fv fv

t_bcHandler bcHandler

t_physics physics

t_config config

TUDof u_face_bufferL

TUDof u_face_bufferR

std::vector<TUScalar> uScalar_face_bufferL

std::vector<TUScalar> uScalar_face_bufferR

Public Static Functions

static inline auto device_array_list_Buffer()

struct Cons2Prim_Arg : public DNDS::EulerP::EvaluatorArgBase<Cons2Prim_Arg>

Public Functions

inline void Validate(Evaluator &self)

Public Members

ssp<TUDof> u

std::vector<ssp<TUScalar>> uScalar

ssp<TUDof> uPrim

std::vector<ssp<TUScalar>> uScalarPrim

ssp<TUScalar> p

ssp<TUScalar> T

ssp<TUScalar> a

ssp<TUScalar> gamma

Public Static Functions

static inline auto member_list()

struct Cons2PrimMu_Arg : public DNDS::EulerP::EvaluatorArgBase<Cons2PrimMu_Arg>

Public Functions

inline void Validate(Evaluator &self)

Public Members

ssp<TUDof> u

ssp<TUGrad> uGrad

std::vector<ssp<TUScalar>> uScalar

std::vector<ssp<TUScalarGrad>> uScalarGrad

ssp<TUDof> uPrim

ssp<TUGrad> uGradPrim

std::vector<ssp<TUScalar>> uScalarPrim

std::vector<ssp<TUScalarGrad>> uScalarGradPrim

ssp<TUScalar> p

ssp<TUScalar> T

ssp<TUScalar> a

ssp<TUScalar> gamma

ssp<TUScalar> mu

std::vector<ssp<TUScalar>> muComp

Public Static Functions

static inline auto member_list()

struct EstEigenDt_Arg : public DNDS::EulerP::EvaluatorArgBase<EstEigenDt_Arg>

Public Functions

inline void Validate(Evaluator &self)

Public Members

ssp<TUDof> u

ssp<TUScalar> muCell

ssp<TUScalar> aCell

ssp<TUScalarGrad> faceLamEst

ssp<TUScalar> faceLamVisEst

ssp<TUScalar> deltaLamFace

ssp<TUScalar> deltaLamCell

ssp<TUScalar> dt

Public Static Functions

static inline auto member_list()

struct Flux2nd_Arg : public DNDS::EulerP::EvaluatorArgBase<Flux2nd_Arg>

Public Functions

inline void Validate(Evaluator &self)

Public Members

ssp<TUDof> u

ssp<TUGrad> uGrad

std::vector<ssp<TUScalar>> uScalar

std::vector<ssp<TUScalarGrad>> uScalarGrad

ssp<TUDof> uPrim

ssp<TUGrad> uGradPrim

std::vector<ssp<TUScalar>> uScalarPrim

std::vector<ssp<TUScalarGrad>> uScalarGradPrim

ssp<TUScalar> p

ssp<TUScalar> T

ssp<TUScalar> a

ssp<TUScalar> mu

std::vector<ssp<TUScalar>> muComp

ssp<TUScalar> gamma

ssp<TUScalar> deltaLamCell

ssp<TUDof> uFL

ssp<TUDof> uFR

ssp<TUGrad> uGradFF

std::vector<ssp<TUScalar>> uScalarFL

std::vector<ssp<TUScalar>> uScalarFR

std::vector<ssp<TUScalarGrad>> uScalarGradFF

ssp<TUScalar> pFL

ssp<TUScalar> pFR

ssp<TUDof> fluxFF

std::vector<ssp<TUScalar>> fluxScalarFF

ssp<TUDof> rhs

std::vector<ssp<TUScalar>> rhsScalar

Public Static Functions

static inline auto member_list()

struct RecFace2nd_Arg : public DNDS::EulerP::EvaluatorArgBase<RecFace2nd_Arg>

Public Functions

inline void Validate(Evaluator &self)

Public Members

ssp<TUDof> u

ssp<TUGrad> uGrad

std::vector<ssp<TUScalar>> uScalar

std::vector<ssp<TUScalarGrad>> uScalarGrad

ssp<TUDof> uFL

ssp<TUDof> uFR

ssp<TUGrad> uGradFF

std::vector<ssp<TUScalar>> uScalarFL

std::vector<ssp<TUScalar>> uScalarFR

std::vector<ssp<TUScalarGrad>> uScalarGradFF

Public Static Functions

static inline auto member_list()

struct RecGradient_Arg : public DNDS::EulerP::EvaluatorArgBase<RecGradient_Arg>

Public Functions

inline void Validate(Evaluator &self)

Public Members

ssp<TUDof> u

ssp<TUGrad> uGrad

std::vector<ssp<TUScalar>> uScalar

std::vector<ssp<TUScalarGrad>> uScalarGrad

Public Static Functions

static inline auto member_list()

template<DeviceBackend B>
struct t_deviceView

Public Functions

t_deviceView(t_deviceView &&R) noexcept = default

template<DeviceBackend B>
struct Evaluator_impl

Public Types

using t_Scalar_deviceViewVector_sup = std::unique_ptr<deviceViewVector<TUScalar::t_deviceView<B>, B>>

using t_ScalarGrad_deviceViewVector_sup = std::unique_ptr<deviceViewVector<TUScalarGrad::t_deviceView<B>, B>>

Public Functions

void RecGradient_GGRec(RecGradient_Arg &arg)

void RecGradient_BarthLimiter(RecGradient_Arg &arg)

void Cons2PrimMu(Cons2PrimMu_Arg &arg)

void Cons2Prim(Cons2Prim_Arg &arg)

void EstEigenDt_GetFaceLam(EstEigenDt_Arg &arg)

void EstEigenDt_FaceLam2CellDt(EstEigenDt_Arg &arg)

void RecFace2nd(RecFace2nd_Arg &arg)

void Flux2nd(Flux2nd_Arg &arg)

Public Static Functions

static void RecGradient_GGRec(RecGradient_Arg &arg)

static void RecGradient_BarthLimiter(RecGradient_Arg &arg)

static void Cons2PrimMu(Cons2PrimMu_Arg &arg)

static void Cons2Prim(Cons2Prim_Arg &arg)

static void EstEigenDt_GetFaceLam(EstEigenDt_Arg &arg)

static void EstEigenDt_FaceLam2CellDt(EstEigenDt_Arg &arg)

static void RecFace2nd(RecFace2nd_Arg &arg)

static void Flux2nd(Flux2nd_Arg &arg)

struct Cons2Prim_Arg

Public Members

EvaluatorDeviceView<B> self_view

struct Portable

struct Cons2PrimMu_Arg

Public Members

EvaluatorDeviceView<B> self_view

struct Portable

Public Members

TUDof::t_deviceView<B> u

TUGrad::t_deviceView<B> uGrad

vector_DeviceView<B, TUScalar::t_deviceView<B>> uScalar

vector_DeviceView<B, TUScalarGrad::t_deviceView<B>> uScalarGrad

TUDof::t_deviceView<B> uPrim

TUGrad::t_deviceView<B> uGradPrim

vector_DeviceView<B, TUScalar::t_deviceView<B>> uScalarPrim

vector_DeviceView<B, TUScalarGrad::t_deviceView<B>> uScalarGradPrim

TUScalar::t_deviceView<B> p

TUScalar::t_deviceView<B> T

TUScalar::t_deviceView<B> a

TUScalar::t_deviceView<B> gamma

TUScalar::t_deviceView<B> mu

vector_DeviceView<B, TUScalar::t_deviceView<B>> muComp

struct EstEigenDt_Arg

Public Members

EvaluatorDeviceView<B> self_view

struct Portable

struct Flux2nd_Arg

Public Members

EvaluatorDeviceView<B> self_view

struct Portable

struct RecFace2nd_Arg

Public Members

EvaluatorDeviceView<B> self_view

struct Portable

struct RecGradient_Arg

Public Functions

inline RecGradient_Arg(Evaluator &self_, Evaluator::RecGradient_Arg &arg)

Public Members

EvaluatorDeviceView<B> self_view

t_Scalar_deviceViewVector_sup faceBCScalarBuffer_v

t_Scalar_deviceViewVector_sup uScalar_v

t_ScalarGrad_deviceViewVector_sup uScalarGrad_v

struct Portable

Public Members

TUDof::t_deviceView<B> faceBCBuffer

vector_DeviceView<B, TUScalar::t_deviceView<B>> faceBCScalarBuffer

TUDof::t_deviceView<B> u

TUGrad::t_deviceView<B> uGrad

vector_DeviceView<B, TUScalar::t_deviceView<B>> uScalar

vector_DeviceView<B, TUScalarGrad::t_deviceView<B>> uScalarGrad

template<class TDerived>
class EvaluatorArgBase

Public Functions

inline void WaitAllPull(DeviceBackend B)

class EvaluatorConfig

Public Functions

EvaluatorConfig()

void valid_patch_keys(const t_jsonconfig &config_in)

inline void merge_patch(const t_jsonconfig &config_in)

inline const t_jsonconfig &config() const

template<DeviceBackend B>
class EvaluatorDeviceView

Public Members

t_fv fv

t_bcHandler bcHandler

t_physics physics

struct Physics

Public Types

template<DeviceBackend B>
using t_deviceView = PhysicsDeviceView<B>

Public Functions

inline  DNDS_NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_ORDERED_AND_UNORDERED_JSON (Physics, reference_values, params) void to_host()

inline void to_device(DeviceBackend B)

inline DeviceBackend device()

template<DeviceBackend B>
inline t_deviceView<B> deviceView()

inline void setPerfectGas(real Rg, real gamma)

Public Members

host_device_vector<real> reference_values

PhysicsParams params

template<DeviceBackend B>
struct PhysicsDeviceView

Public Functions

template<class tUPrim, class tDiffUPrim> inline DNDS_DEVICE_CALLABLE real getMuTot (tUPrim &&UPrim, tDiffUPrim &&DiffUPrim, int nVars, real p, real T) const

template<class tUPrim, class tU> inline DNDS_DEVICE_CALLABLE void Cons2Prim (tU &&U, tUPrim &&UPrim, int nVars) const

template<class tU, class tUPrim, class tDiffU, class tDiffUPrim> inline DNDS_DEVICE_CALLABLE void Cons2PrimDiff (tU &&U, tUPrim &&UPrim, tDiffU &&DiffU, tDiffUPrim &&DiffUPrim, int nVars) const

template<class tUPrim, class tU> inline DNDS_DEVICE_CALLABLE void Prim2Cons (tUPrim &&UPrim, tU &&U, int nVars) const

template<class tU> inline DNDS_DEVICE_CALLABLE real Cons2EInternal (tU &&U, int nVars) const

template<class tUPrim> inline DNDS_DEVICE_CALLABLE real Prim2Pressure (tUPrim &&UPrim, int nVars, real T) const

template<class tUPrim>
inline DNDS_DEVICE_CALLABLE auto Prim2GammaAcousticSpeed(tUPrim &&UPrim, int nVars, real p) const

template<class tUPrim> inline DNDS_DEVICE_CALLABLE real Prim2Temperature (tUPrim &&UPrim, int nVars) const

template<class tU> inline DNDS_DEVICE_CALLABLE real Pressure2Enthalpy (tU &&U, int nVars, real p) const

template<class tU> inline DNDS_DEVICE_CALLABLE real Enthalpy2Pressure (tU &&U, int nVars, real H) const

Public Members

vector_DeviceView<B, real, int32_t> reference_values

PhysicsParams params

struct PhysicsParams

Public Members

real gamma = 1.4

real mu0 = 1e-100

real cp = 1.

real cv = 1.

real Rg = 1.

real TRef = 273.15

int muModel = 0

namespace detail

struct FGlobalAccessor_noOp

Public Functions

inline DNDS_FORCEINLINE DNDS_DEVICE real & operator() (index iPnt, int i)

Public Members

real dummy_

struct FLocalAccessor_noOp

Public Functions

inline DNDS_FORCEINLINE DNDS_DEVICE real & operator() (int i)

Public Members

real dummy_

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>>

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

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

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

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)

inline constexpr Elem::ElemType __getElemTypeFromCGNSType(ElementType_t cgns_et)

inline 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)

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)

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

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)

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)

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)

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

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)

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}

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 CoordPairDOF : public DNDS::ArrayPair<DNDS::ArrayEigenVector<3>>

struct ElemInfo

Public Members

t_index zone = INTERNAL_ZONE

struct NodeIndexPBI

struct NodePeriodicBits

class NodePeriodicBitsRow

class Octree

template<class T>
class OffsetIterator

template<class T>
class OffsetRange

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 SmallCoordsAsVector : public tSmallCoords

struct tGPointPortable

struct tPointPortable

struct UnstructuredMesh : public DNDS::DeviceTransferable<UnstructuredMesh>

Public Functions

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

void InterpolateFace()

tLocalMatStruct GetCell2CellFaceVLocal(bool onLocalPartition = false)

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

inline index NumCellGlobal()

inline index NumNodeGlobal()

inline index NumFaceGlobal()

inline index NumBndGlobal()

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

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

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

template<class tC2n, class tC2nPbi, class tCoordExt>
inline void __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

tAdjPair node2cell

tAdjPair cell2face

tPbiPair face2nodePbi

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 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 __GetCoords (const tC2n &c2n, tSmallCoords &cs)

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

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

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

Public Members

tCoordPair::t_deviceView<B> coords

tPbiPair::t_deviceView<B> cell2nodePbi

tAdjPair::t_deviceView<B> cell2face

tPbiPair::t_deviceView<B> face2nodePbi

struct UnstructuredMeshSerialRW

Public Functions

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

template<class tC2n, class tC2nPbi, class tCoordExt>
inline void __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 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>
inline 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 int dFactorials[ndiff + 1][ndiff + 1] = {{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 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 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)

inline DNDS_DEVICE_CALLABLE constexpr ParamSpace ElemType_to_ParamSpace (const ElemType t)

inline DNDS_DEVICE_CALLABLE constexpr ElemType GetFaceType (ElemType t_v, t_index iFace)

inline DNDS_DEVICE_CALLABLE constexpr t_real ParamSpaceVol (ParamSpace ps)

inline DNDS_DEVICE_CALLABLE constexpr int GetElemElevation_O1O2_NumNode (ElemType t)

inline DNDS_DEVICE_CALLABLE constexpr ElemType GetElemElevation_O1O2_ElevatedType (ElemType t)

inline DNDS_DEVICE_CALLABLE constexpr ElemType GetElemElevation_O1O2_NodeSpanType (ElemType t, t_index ine)

inline DNDS_DEVICE_CALLABLE constexpr ElemType GetElemO1 (ParamSpace ps)

inline DNDS_DEVICE_CALLABLE constexpr t_index GetO2ElemBisectNum (ElemType t)

inline 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)

inline 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 vtkNodeOrderMax = 27

static const int CellNumNodeMax = 27

static struct DNDS::Geom::Elem::__TNBufferAtQuadrature __NBufferAtQuadrature

static const t_real __GaussJacobi_01A2B0_1[2][1]{{0.250000000000000}, {0.333333333333333}}

static const t_real __GaussJacobi_01A2B0_2[2][2]{{0.122514822655441, 0.544151844011225}, {0.232547451253508, 0.100785882079825}}

static const t_real __GaussJacobi_01A2B0_3[2][3]{{0.072994024073150, 0.347003766038352, 0.705002209888499}, {0.157136361064887, 0.146246269259866, 0.029950703008581}}

static const t_real __GaussJacobi_01A2B0_4[2][4]{{0.048500549446997, 0.238600737551862, 0.517047295104367, 0.795851417896773}, {0.110888415611278, 0.143458789799214, 0.068633887172923, 0.010352240749918}}

static const t_real __GaussJacobi_01A2B0_5[2][5]{{0.034578939918215, 0.173480320771696, 0.389886387065519, 0.634333472630887, 0.851054212947016}, {0.081764784285771, 0.126198961899911, 0.089200161221590, 0.032055600722962, 0.004113825203099}}

static const t_real __GaussLegendre_1[2][1]{{0}, {2}}

static const t_real __GaussLegendre_2[2][2]{{-0.577350269189626, 0.577350269189626}, {1, 1}}

static const t_real __GaussLegendre_3[2][3]{{-0.774596669241483, 0, 0.774596669241483}, {0.555555555555555, 0.888888888888889, 0.555555555555555}}

static const t_real __GaussLegendre_4[2][4]{{-0.861136311594053, -0.339981043584856, 0.339981043584856, 0.861136311594053}, {0.347854845137454, 0.652145154862546, 0.652145154862546, 0.347854845137454}}

static const t_real __GaussLegendre_5[2][5]{{-0.906179845938664, -0.538469310105683, 0, 0.538469310105683, 0.906179845938664}, {0.236926885056189, 0.478628670499366, 0.568888888888889, 0.478628670499366, 0.236926885056189}}

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

static const t_real __HammerTet_1[4][1]{{0.25}, {0.25}, {0.25}, {0.1666666666666667}}

static const t_real __HammerTet_4[4][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 const t_real __HammerTet_8[4][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 const t_real __HammerTet_14[4][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 const t_real __HammerTet_24[4][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 const t_real __HammerTri_1[3][1]{{1. / 3.}, {1. / 3.}, {1. / 2.}}

static const t_real __HammerTri_3[3][3]{{2. / 3., 1. / 6., 1. / 6.}, {1. / 6., 2. / 3., 1. / 6.}, {1. / 6., 1. / 6., 1. / 6.}}

static const t_real __HammerTri_6[3][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 const t_real __HammerTri_7[3][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 const t_real __HammerTri_12[3][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

struct Element

Public Functions

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>

Public Static Functions

static inline constexpr ElemType GetFaceType(t_index)

static inline constexpr ElemType GetBisectElemType(t_index)

Public Static Attributes

static constexpr std::array<t_real, 3 * 27> standardCoords = {-1, -1, -1, 1, -1, -1, 1, 1, -1, -1, 1, -1, -1, -1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1, 0, -1, -1, 1, 0, -1, 0, 1, -1, -1, 0, -1, -1, -1, 0, 1, -1, 0, 1, 1, 0, -1, 1, 0, 0, -1, 1, 1, 0, 1, 0, 1, 1, -1, 0, 1, 0, 0, -1, 0, -1, 0, 1, 0, 0, 0, 1, 0, -1, 0, 0, 0, 0, 1, 0, 0, 0}

static constexpr std::array<std::array<t_index, 10>, 6> faceNodes = {{{0, 3, 2, 1, 11, 10, 9, 8, 20}, {0, 1, 5, 4, 8, 13, 16, 12, 21}, {1, 2, 6, 5, 9, 14, 17, 13, 22}, {2, 3, 7, 6, 10, 15, 18, 14, 23}, {0, 4, 7, 3, 12, 19, 15, 11, 24}, {4, 5, 6, 7, 16, 17, 18, 19, 25}}}

static constexpr ElemType elevatedType = UnknownElem

static constexpr int numElevNodes = 0

static constexpr int numBisect = 8

static constexpr int numBisectVariants = 1

static constexpr std::array<tBisectSub, 8> bisectElements = {{{0, 8, 20, 11, 12, 21, 26, 24}, {8, 1, 9, 20, 21, 13, 22, 26}, {11, 20, 10, 3, 24, 26, 23, 15}, {20, 9, 2, 10, 26, 22, 14, 23}, {12, 21, 26, 24, 4, 16, 25, 19}, {21, 13, 22, 26, 16, 5, 17, 25}, {24, 26, 23, 15, 19, 25, 18, 7}, {26, 22, 14, 23, 25, 17, 6, 18}}}

static constexpr int vtkCellType = 25

static constexpr std::array<int, 20> vtkNodeOrder = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 16, 17, 18, 19, 12, 13, 14, 15}

template<>
struct ElementTraits<Hex8>

Public Static Functions

static inline constexpr ElemType GetFaceType(t_index)

Public Static Attributes

static constexpr std::array<t_real, 3 * 8> standardCoords = {-1, -1, -1, 1, -1, -1, 1, 1, -1, -1, 1, -1, -1, -1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1}

static constexpr std::array<std::array<t_index, 10>, 6> faceNodes = {{{0, 3, 2, 1}, {0, 1, 5, 4}, {1, 2, 6, 5}, {2, 3, 7, 6}, {0, 4, 7, 3}, {4, 5, 6, 7}}}

static constexpr ElemType elevatedType = Hex27

static constexpr int numElevNodes = 19

static constexpr std::array<tElevSpan, 19> elevSpans = {{{0, 1}, {1, 2}, {2, 3}, {3, 0}, {0, 4}, {1, 5}, {2, 6}, {3, 7}, {4, 5}, {5, 6}, {6, 7}, {7, 4}, {0, 3, 2, 1}, {0, 1, 5, 4}, {1, 2, 6, 5}, {2, 3, 7, 6}, {0, 4, 7, 3}, {4, 5, 6, 7}, {0, 1, 2, 3, 4, 5, 6, 7}}}

static constexpr std::array<ElemType, 19> elevNodeSpanTypes = {Line2, Line2, Line2, Line2, Line2, Line2, Line2, Line2, Line2, Line2, Line2, Line2, Quad4, Quad4, Quad4, Quad4, Quad4, Quad4, Hex8}

static constexpr int vtkCellType = 12

static constexpr std::array<int, 8> vtkNodeOrder = {0, 1, 2, 3, 4, 5, 6, 7}

template<>
struct ElementTraits<Line2>

Public Static Functions

static inline constexpr ElemType GetFaceType(t_index)

Public Static Attributes

static constexpr ElemType elemType = Line2

static constexpr int dim = 1

static constexpr int order = 1

static constexpr int numVertices = 2

static constexpr int numNodes = 2

static constexpr int numFaces = 0

static constexpr ParamSpace paramSpace = LineSpace

static constexpr t_real paramSpaceVol = 2.0

static constexpr std::array<t_real, 3 * 2> standardCoords = {-1, 0, 0, 1, 0, 0}

static constexpr ElemType elevatedType = Line3

static constexpr int numElevNodes = 1

static constexpr std::array<tElevSpan, 1> elevSpans = {{{0, 1}}}

static constexpr std::array<ElemType, 1> elevNodeSpanTypes = {Line2}

static constexpr int vtkCellType = 3

static constexpr std::array<int, 2> vtkNodeOrder = {0, 1}

template<>
struct ElementTraits<Line3>

Public Static Functions

static inline constexpr ElemType GetFaceType(t_index)

static inline constexpr ElemType GetBisectElemType(t_index)

Public Static Attributes

static constexpr ElemType elemType = Line3

static constexpr int dim = 1

static constexpr int order = 2

static constexpr int numVertices = 2

static constexpr int numNodes = 3

static constexpr int numFaces = 0

static constexpr ParamSpace paramSpace = LineSpace

static constexpr t_real paramSpaceVol = 2.0

static constexpr std::array<t_real, 3 * 3> standardCoords = {-1, 0, 0, 1, 0, 0, 0, 0, 0}

static constexpr ElemType elevatedType = UnknownElem

static constexpr int numElevNodes = 0

static constexpr int numBisect = 2

static constexpr int numBisectVariants = 1

static constexpr std::array<tBisectSub, 2> bisectElements = {{{0, 2}, {2, 1}}}

static constexpr int vtkCellType = 4

static constexpr std::array<int, 3> vtkNodeOrder = {0, 2, 1}

template<>
struct ElementTraits<Prism18>

Public Static Functions

static inline constexpr ElemType GetFaceType(t_index iFace)

static inline constexpr ElemType GetBisectElemType(t_index)

Public Static Attributes

static constexpr std::array<t_real, 3 * 18> standardCoords = {0, 0, -1, 1, 0, -1, 0, 1, -1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0.5, 0, -1, 0.5, 0.5, -1, 0, 0.5, -1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0.5, 0, 1, 0.5, 0.5, 1, 0, 0.5, 1, 0.5, 0, 0, 0.5, 0.5, 0, 0, 0.5, 0}

static constexpr std::array<std::array<t_index, 10>, 5> faceNodes = {{{0, 1, 4, 3, 6, 10, 12, 9, 15}, {1, 2, 5, 4, 7, 11, 13, 10, 16}, {2, 0, 3, 5, 8, 9, 14, 11, 17}, {0, 2, 1, 8, 7, 6}, {3, 4, 5, 9, 10, 11}}}

static constexpr ElemType elevatedType = UnknownElem

static constexpr int numElevNodes = 0

static constexpr int numBisect = 8

static constexpr int numBisectVariants = 1

static constexpr std::array<tBisectSub, 8> bisectElements = {{{0, 6, 8, 9, 15, 17}, {6, 1, 7, 15, 10, 16}, {8, 6, 7, 17, 15, 16}, {8, 7, 2, 17, 16, 11}, {9, 15, 17, 3, 12, 14}, {15, 10, 16, 12, 4, 13}, {17, 15, 16, 14, 12, 13}, {17, 16, 11, 14, 13, 5}}}

static constexpr int vtkCellType = 26

static constexpr std::array<int, 15> vtkNodeOrder = {0, 1, 2, 3, 4, 5, 6, 7, 8, 12, 13, 14, 9, 10, 11}

template<>
struct ElementTraits<Prism6>

Public Static Functions

static inline constexpr ElemType GetFaceType(t_index iFace)

Public Static Attributes

static constexpr std::array<t_real, 3 * 6> standardCoords = {0, 0, -1, 1, 0, -1, 0, 1, -1, 0, 0, 1, 1, 0, 1, 0, 1, 1}

static constexpr std::array<std::array<t_index, 10>, 5> faceNodes = {{{0, 1, 4, 3}, {1, 2, 5, 4}, {2, 0, 3, 5}, {0, 2, 1}, {3, 4, 5}}}

static constexpr ElemType elevatedType = Prism18

static constexpr int numElevNodes = 12

static constexpr std::array<tElevSpan, 12> elevSpans = {{{0, 1}, {1, 2}, {2, 0}, {0, 3}, {1, 4}, {2, 5}, {3, 4}, {4, 5}, {5, 3}, {0, 1, 4, 3}, {1, 2, 5, 4}, {2, 0, 3, 5}}}

static constexpr std::array<ElemType, 12> elevNodeSpanTypes = {Line2, Line2, Line2, Line2, Line2, Line2, Line2, Line2, Line2, Quad4, Quad4, Quad4}

static constexpr int vtkCellType = 13

static constexpr std::array<int, 6> vtkNodeOrder = {0, 1, 2, 3, 4, 5}

template<>
struct ElementTraits<Pyramid14>

Public Static Functions

static inline constexpr ElemType GetFaceType(t_index iFace)

static inline constexpr ElemType GetBisectElemType(t_index i)

Public Static Attributes

static constexpr std::array<t_real, 3 * 14> standardCoords = {-1, -1, 0, 1, -1, 0, 1, 1, 0, -1, 1, 0, 0, 0, 1, 0, -1, 0, 1, 0, 0, 0, 1, 0, -1, 0, 0, -0.5, -0.5, 0.5, 0.5, -0.5, 0.5, 0.5, 0.5, 0.5, -0.5, 0.5, 0.5, 0, 0, 0}

static constexpr std::array<std::array<t_index, 10>, 5> faceNodes = {{{0, 3, 2, 1, 8, 7, 6, 5, 13}, {0, 1, 4, 5, 10, 9}, {1, 2, 4, 6, 11, 10}, {2, 3, 4, 7, 12, 11}, {3, 0, 4, 8, 9, 12}}}

static constexpr ElemType elevatedType = UnknownElem

static constexpr int numElevNodes = 0

static constexpr int numBisect = 12

static constexpr int numBisectVariants = 2

static constexpr std::array<tBisectSub, 24> bisectElements = {{{0, 5, 13, 8, 9}, {5, 1, 6, 13, 10}, {8, 13, 7, 3, 12}, {13, 6, 2, 7, 11}, {12, 9, 8, 13}, {9, 10, 5, 13}, {10, 11, 6, 13}, {11, 12, 7, 13}, {9, 11, 12, 4}, {9, 10, 11, 4}, {9, 11, 10, 13}, {9, 12, 11, 13}, {0, 5, 13, 8, 9}, {5, 1, 6, 13, 10}, {8, 13, 7, 3, 12}, {13, 6, 2, 7, 11}, {12, 9, 8, 13}, {9, 10, 5, 13}, {10, 11, 6, 13}, {11, 12, 7, 13}, {10, 12, 9, 4}, {10, 11, 12, 4}, {10, 12, 11, 13}, {10, 9, 12, 13}}}

static constexpr int vtkCellType = 27

static constexpr std::array<int, 13> vtkNodeOrder = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}

template<>
struct ElementTraits<Pyramid5>

Public Static Functions

static inline constexpr ElemType GetFaceType(t_index iFace)

Public Static Attributes

static constexpr std::array<t_real, 3 * 5> standardCoords = {-1, -1, 0, 1, -1, 0, 1, 1, 0, -1, 1, 0, 0, 0, 1}

static constexpr std::array<std::array<t_index, 10>, 5> faceNodes = {{{0, 3, 2, 1}, {0, 1, 4}, {1, 2, 4}, {2, 3, 4}, {3, 0, 4}}}

static constexpr ElemType elevatedType = Pyramid14

static constexpr int numElevNodes = 9

static constexpr std::array<tElevSpan, 9> elevSpans = {{{0, 1}, {1, 2}, {2, 3}, {3, 0}, {0, 4}, {1, 4}, {2, 4}, {3, 4}, {0, 3, 2, 1}}}

static constexpr std::array<ElemType, 9> elevNodeSpanTypes = {Line2, Line2, Line2, Line2, Line2, Line2, Line2, Line2, Quad4}

static constexpr int vtkCellType = 14

static constexpr std::array<int, 5> vtkNodeOrder = {0, 1, 2, 3, 4}

template<>
struct ElementTraits<Quad4>

Public Static Functions

static inline constexpr ElemType GetFaceType(t_index)

Public Static Attributes

static constexpr std::array<t_real, 3 * 4> standardCoords = {-1, -1, 0, 1, -1, 0, 1, 1, 0, -1, 1, 0}

static constexpr std::array<std::array<t_index, 10>, 4> faceNodes = {{{0, 1}, {1, 2}, {2, 3}, {3, 0}}}

static constexpr ElemType elevatedType = Quad9

static constexpr int numElevNodes = 5

static constexpr std::array<tElevSpan, 5> elevSpans = {{{0, 1}, {1, 2}, {2, 3}, {3, 0}, {0, 1, 2, 3}}}

static constexpr std::array<ElemType, 5> elevNodeSpanTypes = {Line2, Line2, Line2, Line2, Quad4}

static constexpr int vtkCellType = 9

static constexpr std::array<int, 4> vtkNodeOrder = {0, 1, 2, 3}

template<>
struct ElementTraits<Quad9>

Public Static Functions

static inline constexpr ElemType GetFaceType(t_index)

static inline constexpr ElemType GetBisectElemType(t_index)

Public Static Attributes

static constexpr std::array<t_real, 3 * 9> standardCoords = {-1, -1, 0, 1, -1, 0, 1, 1, 0, -1, 1, 0, 0, -1, 0, 1, 0, 0, 0, 1, 0, -1, 0, 0, 0, 0, 0}

static constexpr std::array<std::array<t_index, 10>, 4> faceNodes = {{{0, 1, 4}, {1, 2, 5}, {2, 3, 6}, {3, 0, 7}}}

static constexpr ElemType elevatedType = UnknownElem

static constexpr int numElevNodes = 0

static constexpr int numBisect = 4

static constexpr int numBisectVariants = 1

static constexpr std::array<tBisectSub, 4> bisectElements = {{{0, 4, 8, 7}, {4, 1, 5, 8}, {7, 8, 6, 3}, {8, 5, 2, 6}}}

static constexpr int vtkCellType = 23

static constexpr std::array<int, 8> vtkNodeOrder = {0, 1, 2, 3, 4, 5, 6, 7}

template<>
struct ElementTraits<Tet10>

Public Static Functions

static inline constexpr ElemType GetFaceType(t_index)

static inline constexpr ElemType GetBisectElemType(t_index)

Public Static Attributes

static constexpr std::array<t_real, 3 * 10> standardCoords = {0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0.5, 0, 0, 0.5, 0.5, 0, 0, 0.5, 0, 0, 0, 0.5, 0.5, 0, 0.5, 0, 0.5, 0.5}

static constexpr std::array<std::array<t_index, 10>, 4> faceNodes = {{{0, 2, 1, 6, 5, 4}, {0, 1, 3, 4, 8, 7}, {1, 2, 3, 5, 9, 8}, {2, 0, 3, 6, 7, 9}}}

static constexpr ElemType elevatedType = UnknownElem

static constexpr int numElevNodes = 0

static constexpr int numBisect = 8

static constexpr int numBisectVariants = 3

static constexpr std::array<tBisectSub, 24> bisectElements = {{{0, 4, 6, 7}, {4, 1, 5, 8}, {6, 5, 2, 9}, {9, 7, 8, 3}, {4, 9, 6, 7}, {4, 8, 9, 7}, {4, 9, 8, 5}, {4, 6, 9, 5}, {0, 4, 6, 7}, {4, 1, 5, 8}, {6, 5, 2, 9}, {9, 7, 8, 3}, {5, 6, 7, 9}, {5, 7, 8, 9}, {5, 8, 7, 4}, {5, 7, 6, 4}, {0, 4, 6, 7}, {4, 1, 5, 8}, {6, 5, 2, 9}, {9, 7, 8, 3}, {6, 7, 8, 9}, {6, 8, 5, 9}, {6, 8, 7, 4}, {6, 5, 8, 4}}}

static constexpr int vtkCellType = 24

static constexpr std::array<int, 10> vtkNodeOrder = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

template<>
struct ElementTraits<Tet4>

Public Static Functions

static inline constexpr ElemType GetFaceType(t_index)

Public Static Attributes

static constexpr std::array<t_real, 3 * 4> standardCoords = {0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1}

static constexpr std::array<std::array<t_index, 10>, 4> faceNodes = {{{0, 2, 1}, {0, 1, 3}, {1, 2, 3}, {2, 0, 3}}}

static constexpr ElemType elevatedType = Tet10

static constexpr int numElevNodes = 6

static constexpr std::array<tElevSpan, 6> elevSpans = {{{0, 1}, {1, 2}, {2, 0}, {0, 3}, {1, 3}, {2, 3}}}

static constexpr std::array<ElemType, 6> elevNodeSpanTypes = {Line2, Line2, Line2, Line2, Line2, Line2}

static constexpr int vtkCellType = 10

static constexpr std::array<int, 4> vtkNodeOrder = {0, 1, 2, 3}

template<>
struct ElementTraits<Tri3>

Public Static Functions

static inline constexpr ElemType GetFaceType(t_index)

Public Static Attributes

static constexpr std::array<t_real, 3 * 3> standardCoords = {0, 0, 0, 1, 0, 0, 0, 1, 0}

static constexpr std::array<std::array<t_index, 10>, 3> faceNodes = {{{0, 1}, {1, 2}, {2, 0}}}

static constexpr ElemType elevatedType = Tri6

static constexpr int numElevNodes = 3

static constexpr std::array<tElevSpan, 3> elevSpans = {{{0, 1}, {1, 2}, {2, 0}}}

static constexpr std::array<ElemType, 3> elevNodeSpanTypes = {Line2, Line2, Line2}

static constexpr int vtkCellType = 5

static constexpr std::array<int, 3> vtkNodeOrder = {0, 1, 2}

template<>
struct ElementTraits<Tri6>

Public Static Functions

static inline constexpr ElemType GetFaceType(t_index)

static inline constexpr ElemType GetBisectElemType(t_index)

Public Static Attributes

static constexpr std::array<t_real, 3 * 6> standardCoords = {0, 0, 0, 1, 0, 0, 0, 1, 0, 0.5, 0, 0, 0.5, 0.5, 0, 0, 0.5, 0}

static constexpr std::array<std::array<t_index, 10>, 3> faceNodes = {{{0, 1, 3}, {1, 2, 4}, {2, 0, 5}}}

static constexpr ElemType elevatedType = UnknownElem

static constexpr int numElevNodes = 0

static constexpr int numBisect = 4

static constexpr int numBisectVariants = 1

static constexpr std::array<tBisectSub, 4> bisectElements = {{{0, 3, 5}, {3, 1, 4}, {5, 3, 4}, {5, 4, 2}}}

static constexpr int vtkCellType = 22

static constexpr std::array<int, 6> vtkNodeOrder = {0, 1, 2, 3, 4, 5}

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

namespace HardEigen

Functions

real EigenLeastSquareInverse(const Eigen::MatrixXd &A, Eigen::MatrixXd &AI, real svdTol = 0)

real EigenLeastSquareInverse_Filtered(const Eigen::MatrixXd &A, Eigen::MatrixXd &AI, real svdTol = 0, int mode = 0)

Eigen::Matrix3d Eigen3x3RealSymEigenDecomposition(const Eigen::Matrix3d &A)

Eigen::Matrix2d Eigen2x2RealSymEigenDecomposition(const Eigen::Matrix2d &A)

real Eigen2x2RealSymEigenDecompositionGetCond(const Eigen::Matrix2d &A)

real Eigen3x3RealSymEigenDecompositionGetCond(const Eigen::Matrix3d &A)

real Eigen3x3RealSymEigenDecompositionGetCond01(const Eigen::Matrix3d &A)

Eigen::Matrix3d Eigen3x3RealSymEigenDecompositionNormalized(const Eigen::Matrix3d &A)

Eigen::Matrix2d Eigen2x2RealSymEigenDecompositionNormalized(const Eigen::Matrix2d &A)

Eigen::Index EigenLeastSquareSolve(const Eigen::MatrixXd &A, const Eigen::MatrixXd &B, Eigen::MatrixXd &AIB)

namespace IdealGas

Enums

enum class PrimVariable

Values:

enumerator Pressure

enumerator InternalEnergy

Functions

inline DNDS_DEVICE_CALLABLE void IdealGasThermal (real E, real rho, real vSqr, real gamma, real &p, real &asqr, real &H)

inline DNDS_DEVICE_CALLABLE real Pressure_From_InternalEnergy (real e, real gamma)

inline DNDS_DEVICE_CALLABLE real InternalEnergy_From_Pressure (real p, real gamma)

inline DNDS_DEVICE_CALLABLE real Enthalpy (real E, real rho, real p)

inline DNDS_DEVICE_CALLABLE real SpeedOfSoundSqr (real gamma, real p, real rho)

template<PrimVariable prim> inline DNDS_DEVICE_CALLABLE real Cons2PrimEnergy (real E, real rho, real vSqr, real gamma)

template<PrimVariable prim> inline DNDS_DEVICE_CALLABLE real Prim2ConsEnergy (real primE, real rho, real vSqr, real gamma)

template<PrimVariable prim> inline DNDS_DEVICE_CALLABLE real PrimE2Pressure (real primE, real gamma)

inline DNDS_DEVICE_CALLABLE real RoeSpeedOfSoundSqr (real gamma, real HRoe, real vsqrRoe)

inline DNDS_DEVICE_CALLABLE void RoeAlphaDecomposition (real incU0, real incU123N, real incU4b, real veloRoeN, real HRoe, real asqrRoe, real aRoe, real gamma, real &alpha0, real &alpha1, real &alpha4)

inline DNDS_DEVICE_CALLABLE void EntropyFix_HCorrHY (real aL, real aR, real vnL, real vnR, real dLambda, real fixScale, real &lam0, real &lam123, real &lam4)

Variables

static constexpr real kScaleHartenYee = 0.05

static constexpr real kScaleLD = 0.2

static constexpr real kScaleHFix = 0.25

namespace Linear

template<class TDATA>
class GMRES_LeftPreconditioned

Public Functions

template<class TFA, class TFML, class TFDot, class TFstop>
inline bool solve(TFA &&FA, TFML &&FML, TFDot &&fDot, TDATA &b, TDATA &x, uint32_t nRestart, TFstop &&FStop)

template<class TDATA, class TScalar>
class PCG_PreconditionedRes

namespace Meta

Variables

template<typename T>
constexpr bool always_false = false

template<typename _Tp>
constexpr bool is_std_array_v = is_std_array<_Tp>::value

template<typename _Tp>
constexpr bool is_fixed_data_real_eigen_matrix_v = is_fixed_data_real_eigen_matrix<_Tp>::value

template<typename T>
constexpr bool is_eigen_dense_v = std::is_base_of_v<Eigen::DenseBase<T>, T>

template<class T>
constexpr bool is_real_eigen_matrix_v = is_real_eigen_matrix<T>::value

template<class T>
constexpr bool is_real_eigen_fmt_safe_matrix_v = is_real_eigen_fmt_safe_matrix<T>::value

const bool v = is_real_eigen_fmt_safe_matrix_v<Eigen::MatrixFMTSafe<real, 3, 3>>

template<typename T, typename = void>
struct has_std_hash : public std::false_type

template<typename T>
struct has_std_hash<T, std::void_t<decltype(std::hash<T>{}(std::declval<T>()))>> : public std::true_type

template<class T>
struct is_fixed_data_real_eigen_matrix

template<class T, int M, int N, int options, int max_m, int max_n>
struct is_fixed_data_real_eigen_matrix<Eigen::Matrix<T, M, N, options, max_m, max_n>>

template<class T>
struct is_real_eigen_fmt_safe_matrix : public std::false_type

template<int M, int N, int options, int max_m, int max_n>
struct is_real_eigen_fmt_safe_matrix<Eigen::MatrixFMTSafe<real, M, N, options, max_m, max_n>> : public std::true_type

template<class T>
struct is_real_eigen_matrix

template<int M, int N, int options, int max_m, int max_n>
struct is_real_eigen_matrix<Eigen::Matrix<real, M, N, options, max_m, max_n>>

template<class T>
struct is_std_array : public std::false_type

template<class T, size_t N>
struct is_std_array<std::array<T, N>> : public std::true_type

template<class T>
struct is_std_vector : public std::false_type

template<class T, class Allocator>
struct is_std_vector<std::vector<T, Allocator>> : public std::true_type

namespace MPI

Functions

MPI_int Bcast(void *buf, MPI_int num, MPI_Datatype type, MPI_int source_rank, MPI_Comm comm)

MPI_int Alltoall(void *send, MPI_int sendNum, MPI_Datatype typeSend, void *recv, MPI_int recvNum, MPI_Datatype typeRecv, MPI_Comm comm)

MPI_int Alltoallv(void *send, MPI_int *sendSizes, MPI_int *sendStarts, MPI_Datatype sendType, void *recv, MPI_int *recvSizes, MPI_int *recvStarts, MPI_Datatype recvType, MPI_Comm comm)

MPI_int Allreduce(const void *sendbuf, void *recvbuf, MPI_int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)

MPI_int Scan(const void *sendbuf, void *recvbuf, MPI_int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)

MPI_int Allgather(const void *sendbuf, MPI_int sendcount, MPI_Datatype sendtype, void *recvbuf, MPI_int recvcount, MPI_Datatype recvtype, MPI_Comm comm)

MPI_int Barrier(MPI_Comm comm)

MPI_int BarrierLazy(MPI_Comm comm, uint64_t checkNanoSecs)

MPI_int WaitallLazy(MPI_int count, MPI_Request *reqs, MPI_Status *statuses, uint64_t checkNanoSecs = 10000000)

MPI_int WaitallAuto(MPI_int count, MPI_Request *reqs, MPI_Status *statuses)

bool isCudaAware()

inline int GetMPIThreadLevel()

inline MPI_int Init_thread(int *argc, char ***argv)

inline int Finalize()

inline void AllreduceOneReal(real &v, MPI_Op op, const MPIInfo &mpi)

inline void AllreduceOneIndex(index &v, MPI_Op op, const MPIInfo &mpi)

void pybind11_Init_thread(py::module_ &m)

void pybind11_MPI_Operations(py::module_ &m)

class CommStrategy

Public Types

enum ArrayCommType

Values:

enumerator UnknownArrayCommType

enumerator HIndexed

enumerator InSituPack

Public Functions

ArrayCommType GetArrayStrategy()

void SetArrayStrategy(ArrayCommType t)

bool GetUseStrongSyncWait() const

bool GetUseAsyncOneByOne() const

double GetUseLazyWait() const

Public Static Functions

static CommStrategy &Instance()

class ResourceRecycler

Public Functions

void RegisterCleaner(void *p, std::function<void()> nCleaner)

void RemoveCleaner(void *p)

void clean()

Public Static Functions

static ResourceRecycler &Instance()

namespace ODE

template<class TDATA, class TDTAU>
class ExplicitSSPRK3TimeStepAsImplicitDualTimeStep : public DNDS::ODE::ImplicitDualTimeStep<TDATA, TDTAU>

Public Functions

inline virtual void Step(TDATA &x, TDATA &xinc, const Frhs &frhs, const Fdt &fdt, const Fsolve &fsolve, int maxIter, const Fstop &fstop, const Fincrement &fincrement, real dt) override

template<class TDATA, class TDTAU>
class ImplicitBDFDualTimeStep : public DNDS::ODE::ImplicitDualTimeStep<TDATA, TDTAU>

Public Functions

template<class Finit, class FinitDtau>
inline ImplicitBDFDualTimeStep(index NDOF, Finit &&finit = [](TDATA &) {}, FinitDtau &&finitDtau = [](TDTAU &) {}, index k = 2)

inline virtual void Step(TDATA &x, TDATA &xinc, const Frhs &frhs, const Fdt &fdt, const Fsolve &fsolve, int maxIter, const Fstop &fstop, const Fincrement &fincrement, real dt) override

template<class TDATA, class TDTAU>
class ImplicitDualTimeStep

Subclassed by DNDS::ODE::ExplicitSSPRK3TimeStepAsImplicitDualTimeStep< TDATA, TDTAU >, DNDS::ODE::ImplicitBDFDualTimeStep< TDATA, TDTAU >, DNDS::ODE::ImplicitEulerDualTimeStep< TDATA, TDTAU >, DNDS::ODE::ImplicitHermite3SimpleJacobianDualStep< TDATA, TDTAU >, DNDS::ODE::ImplicitSDIRK4DualTimeStep< TDATA, TDTAU >, DNDS::ODE::ImplicitVBDFDualTimeStep< TDATA, TDTAU >

template<class TDATA, class TDTAU>
class ImplicitEulerDualTimeStep : public DNDS::ODE::ImplicitDualTimeStep<TDATA, TDTAU>

Public Functions

template<class Finit, class FinitDtau>
inline ImplicitEulerDualTimeStep(index NDOF, Finit &&finit = [](TDATA &) {}, FinitDtau &&finitDtau = [](TDTAU &) {})

inline virtual void Step(TDATA &x, TDATA &xinc, const Frhs &frhs, const Fdt &fdt, const Fsolve &fsolve, int maxIter, const Fstop &fstop, const Fincrement &fincrement, real dt) override

template<class TDATA, class TDTAU>
class ImplicitHermite3SimpleJacobianDualStep : public DNDS::ODE::ImplicitDualTimeStep<TDATA, TDTAU>

Public Functions

template<class Finit, class FinitDtau>
inline ImplicitHermite3SimpleJacobianDualStep(index NDOF, Finit &&finit = [](TDATA &) {}, FinitDtau &&finitDtau = [](TDTAU &) {}, real alpha = 0.55, int nCurSolveMethod = 0, int nnStartIter = 0, real thetaM1n = 0.9146, real thetaM2n = 0.0, int mask = 0, int nMGn = 4)

inline virtual void Step(TDATA &x, TDATA &xinc, const Frhs &frhs, const Fdt &fdt, const Fsolve &fsolve, int maxIter, const Fstop &fstop, const Fincrement &fincrement, real dt) override

template<class TDATA, class TDTAU>
class ImplicitSDIRK4DualTimeStep : public DNDS::ODE::ImplicitDualTimeStep<TDATA, TDTAU>

Public Functions

template<class Finit, class FinitDtau>
inline ImplicitSDIRK4DualTimeStep(index NDOF, Finit &&finit = [](TDATA &) {}, FinitDtau &&finitDtau = [](TDTAU &) {}, int schemeCode = 0)

inline virtual void Step(TDATA &x, TDATA &xinc, const Frhs &frhs, const Fdt &fdt, const Fsolve &fsolve, int maxIter, const Fstop &fstop, const Fincrement &fincrement, real dt) override

template<class TDATA, class TDTAU>
class ImplicitVBDFDualTimeStep : public DNDS::ODE::ImplicitDualTimeStep<TDATA, TDTAU>

Public Functions

template<class Finit, class FinitDtau>
inline ImplicitVBDFDualTimeStep(index NDOF, Finit &&finit = [](TDATA &) {}, FinitDtau &&finitDtau = [](TDTAU &) {}, index k = 2)

inline virtual void Step(TDATA &x, TDATA &xinc, const Frhs &frhs, const Fdt &fdt, const Fsolve &fsolve, int maxIter, const Fstop &fstop, const Fincrement &fincrement, real dt) override

namespace OMP

Functions

inline void set_full_parallel_OMP()

namespace Scalar

Functions

template<class TF>
real BisectSolveLower(TF &&F, real v0, real v1, real fTarget, int maxIter)

namespace Serializer

Typedefs

using SerializerBaseSSP = ssp<SerializerBase>

Functions

void pybind11_bind_Serializer(py::module_ m)

inline auto pybind11_SerializerBase_declare(py::module_ m)

inline auto pybind11_SerializerBase_get_class(py::module_ m)

inline void pybind11_SerializerBase_define(py::module_ m)

inline auto pybind11_SerializerJSON_declare(py::module_ m)

inline void pybind11_SerializerJSON_define(py::module_ m)

inline auto pybind11_SerializerH5_declare(py::module_ m)

inline void pybind11_SerializerH5_define(py::module_ m)

inline auto pybind11_SerializerFactory_declare(py::module_ m)

inline void pybind11_SerializerFactory_define(py::module_ m)

static bool processPath(std::vector<std::string> &pth)

static std::string constructPath(std::vector<std::string> &pth)

static hid_t GetGroupOfFileIfExist(hid_t file_id, bool read, const std::string &groupName, bool coll_on_meta)

static herr_t link_iterate_cb(hid_t group_id, const char *name, const H5L_info_t *info, void *op_data)

static herr_t attribute_iterate_cb(hid_t obj_id, const char *attr_name, const H5A_info_t *info, void *op_data)

template<typename T>
void WriteAttributeScalar(const std::string &name, const T &v, hid_t h5file, bool reading, const std::string &cP, bool coll_on_meta)

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 dxpl_id, hid_t dapl_id, int64_t chunksize, int deflateLevel, const void *buf, int dim2 = -1)

template<typename T = index>
static void WriteDataVector(const std::string &name, const T *v, size_t size, ArrayGlobalOffset offset, int64_t chunksize, int deflateLevel, hid_t h5file, bool reading, const std::string &cP, const MPIInfo &mpi, MPI_Comm commDup, bool coll_on_meta, bool coll_on_data)

template<typename T>
void ReadAttributeScalar(const std::string &name, T &v, hid_t h5file, bool reading, const std::string &cP, bool coll_on_meta)

static void H5_ReadDataset(hid_t loc, const char *name, index &nGlobal, index nOffset, index nLocal, hid_t mem_dataType, hid_t dxpl_id, hid_t dapl_id, void *buf, int &dim2)

template<typename T = index>
static void ReadDataVector(const std::string &name, T *v, size_t &size, ArrayGlobalOffset &offset, hid_t h5file, bool reading, const std::string &cP, const MPIInfo &mpi, bool coll_on_meta, bool coll_on_data)

Variables

static const index Offset_Parts = -1

static const index Offset_One = -2

static const index Offset_EvenSplit = -3

static const index Offset_Unknown = UnInitIndex

static const ArrayGlobalOffset ArrayGlobalOffset_Unknown = ArrayGlobalOffset{0, Offset_Unknown}

static const ArrayGlobalOffset ArrayGlobalOffset_One = ArrayGlobalOffset{0, Offset_One}

static const ArrayGlobalOffset ArrayGlobalOffset_Parts = ArrayGlobalOffset{0, Offset_Parts}

static const ArrayGlobalOffset ArrayGlobalOffset_EvenSplit = ArrayGlobalOffset{0, Offset_EvenSplit}

class ArrayGlobalOffset

Public Functions

inline ArrayGlobalOffset(index __size, index __offset)

inline index size() const

inline index offset() const

inline ArrayGlobalOffset operator*(index R) const

inline ArrayGlobalOffset operator/(index R) const

inline void CheckMultipleOf(index R) const

inline bool operator==(const ArrayGlobalOffset &other) const

inline operator std::string() const

inline bool isDist() const

struct H5Contents

class SerializerBase

Subclassed by DNDS::Serializer::SerializerH5, DNDS::Serializer::SerializerJSON

Unnamed Group

virtual void ReadIndexVector(const std::string &name, std::vector<index> &v, ArrayGlobalOffset &offset) = 0

Public Functions

virtual void OpenFile(const std::string &fName, bool read) = 0

virtual void CloseFile() = 0

virtual void CreatePath(const std::string &p) = 0

virtual void GoToPath(const std::string &p) = 0

virtual bool IsPerRank() = 0

virtual std::string GetCurrentPath() = 0

virtual std::set<std::string> ListCurrentPath() = 0

virtual int GetMPIRank() = 0

virtual int GetMPISize() = 0

virtual const MPIInfo &getMPI() = 0

virtual void WriteInt(const std::string &name, int v) = 0

virtual void WriteIndex(const std::string &name, index v) = 0

virtual void WriteReal(const std::string &name, real v) = 0

virtual void WriteString(const std::string &name, const std::string &v) = 0

virtual void WriteIndexVector(const std::string &name, const std::vector<index> &v, ArrayGlobalOffset offset) = 0

virtual void WriteRowsizeVector(const std::string &name, const std::vector<rowsize> &v, ArrayGlobalOffset offset) = 0

virtual void WriteRealVector(const std::string &name, const std::vector<real> &v, ArrayGlobalOffset offset) = 0

virtual void WriteSharedIndexVector(const std::string &name, const ssp<host_device_vector<index>> &v, ArrayGlobalOffset offset) = 0

virtual void WriteSharedRowsizeVector(const std::string &name, const ssp<host_device_vector<rowsize>> &v, ArrayGlobalOffset offset) = 0

virtual void WriteUint8Array(const std::string &name, const uint8_t *data, index size, ArrayGlobalOffset offset) = 0

virtual void WriteIndexVectorPerRank(const std::string &name, const std::vector<index> &v) = 0

virtual void ReadInt(const std::string &name, int &v) = 0

virtual void ReadIndex(const std::string &name, index &v) = 0

virtual void ReadReal(const std::string &name, real &v) = 0

virtual void ReadString(const std::string &name, std::string &v) = 0

virtual void ReadUint8Array(const std::string &name, uint8_t *data, index &size, ArrayGlobalOffset &offset) = 0

struct SerializerFactory

Public Functions

inline SerializerFactory(const std::string &_type)

inline SerializerBaseSSP BuildSerializer(const MPIInfo &mpi)

inline std::tuple<std::string, std::string> ModifyFilePath(std::string fname, const MPIInfo &mpi, std::string rank_part_fmt = "%06d", bool read = false)

Public Members

std::string type = "JSON"

int hdfDeflateLevel = 0

int hdfChunkSize = 0

bool hdfCollOnData = false

bool hdfCollOnMeta = true

int jsonBinaryDeflateLevel = 5

bool jsonUseCodecOnUInt8 = true

class SerializerH5 : public DNDS::Serializer::SerializerBase

Public Functions

virtual void OpenFile(const std::string &fName, bool read) override

virtual void CloseFile() override

virtual void CreatePath(const std::string &p) override

virtual void GoToPath(const std::string &p) override

inline virtual bool IsPerRank() override

virtual std::string GetCurrentPath() override

virtual std::set<std::string> ListCurrentPath() override

inline virtual int GetMPIRank() override

inline virtual int GetMPISize() override

inline virtual const MPIInfo &getMPI() override

virtual void WriteInt(const std::string &name, int v) override

virtual void WriteIndex(const std::string &name, index v) override

virtual void WriteReal(const std::string &name, real v) override

virtual void WriteString(const std::string &name, const std::string &v) override

virtual void WriteIndexVector(const std::string &name, const std::vector<index> &v, ArrayGlobalOffset offset) override

virtual void WriteRowsizeVector(const std::string &name, const std::vector<rowsize> &v, ArrayGlobalOffset offset) override

virtual void WriteRealVector(const std::string &name, const std::vector<real> &v, ArrayGlobalOffset offset) override

virtual void WriteSharedIndexVector(const std::string &name, const ssp<host_device_vector<index>> &v, ArrayGlobalOffset offset) override

virtual void WriteSharedRowsizeVector(const std::string &name, const ssp<host_device_vector<rowsize>> &v, ArrayGlobalOffset offset) override

virtual void WriteUint8Array(const std::string &name, const uint8_t *data, index size, ArrayGlobalOffset offset) override

inline virtual void WriteIndexVectorPerRank(const std::string &name, const std::vector<index> &v) override

virtual void ReadInt(const std::string &name, int &v) override

virtual void ReadIndex(const std::string &name, index &v) override

virtual void ReadReal(const std::string &name, real &v) override

virtual void ReadString(const std::string &name, std::string &v) override

virtual void ReadIndexVector(const std::string &name, std::vector<index> &v, ArrayGlobalOffset &offset) override

virtual void ReadUint8Array(const std::string &name, uint8_t *data, index &size, ArrayGlobalOffset &offset) override

class SerializerJSON : public DNDS::Serializer::SerializerBase

Public Functions

virtual void OpenFile(const std::string &fName, bool read) override

virtual void CloseFile() override

virtual void CreatePath(const std::string &p) override

virtual void GoToPath(const std::string &p) override

inline virtual bool IsPerRank() override

virtual std::string GetCurrentPath() override

virtual std::set<std::string> ListCurrentPath() override

inline virtual int GetMPIRank() override

inline virtual int GetMPISize() override

inline virtual const MPIInfo &getMPI() override

virtual void WriteInt(const std::string &name, int v) override

virtual void WriteIndex(const std::string &name, index v) override

virtual void WriteReal(const std::string &name, real v) override

virtual void WriteString(const std::string &name, const std::string &v) override

virtual void WriteIndexVector(const std::string &name, const std::vector<index> &v, ArrayGlobalOffset offset) override

virtual void WriteRowsizeVector(const std::string &name, const std::vector<rowsize> &v, ArrayGlobalOffset offset) override

virtual void WriteRealVector(const std::string &name, const std::vector<real> &v, ArrayGlobalOffset offset) override

virtual void WriteSharedIndexVector(const std::string &name, const ssp<host_device_vector<index>> &v, ArrayGlobalOffset offset) override

virtual void WriteSharedRowsizeVector(const std::string &name, const ssp<host_device_vector<rowsize>> &v, ArrayGlobalOffset offset) override

virtual void WriteUint8Array(const std::string &name, const uint8_t *data, index size, ArrayGlobalOffset offset) override

inline virtual void WriteIndexVectorPerRank(const std::string &name, const std::vector<index> &v) override

virtual void ReadInt(const std::string &name, int &v) override

virtual void ReadIndex(const std::string &name, index &v) override

virtual void ReadReal(const std::string &name, real &v) override

virtual void ReadString(const std::string &name, std::string &v) override

virtual void ReadIndexVector(const std::string &name, std::vector<index> &v, ArrayGlobalOffset &offset) override

virtual void ReadUint8Array(const std::string &name, uint8_t *data, index &size, ArrayGlobalOffset &offset) override

struct TraverseData

namespace TermColor

Variables

constexpr std::string_view Red = "\033[91m"

constexpr std::string_view Green = "\033[92m"

constexpr std::string_view Yellow = "\033[93m"

constexpr std::string_view Blue = "\033[94m"

constexpr std::string_view Magenta = "\033[95m"

constexpr std::string_view Cyan = "\033[96m"

constexpr std::string_view White = "\033[97m"

constexpr std::string_view Reset = "\033[0m"

constexpr std::string_view Bold = "\033[1m"

constexpr std::string_view Underline = "\033[4m"

constexpr std::string_view Blink = "\033[5m"

constexpr std::string_view Reverse = "\033[7m"

constexpr std::string_view Hidden = "\033[8m"