MooseUtils Namespace Reference

Classes
struct	AnyType
	Comparison helpers that support the MooseUtils::Any wildcard which will match any value. More...
class	Buffer
	Base class for a buffer. More...
struct	canBroadcast
	Custom type trait that has a value of true for types that can be broadcasted. More...
class	CircularBuffer
	An optimized circular buffer. More...
class	DelimitedFileReaderTempl
	Utility class for reading delimited data (e.g., CSV data). More...
class	Has_size
	Taken from https://stackoverflow.com/a/257382 Evaluating constexpr (Has_size<T>::value) in a templated method over class T will return whether T is a standard container or a singleton. More...
struct	IsLikeReal
	Custom type trait that has a value of true for types that cam be use interchangeably with Real. More...
struct	IsLikeReal< ADReal >
struct	IsLikeReal< Real >
class	LIFOBuffer
	An optimized LIFO (Last In First Out) buffer. More...
class	SemidynamicVector
	Utility class template for a semidynamic vector with a maximum size N and a chosen dynamic size. More...
class	SharedPool
	Originally From https://stackoverflow.com/a/27837534/2042320. More...
class	StaticallyAllocatedSet
	Optimized set with static allocation. More...

Typedefs
typedef DelimitedFileReaderTempl< double >	DelimitedFileReader
typedef DelimitedFileReaderTempl< std::string >	DelimitedFileOfStringReader

Functions
std::string	trim (const std::string &str, const std::string &white_space=" \\\)
	Standard scripting language trim function. More...
template<typename T >
void	tokenize (const std::string &str, std::vector< T > &elements, unsigned int min_len=1, const std::string &delims="/")
	This function will split the passed in string on a set of delimiters appending the substrings to the passed in vector. More...
template<class T >
bool	convert (const std::string &str, T &value, const bool throw_on_failure)
	Takes the string representation of a value and converts it to the value. More...
template<typename T >
bool	tokenizeAndConvert (const std::string &str, std::vector< T > &tokenized_vector, const std::string &delimiter=" \\\)
	tokenizeAndConvert splits a string using delimiter and then converts to type T. More...
std::string	toUpper (std::string name)
	Convert supplied string to upper case. More...
std::string	toLower (std::string name)
	Convert supplied string to lower case. More...
std::filesystem::path	pathjoin (const std::filesystem::path &p)
template<typename... Args>
std::filesystem::path	pathjoin (const std::filesystem::path &p, Args... args)
bool	parsesToReal (const std::string &input, Real *parsed_real=nullptr)
	Check if the input string can be parsed into a Real. More...
std::string	runTestsExecutable ()
	Returns the location of either a local repo run_tests script - or an installed test executor script if run_tests isn't found. More...
std::string	findTestRoot ()
	Searches in the current working directory and then recursively up in each parent directory looking for a "testroot" file. More...
std::string	installedInputsDir (const std::string &app_name, const std::string &dir_name, const std::string &extra_error_msg="")
	Returns the directory of any installed inputs or the empty string if none are found. More...
std::string	docsDir (const std::string &app_name)
	Returns the directory of any installed docs/site. More...
std::string	mooseDocsURL (const std::string &path)
	Returns the URL of a page located on the MOOSE documentation site. More...
std::string	replaceAll (std::string str, const std::string &from, const std::string &to)
	Replaces all occurrences of from in str with to and returns the result. More...
std::string	convertLatestCheckpoint (std::string orig)
	Replaces "LATEST" placeholders with the latest checkpoint file name. More...
int	levenshteinDist (const std::string &s1, const std::string &s2)
	Computes and returns the Levenshtein distance between strings s1 and s2. More...
void	escape (std::string &str)
	This function will escape all of the standard C++ escape characters so that they can be printed. More...
std::string	removeExtraWhitespace (const std::string &str)
	Removes additional whitespace from a string. More...
std::vector< std::string >	split (const std::string &str, const std::string &delimiter, std::size_t max_count=std::numeric_limits< std::size_t >::max())
	Python like split functions for strings. More...
std::vector< std::string >	rsplit (const std::string &str, const std::string &delimiter, std::size_t max_count=std::numeric_limits< std::size_t >::max())
template<typename Iterator >
std::string	join (Iterator begin, Iterator end, const std::string &delimiter)
	Python-like join function for strings over an iterator range. More...
template<typename T >
std::string	join (const T &strings, const std::string &delimiter)
	Python-like join function for strings over a container. More...
std::size_t	fileSize (const std::string &filename)
	Check the file size. More...
bool	pathContains (const std::string &expression, const std::string &string_to_find, const std::string &delims="/")
	This function tokenizes a path and checks to see if it contains the string to look for. More...
bool	checkFileReadable (const std::string &filename, bool check_line_endings=false, bool throw_on_unreadable=true, bool check_for_git_lfs_pointer=true)
	Checks to see if a file is readable (exists and permissions) More...
bool	checkFileWriteable (const std::string &filename, bool throw_on_unwritable=true)
	Check if the file is writable (path exists and permissions) More...
bool	checkForGitLFSPointer (std::ifstream &file)
	Check if the file is a Git-LFS pointer. More...
void	parallelBarrierNotify (const libMesh::Parallel::Communicator &comm, bool messaging=true)
	This function implements a parallel barrier function but writes progress to stdout. More...
void	serialBegin (const libMesh::Parallel::Communicator &comm, bool warn=true)
	This function marks the begin of a section of code that is executed in serial rank by rank. More...
void	serialEnd (const libMesh::Parallel::Communicator &comm, bool warn=true)
	Closes a section of code that is executed in serial rank by rank, and that was opened with a call to serialBegin. More...
bool	hasExtension (const std::string &filename, std::string ext, bool strip_exodus_ext=false)
	Function tests if the supplied filename as the desired extension. More...
std::string	getExtension (const std::string &filename, const bool rfind=false)
	Gets the extension of the passed file name. More...
std::string	stripExtension (const std::string &s, const bool rfind=false)
	Removes any file extension from the given string s (i.e. More...
template<typename T >
std::pair< std::filesystem::path, std::filesystem::path >	splitFileName (const T &full_file)
	Function for splitting path and filename. More...
std::string	getCurrentWorkingDir ()
	Returns the current working directory as a string. More...
void	makedirs (const std::string &dir_name, bool throw_on_failure=false)
	Recursively make directories. More...
void	removedirs (const std::string &dir_name, bool throw_on_failure=false)
	Recursively remove directories from inner-most when the directories are empty. More...
std::string	camelCaseToUnderscore (const std::string &camel_case_name)
	Function for converting a camel case name to a name containing underscores. More...
std::string	underscoreToCamelCase (const std::string &underscore_name, bool leading_upper_case)
	Function for converting an underscore name to a camel case name. More...
std::string	shortName (const std::string &name)
	Function for stripping name after the file / in parser block. More...
std::string	baseName (const std::string &name)
	Function for string the information before the final / in a parser block. More...
std::string	hostname ()
	Get the hostname the current process is running on. More...
unsigned short	getTermWidth (bool use_environment)
	Returns the width of the terminal using sys/ioctl. More...
std::string	prettyCppType (const std::string &cpp_type)
template<typename T >
std::string	prettyCppType (const T *obj=nullptr)
template<typename T1 , typename T2 >
bool	doesMapContainValue (const std::map< T1, T2 > &the_map, const T2 &value)
	This routine is a simple helper function for searching a map by values instead of keys. More...
template<typename T , typename T2 , typename T3 = T, typename std::enable_if< libMesh::ScalarTraits< T >::value &&libMesh::ScalarTraits< T2 >::value &&libMesh::ScalarTraits< T3 >::value, int >::type = 0>
bool	absoluteFuzzyEqual (const T &var1, const T2 &var2, const T3 &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
	Function to check whether two variables are equal within an absolute tolerance. More...
template<typename T , typename T2 , typename T3 = T, typename std::enable_if< libMesh::ScalarTraits< T >::value &&libMesh::ScalarTraits< T2 >::value &&libMesh::ScalarTraits< T3 >::value, int >::type = 0>
bool	absoluteFuzzyGreaterEqual (const T &var1, const T2 &var2, const T3 &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
	Function to check whether a variable is greater than or equal to another variable within an absolute tolerance. More...
template<typename T , typename T2 , typename T3 = T, typename std::enable_if< libMesh::ScalarTraits< T >::value &&libMesh::ScalarTraits< T2 >::value &&libMesh::ScalarTraits< T3 >::value, int >::type = 0>
bool	absoluteFuzzyGreaterThan (const T &var1, const T2 &var2, const T3 &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
	Function to check whether a variable is greater than another variable within an absolute tolerance. More...
template<typename T , typename T2 , typename T3 = T, typename std::enable_if< libMesh::ScalarTraits< T >::value &&libMesh::ScalarTraits< T2 >::value &&libMesh::ScalarTraits< T3 >::value, int >::type = 0>
bool	absoluteFuzzyLessEqual (const T &var1, const T2 &var2, const T3 &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
	Function to check whether a variable is less than or equal to another variable within an absolute tolerance. More...
template<typename T , typename T2 , typename T3 = T, typename std::enable_if< libMesh::ScalarTraits< T >::value &&libMesh::ScalarTraits< T2 >::value &&libMesh::ScalarTraits< T3 >::value, int >::type = 0>
bool	absoluteFuzzyLessThan (const T &var1, const T2 &var2, const T3 &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
	Function to check whether a variable is less than another variable within an absolute tolerance. More...
template<typename T , typename T2 , typename T3 = Real>
bool	relativeFuzzyEqual (const T &var1, const T2 &var2, const T3 &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
	Function to check whether two variables are equal within a relative tolerance. More...
template<typename T , typename T2 , typename T3 = T, typename std::enable_if< libMesh::ScalarTraits< T >::value &&libMesh::ScalarTraits< T2 >::value &&libMesh::ScalarTraits< T3 >::value, int >::type = 0>
bool	relativeFuzzyGreaterEqual (const T &var1, const T2 &var2, const T3 &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
	Function to check whether a variable is greater than or equal to another variable within a relative tolerance. More...
template<typename T , typename T2 , typename T3 = T, typename std::enable_if< libMesh::ScalarTraits< T >::value &&libMesh::ScalarTraits< T2 >::value &&libMesh::ScalarTraits< T3 >::value, int >::type = 0>
bool	relativeFuzzyGreaterThan (const T &var1, const T2 &var2, const T3 &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
	Function to check whether a variable is greater than another variable within a relative tolerance. More...
template<typename T , typename T2 , typename T3 = T, typename std::enable_if< libMesh::ScalarTraits< T >::value &&libMesh::ScalarTraits< T2 >::value &&libMesh::ScalarTraits< T3 >::value, int >::type = 0>
bool	relativeFuzzyLessEqual (const T &var1, const T2 &var2, const T3 &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
	Function to check whether a variable is less than or equal to another variable within a relative tolerance. More...
template<typename T , typename T2 , typename T3 = T, typename std::enable_if< libMesh::ScalarTraits< T >::value &&libMesh::ScalarTraits< T2 >::value &&libMesh::ScalarTraits< T3 >::value, int >::type = 0>
bool	relativeFuzzyLessThan (const T &var1, const T2 &var2, const T3 &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
	Function to check whether a variable is less than another variable within a relative tolerance. More...
template<typename T >
void	getUnion (const std::vector< T > &vector1, const std::vector< T > &vector2, std::vector< T > &common)
	Function which takes the union of vector1 and vector2 and copies them to common . More...
template<typename T >
bool	isZero (const T &value, const Real tolerance=TOLERANCE *TOLERANCE *TOLERANCE)
void	MaterialPropertyStorageDump (const HashMap< const libMesh::Elem *, HashMap< unsigned int, MaterialProperties >> &props)
	Function to dump the contents of MaterialPropertyStorage for debugging purposes. More...
void	indentMessage (const std::string &prefix, std::string &message, const char *color=COLOR_CYAN, bool dont_indent_first_line=true, const std::string &post_prefix=": ")
	Indents the supplied message given the prefix and color. More...
std::string &	removeColor (std::string &msg)
	remove ANSI escape sequences for terminal color from msg More...
std::list< std::string >	listDir (const std::string path, bool files_only=false)
bool	pathExists (const std::string &path)
std::list< std::string >	getFilesInDirs (const std::list< std::string > &directory_list, const bool files_only=true)
	Retrieves the names of all of the files contained within the list of directories passed into the routine. More...
std::string	getLatestCheckpointFilePrefix (const std::list< std::string > &checkpoint_files)
	Returns the most recent checkpoint prefix (the four numbers at the beginning) If a suitable file isn't found the empty string is returned. More...
bool	wildCardMatch (std::string name, std::string search_string)
bool	globCompare (const std::string &candidate, const std::string &pattern, std::size_t c=0, std::size_t p=0)
template<typename T >
void	expandAllMatches (const std::vector< T > &candidates, std::vector< T > &patterns)
template<typename T >
T	convert (const std::string &str, bool throw_on_failure=false)
	Takes the string representation of a value and converts it to the value. More...
void	createSymlink (const std::string &target, const std::string &link)
	Create a symbolic link, if the link already exists it is replaced. More...
void	clearSymlink (const std::string &link)
	Remove a symbolic link, if the given filename is a link. More...
template<typename T >
T	concatenate (T c1, const T &c2)
	Returns a container that contains the content of second passed in container inserted into the first passed in container (set or map union). More...
template<typename T >
std::vector< T >	concatenate (std::vector< T > c1, const std::vector< T > &c2)
	Returns a vector that contains is the concatenation of the two passed in vectors. More...
template<typename T >
std::vector< T >	concatenate (std::vector< T > c1, const T &item)
	Returns the passed in vector with the item appended to it. More...
std::string	stringJoin (const std::vector< std::string > &values, const std::string &separator=" ")
	Concatenates value into a single string separated by separator. More...
bool	beginsWith (const std::string &value, const std::string &begin_value)
template<typename T >
int	numDigits (const T &num)
	Return the number of digits for a number. More...
ExecFlagEnum	getDefaultExecFlagEnum ()
	Return the default ExecFlagEnum for MOOSE. More...
int	stringToInteger (const std::string &input, bool throw_on_failure=false)
	Robust string to integer conversion that fails for cases such at "1foo". More...
void	linearPartitionItems (dof_id_type num_items, dof_id_type num_chunks, dof_id_type chunk_id, dof_id_type &num_local_items, dof_id_type &local_items_begin, dof_id_type &local_items_end)
	Linearly partition a number of items. More...
processor_id_type	linearPartitionChunk (dof_id_type num_items, dof_id_type num_chunks, dof_id_type item_id)
	Return the chunk_id that is assigned to handle item_id. More...
std::string	realpath (const std::string &path)
	Wrapper around PetscGetRealPath, which is a cross-platform replacement for realpath. More...
template<typename C , typename It , typename M1 , typename M2 >
auto	findPair (C &container, It start_iterator, const M1 &first, const M2 &second)
	Find a specific pair in a container matching on first, second or both pair components. More...
libMesh::BoundingBox	buildBoundingBox (const Point &p1, const Point &p2)
	Construct a valid bounding box from 2 arbitrary points. More...
template<typename T >
T *	get (const std::unique_ptr< T > &u)
	The MooseUtils::get() specializations are used to support making forwards-compatible code changes from dumb pointers to smart pointers. More...
template<typename T >
T *	get (T *p)
template<typename T >
T *	get (const std::shared_ptr< T > &s)
template<class InputIterator >
bool	setsIntersect (InputIterator first1, InputIterator last1, InputIterator first2, InputIterator last2)
	This method detects whether two sets intersect without building a result set. More...
template<class T >
bool	setsIntersect (const T &s1, const T &s2)
bool	isDigits (const std::string &str)
	Courtesy https://stackoverflow.com/a/8889045 and https://en.cppreference.com/w/cpp/string/byte/isdigit. More...
bool	isFloat (const std::string &str)
	Courtesy https://stackoverflow.com/a/57163016 and https://stackoverflow.com/questions/447206/c-isfloat-function. More...
std::string	canonicalPath (const std::string &path)
	Gets the canonical path of the given path. More...
bool	startsWith (const std::string &string1, const std::string &string2)
void	replaceStart (std::string &string1, const std::string &string2, const std::string &string3)
	Replace the starting string string2 of string1 with string3. More...
bool	isAllLowercase (const std::string &str)
template<class T , typename... Args>
auto	reset (int, T &obj, Args... args) -> decltype(obj.reset(args...), void())
template<class T , typename... Args>
void	reset (double, T &, Args...)
void	addLineBreaks (std::string &message, unsigned int line_width)
template<typename T >
void	swap (std::vector< T > &data, const std::size_t idx0, const std::size_t idx1, const libMesh::Parallel::Communicator &comm)
	Swap function for serial or distributed vector of data. More...
template<typename T >
void	swap (std::vector< T > &data, const std::size_t idx0, const std::size_t idx1, const libMesh::Parallel::Communicator *comm_ptr=nullptr)
template<typename T >
void	shuffle (std::vector< T > &data, MooseRandom &generator, const std::size_t seed_index=0)
	Shuffle function for serial or distributed vector of data that shuffles in place. More...
template<typename T >
void	shuffle (std::vector< T > &data, MooseRandom &generator, const libMesh::Parallel::Communicator &comm)
template<typename T >
void	shuffle (std::vector< T > &data, MooseRandom &generator, const std::size_t seed_index, const libMesh::Parallel::Communicator &comm)
template<typename T >
void	shuffle (std::vector< T > &data, MooseRandom &generator, const std::size_t seed_index, const libMesh::Parallel::Communicator *comm_ptr)
template<typename T >
std::vector< T >	resample (const std::vector< T > &data, MooseRandom &generator, const std::size_t seed_index=0)
	Randomly resample a vector of data, allowing a value to be repeated. More...
template<typename T >
std::vector< T >	resample (const std::vector< T > &data, MooseRandom &generator, const libMesh::Parallel::Communicator &comm)
template<typename T >
std::vector< T >	resample (const std::vector< T > &data, MooseRandom &generator, const std::size_t seed_index, const libMesh::Parallel::Communicator &comm)
template<typename T >
std::vector< T >	resample (const std::vector< T > &data, MooseRandom &generator, const std::size_t seed_index, const libMesh::Parallel::Communicator *comm_ptr)
template<typename T , typename ActionFunctor >
void	resampleWithFunctor (const std::vector< T > &data, const ActionFunctor &functor, MooseRandom &generator, const std::size_t seed_index=0)
	Randomly resample a vector of data and apply a functor, allowing a value to be repeated. More...
template<typename T , typename ActionFunctor >
void	resampleWithFunctor (const std::vector< T > &data, const ActionFunctor &functor, MooseRandom &generator, const libMesh::Parallel::Communicator &comm)
template<typename T , typename ActionFunctor >
void	resampleWithFunctor (const std::vector< T > &data, const ActionFunctor &functor, MooseRandom &generator, const std::size_t seed_index, const libMesh::Parallel::Communicator &comm)
template<typename T , typename ActionFunctor >
void	resampleWithFunctor (const std::vector< T > &data, const ActionFunctor &functor, MooseRandom &generator, const std::size_t seed_index, const libMesh::Parallel::Communicator *comm_ptr)
static const struct MooseUtils::AnyType	Any
template<typename T1 , typename T2 >
bool	wildcardEqual (const T1 &a, const T2 &b)
template<typename T >
bool	wildcardEqual (const T &, AnyType)
template<typename T >
bool	wildcardEqual (AnyType, const T &)

Typedef Documentation

DelimitedFileOfStringReader

typedef DelimitedFileReaderTempl<std::string> MooseUtils::DelimitedFileOfStringReader

Definition at line 201 of file DelimitedFileReader.h.

DelimitedFileReader

typedef DelimitedFileReaderTempl<double> MooseUtils::DelimitedFileReader

Definition at line 200 of file DelimitedFileReader.h.

Function Documentation

absoluteFuzzyEqual()

template<typename T , typename T2 , typename T3 = T, typename std::enable_if< libMesh::ScalarTraits< T >::value &&libMesh::ScalarTraits< T2 >::value &&libMesh::ScalarTraits< T3 >::value, int >::type = 0>

bool MooseUtils::absoluteFuzzyEqual	(	const T &	var1,
		const T2 &	var2,
		const T3 &	tol = libMesh::TOLERANCE * libMesh::TOLERANCE
	)

Function to check whether two variables are equal within an absolute tolerance.

Parameters

var1	The first variable to be checked
var2	The second variable to be checked
tol	The tolerance to be used

Returns

true if var1 and var2 are equal within tol

Definition at line 382 of file MooseUtils.h.

Referenced by MultiAppGeneralFieldTransfer::acceptPointInOriginMesh(), FormattedTable::addData(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), MultiAppGeneralFieldTransfer::cacheIncomingInterpVals(), CartesianGridDivision::CartesianGridDivision(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonPlanarSides(), CircularBoundaryCorrectionGenerator::circularCenterCalculator(), MultiAppGeneralFieldTransfer::closestToPosition(), CSG::CSGPlane::coeffsFromPoints(), ComparisonPostprocessor::comparisonIsTrue(), VariableCondensationPreconditioner::computeDInverseDiag(), ThresholdElementSubdomainModifier::computeSubdomainID(), TimesEnableControl::conditionMet(), ParsedConvergence::convertRealToBool(), CylindricalGridDivision::CylindricalGridDivision(), MultiAppGeneralFieldTransfer::detectConflict(), SphericalGridDivision::divisionIndex(), CartesianGridDivision::divisionIndex(), CylindricalGridDivision::divisionIndex(), MultiAppGeneralFieldNearestLocationTransfer::evaluateInterpValuesNearestNode(), MultiAppGeneralFieldTransfer::examineLocalValueConflicts(), MultiAppGeneralFieldTransfer::examineReceivedValueConflicts(), PIDChainControl::execute(), RealToBoolChainControl::execute(), SmootherChainControl::execute(), MatrixSymmetryCheck::execute(), PointValue::execute(), FindValueOnLine::execute(), FillBetweenPointVectorsTools::fillBetweenPointVectorsGenerator(), MeshDivisionFunctorReductionVectorPostprocessor::finalize(), Moose::findContactPoint(), BicubicInterpolation::findInterval(), MeshRepairGenerator::fixOverlappingNodes(), Boundary2DDelaunayGenerator::General2DDelaunay(), AdvancedExtruderGenerator::generate(), CircularBoundaryCorrectionGenerator::generate(), ParsedCurveGenerator::generate(), CircularBoundaryCorrectionGenerator::generateRadialCorrectionFactor(), FunctorBinnedValuesDivision::getBinIndex(), TransfiniteMeshGenerator::getEdge(), MultiAppGeneralFieldTransfer::getRestrictedFromBoundingBoxes(), AverageVariableChange::getValue(), SideAverageValue::getValue(), RelativeDifferencePostprocessor::getValue(), LineValueSampler::getValue(), Moose::FV::greenGaussGradient(), MooseAppCoordTransform::hasScalingOrRotationTransformation(), AutomaticMortarGeneration::householderOrthogolization(), ElementGroupCentroidPositions::initialize(), MooseVariableBase::initialSetup(), LinearInterpolation::integratePartial(), MooseMeshUtils::isCoPlanar(), ActivateElementsCoupled::isElementActivated(), MultiAppCoordTransform::isIdentity(), RankTwoTensorTempl< Real >::isSymmetric(), isZero(), MooseMeshXYCuttingUtils::lineRemoverCutElemTri(), MooseMeshXYCuttingUtils::lineRemoverMoveNode(), LineValueSampler::LineValueSampler(), FillBetweenPointVectorsTools::needFlip(), CutMeshByLevelSetGeneratorBase::nonDuplicateNodeCreator(), EigenExecutionerBase::normalizeSolution(), MultiAppCoordTransform::operator()(), RankTwoTensorTempl< Real >::operator==(), TableOutput::outputReporter(), FixedPointSolve::performingRelaxation(), PointIndexedMap::PointIndexedMap(), CutMeshByLevelSetGeneratorBase::pointPairLevelSetInterception(), RankTwoTensorTempl< Real >::positiveProjectionEigenDecomposition(), EigenExecutionerBase::postExecute(), EigenProblem::preScaleEigenVector(), MooseMeshXYCuttingUtils::quasiTriElementsFixer(), CoarsenBlockGenerator::recursiveCoarsen(), relativeFuzzyEqual(), BicubicInterpolation::sample2ndDerivative(), BicubicInterpolation::sampleDerivative(), BicubicInterpolation::sampleValueAndDerivativesInternal(), TimeSequenceStepperBase::setupSequence(), Predictor::shouldApply(), TableOutput::shouldOutputPostprocessorsRow(), SphericalGridDivision::SphericalGridDivision(), SymmetryTransformGenerator::SymmetryTransformGenerator(), CutMeshByLevelSetGeneratorBase::tet4ElemCutter(), TimeIntervalTimes::TimeIntervalTimes(), SecantSolve::transformPostprocessors(), SteffensenSolve::transformPostprocessors(), SecantSolve::transformVariables(), SteffensenSolve::transformVariables(), MooseMeshXYCuttingUtils::triElemSplitter(), ParsedCurveGenerator::tSectionSpaceDefiner(), PIDChainControl::updateValues(), Axisymmetric2D3DSolutionFunction::value(), and XYMeshLineCutter::XYMeshLineCutter().

{
  return (std::abs(MetaPhysicL::raw_value(var1) - MetaPhysicL::raw_value(var2)) <=
          MetaPhysicL::raw_value(tol));
}

absoluteFuzzyGreaterEqual()

template<typename T , typename T2 , typename T3 = T, typename std::enable_if< libMesh::ScalarTraits< T >::value &&libMesh::ScalarTraits< T2 >::value &&libMesh::ScalarTraits< T3 >::value, int >::type = 0>

bool MooseUtils::absoluteFuzzyGreaterEqual	(	const T &	var1,
		const T2 &	var2,
		const T3 &	tol = libMesh::TOLERANCE * libMesh::TOLERANCE
	)

Function to check whether a variable is greater than or equal to another variable within an absolute tolerance.

Parameters

var1	The first variable to be checked
var2	The second variable to be checked
tol	The tolerance to be used

Returns

true if var1 > var2 or var1 == var2 within tol

Definition at line 406 of file MooseUtils.h.

Referenced by TimeSequenceStepperBase::acceptStep(), ComparisonPostprocessor::comparisonIsTrue(), TimePeriod::conditionMet(), CylindricalGridDivision::divisionIndex(), SphericalGridDivision::divisionIndex(), CartesianGridDivision::divisionIndex(), PlaneIDMeshGenerator::PlaneIDMeshGenerator(), and relativeFuzzyGreaterEqual().

{
  return (MetaPhysicL::raw_value(var1) >=
          (MetaPhysicL::raw_value(var2) - MetaPhysicL::raw_value(tol)));
}

absoluteFuzzyGreaterThan()

template<typename T , typename T2 , typename T3 = T, typename std::enable_if< libMesh::ScalarTraits< T >::value &&libMesh::ScalarTraits< T2 >::value &&libMesh::ScalarTraits< T3 >::value, int >::type = 0>

bool MooseUtils::absoluteFuzzyGreaterThan	(	const T &	var1,
		const T2 &	var2,
		const T3 &	tol = libMesh::TOLERANCE * libMesh::TOLERANCE
	)

Function to check whether a variable is greater than another variable within an absolute tolerance.

Parameters

var1	The first variable to be checked
var2	The second variable to be checked
tol	The tolerance to be used

Returns

true if var1 > var2 and var1 != var2 within tol

Definition at line 430 of file MooseUtils.h.

Referenced by MultiAppGeneralFieldTransfer::cacheIncomingInterpVals(), ComparisonPostprocessor::comparisonIsTrue(), SphericalGridDivision::divisionIndex(), CartesianGridDivision::divisionIndex(), CylindricalGridDivision::divisionIndex(), FillBetweenPointVectorsTools::elementsCreationFromNodesVectors(), CircularBoundaryCorrectionGenerator::generate(), CSG::CSGSurface::getHalfspaceFromPoint(), Times::getNextTime(), Times::getPreviousTime(), SphericalGridDivision::initialize(), CartesianGridDivision::initialize(), CylindricalGridDivision::initialize(), PointReduction::perpendicularDistance(), CutMeshByLevelSetGeneratorBase::pointLevelSetRelation(), CutMeshByLevelSetGeneratorBase::pointPairLevelSetInterception(), CoarsenBlockGenerator::recursiveCoarsen(), relativeFuzzyGreaterThan(), TimeIntervalTimes::TimeIntervalTimes(), and Axisymmetric2D3DSolutionFunction::value().

{
  return (MetaPhysicL::raw_value(var1) >
          (MetaPhysicL::raw_value(var2) + MetaPhysicL::raw_value(tol)));
}

absoluteFuzzyLessEqual()

template<typename T , typename T2 , typename T3 = T, typename std::enable_if< libMesh::ScalarTraits< T >::value &&libMesh::ScalarTraits< T2 >::value &&libMesh::ScalarTraits< T3 >::value, int >::type = 0>

bool MooseUtils::absoluteFuzzyLessEqual	(	const T &	var1,
		const T2 &	var2,
		const T3 &	tol = libMesh::TOLERANCE * libMesh::TOLERANCE
	)

Function to check whether a variable is less than or equal to another variable within an absolute tolerance.

Parameters

var1	The first variable to be checked
var2	The second variable to be checked
tol	The tolerance to be used

Returns

true if var1 < var2 or var1 == var2 within tol

Definition at line 454 of file MooseUtils.h.

Referenced by MultiAppConservativeTransfer::adjustTransferredSolution(), MultiAppConservativeTransfer::adjustTransferredSolutionNearestPoint(), ComparisonPostprocessor::comparisonIsTrue(), FunctorBinnedValuesDivision::FunctorBinnedValuesDivision(), relativeFuzzyLessEqual(), and TimeIntervalTimes::TimeIntervalTimes().

{
  return (MetaPhysicL::raw_value(var1) <=
          (MetaPhysicL::raw_value(var2) + MetaPhysicL::raw_value(tol)));
}

absoluteFuzzyLessThan()

template<typename T , typename T2 , typename T3 = T, typename std::enable_if< libMesh::ScalarTraits< T >::value &&libMesh::ScalarTraits< T2 >::value &&libMesh::ScalarTraits< T3 >::value, int >::type = 0>

bool MooseUtils::absoluteFuzzyLessThan	(	const T &	var1,
		const T2 &	var2,
		const T3 &	tol = libMesh::TOLERANCE * libMesh::TOLERANCE
	)

Function to check whether a variable is less than another variable within an absolute tolerance.

Parameters

var1	The first variable to be checked
var2	The second variable to be checked
tol	The tolerance to be used

Returns

true if var1 < var2 and var1 != var2 within tol

Definition at line 477 of file MooseUtils.h.

Referenced by FormattedTable::addData(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), ComparisonPostprocessor::comparisonIsTrue(), TimePeriod::conditionMet(), CartesianGridDivision::divisionIndex(), SphericalGridDivision::divisionIndex(), CylindricalGridDivision::divisionIndex(), Boundary2DDelaunayGenerator::General2DDelaunay(), CSG::CSGSurface::getHalfspaceFromPoint(), CutMeshByLevelSetGeneratorBase::pointLevelSetRelation(), and relativeFuzzyLessThan().

{
  return (MetaPhysicL::raw_value(var1) <
          (MetaPhysicL::raw_value(var2) - MetaPhysicL::raw_value(tol)));
}

addLineBreaks()

void MooseUtils::addLineBreaks	(	std::string &	message,
		unsigned int	line_width
	)

Definition at line 730 of file MooseUtils.C.

{
  for (auto i : make_range(int(message.length() / line_width)))
    message.insert((i + 1) * (line_width + 2) - 2, "\n");
}

baseName()

std::string MooseUtils::baseName

(

const std::string &

name

)

Function for string the information before the final / in a parser block.

Definition at line 618 of file MooseUtils.C.

Referenced by Moose::Builder::walkRaw().

{
  return name.substr(0, name.find_last_of('/') != std::string::npos ? name.find_last_of('/') : 0);
}

beginsWith()

bool MooseUtils::beginsWith	(	const std::string &	value,
		const std::string &	begin_value
	)

Returns

Whether or not value begins with begin_value

Definition at line 966 of file MooseUtils.C.

Referenced by CommandLine::initSubAppCommandLine(), CommandLine::parse(), and CommandLine::setCommandLineParam().

{
  return value.rfind(begin_value, 0) == 0;
}

buildBoundingBox()

BoundingBox MooseUtils::buildBoundingBox	(	const Point &	p1,
		const Point &	p2
	)

Construct a valid bounding box from 2 arbitrary points.

If you have 2 points in space and you wish to construct a bounding box, you should use this method to avoid unexpected behavior of the underlying BoundingBox class in libMesh. BoundingBox class expect 2 points whose coordinates are "sorted" (i.e., x-, y- and -z coordinates of the first point are smaller then the corresponding coordinates of the second point). If this "sorting" is not present, the BoundingBox class will build an empty box and any further testing of points inside the box will fail. This method will allow you to obtain the correct bounding box for any valid combination of 2 corner points of a box.

Parameters

p1	First corner of the constructed bounding box
p2	Second corner of the constructed bounding box

Returns

Valid bounding box

Definition at line 1142 of file MooseUtils.C.

Referenced by PropertyReadFile::PropertyReadFile().

{
  BoundingBox bb;
  bb.union_with(p1);
  bb.union_with(p2);
  return bb;
}

camelCaseToUnderscore()

std::string MooseUtils::camelCaseToUnderscore

(

const std::string &

camel_case_name

)

Function for converting a camel case name to a name containing underscores.

Parameters

camel_case_name

A string containing camel casing

Returns

a string containing no capital letters with underscores as appropriate

Definition at line 568 of file MooseUtils.C.

Referenced by MooseApp::appNameToLibName().

{
  std::string replaced = camel_case_name;
  // Put underscores in front of each contiguous set of capital letters
  pcrecpp::RE("(?!^)(?<![A-Z_])([A-Z]+)").GlobalReplace("_\\1", &replaced);

  // Convert all capital letters to lower case
  std::transform(replaced.begin(), replaced.end(), replaced.begin(), ::tolower);
  return replaced;
}

canonicalPath()

std::string MooseUtils::canonicalPath

(

const std::string &

path

)

Gets the canonical path of the given path.

Definition at line 1171 of file MooseUtils.C.

Referenced by Registry::determineDataFilePath(), and Moose::DataFileUtils::getPath().

{
  return std::filesystem::weakly_canonical(path).c_str();
}

checkFileReadable()

bool MooseUtils::checkFileReadable	(	const std::string &	filename,
		bool	check_line_endings = false,
		bool	throw_on_unreadable = true,
		bool	check_for_git_lfs_pointer = true
	)

Checks to see if a file is readable (exists and permissions)

Parameters

filename	The filename to check
check_line_endings	Whether or not to see if the file contains DOS line endings.
throw_on_unreadable	Whether or not to throw a MOOSE error if the file doesn't exist
check_for_git_lfs_pointer	Whether or not to call a subroutine utility to make sure that the file in question is not actually a git-lfs pointer.

Returns

a Boolean indicating whether the file exists and is readable

Definition at line 254 of file MooseUtils.C.

Referenced by MooseServer::addResourcesForDocument(), FileMesh::buildMesh(), Registry::determineDataFilePath(), docsDir(), MooseApp::dynamicRegistration(), ExodusFileTimes::ExodusFileTimes(), findTestRoot(), MooseServer::gatherDocumentDefinitionLocations(), FileMeshGenerator::generate(), Moose::DataFileUtils::getPath(), ExodusTimeSequenceStepper::init(), installedInputsDir(), RestartableDataReader::isAvailable(), ADFParser::JITCompile(), MooseApp::loadLibraryAndDependencies(), Exodus::output(), Parser::parse(), MooseUtils::DelimitedFileReaderTempl< T >::read(), JSONFileReader::read(), MultiApp::readCommandLineArguments(), SolutionUserObjectBase::readXda(), MooseApp::run(), runTestsExecutable(), and ValueCache< T >::ValueCache().

{
  std::ifstream in(filename.c_str(), std::ifstream::in);
  if (in.fail())
  {
    if (throw_on_unreadable)
      mooseError(
          (std::string("Unable to open file \"") + filename +
           std::string("\". Check to make sure that it exists and that you have read permission."))
              .c_str());
    else
      return false;
  }

  if (check_line_endings)
  {
    std::istream_iterator<char> iter(in);
    std::istream_iterator<char> eos;
    in >> std::noskipws;
    while (iter != eos)
      if (*iter++ == '\r')
        mooseError(filename + " contains Windows(DOS) line endings which are not supported.");
  }

  if (check_for_git_lfs_pointer && checkForGitLFSPointer(in))
    mooseError(filename + " appears to be a Git-LFS pointer. Make sure you have \"git-lfs\" "
                          "installed so that you may pull this file.");
  in.close();

  return true;
}

checkFileWriteable()

bool MooseUtils::checkFileWriteable	(	const std::string &	filename,
		bool	throw_on_unwritable = true
	)

Check if the file is writable (path exists and permissions)

Parameters

filename	The filename you want to see if you can write to.
throw_on_unwritable	Whether or not to throw a MOOSE error if the file is not writable return a Boolean indicating whether the file exists and is writable

Definition at line 307 of file MooseUtils.C.

Referenced by PNGOutput::makePNG().

{
  std::ofstream out(filename.c_str(), std::ios_base::app);
  if (out.fail())
  {
    if (throw_on_unwritable)
      mooseError(
          (std::string("Unable to open file \"") + filename +
           std::string("\". Check to make sure that it exists and that you have write permission."))
              .c_str());
    else
      return false;
  }

  out.close();

  return true;
}

checkForGitLFSPointer()

bool MooseUtils::checkForGitLFSPointer

(

std::ifstream &

file

)

Check if the file is a Git-LFS pointer.

When using a repository that utilizes Git-LFS, it's possible that the client may not have the right packages installed in which case the clone will contain plain-text files with key information for retrieving the actual (large) files. This can cause odd errors since the file technically exists, is readable, and even has the right name/extension. However, the content of the file will not match the expected content.

Parameters

file	A pointer to the open filestream.

Definition at line 290 of file MooseUtils.C.

Referenced by checkFileReadable().

{
  mooseAssert(file.is_open(), "Passed in file handle is not open");

  std::string line;

  // git-lfs pointer files contain several name value pairs. The specification states that the
  // first name/value pair must be "version {url}". We'll do a simplified check for that.
  file.seekg(0);
  std::getline(file, line);
  if (line.find("version https://") != std::string::npos)
    return true;
  else
    return false;
}

clearSymlink()

void MooseUtils::clearSymlink

(

const std::string &

link

)

Remove a symbolic link, if the given filename is a link.

Definition at line 1084 of file MooseUtils.C.

Referenced by createSymlink(), and CSV::initialSetup().

{
#ifndef __WIN32__
  struct stat sbuf;
  if (lstat(link.c_str(), &sbuf) == 0)
  {
    auto err = unlink(link.c_str());
    if (err != 0)
      mooseError("Failed to remove symbolic link (via 'unlink') to ", link);
  }
#else
  auto attr = GetFileAttributesA(link.c_str());
  if (attr != INVALID_FILE_ATTRIBUTES)
  {
    auto err = _unlink(link.c_str());
    if (err != 0)
      mooseError("Failed to remove link/file (via '_unlink') to ", link);
  }
#endif
}

concatenate() [1/3]

template<typename T >

T MooseUtils::concatenate	(	T	c1,
		const T &	c2
	)

Returns a container that contains the content of second passed in container inserted into the first passed in container (set or map union).

Definition at line 879 of file MooseUtils.h.

Referenced by MaterialDerivativeTestKernelBase< Real >::MaterialDerivativeTestKernelBase().

{
  c1.insert(c2.begin(), c2.end());
  return c1;
}

concatenate() [2/3]

template<typename T >

std::vector<T> MooseUtils::concatenate	(	std::vector< T >	c1,
		const std::vector< T > &	c2
	)

Returns a vector that contains is the concatenation of the two passed in vectors.

Definition at line 890 of file MooseUtils.h.

{
  c1.insert(c1.end(), c2.begin(), c2.end());
  return c1;
}

concatenate() [3/3]

template<typename T >

std::vector<T> MooseUtils::concatenate	(	std::vector< T >	c1,
		const T &	item
	)

Returns the passed in vector with the item appended to it.

Definition at line 901 of file MooseUtils.h.

{
  c1.push_back(item);
  return c1;
}

convert() [1/2]

template<class T >

bool MooseUtils::convert	(	const std::string &	str,
		T &	value,
		const bool	throw_on_failure
	)

Takes the string representation of a value and converts it to the value.

For standard numeric types, this gets around the deficiencies in the STL stoi and stod methods where they might successfully convert part of a string to a number when we'd instead prefer to get a failure.

For string and string-derived types, this does a direct copy and does not utilize a stream.

For all other types, this uses the stringstream >> operator to fill the value.

Parameters

str	The string to convert from
value	The typed value to fill
throw_on_failure	If true, throw a std::invalid_argument on failure

Returns

Whether or not the conversion succeeded

Definition at line 96 of file MooseStringUtils.h.

Referenced by convert(), and MooseServer::getDocumentSymbolKind().

{
  // Special case for numeric values, also handling range checking
  if constexpr (std::is_same_v<short int, T> || std::is_same_v<unsigned short int, T> ||
                std::is_same_v<int, T> || std::is_same_v<unsigned int, T> ||
                std::is_same_v<long int, T> || std::is_same_v<unsigned long int, T> ||
                std::is_same_v<long long int, T> || std::is_same_v<unsigned long long int, T>)
  {
    // Try read a double and try to cast it to an int
    long double double_val;
    std::stringstream double_ss(str);
    double_ss >> double_val;

    if (!double_ss.fail() && double_ss.eof())
    {
      // on arm64 the long double does not have sufficient precision
      std::stringstream int_ss(str);
      const bool use_int = !(int_ss >> value).fail() && int_ss.eof();

      // Check to see if it's an integer and thus within range of an integer
      if (double_val == static_cast<long double>(static_cast<T>(double_val)))
      {
        if (!use_int)
          value = static_cast<T>(double_val);
        return true;
      }
    }
  }
  // Non numeric values
  else
  {
    // string or derived string: direct copy
    if constexpr (std::is_base_of_v<std::string, T>)
    {
      value = str;
      return true;
    }
    // non-string or numeric, use stringstream >>
    else
    {
      std::stringstream ss(trim(str));
      if (!(ss >> value).fail() && ss.eof())
        return true;
    }
  }

  if (throw_on_failure)
  {
    std::string error = "Unable to convert '" + str + "' to type ";
#ifdef MOOSESTRINGUTILS_NO_LIBMESH
    error += typeid(T).name();
#else
    error += libMesh::demangle(typeid(T).name());
#endif
    throw std::invalid_argument(error);
  }

  return false;
}

convert() [2/2]

template<typename T >

T MooseUtils::convert	(	const std::string &	str,
		bool	throw_on_failure = false
	)

Takes the string representation of a value and converts it to the value.

See the convert method in MooseStringUtils.h for more information on handling of each case.

Parameters

str	The string to convert from
throw_on_failure	If true, throw on a failure to convert, otherwise use mooseError

Returns

The converted value on success

Definition at line 847 of file MooseUtils.h.

{
  T val;
  try
  {
    convert(str, val, true);
  }
  catch (std::exception const & e)
  {
    if (throw_on_failure)
      throw;
    mooseError(e.what());
  }
  return val;
}

convertLatestCheckpoint()

std::string MooseUtils::convertLatestCheckpoint

(

std::string

orig

)

Replaces "LATEST" placeholders with the latest checkpoint file name.

Definition at line 157 of file MooseUtils.C.

Referenced by SetupRecoverFileBaseAction::act(), FileMeshGenerator::deduceCheckpointPath(), and FEProblemBase::FEProblemBase().

{
  auto slash_pos = orig.find_last_of("/");
  auto path = orig.substr(0, slash_pos);
  auto file = orig.substr(slash_pos + 1);
  if (file != "LATEST")
    return orig;

  auto converted = MooseUtils::getLatestCheckpointFilePrefix(MooseUtils::listDir(path));

  if (converted.empty())
    mooseError("Unable to find suitable recovery file!");

  return converted;
}

createSymlink()

void MooseUtils::createSymlink	(	const std::string &	target,
		const std::string &	link
	)

Create a symbolic link, if the link already exists it is replaced.

Definition at line 1071 of file MooseUtils.C.

Referenced by CSV::output().

{
  clearSymlink(link);
#ifndef __WIN32__
  auto err = symlink(target.c_str(), link.c_str());
#else
  auto err = CreateSymbolicLink(target.c_str(), link.c_str(), 0);
#endif
  if (err)
    mooseError("Failed to create symbolic link (via 'symlink') from ", target, " to ", link);
}

docsDir()

std::string MooseUtils::docsDir

(

const std::string &

app_name

)

Returns the directory of any installed docs/site.

Definition at line 125 of file MooseUtils.C.

Referenced by MooseApp::run().

{
  // See moose.mk for a detailed explanation of the assumed installed application
  // layout. Installed docs are expected to be installed in "share/<app_name>/doc".
  // The binary, which has a defined location will be in "bin", a peer directory to "share".
  std::string installed_path = pathjoin(Moose::getExecutablePath(), "..", "share", app_name, "doc");

  auto docfile = pathjoin(installed_path, "css", "moose.css");
  if (pathExists(docfile) && checkFileReadable(docfile))
    return installed_path;
  return "";
}

doesMapContainValue()

template<typename T1 , typename T2 >

bool MooseUtils::doesMapContainValue	(	const std::map< T1, T2 > &	the_map,
		const T2 &	value
	)

This routine is a simple helper function for searching a map by values instead of keys.

Definition at line 358 of file MooseUtils.h.

Referenced by MooseMeshUtils::getBoundaryIDs().

{
  for (typename std::map<T1, T2>::const_iterator iter = the_map.begin(); iter != the_map.end();
       ++iter)
    if (iter->second == value)
      return true;
  return false;
}

escape()

void MooseUtils::escape

(

std::string &

str

)

This function will escape all of the standard C++ escape characters so that they can be printed.

The passed in parameter is modified in place

Definition at line 207 of file MooseUtils.C.

Referenced by MooseServer::addParametersToList(), MooseServer::addValuesToList(), MooseServer::getHoverDisplayText(), YAMLFormatter::printBlockOpen(), InputFileFormatter::printParams(), YAMLFormatter::printParams(), and JsonSyntaxTree::setParams().

{
  std::map<char, std::string> escapes;
  escapes['\a'] = "\\a";
  escapes['\b'] = "\\b";
  escapes['\f'] = "\\f";
  escapes['\n'] = "\\n";
  escapes['\t'] = "\\t";
  escapes['\v'] = "\\v";
  escapes['\r'] = "\\r";

  for (const auto & it : escapes)
    for (size_t pos = 0; (pos = str.find(it.first, pos)) != std::string::npos;
         pos += it.second.size())
      str.replace(pos, 1, it.second);
}

expandAllMatches()

template<typename T >

void MooseUtils::expandAllMatches	(	const std::vector< T > &	candidates,
		std::vector< T > &	patterns
	)

Definition at line 817 of file MooseUtils.h.

Referenced by SingleMatrixPreconditioner::SingleMatrixPreconditioner().

{
  std::set<T> expanded;
  for (const auto & p : patterns)
  {
    unsigned int found = 0;
    for (const auto & c : candidates)
      if (globCompare(c, p))
      {
        expanded.insert(c);
        found++;
      }
    if (!found)
      throw std::invalid_argument(p);
  }
  patterns.assign(expanded.begin(), expanded.end());
}

fileSize()

std::size_t MooseUtils::fileSize

(

const std::string &

filename

)

Check the file size.

Definition at line 1106 of file MooseUtils.C.

Referenced by Exodus::output().

{
#ifndef __WIN32__
  struct stat buffer;
  if (!stat(filename.c_str(), &buffer))
    return buffer.st_size;
#else
  HANDLE hFile = CreateFile(filename.c_str(),
                            GENERIC_READ,
                            FILE_SHARE_READ | FILE_SHARE_WRITE,
                            NULL,
                            OPEN_EXISTING,
                            FILE_ATTRIBUTE_NORMAL,
                            NULL);
  if (hFile == INVALID_HANDLE_VALUE)
    return 0;

  LARGE_INTEGER size;
  if (GetFileSizeEx(hFile, &size))
  {
    CloseHandle(hFile);
    return size.QuadPart;
  }

  CloseHandle(hFile);
#endif
  return 0;
}

findPair()

template<typename C , typename It , typename M1 , typename M2 >

auto MooseUtils::findPair	(	C &	container,
		It	start_iterator,
		const M1 &	first,
		const M2 &	second
	)

Find a specific pair in a container matching on first, second or both pair components.

Definition at line 1041 of file MooseUtils.h.

Referenced by Moose::PetscSupport::addPetscPairsToPetscOptions(), and Moose::PetscSupport::isSNESVI().

{
  return std::find_if(start_iterator,
                      container.end(),
                      [&](auto & item) {
                        return wildcardEqual(first, item.first) &&
                               wildcardEqual(second, item.second);
                      });
}

findTestRoot()

std::string MooseUtils::findTestRoot

(

)

Searches in the current working directory and then recursively up in each parent directory looking for a "testroot" file.

Returns the full path to the first testroot file found.

Definition at line 75 of file MooseUtils.C.

Referenced by MooseApp::runInputs().

{
  std::string path = ".";
  for (int i = 0; i < 5; i++)
  {
    auto testroot = pathjoin(path, "testroot");
    if (pathExists(testroot) && checkFileReadable(testroot))
      return testroot;
    path += "/..";
  }
  return "";
}

get() [1/3]

template<typename T >

T* MooseUtils::get

(

const std::unique_ptr< T > &

u

)

The MooseUtils::get() specializations are used to support making forwards-compatible code changes from dumb pointers to smart pointers.

The same line of code, e.g.

libMesh::Parameters::Value * value = MooseUtils::get(map_iter->second);

will then work regardless of whether map_iter->second is a dumb pointer or a smart pointer. Note that the smart pointer get() functions are const so they can be (ab)used to get a non-const pointer to the underlying resource. We are simply following this convention here.

Definition at line 1135 of file MooseUtils.h.

Referenced by InputParameterWarehouse::addInputParameters(), JsonSyntaxTree::buildOptions(), YAMLFormatter::buildOutputString(), JsonSyntaxTree::buildOutputString(), RestartableDataIO::currentData(), and RestartableDataIO::dataSize().

{
  return u.get();
}

get() [2/3]

template<typename T >

T* MooseUtils::get

(

T *

p

)

Definition at line 1142 of file MooseUtils.h.

{
  return p;
}

get() [3/3]

template<typename T >

T* MooseUtils::get

(

const std::shared_ptr< T > &

s

)

Definition at line 1149 of file MooseUtils.h.

{
  return s.get();
}

getCurrentWorkingDir()

std::string MooseUtils::getCurrentWorkingDir

(

)

Returns the current working directory as a string.

If there's a problem obtaining the current working directory, this function just returns an empty string. It doesn't not throw.

Definition at line 436 of file MooseUtils.C.

Referenced by MooseApp::runInputs().

{
  // Note: At the time of creating this method, our minimum compiler still
  // does not support <filesystem>. Additionally, the inclusion of that header
  // requires an additional library to be linked so for now, we'll just
  // use the Unix standard library to get us the cwd().
  constexpr unsigned int BUF_SIZE = 1024;
  char buffer[BUF_SIZE];

  return getcwd(buffer, BUF_SIZE) != nullptr ? buffer : "";
}

getDefaultExecFlagEnum()

ExecFlagEnum MooseUtils::getDefaultExecFlagEnum

(

)

Return the default ExecFlagEnum for MOOSE.

Definition at line 972 of file MooseUtils.C.

Referenced by AddNodalNormalsAction::act(), AdvancedOutput::addValidParams(), Output::getDefaultExecFlagEnum(), Control::getExecuteOptions(), OutputOnWarehouse::OutputOnWarehouse(), MOOSEToNEML2Unbatched::validParams(), SetupDebugAction::validParams(), NEML2BatchIndexGenerator::validParams(), NEML2ModelExecutor::validParams(), MOOSEToNEML2Batched< Real >::validParams(), and SetupInterface::validParams().

{
  return moose::internal::ExecFlagRegistry::getExecFlagRegistry().getDefaultFlags();
}

getExtension()

std::string MooseUtils::getExtension	(	const std::string &	filename,
		const bool	rfind = false
	)

Gets the extension of the passed file name.

Parameters

filename	The filename of which to get the extension
rfind	When true, searches for last "." in filename. Otherwise, searches for first "."

Returns

file_ext The extension of filename (does not include the leading "."). If filename has no extension, returns "".

Definition at line 411 of file MooseUtils.C.

Referenced by SplitMeshAction::act(), CommonOutputAction::act(), SetupMeshAction::modifyParamsForUseSplit(), and stripExtension().

{
  std::string file_ext = "";
  if (filename != "")
  {
    // The next line splits filename at the last "/" and gives the file name after "/"
    const std::string stripped_filename = splitFileName<std::string>(filename).second;
    auto pos = rfind ? stripped_filename.rfind(".") : stripped_filename.find(".");
    if (pos != std::string::npos)
      file_ext += stripped_filename.substr(pos + 1, std::string::npos);
  }

  return file_ext;
}

getFilesInDirs()

std::list< std::string > MooseUtils::getFilesInDirs	(	const std::list< std::string > &	directory_list,
		const bool	files_only = true
	)

Retrieves the names of all of the files contained within the list of directories passed into the routine.

The names returned will be the paths to the files relative to the current directory.

Parameters

directory_list	The list of directories to retrieve files from.
file_only	Whether or not to list only files

Definition at line 808 of file MooseUtils.C.

Referenced by MooseApp::getCheckpointFiles().

{
  std::list<std::string> files;

  for (const auto & dir_name : directory_list)
    files.splice(files.end(), listDir(dir_name, files_only));

  return files;
}

getLatestCheckpointFilePrefix()

std::string MooseUtils::getLatestCheckpointFilePrefix

(

const std::list< std::string > &

checkpoint_files

)

Returns the most recent checkpoint prefix (the four numbers at the beginning) If a suitable file isn't found the empty string is returned.

Parameters

checkpoint_files

the list of files to analyze

Definition at line 819 of file MooseUtils.C.

Referenced by convertLatestCheckpoint(), and MooseApp::setRestartRecoverFileBase().

{
  // Create storage for newest restart files
  // Note that these might have the same modification time if the simulation was fast.
  // In that case we're going to save all of the "newest" files and sort it out momentarily
  std::time_t newest_time = 0;
  std::list<std::string> newest_restart_files;

  // Loop through all possible files and store the newest
  for (const auto & cp_file : checkpoint_files)
  {
    if (MooseUtils::hasExtension(cp_file, "rd"))
    {
      struct stat stats;
      stat(cp_file.c_str(), &stats);

      std::time_t mod_time = stats.st_mtime;
      if (mod_time > newest_time)
      {
        newest_restart_files.clear(); // If the modification time is greater, clear the list
        newest_time = mod_time;
      }

      if (mod_time == newest_time)
        newest_restart_files.push_back(cp_file);
    }
  }

  // Loop through all of the newest files according the number in the file name
  int max_file_num = -1;
  std::string max_file;
  std::string max_prefix;

  // Pull out the path including the number and the number itself
  // This takes something_blah_out_cp/0024-restart-1.rd
  // and returns "something_blah_out_cp/0024" as the "prefix"
  // and then "24" as the number itself
  pcrecpp::RE re_file_num("(.*?(\\d+))-restart-\\d+.rd$");

  // Now, out of the newest files find the one with the largest number in it
  for (const auto & res_file : newest_restart_files)
  {
    int file_num = 0;

    // All of the file up to and including the digits
    std::string file_prefix;

    re_file_num.FullMatch(res_file, &file_prefix, &file_num);

    if (file_num > max_file_num)
    {
      // Need both the header and the data
      if (!RestartableDataReader::isAvailable(res_file))
        continue;

      max_file_num = file_num;
      max_file = res_file;
      max_prefix = file_prefix;
    }
  }

  // Error if nothing was located
  if (max_file_num == -1)
    mooseError("No checkpoint file found!");

  return max_prefix;
}

getTermWidth()

unsigned short MooseUtils::getTermWidth

(

bool

use_environment

)

Returns the width of the terminal using sys/ioctl.

Initialize the value we intend to populate just in case the system call fails

Initialize the value we intend to populate just in case the system call fails

Definition at line 640 of file MooseUtils.C.

Referenced by FormattedTable::printTable().

{
#ifndef __WIN32__
  struct winsize w;
#else
  struct
  {
    unsigned short ws_col;
  } w;
#endif

  w.ws_col = std::numeric_limits<unsigned short>::max();

  if (use_environment)
  {
    char * pps_width = std::getenv("MOOSE_PPS_WIDTH");
    if (pps_width != NULL)
    {
      std::stringstream ss(pps_width);
      ss >> w.ws_col;
    }
  }
  // Default to AUTO if no environment variable was set
  if (w.ws_col == std::numeric_limits<unsigned short>::max())
  {
#ifndef __WIN32__
    try
    {
      ioctl(0, TIOCGWINSZ, &w);
    }
    catch (...)
#endif
    {
    }
  }

  // Something bad happened, make sure we have a sane value
  // 132 seems good for medium sized screens, and is available as a GNOME preset
  if (w.ws_col == std::numeric_limits<unsigned short>::max())
    w.ws_col = 132;

  return w.ws_col;
}

getUnion()

template<typename T >

void MooseUtils::getUnion	(	const std::vector< T > &	vector1,
		const std::vector< T > &	vector2,
		std::vector< T > &	common
	)

Function which takes the union of vector1 and vector2 and copies them to common .

Depending on the vector size and data type this can be very expensive!

Definition at line 647 of file MooseUtils.h.

Referenced by ComputeLinearFVElementalThread::fetchBlockSystemContributionObjects(), ComputeLinearFVFaceThread::fetchBlockSystemContributionObjects(), ComputeLinearFVElementalThread::setupSystemContributionObjects(), and ComputeLinearFVFaceThread::setupSystemContributionObjects().

{
  std::unordered_set<T> unique_elements;
  unique_elements.reserve(vector1.size() + vector2.size());

  for (const T & entry : vector1)
    unique_elements.insert(entry);
  for (const T & entry : vector2)
    unique_elements.insert(entry);

  // Now populate the common vector with the union
  common.clear();
  common.assign(unique_elements.begin(), unique_elements.end());
}

globCompare()

bool MooseUtils::globCompare	(	const std::string &	candidate,
		const std::string &	pattern,
		std::size_t	c = 0,
		std::size_t	p = 0
	)

Definition at line 932 of file MooseUtils.C.

Referenced by RestartableDataReporter::execute(), expandAllMatches(), and ReferenceResidualConvergence::initialSetup().

{
  if (p == pattern.size())
    return c == candidate.size();

  if (pattern[p] == '*')
  {
    for (; c < candidate.size(); ++c)
      if (globCompare(candidate, pattern, c, p + 1))
        return true;
    return globCompare(candidate, pattern, c, p + 1);
  }

  if (pattern[p] != '?' && pattern[p] != candidate[c])
    return false;

  return globCompare(candidate, pattern, c + 1, p + 1);
}

hasExtension()

bool MooseUtils::hasExtension	(	const std::string &	filename,
		std::string	ext,
		bool	strip_exodus_ext = false
	)

Function tests if the supplied filename as the desired extension.

Parameters

filename	The filename to test the extension
ext	The extension to test for (do not include the .)
strip_exodus_ext	When true, this function ignores -s* from the end of the extension

Returns

True if the filename has the supplied extension

Definition at line 387 of file MooseUtils.C.

Referenced by FileRangeBuilder::FileRangeBuilder(), getLatestCheckpointFilePrefix(), and SolutionUserObjectBase::initialSetup().

{
  // Extract the extension, w/o the '.'
  std::string file_ext;
  if (strip_exodus_ext)
  {
    pcrecpp::RE re(
        ".*\\.([^\\.]*?)(?:-s\\d+)?\\s*$"); // capture the complete extension, ignoring -s*
    re.FullMatch(filename, &file_ext);
  }
  else
  {
    pcrecpp::RE re(".*\\.([^\\.]*?)\\s*$"); // capture the complete extension
    re.FullMatch(filename, &file_ext);
  }

  // Perform the comparision
  if (file_ext == ext)
    return true;
  else
    return false;
}

hostname()

std::string MooseUtils::hostname

(

)

Get the hostname the current process is running on.

Definition at line 624 of file MooseUtils.C.

{
  char hostname[1024];
  hostname[1023] = '\0';
#ifndef __WIN32__
  if (gethostname(hostname, 1023))
    mooseError("Failed to retrieve hostname!");
#else
  DWORD dwSize = sizeof(hostname);
  if (!GetComputerNameEx(ComputerNamePhysicalDnsHostname, hostname, &dwSize))
    mooseError("Failed to retrieve hostname!");
#endif
  return hostname;
}

indentMessage()

void MooseUtils::indentMessage	(	const std::string &	prefix,
		std::string &	message,
		const char *	color = COLOR_CYAN,
		bool	dont_indent_first_line = true,
		const std::string &	post_prefix = ": "
	)

Indents the supplied message given the prefix and color.

Parameters

prefix	The prefix to use for indenting
message	The message that will be indented
color	The color to apply to the prefix (default CYAN)
indent_first_line	If true this will indent the first line too (default)
post_prefix	A string to append right after the prefix, defaults to a column and a space

Takes a message like the following and indents it with another color code (see below)

Input message: COLOR_YELLOW *** Warning *** Something bad has happened and we want to draw attention to it with color COLOR_DEFAULT

Output message: COLOR_CYAN sub_app: COLOR_YELLOW COLOR_CYAN sub_app: COLOR_YELLOW *** Warning *** COLOR_CYAN sub_app: COLOR_YELLOW Something bad has happened and we want to draw attention to it with color COLOR_DEFAULT

Also handles single line color codes COLOR_CYAN sub_app: 0 Nonlinear |R| = COLOR_GREEN 1.0e-10 COLOR_DEFAULT

Not indenting the first line is useful in the case where the first line is actually finishing the line before it.

Definition at line 738 of file MooseUtils.C.

Referenced by DefaultNonlinearConvergence::checkConvergence(), ConsoleUtils::formatString(), OutputWarehouse::mooseConsole(), moose::internal::mooseErrorRaw(), and Console::write().

{
  // First we need to see if the message we need to indent (with color) also contains color codes
  // that span lines.
  // The code matches all of the XTERM constants (see XTermConstants.h). If it does, then we'll work
  // on formatting
  // each colored multiline chunk one at a time with the right codes.
  std::string colored_message;
  std::string curr_color = COLOR_DEFAULT; // tracks last color code before newline
  std::string line, color_code;

  bool ends_in_newline = message.empty() ? true : message.back() == '\n';

  bool first = true;

  std::istringstream iss(message);
  for (std::string line; std::getline(iss, line);) // loop over each line
  {
    const static pcrecpp::RE match_color(".*(\\33\\[3\\dm)((?!\\33\\[3\\d)[^\n])*");
    pcrecpp::StringPiece line_piece(line);
    match_color.FindAndConsume(&line_piece, &color_code);

    if (!first || indent_first_line)
      colored_message += color + prefix + post_prefix + curr_color;

    colored_message += line;

    // Only add a newline to the last line if it had one to begin with!
    if (!iss.eof() || ends_in_newline)
      colored_message += "\n";

    if (!color_code.empty())
      curr_color = color_code; // remember last color of this line

    first = false;
  }
  message = colored_message;
}

installedInputsDir()

std::string MooseUtils::installedInputsDir	(	const std::string &	app_name,
		const std::string &	dir_name,
		const std::string &	extra_error_msg = ""
	)

Returns the directory of any installed inputs or the empty string if none are found.

Definition at line 103 of file MooseUtils.C.

Referenced by MooseApp::copyInputs().

{
  // See moose.mk for a detailed explanation of the assumed installed application
  // layout. Installed inputs are expected to be installed in "share/<app_name>/<folder>".
  // The binary, which has a defined location will be in "bin", a peer directory to "share".
  std::string installed_path =
      pathjoin(Moose::getExecutablePath(), "..", "share", app_name, dir_name);

  auto test_root = pathjoin(installed_path, "testroot");
  if (!pathExists(installed_path))
    mooseError("Couldn't locate any installed inputs to copy in path: ",
               installed_path,
               '\n',
               extra_error_msg);

  checkFileReadable(test_root);
  return installed_path;
}

isAllLowercase()

bool MooseUtils::isAllLowercase

(

const std::string &

str

)

Returns

whether every alphabetic character in a string is lower-case

Definition at line 1193 of file MooseUtils.C.

{
  return std::all_of(
      str.begin(), str.end(), [](unsigned char c) { return !std::isalpha(c) || std::islower(c); });
}

isDigits()

bool MooseUtils::isDigits ( const std::string &  str )

inline

Courtesy https://stackoverflow.com/a/8889045 and https://en.cppreference.com/w/cpp/string/byte/isdigit.

Returns

Whether every character in the string is a digit

Definition at line 1188 of file MooseUtils.h.

Referenced by RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), SideSetsFromNodeSetsGenerator::generate(), XYZDelaunayGenerator::generate(), MooseMeshUtils::getBoundaryID(), MooseMeshUtils::getBoundaryIDs(), MooseMeshUtils::getIDFromName(), and MooseMeshUtils::getSubdomainID().

{
  return std::all_of(str.begin(), str.end(), [](unsigned char c) { return std::isdigit(c); });
}

isFloat()

bool MooseUtils::isFloat ( const std::string &  str )

inline

Courtesy https://stackoverflow.com/a/57163016 and https://stackoverflow.com/questions/447206/c-isfloat-function.

Returns

Whether the string is convertible to a float

Definition at line 1199 of file MooseUtils.h.

Referenced by ChainControlParsedFunctionWrapper::initializeFunctionInputs().

{
  if (str.empty())
    return false;
  char * ptr;
  strtof(str.c_str(), &ptr);
  return (*ptr) == '\0';
}

isZero()

template<typename T >

bool MooseUtils::isZero	(	const T &	value,
		const Real	tolerance = TOLERANCE * TOLERANCE * TOLERANCE
	)

Parameters

value	The quantity to test for zero-ness
tolerance	The tolerance for testing zero-ness. The default is 1e-18 for double precision configurations of libMesh/MOOSE

Returns

whether the L_infty norm of the value is (close enough to) zero

Definition at line 693 of file MooseUtils.h.

Referenced by MathUtils::barycentricToCartesian2D(), MathUtils::barycentricToCartesian3D(), MathUtils::circumcenter2D(), MathUtils::circumcenter3D(), LinearFVAdvectionDiffusionFunctorRobinBC::computeBoundaryNormalGradient(), and LinearFVAdvectionDiffusionFunctorRobinBC::LinearFVAdvectionDiffusionFunctorRobinBC().

{
  if constexpr (Has_size<T>::value)
  {
    for (const auto & element : value)
      if (!isZero(element, tolerance))
        return false;

    return true;
  }
  else if constexpr (libMesh::TensorTools::TensorTraits<T>::rank == 0)
    return MooseUtils::absoluteFuzzyEqual(MetaPhysicL::raw_value(value), 0, tolerance);
  else if constexpr (libMesh::TensorTools::TensorTraits<T>::rank == 1)
  {
    for (const auto i : make_range(Moose::dim))
      if (!MooseUtils::absoluteFuzzyEqual(MetaPhysicL::raw_value(value(i)), 0, tolerance))
        return false;

    return true;
  }
  else if constexpr (libMesh::TensorTools::TensorTraits<T>::rank == 2)
  {
    for (const auto i : make_range(Moose::dim))
      for (const auto j : make_range(Moose::dim))
        if (!MooseUtils::absoluteFuzzyEqual(MetaPhysicL::raw_value(value(i, j)), 0, tolerance))
          return false;

    return true;
  }
}

join() [1/2]

template<typename Iterator >

std::string MooseUtils::join	(	Iterator	begin,
		Iterator	end,
		const std::string &	delimiter
	)

Python-like join function for strings over an iterator range.

Definition at line 144 of file MooseUtils.h.

Referenced by MooseObjectWarehouseBase< Indicator >::activeObjectsToFormattedString(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), boundaryIntegrityCheckError(), ControllableParameter::checkExecuteOnType(), MeshGeneratorSystem::createAddedMeshGenerators(), MeshGeneratorSystem::createMeshGeneratorOrder(), DependencyResolverInterface::cyclicDependencyError(), MaterialBase::declareGenericPropertyByName(), Moose::Kokkos::MaterialBase::declareKokkosPropertyByName(), MaterialPropertyInterface::getBlockMaterialProperty(), Material::getGenericMaterialPropertyByName(), MaterialPropertyInterface::getGenericMaterialPropertyByName(), MaterialPropertyInterface::getKokkosMaterialPropertyByName(), Syntax::getSortedTask(), TransientBase::getTimeIntegratorNames(), MaterialPropertyInterface::hasADMaterialPropertyByName(), MaterialPropertyInterface::hasKokkosMaterialPropertyByName(), MaterialPropertyInterface::hasMaterialPropertyByName(), ParsedConvergence::initialSetup(), SubProblem::initialSetup(), join(), ConsoleUtils::mooseObjectVectorToString(), NEML2Action::NEML2Action(), MaterialPropertyDebugOutput::output(), ConsoleUtils::outputExecutionInformation(), MooseApp::setMFEMDevice(), CreateExecutionerAction::setupAutoPreconditioning(), and SubProblem::showFunctorRequestors().

{
  std::ostringstream oss;
  std::copy(begin, end, infix_ostream_iterator<std::string>(oss, delimiter.c_str()));
  return oss.str();
}

join() [2/2]

template<typename T >

std::string MooseUtils::join	(	const T &	strings,
		const std::string &	delimiter
	)

Python-like join function for strings over a container.

Definition at line 156 of file MooseUtils.h.

{
  return join(strings.begin(), strings.end(), delimiter);
}

levenshteinDist()

int MooseUtils::levenshteinDist	(	const std::string &	s1,
		const std::string &	s2
	)

Computes and returns the Levenshtein distance between strings s1 and s2.

Definition at line 176 of file MooseUtils.C.

Referenced by Moose::findSimilar().

{
  // To change the type this function manipulates and returns, change
  // the return type and the types of the two variables below.
  auto s1len = s1.size();
  auto s2len = s2.size();

  auto column_start = (decltype(s1len))1;

  auto column = new decltype(s1len)[s1len + 1];
  std::iota(column + column_start, column + s1len + 1, column_start);

  for (auto x = column_start; x <= s2len; x++)
  {
    column[0] = x;
    auto last_diagonal = x - column_start;
    for (auto y = column_start; y <= s1len; y++)
    {
      auto old_diagonal = column[y];
      auto possibilities = {
          column[y] + 1, column[y - 1] + 1, last_diagonal + (s1[y - 1] == s2[x - 1] ? 0 : 1)};
      column[y] = std::min(possibilities);
      last_diagonal = old_diagonal;
    }
  }
  auto result = column[s1len];
  delete[] column;
  return result;
}

linearPartitionChunk()

processor_id_type MooseUtils::linearPartitionChunk	(	dof_id_type	num_items,
		dof_id_type	num_chunks,
		dof_id_type	item_id
	)

Return the chunk_id that is assigned to handle item_id.

Parameters

num_items	Global number of items to partition
num_chunks	Total number of chunks to split into
item_id	The item to find the chunk_id for

Returns

The chunk_id of the chunk that contains item_id

Definition at line 1010 of file MooseUtils.C.

Referenced by DistributedRectilinearMeshGenerator::buildCube().

{
  auto global_num_local_items = num_items / num_chunks;

  auto leftovers = num_items % num_chunks;

  auto first_item_past_first_part = leftovers * (global_num_local_items + 1);

  // Is it in the first section (that gets an extra item)
  if (item_id < first_item_past_first_part)
    return item_id / (global_num_local_items + 1);
  else
  {
    auto new_item_id = item_id - first_item_past_first_part;

    // First chunk after the first section + the number of chunks after that
    return leftovers + (new_item_id / global_num_local_items);
  }
}

linearPartitionItems()

void MooseUtils::linearPartitionItems	(	dof_id_type	num_items,
		dof_id_type	num_chunks,
		dof_id_type	chunk_id,
		dof_id_type &	num_local_items,
		dof_id_type &	local_items_begin,
		dof_id_type &	local_items_end
	)

Linearly partition a number of items.

Parameters

num_items	The number of items to partition
num_chunks	The number of chunks to partition into
chunk_id	The ID of the chunk you are trying to get information about (typically the current MPI rank)
num_local_items	Output: The number of items for this chunk_id
local_items_begin	Output: The first item for this chunk_id
local_items_end	Output: One past the final item for this chunk_id

Definition at line 984 of file MooseUtils.C.

Referenced by DistributedRectilinearMeshGenerator::buildCube().

{
  auto global_num_local_items = num_items / num_chunks;

  num_local_items = global_num_local_items;

  auto leftovers = num_items % num_chunks;

  if (chunk_id < leftovers)
  {
    num_local_items++;
    local_items_begin = num_local_items * chunk_id;
  }
  else
    local_items_begin =
        (global_num_local_items + 1) * leftovers + global_num_local_items * (chunk_id - leftovers);

  local_items_end = local_items_begin + num_local_items;
}

listDir()

std::list< std::string > MooseUtils::listDir	(	const std::string	path,
		bool	files_only = false
	)

Definition at line 782 of file MooseUtils.C.

Referenced by convertLatestCheckpoint(), getFilesInDirs(), and removedirs().

{
  std::list<std::string> files;

  tinydir_dir dir;
  dir.has_next = 0; // Avoid a garbage value in has_next (clang StaticAnalysis)
  tinydir_open(&dir, path.c_str());

  while (dir.has_next)
  {
    tinydir_file file;
    file.is_dir = 0; // Avoid a garbage value in is_dir (clang StaticAnalysis)
    tinydir_readfile(&dir, &file);

    if (!files_only || !file.is_dir)
      files.push_back(path + "/" + file.name);

    tinydir_next(&dir);
  }

  tinydir_close(&dir);

  return files;
}

makedirs()

void MooseUtils::makedirs	(	const std::string &	dir_name,
		bool	throw_on_failure = false
	)

Recursively make directories.

Parameters

dir_name	A complete path
throw_on_failure	True to throw instead of error out when creating a directory is failed.

The path can be relative like 'a/b/c' or absolute like '/a/b/c'. The path is allowed to contain '.' or '..'.

Definition at line 449 of file MooseUtils.C.

{
  // split path into directories with delimiter '/'
  std::vector<std::string> split_dir_names;
  MooseUtils::tokenize(dir_name, split_dir_names);

  auto n = split_dir_names.size();

  // remove '.' and '..' when possible
  auto i = n;
  i = 0;
  while (i != n)
  {
    if (split_dir_names[i] == ".")
    {
      for (auto j = i + 1; j < n; ++j)
        split_dir_names[j - 1] = split_dir_names[j];
      --n;
    }
    else if (i > 0 && split_dir_names[i] == ".." && split_dir_names[i - 1] != "..")
    {
      for (auto j = i + 1; j < n; ++j)
        split_dir_names[j - 2] = split_dir_names[j];
      n -= 2;
      --i;
    }
    else
      ++i;
  }
  if (n == 0)
    return;

  split_dir_names.resize(n);

  // start creating directories recursively
  std::string cur_dir = dir_name[0] == '/' ? "" : ".";
  for (auto & dir : split_dir_names)
  {
    cur_dir += "/" + dir;

    if (!pathExists(cur_dir))
    {
      auto code = Utility::mkdir(cur_dir.c_str());
      if (code != 0)
      {
        std::string msg = "Failed creating directory " + dir_name;
        if (throw_on_failure)
          throw std::invalid_argument(msg);
        else
          mooseError(msg);
      }
    }
  }
}

MaterialPropertyStorageDump()

void MooseUtils::MaterialPropertyStorageDump

(

const HashMap< const libMesh::Elem *, HashMap< unsigned int, MaterialProperties >> &

props

)

Function to dump the contents of MaterialPropertyStorage for debugging purposes.

Parameters

props

The storage item to dump, this should be MaterialPropertyStorage.props(state)

Currently this only words for scalar material properties. Something to do as needed would be to create a method in MaterialProperty that may be overloaded to dump the type using template specialization.

Definition at line 688 of file MooseUtils.C.

{
  // Loop through the elements
  for (const auto & elem_it : props)
  {
    Moose::out << "Element " << elem_it.first->id() << '\n';

    // Loop through the sides
    for (const auto & side_it : elem_it.second)
    {
      Moose::out << "  Side " << side_it.first << '\n';

      // Loop over properties
      unsigned int cnt = 0;
      for (const auto & mat_prop : side_it.second)
      {
        if (auto mp = dynamic_cast<const MaterialProperty<Real> *>(&mat_prop))
        {
          Moose::out << "    Property " << cnt << '\n';
          cnt++;

          // Loop over quadrature points
          for (unsigned int qp = 0; qp < mp->size(); ++qp)
            Moose::out << "      prop[" << qp << "] = " << (*mp)[qp] << '\n';
        }
      }
    }
  }

  Moose::out << std::flush;
}

mooseDocsURL()

std::string MooseUtils::mooseDocsURL

(

const std::string &

path

)

Returns the URL of a page located on the MOOSE documentation site.

Parameters

[in]

path

URL path following the domain name. For example, in the URL "www.example.com/folder1/folder2/file.html", this would be "folder1/folder2/file.html".

Definition at line 139 of file MooseUtils.C.

Referenced by ExecFlagEnum::getDocString().

{
  return "https://mooseframework.inl.gov/" + path;
}

numDigits()

template<typename T >

int MooseUtils::numDigits

(

const T &

num

)

Return the number of digits for a number.

This can foster quite a large discussion: https://stackoverflow.com/questions/1489830/efficient-way-to-determine-number-of-digits-in-an-integer

For our purposes I like the following algorithm.

Definition at line 928 of file MooseUtils.h.

Referenced by XMLOutput::filename(), JSONOutput::filename(), CSV::getVectorPostprocessorFileName(), CSV::output(), MooseUtils::DelimitedFileReaderTempl< T >::readColumnData(), and MooseUtils::DelimitedFileReaderTempl< T >::readRowData().

{
  return num > 9 ? static_cast<int>(std::log10(static_cast<double>(num))) + 1 : 1;
}

parallelBarrierNotify()

void MooseUtils::parallelBarrierNotify	(	const libMesh::Parallel::Communicator &	comm,
		bool	messaging = true
	)

This function implements a parallel barrier function but writes progress to stdout.

Definition at line 327 of file MooseUtils.C.

Referenced by FEProblemBase::backupMultiApps(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), FEProblemBase::finishMultiAppStep(), and FEProblemBase::restoreMultiApps().

{
  processor_id_type secondary_processor_id;

  if (messaging)
    Moose::out << "Waiting For Other Processors To Finish" << std::endl;
  if (comm.rank() == 0)
  {
    // The primary process is already through, so report it
    if (messaging)
      Moose::out << "Jobs complete: 1/" << comm.size() << (1 == comm.size() ? "\n" : "\r")
                 << std::flush;
    for (unsigned int i = 2; i <= comm.size(); ++i)
    {
      comm.receive(MPI_ANY_SOURCE, secondary_processor_id);
      if (messaging)
        Moose::out << "Jobs complete: " << i << "/" << comm.size()
                   << (i == comm.size() ? "\n" : "\r") << std::flush;
    }
  }
  else
  {
    secondary_processor_id = comm.rank();
    comm.send(0, secondary_processor_id);
  }

  comm.barrier();
}

parsesToReal()

bool MooseUtils::parsesToReal	(	const std::string &	input,
		Real *	parsed_real = nullptr
	)

Check if the input string can be parsed into a Real.

Parameters

input	input to check / parse
parsed_real	pointer to a Real that gets set to the parsed real if it does parse to Real

Definition at line 89 of file MooseUtils.C.

Referenced by DiffusionCG::addFEBCs(), DiffusionCG::addFEKernels(), DiffusionFV::addFVBCs(), DiffusionFV::addFVKernels(), FunctorExtremaPositions::FunctorExtremaPositions(), and FunctorIC::FunctorIC().

{
  std::istringstream ss(input);
  Real real_value;
  if (ss >> real_value && ss.eof())
  {
    if (parsed_real)
      (*parsed_real) = real_value;
    return true;
  }
  return false;
}

pathContains()

bool MooseUtils::pathContains	(	const std::string &	expression,
		const std::string &	string_to_find,
		const std::string &	delims = "/"
	)

This function tokenizes a path and checks to see if it contains the string to look for.

Definition at line 231 of file MooseUtils.C.

{
  std::vector<std::string> elements;
  tokenize(expression, elements, 0, delims);

  std::vector<std::string>::iterator found_it =
      std::find(elements.begin(), elements.end(), string_to_find);
  if (found_it != elements.end())
    return true;
  else
    return false;
}

pathExists()

bool MooseUtils::pathExists

(

const std::string &

path

)

Definition at line 247 of file MooseUtils.C.

Referenced by MooseApp::copyInputs(), FileMeshGenerator::deduceCheckpointPath(), docsDir(), findTestRoot(), installedInputsDir(), RestartableDataReader::isAvailable(), makedirs(), removedirs(), MooseApp::run(), and runTestsExecutable().

{
  struct stat buffer;
  return (stat(path.c_str(), &buffer) == 0);
}

pathjoin() [1/2]

std::filesystem::path MooseUtils::pathjoin

(

const std::filesystem::path &

p

)

Definition at line 59 of file MooseUtils.C.

Referenced by Registry::addAppDataFilePath(), Registry::determineDataFilePath(), docsDir(), findTestRoot(), Moose::DataFileUtils::getPath(), installedInputsDir(), ADFParser::JITCompile(), MooseApp::loadLibraryAndDependencies(), pathjoin(), MooseApp::run(), and runTestsExecutable().

{
  return p;
}

pathjoin() [2/2]

template<typename... Args>

std::filesystem::path MooseUtils::pathjoin	(	const std::filesystem::path &	p,
		Args...	args
	)

Definition at line 65 of file MooseUtils.h.

{
  return p / pathjoin(args...);
}

prettyCppType() [1/2]

std::string MooseUtils::prettyCppType

(

const std::string &

cpp_type

)

Returns

A cleaner representation of the c++ type cpp_type.

Definition at line 1151 of file MooseUtils.C.

Referenced by MooseServer::addParametersToList(), MooseServer::addValuesToList(), InputParametersChecksUtils< BatchMeshGeneratorAction >::assertParamDefined(), ReporterGeneralContext< T >::contextType(), ReporterBroadcastContext< T >::contextType(), ReporterScatterContext< T >::contextType(), ReporterGatherContext< T >::contextType(), ReporterVectorContext< T >::contextType(), Moose::Kokkos::dataLoad(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), MooseServer::gatherDocumentDefinitionLocations(), MooseServer::getFileNameTypeValues(), MooseServer::getNodesByValueAndTypes(), prettyCppType(), ThreadedElementLoop< ConstElemPointerRange >::printExecutionOrdering(), Moose::ParameterRegistry::set(), JsonSyntaxTree::setParams(), and MFEMProblem::solverTypeString().

{
  // On mac many of the std:: classes are inline namespaced with __1
  // On linux std::string can be inline namespaced with __cxx11
  std::string s = cpp_type;
  // Remove all spaces surrounding a >
  pcrecpp::RE("\\s(?=>)").GlobalReplace("", &s);
  pcrecpp::RE("std::__\\w+::").GlobalReplace("std::", &s);
  // It would be nice if std::string actually looked normal
  pcrecpp::RE("\\s*std::basic_string<char, std::char_traits<char>, std::allocator<char>>\\s*")
      .GlobalReplace("std::string", &s);
  // It would be nice if std::vector looked normal
  pcrecpp::RE r("std::vector<([[:print:]]+),\\s?std::allocator<\\s?\\1\\s?>\\s?>");
  r.GlobalReplace("std::vector<\\1>", &s);
  // Do it again for nested vectors
  r.GlobalReplace("std::vector<\\1>", &s);
  return s;
}

prettyCppType() [2/2]

template<typename T >

std::string MooseUtils::prettyCppType

(

const T *

obj = nullptr

)

Returns

A cleaner representation of the type for the given object

Definition at line 345 of file MooseUtils.h.

{
  if (obj)
    return prettyCppType(libMesh::demangle(typeid(*obj).name()));
  else
    return prettyCppType(libMesh::demangle(typeid(T).name()));
}

realpath()

std::string MooseUtils::realpath

(

const std::string &

path

)

Wrapper around PetscGetRealPath, which is a cross-platform replacement for realpath.

Definition at line 1136 of file MooseUtils.C.

Referenced by Parser::parse(), and MooseApp::run().

{
  return std::filesystem::absolute(path);
}

relativeFuzzyEqual()

template<typename T , typename T2 , typename T3 = Real>

bool MooseUtils::relativeFuzzyEqual	(	const T &	var1,
		const T2 &	var2,
		const T3 &	tol = libMesh::TOLERANCE * libMesh::TOLERANCE
	)

Function to check whether two variables are equal within a relative tolerance.

Parameters

var1	The first variable to be checked
var2	The second variable to be checked
tol	The relative tolerance to be used

Returns

true if var1 and var2 are equal within relative tol

Definition at line 494 of file MooseUtils.h.

Referenced by MortarNodalAuxKernelTempl< ComputeValueType >::compute(), MatrixSymmetryCheck::execute(), SymmetricRankFourTensorTempl< T >::fillGeneralOrthotropicFromInputVector(), RankFourTensorTempl< T >::fillGeneralOrthotropicFromInputVector(), SymmetricRankFourTensorTempl< T >::isIsotropic(), RankFourTensorTempl< T >::isIsotropic(), SymmetricRankTwoTensorTempl< Real >::positiveProjectionEigenDecomposition(), and EigenProblem::postScaleEigenVector().

{
  if constexpr (libMesh::ScalarTraits<T>::value ||
                libMesh::TensorTools::MathWrapperTraits<T>::value)
  {
    static_assert(libMesh::TensorTools::TensorTraits<T>::rank ==
                      libMesh::TensorTools::TensorTraits<T2>::rank,
                  "Mathematical types must be same for arguments to relativelyFuzzEqual");
    if constexpr (libMesh::TensorTools::TensorTraits<T>::rank == 0)
      return absoluteFuzzyEqual(
          var1,
          var2,
          tol * (std::abs(MetaPhysicL::raw_value(var1)) + std::abs(MetaPhysicL::raw_value(var2))));
    else if constexpr (libMesh::TensorTools::TensorTraits<T>::rank == 1)
    {
      for (const auto i : make_range(Moose::dim))
        if (!relativeFuzzyEqual(var1(i), var2(i), tol))
          return false;

      return true;
    }
    else if constexpr (libMesh::TensorTools::TensorTraits<T>::rank == 2)
    {
      for (const auto i : make_range(Moose::dim))
        for (const auto j : make_range(Moose::dim))
          if (!relativeFuzzyEqual(var1(i, j), var2(i, j), tol))
            return false;

      return true;
    }
  }
  else
  {
    // We dare to dream
    mooseAssert(var1.size() == var2.size(), "These must be the same size");
    for (const auto i : index_range(var1))
      if (!relativeFuzzyEqual(var1(i), var2(i), tol))
        return false;

    return true;
  }
}

relativeFuzzyGreaterEqual()

template<typename T , typename T2 , typename T3 = T, typename std::enable_if< libMesh::ScalarTraits< T >::value &&libMesh::ScalarTraits< T2 >::value &&libMesh::ScalarTraits< T3 >::value, int >::type = 0>

bool MooseUtils::relativeFuzzyGreaterEqual	(	const T &	var1,
		const T2 &	var2,
		const T3 &	tol = libMesh::TOLERANCE * libMesh::TOLERANCE
	)

Function to check whether a variable is greater than or equal to another variable within a relative tolerance.

Parameters

var1	The first variable to be checked
var2	The second variable to be checked
tol	The tolerance to be used

Returns

true if var1 > var2 or var1 == var2 within relative tol

Definition at line 555 of file MooseUtils.h.

Referenced by FunctionDT::computeDT().

{
  return (absoluteFuzzyGreaterEqual(
      var1,
      var2,
      tol * (std::abs(MetaPhysicL::raw_value(var1)) + std::abs(MetaPhysicL::raw_value(var2)))));
}

relativeFuzzyGreaterThan()

template<typename T , typename T2 , typename T3 = T, typename std::enable_if< libMesh::ScalarTraits< T >::value &&libMesh::ScalarTraits< T2 >::value &&libMesh::ScalarTraits< T3 >::value, int >::type = 0>

bool MooseUtils::relativeFuzzyGreaterThan	(	const T &	var1,
		const T2 &	var2,
		const T3 &	tol = libMesh::TOLERANCE * libMesh::TOLERANCE
	)

Function to check whether a variable is greater than another variable within a relative tolerance.

Parameters

var1	The first variable to be checked
var2	The second variable to be checked
tol	The tolerance to be used

Returns

true if var1 > var2 and var1 != var2 within relative tol

Definition at line 580 of file MooseUtils.h.

{
  return (absoluteFuzzyGreaterThan(
      var1,
      var2,
      tol * (std::abs(MetaPhysicL::raw_value(var1)) + std::abs(MetaPhysicL::raw_value(var2)))));
}

relativeFuzzyLessEqual()

template<typename T , typename T2 , typename T3 = T, typename std::enable_if< libMesh::ScalarTraits< T >::value &&libMesh::ScalarTraits< T2 >::value &&libMesh::ScalarTraits< T3 >::value, int >::type = 0>

bool MooseUtils::relativeFuzzyLessEqual	(	const T &	var1,
		const T2 &	var2,
		const T3 &	tol = libMesh::TOLERANCE * libMesh::TOLERANCE
	)

Function to check whether a variable is less than or equal to another variable within a relative tolerance.

Parameters

var1	The first variable to be checked
var2	The second variable to be checked
tol	The tolerance to be used

Returns

true if var1 < var2 or var1 == var2 within relative tol

Definition at line 606 of file MooseUtils.h.

{
  return (absoluteFuzzyLessEqual(
      var1,
      var2,
      tol * (std::abs(MetaPhysicL::raw_value(var1)) + std::abs(MetaPhysicL::raw_value(var2)))));
}

relativeFuzzyLessThan()

template<typename T , typename T2 , typename T3 = T, typename std::enable_if< libMesh::ScalarTraits< T >::value &&libMesh::ScalarTraits< T2 >::value &&libMesh::ScalarTraits< T3 >::value, int >::type = 0>

bool MooseUtils::relativeFuzzyLessThan	(	const T &	var1,
		const T2 &	var2,
		const T3 &	tol = libMesh::TOLERANCE * libMesh::TOLERANCE
	)

Function to check whether a variable is less than another variable within a relative tolerance.

Parameters

var1	The first variable to be checked
var2	The second variable to be checked
tol	The tolerance to be used

Returns

true if var1 < var2 and var1 != var2 within relative tol

Definition at line 631 of file MooseUtils.h.

Referenced by PenetrationThread::competeInteractionsBothOnFace(), and FunctionDT::computeDT().

{
  return (absoluteFuzzyLessThan(
      var1,
      var2,
      tol * (std::abs(MetaPhysicL::raw_value(var1)) + std::abs(MetaPhysicL::raw_value(var2)))));
}

removeColor()

std::string & MooseUtils::removeColor

(

std::string &

msg

)

remove ANSI escape sequences for terminal color from msg

Definition at line 722 of file MooseUtils.C.

Referenced by Console::writeStreamToFile().

{
  pcrecpp::RE re("(\\33\\[3[0-7]m))", pcrecpp::DOTALL());
  re.GlobalReplace(std::string(""), &msg);
  return msg;
}

removedirs()

void MooseUtils::removedirs	(	const std::string &	dir_name,
		bool	throw_on_failure = false
	)

Recursively remove directories from inner-most when the directories are empty.

Parameters

dir_name	A complete path
throw_on_failure	True to throw instead of error out when deleting a directory is failed.

The path can be relative like 'a/b/c' or absolute like '/a/b/c'. The path is allowed to contain '.' or '..'.

Definition at line 505 of file MooseUtils.C.

{
  // split path into directories with delimiter '/'
  std::vector<std::string> split_dir_names;
  MooseUtils::tokenize(dir_name, split_dir_names);

  auto n = split_dir_names.size();

  // remove '.' and '..' when possible
  auto i = n;
  i = 0;
  while (i != n)
  {
    if (split_dir_names[i] == ".")
    {
      for (auto j = i + 1; j < n; ++j)
        split_dir_names[j - 1] = split_dir_names[j];
      --n;
    }
    else if (i > 0 && split_dir_names[i] == ".." && split_dir_names[i - 1] != "..")
    {
      for (auto j = i + 1; j < n; ++j)
        split_dir_names[j - 2] = split_dir_names[j];
      n -= 2;
      --i;
    }
    else
      ++i;
  }
  if (n == 0)
    return;

  split_dir_names.resize(n);

  // start removing directories recursively
  std::string base_dir = dir_name[0] == '/' ? "" : ".";
  for (i = n; i > 0; --i)
  {
    std::string cur_dir = base_dir;
    auto j = i;
    for (j = 0; j < i; ++j)
      cur_dir += "/" + split_dir_names[j];

    // listDir should return at least '.' and '..'
    if (pathExists(cur_dir) && listDir(cur_dir).size() == 2)
    {
      auto code = rmdir(cur_dir.c_str());
      if (code != 0)
      {
        std::string msg = "Failed removing directory " + dir_name;
        if (throw_on_failure)
          throw std::invalid_argument(msg);
        else
          mooseError(msg);
      }
    }
    else
      // stop removing
      break;
  }
}

removeExtraWhitespace()

std::string MooseUtils::removeExtraWhitespace

(

const std::string &

str

)

Removes additional whitespace from a string.

Removes beginning whitespace, end whitespace, and repeated whitespace into a single space

Definition at line 225 of file MooseUtils.C.

Referenced by CommandLine::initSubAppCommandLine(), and CommandLine::parse().

{
  return std::regex_replace(input, std::regex("^\\s+|\\s+$|\\s+(?=\\s)"), "");
}

replaceAll()

std::string MooseUtils::replaceAll	(	std::string	str,
		const std::string &	from,
		const std::string &	to
	)

Replaces all occurrences of from in str with to and returns the result.

Definition at line 145 of file MooseUtils.C.

Referenced by ReporterDebugOutput::output(), and MooseUtils::DelimitedFileReaderTempl< T >::processLine().

{
  size_t start_pos = 0;
  while ((start_pos = str.find(from, start_pos)) != std::string::npos)
  {
    str.replace(start_pos, from.length(), to);
    start_pos += to.length(); // Handles case where 'to' is a substring of 'from'
  }
  return str;
}

replaceStart()

void MooseUtils::replaceStart	(	std::string &	string1,
		const std::string &	string2,
		const std::string &	string3
	)

Replace the starting string string2 of string1 with string3.

A user should have checked that string1 startsWith string2

Definition at line 1185 of file MooseUtils.C.

{
  mooseAssert(startsWith(string1, string2),
              "Cannot replace the start because it doesn't match the start string");
  string1.replace(0, string2.size(), string3);
}

resample() [1/4]

template<typename T >

std::vector< T > MooseUtils::resample	(	const std::vector< T > &	data,
		MooseRandom &	generator,
		const std::size_t	seed_index = 0
	)

Randomly resample a vector of data, allowing a value to be repeated.

Parameters

data	The vector on which the values are to be swapped
generator	Random number generator to use for shuffle
seed_index	(default: 0) The seed index to use for calls to randl
comm_ptr	Optional Communicator, if provided and running with multiple processors the vector is assumed to be distributed

Definition at line 530 of file Shuffle.h.

Referenced by resample().

{
  return MooseUtils::resample(data, generator, seed_index, nullptr);
}

resample() [2/4]

template<typename T >

std::vector< T > MooseUtils::resample	(	const std::vector< T > &	data,
		MooseRandom &	generator,
		const libMesh::Parallel::Communicator &	comm
	)

Definition at line 539 of file Shuffle.h.

{
  return MooseUtils::resample(data, generator, 0, &comm);
}

resample() [3/4]

template<typename T >

std::vector< T > MooseUtils::resample	(	const std::vector< T > &	data,
		MooseRandom &	generator,
		const std::size_t	seed_index,
		const libMesh::Parallel::Communicator &	comm
	)

Definition at line 548 of file Shuffle.h.

{
  return MooseUtils::resample(data, generator, seed_index, &comm);
}

resample() [4/4]

template<typename T >

std::vector< T > MooseUtils::resample	(	const std::vector< T > &	data,
		MooseRandom &	generator,
		const std::size_t	seed_index,
		const libMesh::Parallel::Communicator *	comm_ptr
	)

Definition at line 334 of file Shuffle.h.

{
  // Size of the local input data
  const std::size_t n_local = data.size();

  // Re-sampled data vector to be returned
  std::vector<T> replicate(n_local);

  // REPLICATED data
  if (!comm_ptr || comm_ptr->size() == 1)
  {
    replicate.resize(n_local);
    for (std::size_t j = 0; j < n_local; ++j)
    {
      auto index = generator.randl(seed_index, 0, n_local);
      replicate[j] = data[index];
    }
  }

  // DISTRIBUTED data
  else
  {
    // Compute the global size of the vector
    std::size_t n_global = n_local;
    comm_ptr->sum(n_global);

    // Compute the vector data offsets, the scope cleans up the "n_local" vector
    std::vector<std::size_t> offsets(comm_ptr->size());
    {
      std::vector<std::size_t> local_sizes;
      comm_ptr->allgather(n_local, local_sizes);
      for (std::size_t i = 0; i < local_sizes.size() - 1; ++i)
        offsets[i + 1] = offsets[i] + local_sizes[i];
    }

    // Advance the random number generator to the current offset
    const auto rank = comm_ptr->rank();
    for (std::size_t i = 0; i < offsets[rank]; ++i)
      generator.randl(seed_index, 0, n_global);

    // Compute the needs for this processor
    std::unordered_map<processor_id_type, std::vector<std::pair<std::size_t, std::size_t>>> needs;
    for (std::size_t i = 0; i < n_local; ++i)
    {
      const auto idx = generator.randl(seed_index, 0, n_global); // random global index

      // Locate the rank and local index of the data desired
      const auto idx_offset_iter = std::prev(std::upper_bound(offsets.begin(), offsets.end(), idx));
      const auto idx_rank = std::distance(offsets.begin(), idx_offset_iter);
      const auto idx_local_idx = idx - *idx_offset_iter;

      // Local available data can be inserted into the re-sample, non-local data is add the the
      // needs from other ranks
      if (idx_rank == rank)
        replicate[i] = data[idx_local_idx];
      else
        needs[idx_rank].emplace_back(idx_local_idx, i);
    }

    // Advance the random number generator to the end of the global vector
    for (std::size_t i = offsets[rank] + n_local; i < n_global; ++i)
      generator.randl(seed_index, 0, n_global);

    // Collect the values to be returned to the various processors
    std::unordered_map<processor_id_type, std::vector<std::pair<T, std::size_t>>> returns;
    auto return_functor =
        [&data, &returns](processor_id_type pid,
                          const std::vector<std::pair<std::size_t, std::size_t>> & indices)
    {
      auto & returns_pid = returns[pid];
      for (const auto & idx : indices)
        returns_pid.emplace_back(data[idx.first], idx.second);
    };
    Parallel::push_parallel_vector_data(*comm_ptr, needs, return_functor);

    // Receive resampled values from the various processors
    auto recv_functor =
        [&replicate](processor_id_type, const std::vector<std::pair<T, std::size_t>> & values)
    {
      for (const auto & value : values)
        replicate[value.second] = value.first;
    };
    Parallel::push_parallel_vector_data(*comm_ptr, returns, recv_functor);
  }
  return replicate;
}

resampleWithFunctor() [1/4]

template<typename T , typename ActionFunctor >

void MooseUtils::resampleWithFunctor	(	const std::vector< T > &	data,
		const ActionFunctor &	functor,
		MooseRandom &	generator,
		const std::size_t	seed_index = 0
	)

Randomly resample a vector of data and apply a functor, allowing a value to be repeated.

Parameters

data	The vector on which the values are to be swapped
functor	Functor to apply to each entry of the resampled vector
generator	Random number generator to use for shuffle
seed_index	(default: 0) The seed index to use for calls to randl
comm_ptr	Optional Communicator, if provided and running with multiple processors the vector is assumed to be distributed

Definition at line 558 of file Shuffle.h.

Referenced by resampleWithFunctor().

{
  return MooseUtils::resampleWithFunctor(data, functor, generator, seed_index, nullptr);
}

resampleWithFunctor() [2/4]

template<typename T , typename ActionFunctor >

void MooseUtils::resampleWithFunctor	(	const std::vector< T > &	data,
		const ActionFunctor &	functor,
		MooseRandom &	generator,
		const libMesh::Parallel::Communicator &	comm
	)

Definition at line 568 of file Shuffle.h.

{
  return MooseUtils::resampleWithFunctor(data, functor, generator, 0, &comm);
}

resampleWithFunctor() [3/4]

template<typename T , typename ActionFunctor >

void MooseUtils::resampleWithFunctor	(	const std::vector< T > &	data,
		const ActionFunctor &	functor,
		MooseRandom &	generator,
		const std::size_t	seed_index,
		const libMesh::Parallel::Communicator &	comm
	)

Definition at line 578 of file Shuffle.h.

{
  return MooseUtils::resampleWithFunctor(data, functor, generator, seed_index, &comm);
}

resampleWithFunctor() [4/4]

template<typename T , typename ActionFunctor >

void MooseUtils::resampleWithFunctor	(	const std::vector< T > &	data,
		const ActionFunctor &	functor,
		MooseRandom &	generator,
		const std::size_t	seed_index,
		const libMesh::Parallel::Communicator *	comm_ptr
	)

Definition at line 426 of file Shuffle.h.

{
  const std::size_t n_local = data.size();

  if (!comm_ptr || comm_ptr->size() == 1)
  {
    for (std::size_t j = 0; j < n_local; ++j)
    {
      auto index = generator.randl(seed_index, 0, n_local);
      functor(data[index]);
    }
  }
  else
  {
    // Compute the global size of the vector
    std::size_t n_global = n_local;
    comm_ptr->sum(n_global);

    // Compute the vector data offsets, the scope cleans up the "n_local" vector
    std::vector<std::size_t> offsets(comm_ptr->size());
    {
      std::vector<std::size_t> local_sizes;
      comm_ptr->allgather(n_local, local_sizes);
      for (std::size_t i = 0; i < local_sizes.size() - 1; ++i)
        offsets[i + 1] = offsets[i] + local_sizes[i];
    }

    // Advance the random number generator to the current offset
    const auto rank = comm_ptr->rank();
    for (std::size_t i = 0; i < offsets[rank]; ++i)
      generator.randl(seed_index, 0, n_global);

    // Compute the needs for this processor
    std::unordered_map<processor_id_type, std::vector<std::size_t>> indices;
    for (std::size_t i = 0; i < n_local; ++i)
    {
      const auto idx = generator.randl(seed_index, 0, n_global); // random global index

      // Locate the rank and local index of the data desired
      const auto idx_offset_iter = std::prev(std::upper_bound(offsets.begin(), offsets.end(), idx));
      const auto idx_rank = std::distance(offsets.begin(), idx_offset_iter);
      const auto idx_local_idx = idx - *idx_offset_iter;

      // Push back the index to appropriate rank
      indices[idx_rank].push_back(idx_local_idx);
    }

    // Advance the random number generator to the end of the global vector
    for (std::size_t i = offsets[rank] + n_local; i < n_global; ++i)
      generator.randl(seed_index, 0, n_global);

    // Send the indices to the appropriate rank and have the calculator do its work
    auto act_functor =
        [&functor, &data](processor_id_type /*pid*/, const std::vector<std::size_t> & indices)
    {
      for (const auto & idx : indices)
        functor(data[idx]);
    };
    Parallel::push_parallel_vector_data(*comm_ptr, indices, act_functor);
  }
}

reset() [1/2]

template<class T , typename... Args>

auto MooseUtils::reset	(	int	,
		T &	obj,
		Args...	args
	)		-> decltype(obj.reset(args...), void())

Definition at line 21 of file SharedPool.h.

Referenced by MooseUtils::SharedPool< T >::acquire().

{
  obj.reset(std::forward<Args>(args)...);
}

reset() [2/2]

template<class T , typename... Args>

void MooseUtils::reset	(	double	,
		T &	,
		Args...
	)

Definition at line 28 of file SharedPool.h.

{
}

rsplit()

std::vector< std::string > MooseUtils::rsplit	(	const std::string &	str,
		const std::string &	delimiter,
		std::size_t	max_count = std::numeric_limits<std::size_t>::max()
	)

Definition at line 1051 of file MooseUtils.C.

{
  std::vector<std::string> output;
  std::size_t count = 0;
  size_t prev = str.length(), pos = str.length();
  do
  {
    pos = str.rfind(delimiter, prev);
    output.insert(output.begin(), str.substr(pos + delimiter.length(), prev - pos));
    prev = pos - delimiter.length();
    count += 1;
  } while (pos != std::string::npos && pos > 0 && count < max_count);

  if (pos != std::string::npos)
    output.insert(output.begin(), str.substr(0, pos));

  return output;
}

runTestsExecutable()

std::string MooseUtils::runTestsExecutable

(

)

Returns the location of either a local repo run_tests script - or an installed test executor script if run_tests isn't found.

Definition at line 65 of file MooseUtils.C.

Referenced by MooseApp::runInputs().

{
  auto build_loc = pathjoin(Moose::getExecutablePath(), "run_tests");
  if (pathExists(build_loc) && checkFileReadable(build_loc))
    return build_loc;
  // TODO: maybe no path prefix - just moose_test_runner here?
  return pathjoin(Moose::getExecutablePath(), "moose_test_runner");
}

serialBegin()

void MooseUtils::serialBegin	(	const libMesh::Parallel::Communicator &	comm,
		bool	warn = true
	)

This function marks the begin of a section of code that is executed in serial rank by rank.

The section must be closed with a call to serialEnd. These functions are intended for debugging use to obtain clean terminal output from multiple ranks (use –keep-cout).

Parameters

comm	The communicator to use
warn	Whether or not to warn that something is being serialized

Definition at line 357 of file MooseUtils.C.

Referenced by SerializerGuard::SerializerGuard().

{
  // unless we are the first processor...
  if (comm.rank() > 0)
  {
    // ...wait for the previous processor to finish
    int dummy = 0;
    comm.receive(comm.rank() - 1, dummy);
  }
  else if (warn)
    mooseWarning("Entering serial execution block (use only for debugging)");
}

serialEnd()

void MooseUtils::serialEnd	(	const libMesh::Parallel::Communicator &	comm,
		bool	warn = true
	)

Closes a section of code that is executed in serial rank by rank, and that was opened with a call to serialBegin.

No MPI communication can happen in this block.

Parameters

comm	The communicator to use
warn	Whether or not to warn that something is being serialized

Definition at line 371 of file MooseUtils.C.

Referenced by SerializerGuard::~SerializerGuard().

{
  // unless we are the last processor...
  if (comm.rank() + 1 < comm.size())
  {
    // ...notify the next processor of its turn
    int dummy = 0;
    comm.send(comm.rank() + 1, dummy);
  }

  comm.barrier();
  if (comm.rank() == 0 && warn)
    mooseWarning("Leaving serial execution block (use only for debugging)");
}

setsIntersect() [1/2]

template<class InputIterator >

bool MooseUtils::setsIntersect	(	InputIterator	first1,
		InputIterator	last1,
		InputIterator	first2,
		InputIterator	last2
	)

This method detects whether two sets intersect without building a result set.

It exits as soon as any intersection is detected.

Definition at line 1160 of file MooseUtils.h.

Referenced by Coupleable::checkWritableVar(), and setsIntersect().

{
  while (first1 != last1 && first2 != last2)
  {
    if (*first1 == *first2)
      return true;

    if (*first1 < *first2)
      ++first1;
    else if (*first1 > *first2)
      ++first2;
  }
  return false;
}

setsIntersect() [2/2]

template<class T >

bool MooseUtils::setsIntersect	(	const T &	s1,
		const T &	s2
	)

Definition at line 1177 of file MooseUtils.h.

{
  return setsIntersect(s1.begin(), s1.end(), s2.begin(), s2.end());
}

shortName()

std::string MooseUtils::shortName

(

const std::string &

name

)

Function for stripping name after the file / in parser block.

Definition at line 612 of file MooseUtils.C.

Referenced by InputParameterWarehouse::addInputParameters(), ActionFactory::create(), CSV::getVectorPostprocessorFileName(), CSV::getVectorPostprocessorFilePrefix(), and CSV::initialSetup().

{
  return name.substr(name.find_last_of('/') != std::string::npos ? name.find_last_of('/') + 1 : 0);
}

shuffle() [1/4]

template<typename T >

void MooseUtils::shuffle	(	std::vector< T > &	data,
		MooseRandom &	generator,
		const std::size_t	seed_index = 0
	)

Shuffle function for serial or distributed vector of data that shuffles in place.

Parameters

data	The vector on which the values are to be swapped
generator	Random number generator to use for shuffle
seed_index	(default: 0) The seed index to use for calls to randl
comm_ptr	Optional Communicator, if provided and running with multiple processors the vector is assumed to be distributed

Both the serial and distributed version implement a Fisher-Yates shuffle https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle

NOTE: This distributed shuffle I have here does a parallel communication with each swap pair generated. I am certain that there are more efficient ways to shuffle a distributed vector, but there doesn't seem to be an algorithm in the literature (my search was not extensive).

The reason I came to this conclusion was because of a 2019 paper, which states the following (https://iopscience.iop.org/article/10.1088/1742-6596/1196/1/012035):

The study also says that the Fisher-Yates Shuffle can be developed in two ways,
namely the algorithm's initial assumptions that allow for discrete uniform variables,
and also with the avent of large core clusters and GPUs, there is an interest in making
parallel versions of this algorithm.

This paper discusses the MergeShuffle (https://arxiv.org/abs/1508.03167), but that is a shared memory parallel algorithm.

Hence, if you want to become famous create a parallel Fisher-Yates algorithm for MPI.

Definition at line 504 of file Shuffle.h.

Referenced by shuffle().

{
  return MooseUtils::shuffle(data, generator, seed_index, nullptr);
}

shuffle() [2/4]

template<typename T >

void MooseUtils::shuffle	(	std::vector< T > &	data,
		MooseRandom &	generator,
		const libMesh::Parallel::Communicator &	comm
	)

Definition at line 511 of file Shuffle.h.

{
  return MooseUtils::shuffle(data, generator, 0, &comm);
}

shuffle() [3/4]

template<typename T >

void MooseUtils::shuffle	(	std::vector< T > &	data,
		MooseRandom &	generator,
		const std::size_t	seed_index,
		const libMesh::Parallel::Communicator &	comm
	)

Definition at line 520 of file Shuffle.h.

{
  return MooseUtils::shuffle(data, generator, seed_index, &comm);
}

shuffle() [4/4]

template<typename T >

void MooseUtils::shuffle	(	std::vector< T > &	data,
		MooseRandom &	generator,
		const std::size_t	seed_index,
		const libMesh::Parallel::Communicator *	comm_ptr
	)

Definition at line 243 of file Shuffle.h.

{
  // REPLICATED data
  if (!comm_ptr || comm_ptr->size() == 1)
  {
    std::size_t n_global = data.size();
    for (std::size_t i = n_global - 1; i > 0; --i)
    {
      auto j = generator.randl(seed_index, 0, i);
      MooseUtils::swap(data, i, j, nullptr);
    }
  }

  // DISTRIBUTED data
  else
  {
    // Local/global size
    std::size_t n_local = data.size();
    std::size_t n_global = n_local;
    comm_ptr->sum(n_global);

    // Compute the vector data offsets, the scope cleans up the "n_local" vector
    std::vector<std::size_t> offsets(comm_ptr->size());
    {
      std::vector<std::size_t> local_sizes;
      comm_ptr->allgather(n_local, local_sizes);
      for (std::size_t i = 0; i < local_sizes.size() - 1; ++i)
        offsets[i + 1] = offsets[i] + local_sizes[i];
    }

    // Perform swaps
    auto rank = comm_ptr->rank();
    for (std::size_t idx0 = n_global - 1; idx0 > 0; --idx0)
    {
      auto idx1 = generator.randl(seed_index, 0, idx0);

      // Locate the rank and local index of the data to swap
      auto idx0_offset_iter = std::prev(std::upper_bound(offsets.begin(), offsets.end(), idx0));
      auto idx0_rank = std::distance(offsets.begin(), idx0_offset_iter);
      auto idx0_local_idx = idx0 - *idx0_offset_iter;

      auto idx1_offset_iter = std::prev(std::upper_bound(offsets.begin(), offsets.end(), idx1));
      auto idx1_rank = std::distance(offsets.begin(), idx1_offset_iter);
      auto idx1_local_idx = idx1 - *idx1_offset_iter;

      // The values, if any, needed from other rank
      std::unordered_map<processor_id_type, std::vector<std::size_t>> needs;
      if (idx0_rank != rank && idx1_rank == rank)
        needs[idx0_rank].push_back(idx0_local_idx);
      if (idx0_rank == rank && idx1_rank != rank)
        needs[idx1_rank].push_back(idx1_local_idx);

      // Collect the values needed by this processor
      std::unordered_map<processor_id_type, std::vector<T>> returns;
      auto return_functor =
          [&data, &returns](processor_id_type pid, const std::vector<std::size_t> & indices)
      {
        auto & returns_pid = returns[pid];
        for (auto idx : indices)
          returns_pid.push_back(data[idx]);
      };
      Parallel::push_parallel_vector_data(*comm_ptr, needs, return_functor);

      // Receive needed values from the others processors
      std::vector<T> incoming;
      auto recv_functor = [&incoming](processor_id_type /*pid*/, const std::vector<T> & values)
      { incoming = values; };
      Parallel::push_parallel_vector_data(*comm_ptr, returns, recv_functor);

      if (idx0_rank == rank && idx1_rank == rank)
        MooseUtils::swap(data, idx0_local_idx, idx1_local_idx);

      else if (idx0_rank == rank)
      {
        mooseAssert(incoming.size() == 1, "Only one value should be received");
        data[idx0_local_idx] = incoming[0];
      }
      else if (idx1_rank == rank)
      {
        mooseAssert(incoming.size() == 1, "Only one value should be received");
        data[idx1_local_idx] = incoming[0];
      }
    }
  }
}

split()

std::vector< std::string > MooseUtils::split	(	const std::string &	str,
		const std::string &	delimiter,
		std::size_t	max_count = std::numeric_limits<std::size_t>::max()
	)

Python like split functions for strings.

NOTE: This is similar to the tokenize function, but it maintains empty items, which tokenize does not. For example, "foo;bar;;" becomes {"foo", "bar", "", ""}.

Definition at line 1031 of file MooseUtils.C.

Referenced by SONDefinitionFormatter::addParameters(), BatchMeshGeneratorAction::convertStringToCompoundRealScalar(), MeshGenerator::generateInternal(), MultiApp::getCommandLineArgs(), Moose::ParameterRegistration::setDoubleVectorValue(), and MooseApp::setMFEMDevice().

{
  std::vector<std::string> output;
  std::size_t count = 0;
  size_t prev = 0, pos = 0;
  do
  {
    pos = str.find(delimiter, prev);
    output.push_back(str.substr(prev, pos - prev));
    prev = pos + delimiter.length();
    count += 1;
  } while (pos != std::string::npos && count < max_count);

  if (pos != std::string::npos)
    output.push_back(str.substr(prev));

  return output;
}

splitFileName()

template<typename T >

std::pair<std::filesystem::path, std::filesystem::path> MooseUtils::splitFileName

(

const T &

full_file

)

Function for splitting path and filename.

Parameters

full_file

A complete filename and path

Returns

A std::pair<std::string, std::string> containing the path and filename

If the supplied filename does not contain a path, it returns "." as the path

Definition at line 263 of file MooseUtils.h.

Referenced by Registry::addAppDataFilePath(), FileRangeBuilder::FileRangeBuilder(), and MooseApp::loadLibraryAndDependencies().

{
  const auto p = std::filesystem::path(std::string(full_file));
  // Error if path ends with /
  if (!p.has_filename())
    mooseError("Invalid full file name: ", p);

  const auto d = p.parent_path();
  return {d.empty() ? "." : d, p.filename()};
}

startsWith()

bool MooseUtils::startsWith	(	const std::string &	string1,
		const std::string &	string2
	)

Returns

Whether the string1 starts with string2

Definition at line 1177 of file MooseUtils.C.

Referenced by replaceStart().

{
  if (string2.size() > string1.size())
    return false;
  return string1.compare(0, string2.size(), string2) == 0;
}

stringJoin()

std::string MooseUtils::stringJoin	(	const std::vector< std::string > &	values,
		const std::string &	separator = " "
	)

Concatenates value into a single string separated by separator.

Definition at line 955 of file MooseUtils.C.

Referenced by InputParameters::addCommandLineParamHelper(), Moose::Builder::build(), InputParameters::checkParams(), Parser::joinErrorMessages(), Parser::parse(), and ParsedPostprocessor::ParsedPostprocessor().

{
  std::string combined;
  for (const auto & value : values)
    combined += value + separator;
  if (values.size())
    combined = combined.substr(0, combined.size() - separator.size());
  return combined;
}

stringToInteger()

int MooseUtils::stringToInteger	(	const std::string &	input,
		bool	throw_on_failure = false
	)

Robust string to integer conversion that fails for cases such at "1foo".

Parameters

input	The string to convert.
throw_on_failure	Throw an invalid_argument exception instead of mooseError.

Definition at line 978 of file MooseUtils.C.

Referenced by FormattedTable::printTable().

{
  return convert<int>(input, throw_on_failure);
}

stripExtension()

std::string MooseUtils::stripExtension	(	const std::string &	s,
		const bool	rfind = false
	)

Removes any file extension from the given string s (i.e.

any ".[extension]" suffix of s) and returns the result.

Definition at line 427 of file MooseUtils.C.

Referenced by SplitMeshAction::act(), CommonOutputAction::act(), and SetupMeshAction::modifyParamsForUseSplit().

{
  const std::string ext = getExtension(s, rfind);
  const bool offset = (ext.size() != 0);
  // -1 offset accounts for the extension's leading dot ("."), if there is an extension
  return s.substr(0, s.size() - ext.size() - offset);
}

swap() [1/2]

template<typename T >

void MooseUtils::swap	(	std::vector< T > &	data,
		const std::size_t	idx0,
		const std::size_t	idx1,
		const libMesh::Parallel::Communicator &	comm
	)

Swap function for serial or distributed vector of data.

Parameters

data	The vector on which the values are to be swapped
idx0,idx1	The global indices to be swapped
comm_ptr	Optional Communicator, if provided and running with multiple processors the vector is assumed to be distributed

Definition at line 494 of file Shuffle.h.

Referenced by Syntax::addDependencySets(), AllNodesSendListThread::AllNodesSendListThread(), Moose::applyIndices(), AutomaticMortarGeneration::buildMortarSegmentMesh(), RestartableDataReader::clear(), AdvancedExtruderGenerator::generate(), DistributedRectilinearMeshGenerator::paritionSquarely(), MaterialPropertyStorage::shift(), shuffle(), swap(), MooseUtils::StaticallyAllocatedSet< T, N >::swap(), Moose::Kokkos::Map< unsigned int, unsigned int >::swap(), MooseArray< libMesh::VectorValue >::swap(), MooseUtils::Buffer< T >::swap(), and ElementSubdomainModifierBase::timestepSetup().

{
  MooseUtils::swap<T>(data, idx0, idx1, &comm);
}

swap() [2/2]

template<typename T >

void MooseUtils::swap	(	std::vector< T > &	data,
		const std::size_t	idx0,
		const std::size_t	idx1,
		const libMesh::Parallel::Communicator *	comm_ptr = nullptr
	)

Definition at line 155 of file Shuffle.h.

{
  if (!comm_ptr || comm_ptr->size() == 1)
  {
    mooseAssert(idx0 < data.size(),
                "idx0 (" << idx0 << ") out of range, data.size() is " << data.size());
    mooseAssert(idx1 < data.size(),
                "idx1 (" << idx1 << ") out of range, data.size() is " << data.size());
    std::swap(data[idx0], data[idx1]);
  }

  else
  {
    // Size of the local input data
    const auto n_local = data.size();
    const auto rank = comm_ptr->rank();

    // Compute the global size of the vector
    std::size_t n_global = n_local;
    comm_ptr->sum(n_global);
    mooseAssert(idx0 < n_global,
                "idx0 (" << idx0 << ") out of range, the global data size is " << n_global);
    mooseAssert(idx1 < n_global,
                "idx1 (" << idx1 << ") out of range, the global data size is " << n_global);

    // Compute the vector data offsets, the scope cleans up the "n_local" vector
    std::vector<std::size_t> offsets(comm_ptr->size());
    {
      std::vector<std::size_t> local_sizes;
      comm_ptr->allgather(n_local, local_sizes);
      for (std::size_t i = 0; i < local_sizes.size() - 1; ++i)
        offsets[i + 1] = offsets[i] + local_sizes[i];
    }

    // Locate the rank and local index of the data to swap
    auto idx0_offset_iter = std::prev(std::upper_bound(offsets.begin(), offsets.end(), idx0));
    auto idx0_rank = std::distance(offsets.begin(), idx0_offset_iter);
    auto idx0_local_idx = idx0 - *idx0_offset_iter;

    auto idx1_offset_iter = std::prev(std::upper_bound(offsets.begin(), offsets.end(), idx1));
    auto idx1_rank = std::distance(offsets.begin(), idx1_offset_iter);
    auto idx1_local_idx = idx1 - *idx1_offset_iter;

    // The values, if any, needed from other rank
    std::unordered_map<processor_id_type, std::vector<std::size_t>> needs;
    if (idx0_rank != rank && idx1_rank == rank)
      needs[idx0_rank].push_back(idx0_local_idx);
    if (idx0_rank == rank && idx1_rank != rank)
      needs[idx1_rank].push_back(idx1_local_idx);

    // Collect the values needed by this processor
    std::unordered_map<processor_id_type, std::vector<T>> returns;
    auto return_functor =
        [&data, &returns](processor_id_type pid, const std::vector<std::size_t> & indices)
    {
      auto & returns_pid = returns[pid];
      for (auto idx : indices)
        returns_pid.push_back(data[idx]);
    };
    Parallel::push_parallel_vector_data(*comm_ptr, needs, return_functor);

    // Receive needed values from the others processors
    std::vector<T> incoming;
    auto recv_functor = [&incoming](processor_id_type /*pid*/, const std::vector<T> & values)
    { incoming = values; };
    Parallel::push_parallel_vector_data(*comm_ptr, returns, recv_functor);

    if (idx0_rank == rank && idx1_rank == rank)
      MooseUtils::swap(data, idx0_local_idx, idx1_local_idx);

    else if (idx0_rank == rank)
    {
      mooseAssert(incoming.size() == 1, "Only one value should be received");
      data[idx0_local_idx] = incoming[0];
    }
    else if (idx1_rank == rank)
    {
      mooseAssert(incoming.size() == 1, "Only one value should be received");
      data[idx1_local_idx] = incoming[0];
    }
  }
}

tokenize()

template<typename T >

void MooseUtils::tokenize	(	const std::string &	str,
		std::vector< T > &	elements,
		unsigned int	min_len = 1,
		const std::string &	delims = "/"
	)

This function will split the passed in string on a set of delimiters appending the substrings to the passed in vector.

The delimiters default to "/" but may be supplied as well. In addition if min_len is supplied, the minimum token length will be >= than the supplied value. T should be std::string or a MOOSE derived string class.

Definition at line 55 of file MooseStringUtils.h.

Referenced by InputParameters::addCommandLineParamHelper(), Syntax::addDependencySets(), MooseEnumBase::addEnumerationName(), MooseEnumBase::addEnumerationNames(), JsonInputFileFormatter::addLine(), InputParameters::addParamNamesToGroup(), MultiMooseEnum::eraseSetValue(), TransfiniteMeshGenerator::getDiscreteEdge(), MooseApp::getLibrarySearchPaths(), TransfiniteMeshGenerator::getParsedEdge(), Syntax::isAssociated(), makedirs(), MultiMooseEnum::operator=(), FunctionMaterialPropertyDescriptor< is_ad >::parseDependentSymbols(), FunctionMaterialPropertyDescriptor< is_ad >::parseDerivative(), pathContains(), InputFileFormatter::printParams(), MooseUtils::DelimitedFileReaderTempl< T >::readColumnData(), InputParameters::registerBuildableTypes(), removedirs(), MultiMooseEnum::setAdditionalValue(), CommandLine::setCommandLineParam(), Moose::ParameterRegistration::setTripleVectorValue(), MooseApp::showInputs(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), tokenizeAndConvert(), and wildCardMatch().

{
  elements.clear();

  std::string::size_type last_pos = str.find_first_not_of(delims, 0);
  std::string::size_type pos = str.find_first_of(delims, std::min(last_pos + min_len, str.size()));

  while (last_pos != std::string::npos)
  {
    elements.push_back(str.substr(last_pos, pos - last_pos));
    // skip delims between tokens
    last_pos = str.find_first_not_of(delims, pos);
    if (last_pos == std::string::npos)
      break;
    pos = str.find_first_of(delims, std::min(last_pos + min_len, str.size()));
  }
}

tokenizeAndConvert()

template<typename T >

bool MooseUtils::tokenizeAndConvert	(	const std::string &	str,
		std::vector< T > &	tokenized_vector,
		const std::string &	delimiter = " \t\n\v\f\r"
	)

tokenizeAndConvert splits a string using delimiter and then converts to type T.

If the conversion fails tokenizeAndConvert returns false, otherwise true.

Definition at line 162 of file MooseStringUtils.h.

Referenced by SplitMeshAction::act(), CapabilityUtils::check(), TransfiniteMeshGenerator::getCircarcEdge(), TransfiniteMeshGenerator::getDiscreteEdge(), and Moose::MFEM::CoefficientManager::getVectorCoefficientPtr().

{
  std::vector<std::string> tokens;
  MooseUtils::tokenize(str, tokens, 1, delimiter);
  tokenized_vector.resize(tokens.size());
  for (std::size_t i = 0; i < tokens.size(); ++i)
    if (!convert<T>(tokens[i], tokenized_vector[i], false))
      return false;
  return true;
}

toLower()

std::string MooseUtils::toLower ( std::string  name )

inline

Convert supplied string to lower case.

name The string to convert upper case.

Definition at line 191 of file MooseStringUtils.h.

Referenced by Moose::Capabilities::add(), Registry::appNameFromAppPath(), CapabilityUtils::check(), MooseServer::getDocumentSymbolKind(), SubProblem::getVariableHelper(), ConsoleUtils::outputRelationshipManagerInformation(), MooseUtils::DelimitedFileReaderTempl< T >::processLine(), Moose::PetscSupport::setSinglePetscOption(), and WorkBalance::WorkBalance().

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

toUpper()

std::string MooseUtils::toUpper ( std::string  name )

inline

Convert supplied string to upper case.

name The string to convert upper case.

Definition at line 180 of file MooseStringUtils.h.

Referenced by SubProblem::addMatrixTag(), SubProblem::addVectorTag(), MooseEnumBase::find(), SubProblem::getMatrixTagID(), SubProblem::getVectorTagID(), SubProblem::matrixTagExists(), MooseEnumItem::operator!=(), MooseEnumItem::operator==(), MooseEnum::operator==(), moose::internal::ExecFlagRegistry::registerFlag(), moose::internal::ConvergenceIterationTypeRegistry::registerType(), Coupleable::vectorTagDofValueHelper(), SubProblem::vectorTagExists(), and Coupleable::vectorTagValueHelper().

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

trim()

std::string MooseUtils::trim ( const std::string &  str, const std::string &  white_space = " \t\n\v\f\r"  )

inline

Standard scripting language trim function.

Definition at line 38 of file MooseStringUtils.h.

Referenced by MooseEnumBase::addEnumerationName(), JsonInputFileFormatter::addLine(), JsonInputFileFormatter::addParameters(), SONDefinitionFormatter::addParameters(), MooseServer::addParametersToList(), InputParameters::appendFunctorDescription(), convert(), MooseServer::formatDocument(), MultiApp::getCommandLineArgs(), Moose::MFEM::CoefficientManager::getScalarCoefficientPtr(), TimedSubdomainModifier::getSubdomainIDAndCheck(), MooseUtils::DelimitedFileReaderTempl< T >::preprocessLine(), InputFileFormatter::printParams(), MooseUtils::DelimitedFileReaderTempl< T >::readColumnData(), Moose::ParameterRegistration::setDoubleVectorValue(), Moose::ParameterRegistration::setTripleVectorValue(), and Convergence::verboseOutput().

{
  const auto begin = str.find_first_not_of(white_space);
  if (begin == std::string::npos)
    return ""; // no content
  const auto end = str.find_last_not_of(white_space);
  return str.substr(begin, end - begin + 1);
}

underscoreToCamelCase()

std::string MooseUtils::underscoreToCamelCase	(	const std::string &	underscore_name,
		bool	leading_upper_case
	)

Function for converting an underscore name to a camel case name.

Parameters

underscore_name

A string containing underscores

Returns

a string containing camel casing

Definition at line 580 of file MooseUtils.C.

Referenced by MooseApp::libNameToAppName(), and ConsoleUtils::outputRelationshipManagerInformation().

{
  pcrecpp::StringPiece input(underscore_name);
  pcrecpp::RE re("([^_]*)(_|$)");

  std::string result;
  std::string us, not_us;
  bool make_upper = leading_upper_case;
  while (re.Consume(&input, &not_us, &us))
  {
    if (not_us.length() > 0)
    {
      if (make_upper)
      {
        result += std::toupper(not_us[0]);
        if (not_us.length() > 1)
          result += not_us.substr(1);
      }
      else
        result += not_us;
    }
    if (us == "")
      break;

    // Toggle flag so next match is upper cased
    make_upper = true;
  }

  return result;
}

wildcardEqual() [1/3]

template<typename T1 , typename T2 >

bool MooseUtils::wildcardEqual	(	const T1 &	a,
		const T2 &	b
	)

Definition at line 1017 of file MooseUtils.h.

Referenced by findPair().

{
  return a == b;
}

wildcardEqual() [2/3]

template<typename T >

bool MooseUtils::wildcardEqual	(	const T &	,
		AnyType
	)

Definition at line 1024 of file MooseUtils.h.

{
  return true;
}

wildcardEqual() [3/3]

template<typename T >

bool MooseUtils::wildcardEqual	(	AnyType	,
		const T &
	)

Definition at line 1030 of file MooseUtils.h.

{
  return true;
}

wildCardMatch()

bool MooseUtils::wildCardMatch	(	std::string	name,
		std::string	search_string
	)

Definition at line 888 of file MooseUtils.C.

Referenced by JsonSyntaxTree::addParameters(), JsonSyntaxTree::addSyntaxType(), SyntaxTree::TreeNode::print(), InputFileFormatter::printParams(), and JsonSyntaxTree::setParams().

{
  // Assume that an empty string matches anything
  if (search_string == "")
    return true;

  // transform to lower for case insenstive matching
  std::transform(name.begin(), name.end(), name.begin(), (int (*)(int))std::toupper);
  std::transform(search_string.begin(),
                 search_string.end(),
                 search_string.begin(),
                 (int (*)(int))std::toupper);

  // exact match!
  if (search_string.find("*") == std::string::npos)
    return search_string == name;

  // wildcard
  std::vector<std::string> tokens;
  MooseUtils::tokenize(search_string, tokens, 1, "*");

  size_t pos = 0;
  for (unsigned int i = 0; i < tokens.size() && pos != std::string::npos; ++i)
  {
    pos = name.find(tokens[i], pos);
    // See if we have a leading wildcard
    if (search_string[0] != '*' && i == 0 && pos != 0)
      return false;
  }

  if (pos != std::string::npos && tokens.size() > 0)
  {
    // Now see if we have a trailing wildcard
    size_t last_token_length = tokens.back().length();
    if (*search_string.rbegin() == '*' || pos == name.size() - last_token_length)
      return true;
    else
      return false;
  }
  else
    return false;
}

Variable Documentation

Any

const struct MooseUtils::AnyType MooseUtils::Any

static

Referenced by Moose::PetscSupport::addPetscPairsToPetscOptions(), and Moose::PetscSupport::isSNESVI().