MooseUtils.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* 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 "MooseTypes.h"
#include "HashMap.h"
#include "InfixIterator.h"
#include "MooseEnumItem.h"
#include "MooseError.h"
#include "Moose.h"
#include "ExecutablePath.h"
#include "ConsoleUtils.h"
#include "MooseStringUtils.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>
#include <regex>
 
// 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, Real * parsed_real = nullptr);
 
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 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 & str);
 
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 Iterator>
std::string
join(Iterator begin, Iterator end, const std::string & delimiter)
{
  std::ostringstream oss;
  std::copy(begin, end, infix_ostream_iterator<std::string>(oss, delimiter.c_str()));
  return oss.str();
}
 
template <typename T>
std::string
join(const T & strings, const std::string & delimiter)
{
  return join(strings.begin(), strings.end(), delimiter);
}
 
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 getExtension(const std::string & filename, const bool rfind = false);
 
std::string stripExtension(const std::string & s, const bool rfind = false);
 
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 * obj = nullptr)
{
  if (obj)
    return prettyCppType(libMesh::demangle(typeid(*obj).name()));
  else
    return prettyCppType(libMesh::demangle(typeid(T).name()));
}
 
bool isFinitePoint(const Point & point);
 
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;
}
 
inline bool
absoluteFuzzyEqual(const Point & v1,
                   const Point & v2,
                   const Real tol = libMesh::TOLERANCE * libMesh::TOLERANCE)
{
  for (const auto i : make_range(Moose::dim))
    if (std::abs(v1(i) - v2(i)) > tol)
      return false;
  return true;
}
 
template <
    typename T,
    typename T2,
    typename T3 = T,
    typename std::enable_if<libMesh::ScalarTraits<T>::value && libMesh::ScalarTraits<T2>::value &&
                                libMesh::ScalarTraits<T3>::value,
                            int>::type = 0>
bool
absoluteFuzzyEqual(const T & var1,
                   const T2 & var2,
                   const T3 & tol = libMesh::TOLERANCE * libMesh::TOLERANCE)
{
  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<libMesh::ScalarTraits<T>::value && libMesh::ScalarTraits<T2>::value &&
                                libMesh::ScalarTraits<T3>::value,
                            int>::type = 0>
bool
absoluteFuzzyGreaterEqual(const T & var1,
                          const T2 & var2,
                          const T3 & tol = libMesh::TOLERANCE * libMesh::TOLERANCE)
{
  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<libMesh::ScalarTraits<T>::value && libMesh::ScalarTraits<T2>::value &&
                                libMesh::ScalarTraits<T3>::value,
                            int>::type = 0>
bool
absoluteFuzzyGreaterThan(const T & var1,
                         const T2 & var2,
                         const T3 & tol = libMesh::TOLERANCE * libMesh::TOLERANCE)
{
  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<libMesh::ScalarTraits<T>::value && libMesh::ScalarTraits<T2>::value &&
                                libMesh::ScalarTraits<T3>::value,
                            int>::type = 0>
bool
absoluteFuzzyLessEqual(const T & var1,
                       const T2 & var2,
                       const T3 & tol = libMesh::TOLERANCE * libMesh::TOLERANCE)
{
  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<libMesh::ScalarTraits<T>::value && libMesh::ScalarTraits<T2>::value &&
                                libMesh::ScalarTraits<T3>::value,
                            int>::type = 0>
bool
absoluteFuzzyLessThan(const T & var1,
                      const T2 & var2,
                      const T3 & tol = libMesh::TOLERANCE * libMesh::TOLERANCE)
{
  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<libMesh::ScalarTraits<T>::value && libMesh::ScalarTraits<T2>::value &&
                                libMesh::ScalarTraits<T3>::value,
                            int>::type = 0>
bool
relativeFuzzyGreaterEqual(const T & var1,
                          const T2 & var2,
                          const T3 & tol = libMesh::TOLERANCE * libMesh::TOLERANCE)
{
  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<libMesh::ScalarTraits<T>::value && libMesh::ScalarTraits<T2>::value &&
                                libMesh::ScalarTraits<T3>::value,
                            int>::type = 0>
bool
relativeFuzzyGreaterThan(const T & var1,
                         const T2 & var2,
                         const T3 & tol = libMesh::TOLERANCE * libMesh::TOLERANCE)
{
  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<libMesh::ScalarTraits<T>::value && libMesh::ScalarTraits<T2>::value &&
                                libMesh::ScalarTraits<T3>::value,
                            int>::type = 0>
bool
relativeFuzzyLessEqual(const T & var1,
                       const T2 & var2,
                       const T3 & tol = libMesh::TOLERANCE * libMesh::TOLERANCE)
{
  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<libMesh::ScalarTraits<T>::value && libMesh::ScalarTraits<T2>::value &&
                                libMesh::ScalarTraits<T3>::value,
                            int>::type = 0>
bool
relativeFuzzyLessThan(const T & var1,
                      const T2 & var2,
                      const T3 & tol = libMesh::TOLERANCE * libMesh::TOLERANCE)
{
  return (absoluteFuzzyLessThan(
      var1,
      var2,
      tol * (std::abs(MetaPhysicL::raw_value(var1)) + std::abs(MetaPhysicL::raw_value(var2)))));
}
 
template <typename T>
void
getUnion(const std::vector<T> & vector1, const std::vector<T> & vector2, std::vector<T> & common)
{
  std::unordered_set<T> unique_elements;
  unique_elements.reserve(vector1.size() + vector2.size());
  unique_elements.insert(vector1.begin(), vector1.end());
  unique_elements.insert(vector2.begin(), vector2.end());
 
  // Now populate the common vector with the union
  common.assign(unique_elements.begin(), unique_elements.end());
}
 
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);
 
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>
T
convert(const std::string & str, bool throw_on_failure = false)
{
  T val;
  try
  {
    convert(str, val, true);
  }
  catch (std::exception const & e)
  {
    if (throw_on_failure)
      throw;
    mooseError(e.what());
  }
  return val;
}
 
void createSymlink(const std::string & target, const std::string & link);
 
void clearSymlink(const std::string & link);
 
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;
}
 
bool beginsWith(const std::string & value, const std::string & begin_value);
 
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<ADReal>
{
  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 It, typename M1, typename M2>
auto
findPair(C & container, It start_iterator, const M1 & first, const M2 & second)
{
  return std::find_if(
      start_iterator,
      container.end(),
      [&](auto & item)
      { return wildcardEqual(first, item.first) && wildcardEqual(second, item.second); });
}
 
libMesh::BoundingBox buildBoundingBox(const Point & p1, const Point & p2);
 
template <typename T, std::size_t N, bool value_init = true>
#if METAPHYSICL_MAJOR_VERSION < 2
class SemidynamicVector : public MetaPhysicL::DynamicStdArrayWrapper<T, MetaPhysicL::NWrapper<N>>
{
  typedef MetaPhysicL::DynamicStdArrayWrapper<T, MetaPhysicL::NWrapper<N>> Parent;
#else
class SemidynamicVector : public MetaPhysicL::DynamicStdArrayWrapper<T, N>
{
  typedef MetaPhysicL::DynamicStdArrayWrapper<T, N> Parent;
#endif
 
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); });
}
 
inline bool
isFloat(const std::string & str)
{
  if (str.empty())
    return false;
  char * ptr;
  strtof(str.c_str(), &ptr);
  return (*ptr) == '\0';
}
 
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);
} // MooseUtils namespace
 
namespace Moose
{
template <typename T>
struct ADType;
 
template <typename T, std::size_t N, bool value_init>
struct ADType<MooseUtils::SemidynamicVector<T, N, value_init>>
{
  typedef MooseUtils::SemidynamicVector<typename ADType<T>::type, N, value_init> type;
};
}
 
void removeSubstring(std::string & main, const std::string & sub);
 
std::string removeSubstring(const std::string & main, const std::string & sub);