MooseUtils.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html

#pragma once

// MOOSE includes
#include "HashMap.h"
#include "InfixIterator.h"
#include "MooseEnumItem.h"
#include "MooseError.h"
#include "MooseADWrapper.h"
#include "Moose.h"
#include "ADReal.h"
#include "ExecutablePath.h"
#include "ConsoleUtils.h"

#include "libmesh/compare_types.h"
#include "libmesh/bounding_box.h"
#include "libmesh/int_range.h"
#include "libmesh/tensor_tools.h"
#include "metaphysicl/raw_type.h"
#include "metaphysicl/metaphysicl_version.h"
#include "metaphysicl/dualnumber_decl.h"
#include "metaphysicl/dynamic_std_array_wrapper.h"
#include "timpi/standard_type.h"

// C++ includes
#include <string>
#include <vector>
#include <map>
#include <list>
#include <filesystem>
#include <deque>

// Forward Declarations
class InputParameters;
class ExecFlagEnum;
class MaterialProperties;
class MaterialBase;

namespace libMesh
{
class Elem;
namespace Parallel
{
class Communicator;
}
}
class MultiMooseEnum;

namespace MooseUtils
{

std::filesystem::path pathjoin(const std::filesystem::path & p);

template <typename... Args>
std::filesystem::path
pathjoin(const std::filesystem::path & p, Args... args)
{
  return p / pathjoin(args...);
}

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

std::string runTestsExecutable();

std::string findTestRoot();

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 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 trim(const std::string & str, const std::string & white_space = " \t\n\v\f\r");

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

template <typename T>
std::string
join(const T & strings, const std::string & delimiter)
{
  std::ostringstream oss;
  std::copy(
      strings.begin(), strings.end(), infix_ostream_iterator<std::string>(oss, delimiter.c_str()));
  return oss.str();
}

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

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

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

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

bool checkForGitLFSPointer(std::ifstream & file);

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

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

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

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

std::string stripExtension(const std::string & s);

template <typename T>
std::pair<std::filesystem::path, std::filesystem::path>
splitFileName(const T & full_file)
{
  const auto p = std::filesystem::path(std::string(full_file));
  // Error if path ends with /
  if (!p.has_filename())
    mooseError("Invalid full file name: ", p);

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

std::string getCurrentWorkingDir();

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

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

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

std::string prettyCppType(const std::string & cpp_type);

template <typename T>
std::string
prettyCppType(const T * = nullptr)
{
  return prettyCppType(demangle(typeid(T).name()));
}

template <typename T1, typename T2>
bool
doesMapContainValue(const std::map<T1, T2> & the_map, const T2 & value)
{
  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;
}

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)
{
  return (std::abs(MetaPhysicL::raw_value(var1) - MetaPhysicL::raw_value(var2)) <=
          MetaPhysicL::raw_value(tol));
}

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
absoluteFuzzyGreaterEqual(const T & var1,
                          const T2 & var2,
                          const T3 & tol = libMesh::TOLERANCE * libMesh::TOLERANCE)
{
  return (MetaPhysicL::raw_value(var1) >=
          (MetaPhysicL::raw_value(var2) - MetaPhysicL::raw_value(tol)));
}

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
absoluteFuzzyGreaterThan(const T & var1,
                         const T2 & var2,
                         const T3 & tol = libMesh::TOLERANCE * libMesh::TOLERANCE)
{
  return (MetaPhysicL::raw_value(var1) >
          (MetaPhysicL::raw_value(var2) + MetaPhysicL::raw_value(tol)));
}

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
absoluteFuzzyLessEqual(const T & var1,
                       const T2 & var2,
                       const T3 & tol = libMesh::TOLERANCE * libMesh::TOLERANCE)
{
  return (MetaPhysicL::raw_value(var1) <=
          (MetaPhysicL::raw_value(var2) + MetaPhysicL::raw_value(tol)));
}

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
absoluteFuzzyLessThan(const T & var1,
                      const T2 & var2,
                      const T3 & tol = libMesh::TOLERANCE * libMesh::TOLERANCE)
{
  return (MetaPhysicL::raw_value(var1) <
          (MetaPhysicL::raw_value(var2) - MetaPhysicL::raw_value(tol)));
}

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

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

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

    return true;
  }
}

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
relativeFuzzyGreaterEqual(const T & var1,
                          const T2 & var2,
                          const T3 & tol = libMesh::TOLERANCE * libMesh::TOLERANCE)
{
  return (absoluteFuzzyGreaterEqual(
      var1,
      var2,
      tol * (std::abs(MetaPhysicL::raw_value(var1)) + std::abs(MetaPhysicL::raw_value(var2)))));
}

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
relativeFuzzyGreaterThan(const T & var1,
                         const T2 & var2,
                         const T3 & tol = libMesh::TOLERANCE * libMesh::TOLERANCE)
{
  return (absoluteFuzzyGreaterThan(
      var1,
      var2,
      tol * (std::abs(MetaPhysicL::raw_value(var1)) + std::abs(MetaPhysicL::raw_value(var2)))));
}

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
relativeFuzzyLessEqual(const T & var1,
                       const T2 & var2,
                       const T3 & tol = libMesh::TOLERANCE * libMesh::TOLERANCE)
{
  return (absoluteFuzzyLessEqual(
      var1,
      var2,
      tol * (std::abs(MetaPhysicL::raw_value(var1)) + std::abs(MetaPhysicL::raw_value(var2)))));
}

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
relativeFuzzyLessThan(const T & var1,
                      const T2 & var2,
                      const T3 & tol = libMesh::TOLERANCE * libMesh::TOLERANCE)
{
  return (absoluteFuzzyLessThan(
      var1,
      var2,
      tol * (std::abs(MetaPhysicL::raw_value(var1)) + std::abs(MetaPhysicL::raw_value(var2)))));
}

template <typename T>
class Has_size
{
  using Yes = char;
  struct No
  {
    char x[2];
  };

  template <typename C>
  static Yes test(decltype(&C::size));
  template <typename C>
  static No test(...);

public:
  static constexpr bool value = sizeof(test<T>(0)) == sizeof(Yes);
};

template <typename T>
bool
isZero(const T & value, const Real tolerance = TOLERANCE * TOLERANCE * TOLERANCE)
{
  if constexpr (Has_size<T>::value)
  {
    for (const auto & element : value)
      if (!isZero(element, tolerance))
        return false;

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

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

    return true;
  }
}

void MaterialPropertyStorageDump(
    const HashMap<const libMesh::Elem *, HashMap<unsigned int, MaterialProperties>> & props);

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

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

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

bool pathExists(const std::string & path);
bool pathIsDirectory(const std::string & path);

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

std::string getLatestCheckpointFilePrefix(const std::list<std::string> & checkpoint_files);

/*
 * Checks to see if a string matches a search string
 * @param name The name to check
 * @param search_string The search string to check name against
 */
bool wildCardMatch(std::string name, std::string search_string);

/*
 * Checks to see if a candidate string matches a pattern string, permitting glob
 * wildcards (* and ?) anywhere in the pattern.
 * @param candidate The name to check
 * @param pattern The search string to check name candidate
 */
bool globCompare(const std::string & candidate,
                 const std::string & pattern,
                 std::size_t c = 0,
                 std::size_t p = 0);

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

template <typename T>
void
tokenize(const std::string & str,
         std::vector<T> & elements,
         unsigned int min_len = 1,
         const std::string & delims = "/")
{
  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()));
  }
}

template <typename T>
bool
tokenizeAndConvert(const std::string & str,
                   std::vector<T> & tokenized_vector,
                   const std::string & delimiter = " \t\n\v\f\r")
{
  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;
}

template <typename T>
T
convert(const std::string & str, bool throw_on_failure = false)
{
  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;
}

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

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

std::string toUpper(const std::string & name);

std::string toLower(const std::string & name);

template <typename T>
T
concatenate(T c1, const T & c2)
{
  c1.insert(c2.begin(), c2.end());
  return c1;
}

template <typename T>
std::vector<T>
concatenate(std::vector<T> c1, const std::vector<T> & c2)
{
  c1.insert(c1.end(), c2.begin(), c2.end());
  return c1;
}

template <typename T>
std::vector<T>
concatenate(std::vector<T> c1, const T & item)
{
  c1.push_back(item);
  return c1;
}

template <typename T>
int
numDigits(const T & num)
{
  return num > 9 ? static_cast<int>(std::log10(static_cast<double>(num))) + 1 : 1;
}

ExecFlagEnum getDefaultExecFlagEnum();

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

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::string realpath(const std::string & path);

template <typename T>
struct IsLikeReal
{
  static constexpr bool value = false;
};
template <>
struct IsLikeReal<Real>
{
  static constexpr bool value = true;
};
template <>
struct IsLikeReal<DualReal>
{
  static constexpr bool value = true;
};

template <typename T>
struct canBroadcast
{
  static constexpr bool value = std::is_base_of<TIMPI::DataType, TIMPI::StandardType<T>>::value ||
                                TIMPI::Has_buffer_type<TIMPI::Packing<T>>::value;
};

const static struct AnyType
{
} Any;

template <typename T1, typename T2>
bool
wildcardEqual(const T1 & a, const T2 & b)
{
  return a == b;
}

template <typename T>
bool
wildcardEqual(const T &, AnyType)
{
  return true;
}
template <typename T>
bool
wildcardEqual(AnyType, const T &)
{
  return true;
}

template <typename C, typename M1, typename M2>
typename C::iterator
findPair(C & container, const M1 & first, const M2 & second)
{
  return std::find_if(container.begin(),
                      container.end(),
                      [&](auto & item) {
                        return wildcardEqual(first, item.first) &&
                               wildcardEqual(second, item.second);
                      });
}

BoundingBox buildBoundingBox(const Point & p1, const Point & p2);

template <typename T, std::size_t N, bool value_init = true>
class SemidynamicVector : public MetaPhysicL::DynamicStdArrayWrapper<T, MetaPhysicL::NWrapper<N>>
{
  typedef MetaPhysicL::DynamicStdArrayWrapper<T, MetaPhysicL::NWrapper<N>> Parent;

public:
  SemidynamicVector(std::size_t size) : Parent()
  {
    Parent::resize(size);
    if constexpr (value_init)
      for (const auto i : make_range(size))
        _data[i] = T{};
  }

  void resize(std::size_t new_size)
  {
    [[maybe_unused]] const auto old_dynamic_n = Parent::size();

    Parent::resize(new_size);

    if constexpr (value_init)
      for (const auto i : make_range(old_dynamic_n, _dynamic_n))
        _data[i] = T{};
  }

  void push_back(const T & v)
  {
    const auto old_dynamic_n = Parent::size();
    Parent::resize(old_dynamic_n + 1);
    _data[old_dynamic_n] = v;
  }

  template <typename... Args>
  void emplace_back(Args &&... args)
  {
    const auto old_dynamic_n = Parent::size();
    Parent::resize(old_dynamic_n + 1);
    (::new (&_data[old_dynamic_n]) T(std::forward<Args>(args)...));
  }

  std::size_t max_size() const { return N; }

  using Parent::_data;
  using Parent::_dynamic_n;
};

template <typename T>
T *
get(const std::unique_ptr<T> & u)
{
  return u.get();
}

template <typename T>
T *
get(T * p)
{
  return p;
}

template <typename T>
T *
get(const std::shared_ptr<T> & s)
{
  return s.get();
}

template <class InputIterator>
bool
setsIntersect(InputIterator first1, InputIterator last1, InputIterator first2, InputIterator last2)
{
  while (first1 != last1 && first2 != last2)
  {
    if (*first1 == *first2)
      return true;

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

template <class T>
bool
setsIntersect(const T & s1, const T & s2)
{
  return setsIntersect(s1.begin(), s1.end(), s2.begin(), s2.end());
}

inline bool
isDigits(const std::string & str)
{
  return std::all_of(str.begin(), str.end(), [](unsigned char c) { return std::isdigit(c); });
}
} // MooseUtils namespace

void removeSubstring(std::string & main, const std::string & sub);

std::string removeSubstring(const std::string & main, const std::string & sub);