Classes
class	Timer

Functions
template<typename T >
std::vector< T >	flatten (const std::vector< std::vector< T >> &v)

template<typename T >
std::vector< std::vector< T > >	fold (const std::vector< T > &v, int dim)

template<typename T >
std::vector< T >	operator+ (const std::vector< T > &x, const std::vector< T > &y)

template<typename T >
std::vector< T >	operator- (const std::vector< T > &x, const std::vector< T > &y)

template<typename T >
std::vector< T >	operator* (T a, const std::vector< T > &x)

template<typename T >
std::vector< T >	hadamard (const std::vector< T > &x, const std::vector< T > &y)

template<typename T >
T	l2_Norm (const std::vector< T > &x)

template<typename T >
T	reciprocal (T x)

template<typename T >
void	reciprocal_vec (std::vector< T > &x)

template<typename T >
bool	hasZero (const std::vector< T > &x)

template<typename T >
std::vector< T >	getMinMax (const std::vector< T > &x)

template<typename T >
T	scale_to_range (T x, const std::vector< T > &xminmax, const std::vector< T > &yminmax)

template<typename T >
void	scale_vec_to_range (std::vector< T > &x, const std::vector< T > &xminmax, const std::vector< T > &yminmax)

template<typename T >
std::vector< T >	getMeanStdev (const std::vector< T > &x)

template<typename T >
std::vector< bool >	cellsToRefine (const std::vector< T > &values, T tol)

template<typename T >
std::vector< bool >	cellsToRefineStdev (const std::vector< T > &values, T mean, T dev)

template<typename T >
std::vector< bool >	cellsToRefineMaxdev (const std::vector< T > &values, T dev)

std::string	trim_fname (const std::string &name, const std::string &ext)

std::string	find_ext (const std::string &fname)

void	toLower (std::string &str)

void	toUpper (std::string &str)

std::string	findToStr (const std::string &str, const std::string &ptrn)

std::string	findFromStr (const std::string &str, const std::string &ptrn)

std::string	getTimeStr ()

std::string	find_name (const std::string &fname)

template<typename T >
void	printVec (const std::vector< T > &v)

template<typename T >
bool	valInVec (const std::vector< T > &v, T val)

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

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

template<typename T >
bool	isInBBox (const std::vector< T > &crd, const std::vector< T > &bb)

template<typename A , typename B >
std::vector< A >	getSortedKeys (const std::map< A, B > &mapObj)

std::string	getRandomString (int length)

std::shared_ptr< char >	strToChar (const std::string &strng)

std::vector< std::string >	Tokenize (const std::string &lineIn, const char &delim)

std::vector< std::string >	Tokenize (const std::string &lineIn, const std::string &delim)

template<typename A , typename B >
A	leastUnusedKey (const std::map< A, B > &map, A min=1)

Function Documentation

◆ cellsToRefine()

template<typename T >

std::vector< bool > nemAux::cellsToRefine	(	const std::vector< T > &	values,
		T	tol
	)

Definition at line 402 of file AuxiliaryFunctions.H.

Referenced by Foam::AMRFoam::update(), Foam::AMRFoam::updateAMR(), and Foam::AMRFoam::updateAMRML().

                                                                  {
   std::vector<bool> result(values.size(), false);
   for (std::size_t i = 0; i < values.size(); ++i)
     if (values[i] > tol) result[i] = true;
   return result;
 }

◆ cellsToRefineMaxdev()

template<typename T >

std::vector< bool > nemAux::cellsToRefineMaxdev	(	const std::vector< T > &	values,
		T	dev
	)

Definition at line 426 of file AuxiliaryFunctions.H.

Referenced by NEM::ADP::SizeFieldBase::mutateValues().

                                                                        {
   dev = std::abs(dev);
   if (dev > 1) dev = 1;
 
   T max = *std::max_element(values.begin(), values.end());
   T hl = (1 - dev) * max;
 
   std::vector<bool> result(values.size(), false);
   for (std::size_t i = 0; i < values.size(); ++i)
     if (values[i] > hl) result[i] = true;
   return result;
 }

◆ cellsToRefineStdev()

template<typename T >

std::vector< bool > nemAux::cellsToRefineStdev	(	const std::vector< T > &	values,
		T	mean,
		T	dev
	)

Definition at line 411 of file AuxiliaryFunctions.H.

                                             {
   if (std::abs(dev / mean) >= 1.0) dev = 0.99 * mean;
 
   T th = mean + dev;
   T tl = mean - dev;
 
   std::vector<bool> result(values.size(), false);
   for (std::size_t i = 0; i < values.size(); ++i)
     if (values[i] > th || values[i] < tl) result[i] = true;
   return result;
 }

◆ find_ext()

std::string nemAux::find_ext ( const std::string & fname )

inline

Definition at line 451 of file AuxiliaryFunctions.H.

Referenced by NEM::GEN::gmshGen::createMeshFromSTEP(), NEM::DRV::GmshMeshGenDriver::execute(), NEM::DRV::GmshToExoConversionDriver::execute(), NEM::DRV::MeshGenDriver::MeshGenDriver(), NEM::MSH::MeshTypeFromFilename(), NEM::MSH::vtkStandardNewMacro(), NEM::MSH::vtkGeoMesh::write(), NEM::MSH::exoGeoMesh::write(), NEM::MSH::oshGeoMesh::write(), and vtkMesh::write().

                                            {
   std::string::size_type last = fname.find_last_of('.');
   if (last != std::string::npos) {
     return fname.substr(last);
   } else {
     std::cerr << "Error finding file extension for " << fname << std::endl;
     exit(1);
   }
 }

◆ find_name()

std::string nemAux::find_name ( const std::string & fname )

inline

Definition at line 497 of file AuxiliaryFunctions.H.

                                             {
   std::string::size_type first = fname.find_last_of('/');
   std::string::size_type last = fname.find_last_of('.');
   if (first != std::string::npos && last != std::string::npos) {
     return fname.substr(first + 1, last);
   } else {
     std::cerr << "error finding file extension for " << fname << std::endl;
     exit(1);
   }
 }

◆ findFromStr()

std::string nemAux::findFromStr	(	const std::string &	str,
		const std::string &	ptrn
	)

inline

Definition at line 477 of file AuxiliaryFunctions.H.

Referenced by NEM::MSH::gmshGeoMesh::getVTKTypeFromGmshType().

                                                                    {
   return str.substr(str.find_first_of(ptrn) + 1, std::string::npos);
 }

◆ findToStr()

std::string nemAux::findToStr	(	const std::string &	str,
		const std::string &	ptrn
	)

inline

Definition at line 472 of file AuxiliaryFunctions.H.

Referenced by NEM::MSH::gmshGeoMesh::getVTKTypeFromGmshType().

                                                                  {
   return str.substr(0, str.find_first_of(ptrn));
 }

◆ flatten()

template<typename T >

std::vector< T > nemAux::flatten ( const std::vector< std::vector< T >> & v )

Definition at line 211 of file AuxiliaryFunctions.H.

Referenced by OrderOfAccuracy::computeMeshWithResolution().

                                                        {
   std::size_t size = 0;
   for (const auto &sub : v) size += sub.size();
 
   std::vector<T> result;
   result.reserve(size);
   for (const auto &sub : v) result.insert(result.end(), sub.begin(), sub.end());
   return result;
 }

◆ flip_map()

template<typename A , typename B >

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

Definition at line 529 of file AuxiliaryFunctions.H.

Referenced by ReadDegenerateVTKFile().

                                                     {
   std::multimap<B, A> dst;
   std::transform(src.begin(), src.end(), std::inserter(dst, dst.begin()),
                  flip_pair<A, B>);
   return dst;
 }

◆ flip_pair()

template<typename A , typename B >

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

Definition at line 524 of file AuxiliaryFunctions.H.

                                                 {
   return std::pair<B, A>(p.second, p.first);
 }

◆ fold()

template<typename T >

std::vector< std::vector< T > > nemAux::fold	(	const std::vector< T > &	v,
		int	dim
	)

Definition at line 223 of file AuxiliaryFunctions.H.

                                                              {
   if (v.size() % dim != 0) {
     std::cerr << "Size must be divisible by dim for folding" << std::endl;
     exit(1);
   }
 
   std::vector<std::vector<T>> result(v.size() / dim);
   for (std::size_t i = 0; i < result.size(); ++i) {
     result[i].resize(dim);
     for (std::size_t j = 0; j < dim; ++j) result[i][j] = v[i * dim + j];
   }
   return result;
 }

◆ getMeanStdev()

template<typename T >

std::vector< T > nemAux::getMeanStdev ( const std::vector< T > & x )

Definition at line 388 of file AuxiliaryFunctions.H.

Referenced by NEM::ADP::SizeFieldBase::mutateValues().

                                                  {
   T ave = 0;
   for (const auto &i : x) ave += i;
   ave /= x.size();
 
   T stdev = 0;
   for (const auto &i : x) stdev += (i - ave) * (i - ave);
   stdev = std::sqrt(stdev / x.size());
 
   return {ave, stdev};
 }

◆ getMinMax()

template<typename T >

std::vector< T > nemAux::getMinMax ( const std::vector< T > & x )

Definition at line 358 of file AuxiliaryFunctions.H.

Referenced by NEM::ADP::SizeFieldBase::mutateValues().

                                               {
   std::vector<T> tmp;
   for (std::size_t i = 0; i < x.size(); ++i)
     if (!std::isinf(x[i]))  // exclude inf
       tmp.push_back(x[i]);
 
   auto minmax = std::minmax_element(tmp.begin(), tmp.end());
 
   return {*minmax.first, *minmax.second};
 }

◆ getRandomString()

std::string nemAux::getRandomString ( int length )

inline

Definition at line 556 of file AuxiliaryFunctions.H.

Referenced by NEM::MSH::foamGeoMesh::foam2GM(), NEM::MSH::inpGeoMesh::inp2GM(), NEM::MSH::geoMeshBase::reconstructGeo(), NEM::MSH::gmshGeoMesh::resetNative(), and NEM::MSH::vtkGeoMesh::vtk2GM().

                                       {
   const char *alp = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
   std::random_device rd;
   std::default_random_engine dre(rd());
   std::uniform_int_distribution<int> uid(0, strlen(alp) - 1);
 
   std::string out;
   for (int i = 0; i < length; ++i) out += alp[uid(dre)];
 
   return out;
 }

◆ getSortedKeys()

template<typename A , typename B >

std::vector< A > nemAux::getSortedKeys ( const std::map< A, B > & mapObj )

Definition at line 544 of file AuxiliaryFunctions.H.

                                                        {
   if (!mapObj.empty()) {
     std::vector<A> sortedKeys(mapObj.size());
     for (const auto &i : mapObj) sortedKeys.emplace_back(i.first);
     return sortedKeys;
   } else {
     std::cerr << "Map is empty! No sorted keys to return." << std::endl;
     exit(1);
   }
 }

◆ getTimeStr()

std::string nemAux::getTimeStr ( )

inline

Definition at line 482 of file AuxiliaryFunctions.H.

                        {
   time_t rawTime;
   struct tm *timeInfo;
   char buffer[80];
 
   time(&rawTime);
   timeInfo = localtime(&rawTime);
 
   strftime(buffer, sizeof(buffer), "%d-%m-%Y %I:%M:%S %p", timeInfo);
   std::string str(buffer);
 
   return str;
 }

◆ hadamard()

template<typename T >

std::vector< T > nemAux::hadamard	(	const std::vector< T > &	x,
		const std::vector< T > &	y
	)

Definition at line 281 of file AuxiliaryFunctions.H.

                                                                     {
   if (x.size() != y.size()) {
     std::cerr << "Vectors must be same length for Hadamard product"
               << std::endl;
     exit(1);
   }
 
   std::vector<T> result(x.size());
   for (std::size_t i = 0; i < x.size(); ++i) result[i] = x[i] * y[i];
   return result;
 }

◆ hasZero()

template<typename T >

bool nemAux::hasZero ( const std::vector< T > & x )

Definition at line 350 of file AuxiliaryFunctions.H.

Referenced by NEM::ADP::SizeFieldBase::mutateValues().

                                     {
   for (const auto &i : x)
     if (i == 0) return true;
   return false;
 }

◆ isInBBox()

template<typename T >

bool nemAux::isInBBox	(	const std::vector< T > &	crd,
		const std::vector< T > &	bb
	)

Definition at line 537 of file AuxiliaryFunctions.H.

Referenced by meshSrch::FindCellsWithinBounds().

                                                                {
   for (std::size_t i = 0; i < crd.size(); ++i)
     if (crd[i] < bb[2 * i] || crd[i] > bb[2 * i + 1]) return false;
   return true;
 }

◆ l2_Norm()

template<typename T >

T nemAux::l2_Norm ( const std::vector< T > & x )

Definition at line 239 of file AuxiliaryFunctions.H.

Referenced by NEM::ADP::GradSizeField::computeL2GradAtAllCells(), NEM::ADP::ValSizeField::computeL2ValAtAllCells(), FETransfer::transferCellData(), COBALT::cobalt::write(), and PATRAN::patran::write6().

                                  {
   T result = 0.0;
   for (const auto &i : x) result += i * i;
 
   return std::sqrt(result);
 }

◆ leastUnusedKey()

template<typename A , typename B >

A nemAux::leastUnusedKey	(	const std::map< A, B > &	map,
		A	min = `1`
	)

Definition at line 569 of file AuxiliaryFunctions.H.

Referenced by NEM::MSH::exoGeoMesh::addElemBlock(), NEM::MSH::exoGeoMesh::addNodeSet(), NEM::MSH::exoGeoMesh::addSideSet(), NEM::MSH::exoGeoMesh::reassignCells(), NEM::MSH::exoGeoMesh::resetElemBlocks(), and NEM::MSH::exoGeoMesh::stitch().

                                                  {
   A i = min;
   auto it = map.begin();
   if (min > 1) {
     auto ub = map.upper_bound(min);
     if (ub != it) {
       it = --ub;
     }
   }
   for (; it != map.end(); ++it) {
     if (it->first == i) {
       ++i;
     } else {
       return i;
     }
   }
   return i;
 }

◆ operator*()

template<typename T >

std::vector< T > nemAux::operator*	(	T	a,
		const std::vector< T > &	x
	)

Definition at line 274 of file AuxiliaryFunctions.H.

                                                    {
   std::vector<T> result(x.size());
   for (std::size_t i = 0; i < x.size(); ++i) result[i] = a * x[i];
   return result;
 }

◆ operator+()

template<typename T >

std::vector< T > nemAux::operator+	(	const std::vector< T > &	x,
		const std::vector< T > &	y
	)

Definition at line 248 of file AuxiliaryFunctions.H.

                                                                      {
   if (x.size() != y.size()) {
     std::cerr << "Vectors must be same length for addition" << std::endl;
     exit(1);
   }
 
   std::vector<T> result(x.size());
   for (std::size_t i = 0; i < x.size(); ++i) result[i] = x[i] + y[i];
   return result;
 }

◆ operator-()

template<typename T >

std::vector< T > nemAux::operator-	(	const std::vector< T > &	x,
		const std::vector< T > &	y
	)

Definition at line 261 of file AuxiliaryFunctions.H.

                                                                      {
   if (x.size() != y.size()) {
     std::cerr << "Vectors must be same length for subtraction" << std::endl;
     exit(1);
   }
 
   std::vector<T> result(x.size());
   for (std::size_t i = 0; i < x.size(); ++i) result[i] = x[i] - y[i];
   return result;
 }

◆ printVec()

template<typename T >

void nemAux::printVec ( const std::vector< T > & v )

Definition at line 510 of file AuxiliaryFunctions.H.

Referenced by orthoPoly3D::computeA(), and orthoPoly3D::orthoPoly3D().

                                      {
   for (const auto &i : v) std::cout << std::setprecision(15) << i << " ";
   std::cout << std::endl;
 }

◆ reciprocal()

template<typename T >

T nemAux::reciprocal ( T x )

Definition at line 295 of file AuxiliaryFunctions.H.

                   {
   return 1 / x;
 }

◆ reciprocal_vec()

template<typename T >

void nemAux::reciprocal_vec ( std::vector< T > & x )

Definition at line 345 of file AuxiliaryFunctions.H.

Referenced by NEM::ADP::SizeFieldBase::mutateValues().

                                      {
   std::transform(x.begin(), x.end(), x.begin(), reciprocal<T>);
 }

◆ scale_to_range()

template<typename T >

T nemAux::scale_to_range	(	T	x,
		const std::vector< T > &	xminmax,
		const std::vector< T > &	yminmax
	)

Definition at line 372 of file AuxiliaryFunctions.H.

Referenced by scale_vec_to_range().

                                               {
   if (std::isinf(x)) return yminmax[1];
   return yminmax[0] + (yminmax[1] - yminmax[0]) * (x - xminmax[0]) /
                           (xminmax[1] - xminmax[0]);
 }

◆ scale_vec_to_range()

template<typename T >

void nemAux::scale_vec_to_range	(	std::vector< T > &	x,
		const std::vector< T > &	xminmax,
		const std::vector< T > &	yminmax
	)

Definition at line 381 of file AuxiliaryFunctions.H.

References scale_to_range().

Referenced by NEM::ADP::SizeFieldBase::mutateValues().

                                                      {
   for (auto &&i : x) i = scale_to_range(i, xminmax, yminmax);
 }

◆ strToChar()

std::shared_ptr< char > nemAux::strToChar ( const std::string & strng )

inline

Definition at line 300 of file AuxiliaryFunctions.H.

Referenced by Foam::AMRFoam::readIncomingCellField(), Foam::AMRFoam::readIncomingPtField(), and NEM::GEO::rocPack::rocParser().

                                                       {
   std::shared_ptr<char> tab(new char[strng.length() + 1],
                             std::default_delete<char[]>());
   std::strcpy(tab.get(), strng.c_str());
   return tab;
 }

◆ Tokenize() [1/2]

std::vector< std::string > nemAux::Tokenize	(	const std::string &	lineIn,
		const char &	delim
	)

inline

Definition at line 308 of file AuxiliaryFunctions.H.

Referenced by NEM::GEO::rocPack::getShapeData(), and NEM::GEO::rocPack::rocParser().

                                                      {
   std::vector<std::string> rtrnTokens;
 
   std::string intermediate;
   std::stringstream checkStr(lineIn);
 
   // Tokenizing
   while (std::getline(checkStr, intermediate, delim)) {
     rtrnTokens.push_back(intermediate);
   }
   return rtrnTokens;
 }

◆ Tokenize() [2/2]

std::vector< std::string > nemAux::Tokenize	(	const std::string &	lineIn,
		const std::string &	delim
	)

inline

Definition at line 323 of file AuxiliaryFunctions.H.

                                                           {
   std::vector<std::string> rtrnTokens;
   std::vector<char> delimStr;
   delimStr.reserve(delim.size());
 
   for (int i = 0; i < delim.size(); i++) delimStr.push_back(delim[i]);
 
   std::string intermediate;
   std::stringstream checkStr(lineIn);
 
   // Tokenizing
   int iter = 0;
   while (std::getline(checkStr, intermediate, delimStr[iter])) {
     rtrnTokens.push_back(intermediate);
     iter++;
   }
   return rtrnTokens;
 }

◆ toLower()

void nemAux::toLower ( std::string & str )

inline

Definition at line 462 of file AuxiliaryFunctions.H.

Referenced by NEM::MSH::EXOMesh::bcTagNum(), PNTMesh::bcTagNum(), PNTMesh::elmTypeNum(), NEM::MSH::EXOMesh::elmTypeNum(), NEM::DRV::InputGenDriver::execute(), inputGen::pushOrder(), NEM::GEO::rocPack::rocParser(), and inputGen::setOrder().

                              {
   std::transform(str.begin(), str.end(), str.begin(), ::tolower);
 }

◆ toUpper()

void nemAux::toUpper ( std::string & str )

inline

Definition at line 467 of file AuxiliaryFunctions.H.

                              {
   std::transform(str.begin(), str.end(), str.begin(), ::toupper);
 }

◆ trim_fname()

std::string nemAux::trim_fname	(	const std::string &	name,
		const std::string &	ext
	)

inline

Definition at line 440 of file AuxiliaryFunctions.H.

Referenced by MeshQuality::checkMesh(), NEM::GEN::gmshGen::createMeshFromSTEP(), netgenGen::createMeshFromSTL(), NEM::DRV::CFMeshMeshGenDriver::execute(), NEM::DRV::GmshMeshGenDriver::execute(), NEM::DRV::SnappyMeshMeshGenDriver::execute(), NEM::DRV::NetgenMeshGenDriver::execute(), meshBase::exportPntToVtk(), meshBase::exportVolToVtk(), meshStitcher::initSurfCgObj(), meshStitcher::initVolCgObj(), NEM::DRV::MeshGenDriver::MeshGenDriver(), meshBase::partition(), and vtkMesh::write().

                                                                    {
   std::string::size_type end = fname.find_last_of('.');
   if (end != std::string::npos) {
     return fname.substr(0, end).append(ext);
   } else {
     std::cerr << "Error finding file extension for " << fname << std::endl;
     exit(1);
   }
 }

◆ valInVec()

template<typename T >

bool nemAux::valInVec	(	const std::vector< T > &	v,
		T	val
	)

Definition at line 517 of file AuxiliaryFunctions.H.

                                             {
   for (const auto &i : v)
     if (i == val) return true;
   return false;
 }

Classes

Functions

Function Documentation

◆ cellsToRefine()

◆ cellsToRefineMaxdev()

◆ cellsToRefineStdev()

◆ find_ext()

◆ find_name()

◆ findFromStr()

◆ findToStr()

◆ flatten()

◆ flip_map()

◆ flip_pair()

◆ fold()

◆ getMeanStdev()

◆ getMinMax()

◆ getRandomString()

◆ getSortedKeys()

◆ getTimeStr()

◆ hadamard()

◆ hasZero()

◆ isInBBox()

◆ l2_Norm()

◆ leastUnusedKey()

◆ operator*()

◆ operator+()

◆ operator-()

◆ printVec()

◆ reciprocal()

◆ reciprocal_vec()

◆ scale_to_range()

◆ scale_vec_to_range()

◆ strToChar()

◆ Tokenize() [1/2]

◆ Tokenize() [2/2]

◆ toLower()

◆ toUpper()

◆ trim_fname()

◆ valInVec()