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

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

#include <set>
#include <string>

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

using namespace libMesh;

class ActionFactory;
class Factory;
class MooseEnumItem;
class ExecFlagEnum;
class MooseVariableFEBase;

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

#ifndef LIBMESH_HAVE_CXX11
#error MOOSE requires a C++11 compatible compiler (GCC >= 4.8.4, Clang >= 3.4.0, Intel >= 20130607). Please update your compiler and try again.
#endif

#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;
extern const ExecFlagType EXEC_NONLINEAR;
extern const ExecFlagType EXEC_TIMESTEP_END;
extern const ExecFlagType EXEC_TIMESTEP_BEGIN;
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;

namespace Moose
{

extern PerfLog perf_log;

extern bool _trap_fpe;

extern bool _warnings_are_errors;

extern bool _deprecated_is_error;

extern bool _throw_on_error;

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);
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 registerExecFlags(Factory & factory);

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

// 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