moose::internal Namespace Reference

Classes
class	ConvergenceIterationTypeRegistry
	Registry for Convergence iteration types. More...
class	ExecFlagRegistry
	Registry for statically defining execute flags with consistent numbering. More...
class	PerfGraphRegistry
	The place where all timed sections will be stored. More...
class	PerfGraphSectionInfo
	Used to hold metadata about the registered sections Note: this is a class instead of a struct because structs are not able to be created in place using emplace_back in C++11. More...
struct	SoltionInvalidityNameHash
	Helper class that hash the name associated with an invalid solution. More...
class	SolutionInvalidityInfo
	Helper class that stores the info associated with an invalid solution. More...
class	SolutionInvalidityName
	Helper class that stores the name associated with an invalid solution. More...
class	SolutionInvalidityRegistry
	The place where all sections with solution invalid warnings will be stored. More...

Functions
std::string	incompatVarMsg (MooseVariableFieldBase &var1, MooseVariableFieldBase &var2)
	Builds and returns a string of the form:
std::string	mooseMsgFmt (const std::string &msg, const std::string &title, const std::string &color)
	Format a message for output with a title.
std::string	mooseMsgFmt (const std::string &msg, const std::string &color)
	Format a message for output without a title.
void	mooseErrorRaw (std::string msg, const std::string &prefix="", const hit::Node *node=nullptr, const bool show_trace=true)
	Main callback for emitting a moose error.
std::string	formatMooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, const std::string &msg)
	Formats a documented error.
template<typename T1 , typename T2 >
void	rawValueEqualityHelper (T1 &out, const T2 &in)
template<typename T1 , typename T2 >
void	rawValueEqualityHelper (std::vector< T1 > &out, const std::vector< T2 > &in)
template<typename T1 , typename T2 , std::size_t N>
void	rawValueEqualityHelper (std::array< T1, N > &out, const std::array< T2, N > &in)
template<typename T >
void	dataStoreSizeof (std::ostream &stream, T &v)
template<typename T >
void	dataLoadSizeof (std::istream &stream, T &v)
PerfGraphRegistry &	getPerfGraphRegistry ()
	Get the global PerfGraphRegistry singleton.
SolutionInvalidityRegistry &	getSolutionInvalidityRegistry ()
	Get the global SolutionInvalidityRegistry singleton.
std::ostream &	operator<< (std::ostream &os, const SolutionInvalidityName &name)
bool	boundaryRestricted (const std::set< BoundaryID > &boundary_ids)
void	mooseStreamAll (std::ostringstream &ss)
	All of the following are not meant to be called directly - they are called by the normal macros (mooseError(), etc.) down below.
template<typename T , typename... Args>
void	mooseStreamAll (std::ostringstream &ss, T &&val, Args &&... args)
template<typename S , typename... Args>
void	mooseWarningStream (S &oss, Args &&... args)
template<typename S , typename... Args>
void	mooseUnusedStream (S &oss, Args &&... args)
template<typename S , typename... Args>
void	mooseInfoStreamRepeated (S &oss, Args &&... args)
template<typename S , typename... Args>
void	mooseInfoStream (S &oss, Args &&... args)
template<typename S , typename... Args>
void	mooseDeprecatedStream (S &oss, const bool expired, const bool print_title, const bool show_trace, Args &&... args)

Variables
libMesh::Threads::spin_mutex	moose_stream_lock

Function Documentation

boundaryRestricted()

bool moose::internal::boundaryRestricted

(

const std::set< BoundaryID > &

boundary_ids

)

Definition at line 46 of file MaterialPropertyInterface.C.

{
  return !boundary_ids.empty() && BoundaryRestrictable::restricted(boundary_ids);
}

Referenced by MaterialPropertyInterface::getMaterialDataType().

dataLoadSizeof()

template<typename T >

void moose::internal::dataLoadSizeof	(	std::istream &	stream,
		T &	v
	)

Definition at line 638 of file DataIO.h.

{
  stream.read((char *)&v, sizeof(v));
  mooseAssert(!stream.bad(), "Failed to load");
}

dataStoreSizeof()

template<typename T >

void moose::internal::dataStoreSizeof	(	std::ostream &	stream,
		T &	v
	)

Definition at line 92 of file DataIO.h.

{
  stream.write((char *)&v, sizeof(v));
  mooseAssert(!stream.bad(), "Failed to store");
}

formatMooseDocumentedError()

std::string moose::internal::formatMooseDocumentedError ( const std::string &  repo_name, const unsigned int  issue_num, const std::string &  msg  )

private

Formats a documented error.

A documented error is an error that has an issue associated with it.

The repository name repo_name links a named repository to a URL and should be registered at the application level with registerRepository(). See Moose.C for an example of the "moose" repository registration.

Parameters

repo_name	The repository name where the issue resides
issue_num	The number of the issue
msg	The specific error message

Definition at line 140 of file MooseError.C.

{
  const auto & repo_url = Registry::getRepositoryURL(repo_name);
  std::stringstream oss;
  oss << msg << "\n\nThis error is documented at " << repo_url << "/issues/" << issue_num << ".";
  return oss.str();
}

Referenced by mooseDocumentedError(), and MooseBase::mooseDocumentedError().

getPerfGraphRegistry()

PerfGraphRegistry & moose::internal::getPerfGraphRegistry

(

)

Get the global PerfGraphRegistry singleton.

So it can be constructed.

Definition at line 20 of file PerfGraphRegistry.C.

{
  // In C++11 this is even thread safe! (Lookup "Static Initializers")
  static PerfGraphRegistry perf_graph_registry_singleton;
 
  return perf_graph_registry_singleton;
}

Referenced by PerfGraphReporter::finalize(), PerfGuard::PerfGuard(), PerfGraphInterface::registerTimedSection(), and PerfGraphInterface::registerTimedSection().

getSolutionInvalidityRegistry()

SolutionInvalidityRegistry & moose::internal::getSolutionInvalidityRegistry

(

)

Get the global SolutionInvalidityRegistry singleton.

So it can be constructed.

Definition at line 18 of file SolutionInvalidityRegistry.C.

{
  // In C++11 this is even thread safe! (Lookup "Static Initializers")
  static SolutionInvalidityRegistry solution_invalid_registry_singleton;
 
  return solution_invalid_registry_singleton;
}

Referenced by SolutionInvalidInterface::flagInvalidSolutionInternal(), SolutionInvalidInterface::registerInvalidSolutionInternal(), SolutionInvalidity::syncIteration(), and to_json().

incompatVarMsg()

std::string moose::internal::incompatVarMsg ( MooseVariableFieldBase &  var1, MooseVariableFieldBase &  var2  )

private

Builds and returns a string of the form:

[var1-elemtype],ORDER[var1-order] != [var2-elemtype],ORDER[var2-order]

This is a convenience function to be used when error messages (especially with paramError) need to report that variable types are incompatible (e.g. with residual save-in).

Definition at line 24 of file MooseError.C.

{
  std::stringstream ss;
  ss << libMesh::Utility::enum_to_string<FEFamily>(var1.feType().family) << ",ORDER"
     << var1.feType().order
     << " != " << libMesh::Utility::enum_to_string<FEFamily>(var2.feType().family) << ",ORDER"
     << var2.feType().order;
  return ss.str();
}

Referenced by ADDGKernel::ADDGKernel(), ADIntegratedBCTempl< T >::ADIntegratedBCTempl(), ADKernelTempl< T >::ADKernelTempl(), ArrayDGKernel::ArrayDGKernel(), ArrayIntegratedBC::ArrayIntegratedBC(), ArrayKernel::ArrayKernel(), DGKernel::DGKernel(), IntegratedBC::IntegratedBC(), Kernel::Kernel(), NodalBC::NodalBC(), NodalKernel::NodalKernel(), and MultiAppDofCopyTransfer::transfer().

mooseDeprecatedStream()

template<typename S , typename... Args>

void moose::internal::mooseDeprecatedStream ( S &  oss, const bool  expired, const bool  print_title, const bool  show_trace, Args &&...  args  )

private

Definition at line 252 of file MooseError.h.

{
  if (Moose::_deprecated_is_error)
    mooseError("\n\nDeprecated code:\n", std::forward<Args>(args)...);
 
  std::ostringstream ss;
  mooseStreamAll(ss, args...);
 
  const auto color = expired ? COLOR_RED : COLOR_YELLOW;
  std::string msg = print_title ? mooseMsgFmt(ss.str(), "*** Deprecation Warning ***", color)
                                : mooseMsgFmt(ss.str(), color);
  oss << msg;
  ss.str("");
  if (show_trace)
  {
    if (libMesh::global_n_processors() == 1)
      libMesh::print_trace(ss);
    else
      libMesh::write_traceout();
    {
      libMesh::Threads::spin_mutex::scoped_lock lock(moose_stream_lock);
      oss << ss.str() << std::endl;
    };
  };
}

Referenced by Moose::Builder::build(), mooseDeprecated(), MooseBase::mooseDeprecated(), mooseDeprecatedNoTrace(), MooseBase::mooseDeprecatedNoTrace(), mooseDeprecationExpired(), and mooseDeprecationExpiredNoTrace().

mooseErrorRaw()

void moose::internal::mooseErrorRaw ( std::string  msg, const std::string &  prefix = "", const hit::Node *  node = nullptr, const bool  show_trace = true  )

private

Main callback for emitting a moose error.

Parameters

msg	The error message
prefix	Optional prefix to add to every line of the error (for multiapp prefixes)
node	Optional HIT node to associate with the error, adding file path context
show_trace	Whether or not to show a stack trace, defaults to true

Definition at line 51 of file MooseError.C.

{
  if (Moose::_throw_on_error)
    throw MooseRuntimeError(msg, node);
 
  // Atomic that will be set as soon as any thread hits this method
  static std::atomic_flag aborting = ATOMIC_FLAG_INIT;
 
  // Per-thread bool that will avoid us getting stuck in pause() if one
  // thread hits this method twice.
  thread_local static bool this_thread_aborting = false;
 
  // This branch will be hit after another thread has already set the atomic.
  // MPI_Abort, despite its name, does not behave like std::abort but instead
  // calls exit handlers and destroys statics. So we don't want to touch
  // anything static at this point. We'll just wait until the winning thread
  // has incurred program exit
  if (aborting.test_and_set(std::memory_order_acq_rel) && !this_thread_aborting)
  {
    // Waiting for the other thread(s), not burning CPU
    for (;;)
      pause();
  }
  // We're the first thread to hit this method (we set the atomic), so we're
  // responsible for dumping the error and trace(s) while the remaining
  // threads wait for us to exit (via libmesh_abort())
  else
  {
    // No, really, terminate. libmesh_abort() may throw an
    // exception, and if we catch that exception (or a bad_alloc, or
    // anything thrown) and mooseError because we didn't understand
    // it, we just want to continue up the stack.
    if (this_thread_aborting)
      libMesh::libmesh_abort();
 
    this_thread_aborting = true;
 
    // Output the message if there is one, but flush it without the trace
    // as trace retrieval can be slow in some circumstances and we want to
    // get the error message out ASAP
    if (!msg.empty())
    {
      // If we have a node available, add in the hit context (file location)
      if (node)
        msg = Moose::hitMessagePrefix(*node) + msg;
 
      msg = mooseMsgFmt(msg, "*** ERROR ***", COLOR_RED) + "\n";
      if (!prefix.empty()) // multiapp prefix
        MooseUtils::indentMessage(prefix, msg);
 
      {
        Threads::spin_mutex::scoped_lock lock(moose_stream_lock);
        Moose::err << msg << std::flush;
      }
    }
 
    // Print the trace if enabled and on a single rank
    if (show_trace && libMesh::global_n_processors() == 1)
    {
      std::ostringstream oss;
      libMesh::print_trace(oss);
      auto trace = oss.str();
      if (!prefix.empty()) // multiapp prefix
        MooseUtils::indentMessage(prefix, trace);
 
      {
        Threads::spin_mutex::scoped_lock lock(moose_stream_lock);
        Moose::err << trace << std::flush;
      }
    }
 
    // In parallel with libMesh configured with --enable-tracefiles, this will
    // dump a trace for each rank to file
    if (libMesh::global_n_processors() > 1)
      libMesh::write_traceout();
 
    libMesh::libmesh_abort();
  }
}

Referenced by MooseBase::callMooseError(), mooseDocumentedError(), and mooseError().

mooseInfoStream()

template<typename S , typename... Args>

void moose::internal::mooseInfoStream ( S &  oss, Args &&...  args  )

private

Definition at line 245 of file MooseError.h.

{
  mooseDoOnce(mooseInfoStreamRepeated(oss, args...););
}

Referenced by mooseInfo(), and MooseBase::mooseInfo().

mooseInfoStreamRepeated()

template<typename S , typename... Args>

void moose::internal::mooseInfoStreamRepeated ( S &  oss, Args &&...  args  )

private

Definition at line 232 of file MooseError.h.

{
  std::ostringstream ss;
  mooseStreamAll(ss, args...);
  std::string msg = mooseMsgFmt(ss.str(), "*** Info ***", COLOR_CYAN);
  {
    libMesh::Threads::spin_mutex::scoped_lock lock(moose_stream_lock);
    oss << msg << std::flush;
  }
}

Referenced by mooseInfoRepeated(), and mooseInfoStream().

mooseMsgFmt() [1/2]

std::string moose::internal::mooseMsgFmt ( const std::string &  msg, const std::string &  color  )

private

Format a message for output without a title.

Parameters

msg	The message to print
color	The color to print the message in

Returns

The formatted message

Definition at line 43 of file MooseError.C.

{
  std::ostringstream oss;
  oss << "\n" << color << "\n" << msg << COLOR_DEFAULT << "\n";
  return oss.str();
}

mooseMsgFmt() [2/2]

std::string moose::internal::mooseMsgFmt ( const std::string &  msg, const std::string &  title, const std::string &  color  )

private

Format a message for output with a title.

Parameters

msg	The message to print
title	The title that will go on a line before the message
color	The color to print the message in

Returns

The formatted message

Definition at line 35 of file MooseError.C.

{
  std::ostringstream oss;
  oss << "\n" << color << "\n" << title << "\n" << msg << COLOR_DEFAULT << "\n";
  return oss.str();
}

Referenced by mooseDeprecatedStream(), mooseErrorRaw(), mooseInfoStreamRepeated(), mooseUnusedStream(), and mooseWarningStream().

mooseStreamAll() [1/2]

void moose::internal::mooseStreamAll ( std::ostringstream &  ss )

private

All of the following are not meant to be called directly - they are called by the normal macros (mooseError(), etc.) down below.

Definition at line 135 of file MooseError.C.

{
}

Referenced by mooseDeprecatedStream(), mooseDocumentedError(), mooseError(), InputParameters::mooseError(), mooseInfoStreamRepeated(), mooseStreamAll(), mooseUnusedStream(), mooseWarningStream(), InputParameters::paramError(), and InputParameters::paramMessage().

mooseStreamAll() [2/2]

template<typename T , typename... Args>

void moose::internal::mooseStreamAll ( std::ostringstream &  ss, T &&  val, Args &&...  args  )

private

Definition at line 189 of file MooseError.h.

{
  ss << val;
  mooseStreamAll(ss, std::forward<Args>(args)...);
}

mooseUnusedStream()

template<typename S , typename... Args>

void moose::internal::mooseUnusedStream ( S &  oss, Args &&...  args  )

private

Definition at line 216 of file MooseError.h.

{
  std::ostringstream ss;
  mooseStreamAll(ss, args...);
  std::string msg = mooseMsgFmt(ss.str(), "*** Warning ***", COLOR_YELLOW);
  if (Moose::_throw_on_warning)
    throw std::runtime_error(msg);
 
  {
    libMesh::Threads::spin_mutex::scoped_lock lock(moose_stream_lock);
    oss << msg << std::flush;
  }
}

Referenced by mooseUnused().

mooseWarningStream()

template<typename S , typename... Args>

void moose::internal::mooseWarningStream ( S &  oss, Args &&...  args  )

private

Definition at line 197 of file MooseError.h.

{
  if (Moose::_warnings_are_errors)
    mooseError(std::forward<Args>(args)...);
 
  std::ostringstream ss;
  mooseStreamAll(ss, args...);
  std::string msg = mooseMsgFmt(ss.str(), "*** Warning ***", COLOR_YELLOW);
  if (Moose::_throw_on_warning)
    throw std::runtime_error(msg);
 
  {
    libMesh::Threads::spin_mutex::scoped_lock lock(moose_stream_lock);
    oss << msg << std::flush;
  }
}

Referenced by mooseWarning(), MooseBase::mooseWarning(), and MooseBase::mooseWarningNonPrefixed().

operator<<()

std::ostream & moose::internal::operator<<	(	std::ostream &	os,
		const SolutionInvalidityName &	name
	)

Definition at line 45 of file SolutionInvalidityRegistry.C.

{
  os << name.object_type << ": " << name.message;
  return os;
}

rawValueEqualityHelper() [1/3]

template<typename T1 , typename T2 , std::size_t N>

void moose::internal::rawValueEqualityHelper ( std::array< T1, N > &  out, const std::array< T2, N > &  in  )

protected

Definition at line 232 of file MaterialProperty.h.

{
  for (MooseIndex(in) i = 0; i < in.size(); ++i)
    rawValueEqualityHelper(out[i], in[i]);
}

rawValueEqualityHelper() [2/3]

template<typename T1 , typename T2 >

void moose::internal::rawValueEqualityHelper ( std::vector< T1 > &  out, const std::vector< T2 > &  in  )

protected

Definition at line 223 of file MaterialProperty.h.

{
  out.resize(in.size());
  for (MooseIndex(in) i = 0; i < in.size(); ++i)
    rawValueEqualityHelper(out[i], in[i]);
}

rawValueEqualityHelper() [3/3]

template<typename T1 , typename T2 >

void moose::internal::rawValueEqualityHelper ( T1 &  out, const T2 &  in  )

protected

Definition at line 216 of file MaterialProperty.h.

{
  out = MetaPhysicL::raw_value(in);
}

Referenced by MaterialPropertyBase< T, is_ad >::qpCopy(), rawValueEqualityHelper(), rawValueEqualityHelper(), and MaterialPropertyBase< T, is_ad >::swap().

Variable Documentation

moose_stream_lock

libMesh::Threads::spin_mutex moose::internal::moose_stream_lock

inlineprivate

Definition at line 140 of file MooseError.h.

Referenced by mooseDeprecatedStream(), mooseErrorRaw(), mooseInfoStreamRepeated(), mooseUnusedStream(), and mooseWarningStream().