tk namespace

enum tk::ErrCode

Error codes for the OS (or whatever calls us)

enum class tk::ExoElemType: int

Supported ExodusII mesh cell types

enum class tk::Centering: char

Mesh/scheme centering types

template<std::size_t N>

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

Type alias for storing a discrete (y1,y2,...,yN) = f(x) function

template<class Container>

void tk::unique(Container& c)

Make elements of container unique (in-place, overwriting source container)

template<class Container>

Container tk::uniquecopy(const Container& src)

Make elements of container unique (on a copy, leaving the source as is)

template<typename Container>

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

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 tk::ref_find(const Container& map, const typename Container::key_type& key) -> typename Container::mapped_type &

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

template<typename T>

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

Return minimum and maximum values of a vector.

template<typename Container>

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

Find and return minimum and maximum values in associative container.

template<class T, std::size_t N>

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

Add all elements of an array to those of another one

template<class T, class Allocator>

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

Add all elements of a vector to those of another one If src.size() > dst.size() will grow dst to that of src.size() padding with zeros.

template<class T, class Allocator>

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

Divide all elements of a vector with those of another one If src.size() > dst.size() will grow dst to that of src.size() padding with zeros.

template<class C1, class C2>

bool tk::keyEqual(const C1& a, const C2& b)

Test if all keys of two associative containers are equal

template<class Container>

std::size_t tk::sumsize(const Container& c)

Compute the sum of the sizes of a container of containers

template<class Container>

std::size_t tk::numunique(const Container& c)

Compute the number of unique values in a container of containers

template<class Map>

std::size_t tk::sumvalsize(const Map& c)

Compute the sum of the sizes of the values of an associative container

template<class Container>

void tk::destroy(Container& c)

Free memory of a container See http://stackoverflow.com/a/10465032 as to why this is done with the swap() member function of the container.

template<typename Container, typename Predicate>

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

Remove items from container based on predicate

template<class T>

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

Concatenate vectors of T

template<class T>

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

Overwrite vectors of pair< bool, tk::real >

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

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

Concatenate unordered sets

template<class Key, class Value>

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

Operator << for writing value_type of a standard map to output streams

template<typename T>

std::string tk::parameter(const T& v)

Convert and return value as string.

template<typename V>

std::string tk::parameters(const V& v)

Convert and return values from container as string.

template<uint8_t Layout>

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

Operator * multiplying all items by a scalar from the left

template<uint8_t Layout>

Data<Layout> tk::min(const Data<Layout>& a, const Data<Layout>& b)

Operator min between two Data objects

template<uint8_t Layout>

Data<Layout> tk::max(const Data<Layout>& a, const Data<Layout>& b)

Operator max between two Data objects

template<uint8_t Layout>

bool tk::operator==(const Data<Layout>& lhs, const Data<Layout>& rhs)

Operator == between two Data objects

template<uint8_t Layout>

bool tk::operator!=(const Data<Layout>& lhs, const Data<Layout>& rhs)

Operator != between two Data objects

template<uint8_t Layout>

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

Compute the maximum difference between the elements of two Data objects The position returned is the position in the underlying raw data structure, independent of components. If lhs == rhs with precision std::numeric_limits< tk::real >::epsilon(), a pair of (0,0.0) is returned.

template<typename A, typename B>

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

Flip a std::pair of arbitrary types

template<typename A, typename B>

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

Flip a std::map of arbitrary types, yielding a std::multimap sorted by std::map::value_type.

uint64_t tk::linearLoadDistributor(real virtualization, uint64_t load, int npe, uint64_t& chunksize, uint64_t& remainder)

Compute linear load distribution for given total work and virtualization.

Compute load distibution (number of chares and chunksize) based on total work (e.g., total number of particles) and virtualization

The virtualization parameter, specified by the user, is a real number between 0.0 and 1.0, inclusive, which controls the degree of virtualization or over-decomposition. Independent of the value of virtualization the work is approximately evenly distributed among the available processing elements, given by npe. For zero virtualization (no over-decomposition), the work is simply decomposed into total_work/numPEs, which yields the smallest number of Charm++ chares and the largest chunks of work units. The other extreme is unity virtualization, which decomposes the total work into the smallest size work units possible, yielding the largest number of Charm++ chares. Obviously, the optimum will be between 0.0 and 1.0, depending on the problem.

The formula implemented uses a linear relationship between the virtualization parameter and the number of work units with the extremes described above. The formula is given by

chunksize = (1 - n) * v + n;

where

• v = degree of virtualization
• n = load/npes
• load = total work, e.g., number of particles, number of mesh cells
• npes = number of hardware processing elements

template<class List>

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

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

template<class List>

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

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

template<class Tuple>

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

Output command line object (a TaggedTuple) to file

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

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

Operator << for writing an enum class to an output stream

template<class T, typename Ch, typename Tr>

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

Operator << for writing a std::vector to an output stream

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

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

Operator << for writing an std::map to an output stream

template<typename T, typename Ch, typename Tr>

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

Operator << for adding (concatenating) T to a std::basic_string for lvalues.

template<typename T, typename Ch, typename Tr>

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

Operator << for adding (concatenating) T to a std::basic_string for rvalues.

void tk::signalHandler(int signum)

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

Signals caught: SIGABRT is generated when the program calls the abort() function, such as when an assert() triggers SIGSEGV is generated when the program makes an illegal memory access, such as reading unaligned memory, dereferencing a null pointer, reading memory out of bounds etc. SIGILL is generated when the program tries to execute a malformed instruction. This happens when the execution pointer starts reading non-program data, or when a pointer to a function is corrupted. SIGFPE is generated when executing an illegal floating point instruction, most commonly division by zero or floating point overflow.

int tk::setSignalHandlers()

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

void tk::processExceptionCharm()

Process an exception from the Charm++ runtime system.

See Josuttis, The C++ Standard Library - A Tutorial and Reference, 2nd Edition, 2012.

template<std::size_t N>

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

Sample a discrete (y1,y2,...,yN) = f(x) function at x

Timer::Watch tk::hms(tk::real stamp)

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

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

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

Compute the cross-product of two vectors

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

Compute the cross-product of two vectors

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

Compute the cross-product of two vectors divided by a scalar

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

Compute the cross-product of two vectors divided by a scalar

real tk::dot(real v1x, real v1y, real v1z, real v2x, real v2y, real v2z)

Compute the dot-product of two vectors

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

Compute the dot-product of two vectors

real tk::length(real x, real y, real z)

Compute length of a vector

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

Compute length of a vector

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

Scale vector to unit length

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

Compute the triple-product of three vectors

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

Compute the triple-product of three vectors

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

Rotate vector about X axis

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

Rotate vector about Y axis

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

Rotate vector about Z axis

real tk::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)

Compute the unit normal vector of a triangle

std::pair<int, std::unique_ptr<char[]>> tk::serialize(const std::unordered_map<std::size_t, std::vector<std::size_t>>& d)

Serialize to raw memory stream.

CkReductionMsg* tk::mergeGraph(int nmsg, CkReductionMsg** msgs)

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

std::pair<int, std::unique_ptr<char[]>> tk::serialize(const std::unordered_map<std::size_t, std::size_t>& d)

Serialize to raw memory stream.

CkReductionMsg* tk::mergeParts(int nmsg, CkReductionMsg** msgs)

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

MeshReaderType tk::detectInput(const std::string& filename)

Detect input mesh file type.

MeshWriterType tk::pickOutput(const std::string& filename)

Determine output mesh file type.

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

Read unstructured mesh from file.

Create unstructured mesh to store mesh

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

Write unstructured mesh to file.

static std::string tk::workdir()

std::string tk::curtime()

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

void tk::echoHeader(HeaderType header)

Echo program header.

void tk::echoBuildEnv(const std::string& executable)

Echo build environment.

Echo information read from build_dir/Base/Config.h filled by CMake based on src/Main/Config.h.in.

void tk::echoRunEnv(int argc, char** argv, int quiescence)

Echo runtime environment.

void tk::finalize(const std::vector<tk::Timer>& timer, std::vector<std::pair<std::string, tk::Timer::Watch>>& timestamp, bool clean)

Finalize function for different executables.

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

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

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

Generate derived data structure, elements surrounding points.

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

The data generated here is stored in a linked list, more precisely, two linked arrays (vectors), esup1 and esup2, where esup2 holds the indices at which esup1 holds the element ids surrounding points. Looping over all elements surrounding all points can then be accomplished by the following loop:

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]

To find out the number of points, npoin, the mesh connectivity, inpoel, can be queried:

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::pair<std::vector<std::size_t>, std::vector<std::size_t>> tk::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)

Generate derived data structure, points surrounding points.

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

The data generated here is stored in a linked list, more precisely, two linked arrays (vectors), psup1 and psup2, where psup2 holds the indices at which psup1 holds the point ids surrounding points. Looping over all points surrounding all points can then be accomplished by the following loop:

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]

To find out the number of points, npoin, the mesh connectivity, inpoel, can be queried:

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

or the length-1 of the generated index list: auto npoin = psup.second.size()-1;

std::pair<std::vector<std::size_t>, std::vector<std::size_t>> tk::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)

Generate derived data structure, edges surrounding points.

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

The data generated here is stored in a linked list, more precisely, two linked arrays (vectors), edsup1 and edsup2, where edsup2 holds the indices at which edsup1 holds the edge-end point ids emanating from points for all points. The generated data structure, linked lists edsup1 and edsup2, are very similar to psup1 and psup2, generated by genPsup(), except here only unique edges are stored, i.e., for edges with point ids p < q, only ids q are stored that are still associated to point p. Looping over all unique edges can then be accomplished by the following loop:

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]

To find out the number of points, npoin, the mesh connectivity, inpoel, can be queried:

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> tk::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)

Generate derived data structure, edge connectivity.

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

The data generated here is stored in a linear vector and is very similar to the linked lists, edsup1 and _edsup2, generated by genEdsup(). The difference is that in the linear vector, inpoed, generated here, both edge point ids are stored as a pair, p < q, as opposed to the linked lists edsup1 and edsup2, in which edsup1 only stores the edge-end point ids (still associated to edge-start point ids when used together with edsup2). The rationale is that while inpoed is larger in memory, it allows direct access to edges (pair of point ids making up an edge), edsup1 and edsup2 are smaller in memory, still allow accessing the same data (edge point id pairs) but only in a linear fashion, not by direct access to particular edges. Accessing all unique edges using the edge connectivity data structure, inpoed, generated here can be accomplished by

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::pair<std::vector<std::size_t>, std::vector<std::size_t>> tk::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)

Generate derived data structure, elements surrounding points of elements.

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

The data generated here is stored in a linked list, more precisely, two linked arrays (vectors), esupel1 and esupel2, where esupel2 holds the indices at which esupel1 holds the element ids surrounding points of elements. Looping over all elements surrounding the points of all elements can then be accomplished by the following loop:

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]

To find out the number of elements, nelem, the size of the mesh connectivity vector, inpoel, can be devided by the number of nodes per elements, nnpe: auto nelem = inpoel.size()/nnpe;

std::pair<std::vector<std::size_t>, std::vector<std::size_t>> tk::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)

Generate derived data structure, elements surrounding elements.

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

The data generated here is stored in a linked list, more precisely, two linked arrays (vectors), esuel1 and esuel2, where esuel2 holds the indices at which esuel1 holds the element ids surrounding elements. Looping over elements surrounding elements can then be accomplished by the following loop:

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]

To find out the number of elements, nelem, the size of the mesh connectivity vector, inpoel, can be devided by the number of nodes per elements, nnpe: auto nelem = inpoel.size()/nnpe;

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

Generate derived data structure, edges of elements.

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

The data generated here is stored in a linear vector with all edge ids (as defined by inpoed) of all elements. The edge ids stored in inedel can be directly used to index the vector inpoed. Because the derived data structure generated here, inedel, is intended to be used in conjunction with the linear vector inpoed and not with the linked lists edsup1 and edsup2, this function takes inpoed as an argument. Accessing the edges of element e using the edge of elements data structure, inedel, generated here can be accomplished by

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 ]
  }
}

where nepe denotes the number of edges per elements: 3 for triangles, 6 for tetrahedra. To find out the number of elements, nelem, the size of the mesh connectivity vector, inpoel, can be devided by the number of nodes per elements, nnpe: auto nelem = inpoel.size()/nnpe;

std::unordered_map<UnsMesh::Edge, std::vector<std::size_t>, UnsMesh::Hash<2>, UnsMesh::Eq<2>> tk::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)

Generate derived data structure, elements surrounding edges.

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

Looping over elements surrounding all edges can be accomplished by the following loop:

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
  }
}

esued.size() equals the number of edges.

std::pair<std::vector<std::size_t>, std::vector<std::size_t>> tk::genEdpas(int mvecl, std::size_t nnpe, std::size_t npoin, const std::vector<std::size_t>& inpoed)

Generate vector-groups for edges.

The data generated here is stored in a linked list, more precisely, two linked arrays (vectors), edpas1 and edpas2, where edpas2 holds the indices at which edpas1 holds the edge ids of a vector group. Looping over all groups can then be accomplished by the following loop:

for (std::size_t w=0; w<edpas.second.size()-1; ++w)
  for (auto i=edpas.second[w]+1; i<=edpas.second[w+1]; ++i)
     use edge id edpas.first[i]

std::size_t tk::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)

Generate number of boundary-faces and triangle boundary-face connectivity.

This function takes a mesh by its domain-element (tetrahedron-connectivity) in inpoel and a boundary-face (triangle) connectivity in triinpoel_complete. Based on these two arrays, it searches for those faces of triinpoel_complete that are also in inpoel and as a result it generates (1) the number of boundary faces shared with the mesh in inpoel and (2) the intersection of the triangle element connectivity whose faces are shared with inpoel. An example use case is where triinpoel_complete contains the connectivity for the boundary of the full problem/mesh and inpoel contains the connectivity for only a chunk of an already partitioned mesh. This function then intersects triinpoel_complete with inpoel and returns only those faces that share nodes with inpoel.

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

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

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

The data generated here is stored in a single vector, with length nfpe * nelem. Note however, that nelem is not explicitly provided, but calculated from inpoel. For boundary elements, at the boundary face, this esuelTet stores value -1 indicating that this is outside the domain. The convention for numbering the local face (triangle) connectivity is very important, e.g., in generating the inpofa array later. This node ordering convention is stored in tk::lpofa. Thus function is specific to tetrahedra, which is reflected in the fact that nnpe and nfpe are being set here in the function rather than being input arguments. To find out the number of elements, nelem, the size of the mesh connectivity vector, inpoel, can be devided by the number of nodes per elements, nnpe: auto nelem = inpoel.size()/nnpe;

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

Generate number of internal and physical-boundary faces.

The unsigned integer here gives the number of internal and physical-boundary faces in the mesh. The data structure does not include faces that are on partition/chare-boundaries.

std::vector<int> tk::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)

Generate derived data structure, elements surrounding faces.

The unsigned integer vector gives the IDs of the elements to the

std::vector<std::size_t> tk::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)

Generate derived data structure, points on faces for tetrahedra only.

std::vector<std::size_t> tk::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)

Generate derived data structure, boundary elements.

The data structure generated here contains an array of elements which share one or more of their faces with the physical boundary, i.e., where exodus specifies a side-set for faces. Such elements are sometimes also called host or boundary elements.

bool tk::leakyPartition(const std::vector<int>& esueltet, const std::vector<std::size_t>& inpoel, const std::array<std::vector<real>, 3>& coord)

Perform leak-test on mesh (partition)

This function computes a surface integral over the boundary of the incoming mesh (partition). A non-zero vector result indicates a leak, e.g., a hole in the mesh (partition), which indicates an error either in the

bool tk::conforming(const std::vector<std::size_t>& inpoel, const std::array<std::vector<real>, 3>& coord, bool cerr, const std::vector<std::size_t>& rid)

Check if mesh (partition) is conforming.

A conforming mesh by definition has no hanging nodes. A node is hanging if an edge of one element coincides with two (or more) edges (of two or more other elements). Thus, testing for conformity relies on checking the coordinates of all vertices: if any vertex coincides with that of a mid-point node of an edge, that is a hanging node. Note that this assumes that hanging nodes can only be at the mid-point of edges. This may happen after a mesh refinement step, due to a problem/bug, within the mesh refinement algorithm given by J. Waltz, Parallel adaptive refinement for unsteady flow calculations on 3D unstructured grids, International Journal for Numerical Methods in Fluids, 46: 37–57, 2004, which always adds/removes vertices at the mid-points of edges of a tetrahedron mesh within a single refinement step. Thus this algorithm is intended for this specific case, i.e., test for conformity after a single refinement step and not after multiple ones or for detecting hanging nodes in an arbitrary mesh.

bool tk::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)

Determine if a point is in a tetrahedron.

std::array<tk::real, 3> tk::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, uint64_t c)

Compute gradient at a mesh node.

std::array<tk::real, 3> tk::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, uint64_t c)

Compute gradient at a mesh edge.

std::size_t tk::shiftToZero(std::vector<std::size_t>& inpoel)

Shift node IDs to start with zero in element connectivity.

This function implements a simple reordering of the node ids of the element connectivity in inpoel by shifting the node ids so that the smallest is zero.

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

Apply new mapping to vector of indices.

This function applies a mapping (reordering) to the integer IDs passed in using the map passed in. The mapping is expressed between the array index and its value. The function overwrites every value, i, of vector ids with map[i].

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

Apply new mapping to vector of real numbers.

This function applies a mapping (reordering) to the real values passed in using the map passed in. The mapping is expressed between the array index and its value. The function moves every value r[i] to r[ map[i] ].

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

Create remapped vector of indices using a vector.

This function applies a mapping (reordering) to the integer IDs passed in using the map passed in. The mapping is expressed between the array index and its value. The function creates and returns a new container with remapped ids of identical size of the origin ids container.

void tk::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.

This function applies a mapping (reordering) to the integer IDs passed in using the map passed in. The mapping is expressed as a hash-map of key->value pairs, where the key is the original and the value is the new ids of the mapping. The function overwrites the ids container with the remapped ids of identical size.

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

Create remapped vector of indices using a map.

This function applies a mapping (reordering) to the integer IDs passed in using the map passed in. The mapping is expressed as a hash-map of key->value pairs, where the key is the original and the value is the new ids of the mapping. The function creates and returns a new container with the remapped ids of identical size of the original ids container.

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

Create remapped map of vector of indices using a map.

This function applies a mapping (reordering) to the map of integer IDs passed in using the map passed in by applying remap(vector,map) on each vector of ids. The keys in the returned map will be the same as in ids.

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

Reorder mesh points with the advancing front technique.

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

Assign local ids to global ids.

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

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

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

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

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

Generate nodes of side set faces.

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

Serialize univariate PDF to raw memory stream.

CkReductionMsg* tk::mergeUniPDFs(int nmsg, CkReductionMsg** msgs)

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

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

Output univariate PDF to output stream

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

ExodusII mesh cell number of nodes

List of number of nodes per element for different element types supported in the order of tk::ExoElemType

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

ExodusII face-node numbering for tetrahedron side sets

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

Const array defining the node ordering convention for tetrahedron faces

This two-dimensional array stores the naming/ordering convention of the node indices of a tetrahedron (tet) element. The dimensions are 4x3 as a tetrahedron has a total of 4 nodes and each (triangle) face has 3 nodes. Thus the array below associates tet node 0 with nodes {1,2,3}, tet node 1 with {2,0,3}, tet node 2 with {3,0,1}, and tet node 3 with {0,2,1}. Note that not only these mappings are important, but also the order of the nodes within the triplets as this specific order also defines the outwards normal of each face.

static highwayhash::HH_U64 tk::hh_key constexpr

Highway hash "secret" key