escript Revision_
finley::util Namespace Reference

Typedefs

typedef std::pair< index_t, index_tIndexPair
 
typedef std::vector< IndexPairValueAndIndexList
 

Functions

bool ValueAndIndexCompare (const std::pair< int, int > &i, const std::pair< int, int > &j)
 comparison function for sortValueAndIndex
 
void sortValueAndIndex (ValueAndIndexList &array)
 orders a ValueAndIndexList by value.
 
void gather (int len, const index_t *index, int numData, const double *in, double *out)
 
template<typename Scalar >
void addScatter (int len, const index_t *index, int numData, const Scalar *in, Scalar *out, index_t upperBound)
 
template void addScatter< real_t > (int len, const index_t *index, int numData, const real_t *in, real_t *out, index_t upperBound)
 
template void addScatter< cplx_t > (int len, const index_t *index, int numData, const cplx_t *in, cplx_t *out, index_t upperBound)
 
void smallMatMult (int A1, int A2, double *A, int B2, const std::vector< double > &B, const std::vector< double > &C)
 multiplies two matrices: A(1:A1,1:A2) := B(1:A1,1:B2)*C(1:B2,1:A2)
 
template<typename Scalar >
void smallMatSetMult1 (int len, int A1, int A2, Scalar *A, int B2, const std::vector< Scalar > &B, const std::vector< real_t > &C)
 
template void smallMatSetMult1< real_t > (int len, int A1, int A2, real_t *A, int B2, const std::vector< real_t > &B, const std::vector< real_t > &C)
 
template void smallMatSetMult1< cplx_t > (int len, int A1, int A2, cplx_t *A, int B2, const std::vector< cplx_t > &B, const std::vector< real_t > &C)
 
void invertSmallMat (int len, int dim, const double *A, double *invA, double *det)
 
void normalVector (int len, int dim, int dim1, const double *A, double *Normal)
 
index_t getMinInt (int dim, dim_t N, const index_t *values)
 calculates the minimum value from a dim X N integer array
 
index_t getMaxInt (int dim, dim_t N, const index_t *values)
 calculates the maximum value from a dim X N integer array
 
IndexPair getMinMaxInt (int dim, dim_t N, const index_t *values)
 
IndexPair getFlaggedMinMaxInt (dim_t N, const index_t *values, index_t ignore)
 
std::vector< index_tpackMask (const std::vector< short > &mask)
 
void setValuesInUse (const int *values, dim_t numValues, std::vector< int > &valuesInUse, escript::JMPI mpiinfo)
 
bool hasReducedIntegrationOrder (const escript::Data &in)
 returns true if the data object is defined on reduced element types
 

Typedef Documentation

◆ IndexPair

◆ ValueAndIndexList

Function Documentation

◆ addScatter()

template<typename Scalar >
void finley::util::addScatter ( int len,
const index_t * index,
int numData,
const Scalar * in,
Scalar * out,
index_t upperBound )

◆ addScatter< cplx_t >()

template void finley::util::addScatter< cplx_t > ( int len,
const index_t * index,
int numData,
const cplx_t * in,
cplx_t * out,
index_t upperBound )

◆ addScatter< real_t >()

template void finley::util::addScatter< real_t > ( int len,
const index_t * index,
int numData,
const real_t * in,
real_t * out,
index_t upperBound )

◆ gather()

void finley::util::gather ( int len,
const index_t * index,
int numData,
const double * in,
double * out )

gathers values into array out from array in using index: out(1:numData, 1:len) := in(1:numData, index(1:len))

References INDEX2.

Referenced by finley::Assemble_getNormal(), finley::Assemble_getSize(), and finley::FinleyDomain::findMatchingFaces().

◆ getFlaggedMinMaxInt()

IndexPair finley::util::getFlaggedMinMaxInt ( dim_t N,
const index_t * values,
index_t ignore )

calculates the minimum and maximum value from an integer array of length N disregarding the value ignore

References escript::DataTypes::index_t_max(), and escript::DataTypes::index_t_min().

Referenced by finley::NodeMapping::assign(), and finley::NodeFile::createDOFMappingAndCoupling().

◆ getMaxInt()

index_t finley::util::getMaxInt ( int dim,
dim_t N,
const index_t * values )

calculates the maximum value from a dim X N integer array

References INDEX2.

Referenced by finley::FinleyDomain::merge().

◆ getMinInt()

index_t finley::util::getMinInt ( int dim,
dim_t N,
const index_t * values )

calculates the minimum value from a dim X N integer array

References INDEX2.

◆ getMinMaxInt()

IndexPair finley::util::getMinMaxInt ( int dim,
dim_t N,
const index_t * values )

◆ hasReducedIntegrationOrder()

◆ invertSmallMat()

void finley::util::invertSmallMat ( int len,
int dim,
const double * A,
double * invA,
double * det )

inverts the set of dim x dim matrices A(:,:,1:len) with dim=1,2,3 the inverse and determinant are returned.

References INDEX3.

◆ normalVector()

void finley::util::normalVector ( int len,
int dim,
int dim1,
const double * A,
double * Normal )

returns the normalized vector normal[dim,len] orthogonal to A(:,0,q) and A(:,1,q) in the case of dim=3, or the vector A(:,0,q) in the case of dim=2

References INDEX2, and INDEX3.

Referenced by finley::Assemble_getNormal().

◆ packMask()

std::vector< index_t > finley::util::packMask ( const std::vector< short > & mask)

extracts the positive entries in mask returning a contiguous vector of those entries

Referenced by finley::FinleyDomain::createMappings(), and finley::NodeFile::createNodeMappings().

◆ setValuesInUse()

void finley::util::setValuesInUse ( const int * values,
dim_t numValues,
std::vector< int > & valuesInUse,
escript::JMPI mpiinfo )

◆ smallMatMult()

void finley::util::smallMatMult ( int A1,
int A2,
double * A,
int B2,
const std::vector< double > & B,
const std::vector< double > & C )

multiplies two matrices: A(1:A1,1:A2) := B(1:A1,1:B2)*C(1:B2,1:A2)

References INDEX2.

Referenced by finley::Assemble_getNormal().

◆ smallMatSetMult1()

template<typename Scalar >
void finley::util::smallMatSetMult1 ( int len,
int A1,
int A2,
Scalar * A,
int B2,
const std::vector< Scalar > & B,
const std::vector< double > & C )

multiplies a set of matrices with a single matrix: A(1:A1,1:A2,i)=B(1:A1,1:B2,i)*C(1:B2,1:A2) for i=1,len

References INDEX2, and INDEX3.

Referenced by finley::Assemble_interpolate().

◆ smallMatSetMult1< cplx_t >()

template void finley::util::smallMatSetMult1< cplx_t > ( int len,
int A1,
int A2,
cplx_t * A,
int B2,
const std::vector< cplx_t > & B,
const std::vector< real_t > & C )

◆ smallMatSetMult1< real_t >()

template void finley::util::smallMatSetMult1< real_t > ( int len,
int A1,
int A2,
real_t * A,
int B2,
const std::vector< real_t > & B,
const std::vector< real_t > & C )

◆ sortValueAndIndex()

void finley::util::sortValueAndIndex ( ValueAndIndexList & array)

orders a ValueAndIndexList by value.

References ValueAndIndexCompare().

Referenced by finley::ElementFile::optimizeOrdering().

◆ ValueAndIndexCompare()

bool finley::util::ValueAndIndexCompare ( const std::pair< int, int > & i,
const std::pair< int, int > & j )

comparison function for sortValueAndIndex

Referenced by sortValueAndIndex().