https://mooseframework.inl.gov
Classes | Typedefs | Functions
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<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 (const std::string &name)
 Convert supplied string to upper case. More...
 
std::string toLower (const 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)
 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 >
convert (const std::string &str, bool throw_on_failure=false)
 convert takes a string representation of a number type and converts it to the number. More...
 
template<>
short int convert< short int > (const std::string &str, bool throw_on_failure)
 
template<>
unsigned short int convert< unsigned short int > (const std::string &str, bool throw_on_failure)
 
template<>
int convert< int > (const std::string &str, bool throw_on_failure)
 
template<>
unsigned int convert< unsigned int > (const std::string &str, bool throw_on_failure)
 
template<>
long int convert< long int > (const std::string &str, bool throw_on_failure)
 
template<>
unsigned long int convert< unsigned long int > (const std::string &str, bool throw_on_failure)
 
template<>
long long int convert< long long int > (const std::string &str, bool throw_on_failure)
 
template<>
unsigned long long int convert< unsigned long long int > (const std::string &str, bool throw_on_failure)
 
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 >
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 >
convertStringToInt (const std::string &str, bool throw_on_failure)
 
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

Definition at line 201 of file DelimitedFileReader.h.

◆ 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
var1The first variable to be checked
var2The second variable to be checked
tolThe tolerance to be used
Returns
true if var1 and var2 are equal within tol

Definition at line 380 of file MooseUtils.h.

Referenced by MultiAppGeneralFieldTransfer::acceptPointInOriginMesh(), FormattedTable::addData(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), MultiAppGeneralFieldTransfer::cacheIncomingInterpVals(), CartesianGridDivision::CartesianGridDivision(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonPlanarSides(), CircularBoundaryCorrectionGenerator::circularCenterCalculator(), MultiAppGeneralFieldTransfer::closestToPosition(), 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(), MatrixSymmetryCheck::execute(), SmootherChainControl::execute(), PointValue::execute(), FindValueOnLine::execute(), FillBetweenPointVectorsTools::fillBetweenPointVectorsGenerator(), RankFourTensorTempl< T >::fillGeneralOrthotropicFromInputVector(), MeshDivisionFunctorReductionVectorPostprocessor::finalize(), Moose::findContactPoint(), BicubicInterpolation::findInterval(), MeshRepairGenerator::fixOverlappingNodes(), 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::outputPostprocessors(), TableOutput::outputReporter(), 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(), 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().

383 {
384  return (std::abs(MetaPhysicL::raw_value(var1) - MetaPhysicL::raw_value(var2)) <=
386 }
MetaPhysicL::DualNumber< V, D, asd > abs(const MetaPhysicL::DualNumber< V, D, asd > &a)
Definition: EigenADReal.h:42
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73

◆ 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
var1The first variable to be checked
var2The second variable to be checked
tolThe tolerance to be used
Returns
true if var1 > var2 or var1 == var2 within tol

Definition at line 404 of file MooseUtils.h.

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

407 {
408  return (MetaPhysicL::raw_value(var1) >=
410 }
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73

◆ 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 
)

◆ 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
var1The first variable to be checked
var2The second variable to be checked
tolThe tolerance to be used
Returns
true if var1 < var2 or var1 == var2 within tol

Definition at line 452 of file MooseUtils.h.

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

455 {
456  return (MetaPhysicL::raw_value(var1) <=
458 }
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73

◆ 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
var1The first variable to be checked
var2The second variable to be checked
tolThe tolerance to be used
Returns
true if var1 < var2 and var1 != var2 within tol

Definition at line 475 of file MooseUtils.h.

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

478 {
479  return (MetaPhysicL::raw_value(var1) <
481 }
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73

◆ addLineBreaks()

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

Definition at line 726 of file MooseUtils.C.

728 {
729  for (auto i : make_range(int(message.length() / line_width)))
730  message.insert((i + 1) * (line_width + 2) - 2, "\n");
731 }
IntRange< T > make_range(T beg, T end)

◆ baseName()

std::string MooseUtils::baseName ( const std::string &  name)

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

Definition at line 614 of file MooseUtils.C.

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

615 {
616  return name.substr(0, name.find_last_of('/') != std::string::npos ? name.find_last_of('/') : 0);
617 }
std::string name(const ElemQuality q)

◆ 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 1061 of file MooseUtils.C.

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

1062 {
1063  return value.rfind(begin_value, 0) == 0;
1064 }
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)

◆ 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
p1First corner of the constructed bounding box
p2Second corner of the constructed bounding box
Returns
Valid bounding box

Definition at line 1237 of file MooseUtils.C.

Referenced by PropertyReadFile::PropertyReadFile().

1238 {
1239  BoundingBox bb;
1240  bb.union_with(p1);
1241  bb.union_with(p2);
1242  return bb;
1243 }

◆ 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_nameA string containing camel casing
Returns
a string containing no capital letters with underscores as appropriate

Definition at line 564 of file MooseUtils.C.

Referenced by MooseApp::appNameToLibName().

565 {
566  std::string replaced = camel_case_name;
567  // Put underscores in front of each contiguous set of capital letters
568  pcrecpp::RE("(?!^)(?<![A-Z_])([A-Z]+)").GlobalReplace("_\\1", &replaced);
569 
570  // Convert all capital letters to lower case
571  std::transform(replaced.begin(), replaced.end(), replaced.begin(), ::tolower);
572  return replaced;
573 }

◆ canonicalPath()

std::string MooseUtils::canonicalPath ( const std::string &  path)

Gets the canonical path of the given path.

Definition at line 1266 of file MooseUtils.C.

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

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

◆ 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
filenameThe filename to check
check_line_endingsWhether or not to see if the file contains DOS line endings.
throw_on_unreadableWhether or not to throw a MOOSE error if the file doesn't exist
check_for_git_lfs_pointerWhether 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 250 of file MooseUtils.C.

Referenced by FileMesh::buildMesh(), Registry::determineDataFilePath(), docsDir(), MooseApp::dynamicRegistration(), ExodusFileTimes::ExodusFileTimes(), ExodusTimeSequenceStepper::ExodusTimeSequenceStepper(), findTestRoot(), MooseServer::gatherDocumentDefinitionLocations(), FileMeshGenerator::generate(), Moose::DataFileUtils::getPath(), 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().

254 {
255  std::ifstream in(filename.c_str(), std::ifstream::in);
256  if (in.fail())
257  {
258  if (throw_on_unreadable)
259  mooseError(
260  (std::string("Unable to open file \"") + filename +
261  std::string("\". Check to make sure that it exists and that you have read permission."))
262  .c_str());
263  else
264  return false;
265  }
266 
267  if (check_line_endings)
268  {
269  std::istream_iterator<char> iter(in);
270  std::istream_iterator<char> eos;
271  in >> std::noskipws;
272  while (iter != eos)
273  if (*iter++ == '\r')
274  mooseError(filename + " contains Windows(DOS) line endings which are not supported.");
275  }
276 
277  if (check_for_git_lfs_pointer && checkForGitLFSPointer(in))
278  mooseError(filename + " appears to be a Git-LFS pointer. Make sure you have \"git-lfs\" "
279  "installed so that you may pull this file.");
280  in.close();
281 
282  return true;
283 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
bool checkForGitLFSPointer(std::ifstream &file)
Check if the file is a Git-LFS pointer.
Definition: MooseUtils.C:286

◆ checkFileWriteable()

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

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

Parameters
filenameThe filename you want to see if you can write to.
throw_on_unwritableWhether 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 303 of file MooseUtils.C.

Referenced by PNGOutput::makePNG().

304 {
305  std::ofstream out(filename.c_str(), std::ios_base::app);
306  if (out.fail())
307  {
308  if (throw_on_unwritable)
309  mooseError(
310  (std::string("Unable to open file \"") + filename +
311  std::string("\". Check to make sure that it exists and that you have write permission."))
312  .c_str());
313  else
314  return false;
315  }
316 
317  out.close();
318 
319  return true;
320 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
OStreamProxy out

◆ 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
fileA pointer to the open filestream.

Definition at line 286 of file MooseUtils.C.

Referenced by checkFileReadable().

287 {
288  mooseAssert(file.is_open(), "Passed in file handle is not open");
289 
290  std::string line;
291 
292  // git-lfs pointer files contain several name value pairs. The specification states that the
293  // first name/value pair must be "version {url}". We'll do a simplified check for that.
294  file.seekg(0);
295  std::getline(file, line);
296  if (line.find("version https://") != std::string::npos)
297  return true;
298  else
299  return false;
300 }

◆ clearSymlink()

void MooseUtils::clearSymlink ( const std::string &  link)

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

Definition at line 1179 of file MooseUtils.C.

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

1180 {
1181 #ifndef __WIN32__
1182  struct stat sbuf;
1183  if (lstat(link.c_str(), &sbuf) == 0)
1184  {
1185  auto err = unlink(link.c_str());
1186  if (err != 0)
1187  mooseError("Failed to remove symbolic link (via 'unlink') to ", link);
1188  }
1189 #else
1190  auto attr = GetFileAttributesA(link.c_str());
1191  if (attr != INVALID_FILE_ATTRIBUTES)
1192  {
1193  auto err = _unlink(link.c_str());
1194  if (err != 0)
1195  mooseError("Failed to remove link/file (via '_unlink') to ", link);
1196  }
1197 #endif
1198 }
OStreamProxy err
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302

◆ concatenate() [1/3]

template<typename T >
T MooseUtils::concatenate ( 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 899 of file MooseUtils.h.

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

900 {
901  c1.insert(c2.begin(), c2.end());
902  return c1;
903 }

◆ 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 910 of file MooseUtils.h.

911 {
912  c1.insert(c1.end(), c2.begin(), c2.end());
913  return c1;
914 }

◆ 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 921 of file MooseUtils.h.

922 {
923  c1.push_back(item);
924  return c1;
925 }

◆ convert()

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

convert takes a string representation of a number type and converts it to the number.

This method is here to get around deficiencies in the STL stoi and stod methods where they might successfully convert part of a string to a number when we'd like to throw an error.

Definition at line 840 of file MooseUtils.h.

Referenced by MooseServer::getDocumentSymbolKind().

841 {
842  std::stringstream ss(str);
843  T val;
844  if ((ss >> val).fail() || !ss.eof())
845  {
846  std::string msg = std::string("Unable to convert '") + str + "' to type " +
847  libMesh::demangle(typeid(T).name());
848 
849  if (throw_on_failure)
850  throw std::invalid_argument(msg);
851  else
852  mooseError(msg);
853  }
854 
855  return val;
856 }
std::string name(const ElemQuality q)
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
std::string demangle(const char *name)

◆ convert< int >()

template<>
int MooseUtils::convert< int > ( const std::string &  str,
bool  throw_on_failure 
)

Definition at line 1009 of file MooseUtils.C.

Referenced by SystemBase::copyVars(), BatchMeshGeneratorAction::setScalarParams(), and stringToInteger().

1010 {
1011  return convertStringToInt<int>(str, throw_on_failure);
1012 }

◆ convert< long int >()

template<>
long int MooseUtils::convert< long int > ( const std::string &  str,
bool  throw_on_failure 
)

Definition at line 1023 of file MooseUtils.C.

1024 {
1025  return convertStringToInt<long int>(str, throw_on_failure);
1026 }

◆ convert< long long int >()

template<>
long long int MooseUtils::convert< long long int > ( const std::string &  str,
bool  throw_on_failure 
)

Definition at line 1037 of file MooseUtils.C.

1038 {
1039  return convertStringToInt<long long int>(str, throw_on_failure);
1040 }

◆ convert< short int >()

template<>
short int MooseUtils::convert< short int > ( const std::string &  str,
bool  throw_on_failure 
)

Definition at line 995 of file MooseUtils.C.

996 {
997  return convertStringToInt<short int>(str, throw_on_failure);
998 }

◆ convert< unsigned int >()

template<>
unsigned int MooseUtils::convert< unsigned int > ( const std::string &  str,
bool  throw_on_failure 
)

Definition at line 1016 of file MooseUtils.C.

Referenced by BatchMeshGeneratorAction::setScalarParams().

1017 {
1018  return convertStringToInt<unsigned int>(str, throw_on_failure);
1019 }

◆ convert< unsigned long int >()

template<>
unsigned long int MooseUtils::convert< unsigned long int > ( const std::string &  str,
bool  throw_on_failure 
)

Definition at line 1030 of file MooseUtils.C.

1031 {
1032  return convertStringToInt<unsigned long int>(str, throw_on_failure);
1033 }

◆ convert< unsigned long long int >()

template<>
unsigned long long int MooseUtils::convert< unsigned long long int > ( const std::string &  str,
bool  throw_on_failure 
)

Definition at line 1044 of file MooseUtils.C.

1045 {
1046  return convertStringToInt<unsigned long long int>(str, throw_on_failure);
1047 }

◆ convert< unsigned short int >()

template<>
unsigned short int MooseUtils::convert< unsigned short int > ( const std::string &  str,
bool  throw_on_failure 
)

Definition at line 1002 of file MooseUtils.C.

1003 {
1004  return convertStringToInt<unsigned short int>(str, throw_on_failure);
1005 }

◆ convertLatestCheckpoint()

std::string MooseUtils::convertLatestCheckpoint ( std::string  orig)

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

Definition at line 153 of file MooseUtils.C.

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

154 {
155  auto slash_pos = orig.find_last_of("/");
156  auto path = orig.substr(0, slash_pos);
157  auto file = orig.substr(slash_pos + 1);
158  if (file != "LATEST")
159  return orig;
160 
162 
163  if (converted.empty())
164  mooseError("Unable to find suitable recovery file!");
165 
166  return converted;
167 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
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&#39;...
Definition: MooseUtils.C:815
std::list< std::string > listDir(const std::string path, bool files_only=false)
Definition: MooseUtils.C:778

◆ convertStringToInt()

template<typename T >
T MooseUtils::convertStringToInt ( const std::string &  str,
bool  throw_on_failure 
)

Definition at line 952 of file MooseUtils.C.

953 {
954  T val;
955 
956  // Let's try to read a double and see if we can cast it to an int
957  // This would be the case for scientific notation
958  long double double_val;
959  std::stringstream double_ss(str);
960  double_ss >> double_val;
961 
962  // on arm64 the long double does not have sufficient precission
963  bool use_int = false;
964  std::stringstream int_ss(str);
965  if (!(int_ss >> val).fail() && int_ss.eof())
966  use_int = true;
967 
968  if (double_ss.fail() || !double_ss.eof())
969  {
970  std::string msg =
971  std::string("Unable to convert '") + str + "' to type " + demangle(typeid(T).name());
972 
973  if (throw_on_failure)
974  throw std::invalid_argument(msg);
975  else
976  mooseError(msg);
977  }
978 
979  // Check to see if it's an integer (and within range of an integer)
980  if (double_val == static_cast<long double>(static_cast<T>(double_val)))
981  return use_int ? val : static_cast<T>(double_val);
982 
983  // Still failure
984  std::string msg =
985  std::string("Unable to convert '") + str + "' to type " + demangle(typeid(T).name());
986 
987  if (throw_on_failure)
988  throw std::invalid_argument(msg);
989  else
990  mooseError(msg);
991 }
std::string name(const ElemQuality q)
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
std::string demangle(const char *name)

◆ 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 1166 of file MooseUtils.C.

Referenced by CSV::output().

1167 {
1168  clearSymlink(link);
1169 #ifndef __WIN32__
1170  auto err = symlink(target.c_str(), link.c_str());
1171 #else
1172  auto err = CreateSymbolicLink(target.c_str(), link.c_str(), 0);
1173 #endif
1174  if (err)
1175  mooseError("Failed to create symbolic link (via 'symlink') from ", target, " to ", link);
1176 }
OStreamProxy err
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
void clearSymlink(const std::string &link)
Remove a symbolic link, if the given filename is a link.
Definition: MooseUtils.C:1179

◆ docsDir()

std::string MooseUtils::docsDir ( const std::string &  app_name)

Returns the directory of any installed docs/site.

Definition at line 121 of file MooseUtils.C.

Referenced by MooseApp::run().

122 {
123  // See moose.mk for a detailed explanation of the assumed installed application
124  // layout. Installed docs are expected to be installed in "share/<app_name>/doc".
125  // The binary, which has a defined location will be in "bin", a peer directory to "share".
126  std::string installed_path = pathjoin(Moose::getExecutablePath(), "..", "share", app_name, "doc");
127 
128  auto docfile = pathjoin(installed_path, "css", "moose.css");
129  if (pathExists(docfile) && checkFileReadable(docfile))
130  return installed_path;
131  return "";
132 }
std::string getExecutablePath()
This function returns the PATH of the running executable.
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)
Definition: MooseUtils.C:250
std::filesystem::path pathjoin(const std::filesystem::path &p)
Definition: MooseUtils.C:59
bool pathExists(const std::string &path)
Definition: MooseUtils.C:243

◆ 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 356 of file MooseUtils.h.

Referenced by MooseMeshUtils::getBoundaryIDs().

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

◆ 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 203 of file MooseUtils.C.

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

204 {
205  std::map<char, std::string> escapes;
206  escapes['\a'] = "\\a";
207  escapes['\b'] = "\\b";
208  escapes['\f'] = "\\f";
209  escapes['\n'] = "\\n";
210  escapes['\t'] = "\\t";
211  escapes['\v'] = "\\v";
212  escapes['\r'] = "\\r";
213 
214  for (const auto & it : escapes)
215  for (size_t pos = 0; (pos = str.find(it.first, pos)) != std::string::npos;
216  pos += it.second.size())
217  str.replace(pos, 1, it.second);
218 }

◆ expandAllMatches()

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

Definition at line 815 of file MooseUtils.h.

Referenced by SingleMatrixPreconditioner::SingleMatrixPreconditioner().

816 {
817  std::set<T> expanded;
818  for (const auto & p : patterns)
819  {
820  unsigned int found = 0;
821  for (const auto & c : candidates)
822  if (globCompare(c, p))
823  {
824  expanded.insert(c);
825  found++;
826  }
827  if (!found)
828  throw std::invalid_argument(p);
829  }
830  patterns.assign(expanded.begin(), expanded.end());
831 }
bool globCompare(const std::string &candidate, const std::string &pattern, std::size_t c=0, std::size_t p=0)
Definition: MooseUtils.C:928

◆ fileSize()

std::size_t MooseUtils::fileSize ( const std::string &  filename)

Check the file size.

Definition at line 1201 of file MooseUtils.C.

Referenced by Exodus::output().

1202 {
1203 #ifndef __WIN32__
1204  struct stat buffer;
1205  if (!stat(filename.c_str(), &buffer))
1206  return buffer.st_size;
1207 #else
1208  HANDLE hFile = CreateFile(filename.c_str(),
1209  GENERIC_READ,
1210  FILE_SHARE_READ | FILE_SHARE_WRITE,
1211  NULL,
1212  OPEN_EXISTING,
1213  FILE_ATTRIBUTE_NORMAL,
1214  NULL);
1215  if (hFile == INVALID_HANDLE_VALUE)
1216  return 0;
1217 
1218  LARGE_INTEGER size;
1219  if (GetFileSizeEx(hFile, &size))
1220  {
1221  CloseHandle(hFile);
1222  return size.QuadPart;
1223  }
1224 
1225  CloseHandle(hFile);
1226 #endif
1227  return 0;
1228 }

◆ 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 1061 of file MooseUtils.h.

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

1062 {
1063  return std::find_if(start_iterator,
1064  container.end(),
1065  [&](auto & item) {
1066  return wildcardEqual(first, item.first) &&
1067  wildcardEqual(second, item.second);
1068  });
1069 }
bool wildcardEqual(AnyType, const T &)
Definition: MooseUtils.h:1050

◆ 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().

76 {
77  std::string path = ".";
78  for (int i = 0; i < 5; i++)
79  {
80  auto testroot = pathjoin(path, "testroot");
81  if (pathExists(testroot) && checkFileReadable(testroot))
82  return testroot;
83  path += "/..";
84  }
85  return "";
86 }
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)
Definition: MooseUtils.C:250
std::filesystem::path pathjoin(const std::filesystem::path &p)
Definition: MooseUtils.C:59
bool pathExists(const std::string &path)
Definition: MooseUtils.C:243

◆ 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 1155 of file MooseUtils.h.

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

1156 {
1157  return u.get();
1158 }

◆ get() [2/3]

template<typename T >
T* MooseUtils::get ( T *  p)

Definition at line 1162 of file MooseUtils.h.

1163 {
1164  return p;
1165 }

◆ get() [3/3]

template<typename T >
T* MooseUtils::get ( const std::shared_ptr< T > &  s)

Definition at line 1169 of file MooseUtils.h.

1170 {
1171  return s.get();
1172 }

◆ 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 432 of file MooseUtils.C.

Referenced by MooseApp::runInputs().

433 {
434  // Note: At the time of creating this method, our minimum compiler still
435  // does not support <filesystem>. Additionally, the inclusion of that header
436  // requires an additional library to be linked so for now, we'll just
437  // use the Unix standard library to get us the cwd().
438  constexpr unsigned int BUF_SIZE = 1024;
439  char buffer[BUF_SIZE];
440 
441  return getcwd(buffer, BUF_SIZE) != nullptr ? buffer : "";
442 }

◆ getDefaultExecFlagEnum()

ExecFlagEnum MooseUtils::getDefaultExecFlagEnum ( )

◆ getExtension()

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

Gets the extension of the passed file name.

Parameters
filenameThe filename of which to get the extension
rfindWhen 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 407 of file MooseUtils.C.

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

408 {
409  std::string file_ext = "";
410  if (filename != "")
411  {
412  // The next line splits filename at the last "/" and gives the file name after "/"
413  const std::string stripped_filename = splitFileName<std::string>(filename).second;
414  auto pos = rfind ? stripped_filename.rfind(".") : stripped_filename.find(".");
415  if (pos != std::string::npos)
416  file_ext += stripped_filename.substr(pos + 1, std::string::npos);
417  }
418 
419  return file_ext;
420 }

◆ 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_listThe list of directories to retrieve files from.
file_onlyWhether or not to list only files

Definition at line 804 of file MooseUtils.C.

Referenced by MooseApp::getCheckpointFiles().

805 {
806  std::list<std::string> files;
807 
808  for (const auto & dir_name : directory_list)
809  files.splice(files.end(), listDir(dir_name, files_only));
810 
811  return files;
812 }
std::list< std::string > listDir(const std::string path, bool files_only=false)
Definition: MooseUtils.C:778

◆ 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_filesthe list of files to analyze

Definition at line 815 of file MooseUtils.C.

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

816 {
817  // Create storage for newest restart files
818  // Note that these might have the same modification time if the simulation was fast.
819  // In that case we're going to save all of the "newest" files and sort it out momentarily
820  std::time_t newest_time = 0;
821  std::list<std::string> newest_restart_files;
822 
823  // Loop through all possible files and store the newest
824  for (const auto & cp_file : checkpoint_files)
825  {
826  if (MooseUtils::hasExtension(cp_file, "rd"))
827  {
828  struct stat stats;
829  stat(cp_file.c_str(), &stats);
830 
831  std::time_t mod_time = stats.st_mtime;
832  if (mod_time > newest_time)
833  {
834  newest_restart_files.clear(); // If the modification time is greater, clear the list
835  newest_time = mod_time;
836  }
837 
838  if (mod_time == newest_time)
839  newest_restart_files.push_back(cp_file);
840  }
841  }
842 
843  // Loop through all of the newest files according the number in the file name
844  int max_file_num = -1;
845  std::string max_file;
846  std::string max_prefix;
847 
848  // Pull out the path including the number and the number itself
849  // This takes something_blah_out_cp/0024-restart-1.rd
850  // and returns "something_blah_out_cp/0024" as the "prefix"
851  // and then "24" as the number itself
852  pcrecpp::RE re_file_num("(.*?(\\d+))-restart-\\d+.rd$");
853 
854  // Now, out of the newest files find the one with the largest number in it
855  for (const auto & res_file : newest_restart_files)
856  {
857  int file_num = 0;
858 
859  // All of the file up to and including the digits
860  std::string file_prefix;
861 
862  re_file_num.FullMatch(res_file, &file_prefix, &file_num);
863 
864  if (file_num > max_file_num)
865  {
866  // Need both the header and the data
867  if (!RestartableDataReader::isAvailable(res_file))
868  continue;
869 
870  max_file_num = file_num;
871  max_file = res_file;
872  max_prefix = file_prefix;
873  }
874  }
875 
876  // Error if nothing was located
877  if (max_file_num == -1)
878  mooseError("No checkpoint file found!");
879 
880  return max_prefix;
881 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
bool hasExtension(const std::string &filename, std::string ext, bool strip_exodus_ext=false)
Function tests if the supplied filename as the desired extension.
Definition: MooseUtils.C:383
static bool isAvailable(const std::filesystem::path &folder_base)

◆ 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 636 of file MooseUtils.C.

Referenced by FormattedTable::printTable().

637 {
638 #ifndef __WIN32__
639  struct winsize w;
640 #else
641  struct
642  {
643  unsigned short ws_col;
644  } w;
645 #endif
646 
651 
652  if (use_environment)
653  {
654  char * pps_width = std::getenv("MOOSE_PPS_WIDTH");
655  if (pps_width != NULL)
656  {
657  std::stringstream ss(pps_width);
658  ss >> w.ws_col;
659  }
660  }
661  // Default to AUTO if no environment variable was set
663  {
664 #ifndef __WIN32__
665  try
666  {
667  ioctl(0, TIOCGWINSZ, &w);
668  }
669  catch (...)
670 #endif
671  {
672  }
673  }
674 
675  // Something bad happened, make sure we have a sane value
676  // 132 seems good for medium sized screens, and is available as a GNOME preset
678  w.ws_col = 132;
679 
680  return w.ws_col;
681 }
auto max(const L &left, const R &right)

◆ 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 645 of file MooseUtils.h.

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

646 {
647  std::unordered_set<T> unique_elements;
648  unique_elements.reserve(vector1.size() + vector2.size());
649 
650  for (const T & entry : vector1)
651  unique_elements.insert(entry);
652  for (const T & entry : vector2)
653  unique_elements.insert(entry);
654 
655  // Now populate the common vector with the union
656  common.clear();
657  common.assign(unique_elements.begin(), unique_elements.end());
658 }

◆ 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 928 of file MooseUtils.C.

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

932 {
933  if (p == pattern.size())
934  return c == candidate.size();
935 
936  if (pattern[p] == '*')
937  {
938  for (; c < candidate.size(); ++c)
939  if (globCompare(candidate, pattern, c, p + 1))
940  return true;
941  return globCompare(candidate, pattern, c, p + 1);
942  }
943 
944  if (pattern[p] != '?' && pattern[p] != candidate[c])
945  return false;
946 
947  return globCompare(candidate, pattern, c + 1, p + 1);
948 }
bool globCompare(const std::string &candidate, const std::string &pattern, std::size_t c=0, std::size_t p=0)
Definition: MooseUtils.C:928

◆ 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
filenameThe filename to test the extension
extThe extension to test for (do not include the .)
strip_exodus_extWhen true, this function ignores -s* from the end of the extension
Returns
True if the filename has the supplied extension

Definition at line 383 of file MooseUtils.C.

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

384 {
385  // Extract the extension, w/o the '.'
386  std::string file_ext;
387  if (strip_exodus_ext)
388  {
389  pcrecpp::RE re(
390  ".*\\.([^\\.]*?)(?:-s\\d+)?\\s*$"); // capture the complete extension, ignoring -s*
391  re.FullMatch(filename, &file_ext);
392  }
393  else
394  {
395  pcrecpp::RE re(".*\\.([^\\.]*?)\\s*$"); // capture the complete extension
396  re.FullMatch(filename, &file_ext);
397  }
398 
399  // Perform the comparision
400  if (file_ext == ext)
401  return true;
402  else
403  return false;
404 }

◆ hostname()

std::string MooseUtils::hostname ( )

Get the hostname the current process is running on.

Definition at line 620 of file MooseUtils.C.

Referenced by MooseApp::MooseApp().

621 {
622  char hostname[1024];
623  hostname[1023] = '\0';
624 #ifndef __WIN32__
625  if (gethostname(hostname, 1023))
626  mooseError("Failed to retrieve hostname!");
627 #else
628  DWORD dwSize = sizeof(hostname);
629  if (!GetComputerNameEx(ComputerNamePhysicalDnsHostname, hostname, &dwSize))
630  mooseError("Failed to retrieve hostname!");
631 #endif
632  return hostname;
633 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
std::string hostname()
Get the hostname the current process is running on.
Definition: MooseUtils.C:620

◆ 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
prefixThe prefix to use for indenting
messageThe message that will be indented
colorThe color to apply to the prefix (default CYAN)
indent_first_lineIf true this will indent the first line too (default)
post_prefixA 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 734 of file MooseUtils.C.

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

739 {
740  // First we need to see if the message we need to indent (with color) also contains color codes
741  // that span lines.
742  // The code matches all of the XTERM constants (see XTermConstants.h). If it does, then we'll work
743  // on formatting
744  // each colored multiline chunk one at a time with the right codes.
745  std::string colored_message;
746  std::string curr_color = COLOR_DEFAULT; // tracks last color code before newline
747  std::string line, color_code;
748 
749  bool ends_in_newline = message.empty() ? true : message.back() == '\n';
750 
751  bool first = true;
752 
753  std::istringstream iss(message);
754  for (std::string line; std::getline(iss, line);) // loop over each line
755  {
756  const static pcrecpp::RE match_color(".*(\\33\\[3\\dm)((?!\\33\\[3\\d)[^\n])*");
757  pcrecpp::StringPiece line_piece(line);
758  match_color.FindAndConsume(&line_piece, &color_code);
759 
760  if (!first || indent_first_line)
761  colored_message += color + prefix + post_prefix + curr_color;
762 
763  colored_message += line;
764 
765  // Only add a newline to the last line if it had one to begin with!
766  if (!iss.eof() || ends_in_newline)
767  colored_message += "\n";
768 
769  if (!color_code.empty())
770  curr_color = color_code; // remember last color of this line
771 
772  first = false;
773  }
774  message = colored_message;
775 }

◆ 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 99 of file MooseUtils.C.

Referenced by MooseApp::copyInputs().

102 {
103  // See moose.mk for a detailed explanation of the assumed installed application
104  // layout. Installed inputs are expected to be installed in "share/<app_name>/<folder>".
105  // The binary, which has a defined location will be in "bin", a peer directory to "share".
106  std::string installed_path =
107  pathjoin(Moose::getExecutablePath(), "..", "share", app_name, dir_name);
108 
109  auto test_root = pathjoin(installed_path, "testroot");
110  if (!pathExists(installed_path))
111  mooseError("Couldn't locate any installed inputs to copy in path: ",
112  installed_path,
113  '\n',
114  extra_error_msg);
115 
116  checkFileReadable(test_root);
117  return installed_path;
118 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
std::string getExecutablePath()
This function returns the PATH of the running executable.
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)
Definition: MooseUtils.C:250
std::filesystem::path pathjoin(const std::filesystem::path &p)
Definition: MooseUtils.C:59
bool pathExists(const std::string &path)
Definition: MooseUtils.C:243

◆ isAllLowercase()

bool MooseUtils::isAllLowercase ( const std::string &  str)
Returns
whether every alphabetic character in a string is lower-case

Definition at line 1288 of file MooseUtils.C.

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

◆ 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 1208 of file MooseUtils.h.

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

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

◆ 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 1219 of file MooseUtils.h.

Referenced by ChainControlParsedFunctionWrapper::initializeFunctionInputs().

1220 {
1221  if (str.empty())
1222  return false;
1223  char * ptr;
1224  strtof(str.c_str(), &ptr);
1225  return (*ptr) == '\0';
1226 }

◆ isZero()

template<typename T >
bool MooseUtils::isZero ( const T &  value,
const Real  tolerance = TOLERANCE * TOLERANCE * TOLERANCE 
)
Parameters
valueThe quantity to test for zero-ness
toleranceThe 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 691 of file MooseUtils.h.

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

692 {
693  if constexpr (Has_size<T>::value)
694  {
695  for (const auto & element : value)
696  if (!isZero(element, tolerance))
697  return false;
698 
699  return true;
700  }
701  else if constexpr (libMesh::TensorTools::TensorTraits<T>::rank == 0)
702  return MooseUtils::absoluteFuzzyEqual(MetaPhysicL::raw_value(value), 0, tolerance);
703  else if constexpr (libMesh::TensorTools::TensorTraits<T>::rank == 1)
704  {
705  for (const auto i : make_range(Moose::dim))
707  return false;
708 
709  return true;
710  }
711  else if constexpr (libMesh::TensorTools::TensorTraits<T>::rank == 2)
712  {
713  for (const auto i : make_range(Moose::dim))
714  for (const auto j : make_range(Moose::dim))
716  return false;
717 
718  return true;
719  }
720 }
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.
Definition: MooseUtils.h:380
bool isZero(const T &value, const Real tolerance=TOLERANCE *TOLERANCE *TOLERANCE)
Definition: MooseUtils.h:691
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73
static constexpr std::size_t dim
This is the dimension of all vector and tensor datastructures used in MOOSE.
Definition: Moose.h:153
We need to instantiate the following CompareTypes to tell the compiler that ADReal is a subtype of Ch...
The following methods are specializations for using the libMesh::Parallel::packed_range_* routines fo...
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
if(!dmm->_nl) SETERRQ(PETSC_COMM_WORLD
IntRange< T > make_range(T beg, T end)

◆ join() [1/2]

template<typename Iterator >
std::string MooseUtils::join ( Iterator  begin,
Iterator  end,
const std::string &  delimiter 
)

◆ 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 154 of file MooseUtils.h.

155 {
156  return join(strings.begin(), strings.end(), delimiter);
157 }
charT const * delimiter
Definition: InfixIterator.h:34
std::string join(const T &strings, const std::string &delimiter)
Python-like join function for strings over a container.
Definition: MooseUtils.h:154

◆ 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 172 of file MooseUtils.C.

Referenced by Moose::findSimilar().

173 {
174  // To change the type this function manipulates and returns, change
175  // the return type and the types of the two variables below.
176  auto s1len = s1.size();
177  auto s2len = s2.size();
178 
179  auto column_start = (decltype(s1len))1;
180 
181  auto column = new decltype(s1len)[s1len + 1];
182  std::iota(column + column_start, column + s1len + 1, column_start);
183 
184  for (auto x = column_start; x <= s2len; x++)
185  {
186  column[0] = x;
187  auto last_diagonal = x - column_start;
188  for (auto y = column_start; y <= s1len; y++)
189  {
190  auto old_diagonal = column[y];
191  auto possibilities = {
192  column[y] + 1, column[y - 1] + 1, last_diagonal + (s1[y - 1] == s2[x - 1] ? 0 : 1)};
193  column[y] = std::min(possibilities);
194  last_diagonal = old_diagonal;
195  }
196  }
197  auto result = column[s1len];
198  delete[] column;
199  return result;
200 }
auto min(const L &left, const R &right)

◆ 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_itemsGlobal number of items to partition
num_chunksTotal number of chunks to split into
item_idThe item to find the chunk_id for
Returns
The chunk_id of the chunk that contains item_id

Definition at line 1105 of file MooseUtils.C.

Referenced by DistributedRectilinearMeshGenerator::buildCube().

1106 {
1107  auto global_num_local_items = num_items / num_chunks;
1108 
1109  auto leftovers = num_items % num_chunks;
1110 
1111  auto first_item_past_first_part = leftovers * (global_num_local_items + 1);
1112 
1113  // Is it in the first section (that gets an extra item)
1114  if (item_id < first_item_past_first_part)
1115  return item_id / (global_num_local_items + 1);
1116  else
1117  {
1118  auto new_item_id = item_id - first_item_past_first_part;
1119 
1120  // First chunk after the first section + the number of chunks after that
1121  return leftovers + (new_item_id / global_num_local_items);
1122  }
1123 }

◆ 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_itemsThe number of items to partition
num_chunksThe number of chunks to partition into
chunk_idThe ID of the chunk you are trying to get information about (typically the current MPI rank)
num_local_itemsOutput: The number of items for this chunk_id
local_items_beginOutput: The first item for this chunk_id
local_items_endOutput: One past the final item for this chunk_id

Definition at line 1079 of file MooseUtils.C.

Referenced by DistributedRectilinearMeshGenerator::buildCube().

1085 {
1086  auto global_num_local_items = num_items / num_chunks;
1087 
1088  num_local_items = global_num_local_items;
1089 
1090  auto leftovers = num_items % num_chunks;
1091 
1092  if (chunk_id < leftovers)
1093  {
1094  num_local_items++;
1095  local_items_begin = num_local_items * chunk_id;
1096  }
1097  else
1098  local_items_begin =
1099  (global_num_local_items + 1) * leftovers + global_num_local_items * (chunk_id - leftovers);
1100 
1101  local_items_end = local_items_begin + num_local_items;
1102 }

◆ listDir()

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

Definition at line 778 of file MooseUtils.C.

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

779 {
780  std::list<std::string> files;
781 
782  tinydir_dir dir;
783  dir.has_next = 0; // Avoid a garbage value in has_next (clang StaticAnalysis)
784  tinydir_open(&dir, path.c_str());
785 
786  while (dir.has_next)
787  {
788  tinydir_file file;
789  file.is_dir = 0; // Avoid a garbage value in is_dir (clang StaticAnalysis)
790  tinydir_readfile(&dir, &file);
791 
792  if (!files_only || !file.is_dir)
793  files.push_back(path + "/" + file.name);
794 
795  tinydir_next(&dir);
796  }
797 
798  tinydir_close(&dir);
799 
800  return files;
801 }

◆ makedirs()

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

Recursively make directories.

Parameters
dir_nameA complete path
throw_on_failureTrue 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 445 of file MooseUtils.C.

Referenced by MooseApp::MooseApp().

446 {
447  // split path into directories with delimiter '/'
448  std::vector<std::string> split_dir_names;
449  MooseUtils::tokenize(dir_name, split_dir_names);
450 
451  auto n = split_dir_names.size();
452 
453  // remove '.' and '..' when possible
454  auto i = n;
455  i = 0;
456  while (i != n)
457  {
458  if (split_dir_names[i] == ".")
459  {
460  for (auto j = i + 1; j < n; ++j)
461  split_dir_names[j - 1] = split_dir_names[j];
462  --n;
463  }
464  else if (i > 0 && split_dir_names[i] == ".." && split_dir_names[i - 1] != "..")
465  {
466  for (auto j = i + 1; j < n; ++j)
467  split_dir_names[j - 2] = split_dir_names[j];
468  n -= 2;
469  --i;
470  }
471  else
472  ++i;
473  }
474  if (n == 0)
475  return;
476 
477  split_dir_names.resize(n);
478 
479  // start creating directories recursively
480  std::string cur_dir = dir_name[0] == '/' ? "" : ".";
481  for (auto & dir : split_dir_names)
482  {
483  cur_dir += "/" + dir;
484 
485  if (!pathExists(cur_dir))
486  {
487  auto code = Utility::mkdir(cur_dir.c_str());
488  if (code != 0)
489  {
490  std::string msg = "Failed creating directory " + dir_name;
491  if (throw_on_failure)
492  throw std::invalid_argument(msg);
493  else
494  mooseError(msg);
495  }
496  }
497  }
498 }
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 ...
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
int mkdir(const char *pathname)
bool pathExists(const std::string &path)
Definition: MooseUtils.C:243

◆ 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
propsThe 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 684 of file MooseUtils.C.

686 {
687  // Loop through the elements
688  for (const auto & elem_it : props)
689  {
690  Moose::out << "Element " << elem_it.first->id() << '\n';
691 
692  // Loop through the sides
693  for (const auto & side_it : elem_it.second)
694  {
695  Moose::out << " Side " << side_it.first << '\n';
696 
697  // Loop over properties
698  unsigned int cnt = 0;
699  for (const auto & mat_prop : side_it.second)
700  {
701  if (auto mp = dynamic_cast<const MaterialProperty<Real> *>(&mat_prop))
702  {
703  Moose::out << " Property " << cnt << '\n';
704  cnt++;
705 
706  // Loop over quadrature points
707  for (unsigned int qp = 0; qp < mp->size(); ++qp)
708  Moose::out << " prop[" << qp << "] = " << (*mp)[qp] << '\n';
709  }
710  }
711  }
712  }
713 
714  Moose::out << std::flush;
715 }

◆ mooseDocsURL()

std::string MooseUtils::mooseDocsURL ( const std::string &  path)

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

Parameters
[in]pathURL 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 135 of file MooseUtils.C.

Referenced by ExecFlagEnum::getDocString().

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

◆ 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 948 of file MooseUtils.h.

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

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

◆ 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 323 of file MooseUtils.C.

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

324 {
325  processor_id_type secondary_processor_id;
326 
327  if (messaging)
328  Moose::out << "Waiting For Other Processors To Finish" << std::endl;
329  if (comm.rank() == 0)
330  {
331  // The primary process is already through, so report it
332  if (messaging)
333  Moose::out << "Jobs complete: 1/" << comm.size() << (1 == comm.size() ? "\n" : "\r")
334  << std::flush;
335  for (unsigned int i = 2; i <= comm.size(); ++i)
336  {
337  comm.receive(MPI_ANY_SOURCE, secondary_processor_id);
338  if (messaging)
339  Moose::out << "Jobs complete: " << i << "/" << comm.size()
340  << (i == comm.size() ? "\n" : "\r") << std::flush;
341  }
342  }
343  else
344  {
345  secondary_processor_id = comm.rank();
346  comm.send(0, secondary_processor_id);
347  }
348 
349  comm.barrier();
350 }
processor_id_type rank() const
processor_id_type size() const
uint8_t processor_id_type
Status receive(const unsigned int dest_processor_id, T &buf, const MessageTag &tag=any_tag) const
void send(const unsigned int dest_processor_id, const T &buf, const MessageTag &tag=no_tag) const

◆ parsesToReal()

bool MooseUtils::parsesToReal ( const std::string &  input)

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

Definition at line 89 of file MooseUtils.C.

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

90 {
91  std::istringstream ss(input);
92  Real real_value;
93  if (ss >> real_value && ss.eof())
94  return true;
95  return false;
96 }
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

◆ 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 227 of file MooseUtils.C.

230 {
231  std::vector<std::string> elements;
232  tokenize(expression, elements, 0, delims);
233 
234  std::vector<std::string>::iterator found_it =
235  std::find(elements.begin(), elements.end(), string_to_find);
236  if (found_it != elements.end())
237  return true;
238  else
239  return false;
240 }
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 ...

◆ pathExists()

bool MooseUtils::pathExists ( const std::string &  path)

Definition at line 243 of file MooseUtils.C.

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

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

◆ pathjoin() [1/2]

std::filesystem::path MooseUtils::pathjoin ( const std::filesystem::path &  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.

66 {
67  return p / pathjoin(args...);
68 }
std::filesystem::path pathjoin(const std::filesystem::path &p, Args... args)
Definition: MooseUtils.h:65

◆ 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 1246 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(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), MooseServer::gatherDocumentDefinitionLocations(), MooseServer::getNodesByValueAndTypes(), prettyCppType(), ThreadedElementLoop< ConstElemPointerRange >::printExecutionOrdering(), JsonSyntaxTree::setParams(), and MFEMProblem::solverTypeString().

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

◆ 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 343 of file MooseUtils.h.

344 {
345  if (obj)
346  return prettyCppType(libMesh::demangle(typeid(*obj).name()));
347  else
348  return prettyCppType(libMesh::demangle(typeid(T).name()));
349 }
std::string name(const ElemQuality q)
std::string prettyCppType(const T *obj=nullptr)
Definition: MooseUtils.h:343
std::string demangle(const char *name)

◆ realpath()

std::string MooseUtils::realpath ( const std::string &  path)

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

Definition at line 1231 of file MooseUtils.C.

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

1232 {
1233  return std::filesystem::absolute(path);
1234 }

◆ 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
var1The first variable to be checked
var2The second variable to be checked
tolThe relative tolerance to be used
Returns
true if var1 and var2 are equal within relative tol

Definition at line 492 of file MooseUtils.h.

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

495 {
496  if constexpr (libMesh::ScalarTraits<T>::value ||
498  {
501  "Mathematical types must be same for arguments to relativelyFuzzEqual");
503  return absoluteFuzzyEqual(
504  var1,
505  var2,
506  tol * (std::abs(MetaPhysicL::raw_value(var1)) + std::abs(MetaPhysicL::raw_value(var2))));
507  else if constexpr (libMesh::TensorTools::TensorTraits<T>::rank == 1)
508  {
509  for (const auto i : make_range(Moose::dim))
510  if (!relativeFuzzyEqual(var1(i), var2(i), tol))
511  return false;
512 
513  return true;
514  }
515  else if constexpr (libMesh::TensorTools::TensorTraits<T>::rank == 2)
516  {
517  for (const auto i : make_range(Moose::dim))
518  for (const auto j : make_range(Moose::dim))
519  if (!relativeFuzzyEqual(var1(i, j), var2(i, j), tol))
520  return false;
521 
522  return true;
523  }
524  }
525  else
526  {
527  // We dare to dream
528  mooseAssert(var1.size() == var2.size(), "These must be the same size");
529  for (const auto i : index_range(var1))
530  if (!relativeFuzzyEqual(var1(i), var2(i), tol))
531  return false;
532 
533  return true;
534  }
535 }
MetaPhysicL::DualNumber< V, D, asd > abs(const MetaPhysicL::DualNumber< V, D, asd > &a)
Definition: EigenADReal.h:42
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.
Definition: MooseUtils.h:380
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73
static constexpr std::size_t dim
This is the dimension of all vector and tensor datastructures used in MOOSE.
Definition: Moose.h:153
We need to instantiate the following CompareTypes to tell the compiler that ADReal is a subtype of Ch...
The following methods are specializations for using the libMesh::Parallel::packed_range_* routines fo...
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.
Definition: MooseUtils.h:492
if(!dmm->_nl) SETERRQ(PETSC_COMM_WORLD
IntRange< T > make_range(T beg, T end)
auto index_range(const T &sizable)

◆ 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
var1The first variable to be checked
var2The second variable to be checked
tolThe tolerance to be used
Returns
true if var1 > var2 or var1 == var2 within relative tol

Definition at line 553 of file MooseUtils.h.

Referenced by FunctionDT::computeDT().

556 {
558  var1,
559  var2,
561 }
MetaPhysicL::DualNumber< V, D, asd > abs(const MetaPhysicL::DualNumber< V, D, asd > &a)
Definition: EigenADReal.h:42
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73
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 ...
Definition: MooseUtils.h:404

◆ 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
var1The first variable to be checked
var2The second variable to be checked
tolThe tolerance to be used
Returns
true if var1 > var2 and var1 != var2 within relative tol

Definition at line 578 of file MooseUtils.h.

581 {
582  return (absoluteFuzzyGreaterThan(
583  var1,
584  var2,
586 }
MetaPhysicL::DualNumber< V, D, asd > abs(const MetaPhysicL::DualNumber< V, D, asd > &a)
Definition: EigenADReal.h:42
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73
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...
Definition: MooseUtils.h:428

◆ 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
var1The first variable to be checked
var2The second variable to be checked
tolThe tolerance to be used
Returns
true if var1 < var2 or var1 == var2 within relative tol

Definition at line 604 of file MooseUtils.h.

607 {
608  return (absoluteFuzzyLessEqual(
609  var1,
610  var2,
612 }
MetaPhysicL::DualNumber< V, D, asd > abs(const MetaPhysicL::DualNumber< V, D, asd > &a)
Definition: EigenADReal.h:42
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73
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 tol...
Definition: MooseUtils.h:452

◆ 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
var1The first variable to be checked
var2The second variable to be checked
tolThe tolerance to be used
Returns
true if var1 < var2 and var1 != var2 within relative tol

Definition at line 629 of file MooseUtils.h.

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

632 {
633  return (absoluteFuzzyLessThan(
634  var1,
635  var2,
637 }
MetaPhysicL::DualNumber< V, D, asd > abs(const MetaPhysicL::DualNumber< V, D, asd > &a)
Definition: EigenADReal.h:42
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73
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...
Definition: MooseUtils.h:475

◆ removeColor()

std::string & MooseUtils::removeColor ( std::string &  msg)

remove ANSI escape sequences for terminal color from msg

Definition at line 718 of file MooseUtils.C.

Referenced by Console::writeStreamToFile().

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

◆ 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_nameA complete path
throw_on_failureTrue 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 501 of file MooseUtils.C.

502 {
503  // split path into directories with delimiter '/'
504  std::vector<std::string> split_dir_names;
505  MooseUtils::tokenize(dir_name, split_dir_names);
506 
507  auto n = split_dir_names.size();
508 
509  // remove '.' and '..' when possible
510  auto i = n;
511  i = 0;
512  while (i != n)
513  {
514  if (split_dir_names[i] == ".")
515  {
516  for (auto j = i + 1; j < n; ++j)
517  split_dir_names[j - 1] = split_dir_names[j];
518  --n;
519  }
520  else if (i > 0 && split_dir_names[i] == ".." && split_dir_names[i - 1] != "..")
521  {
522  for (auto j = i + 1; j < n; ++j)
523  split_dir_names[j - 2] = split_dir_names[j];
524  n -= 2;
525  --i;
526  }
527  else
528  ++i;
529  }
530  if (n == 0)
531  return;
532 
533  split_dir_names.resize(n);
534 
535  // start removing directories recursively
536  std::string base_dir = dir_name[0] == '/' ? "" : ".";
537  for (i = n; i > 0; --i)
538  {
539  std::string cur_dir = base_dir;
540  auto j = i;
541  for (j = 0; j < i; ++j)
542  cur_dir += "/" + split_dir_names[j];
543 
544  // listDir should return at least '.' and '..'
545  if (pathExists(cur_dir) && listDir(cur_dir).size() == 2)
546  {
547  auto code = rmdir(cur_dir.c_str());
548  if (code != 0)
549  {
550  std::string msg = "Failed removing directory " + dir_name;
551  if (throw_on_failure)
552  throw std::invalid_argument(msg);
553  else
554  mooseError(msg);
555  }
556  }
557  else
558  // stop removing
559  break;
560  }
561 }
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 ...
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
std::list< std::string > listDir(const std::string path, bool files_only=false)
Definition: MooseUtils.C:778
bool pathExists(const std::string &path)
Definition: MooseUtils.C:243

◆ 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 221 of file MooseUtils.C.

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

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

◆ 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 141 of file MooseUtils.C.

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

142 {
143  size_t start_pos = 0;
144  while ((start_pos = str.find(from, start_pos)) != std::string::npos)
145  {
146  str.replace(start_pos, from.length(), to);
147  start_pos += to.length(); // Handles case where 'to' is a substring of 'from'
148  }
149  return str;
150 }

◆ 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 1280 of file MooseUtils.C.

1281 {
1282  mooseAssert(startsWith(string1, string2),
1283  "Cannot replace the start because it doesn't match the start string");
1284  string1.replace(0, string2.size(), string3);
1285 }
bool startsWith(const std::string &string1, const std::string &string2)
Definition: MooseUtils.C:1272

◆ 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
dataThe vector on which the values are to be swapped
generatorRandom number generator to use for shuffle
seed_index(default: 0) The seed index to use for calls to randl
comm_ptrOptional 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().

533 {
534  return MooseUtils::resample(data, generator, seed_index, nullptr);
535 }
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.
Definition: Shuffle.h:530

◆ 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.

542 {
543  return MooseUtils::resample(data, generator, 0, &comm);
544 }
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.
Definition: Shuffle.h:530

◆ 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.

552 {
553  return MooseUtils::resample(data, generator, seed_index, &comm);
554 }
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.
Definition: Shuffle.h:530

◆ 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.

338 {
339  // Size of the local input data
340  const std::size_t n_local = data.size();
341 
342  // Re-sampled data vector to be returned
343  std::vector<T> replicate(n_local);
344 
345  // REPLICATED data
346  if (!comm_ptr || comm_ptr->size() == 1)
347  {
348  replicate.resize(n_local);
349  for (std::size_t j = 0; j < n_local; ++j)
350  {
351  auto index = generator.randl(seed_index, 0, n_local);
352  replicate[j] = data[index];
353  }
354  }
355 
356  // DISTRIBUTED data
357  else
358  {
359  // Compute the global size of the vector
360  std::size_t n_global = n_local;
361  comm_ptr->sum(n_global);
362 
363  // Compute the vector data offsets, the scope cleans up the "n_local" vector
364  std::vector<std::size_t> offsets(comm_ptr->size());
365  {
366  std::vector<std::size_t> local_sizes;
367  comm_ptr->allgather(n_local, local_sizes);
368  for (std::size_t i = 0; i < local_sizes.size() - 1; ++i)
369  offsets[i + 1] = offsets[i] + local_sizes[i];
370  }
371 
372  // Advance the random number generator to the current offset
373  const auto rank = comm_ptr->rank();
374  for (std::size_t i = 0; i < offsets[rank]; ++i)
375  generator.randl(seed_index, 0, n_global);
376 
377  // Compute the needs for this processor
378  std::unordered_map<processor_id_type, std::vector<std::pair<std::size_t, std::size_t>>> needs;
379  for (std::size_t i = 0; i < n_local; ++i)
380  {
381  const auto idx = generator.randl(seed_index, 0, n_global); // random global index
382 
383  // Locate the rank and local index of the data desired
384  const auto idx_offset_iter = std::prev(std::upper_bound(offsets.begin(), offsets.end(), idx));
385  const auto idx_rank = std::distance(offsets.begin(), idx_offset_iter);
386  const auto idx_local_idx = idx - *idx_offset_iter;
387 
388  // Local available data can be inserted into the re-sample, non-local data is add the the
389  // needs from other ranks
390  if (idx_rank == rank)
391  replicate[i] = data[idx_local_idx];
392  else
393  needs[idx_rank].emplace_back(idx_local_idx, i);
394  }
395 
396  // Advance the random number generator to the end of the global vector
397  for (std::size_t i = offsets[rank] + n_local; i < n_global; ++i)
398  generator.randl(seed_index, 0, n_global);
399 
400  // Collect the values to be returned to the various processors
401  std::unordered_map<processor_id_type, std::vector<std::pair<T, std::size_t>>> returns;
402  auto return_functor =
403  [&data, &returns](processor_id_type pid,
404  const std::vector<std::pair<std::size_t, std::size_t>> & indices)
405  {
406  auto & returns_pid = returns[pid];
407  for (const auto & idx : indices)
408  returns_pid.emplace_back(data[idx.first], idx.second);
409  };
410  Parallel::push_parallel_vector_data(*comm_ptr, needs, return_functor);
411 
412  // Receive resampled values from the various processors
413  auto recv_functor =
414  [&replicate](processor_id_type, const std::vector<std::pair<T, std::size_t>> & values)
415  {
416  for (const auto & value : values)
417  replicate[value.second] = value.first;
418  };
419  Parallel::push_parallel_vector_data(*comm_ptr, returns, recv_functor);
420  }
421  return replicate;
422 }
void allgather(const T &send_data, std::vector< T, A > &recv_data) const
static uint32_t randl()
This method returns the next random number (long format) from the generator.
Definition: MooseRandom.h:71
processor_id_type rank() const
processor_id_type size() const
uint8_t processor_id_type
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
unsigned int idx(const ElemType type, const unsigned int nx, const unsigned int i, const unsigned int j)

◆ 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
dataThe vector on which the values are to be swapped
functorFunctor to apply to each entry of the resampled vector
generatorRandom number generator to use for shuffle
seed_index(default: 0) The seed index to use for calls to randl
comm_ptrOptional 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().

562 {
563  return MooseUtils::resampleWithFunctor(data, functor, generator, seed_index, nullptr);
564 }
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.
Definition: Shuffle.h:558

◆ 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.

572 {
573  return MooseUtils::resampleWithFunctor(data, functor, generator, 0, &comm);
574 }
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.
Definition: Shuffle.h:558

◆ 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.

583 {
584  return MooseUtils::resampleWithFunctor(data, functor, generator, seed_index, &comm);
585 }
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.
Definition: Shuffle.h:558

◆ 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.

431 {
432  const std::size_t n_local = data.size();
433 
434  if (!comm_ptr || comm_ptr->size() == 1)
435  {
436  for (std::size_t j = 0; j < n_local; ++j)
437  {
438  auto index = generator.randl(seed_index, 0, n_local);
439  functor(data[index]);
440  }
441  }
442  else
443  {
444  // Compute the global size of the vector
445  std::size_t n_global = n_local;
446  comm_ptr->sum(n_global);
447 
448  // Compute the vector data offsets, the scope cleans up the "n_local" vector
449  std::vector<std::size_t> offsets(comm_ptr->size());
450  {
451  std::vector<std::size_t> local_sizes;
452  comm_ptr->allgather(n_local, local_sizes);
453  for (std::size_t i = 0; i < local_sizes.size() - 1; ++i)
454  offsets[i + 1] = offsets[i] + local_sizes[i];
455  }
456 
457  // Advance the random number generator to the current offset
458  const auto rank = comm_ptr->rank();
459  for (std::size_t i = 0; i < offsets[rank]; ++i)
460  generator.randl(seed_index, 0, n_global);
461 
462  // Compute the needs for this processor
463  std::unordered_map<processor_id_type, std::vector<std::size_t>> indices;
464  for (std::size_t i = 0; i < n_local; ++i)
465  {
466  const auto idx = generator.randl(seed_index, 0, n_global); // random global index
467 
468  // Locate the rank and local index of the data desired
469  const auto idx_offset_iter = std::prev(std::upper_bound(offsets.begin(), offsets.end(), idx));
470  const auto idx_rank = std::distance(offsets.begin(), idx_offset_iter);
471  const auto idx_local_idx = idx - *idx_offset_iter;
472 
473  // Push back the index to appropriate rank
474  indices[idx_rank].push_back(idx_local_idx);
475  }
476 
477  // Advance the random number generator to the end of the global vector
478  for (std::size_t i = offsets[rank] + n_local; i < n_global; ++i)
479  generator.randl(seed_index, 0, n_global);
480 
481  // Send the indices to the appropriate rank and have the calculator do its work
482  auto act_functor =
483  [&functor, &data](processor_id_type /*pid*/, const std::vector<std::size_t> & indices)
484  {
485  for (const auto & idx : indices)
486  functor(data[idx]);
487  };
488  Parallel::push_parallel_vector_data(*comm_ptr, indices, act_functor);
489  }
490 }
void allgather(const T &send_data, std::vector< T, A > &recv_data) const
static uint32_t randl()
This method returns the next random number (long format) from the generator.
Definition: MooseRandom.h:71
processor_id_type rank() const
processor_id_type size() const
uint8_t processor_id_type
unsigned int idx(const ElemType type, const unsigned int nx, const unsigned int i, const unsigned int j)

◆ 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().

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

◆ reset() [2/2]

template<class T , typename... Args>
void MooseUtils::reset ( double  ,
T &  ,
Args...   
)

Definition at line 28 of file SharedPool.h.

29 {
30 }

◆ 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 1146 of file MooseUtils.C.

Referenced by Moose::Builder::setScalarParameter< ReporterName, std::string >(), Moose::Builder::setVectorParameter< CLIArgString, std::string >(), and Moose::Builder::setVectorParameter< ReporterName, std::string >().

1147 {
1148  std::vector<std::string> output;
1149  std::size_t count = 0;
1150  size_t prev = str.length(), pos = str.length();
1151  do
1152  {
1153  pos = str.rfind(delimiter, prev);
1154  output.insert(output.begin(), str.substr(pos + delimiter.length(), prev - pos));
1155  prev = pos - delimiter.length();
1156  count += 1;
1157  } while (pos != std::string::npos && pos > 0 && count < max_count);
1158 
1159  if (pos != std::string::npos)
1160  output.insert(output.begin(), str.substr(0, pos));
1161 
1162  return output;
1163 }
charT const * delimiter
Definition: InfixIterator.h:34

◆ 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().

66 {
67  auto build_loc = pathjoin(Moose::getExecutablePath(), "run_tests");
68  if (pathExists(build_loc) && checkFileReadable(build_loc))
69  return build_loc;
70  // TODO: maybe no path prefix - just moose_test_runner here?
71  return pathjoin(Moose::getExecutablePath(), "moose_test_runner");
72 }
std::string getExecutablePath()
This function returns the PATH of the running executable.
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)
Definition: MooseUtils.C:250
std::filesystem::path pathjoin(const std::filesystem::path &p)
Definition: MooseUtils.C:59
bool pathExists(const std::string &path)
Definition: MooseUtils.C:243

◆ 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
commThe communicator to use
warnWhether or not to warn that something is being serialized

Definition at line 353 of file MooseUtils.C.

Referenced by SerializerGuard::SerializerGuard().

354 {
355  // unless we are the first processor...
356  if (comm.rank() > 0)
357  {
358  // ...wait for the previous processor to finish
359  int dummy = 0;
360  comm.receive(comm.rank() - 1, dummy);
361  }
362  else if (warn)
363  mooseWarning("Entering serial execution block (use only for debugging)");
364 }
void mooseWarning(Args &&... args)
Emit a warning message with the given stringified, concatenated args.
Definition: MooseError.h:336
processor_id_type rank() const
Status receive(const unsigned int dest_processor_id, T &buf, const MessageTag &tag=any_tag) const

◆ 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
commThe communicator to use
warnWhether or not to warn that something is being serialized

Definition at line 367 of file MooseUtils.C.

Referenced by SerializerGuard::~SerializerGuard().

368 {
369  // unless we are the last processor...
370  if (comm.rank() + 1 < comm.size())
371  {
372  // ...notify the next processor of its turn
373  int dummy = 0;
374  comm.send(comm.rank() + 1, dummy);
375  }
376 
377  comm.barrier();
378  if (comm.rank() == 0 && warn)
379  mooseWarning("Leaving serial execution block (use only for debugging)");
380 }
void mooseWarning(Args &&... args)
Emit a warning message with the given stringified, concatenated args.
Definition: MooseError.h:336
processor_id_type rank() const
processor_id_type size() const
void send(const unsigned int dest_processor_id, const T &buf, const MessageTag &tag=no_tag) const

◆ 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 1180 of file MooseUtils.h.

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

1181 {
1182  while (first1 != last1 && first2 != last2)
1183  {
1184  if (*first1 == *first2)
1185  return true;
1186 
1187  if (*first1 < *first2)
1188  ++first1;
1189  else if (*first1 > *first2)
1190  ++first2;
1191  }
1192  return false;
1193 }

◆ setsIntersect() [2/2]

template<class T >
bool MooseUtils::setsIntersect ( const T &  s1,
const T &  s2 
)

Definition at line 1197 of file MooseUtils.h.

1198 {
1199  return setsIntersect(s1.begin(), s1.end(), s2.begin(), s2.end());
1200 }
bool setsIntersect(const T &s1, const T &s2)
Definition: MooseUtils.h:1197

◆ shortName()

std::string MooseUtils::shortName ( const std::string &  name)

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

Definition at line 608 of file MooseUtils.C.

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

609 {
610  return name.substr(name.find_last_of('/') != std::string::npos ? name.find_last_of('/') + 1 : 0);
611 }
std::string name(const ElemQuality q)

◆ 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
dataThe vector on which the values are to be swapped
generatorRandom number generator to use for shuffle
seed_index(default: 0) The seed index to use for calls to randl
comm_ptrOptional 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().

505 {
506  return MooseUtils::shuffle(data, generator, seed_index, nullptr);
507 }
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. ...
Definition: Shuffle.h:504

◆ 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.

514 {
515  return MooseUtils::shuffle(data, generator, 0, &comm);
516 }
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. ...
Definition: Shuffle.h:504

◆ 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.

524 {
525  return MooseUtils::shuffle(data, generator, seed_index, &comm);
526 }
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. ...
Definition: Shuffle.h:504

◆ 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.

247 {
248  // REPLICATED data
249  if (!comm_ptr || comm_ptr->size() == 1)
250  {
251  std::size_t n_global = data.size();
252  for (std::size_t i = n_global - 1; i > 0; --i)
253  {
254  auto j = generator.randl(seed_index, 0, i);
255  MooseUtils::swap(data, i, j, nullptr);
256  }
257  }
258 
259  // DISTRIBUTED data
260  else
261  {
262  // Local/global size
263  std::size_t n_local = data.size();
264  std::size_t n_global = n_local;
265  comm_ptr->sum(n_global);
266 
267  // Compute the vector data offsets, the scope cleans up the "n_local" vector
268  std::vector<std::size_t> offsets(comm_ptr->size());
269  {
270  std::vector<std::size_t> local_sizes;
271  comm_ptr->allgather(n_local, local_sizes);
272  for (std::size_t i = 0; i < local_sizes.size() - 1; ++i)
273  offsets[i + 1] = offsets[i] + local_sizes[i];
274  }
275 
276  // Perform swaps
277  auto rank = comm_ptr->rank();
278  for (std::size_t idx0 = n_global - 1; idx0 > 0; --idx0)
279  {
280  auto idx1 = generator.randl(seed_index, 0, idx0);
281 
282  // Locate the rank and local index of the data to swap
283  auto idx0_offset_iter = std::prev(std::upper_bound(offsets.begin(), offsets.end(), idx0));
284  auto idx0_rank = std::distance(offsets.begin(), idx0_offset_iter);
285  auto idx0_local_idx = idx0 - *idx0_offset_iter;
286 
287  auto idx1_offset_iter = std::prev(std::upper_bound(offsets.begin(), offsets.end(), idx1));
288  auto idx1_rank = std::distance(offsets.begin(), idx1_offset_iter);
289  auto idx1_local_idx = idx1 - *idx1_offset_iter;
290 
291  // The values, if any, needed from other rank
292  std::unordered_map<processor_id_type, std::vector<std::size_t>> needs;
293  if (idx0_rank != rank && idx1_rank == rank)
294  needs[idx0_rank].push_back(idx0_local_idx);
295  if (idx0_rank == rank && idx1_rank != rank)
296  needs[idx1_rank].push_back(idx1_local_idx);
297 
298  // Collect the values needed by this processor
299  std::unordered_map<processor_id_type, std::vector<T>> returns;
300  auto return_functor =
301  [&data, &returns](processor_id_type pid, const std::vector<std::size_t> & indices)
302  {
303  auto & returns_pid = returns[pid];
304  for (auto idx : indices)
305  returns_pid.push_back(data[idx]);
306  };
307  Parallel::push_parallel_vector_data(*comm_ptr, needs, return_functor);
308 
309  // Receive needed values from the others processors
310  std::vector<T> incoming;
311  auto recv_functor = [&incoming](processor_id_type /*pid*/, const std::vector<T> & values)
312  { incoming = values; };
313  Parallel::push_parallel_vector_data(*comm_ptr, returns, recv_functor);
314 
315  if (idx0_rank == rank && idx1_rank == rank)
316  MooseUtils::swap(data, idx0_local_idx, idx1_local_idx);
317 
318  else if (idx0_rank == rank)
319  {
320  mooseAssert(incoming.size() == 1, "Only one value should be received");
321  data[idx0_local_idx] = incoming[0];
322  }
323  else if (idx1_rank == rank)
324  {
325  mooseAssert(incoming.size() == 1, "Only one value should be received");
326  data[idx1_local_idx] = incoming[0];
327  }
328  }
329  }
330 }
void allgather(const T &send_data, std::vector< T, A > &recv_data) const
static uint32_t randl()
This method returns the next random number (long format) from the generator.
Definition: MooseRandom.h:71
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.
Definition: Shuffle.h:494
processor_id_type rank() const
processor_id_type size() const
uint8_t processor_id_type

◆ 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 1126 of file MooseUtils.C.

Referenced by SONDefinitionFormatter::addParameters(), BatchMeshGeneratorAction::convertStringToCompoundRealScalar(), MeshGenerator::generateInternal(), MultiApp::getCommandLineArgs(), Moose::Builder::setDoubleIndexParameter(), and Moose::Builder::setVectorParameter().

1127 {
1128  std::vector<std::string> output;
1129  std::size_t count = 0;
1130  size_t prev = 0, pos = 0;
1131  do
1132  {
1133  pos = str.find(delimiter, prev);
1134  output.push_back(str.substr(prev, pos - prev));
1135  prev = pos + delimiter.length();
1136  count += 1;
1137  } while (pos != std::string::npos && count < max_count);
1138 
1139  if (pos != std::string::npos)
1140  output.push_back(str.substr(prev));
1141 
1142  return output;
1143 }
charT const * delimiter
Definition: InfixIterator.h:34

◆ 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_fileA 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 261 of file MooseUtils.h.

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

262 {
263  const auto p = std::filesystem::path(std::string(full_file));
264  // Error if path ends with /
265  if (!p.has_filename())
266  mooseError("Invalid full file name: ", p);
267 
268  const auto d = p.parent_path();
269  return {d.empty() ? "." : d, p.filename()};
270 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302

◆ startsWith()

bool MooseUtils::startsWith ( const std::string &  string1,
const std::string &  string2 
)
Returns
Whether the string1 starts with string2

Definition at line 1272 of file MooseUtils.C.

Referenced by replaceStart().

1273 {
1274  if (string2.size() > string1.size())
1275  return false;
1276  return string1.compare(0, string2.size(), string2) == 0;
1277 }

◆ 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 1050 of file MooseUtils.C.

Referenced by InputParameters::addCommandLineParamHelper(), CommandLine::buildHitParams(), and ParsedPostprocessor::ParsedPostprocessor().

1051 {
1052  std::string combined;
1053  for (const auto & value : values)
1054  combined += value + separator;
1055  if (values.size())
1056  combined = combined.substr(0, combined.size() - separator.size());
1057  return combined;
1058 }
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)

◆ 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
inputThe string to convert.
throw_on_failureThrow an invalid_argument exception instead of mooseError.

Definition at line 1073 of file MooseUtils.C.

Referenced by FormattedTable::printTable().

1074 {
1075  return convert<int>(input, throw_on_failure);
1076 }
int convert< int >(const std::string &str, bool throw_on_failure)
Definition: MooseUtils.C:1009

◆ 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 423 of file MooseUtils.C.

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

424 {
425  const std::string ext = getExtension(s, rfind);
426  const bool offset = (ext.size() != 0);
427  // -1 offset accounts for the extension's leading dot ("."), if there is an extension
428  return s.substr(0, s.size() - ext.size() - offset);
429 }
std::string getExtension(const std::string &filename, const bool rfind=false)
Gets the extension of the passed file name.
Definition: MooseUtils.C:407

◆ 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
dataThe vector on which the values are to be swapped
idx0,idx1The global indices to be swapped
comm_ptrOptional 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(), MooseArray< libMesh::VectorValue >::swap(), and MooseUtils::Buffer< T >::swap().

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

◆ 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.

159 {
160  if (!comm_ptr || comm_ptr->size() == 1)
161  {
162  mooseAssert(idx0 < data.size(),
163  "idx0 (" << idx0 << ") out of range, data.size() is " << data.size());
164  mooseAssert(idx1 < data.size(),
165  "idx1 (" << idx1 << ") out of range, data.size() is " << data.size());
166  std::swap(data[idx0], data[idx1]);
167  }
168 
169  else
170  {
171  // Size of the local input data
172  const auto n_local = data.size();
173  const auto rank = comm_ptr->rank();
174 
175  // Compute the global size of the vector
176  std::size_t n_global = n_local;
177  comm_ptr->sum(n_global);
178  mooseAssert(idx0 < n_global,
179  "idx0 (" << idx0 << ") out of range, the global data size is " << n_global);
180  mooseAssert(idx1 < n_global,
181  "idx1 (" << idx1 << ") out of range, the global data size is " << n_global);
182 
183  // Compute the vector data offsets, the scope cleans up the "n_local" vector
184  std::vector<std::size_t> offsets(comm_ptr->size());
185  {
186  std::vector<std::size_t> local_sizes;
187  comm_ptr->allgather(n_local, local_sizes);
188  for (std::size_t i = 0; i < local_sizes.size() - 1; ++i)
189  offsets[i + 1] = offsets[i] + local_sizes[i];
190  }
191 
192  // Locate the rank and local index of the data to swap
193  auto idx0_offset_iter = std::prev(std::upper_bound(offsets.begin(), offsets.end(), idx0));
194  auto idx0_rank = std::distance(offsets.begin(), idx0_offset_iter);
195  auto idx0_local_idx = idx0 - *idx0_offset_iter;
196 
197  auto idx1_offset_iter = std::prev(std::upper_bound(offsets.begin(), offsets.end(), idx1));
198  auto idx1_rank = std::distance(offsets.begin(), idx1_offset_iter);
199  auto idx1_local_idx = idx1 - *idx1_offset_iter;
200 
201  // The values, if any, needed from other rank
202  std::unordered_map<processor_id_type, std::vector<std::size_t>> needs;
203  if (idx0_rank != rank && idx1_rank == rank)
204  needs[idx0_rank].push_back(idx0_local_idx);
205  if (idx0_rank == rank && idx1_rank != rank)
206  needs[idx1_rank].push_back(idx1_local_idx);
207 
208  // Collect the values needed by this processor
209  std::unordered_map<processor_id_type, std::vector<T>> returns;
210  auto return_functor =
211  [&data, &returns](processor_id_type pid, const std::vector<std::size_t> & indices)
212  {
213  auto & returns_pid = returns[pid];
214  for (auto idx : indices)
215  returns_pid.push_back(data[idx]);
216  };
217  Parallel::push_parallel_vector_data(*comm_ptr, needs, return_functor);
218 
219  // Receive needed values from the others processors
220  std::vector<T> incoming;
221  auto recv_functor = [&incoming](processor_id_type /*pid*/, const std::vector<T> & values)
222  { incoming = values; };
223  Parallel::push_parallel_vector_data(*comm_ptr, returns, recv_functor);
224 
225  if (idx0_rank == rank && idx1_rank == rank)
226  MooseUtils::swap(data, idx0_local_idx, idx1_local_idx);
227 
228  else if (idx0_rank == rank)
229  {
230  mooseAssert(incoming.size() == 1, "Only one value should be received");
231  data[idx0_local_idx] = incoming[0];
232  }
233  else if (idx1_rank == rank)
234  {
235  mooseAssert(incoming.size() == 1, "Only one value should be received");
236  data[idx1_local_idx] = incoming[0];
237  }
238  }
239 }
void allgather(const T &send_data, std::vector< T, A > &recv_data) const
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.
Definition: Shuffle.h:494
processor_id_type rank() const
processor_id_type size() const
uint8_t processor_id_type
void swap(std::vector< T > &data, const std::size_t idx0, const std::size_t idx1, const libMesh::Parallel::Communicator *comm_ptr=nullptr)
Definition: Shuffle.h:155

◆ 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 44 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::Builder::setScalarParameter(), Moose::Builder::setTripleIndexParameter(), Moose::Builder::setVectorVectorComponentParameter(), MooseApp::showInputs(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), tokenizeAndConvert(), and wildCardMatch().

48 {
49  elements.clear();
50 
51  std::string::size_type last_pos = str.find_first_not_of(delims, 0);
52  std::string::size_type pos = str.find_first_of(delims, std::min(last_pos + min_len, str.size()));
53 
54  while (last_pos != std::string::npos)
55  {
56  elements.push_back(str.substr(last_pos, pos - last_pos));
57  // skip delims between tokens
58  last_pos = str.find_first_not_of(delims, pos);
59  if (last_pos == std::string::npos)
60  break;
61  pos = str.find_first_of(delims, std::min(last_pos + min_len, str.size()));
62  }
63 }
auto min(const L &left, const R &right)

◆ 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 71 of file MooseStringUtils.h.

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

74 {
75  std::vector<std::string> tokens;
76  MooseUtils::tokenize(str, tokens, 1, delimiter);
77  tokenized_vector.resize(tokens.size());
78  for (unsigned int j = 0; j < tokens.size(); ++j)
79  {
80  std::stringstream ss(trim(tokens[j]));
81  // we have to make sure that the conversion succeeded _and_ that the string
82  // was fully read to avoid situations like [conversion to Real] 3.0abc to work
83  if ((ss >> tokenized_vector[j]).fail() || !ss.eof())
84  return false;
85  }
86  return true;
87 }
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 ...
std::string trim(const std::string &str, const std::string &white_space=" \\\)
Standard scripting language trim function.
charT const * delimiter
Definition: InfixIterator.h:34

◆ toLower()

std::string MooseUtils::toLower ( const std::string &  name)
inline

Convert supplied string to lower case.

name The string to convert upper case.

Definition at line 106 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().

107 {
108  std::string lower(name);
109  std::transform(lower.begin(), lower.end(), lower.begin(), ::tolower);
110  return lower;
111 }

◆ toUpper()

std::string MooseUtils::toUpper ( const std::string &  name)
inline

Convert supplied string to upper case.

name The string to convert upper case.

Definition at line 94 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(), Coupleable::vectorTagDofValueHelper(), SubProblem::vectorTagExists(), and Coupleable::vectorTagValueHelper().

95 {
96  std::string upper(name);
97  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
98  return upper;
99 }

◆ trim()

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

◆ 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_nameA string containing underscores
Returns
a string containing camel casing

Definition at line 576 of file MooseUtils.C.

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

577 {
578  pcrecpp::StringPiece input(underscore_name);
579  pcrecpp::RE re("([^_]*)(_|$)");
580 
581  std::string result;
582  std::string us, not_us;
583  bool make_upper = leading_upper_case;
584  while (re.Consume(&input, &not_us, &us))
585  {
586  if (not_us.length() > 0)
587  {
588  if (make_upper)
589  {
590  result += std::toupper(not_us[0]);
591  if (not_us.length() > 1)
592  result += not_us.substr(1);
593  }
594  else
595  result += not_us;
596  }
597  if (us == "")
598  break;
599 
600  // Toggle flag so next match is upper cased
601  make_upper = true;
602  }
603 
604  return result;
605 }

◆ wildcardEqual() [1/3]

template<typename T1 , typename T2 >
bool MooseUtils::wildcardEqual ( const T1 &  a,
const T2 &  b 
)

Definition at line 1037 of file MooseUtils.h.

Referenced by findPair().

1038 {
1039  return a == b;
1040 }

◆ wildcardEqual() [2/3]

template<typename T >
bool MooseUtils::wildcardEqual ( const T &  ,
AnyType   
)

Definition at line 1044 of file MooseUtils.h.

1045 {
1046  return true;
1047 }

◆ wildcardEqual() [3/3]

template<typename T >
bool MooseUtils::wildcardEqual ( AnyType  ,
const T &   
)

Definition at line 1050 of file MooseUtils.h.

1051 {
1052  return true;
1053 }

◆ wildCardMatch()

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

Definition at line 884 of file MooseUtils.C.

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

885 {
886  // Assume that an empty string matches anything
887  if (search_string == "")
888  return true;
889 
890  // transform to lower for case insenstive matching
891  std::transform(name.begin(), name.end(), name.begin(), (int (*)(int))std::toupper);
892  std::transform(search_string.begin(),
893  search_string.end(),
894  search_string.begin(),
895  (int (*)(int))std::toupper);
896 
897  // exact match!
898  if (search_string.find("*") == std::string::npos)
899  return search_string == name;
900 
901  // wildcard
902  std::vector<std::string> tokens;
903  MooseUtils::tokenize(search_string, tokens, 1, "*");
904 
905  size_t pos = 0;
906  for (unsigned int i = 0; i < tokens.size() && pos != std::string::npos; ++i)
907  {
908  pos = name.find(tokens[i], pos);
909  // See if we have a leading wildcard
910  if (search_string[0] != '*' && i == 0 && pos != 0)
911  return false;
912  }
913 
914  if (pos != std::string::npos && tokens.size() > 0)
915  {
916  // Now see if we have a trailing wildcard
917  size_t last_token_length = tokens.back().length();
918  if (*search_string.rbegin() == '*' || pos == name.size() - last_token_length)
919  return true;
920  else
921  return false;
922  }
923  else
924  return false;
925 }
std::string name(const ElemQuality q)
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 ...
void ErrorVector unsigned int

Variable Documentation

◆ Any

const struct MooseUtils::AnyType MooseUtils::Any
static