tk namespace

Namespaces

namespace grm

Toolkit general purpose grammar definition.

namespace zoltan

Interoperation with the Zoltan library, used for static mesh partitioning.

Classes

class ChareStateCollector

template<uint8_t Layout>

class Data

Zero-runtime-cost data-layout wrappers with type-based compile-time dispatch.

class Exception

Basic exception class for producing file:func:line info + call trace.

template<typename, typename = std::void_t<>>

struct HasTypedef_alias

Detect if a type defines type 'alias'.

template<typename, typename = std::void_t<>>

struct HasTypedef_i_am_tagged_tuple

Detect if a type defines type 'i_am_tagged_tuple'.

template<typename, typename = std::void_t<>>

struct HasFunction_expect_description

Detect if a type defines function 'expect::description()'.

template<typename, typename = std::void_t<>>

struct HasVar_expect_lower

Detect if a type defines variable 'expect::lower'.

template<typename, typename = std::void_t<>>

struct HasVar_expect_upper

Detect if a type defines variable 'expect::upper'.

template<typename, typename = std::void_t<>>

struct HasFunction_expect_choices

Detect if a type defines function 'expect::choices()'.

template<bool Condition, typename Then, typename Else = void>

struct if_

Type selection: if_< Condition, Then, Else >::type.

class Print

template<std::size_t N>

class Progress

class Reader

template<class List>

class TaggedTuple

Tagged tuple, allowing tag-based access.

template<class List, class Ignore = brigand::set<>>

struct DeepTuplePrinter

template<class List, class Ignore = brigand::set<>>

struct TuplePrinter

class Timer

struct info_t

Struct for storing info.

struct entry_t

Struct for storing keyword in the input deck.

class Writer

template<typename... T>

class cmd_keywords

class StringParser

StringParser.

template<typename Enum>

class Toggle

Toggle is the base for an Option, doing generic searches.

class ASCMeshReader

ASCMeshReader : tk::Reader.

class DiagWriter

DiagWriter : tk::Writer.

class ExodusIIMeshReader

class ExodusIIMeshWriter

class GmshMeshReader

class GmshMeshWriter

class HyperMeshReader

HyperMeshReader : tk::Reader.

class MeshReader

class MeshWriter

Charm++ group used to output particle data to file in parallel.

class NetgenMeshReader

NetgenMeshReader : tk::Reader.

class NetgenMeshWriter

class Omega_h_MeshReader

class PDFWriter

PDFWriter : Writer.

class RDGFLOMeshReader

RDGFLOMeshReader : tk::Reader.

class SiloWriter

SiloWriter.

class STLTxtMeshReader

STLTxtMeshReader : tk::Reader.

class TxtStatWriter

TxtStatWriter : tk::Writer.

class UGRIDMeshReader

UGRIDMeshReader : tk::Reader.

class ConjugateGradients

ConjugateGradients Charm++ chare array used to perform a distributed linear solve with the conjugate gradients algorithm.

class CSR

Compressed sparse row (CSR) storage for a sparse matrix.

class LinearMap

class UnsMeshMap

Charm++ array map for initial placement of array elements using an unstructured grid.

class LBSwitch

class Around

Helper class simplifying client code for iterating on entries surrounding entries via linked lists derived from unstructured mesh connectivity.

class STLMesh

STLMesh.

class UnsMesh

3D unstructured mesh class

class BiPDF

Joint bivariate PDF estimator.

class Statistics

Statistics estimator.

class TriPDF

Joint trivariate PDF estimator.

class UniPDF

Univariate PDF estimator.

class QuietCerr

Enums

enum ErrCode { SUCCESS = EXIT_SUCCESS, FAILURE = EXIT_FAILURE }

Error codes for the OS (or whatever calls us)

enum Style { QUIET =0, VERBOSE =1 }

Output verbosity. C-style enum as this is used for template argument.

enum class ExoElemType: int { TET = 0, TRI = 1 }

enum class ExoWriter { CREATE, OPEN }

ExodusII writer constructor modes.

enum GmshElemType { LIN = 1, TRI = 2, TRI = 1, TET = 4, TET = 0, PNT = 15 }

Identifiers of supported Gmsh elements.

enum class GmshFileType { UNDEFINED = -1, ASCII = 0, BINARY = 1 }

Supported Gmsh mesh file types.

enum class MeshReaderType: uint8_t { GMSH = 0, NETGEN, EXODUSII, HYPER, ASC, OMEGA_H, UGRID, RDGFLO }

Supported mesh readers.

enum class MeshWriterType: uint8_t { GMSH = 0, NETGEN, EXODUSII }

Supported mesh writers.

enum class HeaderType: uint8_t { INCITER =0, UNITTEST, MESHCONV }

Executable types for which an ascii logo is available in tk::Print.

enum class Centering: char { NODE = 'n', ELEM = 'e' }

Typedefs

template<class li, class lo>

using cartesian_product = brigand::reverse_fold<brigand::list<li, lo>, brigand::list<brigand::list<>>, brigand::bind<brigand::join, brigand::bind<brigand::transform, brigand::_2, brigand::defer<brigand::bind<brigand::join, brigand::bind<brigand::transform, brigand::parent<brigand::_1>, brigand::defer<brigand::bind<brigand::list, brigand::bind<brigand::push_front, brigand::_1, brigand::parent<brigand::_1>>>>>>>>>>

using ChareState = TaggedTuple<brigand::list<tag::ch, std::string, tag::id, int, tag::pe, int, tag::it, uint64_t, tag::fn, std::string, tag::time, tk::real>>

Chare state.

template<std::size_t N>

using Table = std::vector<std::array<real, N+1>>

using real = double

Real number type used throughout the whole code.

using ncomp_t = std::size_t

uint type used throughout the whole code.

using SiloErrorHandler = void(*)(char*)

Silo error handler function type.

using NodeSet = std::unordered_set<std::size_t>

Node list type used for node communication map.

using EdgeSet = UnsMesh::EdgeSet

Edge list type used for edge communication map.

using NodeCommMap = std::unordered_map<int, NodeSet>

using EdgeCommMap = std::unordered_map<int, EdgeSet>

using AllCommMaps = TaggedTuple<brigand::list<tag::node, NodeSet, tag::edge, EdgeSet>>

Type list of all communication maps bundled as a tagged tuple.

using CommMaps = std::map<int, AllCommMaps>

using InitializeFn = std::function<std::vector<real>(ncomp_t, const std::vector<inciter::EOS>&, real, real, real, real)>

using RiemannFluxFn = std::function<std::vector<real>(const std::vector<inciter::EOS>&, const std::array<real, 3>&, const std::array<std::vector<real>, 2>&, const std::vector<std::array<real, 3>>&)>

using FluxFn = std::function<std::vector<std::array<real, 3>>(ncomp_t, const std::vector<inciter::EOS>&, const std::vector<real>&, const std::vector<std::array<real, 3>>&)>

using VelFn = std::function<std::vector<std::array<tk::real, 3>>(ncomp_t, real, real, real, real)>

using StateFn = std::function<std::array<std::vector<real>, 2>(ncomp_t, const std::vector<inciter::EOS>&, const std::vector<real>&, real, real, real, real, const std::array<tk::real, 3>&)>

using SrcFn = std::function<void(ncomp_t, const std::vector<inciter::EOS>&, tk::real, tk::real, tk::real, tk::real, std::vector<tk::real>&)>

using ElemGradFn = std::function<std::tuple<std::array<std::size_t, 4>, std::array<std::array<tk::real, 3>, 4>, std::vector<std::array<tk::real, 4>>, tk::real>(ncomp_t, ncomp_t, std::size_t, const std::array<std::vector<tk::real>, 3>&, const std::vector<std::size_t>&, const std::tuple<std::vector<tk::real>, std::vector<tk::real>>&, const tk::Fields&)>

Function prototype for computing the element gradient contribution to a nodal gradient in ALECG.

using GetVarFn = std::function<std::vector<real>(const tk::Fields&, std::size_t)>

Prototype for functions to compute a variable from the numerical solution.

using MultiMatIdxFn = std::function<std::size_t(std::size_t, std::size_t)>

Prototype for functions to a compute multi-material index.

Functions

template<class Container>

void unique(Container& c)

template<class Container>

auto uniquecopy(const Container& src) -> Container

template<typename Container>

auto cref_find(const Container& map, const typename Container::key_type& key) -> const typename Container::mapped_type & -> auto

Find and return a constant reference to value for key in container that provides a find() member function with error handling.

template<typename Container>

auto ref_find(const Container& map, const typename Container::key_type& key) -> typename Container::mapped_type & -> auto

Find and return a reference to value for key in a container that provides a find() member function with error handling.

template<typename T>

auto extents(const std::vector<T>& vec) -> std::array<T, 2>

Return minimum and maximum values of a vector.

template<typename Container>

auto extents(const Container& map) -> std::array< typename Container::mapped_type, 2 > -> auto

Find and return minimum and maximum values in associative container.

template<class T, std::size_t N>

auto operator+=(std::array<T, N>& dst, const std::array<T, N>& src) -> std::array<T, N>&

template<class T, class Allocator>

auto operator+=(std::vector<T, Allocator>& dst, const std::vector<T, Allocator>& src) -> std::vector<T, Allocator>&

template<class T, class Allocator>

auto operator/=(std::vector<T, Allocator>& dst, const std::vector<T, Allocator>& src) -> std::vector<T, Allocator>&

template<class C1, class C2>

auto keyEqual(const C1& a, const C2& b) -> bool

template<class Container>

auto sumsize(const Container& c) -> std::size_t

template<class Container>

auto numunique(const Container& c) -> std::size_t

template<class Map>

auto sumvalsize(const Map& c) -> std::size_t

template<class Container>

void destroy(Container& c)

template<typename Container, typename Predicate>

void erase_if(Container& items, const Predicate& predicate)

template<class T>

void concat(std::vector<T>&& src, std::vector<T>& dst)

template<class T>

void concat(std::vector<std::pair<bool, T>>&& src, std::vector<std::pair<bool, T>>& dst)

template<class Key, class Hash = std::hash<Key>, class Eq = std::equal_to<Key>>

void concat(std::unordered_set<Key, Hash, Eq>&& src, std::unordered_set<Key, Hash, Eq>& dst)

template<class Key, class Value>

auto operator<<(std::ostream& os, const std::pair<const Key, Value>& v) -> std::ostream&

template<typename T>

auto parameter(const T& v) -> std::string

Convert and return value as string.

template<typename V>

auto parameters(const V& v) -> std::string

Convert and return values from container as string.

template<uint8_t Layout>

auto operator*(tk::real lhs, const Data<Layout>& rhs) -> Data<Layout>

template<uint8_t Layout>

auto min(const Data<Layout>& a, const Data<Layout>& b) -> Data<Layout>

template<uint8_t Layout>

auto max(const Data<Layout>& a, const Data<Layout>& b) -> Data<Layout>

template<uint8_t Layout>

auto operator==(const Data<Layout>& lhs, const Data<Layout>& rhs) -> bool

template<uint8_t Layout>

auto operator!=(const Data<Layout>& lhs, const Data<Layout>& rhs) -> bool

template<uint8_t Layout>

auto maxdiff(const Data<Layout>& lhs, const Data<Layout>& rhs) -> std::pair<std::size_t, tk::real>

template<class C, class Key, class Factory, typename... ConstructorArgs>

void record(Factory& f, const Key& key, ConstructorArgs&&... args)

template<class Factory, class Key, class Obj = typename std::remove_pointer< typename Factory::mapped_type::result_type>::type>

auto instantiate(const Factory& f, const Key& key) -> std::unique_ptr<Obj>

template<class Host, class ModelConstructor, class Factory, class Key, typename... ModelConstrArgs>

void recordModel(Factory& f, const Key& key, ModelConstrArgs&&... args)

template<class Host, class ModelConstructor, class Factory, class Key>

void recordModelLate(Factory& f, const Key& key)

template<class Host, class ModelConstructor, class Factory, class Key, typename... ModelConstrArgs>

void recordCharmModel(Factory& f, const Key& key, ModelConstrArgs&&... args)

template<typename A, typename B>

auto flip_pair(const std::pair<A, B>& p) -> std::pair<B, A>

template<typename A, typename B>

auto flip_map(const std::map<A, B>& src) -> std::multimap<B, A>

template<class Key, class T, class Hash = std::hash<Key>, class Eq = std::equal_to<Key>>

auto serialize(const std::unordered_map<Key, T, Hash, Eq>& m) -> std::pair<int, std::unique_ptr<char[]>>

template<class Key, class T, class Hash = std::hash<Key>, class Eq = std::equal_to<Key>>

auto mergeHashMap(int nmsg, CkReductionMsg** msgs) -> CkReductionMsg*

Charm++ custom reducer for merging std::unordered_maps during reduction across PEs.

auto linearLoadDistributor(real virtualization, uint64_t load, int npe, uint64_t& chunksize, uint64_t& remainder) -> uint64_t

Compute linear load distribution for given total work and virtualization.

template<typename Enum, typename Ch, typename Tr, typename std::enable_if_t<std::is_enum_v<Enum>, int> = 0>

auto operator<<(std::basic_ostream<Ch, Tr>& os, const Enum& e) -> std::basic_ostream<Ch, Tr>&

template<class T, typename Ch, typename Tr>

auto operator<<(std::basic_ostream<Ch, Tr>& os, const std::vector<T>& v) -> std::basic_ostream<Ch, Tr>&

template<typename Ch, typename Tr, class Key, class Value, class Compare = std::less<Key>>

auto operator<<(std::basic_ostream<Ch, Tr>& os, const std::map<Key, Value, Compare>& m) -> std::basic_ostream<Ch, Tr>&

template<typename T, typename Ch, typename Tr>

auto operator<<(std::basic_string<Ch, Tr>& lhs, const T& e) -> std::basic_string<Ch, Tr>

template<typename T, typename Ch, typename Tr>

auto operator<<(std::basic_string<Ch, Tr>&& lhs, const T& e) -> std::basic_string<Ch, Tr>

auto splitLines(std::string str, std::string indent, const std::string& name = "", std::size_t width = 80) -> std::string

Clean up whitespaces and format a long string into multiple lines.

auto baselogname(const std::string& executable) -> std::string

auto logname(const std::string& executable, int numrestart = 0) -> std::string

Construct log file name.

void signalHandler(int signum)

Signal handler for multiple signals, SIGABRT, SIGSEGV, etc.

auto setSignalHandlers() -> int

Set signal handlers for multiple signals, SIGABRT, SIGSEGV, etc.

void processExceptionCharm()

Process an exception from the Charm++ runtime system.

template<typename T>

auto swap_endian(T u) -> T

template<>

auto swap_endian(double u) -> double

template<std::size_t N>

auto sample(real x, const Table<N>& table) -> std::array<real, N>

template<class Tuple>

void print(std::ostream& os, const std::string& name, const Tuple& c)

template<class List>

auto operator<<(std::ostream& os, const tk::TaggedTuple<List>& t) -> std::ostream&

template<class List, class Ignore = brigand::set<>>

void print(std::ostream& os, const tk::TaggedTuple<List>& t)

Simple (unformatted, one-line) output of a TaggedTuple to output stream with ignore.

auto hms(tk::real stamp) -> Timer::Watch

Convert existing time stamp as a real to Watch (global scope)

void flip(std::array<real, 3>& v)

void cross(real v1x, real v1y, real v1z, real v2x, real v2y, real v2z, real& rx, real& ry, real& rz)

auto cross(const std::array<real, 3>& v1, const std::array<real, 3>& v2) -> std::array<real, 3>

void crossdiv(real v1x, real v1y, real v1z, real v2x, real v2y, real v2z, real j, real& rx, real& ry, real& rz)

auto crossdiv(const std::array<real, 3>& v1, const std::array<real, 3>& v2, real j) -> std::array<real, 3>

auto dot(const std::array<real, 3>& v1, const std::array<real, 3>& v2) -> real

auto matvec(const std::array<std::array<real, 3>, 3>& m, const std::array<real, 3>& v) -> std::array<real, 3>

auto length(real x, real y, real z) -> real

auto length(const std::array<real, 3>& v) -> real

void unit(std::array<real, 3>& v)

auto triple(real v1x, real v1y, real v1z, real v2x, real v2y, real v2z, real v3x, real v3y, real v3z) -> tk::real

auto triple(const std::array<real, 3>& v1, const std::array<real, 3>& v2, const std::array<real, 3>& v3) -> real

auto rotateX(const std::array<real, 3>& v, real angle) -> std::array<real, 3>

auto rotateY(const std::array<real, 3>& v, real angle) -> std::array<real, 3>

auto rotateZ(const std::array<real, 3>& v, real angle) -> std::array<real, 3>

auto Jacobian(const std::array<real, 3>& v1, const std::array<real, 3>& v2, const std::array<real, 3>& v3, const std::array<real, 3>& v4) -> real

Compute the determinant of the Jacobian of a coordinate transformation over a tetrahedron.

auto inverseJacobian(const std::array<real, 3>& v1, const std::array<real, 3>& v2, const std::array<real, 3>& v3, const std::array<real, 3>& v4) -> std::array<std::array<real, 3>, 3>

Compute the inverse of the Jacobian of a coordinate transformation over a tetrahedron.

auto determinant(const std::array<std::array<tk::real, 3>, 3>& a) -> tk::real

auto inverse(const std::array<std::array<tk::real, 3>, 3>& m) -> std::array<std::array<tk::real, 3>, 3>

auto cramer(const std::array<std::array<tk::real, 3>, 3>& a, const std::array<tk::real, 3>& b) -> std::array<tk::real, 3>

void movePoint(const std::array<tk::real, 3>& origin, std::array<tk::real, 3>& point)

void rotatePoint(const std::array<tk::real, 3>& angles, std::array<tk::real, 3>& point)

auto getRightCauchyGreen(const std::array<std::array<real, 3>, 3>& g) -> std::array<std::array<real, 3>, 3>

Get the Right Cauchy-Green strain tensor from the inverse deformation gradient tensor.

auto getLeftCauchyGreen(const std::array<std::array<real, 3>, 3>& g) -> std::array<std::array<real, 3>, 3>

Get the Left Cauchy-Green strain tensor from the inverse deformation gradient tensor.

auto getDevHencky(const std::array<std::array<real, 3>, 3>& g) -> std::array<std::array<real, 3>, 3>

Get the deviatoric Hencky strain tensor from the inverse deformation gradient tensor.

auto transpose3by3(std::array<std::array<tk::real, 3>, 3> mat) -> std::array<std::array<tk::real, 3>, 3>

Get transpose of a 3 by 3 matrix.

auto getRotationMatrix(const std::array<tk::real, 3>& r) -> std::array<std::array<tk::real, 3>, 3>

Get rotation matrix in 2D array form given a normal direction. The remaining directions are given by section 5.3.1 of Miller, G. H., and P. Colella. "A conservative three-dimensional Eulerian method for coupled solid–fluid shock capturing." Journal of Computational Physics 183.1 (2002): 26-82.

auto rotateTensor(const std::array<std::array<tk::real, 3>, 3>& mat, const std::array<tk::real, 3>& r) -> std::array<std::array<tk::real, 3>, 3>

Rotate a second order tensor (e.g. a Strain/Stress matrix) from the (x,y,z) to a new (r,s,t) coordinate system. The directions are given by section 5.3.1 of Miller, G. H., and P. Colella. "A conservative three-dimensional Eulerian method for coupled solid–fluid shock capturing." Journal of Computational Physics 183.1 (2002): 26-82.

auto unrotateTensor(const std::array<std::array<tk::real, 3>, 3>& mat, const std::array<tk::real, 3>& r) -> std::array<std::array<tk::real, 3>, 3>

Rotate a second order tensor (e.g. a Strain/Stress matrix) from the (x,y,z) to a new (r,s,t) coordinate system. The directions are given by section 5.3.1 of Miller, G. H., and P. Colella. "A conservative three-dimensional Eulerian method for coupled solid–fluid shock capturing." Journal of Computational Physics 183.1 (2002): 26-82.

auto rotateVector(const std::array<tk::real, 3>& v, const std::array<tk::real, 3>& r) -> std::array<tk::real, 3>

Rotate a vector (e.g. a velocity) from the (x,y,z) to a new (r,s,t) coordinate system. The directions are given by section 5.3.1 of Miller, G. H., and P. Colella. "A conservative three-dimensional Eulerian method for coupled solid–fluid shock capturing." Journal of Computational Physics 183.1 (2002): 26-82.

auto unrotateVector(const std::array<tk::real, 3>& v, const std::array<tk::real, 3>& r) -> std::array<tk::real, 3>

Unrotate a vector (e.g. a velocity) from the (x,y,z) to a new (r,s,t) coordinate system. The directions are given by section 5.3.1 of Miller, G. H., and P. Colella. "A conservative three-dimensional Eulerian method for coupled solid–fluid shock capturing." Journal of Computational Physics 183.1 (2002): 26-82.

auto reflectTensor(const std::array<std::array<tk::real, 3>, 3>& mat, const std::array<std::array<tk::real, 3>, 3>& reflectMat) -> std::array<std::array<tk::real, 3>, 3>

Reflect a second order tensor (e.g. a Strain/Stress matrix)

auto detectInput(const std::string& filename) -> MeshReaderType

Detect input mesh file type.

auto pickOutput(const std::string& filename) -> MeshWriterType

Determine output mesh file type.

auto readUnsMesh(const tk::Print& print, const std::string& filename, std::pair<std::string, tk::real>& timestamp) -> UnsMesh

Read unstructured mesh from file.

auto writeUnsMesh(const tk::Print& print, const std::string& filename, UnsMesh& mesh, bool reorder) -> std::vector<std::pair<std::string, tk::real>>

Write unstructured mesh to file.

void SiloError(char* msg)

Silo error handler.

static auto workdir() -> std::string

auto curtime() -> std::string

Wrapper for the standard C library's gettimeofday() from.

void echoHeader(const Print& print, HeaderType header)

Echo program header.

void echoBuildEnv(const Print& print, const std::string& executable)

Echo build environment.

void echoRunEnv(const Print& print, int argc, char** argv, bool verbose, bool quiescence, bool charestate, bool trace, const std::string& screen_log, const std::string& input_log)

Echo runtime environment.

template<class Driver, class CmdLine>

auto Main(int argc, char* argv[], const CmdLine& cmdline, HeaderType header, const std::string& executable, const std::string& def, int nrestart) -> Driver

Generic Main() used for all executables for code-reuse and a uniform output.

template<class MainProxy, class CmdLine>

void MainCtor(MainProxy& mp, const MainProxy& thisProxy, std::vector<tk::Timer>& timer, const CmdLine& cmdline, const CkCallback& quiescenceTarget)

template<class CmdLine>

void dumpstate(const CmdLine& cmdline, const std::string& def, int nrestart, CkReductionMsg* msg)

template<class CmdLine>

void finalize(const CmdLine& cmdline, const std::vector<tk::Timer>& timer, tk::CProxy_ChareStateCollector& state, std::vector<std::pair<std::string, tk::Timer::Watch>>& timestamp, const std::string& def, int nrestart, const CkCallback& dumpstateTarget, bool clean = true)

auto slave(const NodeCommMap& map, std::size_t node, int chare) -> bool

Decide if a node is not counted by a chare.

auto count(const NodeCommMap& map, std::size_t node) -> tk::real

Count the number of contributions to a node.

auto orient(const UnsMesh::Edge& t, const UnsMesh::Edge& e) -> int

Determine edge orientation.

auto npoin_in_graph(const std::vector<std::size_t>& inpoel) -> std::size_t

Compute number of points (nodes) in mesh from connectivity.

auto genEsup(const std::vector<std::size_t>& inpoel, std::size_t nnpe) -> std::pair<std::vector<std::size_t>, std::vector<std::size_t>>

Generate derived data structure, elements surrounding points.

auto genPsup(const std::vector<std::size_t>& inpoel, std::size_t nnpe, const std::pair<std::vector<std::size_t>, std::vector<std::size_t>>& esup) -> std::pair<std::vector<std::size_t>, std::vector<std::size_t>>

Generate derived data structure, points surrounding points.

auto genEdsup(const std::vector<std::size_t>& inpoel, std::size_t nnpe, const std::pair<std::vector<std::size_t>, std::vector<std::size_t>>& esup) -> std::pair<std::vector<std::size_t>, std::vector<std::size_t>>

Generate derived data structure, edges surrounding points.

auto genInpoed(const std::vector<std::size_t>& inpoel, std::size_t nnpe, const std::pair<std::vector<std::size_t>, std::vector<std::size_t>>& esup) -> std::vector<std::size_t>

Generate derived data structure, edge connectivity.

auto genEsupel(const std::vector<std::size_t>& inpoel, std::size_t nnpe, const std::pair<std::vector<std::size_t>, std::vector<std::size_t>>& esup) -> std::pair<std::vector<std::size_t>, std::vector<std::size_t>>

Generate derived data structure, elements surrounding points of elements.

auto genEsuel(const std::vector<std::size_t>& inpoel, std::size_t nnpe, const std::pair<std::vector<std::size_t>, std::vector<std::size_t>>& esup) -> std::pair<std::vector<std::size_t>, std::vector<std::size_t>>

Generate derived data structure, elements surrounding elements.

auto genInedel(const std::vector<std::size_t>& inpoel, std::size_t nnpe, const std::vector<std::size_t>& inpoed) -> std::vector<std::size_t>

Generate derived data structure, edges of elements.

auto genEsued(const std::vector<std::size_t>& inpoel, std::size_t nnpe, const std::pair<std::vector<std::size_t>, std::vector<std::size_t>>& esup) -> std::unordered_map<UnsMesh::Edge, std::vector<std::size_t>, UnsMesh::Hash<2>, UnsMesh::Eq<2>>

Generate derived data structure, elements surrounding edges.

auto genNbfacTet(std::size_t tnbfac, const std::vector<std::size_t>& inpoel, const std::vector<std::size_t>& triinpoel_complete, const std::map<int, std::vector<std::size_t>>& bface_complete, const std::unordered_map<std::size_t, std::size_t>& lid, std::vector<std::size_t>& triinpoel, std::map<int, std::vector<std::size_t>>& bface) -> std::size_t

Generate total number of boundary faces in this chunk.

auto genEsuelTet(const std::vector<std::size_t>& inpoel, const std::pair<std::vector<std::size_t>, std::vector<std::size_t>>& esup) -> std::vector<int>

Generate derived data structure, elements surrounding elements as a fixed length data structure as a full vector, including boundary elements as -1.

auto genNipfac(std::size_t nfpe, std::size_t nbfac, const std::vector<int>& esuelTet) -> std::size_t

Generate number of internal and physical-boundary faces.

auto genEsuf(std::size_t nfpe, std::size_t nipfac, std::size_t nbfac, const std::vector<std::size_t>& belem, const std::vector<int>& esuelTet) -> std::vector<int>

Generate derived data structure, elements surrounding faces.

auto genInpofaTet(std::size_t nipfac, std::size_t nbfac, const std::vector<std::size_t>& inpoel, const std::vector<std::size_t>& triinpoel, const std::vector<int>& esuelTet) -> std::vector<std::size_t>

Generate derived data structure, node-face connectivity.

auto genBelemTet(std::size_t nbfac, const std::vector<std::size_t>& inpofa, const std::pair<std::vector<std::size_t>, std::vector<std::size_t>>& esup) -> std::vector<std::size_t>

Generate derived data structure, host/boundary element.

auto genGeoFaceTri(std::size_t nipfac, const std::vector<std::size_t>& inpofa, const UnsMesh::Coords& coord) -> Fields

Generate derived data structure, face geometry.

auto normal(const std::array<real, 3>& x, const std::array<real, 3>& y, const std::array<real, 3>& z) -> std::array<real, 3>

Compute the unit normal vector of a triangle.

auto area(const std::array<real, 3>& x, const std::array<real, 3>& y, const std::array<real, 3>& z) -> real

Compute the area of a triangle.

auto geoFaceTri(const std::array<real, 3>& x, const std::array<real, 3>& y, const std::array<real, 3>& z) -> Fields

Compute geometry of the face given by three vertices.

auto genGeoElemTet(const std::vector<std::size_t>& inpoel, const UnsMesh::Coords& coord) -> Fields

Generate derived data structure, element geometry.

auto leakyPartition(const std::vector<int>& esueltet, const std::vector<std::size_t>& inpoel, const UnsMesh::Coords& coord) -> bool

Perform leak-test on mesh (partition)

auto conforming(const std::vector<std::size_t>& inpoel, const UnsMesh::Coords& coord, bool cerr, const std::vector<std::size_t>& rid) -> bool

Check if mesh (partition) is conforming.

auto intet(const std::array<std::vector<real>, 3>& coord, const std::vector<std::size_t>& inpoel, const std::vector<real>& p, std::size_t e, std::array<real, 4>& N) -> bool

Determine if a point is in a tetrahedron.

auto curl(const std::array<std::vector<tk::real>, 3>& coord, const std::vector<std::size_t>& inpoel, const tk::UnsMesh::Coords& v) -> tk::UnsMesh::Coords

Compute curl of a vector field at nodes of unstructured tetrahedra mesh.

auto div(const std::array<std::vector<tk::real>, 3>& coord, const std::vector<std::size_t>& inpoel, const tk::UnsMesh::Coords& v) -> std::vector<tk::real>

Compute divergence of vector field at nodes of unstructured tetrahedra mesh.

auto grad(const std::array<std::vector<tk::real>, 3>& coord, const std::vector<std::size_t>& inpoel, const std::vector<tk::real>& phi) -> tk::UnsMesh::Coords

Compute gradient of a scalar field at nodes of unstructured tetrahedra mesh.

void normal(real x1, real x2, real x3, real y1, real y2, real y3, real z1, real z2, real z3, real& nx, real& ny, real& nz)

auto area(real x1, real x2, real x3, real y1, real y2, real y3, real z1, real z2, real z3) -> real

auto nodegrad(std::size_t node, const std::array<std::vector<tk::real>, 3>& coord, const std::vector<std::size_t>& inpoel, const std::pair<std::vector<std::size_t>, std::vector<std::size_t>>& esup, const tk::Fields& U, ncomp_t c) -> std::array<tk::real, 3>

Compute gradient at a mesh node.

auto edgegrad(const std::array<std::vector<tk::real>, 3>& coord, const std::vector<std::size_t>& inpoel, const std::vector<std::size_t>& esued, const tk::Fields& U, ncomp_t c) -> std::array<tk::real, 3>

Compute gradient at a mesh edge.

auto shiftToZero(std::vector<std::size_t>& inpoel) -> std::size_t

Shift node IDs to start with zero in element connectivity.

void remap(std::vector<std::size_t>& ids, const std::vector<std::size_t>& map)

Apply new mapping to vector of indices.

void remap(std::vector<tk::real>& r, const std::vector<std::size_t>& map)

Apply new mapping to vector of real numbers.

auto remap(const std::vector<std::size_t>& ids, const std::vector<std::size_t>& map) -> std::vector<std::size_t>

Create remapped vector of indices using a vector.

void remap(std::vector<std::size_t>& ids, const std::unordered_map<std::size_t, std::size_t>& map)

In-place remap vector of indices using a map.

auto remap(const std::vector<std::size_t>& ids, const std::unordered_map<std::size_t, std::size_t>& map) -> std::vector<std::size_t>

Create remapped vector of indices using a map.

auto remap(const std::map<int, std::vector<std::size_t>>& ids, const std::unordered_map<std::size_t, std::size_t>& map) -> std::map<int, std::vector<std::size_t>>

Create remapped map of vector of indices using a map.

auto renumber(const std::pair<std::vector<std::size_t>, std::vector<std::size_t>>& psup) -> std::vector<std::size_t>

Reorder mesh points with the advancing front technique.

auto assignLid(const std::vector<std::size_t>& gid) -> std::unordered_map<std::size_t, std::size_t>

Assign local ids to global ids.

auto global2local(const std::vector<std::size_t>& ginpoel) -> std::tuple<std::vector<std::size_t>, std::vector<std::size_t>, std::unordered_map<std::size_t, std::size_t>>

Generate element connectivity of local node IDs from connectivity of global node IDs also returning the mapping between local to global IDs.

auto positiveJacobians(const std::vector<std::size_t>& inpoel, const std::array<std::vector<real>, 3>& coord) -> bool

Test positivity of the Jacobian for all cells in a mesh.

auto bfacenodes(const std::map<int, std::vector<std::size_t>>& bface, const std::vector<std::size_t>& triinpoel) -> std::map<int, std::vector<std::size_t>>

Generate nodes of side set faces.

auto eval_gp(const std::size_t igp, const std::array<std::array<tk::real, 3>, 3>& coordfa, const std::array<std::vector<tk::real>, 2>& coordgp) -> std::array<tk::real, 3>

Compute the coordinates of quadrature points for face integral.

auto eval_gp(const std::size_t igp, const std::array<std::array<tk::real, 3>, 4>& coord, const std::array<std::vector<tk::real>, 3>& coordgp) -> std::array<tk::real, 3>

Compute the coordinates of quadrature points for volume integral.

auto eval_dBdxi(const std::size_t ndof, const std::array<tk::real, 3>& coordgp) -> std::array<std::vector<tk::real>, 3>

Compute the derivatives of Dubiner basis wrt. reference coordinates.

auto eval_dBdx_p1(const std::size_t ndof, const std::array<std::array<tk::real, 3>, 3>& jacInv) -> std::array<std::vector<tk::real>, 3>

Compute the derivatives of basis function for DG(P1)

void eval_dBdx_p2(const std::size_t igp, const std::array<std::vector<tk::real>, 3>& coordgp, const std::array<std::array<tk::real, 3>, 3>& jacInv, std::array<std::vector<tk::real>, 3>& dBdx)

Compute the derivatives of basis function for DG(P2)

auto eval_basis(const std::size_t ndof, const tk::real xi, const tk::real eta, const tk::real zeta) -> std::vector<tk::real>

Compute the Dubiner basis functions.

auto eval_state(ncomp_t ncomp, const std::size_t ndof, const std::size_t ndof_el, const std::size_t e, const Fields& U, const std::vector<tk::real>& B) -> std::vector<tk::real>

Compute the state variables for the tetrahedron element.

auto DubinerToTaylor(ncomp_t ncomp, const std::size_t e, const std::size_t ndof, const tk::Fields& U, const std::vector<std::size_t>& inpoel, const tk::UnsMesh::Coords& coord) -> std::vector<std::vector<tk::real>>

Transform the solution with Dubiner basis to the solution with Taylor basis.

void TaylorToDubiner(ncomp_t ncomp, std::size_t e, std::size_t ndof, const std::vector<std::size_t>& inpoel, const tk::UnsMesh::Coords& coord, const tk::Fields& geoElem, std::vector<std::vector<tk::real>>& unk)

Convert the solution with Taylor basis to the solution with Dubiner basis.

auto eval_TaylorBasis(const std::size_t ndof, const std::array<tk::real, 3>& x, const std::array<tk::real, 3>& x_c, const std::array<std::array<tk::real, 3>, 4>& coordel) -> std::vector<tk::real>

Evaluate the Taylor basis at points.

auto DubinerToTaylorRefEl(ncomp_t ncomp, const std::size_t e, const std::size_t ndof, const std::size_t ndof_el, const std::vector<std::vector<tk::real>>& mtInv, const tk::Fields& U) -> std::vector<std::vector<tk::real>>

Transform the solution from Dubiner basis to Taylor basis.

void TaylorToDubinerRefEl(ncomp_t ncomp, const std::size_t ndof, std::vector<std::vector<tk::real>>& unk)

Transform the solution from Taylor to Dubiner basis.

auto eval_TaylorBasisRefEl(std::size_t ndof, tk::real x, tk::real y, tk::real z) -> std::vector<tk::real>

Evaluate the Taylor basis at a point in the reference element.

auto invMassMatTaylorRefEl(std::size_t dof) -> std::vector<std::vector<tk::real>>

Obtain inverse mass matrix for Taylor basis in reference element.

auto massMatrixTaylorRefEl(std::size_t dof) -> std::vector<std::vector<tk::real>>

Obtain mass matrix for Taylor basis in reference element.

void bndSurfInt(const bool pref, std::size_t nmat, const std::vector<inciter::EOS>& mat_blk, const std::size_t ndof, const std::size_t rdof, const std::vector<std::size_t>& bcconfig, const inciter::FaceData& fd, const Fields& geoFace, const Fields& geoElem, const std::vector<std::size_t>& inpoel, const UnsMesh::Coords& coord, real t, const RiemannFluxFn& flux, const VelFn& vel, const StateFn& state, const Fields& U, const Fields& P, const std::vector<std::size_t>& ndofel, Fields& R, std::vector<std::vector<tk::real>>& riemannDeriv, int intsharp)

Compute boundary surface flux integrals for a given boundary type for DG.

void update_rhs_bc(ncomp_t ncomp, std::size_t nmat, const std::size_t ndof, const std::size_t ndof_l, const tk::real wt, const std::array<tk::real, 3>& fn, const std::size_t el, const std::vector<tk::real>& fl, const std::vector<tk::real>& B_l, Fields& R, std::vector<std::vector<tk::real>>& riemannDeriv)

Update the rhs by adding the boundary surface integration term.

void bndSurfIntFV(std::size_t nmat, const std::vector<inciter::EOS>& mat_blk, const std::size_t rdof, const std::vector<std::size_t>& bcconfig, const inciter::FaceData& fd, const Fields& geoFace, const Fields& geoElem, const std::vector<std::size_t>& inpoel, const UnsMesh::Coords& coord, real t, const RiemannFluxFn& flux, const VelFn& vel, const StateFn& state, const Fields& U, const Fields& P, const std::vector<int>& srcFlag, Fields& R, int intsharp)

Compute boundary surface flux integrals for a given boundary type for FV.

void bndSurfIntViscousFV(std::size_t nmat, const std::vector<inciter::EOS>& mat_blk, const std::size_t rdof, const std::vector<std::size_t>& bcconfig, const inciter::FaceData& fd, const Fields& geoFace, const Fields& geoElem, const std::vector<std::size_t>& inpoel, const UnsMesh::Coords& coord, real t, const StateFn& state, const StateFn& gradFn, const Fields& U, const Fields& P, const Fields& T, const std::vector<int>& srcFlag, Fields& R, int intsharp)

Compute boundary surface flux integrals for a given boundary type for FV.

void initialize(ncomp_t ncomp, const std::vector<inciter::EOS>& mat_blk, const Fields& L, const std::vector<std::size_t>& inpoel, const UnsMesh::Coords& coord, const InitializeFn& solution, Fields& unk, real t, const std::size_t nielem)

void update_rhs(ncomp_t ncomp, const std::size_t ndof, const tk::real wt, const std::vector<tk::real>& B, const std::vector<tk::real>& s, std::vector<tk::real>& R)

Update the rhs by adding the initial analytical solution term.

void eval_init(ncomp_t ncomp, const std::size_t ndof, const std::size_t rdof, const std::size_t e, const std::vector<tk::real>& R, const Fields& L, Fields& unk)

Compute the initial conditions.

template<class eq>

void BoxElems(const tk::Fields& geoElem, std::size_t nielem, std::vector<std::unordered_set<std::size_t>>& inbox)

void mass(ncomp_t ncomp, ncomp_t ndof, const Fields& geoElem, Fields& l)

Compute the block-diagnoal mass matrix for DG.

auto lump(ncomp_t ncomp, const std::array<std::vector<tk::real>, 3>& coord, const std::vector<std::size_t>& inpoel) -> tk::Fields

Compute lumped mass matrix for CG.

auto massMatrixDubiner(std::size_t dof, tk::real vol) -> std::vector<tk::real>

Compute the diagonal mass matrix for DG with Dubiner basis functions.

void nonConservativeInt(const bool pref, std::size_t nmat, const std::vector<inciter::EOS>& mat_blk, const std::size_t ndof, const std::size_t rdof, const std::size_t nelem, const std::vector<std::size_t>& inpoel, const UnsMesh::Coords& coord, const Fields& geoElem, const Fields& U, const Fields& P, const std::vector<std::vector<tk::real>>& riemannDeriv, const std::vector<std::size_t>& ndofel, Fields& R, int intsharp)

Compute volume integrals of non-conservative terms for multi-material DG.

void updateRhsNonCons(ncomp_t ncomp, const std::size_t nmat, const std::size_t ndof, ] const std::size_t ndof_el, const tk::real wt, const std::size_t e, const std::vector<tk::real>& B, ] const std::array<std::vector<tk::real>, 3>& dBdx, const std::vector<std::vector<tk::real>>& ncf, Fields& R)

auto nonConservativeIntFV(std::size_t nmat, const std::size_t rdof, const std::size_t e, const std::array<tk::real, 3>& fn, const Fields& U, const Fields& P, const std::vector<tk::real>& var_riemann) -> std::vector<tk::real>

Compute volume integrals of non-conservative terms for multi-material FV.

void pressureRelaxationInt(const bool pref, std::size_t nmat, const std::vector<inciter::EOS>& mat_blk, const std::size_t ndof, const std::size_t rdof, const std::size_t nelem, const std::vector<std::size_t>& inpoel, const UnsMesh::Coords& coord, const Fields& geoElem, const Fields& U, const Fields& P, const std::vector<std::size_t>& ndofel, const tk::real ct, Fields& R, int intsharp)

Compute volume integrals of pressure relaxation terms in multi-material DG.

void updateRhsPre(ncomp_t ncomp, const std::size_t ndof, ] const std::size_t ndof_el, const tk::real wt, const std::size_t e, const std::vector<tk::real>& B, std::vector<tk::real>& ncf, Fields& R)

void pressureRelaxationIntFV(std::size_t nmat, const std::vector<inciter::EOS>& mat_blk, const std::size_t rdof, const std::size_t nelem, const std::vector<std::size_t>& inpoel, const UnsMesh::Coords& coord, const Fields& geoElem, const Fields& U, const Fields& P, const tk::real ct, Fields& R)

Compute volume integrals of pressure relaxation terms in multi-material FV.

auto solvevriem(std::size_t nelem, const std::vector<std::vector<tk::real>>& vriem, const std::vector<std::vector<tk::real>>& riemannLoc) -> std::vector<std::vector<tk::real>>

Solve the reconstruct velocity used for volume fraction equation.

void evaluRiemann(ncomp_t ncomp, const int e_left, const int e_right, const std::size_t nmat, const std::vector<tk::real>& fl, const std::array<tk::real, 3>& fn, const std::array<tk::real, 3>& gp, const std::array<std::vector<tk::real>, 2>& state, std::vector<std::vector<tk::real>>& vriem, std::vector<std::vector<tk::real>>& riemannLoc)

Compute the riemann velociry at the interface.

auto fluxTerms(std::size_t ncomp, std::size_t nmat, const std::vector<inciter::EOS>&, const std::vector<tk::real>& ugp) -> std::vector<std::array<tk::real, 3>>

Compute the flux-function for the multimaterial PDEs.

void updateRhsNonCons(ncomp_t ncomp, const std::size_t nmat, const std::size_t ndof, const std::size_t ndof_el, const tk::real wt, const std::size_t e, const std::vector<tk::real>& B, const std::array<std::vector<tk::real>, 3>& dBdx, const std::vector<std::vector<tk::real>>& ncf, Fields& R)

Update the rhs by adding the non-conservative term integrals.

void updateRhsPre(ncomp_t ncomp, const std::size_t ndof, const std::size_t ndof_el, const tk::real wt, const std::size_t e, const std::vector<tk::real>& B, std::vector<tk::real>& ncf, Fields& R)

Update the rhs by adding the pressure relaxation integrals.

auto NGvol(const std::size_t ndof) -> std::size_t constexpr

auto NGfa(const std::size_t ndof) -> std::size_t constexpr

auto NGdiag(const std::size_t ndof) -> std::size_t constexpr

Initialization of number of Gauss points for volume integration in error estimation.

auto NGinit(const std::size_t ndof) -> std::size_t constexpr

Initialization of number of Gauss points for volume integration in DG initialization.

void GaussQuadratureTet(std::size_t NG, std::array<std::vector<real>, 3>& coordgp, std::vector<real>& wgp)

Initialize Gaussian quadrature points locations and weights for a tetrahedron.

void GaussQuadratureTri(std::size_t NG, std::array<std::vector<real>, 2>& coordgp, std::vector<real>& wgp)

Initialize Gaussian quadrature points locations and weights for a triangle.

void solidTermsVolInt(std::size_t nmat, const std::vector<inciter::EOS>& mat_blk, const std::size_t ndof, const std::size_t rdof, const std::size_t nelem, const std::vector<std::size_t>& inpoel, const UnsMesh::Coords& coord, const Fields& geoElem, const Fields& U, const Fields& P, const std::vector<std::size_t>& ndofel, const tk::real dt, Fields& R, int intsharp)

Compute Solid Terms with volume integrals.

void update_rhs(std::size_t nmat, const std::size_t ndof, const tk::real wt, const std::size_t e, const std::size_t solidx, const std::vector<real>& s, Fields& R)

void srcInt(const std::vector<inciter::EOS>& mat_blk, real t, const std::size_t ndof, const std::size_t nelem, const std::vector<std::size_t>& inpoel, const UnsMesh::Coords& coord, const Fields& geoElem, const SrcFn& src, const std::vector<std::size_t>& ndofel, Fields& R, std::size_t nmat = 1)

Compute source term integrals for DG.

void update_rhs(const std::size_t ndof, const std::size_t ndof_el, const tk::real wt, const std::size_t e, const std::vector<tk::real>& B, const std::vector<tk::real>& s, Fields& R)

Update the rhs by adding the source term integrals.

void srcIntFV(const std::vector<inciter::EOS>& mat_blk, real t, const std::size_t nelem, const Fields& geoElem, const SrcFn& src, Fields& R, std::size_t nmat)

Compute source term integrals for FV.

void surfInt(const bool pref, std::size_t nmat, const std::vector<inciter::EOS>& mat_blk, real t, const std::size_t ndof, const std::size_t rdof, const std::vector<std::size_t>& inpoel, const std::vector<std::size_t>&, const UnsMesh::Coords& coord, const inciter::FaceData& fd, const Fields& geoFace, const Fields& geoElem, const RiemannFluxFn& flux, const VelFn& vel, const Fields& U, const Fields& P, const std::vector<std::size_t>& ndofel, const tk::real, Fields& R, std::vector<std::vector<tk::real>>& riemannDeriv, int intsharp)

Compute internal surface flux integrals for DG.

void update_rhs_fa(ncomp_t ncomp, std::size_t nmat, const std::size_t ndof, const std::size_t ndof_l, const std::size_t ndof_r, const tk::real wt, const std::array<tk::real, 3>& fn, const std::size_t el, const std::size_t er, const std::vector<tk::real>& fl, const std::vector<tk::real>& B_l, const std::vector<tk::real>& B_r, Fields& R, std::vector<std::vector<tk::real>>& riemannDeriv)

void surfIntFV(std::size_t nmat, const std::vector<inciter::EOS>& mat_blk, real t, const std::size_t rdof, const std::vector<std::size_t>& inpoel, const UnsMesh::Coords& coord, const inciter::FaceData& fd, const Fields& geoFace, const Fields& geoElem, const RiemannFluxFn& flux, const VelFn& vel, const Fields& U, const Fields& P, const std::vector<int>& srcFlag, Fields& R, int intsharp)

void surfIntViscousFV(std::size_t nmat, const std::vector<inciter::EOS>& mat_blk, const std::size_t rdof, const std::vector<std::size_t>& inpoel, const UnsMesh::Coords& coord, const inciter::FaceData& fd, const Fields& geoFace, const Fields& geoElem, const Fields& U, const Fields& P, const Fields& T, const std::vector<int>& srcFlag, Fields& R, int intsharp)

auto modifiedGradientViscousFlux(std::size_t nmat, std::size_t ncomp, const std::array<tk::real, 3>& fn, const std::array<std::array<tk::real, 3>, 2>& centroids, const std::array<std::vector<tk::real>, 2>& state, const std::array<std::vector<tk::real>, 2>& cellAvgState, const std::array<std::vector<tk::real>, 2>& cellAvgT, const std::array<std::array<real, 3>, 3> dudx, const std::vector<std::array<real, 3>>& dTdx) -> std::vector<real>

void volInt(std::size_t nmat, real t, const std::vector<inciter::EOS>& mat_blk, const std::size_t ndof, const std::size_t rdof, const std::size_t nelem, const std::vector<std::size_t>& inpoel, const UnsMesh::Coords& coord, const Fields& geoElem, const FluxFn& flux, const VelFn& vel, const Fields& U, const Fields& P, const std::vector<std::size_t>& ndofel, Fields& R, int intsharp = 0)

Compute volume integrals for DG.

void update_rhs(ncomp_t ncomp, const std::size_t ndof, const std::size_t ndof_el, const tk::real wt, const std::size_t e, const std::array<std::vector<tk::real>, 3>& dBdx, const std::vector<std::array<tk::real, 3>>& fl, Fields& R)

Update the rhs by adding the source term integrals.

void recoLeastSqExtStencil(std::size_t rdof, std::size_t e, const std::map<std::size_t, std::vector<std::size_t>>& esup, const std::vector<std::size_t>& inpoel, const Fields& geoElem, Fields& W, const std::vector<std::size_t>& varList)

Reconstruct the second-order solution using least-squares approach from an extended stencil involving the node-neighbors.

void transform_P0P1(std::size_t rdof, std::size_t e, const std::vector<std::size_t>& inpoel, const UnsMesh::Coords& coord, Fields& W, const std::vector<std::size_t>& varList)

Transform the reconstructed P1-derivatives to the Dubiner dofs.

void THINCReco(std::size_t rdof, std::size_t nmat, std::size_t e, const std::vector<std::size_t>& inpoel, const UnsMesh::Coords& coord, const Fields& geoElem, const std::array<real, 3>& ref_xp, const Fields& U, const Fields& P, bool intInd, const std::vector<std::size_t>& matInt, ] const std::vector<real>& vfmin, ] const std::vector<real>& vfmax, std::vector<real>& state)

void THINCRecoTransport(std::size_t rdof, std::size_t, std::size_t e, const std::vector<std::size_t>& inpoel, const UnsMesh::Coords& coord, const Fields& geoElem, const std::array<real, 3>& ref_xp, const Fields& U, const Fields&, ] const std::vector<real>& vfmin, ] const std::vector<real>& vfmax, std::vector<real>& state)

Compute THINC reconstructions for linear advection (transport)

void THINCFunction(std::size_t rdof, std::size_t nmat, std::size_t e, const std::vector<std::size_t>& inpoel, const UnsMesh::Coords& coord, const std::array<real, 3>& ref_xp, real vol, real bparam, const std::vector<real>& alSol, bool intInd, const std::vector<std::size_t>& matInt, std::vector<real>& alReco)

Old THINC reconstruction function for volume fractions near interfaces.

void THINCFunction_new(std::size_t rdof, std::size_t nmat, std::size_t e, const std::vector<std::size_t>& inpoel, const UnsMesh::Coords& coord, const std::array<real, 3>& ref_xp, real vol, real bparam, const std::vector<real>& alSol, bool intInd, const std::vector<std::size_t>& matInt, std::vector<real>& alReco)

New THINC reconstruction function for volume fractions near interfaces.

void computeTemperaturesFV(const std::vector<inciter::EOS>& mat_blk, std::size_t nmat, const std::vector<std::size_t>& inpoel, const tk::UnsMesh::Coords& coord, const tk::Fields& geoElem, const tk::Fields& unk, const tk::Fields& prim, const std::vector<int>& srcFlag, tk::Fields& T)

Compute the temperatures based on FV conserved quantities.

auto evalPolynomialSol(const std::vector<inciter::EOS>& mat_blk, int intsharp, std::size_t ncomp, std::size_t nprim, std::size_t rdof, std::size_t nmat, std::size_t e, std::size_t dof_e, const std::vector<std::size_t>& inpoel, const UnsMesh::Coords& coord, const Fields& geoElem, const std::array<real, 3>& ref_gp, const std::vector<real>& B, const Fields& U, const Fields& P) -> std::vector<tk::real>

Evaluate polynomial solution at quadrature point.

auto evalFVSol(const std::vector<inciter::EOS>& mat_blk, int intsharp, std::size_t ncomp, std::size_t nprim, std::size_t rdof, std::size_t nmat, std::size_t e, const std::vector<std::size_t>& inpoel, const UnsMesh::Coords& coord, const Fields& geoElem, const std::array<real, 3>& ref_gp, const std::vector<real>& B, const Fields& U, const Fields& P, int srcFlag) -> std::vector<tk::real>

Evaluate second-order FV solution at quadrature point.

void safeReco(std::size_t rdof, std::size_t nmat, std::size_t el, int er, const Fields& U, std::array<std::vector<real>, 2>& state)

Compute safe reconstructions near material interfaces.

void THINCReco(std::size_t rdof, std::size_t nmat, std::size_t e, const std::vector<std::size_t>& inpoel, const UnsMesh::Coords& coord, const Fields& geoElem, const std::array<real, 3>& xp, const Fields& U, const Fields& P, bool intInd, const std::vector<std::size_t>& matInt, const std::vector<real>& vfmin, const std::vector<real>& vfmax, std::vector<real>& state)

Compute THINC reconstructions near material interfaces.

auto serialize(std::size_t meshid, const std::vector<tk::UniPDF>& u) -> std::pair<int, std::unique_ptr<char[]>>

Serialize univariate PDF to raw memory stream.

auto mergeUniPDFs(int nmsg, CkReductionMsg** msgs) -> CkReductionMsg*

Charm++ custom reducer for merging a univariate PDF during reduction across PEs.

auto serialize(const std::vector<tk::UniPDF>& u, const std::vector<tk::BiPDF>& b, const std::vector<tk::TriPDF>& t) -> std::pair<int, std::unique_ptr<char[]>>

Serialize vectors of PDFs to raw memory stream.

auto mergePDF(int nmsg, CkReductionMsg** msgs) -> CkReductionMsg*

Charm++ custom reducer for merging PDFs during reduction across PEs.

static auto operator<<(std::ostream& os, const tk::UniPDF& p) -> std::ostream&

Variables

const uint8_t UnkEqComp

Tags for selecting data layout policies.

const std::array<std::size_t, 2> ExoNnpe

const std::array<std::array<std::size_t, 3>, 4> expofa

const std::array<UnsMesh::Face, 4> lpofa

const std::array<UnsMesh::Edge, 6> lpoed

Const array defining the node ordering convention for tetrahedron edges.

const std::array<UnsMesh::Edge, 3> lpoet

Const array defining the node ordering convention for triangle edges.

static highwayhash::HH_U64 hh_key constexpr

static std::stringstream cerr_quiet

std::tringstream used to quiet std::cerr's stream by redirecting to it

static std::streambuf* cerr_old

std::streambuf used to store state of std::cerr before redirecting it

Enum documentation

Typedef documentation

Function documentation

std::vector< std::size_t > inpoel { 12, 14,  9, 11,
                                    10, 14, 13, 12 };

for (std::size_t p=0; p<npoin; ++p)
  for (auto i=esup.second[p]+1; i<=esup.second[p+1]; ++i)
     use element id esup.first[i]

auto minmax = std::minmax_element( begin(inpoel), end(inpoel) );
Assert( *minmax.first == 0, "node ids should start from zero" );
auto npoin = *minmax.second + 1;

std::vector< std::size_t > inpoel { 12, 14,  9, 11,
                                    10, 14, 13, 12 };

for (std::size_t p=0; p<npoin; ++p)
  for (auto i=psup.second[p]+1; i<=psup.second[p+1]; ++i)
     use point id psup.first[i]

auto minmax = std::minmax_element( begin(inpoel), end(inpoel) );
Assert( *minmax.first == 0, "node ids should start from zero" );
auto npoin = *minmax.second + 1;

std::vector< std::size_t > inpoel { 12, 14,  9, 11,
                                    10, 14, 13, 12 };

for (std::size_t p=0; p<npoin; ++p)
  for (auto i=edsup.second[p]+1; i<=edsup.second[p+1]; ++i)
    use edge with point ids p < edsup.first[i]

auto minmax = std::minmax_element( begin(inpoel), end(inpoel) );
Assert( *minmax.first == 0, "node ids should start from zero" );
auto npoin = *minmax.second + 1;

std::vector< std::size_t > inpoel { 12, 14,  9, 11,
                                    10, 14, 13, 12 };

for (std::size_t e=0; e<inpoed.size()/2; ++e) {
  use point id p of edge e = inpoed[e*2];
  use point id q of edge e = inpoed[e*2+1];
}

std::vector< std::size_t > inpoel { 12, 14,  9, 11,
                                    10, 14, 13, 12 };

for (std::size_t e=0; e<nelem; ++e)
  for (auto i=esupel.second[e]+1; i<=esupel.second[e+1]; ++i)
     use element id esupel.first[i]

std::vector< std::size_t > inpoel { 12, 14,  9, 11,
                                    10, 14, 13, 12 };

for (std::size_t e=0; e<nelem; ++e)
  for (auto i=esuel.second[e]+1; i<=esuel.second[e+1]; ++i)
     use element id esuel.first[i]

std::vector< std::size_t > inpoel { 12, 14,  9, 11,
                                    10, 14, 13, 12 };

for (std::size_t e=0; e<nelem; ++e) {
  for (std::size_t i=0; i<nepe; ++i) {
    use edge id inedel[e*nepe+i] of element e, or
    use point ids p < q of edge id inedel[e*nepe+i] of element e as
      p = inpoed[ inedel[e*nepe+i]*2 ]
      q = inpoed[ inedel[e*nepe+i]*2+1 ]
  }
}

std::vector< std::size_t > inpoel { 12, 14,  9, 11,
                                    10, 14, 13, 12 };

for (const auto& [edge,surr_elements] : esued) {
  use element edge-end-point ids edge[0] and edge[1]
  for (auto e : surr_elements) {
     use element id e
  }
}

std::vector< std::size_t > inpoel { 12, 14,  9, 11,
                                    10, 14, 13, 12 };