MooseUtils Namespace Reference

Classes
class	Buffer
	Base class for a buffer. More...
class	CircularBuffer
	An optimized circular buffer. More...
class	DelimitedFileReaderTempl
	Utility class for reading delimited data (e.g., CSV data). More...
class	LIFOBuffer
	An optimized LIFO (Last In First Out) buffer. 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=" \t\n\v\f\r")
	Standard scripting language trim function.
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.
template<class T >
bool	convert (const std::string &str, T &value, const bool throw_on_failure)
	Takes the string representation of a value and converts it to the value.
template<typename T >
bool	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.
std::string	toUpper (std::string name)
	Convert supplied string to upper case.
std::string	toLower (std::string name)
	Convert supplied string to lower case.
std::string	stringJoin (const std::vector< std::string > &values, const std::string &separator=" ")
	Concatenates value into a single string separated by separator.
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...)
bool	isFinitePoint (const Point &point)
libMesh::FEType	variableFEType (const InputParameters &params)
std::filesystem::path	pathjoin (const std::filesystem::path &p)
std::string	runTestsExecutable ()
std::string	findTestRoot ()
bool	parsesToReal (const std::string &input, Real *parsed_real)
std::string	installedInputsDir (const std::string &app_name, const std::string &dir_name, const std::string &extra_error_msg)
std::string	docsDir (const std::string &app_name)
std::string	mooseDocsURL (const std::string &path)
std::string	replaceAll (std::string str, const std::string &from, const std::string &to)
std::string	convertLatestCheckpoint (std::string orig)
int	levenshteinDist (const std::string &s1, const std::string &s2)
void	escape (std::string &str)
std::string	removeExtraWhitespace (const std::string &input)
bool	pathContains (const std::string &expression, const std::string &string_to_find, const std::string &delims)
bool	pathExists (const std::string &path)
bool	checkFileReadable (const std::string &filename, bool check_line_endings, bool throw_on_unreadable, bool check_for_git_lfs_pointer)
bool	checkForGitLFSPointer (std::ifstream &file)
bool	checkFileWriteable (const std::string &filename, bool throw_on_unwritable)
void	parallelBarrierNotify (const Parallel::Communicator &comm, bool messaging)
void	serialBegin (const libMesh::Parallel::Communicator &comm, bool warn)
void	serialEnd (const libMesh::Parallel::Communicator &comm, bool warn)
bool	hasExtension (const std::string &filename, std::string ext, bool strip_exodus_ext)
std::string	getExtension (const std::string &filename, const bool rfind)
std::string	stripExtension (const std::string &s, const bool rfind)
std::string	getCurrentWorkingDir ()
void	makedirs (const std::string &dir_name, bool throw_on_failure)
void	removedirs (const std::string &dir_name, bool throw_on_failure)
std::string	camelCaseToUnderscore (const std::string &camel_case_name)
std::string	underscoreToCamelCase (const std::string &underscore_name, bool leading_upper_case)
std::string	shortName (const std::string &name)
std::string	baseName (const std::string &name)
std::string	hostname ()
unsigned short	getTermWidth (bool use_environment)
void	MaterialPropertyStorageDump (const HashMap< const libMesh::Elem *, HashMap< unsigned int, MaterialProperties > > &props)
std::string &	removeColor (std::string &msg)
void	addLineBreaks (std::string &message, unsigned int line_width)
void	indentMessage (const std::string &prefix, std::string &message, const char *color, bool indent_first_line, const std::string &post_prefix)
std::list< std::string >	listDir (const std::string path, bool files_only)
std::list< std::string >	getFilesInDirs (const std::list< std::string > &directory_list, const bool files_only)
std::string	getLatestCheckpointFilePrefix (const std::list< std::string > &checkpoint_files)
bool	wildCardMatch (std::string name, std::string search_string)
bool	globCompare (const std::string &candidate, const std::string &pattern, std::size_t c, std::size_t p)
bool	beginsWith (const std::string &value, const std::string &begin_value)
ExecFlagEnum	getDefaultExecFlagEnum ()
int	stringToInteger (const std::string &input, bool throw_on_failure)
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)
processor_id_type	linearPartitionChunk (dof_id_type num_items, dof_id_type num_chunks, dof_id_type item_id)
std::vector< std::string >	split (const std::string &str, const std::string &delimiter, std::size_t max_count)
std::vector< std::string >	rsplit (const std::string &str, const std::string &delimiter, std::size_t max_count)
void	createSymlink (const std::string &target, const std::string &link)
void	clearSymlink (const std::string &link)
std::size_t	fileSize (const std::string &filename)
std::string	realpath (const std::string &path)
BoundingBox	buildBoundingBox (const Point &p1, const Point &p2)
std::string	prettyCppType (const std::string &cpp_type)
std::string	canonicalPath (const std::string &path)
bool	startsWith (const std::string &string1, const std::string &string2)
void	replaceStart (std::string &string1, const std::string &string2, const std::string &string3)
bool	isAllLowercase (const std::string &str)
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.
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.
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.
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.
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)

Typedef Documentation

DelimitedFileOfStringReader

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

Definition at line 201 of file DelimitedFileReader.h.

DelimitedFileReader

typedef DelimitedFileReaderTempl<double> MooseUtils::DelimitedFileReader

Definition at line 200 of file DelimitedFileReader.h.

Function Documentation

addLineBreaks()

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

Definition at line 793 of file MooseUtils.C.

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

baseName()

std::string MooseUtils::baseName

(

const std::string &

name

)

Definition at line 681 of file MooseUtils.C.

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

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

beginsWith()

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

Definition at line 1018 of file MooseUtils.C.

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

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

buildBoundingBox()

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

Definition at line 1194 of file MooseUtils.C.

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

Referenced by PropertyReadFile::PropertyReadFile().

camelCaseToUnderscore()

std::string MooseUtils::camelCaseToUnderscore

(

const std::string &

camel_case_name

)

Definition at line 631 of file MooseUtils.C.

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

Referenced by MooseApp::appNameToLibName().

canonicalPath()

std::string MooseUtils::canonicalPath

(

const std::string &

path

)

Definition at line 1236 of file MooseUtils.C.

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

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

checkFileReadable()

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

Definition at line 317 of file MooseUtils.C.

{
  std::ifstream in(filename.c_str(), std::ifstream::in);
  if (in.fail())
  {
    if (throw_on_unreadable)
      mooseError(
          (std::string("Unable to open file \"") + filename +
           std::string("\". Check to make sure that it exists and that you have read permission."))
              .c_str());
    else
      return false;
  }
 
  if (check_line_endings)
  {
    std::istream_iterator<char> iter(in);
    std::istream_iterator<char> eos;
    in >> std::noskipws;
    while (iter != eos)
      if (*iter++ == '\r')
        mooseError(filename + " contains Windows(DOS) line endings which are not supported.");
  }
 
  if (check_for_git_lfs_pointer && checkForGitLFSPointer(in))
    mooseError(filename + " appears to be a Git-LFS pointer. Make sure you have \"git-lfs\" "
                          "installed so that you may pull this file.");
  in.close();
 
  return true;
}

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

checkFileWriteable()

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

Definition at line 370 of file MooseUtils.C.

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

Referenced by PNGOutput::makePNG().

checkForGitLFSPointer()

bool MooseUtils::checkForGitLFSPointer

(

std::ifstream &

file

)

Definition at line 353 of file MooseUtils.C.

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

Referenced by checkFileReadable().

clearSymlink()

void MooseUtils::clearSymlink

(

const std::string &

link

)

Definition at line 1136 of file MooseUtils.C.

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

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

convert()

template<class T >

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

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

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

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

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

Parameters

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

Returns

Whether or not the conversion succeeded

Definition at line 96 of file MooseStringUtils.h.

{
  // Special case for numeric values, also handling range checking
  if constexpr (std::is_same_v<short int, T> || std::is_same_v<unsigned short int, T> ||
                std::is_same_v<int, T> || std::is_same_v<unsigned int, T> ||
                std::is_same_v<long int, T> || std::is_same_v<unsigned long int, T> ||
                std::is_same_v<long long int, T> || std::is_same_v<unsigned long long int, T>)
  {
    // Try read a double and try to cast it to an int
    long double double_val;
    std::stringstream double_ss(str);
    double_ss >> double_val;
 
    if (!double_ss.fail() && double_ss.eof())
    {
      // on arm64 the long double does not have sufficient precision
      std::stringstream int_ss(str);
      const bool use_int = !(int_ss >> value).fail() && int_ss.eof();
 
      // Check to see if it's an integer and thus within range of an integer
      if (double_val == static_cast<long double>(static_cast<T>(double_val)))
      {
        if (!use_int)
          value = static_cast<T>(double_val);
        return true;
      }
    }
  }
  // Non numeric values
  else
  {
    // string or derived string: direct copy
    if constexpr (std::is_base_of_v<std::string, T>)
    {
      value = str;
      return true;
    }
    // non-string or numeric, use stringstream >>
    else
    {
      std::stringstream ss(trim(str));
      if (!(ss >> value).fail() && ss.eof())
        return true;
    }
  }
 
  if (throw_on_failure)
  {
    std::string error = "Unable to convert '" + str + "' to type ";
#ifdef MOOSESTRINGUTILS_NO_LIBMESH
    error += typeid(T).name();
#else
    error += libMesh::demangle(typeid(T).name());
#endif
    throw std::invalid_argument(error);
  }
 
  return false;
}

Referenced by RangeEvaler::eval().

convertLatestCheckpoint()

std::string MooseUtils::convertLatestCheckpoint

(

std::string

orig

)

Definition at line 220 of file MooseUtils.C.

{
  auto slash_pos = orig.find_last_of("/");
  auto path = orig.substr(0, slash_pos);
  auto file = orig.substr(slash_pos + 1);
  if (file != "LATEST")
    return orig;
 
  auto converted = MooseUtils::getLatestCheckpointFilePrefix(MooseUtils::listDir(path));
 
  if (converted.empty())
    mooseError("Unable to find suitable recovery file!");
 
  return converted;
}

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

createSymlink()

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

Definition at line 1123 of file MooseUtils.C.

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

Referenced by CSV::output().

docsDir()

std::string MooseUtils::docsDir

(

const std::string &

app_name

)

Definition at line 188 of file MooseUtils.C.

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

Referenced by MooseApp::run().

escape()

void MooseUtils::escape

(

std::string &

str

)

Definition at line 270 of file MooseUtils.C.

{
  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);
}

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

fileSize()

std::size_t MooseUtils::fileSize

(

const std::string &

filename

)

Definition at line 1158 of file MooseUtils.C.

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

Referenced by Exodus::output().

findTestRoot()

std::string MooseUtils::findTestRoot

(

)

Definition at line 138 of file MooseUtils.C.

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

Referenced by MooseApp::runInputs().

getCurrentWorkingDir()

std::string MooseUtils::getCurrentWorkingDir

(

)

Definition at line 499 of file MooseUtils.C.

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

Referenced by MooseApp::runInputs().

getDefaultExecFlagEnum()

ExecFlagEnum MooseUtils::getDefaultExecFlagEnum

(

)

Definition at line 1024 of file MooseUtils.C.

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

Referenced by AddNodalNormalsAction::act(), AdvancedOutput::addValidParams(), Output::getDefaultExecFlagEnum(), Control::getExecuteOptions(), OutputOnWarehouse::OutputOnWarehouse(), SetupDebugAction::validParams(), SetupInterface::validParams(), MOOSEQuantityToNEML2< T, state >::validParams(), NEML2Assembly::validParams(), NEML2BatchIndexGenerator::validParams(), NEML2FEInterpolation::validParams(), and NEML2ModelExecutor::validParams().

getExtension()

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

Definition at line 474 of file MooseUtils.C.

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

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

getFilesInDirs()

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

Definition at line 871 of file MooseUtils.C.

{
  std::list<std::string> files;
 
  for (const auto & dir_name : directory_list)
    files.splice(files.end(), listDir(dir_name, files_only));
 
  return files;
}

Referenced by MooseApp::getCheckpointFiles().

getLatestCheckpointFilePrefix()

std::string MooseUtils::getLatestCheckpointFilePrefix

(

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

checkpoint_files

)

Definition at line 882 of file MooseUtils.C.

{
  // Create storage for newest restart files
  // Note that these might have the same modification time if the simulation was fast.
  // In that case we're going to save all of the "newest" files and sort it out momentarily
  std::time_t newest_time = 0;
  std::list<std::string> newest_restart_files;
 
  // Loop through all possible files and store the newest
  for (const auto & cp_file : checkpoint_files)
  {
    if (MooseUtils::hasExtension(cp_file, "rd"))
    {
      struct stat stats;
      stat(cp_file.c_str(), &stats);
 
      std::time_t mod_time = stats.st_mtime;
      if (mod_time > newest_time)
      {
        newest_restart_files.clear(); // If the modification time is greater, clear the list
        newest_time = mod_time;
      }
 
      if (mod_time == newest_time)
        newest_restart_files.push_back(cp_file);
    }
  }
 
  // Loop through all of the newest files according the number in the file name
  int max_file_num = -1;
  std::string max_file;
  std::string max_prefix;
 
  // Pull out the path including the number and the number itself
  // This takes something_blah_out_cp/0024-restart-1.rd
  // and returns "something_blah_out_cp/0024" as the "prefix"
  // and then "24" as the number itself
  pcrecpp::RE re_file_num("(.*?(\\d+))-restart-\\d+.rd$");
 
  // Now, out of the newest files find the one with the largest number in it
  for (const auto & res_file : newest_restart_files)
  {
    int file_num = 0;
 
    // All of the file up to and including the digits
    std::string file_prefix;
 
    re_file_num.FullMatch(res_file, &file_prefix, &file_num);
 
    if (file_num > max_file_num)
    {
      // Need both the header and the data
      if (!RestartableDataReader::isAvailable(res_file))
        continue;
 
      max_file_num = file_num;
      max_file = res_file;
      max_prefix = file_prefix;
    }
  }
 
  // Error if nothing was located
  if (max_file_num == -1)
    mooseError("No checkpoint file found!");
 
  return max_prefix;
}

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

getTermWidth()

unsigned short MooseUtils::getTermWidth

(

bool

use_environment

)

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

Definition at line 703 of file MooseUtils.C.

{
#ifndef __WIN32__
  struct winsize w;
#else
  struct
  {
    unsigned short ws_col;
  } w;
#endif
  w.ws_col = std::numeric_limits<unsigned short>::max();
 
  if (use_environment)
  {
    char * pps_width = std::getenv("MOOSE_PPS_WIDTH");
    if (pps_width != NULL)
    {
      std::stringstream ss(pps_width);
      ss >> w.ws_col;
    }
  }
  // Default to AUTO if no environment variable was set
  if (w.ws_col == std::numeric_limits<unsigned short>::max())
  {
#ifndef __WIN32__
    try
    {
      ioctl(0, TIOCGWINSZ, &w);
    }
    catch (...)
#endif
    {
    }
  }
 
  // Something bad happened, make sure we have a sane value
  // 132 seems good for medium sized screens, and is available as a GNOME preset
  if (w.ws_col == std::numeric_limits<unsigned short>::max())
    w.ws_col = 132;
 
  return w.ws_col;
}

Referenced by FormattedTable::printTable().

globCompare()

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

Definition at line 995 of file MooseUtils.C.

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

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

hasExtension()

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

Definition at line 450 of file MooseUtils.C.

{
  // 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;
}

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

hostname()

std::string MooseUtils::hostname

(

)

Definition at line 687 of file MooseUtils.C.

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

Referenced by hostname().

indentMessage()

void MooseUtils::indentMessage	(	const std::string &	prefix,
		std::string &	message,
		const char *	color,
		bool	indent_first_line,
		const std::string &	post_prefix
	)

Definition at line 801 of file MooseUtils.C.

{
  // First we need to see if the message we need to indent (with color) also contains color codes
  // that span lines.
  // The code matches all of the XTERM constants (see XTermConstants.h). If it does, then we'll work
  // on formatting
  // each colored multiline chunk one at a time with the right codes.
  std::string colored_message;
  std::string curr_color = COLOR_DEFAULT; // tracks last color code before newline
  std::string line, color_code;
 
  bool ends_in_newline = message.empty() ? true : message.back() == '\n';
 
  bool first = true;
 
  std::istringstream iss(message);
  for (std::string line; std::getline(iss, line);) // loop over each line
  {
    const static pcrecpp::RE match_color(".*(\\33\\[3\\dm)((?!\\33\\[3\\d)[^\n])*");
    pcrecpp::StringPiece line_piece(line);
    match_color.FindAndConsume(&line_piece, &color_code);
 
    if (!first || indent_first_line)
      colored_message += color + prefix + post_prefix + curr_color;
 
    colored_message += line;
 
    // Only add a newline to the last line if it had one to begin with!
    if (!iss.eof() || ends_in_newline)
      colored_message += "\n";
 
    if (!color_code.empty())
      curr_color = color_code; // remember last color of this line
 
    first = false;
  }
  message = colored_message;
}

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

installedInputsDir()

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

Definition at line 166 of file MooseUtils.C.

{
  // See moose.mk for a detailed explanation of the assumed installed application
  // layout. Installed inputs are expected to be installed in "share/<app_name>/<folder>".
  // The binary, which has a defined location will be in "bin", a peer directory to "share".
  std::string installed_path =
      pathjoin(Moose::getExecutablePath(), "..", "share", app_name, dir_name);
 
  auto test_root = pathjoin(installed_path, "testroot");
  if (!pathExists(installed_path))
    mooseError("Couldn't locate any installed inputs to copy in path: ",
               installed_path,
               '\n',
               extra_error_msg);
 
  checkFileReadable(test_root);
  return installed_path;
}

Referenced by MooseApp::copyInputs().

isAllLowercase()

bool MooseUtils::isAllLowercase

(

const std::string &

str

)

Definition at line 1258 of file MooseUtils.C.

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

isFinitePoint()

bool MooseUtils::isFinitePoint

(

const Point &

point

)

Definition at line 63 of file MooseUtils.C.

{
  for (const auto component : make_range(Moose::dim))
    if (!std::isfinite(point(component)))
      return false;
 
  return true;
}

Referenced by Moose::Mortar::projectQPoints3d(), and MortarSegmentHelper::referencePoint().

levenshteinDist()

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

Definition at line 239 of file MooseUtils.C.

{
  // 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;
}

Referenced by Moose::findSimilar().

linearPartitionChunk()

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

Definition at line 1062 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);
  }
}

Referenced by DistributedRectilinearMeshGenerator::buildCube().

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
	)

Definition at line 1036 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;
}

Referenced by DistributedRectilinearMeshGenerator::buildCube().

listDir()

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

Definition at line 845 of file MooseUtils.C.

{
  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;
}

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

makedirs()

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

Definition at line 512 of file MooseUtils.C.

{
  // split path into directories with delimiter '/'
  std::vector<std::string> split_dir_names;
  MooseUtils::tokenize(dir_name, split_dir_names);
 
  auto n = split_dir_names.size();
 
  // remove '.' and '..' when possible
  auto i = n;
  i = 0;
  while (i != n)
  {
    if (split_dir_names[i] == ".")
    {
      for (auto j = i + 1; j < n; ++j)
        split_dir_names[j - 1] = split_dir_names[j];
      --n;
    }
    else if (i > 0 && split_dir_names[i] == ".." && split_dir_names[i - 1] != "..")
    {
      for (auto j = i + 1; j < n; ++j)
        split_dir_names[j - 2] = split_dir_names[j];
      n -= 2;
      --i;
    }
    else
      ++i;
  }
  if (n == 0)
    return;
 
  split_dir_names.resize(n);
 
  // start creating directories recursively
  std::string cur_dir = dir_name[0] == '/' ? "" : ".";
  for (auto & dir : split_dir_names)
  {
    cur_dir += "/" + dir;
 
    if (!pathExists(cur_dir))
    {
      auto code = Utility::mkdir(cur_dir.c_str());
      if (code != 0)
      {
        std::string msg = "Failed creating directory " + dir_name;
        if (throw_on_failure)
          throw std::invalid_argument(msg);
        else
          mooseError(msg);
      }
    }
  }
}

MaterialPropertyStorageDump()

void MooseUtils::MaterialPropertyStorageDump

(

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

props

)

Definition at line 751 of file MooseUtils.C.

{
  // Loop through the elements
  for (const auto & elem_it : props)
  {
    Moose::out << "Element " << elem_it.first->id() << '\n';
 
    // Loop through the sides
    for (const auto & side_it : elem_it.second)
    {
      Moose::out << "  Side " << side_it.first << '\n';
 
      // Loop over properties
      unsigned int cnt = 0;
      for (const auto & mat_prop : side_it.second)
      {
        if (auto mp = dynamic_cast<const MaterialProperty<Real> *>(&mat_prop))
        {
          Moose::out << "    Property " << cnt << '\n';
          cnt++;
 
          // Loop over quadrature points
          for (unsigned int qp = 0; qp < mp->size(); ++qp)
            Moose::out << "      prop[" << qp << "] = " << (*mp)[qp] << '\n';
        }
      }
    }
  }
 
  Moose::out << std::flush;
}

mooseDocsURL()

std::string MooseUtils::mooseDocsURL

(

const std::string &

path

)

Definition at line 202 of file MooseUtils.C.

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

Referenced by ExecFlagEnum::getDocString().

parallelBarrierNotify()

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

Definition at line 390 of file MooseUtils.C.

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

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

parsesToReal()

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

Definition at line 152 of file MooseUtils.C.

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

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

pathContains()

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

Definition at line 294 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 310 of file MooseUtils.C.

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

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

pathjoin()

std::filesystem::path MooseUtils::pathjoin

(

const std::filesystem::path &

p

)

Definition at line 122 of file MooseUtils.C.

{
  return p;
}

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

prettyCppType()

std::string MooseUtils::prettyCppType

(

const std::string &

cpp_type

)

Definition at line 1203 of file MooseUtils.C.

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

Referenced by MooseServer::addParametersToList(), MooseServer::addValuesToList(), InputParametersChecksUtils< C >::assertParamDefined(), ReporterGeneralContext< T >::contextType(), ReporterBroadcastContext< T >::contextType(), ReporterScatterContext< T >::contextType(), ReporterGatherContext< T >::contextType(), ReporterVectorContext< T >::contextType(), Moose::Kokkos::dataLoad(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), MooseServer::gatherDocumentDefinitionLocations(), MooseServer::getFileNameTypeValues(), MooseServer::getNodesByValueAndTypes(), CSG::CSGSurface::getSurfaceType(), CSG::CSGLattice::getType(), CSG::CSGEngUnit::getUnitType(), ThreadedElementLoop< RangeType >::printExecutionOrdering(), Moose::ParameterRegistry::set(), JsonSyntaxTree::setParams(), and MFEMProblem::solverTypeString().

realpath()

std::string MooseUtils::realpath

(

const std::string &

path

)

Definition at line 1188 of file MooseUtils.C.

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

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

removeColor()

std::string & MooseUtils::removeColor

(

std::string &

msg

)

Definition at line 785 of file MooseUtils.C.

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

Referenced by Console::writeStreamToFile().

removedirs()

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

Definition at line 568 of file MooseUtils.C.

{
  // split path into directories with delimiter '/'
  std::vector<std::string> split_dir_names;
  MooseUtils::tokenize(dir_name, split_dir_names);
 
  auto n = split_dir_names.size();
 
  // remove '.' and '..' when possible
  auto i = n;
  i = 0;
  while (i != n)
  {
    if (split_dir_names[i] == ".")
    {
      for (auto j = i + 1; j < n; ++j)
        split_dir_names[j - 1] = split_dir_names[j];
      --n;
    }
    else if (i > 0 && split_dir_names[i] == ".." && split_dir_names[i - 1] != "..")
    {
      for (auto j = i + 1; j < n; ++j)
        split_dir_names[j - 2] = split_dir_names[j];
      n -= 2;
      --i;
    }
    else
      ++i;
  }
  if (n == 0)
    return;
 
  split_dir_names.resize(n);
 
  // start removing directories recursively
  std::string base_dir = dir_name[0] == '/' ? "" : ".";
  for (i = n; i > 0; --i)
  {
    std::string cur_dir = base_dir;
    auto j = i;
    for (j = 0; j < i; ++j)
      cur_dir += "/" + split_dir_names[j];
 
    // listDir should return at least '.' and '..'
    if (pathExists(cur_dir) && listDir(cur_dir).size() == 2)
    {
      auto code = rmdir(cur_dir.c_str());
      if (code != 0)
      {
        std::string msg = "Failed removing directory " + dir_name;
        if (throw_on_failure)
          throw std::invalid_argument(msg);
        else
          mooseError(msg);
      }
    }
    else
      // stop removing
      break;
  }
}

removeExtraWhitespace()

std::string MooseUtils::removeExtraWhitespace

(

const std::string &

input

)

Definition at line 288 of file MooseUtils.C.

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

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

replaceAll()

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

Definition at line 208 of file MooseUtils.C.

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

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

replaceStart()

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

Definition at line 1250 of file MooseUtils.C.

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

resample() [1/4]

template<typename T >

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

Definition at line 540 of file Shuffle.h.

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

resample() [2/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 549 of file Shuffle.h.

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

resample() [3/4]

template<typename T >

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

Definition at line 335 of file Shuffle.h.

{
  // Size of the local input data
  const std::size_t n_local = data.size();
 
  // Re-sampled data vector to be returned
  std::vector<T> replicate(n_local);
 
  // REPLICATED data
  if (!comm_ptr || comm_ptr->size() == 1)
  {
    replicate.resize(n_local);
    for (std::size_t j = 0; j < n_local; ++j)
    {
      auto index = generator.randl(seed_index, 0, n_local);
      replicate[j] = data[index];
    }
  }
 
  // DISTRIBUTED data
  else
  {
    // Compute the global size of the vector
    std::size_t n_global = n_local;
    comm_ptr->sum(n_global);
 
    // Compute the vector data offsets, the scope cleans up the "n_local" vector
    std::vector<std::size_t> offsets(comm_ptr->size());
    {
      std::vector<std::size_t> local_sizes;
      comm_ptr->allgather(n_local, local_sizes);
      for (std::size_t i = 0; i < local_sizes.size() - 1; ++i)
        offsets[i + 1] = offsets[i] + local_sizes[i];
    }
 
    // Advance the random number generator to the current offset
    const auto rank = comm_ptr->rank();
    for (std::size_t i = 0; i < offsets[rank]; ++i)
      generator.randl(seed_index, 0, n_global);
 
    // Compute the needs for this processor
    std::unordered_map<processor_id_type, std::vector<std::pair<std::size_t, std::size_t>>> needs;
    for (std::size_t i = 0; i < n_local; ++i)
    {
      const auto idx = generator.randl(seed_index, 0, n_global); // random global index
 
      // Locate the rank and local index of the data desired
      const auto idx_offset_iter = std::prev(std::upper_bound(offsets.begin(), offsets.end(), idx));
      const auto idx_rank = std::distance(offsets.begin(), idx_offset_iter);
      const auto idx_local_idx = idx - *idx_offset_iter;
 
      // Local available data can be inserted into the re-sample, non-local data is add the the
      // needs from other ranks
      if (idx_rank == rank)
        replicate[i] = data[idx_local_idx];
      else
        needs[idx_rank].emplace_back(idx_local_idx, i);
    }
 
    // Advance the random number generator to the end of the global vector
    for (std::size_t i = offsets[rank] + n_local; i < n_global; ++i)
      generator.randl(seed_index, 0, n_global);
 
    // Collect the values to be returned to the various processors
    std::unordered_map<processor_id_type, std::vector<std::pair<T, std::size_t>>> returns;
    auto return_functor =
        [&data, &returns](processor_id_type pid,
                          const std::vector<std::pair<std::size_t, std::size_t>> & indices)
    {
      auto & returns_pid = returns[pid];
      for (const auto & idx : indices)
        returns_pid.emplace_back(data[idx.first], idx.second);
    };
    Parallel::push_parallel_vector_data(*comm_ptr, needs, return_functor);
 
    // Receive resampled values from the various processors
    auto recv_functor =
        [&replicate](processor_id_type, const std::vector<std::pair<T, std::size_t>> & values)
    {
      for (const auto & value : values)
        replicate[value.second] = value.first;
    };
    Parallel::push_parallel_vector_data(*comm_ptr, returns, recv_functor);
  }
  return replicate;
}

resample() [4/4]

template<typename T >

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

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

Parameters

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

Definition at line 531 of file Shuffle.h.

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

Referenced by resample(), resample(), and resample().

resampleWithFunctor() [1/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 569 of file Shuffle.h.

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

resampleWithFunctor() [2/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 579 of file Shuffle.h.

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

resampleWithFunctor() [3/4]

template<typename T , typename ActionFunctor >

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

Definition at line 427 of file Shuffle.h.

{
  const std::size_t n_local = data.size();
 
  if (!comm_ptr || comm_ptr->size() == 1)
  {
    for (std::size_t j = 0; j < n_local; ++j)
    {
      auto index = generator.randl(seed_index, 0, n_local);
      functor(data[index]);
    }
  }
  else
  {
    // Compute the global size of the vector
    std::size_t n_global = n_local;
    comm_ptr->sum(n_global);
 
    // Compute the vector data offsets, the scope cleans up the "n_local" vector
    std::vector<std::size_t> offsets(comm_ptr->size());
    {
      std::vector<std::size_t> local_sizes;
      comm_ptr->allgather(n_local, local_sizes);
      for (std::size_t i = 0; i < local_sizes.size() - 1; ++i)
        offsets[i + 1] = offsets[i] + local_sizes[i];
    }
 
    // Advance the random number generator to the current offset
    const auto rank = comm_ptr->rank();
    for (std::size_t i = 0; i < offsets[rank]; ++i)
      generator.randl(seed_index, 0, n_global);
 
    // Compute the needs for this processor
    std::unordered_map<processor_id_type, std::vector<std::size_t>> indices;
    for (std::size_t i = 0; i < n_local; ++i)
    {
      const auto idx = generator.randl(seed_index, 0, n_global); // random global index
 
      // Locate the rank and local index of the data desired
      const auto idx_offset_iter = std::prev(std::upper_bound(offsets.begin(), offsets.end(), idx));
      const auto idx_rank = std::distance(offsets.begin(), idx_offset_iter);
      const auto idx_local_idx = idx - *idx_offset_iter;
 
      // Push back the index to appropriate rank
      indices[idx_rank].push_back(idx_local_idx);
    }
 
    // Advance the random number generator to the end of the global vector
    for (std::size_t i = offsets[rank] + n_local; i < n_global; ++i)
      generator.randl(seed_index, 0, n_global);
 
    // Send the indices to the appropriate rank and have the calculator do its work
    auto act_functor =
        [&functor, &data](processor_id_type /*pid*/, const std::vector<std::size_t> & indices)
    {
      for (const auto & idx : indices)
        functor(data[idx]);
    };
    Parallel::push_parallel_vector_data(*comm_ptr, indices, act_functor);
  }
}

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 = 0
	)

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

Parameters

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

Definition at line 559 of file Shuffle.h.

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

Referenced by resampleWithFunctor(), resampleWithFunctor(), and resampleWithFunctor().

reset() [1/2]

template<class T , typename... Args>

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

Definition at line 28 of file SharedPool.h.

{
}

reset() [2/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.

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

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

rsplit()

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

Definition at line 1103 of file MooseUtils.C.

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

runTestsExecutable()

std::string MooseUtils::runTestsExecutable

(

)

Definition at line 128 of file MooseUtils.C.

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

Referenced by MooseApp::runInputs().

serialBegin()

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

Definition at line 420 of file MooseUtils.C.

{
  // 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)");
}

Referenced by SerializerGuard::SerializerGuard().

serialEnd()

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

Definition at line 434 of file MooseUtils.C.

{
  // 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)");
}

Referenced by SerializerGuard::~SerializerGuard().

shortName()

std::string MooseUtils::shortName

(

const std::string &

name

)

Definition at line 675 of file MooseUtils.C.

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

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

shuffle() [1/4]

template<typename T >

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

Definition at line 512 of file Shuffle.h.

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

shuffle() [2/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 521 of file Shuffle.h.

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

shuffle() [3/4]

template<typename T >

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

Definition at line 244 of file Shuffle.h.

{
  // REPLICATED data
  if (!comm_ptr || comm_ptr->size() == 1)
  {
    std::size_t n_global = data.size();
    for (std::size_t i = n_global - 1; i > 0; --i)
    {
      auto j = generator.randl(seed_index, 0, i);
      MooseUtils::swap(data, i, j, nullptr);
    }
  }
 
  // DISTRIBUTED data
  else
  {
    // Local/global size
    std::size_t n_local = data.size();
    std::size_t n_global = n_local;
    comm_ptr->sum(n_global);
 
    // Compute the vector data offsets, the scope cleans up the "n_local" vector
    std::vector<std::size_t> offsets(comm_ptr->size());
    {
      std::vector<std::size_t> local_sizes;
      comm_ptr->allgather(n_local, local_sizes);
      for (std::size_t i = 0; i < local_sizes.size() - 1; ++i)
        offsets[i + 1] = offsets[i] + local_sizes[i];
    }
 
    // Perform swaps
    auto rank = comm_ptr->rank();
    for (std::size_t idx0 = n_global - 1; idx0 > 0; --idx0)
    {
      auto idx1 = generator.randl(seed_index, 0, idx0);
 
      // Locate the rank and local index of the data to swap
      auto idx0_offset_iter = std::prev(std::upper_bound(offsets.begin(), offsets.end(), idx0));
      auto idx0_rank = std::distance(offsets.begin(), idx0_offset_iter);
      auto idx0_local_idx = idx0 - *idx0_offset_iter;
 
      auto idx1_offset_iter = std::prev(std::upper_bound(offsets.begin(), offsets.end(), idx1));
      auto idx1_rank = std::distance(offsets.begin(), idx1_offset_iter);
      auto idx1_local_idx = idx1 - *idx1_offset_iter;
 
      // The values, if any, needed from other rank
      std::unordered_map<processor_id_type, std::vector<std::size_t>> needs;
      if (idx0_rank != rank && idx1_rank == rank)
        needs[idx0_rank].push_back(idx0_local_idx);
      if (idx0_rank == rank && idx1_rank != rank)
        needs[idx1_rank].push_back(idx1_local_idx);
 
      // Collect the values needed by this processor
      std::unordered_map<processor_id_type, std::vector<T>> returns;
      auto return_functor =
          [&data, &returns](processor_id_type pid, const std::vector<std::size_t> & indices)
      {
        auto & returns_pid = returns[pid];
        for (auto idx : indices)
          returns_pid.push_back(data[idx]);
      };
      Parallel::push_parallel_vector_data(*comm_ptr, needs, return_functor);
 
      // Receive needed values from the others processors
      std::vector<T> incoming;
      auto recv_functor = [&incoming](processor_id_type /*pid*/, const std::vector<T> & values)
      { incoming = values; };
      Parallel::push_parallel_vector_data(*comm_ptr, returns, recv_functor);
 
      if (idx0_rank == rank && idx1_rank == rank)
        MooseUtils::swap(data, idx0_local_idx, idx1_local_idx);
 
      else if (idx0_rank == rank)
      {
        mooseAssert(incoming.size() == 1, "Only one value should be received");
        data[idx0_local_idx] = incoming[0];
      }
      else if (idx1_rank == rank)
      {
        mooseAssert(incoming.size() == 1, "Only one value should be received");
        data[idx1_local_idx] = incoming[0];
      }
    }
  }
}

shuffle() [4/4]

template<typename T >

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

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

Parameters

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

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

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

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

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

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

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

Definition at line 505 of file Shuffle.h.

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

Referenced by shuffle(), shuffle(), and shuffle().

split()

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

Definition at line 1083 of file MooseUtils.C.

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

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

startsWith()

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

Definition at line 1242 of file MooseUtils.C.

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

Referenced by replaceStart().

stringJoin()

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

inline

Concatenates value into a single string separated by separator.

Definition at line 201 of file MooseStringUtils.h.

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

Referenced by InputParameters::addCommandLineParamHelper(), Moose::Builder::build(), InputParameters::checkParams(), Moose::Capability::enumerationToString(), EnumerateEvaler::eval(), RangeEvaler::eval(), RepeatEvaler::eval(), Parser::joinErrorMessages(), Parser::parse(), ParsedPostprocessor::ParsedPostprocessor(), MFEMProblem::solverTypeString(), and MeshInfo::validParams().

stringToInteger()

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

Definition at line 1030 of file MooseUtils.C.

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

Referenced by FormattedTable::printTable().

stripExtension()

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

Definition at line 490 of file MooseUtils.C.

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

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

swap() [1/2]

template<typename T >

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

Swap function for serial or distributed vector of data.

Parameters

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

Definition at line 495 of file Shuffle.h.

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

Referenced by shuffle(), and swap().

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 156 of file Shuffle.h.

{
  if (!comm_ptr || comm_ptr->size() == 1)
  {
    mooseAssert(idx0 < data.size(),
                "idx0 (" << idx0 << ") out of range, data.size() is " << data.size());
    mooseAssert(idx1 < data.size(),
                "idx1 (" << idx1 << ") out of range, data.size() is " << data.size());
    std::swap(data[idx0], data[idx1]);
  }
 
  else
  {
    // Size of the local input data
    const auto n_local = data.size();
    const auto rank = comm_ptr->rank();
 
    // Compute the global size of the vector
    std::size_t n_global = n_local;
    comm_ptr->sum(n_global);
    mooseAssert(idx0 < n_global,
                "idx0 (" << idx0 << ") out of range, the global data size is " << n_global);
    mooseAssert(idx1 < n_global,
                "idx1 (" << idx1 << ") out of range, the global data size is " << n_global);
 
    // Compute the vector data offsets, the scope cleans up the "n_local" vector
    std::vector<std::size_t> offsets(comm_ptr->size());
    {
      std::vector<std::size_t> local_sizes;
      comm_ptr->allgather(n_local, local_sizes);
      for (std::size_t i = 0; i < local_sizes.size() - 1; ++i)
        offsets[i + 1] = offsets[i] + local_sizes[i];
    }
 
    // Locate the rank and local index of the data to swap
    auto idx0_offset_iter = std::prev(std::upper_bound(offsets.begin(), offsets.end(), idx0));
    auto idx0_rank = std::distance(offsets.begin(), idx0_offset_iter);
    auto idx0_local_idx = idx0 - *idx0_offset_iter;
 
    auto idx1_offset_iter = std::prev(std::upper_bound(offsets.begin(), offsets.end(), idx1));
    auto idx1_rank = std::distance(offsets.begin(), idx1_offset_iter);
    auto idx1_local_idx = idx1 - *idx1_offset_iter;
 
    // The values, if any, needed from other rank
    std::unordered_map<processor_id_type, std::vector<std::size_t>> needs;
    if (idx0_rank != rank && idx1_rank == rank)
      needs[idx0_rank].push_back(idx0_local_idx);
    if (idx0_rank == rank && idx1_rank != rank)
      needs[idx1_rank].push_back(idx1_local_idx);
 
    // Collect the values needed by this processor
    std::unordered_map<processor_id_type, std::vector<T>> returns;
    auto return_functor =
        [&data, &returns](processor_id_type pid, const std::vector<std::size_t> & indices)
    {
      auto & returns_pid = returns[pid];
      for (auto idx : indices)
        returns_pid.push_back(data[idx]);
    };
    Parallel::push_parallel_vector_data(*comm_ptr, needs, return_functor);
 
    // Receive needed values from the others processors
    std::vector<T> incoming;
    auto recv_functor = [&incoming](processor_id_type /*pid*/, const std::vector<T> & values)
    { incoming = values; };
    Parallel::push_parallel_vector_data(*comm_ptr, returns, recv_functor);
 
    if (idx0_rank == rank && idx1_rank == rank)
      MooseUtils::swap(data, idx0_local_idx, idx1_local_idx);
 
    else if (idx0_rank == rank)
    {
      mooseAssert(incoming.size() == 1, "Only one value should be received");
      data[idx0_local_idx] = incoming[0];
    }
    else if (idx1_rank == rank)
    {
      mooseAssert(incoming.size() == 1, "Only one value should be received");
      data[idx1_local_idx] = incoming[0];
    }
  }
}

tokenize()

template<typename T >

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

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

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

Definition at line 55 of file MooseStringUtils.h.

{
  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()));
  }
}

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

tokenizeAndConvert()

template<typename T >

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

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

If the conversion fails tokenizeAndConvert returns false, otherwise true.

Definition at line 162 of file MooseStringUtils.h.

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

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

toLower()

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

inline

Convert supplied string to lower case.

@params name The string to convert upper case.

Definition at line 191 of file MooseStringUtils.h.

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

Referenced by Registry::appNameFromAppPath(), Moose::internal::CapabilityRegistry::check(), elemQualityToString(), MooseServer::getDocumentSymbolKind(), ConsoleUtils::outputRelationshipManagerInformation(), MooseUtils::DelimitedFileReaderTempl< T >::processLine(), Moose::internal::CapabilityRegistry::query(), AppFactory::registerAppCapability(), Moose::PeriodicBCHelper::setupAutoPeriodicBoundaries(), and WorkBalance::WorkBalance().

toUpper()

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

inline

Convert supplied string to upper case.

@params name The string to convert upper case.

Definition at line 180 of file MooseStringUtils.h.

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

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

trim()

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

inline

Standard scripting language trim function.

Definition at line 38 of file MooseStringUtils.h.

{
  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);
}

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

underscoreToCamelCase()

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

Definition at line 643 of file MooseUtils.C.

{
  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;
}

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

variableFEType()

libMesh::FEType MooseUtils::variableFEType

(

const InputParameters &

params

)

Definition at line 98 of file MooseUtils.C.

{
  const auto order =
      libMesh::Utility::string_to_enum<libMesh::Order>(params.get<MooseEnum>("order"));
  const auto family =
      libMesh::Utility::string_to_enum<libMesh::FEFamily>(params.get<MooseEnum>("family"));
 
  bool p_refinement = defaultPRefinement(order, family);
  if (params.isParamValid("p_refinement"))
    p_refinement = params.get<bool>("p_refinement");
 
  if (params.isParamValid("disable_p_refinement"))
  {
    if (params.isParamSetByUser("p_refinement"))
      params.paramError("disable_p_refinement",
                        "Cannot be supplied together with 'p_refinement'. Use "
                        "'p_refinement = false' instead.");
    p_refinement = !params.get<bool>("disable_p_refinement");
  }
 
  return libMesh::FEType(order, family).set_p_refinement(p_refinement);
}

Referenced by FEProblemBase::addAuxVariable(), AuxiliarySystem::addVariable(), SystemBase::addVariable(), FEProblemBase::addVariable(), and AddVariableAction::feType().

wildCardMatch()

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

Definition at line 951 of file MooseUtils.C.

{
  // 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;
}

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