Moose.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

#include "libMeshReducedNamespace.h"
#include "libmesh/perf_log.h"
#include "libmesh/libmesh_common.h"
#include "XTermConstants.h"

#include <memory>
#include <set>
#include <string>

#define QUOTE(macro) stringifyName(macro)
#define stringifyName(name) #name

namespace libMesh
{
template <typename>
class NumericVector;
template <typename>
class SparseMatrix;

// This was deprecated in libMesh a year ago!  It was obsolete 5 years
// ago!  How are 6 apps in CI still using it!?
#ifdef LIBMESH_ENABLE_DEPRECATED
template <typename T>
using UniquePtr = std::unique_ptr<T>;
#endif
}

class ActionFactory;
class Factory;
class MooseEnumItem;
class ExecFlagEnum;
class MooseVariableFieldBase;

namespace hit
{
class Node;
}

void MooseVecView(libMesh::NumericVector<libMesh::Number> & vector);
void MooseVecView(const libMesh::NumericVector<libMesh::Number> & vector);
void MooseMatView(libMesh::SparseMatrix<libMesh::Number> & mat);
void MooseMatView(const libMesh::SparseMatrix<libMesh::Number> & mat);

namespace Moose
{
static_assert(__cplusplus >= 201703L,
              "MOOSE requires a C++17 compatible compiler (GCC >= 7.5.0, Clang >= 5.0.2). Please "
              "update your compiler or, if compatible, add '-std=c++17' to your compiler flags "
              "and try again. If using the MOOSE conda package, please attempt a MOOSE environment "
              "update (using `mamba update moose-dev`). If this update is not successful, please "
              "create a new MOOSE environment (see "
              "https://mooseframework.inl.gov/getting_started/installation/"
              "conda.html#uninstall-conda-moose-environment).");
}

#define parallel_if                                                                                \
  (cond) bool __local_bool__ = (cond);                                                             \
  Parallel::max<bool>(__local_bool__);                                                             \
  if (__local_bool__)

#ifdef __bg__ // On Blue Gene Architectures there is no underscore
#define FORTRAN_CALL(name) name
#else // One underscore everywhere else
#define FORTRAN_CALL(name) name##_
#endif

template <class M, class... Args>
std::pair<typename M::iterator, bool>
moose_try_emplace(M & m, const typename M::key_type & k, Args &&... args)
{
  auto it = m.lower_bound(k);
  if (it == m.end() || m.key_comp()(k, it->first))
  {
    return {m.emplace_hint(it,
                           std::piecewise_construct,
                           std::forward_as_tuple(k),
                           std::forward_as_tuple(std::forward<Args>(args)...)),
            true};
  }
  return {it, false};
}

// forward declarations
class Syntax;
class FEProblemBase;

// Define MOOSE execution flags, this cannot be done in MooseTypes because the registration calls
// must be in Moose.C to remain consistent with other registration calls.
using ExecFlagType = MooseEnumItem;
extern const ExecFlagType EXEC_NONE;
extern const ExecFlagType EXEC_INITIAL;
extern const ExecFlagType EXEC_LINEAR_CONVERGENCE;
extern const ExecFlagType EXEC_LINEAR;
extern const ExecFlagType EXEC_NONLINEAR_CONVERGENCE;
extern const ExecFlagType EXEC_NONLINEAR;
extern const ExecFlagType EXEC_POSTCHECK;
extern const ExecFlagType EXEC_TIMESTEP_END;
extern const ExecFlagType EXEC_TIMESTEP_BEGIN;
extern const ExecFlagType EXEC_MULTIAPP_FIXED_POINT_ITERATION_END;
extern const ExecFlagType EXEC_MULTIAPP_FIXED_POINT_BEGIN;
extern const ExecFlagType EXEC_MULTIAPP_FIXED_POINT_END;
extern const ExecFlagType EXEC_MULTIAPP_FIXED_POINT_CONVERGENCE;
extern const ExecFlagType EXEC_FINAL;
extern const ExecFlagType EXEC_FORCED;
extern const ExecFlagType EXEC_FAILED;
extern const ExecFlagType EXEC_CUSTOM;
extern const ExecFlagType EXEC_SUBDOMAIN;
extern const ExecFlagType EXEC_PRE_DISPLACE;
extern const ExecFlagType EXEC_SAME_AS_MULTIAPP;
extern const ExecFlagType EXEC_PRE_MULTIAPP_SETUP;
extern const ExecFlagType EXEC_TRANSFER;
extern const ExecFlagType EXEC_PRE_KERNELS;
extern const ExecFlagType EXEC_ALWAYS;
#ifdef LIBMESH_ENABLE_AMR
extern const ExecFlagType EXEC_POST_ADAPTIVITY;
#endif

namespace Moose
{
// MOOSE is not tested with LIBMESH_DIM != 3
static_assert(LIBMESH_DIM == 3,
              "MOOSE must be built with a libmesh library compiled without --enable-1D-only "
              "or --enable-2D-only");

static constexpr std::size_t dim = LIBMESH_DIM;

extern int interrupt_signal_number;

extern bool show_trace;

extern bool show_multiple;

extern libMesh::PerfLog perf_log;

extern bool _trap_fpe;

extern bool _warnings_are_errors;

extern bool _deprecated_is_error;

extern bool _throw_on_error;

extern bool _throw_on_warning;

extern ExecFlagEnum execute_flags;

#define COLOR_BLACK (Moose::colorConsole() ? XTERM_BLACK : "")
#define COLOR_RED (Moose::colorConsole() ? XTERM_RED : "")
#define COLOR_GREEN (Moose::colorConsole() ? XTERM_GREEN : "")
#define COLOR_YELLOW (Moose::colorConsole() ? XTERM_YELLOW : "")
#define COLOR_BLUE (Moose::colorConsole() ? XTERM_BLUE : "")
#define COLOR_MAGENTA (Moose::colorConsole() ? XTERM_MAGENTA : "")
#define COLOR_CYAN (Moose::colorConsole() ? XTERM_CYAN : "")
#define COLOR_WHITE (Moose::colorConsole() ? XTERM_WHITE : "")
#define COLOR_DEFAULT (Moose::colorConsole() ? XTERM_DEFAULT : "")

bool colorConsole();

bool setColorConsole(bool use_color, bool force = false);

using libMesh::err;
using libMesh::out;

void registerAll(Factory & f, ActionFactory & af, Syntax & s);

void registerObjects(Factory & factory, const std::set<std::string> & obj_labels);
void addActionTypes(Syntax & syntax);
void registerActions(Syntax & syntax, ActionFactory & action_factory);
void registerActions(Syntax & syntax,
                     ActionFactory & action_factory,
                     const std::set<std::string> & obj_labels);

void associateSyntax(Syntax & syntax, ActionFactory & action_factory);

void setSolverDefaults(FEProblemBase & problem);

MPI_Comm swapLibMeshComm(MPI_Comm new_comm);

class ScopedCommSwapper
{
public:
  ScopedCommSwapper(MPI_Comm new_comm) : _orig(swapLibMeshComm(new_comm)) {}
  virtual ~ScopedCommSwapper() { swapLibMeshComm(_orig); }
  void forceSwap() { _orig = swapLibMeshComm(_orig); }

private:
  MPI_Comm _orig;
};

class ScopedThrowOnError
{
public:
  ScopedThrowOnError();

  ScopedThrowOnError(const bool throw_on_error);

  ~ScopedThrowOnError();

private:
  const bool _throw_on_error_before;
};

std::string hitMessagePrefix(const hit::Node & node);

// MOOSE Requires PETSc to run, this CPP check will cause a compile error if PETSc is not found
#ifndef LIBMESH_HAVE_PETSC
#error PETSc has not been detected, please ensure your environment is set up properly then rerun the libmesh build script and try to compile MOOSE again.
#endif

} // namespace Moose

// If we are using MFEM, in addition to the checks we do as part of the build system in moose.mk,
// we check at compile time if both MOOSE and MFEM were built in dbg mode or not
#ifdef MOOSE_MFEM_ENABLED
#include "libmesh/ignore_warnings.h"
#include <mfem.hpp>
#include "libmesh/restore_warnings.h"
#ifdef MFEM_DEBUG
static_assert(std::string_view(QUOTE(METHOD)) == "dbg",
              "MFEM was built in dbg mode, but not MOOSE. Try reinstalling "
              "MFEM using the scripts/update_and_rebuild_mfem.sh script.");
#else
static_assert(std::string_view(QUOTE(METHOD)) != "dbg",
              "MOOSE was built in dbg mode, but not MFEM. Try reinstalling "
              "MFEM using the scripts/update_and_rebuild_mfem.sh script.");
#endif
#endif