MooseUtils Namespace Reference

Classes
class	DelimitedFileReader
	Utility class for reading delimited data (e.g., CSV data). More...
class	SharedPool
	Originally From https://stackoverflow.com/a/27837534/2042320. More...

Functions
std::string	convertLatestCheckpoint (std::string orig, bool base_only=true)
	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	trim (const std::string &str, const std::string &white_space=" \\\)
	Standard scripting language trim function. More...
std::vector< std::string >	split (const std::string &str, const std::string &delimiter)
	Python like split function for strings. More...
template<typename T >
std::string	join (const T &strings, const std::string &delimiter)
	Python like join function for strings. 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)
	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...
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	stripExtension (const std::string &s)
	Removes any file extension from the fiven string s (i.e. More...
std::pair< std::string, std::string >	splitFileName (std::string full_file)
	Function for splitting path and filename. 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...
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< ScalarTraits< T >::value &&ScalarTraits< T2 >::value &&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...
bool	absoluteFuzzyGreaterEqual (const libMesh::Real &var1, const libMesh::Real &var2, const libMesh::Real &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
	Function to check whether a variable is greater than or equal to another variable within an absolute tolerance. More...
bool	absoluteFuzzyGreaterThan (const libMesh::Real &var1, const libMesh::Real &var2, const libMesh::Real &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
	Function to check whether a variable is greater than another variable within an absolute tolerance. More...
bool	absoluteFuzzyLessEqual (const libMesh::Real &var1, const libMesh::Real &var2, const libMesh::Real &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
	Function to check whether a variable is less than or equal to another variable within an absolute tolerance. More...
bool	absoluteFuzzyLessThan (const libMesh::Real &var1, const libMesh::Real &var2, const libMesh::Real &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 std::enable_if< ScalarTraits< T >::value &&ScalarTraits< T2 >::value, int >::type = 0>
bool	relativeFuzzyEqual (const T &var1, const T2 &var2, const Real &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
	Function to check whether two variables are equal within a relative tolerance. More...
bool	relativeFuzzyGreaterEqual (const libMesh::Real &var1, const libMesh::Real &var2, const libMesh::Real &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
	Function to check whether a variable is greater than or equal to another variable within a relative tolerance. More...
bool	relativeFuzzyGreaterThan (const libMesh::Real &var1, const libMesh::Real &var2, const libMesh::Real &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
	Function to check whether a variable is greater than another variable within a relative tolerance. More...
bool	relativeFuzzyLessEqual (const libMesh::Real &var1, const libMesh::Real &var2, const libMesh::Real &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
	Function to check whether a variable is less than or equal to another variable within a relative tolerance. More...
bool	relativeFuzzyLessThan (const libMesh::Real &var1, const libMesh::Real &var2, const libMesh::Real &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
	Function to check whether a variable is less than another variable within a relative tolerance. More...
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)
	Indents the supplied message given the prefix and color. More...
std::string &	removeColor (std::string &msg)
	remove ANSI escape sequences for teminal 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)
	Retrieves the names of all of the files contained within the list of directories passed into the routine. More...
std::string	getLatestMeshCheckpointFile (const std::list< std::string > &checkpoint_files)
	Returns the most recent checkpoint or mesh file given a list of files. More...
std::string	getLatestAppCheckpointFileBase (const std::list< std::string > &checkpoint_files)
bool	wildCardMatch (std::string name, std::string search_string)
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...
template<typename T >
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...
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...
template<typename T >
T	concatenate (T c1, const T &c2)
	Returns a container that contains the content of second passed in container inserted into the first passed in container (set or map union). More...
template<typename T >
std::vector< T >	concatenate (std::vector< T > c1, const std::vector< T > &c2)
	Returns a vector that contains is the concatenation of the two passed in vectors. More...
template<typename T >
std::vector< T >	concatenate (std::vector< T > c1, const T &item)
	Returns the passed in vector with the item appended to it. More...
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...
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	parallelBarrierNotify (const Parallel::Communicator &comm, bool messaging)
bool	absoluteFuzzyGreaterEqual (const Real &var1, const Real &var2, const Real &tol)
bool	absoluteFuzzyGreaterThan (const Real &var1, const Real &var2, const Real &tol)
bool	absoluteFuzzyLessEqual (const Real &var1, const Real &var2, const Real &tol)
bool	absoluteFuzzyLessThan (const Real &var1, const Real &var2, const Real &tol)
bool	relativeFuzzyGreaterEqual (const Real &var1, const Real &var2, const Real &tol)
bool	relativeFuzzyGreaterThan (const Real &var1, const Real &var2, const Real &tol)
bool	relativeFuzzyLessEqual (const Real &var1, const Real &var2, const Real &tol)
bool	relativeFuzzyLessThan (const Real &var1, const Real &var2, const Real &tol)
template<typename T >
T	convertStringToInt (const std::string &str, bool throw_on_failure)
template std::string	join< std::vector< std::string > > (const std::vector< std::string > &, const std::string &)
template std::string	join< std::set< std::string > > (const std::set< std::string > &, const std::string &)
template std::string	join< std::vector< MooseEnumItem > > (const std::vector< MooseEnumItem > &, const std::string &)
template std::string	join< std::set< MooseEnumItem > > (const std::set< MooseEnumItem > &, const std::string &)

Function Documentation

absoluteFuzzyEqual()

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

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

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

Parameters

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

Returns

true if var1 and var2 are equal within tol

Definition at line 231 of file MooseUtils.h.

Referenced by FormattedTable::addData(), ComparisonPostprocessor::comparisonIsTrue(), PointValue::execute(), FindValueOnLine::execute(), BicubicInterpolation::findInterval(), RelativeDifferencePostprocessor::getValue(), LineValueSampler::getValue(), LineValueSampler::LineValueSampler(), EigenExecutionerBase::normalizeSolution(), RankTwoTensorTempl< Real >::operator==(), TableOutput::outputPostprocessors(), RankTwoTensorTempl< Real >::positiveProjectionEigenDecomposition(), EigenExecutionerBase::postExecute(), relativeFuzzyEqual(), BicubicInterpolation::sample2ndDerivative(), BicubicInterpolation::sampleDerivative(), BicubicInterpolation::sampleValueAndDerivatives(), TimeSequenceStepperBase::setupSequence(), Predictor::shouldApply(), and Axisymmetric2D3DSolutionFunction::value().

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

absoluteFuzzyGreaterEqual() [1/2]

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

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

Parameters

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

Returns

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

Referenced by ComparisonPostprocessor::comparisonIsTrue(), TimePeriod::execute(), and relativeFuzzyGreaterEqual().

absoluteFuzzyGreaterEqual() [2/2]

bool MooseUtils::absoluteFuzzyGreaterEqual	(	const Real &	var1,
		const Real &	var2,
		const Real &	tol
	)

Definition at line 388 of file MooseUtils.C.

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

absoluteFuzzyGreaterThan() [1/2]

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

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

Parameters

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

Returns

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

Referenced by ComparisonPostprocessor::comparisonIsTrue(), relativeFuzzyGreaterThan(), and Axisymmetric2D3DSolutionFunction::value().

absoluteFuzzyGreaterThan() [2/2]

bool MooseUtils::absoluteFuzzyGreaterThan	(	const Real &	var1,
		const Real &	var2,
		const Real &	tol
	)

Definition at line 394 of file MooseUtils.C.

{
  return (var1 > (var2 + tol));
}

absoluteFuzzyLessEqual() [1/2]

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

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

Parameters

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

Returns

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

Referenced by ComparisonPostprocessor::comparisonIsTrue(), and relativeFuzzyLessEqual().

absoluteFuzzyLessEqual() [2/2]

bool MooseUtils::absoluteFuzzyLessEqual	(	const Real &	var1,
		const Real &	var2,
		const Real &	tol
	)

Definition at line 400 of file MooseUtils.C.

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

absoluteFuzzyLessThan() [1/2]

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

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

Parameters

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

Returns

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

Referenced by FormattedTable::addData(), ComparisonPostprocessor::comparisonIsTrue(), TimePeriod::execute(), and relativeFuzzyLessThan().

absoluteFuzzyLessThan() [2/2]

bool MooseUtils::absoluteFuzzyLessThan	(	const Real &	var1,
		const Real &	var2,
		const Real &	tol
	)

Definition at line 406 of file MooseUtils.C.

{
  return (var1 < (var2 - tol));
}

baseName()

std::string MooseUtils::baseName

(

const std::string &

name

)

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

Definition at line 367 of file MooseUtils.C.

Referenced by Action::getBaseName(), and Parser::walkRaw().

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

camelCaseToUnderscore()

std::string MooseUtils::camelCaseToUnderscore

(

const std::string &

camel_case_name

)

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

Parameters

camel_case_name

A string containing camel casing

Returns

a string containing no capital letters with underscores as appropriate

Definition at line 317 of file MooseUtils.C.

Referenced by MooseApp::appNameToLibName().

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

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

checkFileReadable()

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

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

Parameters

filename	The filename to check
check_line_endings	Whether or not to see if the file contains DOS line endings.
throw_on_unreadable	Whether or not to throw a MOOSE error if the file doesn't exist

Returns

a Boolean indicating whether the file exists and is readable

Definition at line 146 of file MooseUtils.C.

Referenced by FileMesh::buildMesh(), MooseApp::dynamicRegistration(), ExodusTimeSequenceStepper::ExodusTimeSequenceStepper(), NearestPointBase< LayeredAverage >::fillPoints(), MultiApp::fillPositions(), Exodus::output(), Parser::parse(), MooseUtils::DelimitedFileReader::read(), RestartableDataIO::readRestartableDataHeader(), SolutionUserObject::readXda(), and Resurrector::restartFromFile().

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

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

  in.close();

  return true;
}

checkFileWriteable()

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

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

Parameters

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

Definition at line 176 of file MooseUtils.C.

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

  out.close();

  return true;
}

clearSymlink()

void MooseUtils::clearSymlink

(

const std::string &

link

)

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

Definition at line 823 of file MooseUtils.C.

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

{
  struct stat sbuf;
  if (lstat(link.c_str(), &sbuf) == 0)
  {
    int err = unlink(link.c_str());
    if (err != 0)
      mooseError("Failed to remove symbolic link (via 'unlink') to ", link);
  }
}

concatenate() [1/3]

template<typename T >

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

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

Definition at line 552 of file MooseUtils.h.

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

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

concatenate() [2/3]

template<typename T >

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

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

Definition at line 563 of file MooseUtils.h.

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

concatenate() [3/3]

template<typename T >

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

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

Definition at line 574 of file MooseUtils.h.

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

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

{
  std::stringstream ss(str);
  T val;
  if ((ss >> val).fail() || !ss.eof())
  {
    std::string msg =
        std::string("Unable to convert '") + str + "' to type " + demangle(typeid(T).name());

    if (throw_on_failure)
      throw std::invalid_argument(msg);
    else
      mooseError(msg);
  }

  return val;
}

convert< int >()

template<>

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

Definition at line 656 of file MooseUtils.C.

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

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

convert< long int >()

template<>

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

Definition at line 670 of file MooseUtils.C.

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

convert< long long int >()

template<>

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

Definition at line 684 of file MooseUtils.C.

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

convert< short int >()

template<>

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

Definition at line 642 of file MooseUtils.C.

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

convert< unsigned int >()

template<>

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

Definition at line 663 of file MooseUtils.C.

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

convert< unsigned long int >()

template<>

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

Definition at line 677 of file MooseUtils.C.

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

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

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

convert< unsigned short int >()

template<>

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

Definition at line 649 of file MooseUtils.C.

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

convertLatestCheckpoint()

std::string MooseUtils::convertLatestCheckpoint	(	std::string	orig,
		bool	base_only = true
	)

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

If base_only is true, then only return the base-name of the checkpoint directory - otherwise, a full mesh checkpoint file path is returned.

Definition at line 45 of file MooseUtils.C.

Referenced by SetupRecoverFileBaseAction::act(), FileMesh::buildMesh(), and FEProblemBase::FEProblemBase().

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

  auto converted = MooseUtils::getLatestAppCheckpointFileBase(MooseUtils::listDir(path));
  if (!base_only)
    converted = MooseUtils::getLatestMeshCheckpointFile(MooseUtils::listDir(path));
  else if (converted.empty())
    mooseError("Unable to find suitable recovery file!");
  return converted;
}

convertStringToInt()

template<typename T >

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

Definition at line 603 of file MooseUtils.C.

{
  T val;

  // Let's try to read a double and see if we can cast it to an int
  // This would be the case for scientific notation
  long double double_val;
  std::stringstream double_ss(str);

  if ((double_ss >> double_val).fail() || !double_ss.eof())
  {
    std::string msg =
        std::string("Unable to convert '") + str + "' to type " + demangle(typeid(T).name());

    if (throw_on_failure)
      throw std::invalid_argument(msg);
    else
      mooseError(msg);
  }

  // Check to see if it's an integer (and within range of an integer
  if (double_val == static_cast<T>(double_val))
    val = double_val;
  else // Still failure
  {
    std::string msg =
        std::string("Unable to convert '") + str + "' to type " + demangle(typeid(T).name());

    if (throw_on_failure)
      throw std::invalid_argument(msg);
    else
      mooseError(msg);
  }

  return val;
}

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

Referenced by CSV::output().

{
  clearSymlink(link);
  int err = symlink(target.c_str(), link.c_str());
  if (err != 0)
    mooseError("Failed to create symbolic link (via 'symlink') from ", target, " to ", link);
}

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

Referenced by MooseMeshUtils::getBoundaryIDs(), and MooseMesh::getBoundaryIDs().

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

escape()

void MooseUtils::escape

(

std::string &

str

)

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

The passed in parameter is modified in place

Definition at line 95 of file MooseUtils.C.

Referenced by YAMLFormatter::printBlockOpen(), InputFileFormatter::printParams(), YAMLFormatter::printParams(), and JsonSyntaxTree::setParams().

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

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

fileSize()

std::size_t MooseUtils::fileSize

(

const std::string &

filename

)

Check the file size.

Definition at line 835 of file MooseUtils.C.

Referenced by Exodus::output().

{
  struct stat buffer;
  if (stat(filename.c_str(), &buffer))
    return 0;

  return buffer.st_size;
}

getDefaultExecFlagEnum()

ExecFlagEnum MooseUtils::getDefaultExecFlagEnum

(

)

Return the default ExecFlagEnum for MOOSE.

Definition at line 713 of file MooseUtils.C.

Referenced by AddNodalNormalsAction::act(), AdvancedOutput::addValidParams(), Output::getDefaultExecFlagEnum(), Control::getExecuteOptions(), SetupInterface::getExecuteOptions(), OutputOnWarehouse::OutputOnWarehouse(), and validParams< SetupInterface >().

{
  ExecFlagEnum exec_enum = ExecFlagEnum();
  exec_enum.addAvailableFlags(EXEC_NONE,
                              EXEC_INITIAL,
                              EXEC_LINEAR,
                              EXEC_NONLINEAR,
                              EXEC_TIMESTEP_END,
                              EXEC_TIMESTEP_BEGIN,
                              EXEC_FINAL,
                              EXEC_CUSTOM);
  return exec_enum;
}

getFilesInDirs()

std::list< std::string > MooseUtils::getFilesInDirs

(

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

directory_list

)

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

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

Parameters

directory_list

The list of directories to retrieve files from.

Definition at line 531 of file MooseUtils.C.

Referenced by MooseApp::getCheckpointFiles().

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

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

  return files;
}

getLatestAppCheckpointFileBase()

std::string MooseUtils::getLatestAppCheckpointFileBase

(

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

checkpoint_files

)

Definition at line 550 of file MooseUtils.C.

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

{
  const static std::vector<std::string> extensions{"xda", "xdr"};

  return getLatestCheckpointFileHelper(checkpoint_files, extensions, false);
}

getLatestMeshCheckpointFile()

std::string MooseUtils::getLatestMeshCheckpointFile

(

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

checkpoint_files

)

Returns the most recent checkpoint or mesh file given a list of files.

If a suitable file isn't found the empty string is returned

Parameters

checkpoint_files

the list of files to analyze

Definition at line 542 of file MooseUtils.C.

Referenced by convertLatestCheckpoint().

{
  const static std::vector<std::string> extensions{"cpr"};

  return getLatestCheckpointFileHelper(checkpoint_files, extensions, true);
}

hasExtension()

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

Function tests if the supplied filename as the desired extension.

Parameters

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

Returns

True if the filename has the supplied extension

Definition at line 254 of file MooseUtils.C.

Referenced by FileRangeBuilder::FileRangeBuilder(), getLatestCheckpointFileHelper(), and SolutionUserObject::initialSetup().

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

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

hostname()

std::string MooseUtils::hostname

(

)

Get the hostname the current process is running on.

Definition at line 373 of file MooseUtils.C.

Referenced by MooseApp::MooseApp().

{
  // This is from: https://stackoverflow.com/a/505546
  char hostname[1024];
  hostname[1023] = '\0';

  auto failure = gethostname(hostname, 1023);

  if (failure)
    mooseError("Failed to retrieve hostname!");

  return hostname;
}

indentMessage()

void MooseUtils::indentMessage	(	const std::string &	prefix,
		std::string &	message,
		const char *	color = COLOR_CYAN
	)

Indents the supplied message given the prefix and color.

Parameters

prefix	The prefix to use for indenting
message	The message that will be indented
color	The color to apply to the prefix (default CYAN)

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

Input messsage: 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 Nonline |R| = COLOR_GREEN 1.0e-10 COLOR_DEFAULT

Definition at line 477 of file MooseUtils.C.

Referenced by FEProblemBase::checkNonlinearConvergence(), OutputWarehouse::mooseConsole(), moose::internal::mooseErrorRaw(), MooseApp::setupOptions(), and Console::write().

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

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

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

join()

template<typename T >

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

Python like join function for strings.

Definition at line 797 of file MooseUtils.C.

Referenced by ControllableParameter::checkExecuteOnType().

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

join< std::set< MooseEnumItem > >()

template std::string MooseUtils::join< std::set< MooseEnumItem > >	(	const std::set< MooseEnumItem > &	,
		const std::string &
	)

join< std::set< std::string > >()

template std::string MooseUtils::join< std::set< std::string > >	(	const std::set< std::string > &	,
		const std::string &
	)

join< std::vector< MooseEnumItem > >()

template std::string MooseUtils::join< std::vector< MooseEnumItem > >	(	const std::vector< MooseEnumItem > &	,
		const std::string &
	)

join< std::vector< std::string > >()

template std::string MooseUtils::join< std::vector< std::string > >	(	const std::vector< std::string > &	,
		const std::string &
	)

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

Referenced by findSimilar().

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

  auto column_start = (decltype(s1len))1;

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

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

linearPartitionChunk()

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

Return the chunk_id that is assigned to handle item_id.

Parameters

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

Returns

The chunk_id of the chunk that contains item_id

Definition at line 761 of file MooseUtils.C.

{
  auto global_num_local_items = num_items / num_chunks;

  auto leftovers = num_items % num_chunks;

  auto first_item_past_first_part = leftovers * (global_num_local_items + 1);

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

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

linearPartitionItems()

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

Linearly partition a number of items.

Parameters

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

Definition at line 735 of file MooseUtils.C.

{
  auto global_num_local_items = num_items / num_chunks;

  num_local_items = global_num_local_items;

  auto leftovers = num_items % num_chunks;

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

  local_items_end = local_items_begin + num_local_items;
}

listDir()

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

Definition at line 505 of file MooseUtils.C.

Referenced by convertLatestCheckpoint(), and getFilesInDirs().

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

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

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

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

    tinydir_next(&dir);
  }

  tinydir_close(&dir);

  return files;
}

MaterialPropertyStorageDump()

void MooseUtils::MaterialPropertyStorageDump

(

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

props

)

Function to dump the contents of MaterialPropertyStorage for debugging purposes.

Parameters

props

The storage item to dump, this should be MaterialPropertyStorage.props()/propsOld()/propsOlder().

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

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

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

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

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

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

Referenced by MooseUtils::DelimitedFileReader::readColumnData(), and MooseUtils::DelimitedFileReader::readRowData().

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

parallelBarrierNotify() [1/2]

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

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

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

parallelBarrierNotify() [2/2]

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

Definition at line 196 of file MooseUtils.C.

{
  processor_id_type slave_processor_id;

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

  comm.barrier();
}

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

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

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

pathExists()

bool MooseUtils::pathExists

(

const std::string &

path

)

Definition at line 139 of file MooseUtils.C.

Referenced by FileMesh::buildMesh().

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

relativeFuzzyEqual()

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

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

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

Parameters

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

Returns

true if var1 and var2 are equal within relative tol

Definition at line 296 of file MooseUtils.h.

Referenced by RankFourTensorTempl< Real >::isIsotropic().

{
  return (absoluteFuzzyEqual(var1, var2, tol * (std::abs(var1) + std::abs(var2))));
}

relativeFuzzyGreaterEqual() [1/2]

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

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

Parameters

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

Returns

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

Referenced by FunctionDT::computeDT().

relativeFuzzyGreaterEqual() [2/2]

bool MooseUtils::relativeFuzzyGreaterEqual	(	const Real &	var1,
		const Real &	var2,
		const Real &	tol
	)

Definition at line 412 of file MooseUtils.C.

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

relativeFuzzyGreaterThan() [1/2]

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

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

Parameters

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

Returns

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

relativeFuzzyGreaterThan() [2/2]

bool MooseUtils::relativeFuzzyGreaterThan	(	const Real &	var1,
		const Real &	var2,
		const Real &	tol
	)

Definition at line 418 of file MooseUtils.C.

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

relativeFuzzyLessEqual() [1/2]

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

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

Parameters

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

Returns

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

relativeFuzzyLessEqual() [2/2]

bool MooseUtils::relativeFuzzyLessEqual	(	const Real &	var1,
		const Real &	var2,
		const Real &	tol
	)

Definition at line 424 of file MooseUtils.C.

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

relativeFuzzyLessThan() [1/2]

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

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

Parameters

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

Returns

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

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

relativeFuzzyLessThan() [2/2]

bool MooseUtils::relativeFuzzyLessThan	(	const Real &	var1,
		const Real &	var2,
		const Real &	tol
	)

Definition at line 430 of file MooseUtils.C.

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

removeColor()

std::string & MooseUtils::removeColor

(

std::string &

msg

)

remove ANSI escape sequences for teminal color from msg

Definition at line 469 of file MooseUtils.C.

Referenced by Console::writeStreamToFile().

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

reset() [1/2]

template<class T , typename... Args>

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

Definition at line 22 of file SharedPool.h.

Referenced by MooseUtils::SharedPool< T >::acquire(), FEProblemBase::reinitMaterials(), and FEProblemBase::reinitMaterialsBoundary().

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

reset() [2/2]

template<class T , typename... Args>

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

Definition at line 29 of file SharedPool.h.

{
}

serialBegin()

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

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

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

Parameters

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

Definition at line 224 of file MooseUtils.C.

Referenced by SerializerGuard::SerializerGuard().

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

serialEnd()

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

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

No MPI communication can happen in this block.

Parameters

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

Definition at line 238 of file MooseUtils.C.

Referenced by SerializerGuard::~SerializerGuard().

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

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

shortName()

std::string MooseUtils::shortName

(

const std::string &

name

)

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

Definition at line 361 of file MooseUtils.C.

Referenced by MooseApp::addMeshGenerator(), MooseApp::addMeshModifier(), MooseApp::getMeshGenerator(), MooseApp::getMeshModifier(), Action::getShortName(), CSV::getVectorPostprocessorFileName(), CSV::getVectorPostprocessorFilePrefix(), CSV::initialSetup(), and Parser::walkRaw().

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

split()

std::vector< std::string > MooseUtils::split	(	const std::string &	str,
		const std::string &	delimiter
	)

Python like split function 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 782 of file MooseUtils.C.

Referenced by NonlinearSystemBase::addSplit(), MultiApp::createApp(), DMMooseReset(), and Split::setup().

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

splitFileName()

std::pair< std::string, std::string > MooseUtils::splitFileName

(

std::string

full_file

)

Function for splitting path and filename.

Parameters

full_file

A complete filename and path

Returns

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

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

Definition at line 287 of file MooseUtils.C.

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

{
  // Error if path ends with /
  if (full_file.empty() || *full_file.rbegin() == '/')
    mooseError("Invalid full file name: ", full_file);

  // Define the variables to output
  std::string path;
  std::string file;

  // Locate the / sepearting the file from path
  std::size_t found = full_file.find_last_of("/");

  // If no / is found used "." for the path, otherwise seperate the two
  if (found == std::string::npos)
  {
    path = ".";
    file = full_file;
  }
  else
  {
    path = full_file.substr(0, found);
    file = full_file.substr(found + 1);
  }

  // Return the path and file as a pair
  return std::pair<std::string, std::string>(path, file);
}

stringToInteger()

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

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

Parameters

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

Definition at line 728 of file MooseUtils.C.

Referenced by FormattedTable::printTable().

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

stripExtension()

std::string MooseUtils::stripExtension

(

const std::string &

s

)

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

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

Definition at line 278 of file MooseUtils.C.

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

{
  auto pos = s.rfind(".");
  if (pos != std::string::npos)
    return s.substr(0, pos);
  return s;
}

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 greater than the supplied value. T should be std::string or a MOOSE derived string class.

Definition at line 429 of file MooseUtils.h.

Referenced by CommandLine::addArgument(), InputParameters::addCommandLineParam(), Syntax::addDependencySets(), MooseEnumBase::addEnumerationName(), MooseEnumBase::addEnumerationNames(), JsonInputFileFormatter::addLine(), InputParameters::addParamNamesToGroup(), InputParameters::addRequiredCommandLineParam(), MooseApp::dynamicRegistration(), MultiMooseEnum::erase(), FileOutput::FileOutput(), Syntax::isAssociated(), MultiMooseEnum::operator=(), FunctionMaterialPropertyDescriptor::parseDependentVariables(), FunctionMaterialPropertyDescriptor::parseDerivative(), pathContains(), InputFileFormatter::printParams(), MultiMooseEnum::push_back(), MooseUtils::DelimitedFileReader::readColumnData(), InputParameters::registerBuildableTypes(), InputParameters::registerRelationshipManagers(), Parser::setDoubleIndexParameter(), tokenizeAndConvert(), and wildCardMatch().

{
  elements.clear();

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

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

tokenizeAndConvert()

template<typename T >

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

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

If the conversion fails tokenizeAndConvert returns false, otherwise true.

Definition at line 456 of file MooseUtils.h.

Referenced by SplitMeshAction::act().

{
  std::vector<std::string> tokens;
  MooseUtils::tokenize(str, tokens, 1, delimiter);
  tokenized_vector.resize(tokens.size());
  for (unsigned int j = 0; j < tokens.size(); ++j)
  {
    std::stringstream ss(trim(tokens[j]));
    // we have to make sure that the conversion succeeded _and_ that the string
    // was fully read to avoid situations like [conversion to Real] 3.0abc to work
    if ((ss >> tokenized_vector[j]).fail() || !ss.eof())
      return false;
  }
  return true;
}

toLower()

std::string MooseUtils::toLower

(

const std::string &

name

)

Convert supplied string to lower case.

name The string to convert upper case.

Definition at line 705 of file MooseUtils.C.

Referenced by ConsoleUtils::outputRelationshipManagerInformation().

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

toUpper()

std::string MooseUtils::toUpper

(

const std::string &

name

)

Convert supplied string to upper case.

name The string to convert upper case.

Definition at line 697 of file MooseUtils.C.

Referenced by SubProblem::addMatrixTag(), SubProblem::addVectorTag(), MooseEnumBase::find(), SubProblem::getMatrixTagID(), SubProblem::getVectorTagID(), SubProblem::matrixTagExists(), MooseEnumItem::operator!=(), MooseEnumItem::operator==(), MooseEnum::operator==(), and SubProblem::vectorTagExists().

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

trim()

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

Standard scripting language trim function.

Definition at line 113 of file MooseUtils.C.

Referenced by CommandLine::addArgument(), MooseEnumBase::addEnumerationName(), JsonInputFileFormatter::addLine(), JsonInputFileFormatter::addParameters(), SONDefinitionFormatter::addParameters(), MooseUtils::DelimitedFileReader::preprocessLine(), InputFileFormatter::printParams(), MooseUtils::DelimitedFileReader::readColumnData(), and tokenizeAndConvert().

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

underscoreToCamelCase()

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

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

Parameters

underscore_name

A string containing underscores

Returns

a string containing camel casing

Definition at line 329 of file MooseUtils.C.

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

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

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

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

  return result;
}

wildCardMatch()

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

Definition at line 558 of file MooseUtils.C.

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

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

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

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

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

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

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