Adaptivity.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 "libmesh/libmesh_config.h"
 
#ifdef LIBMESH_ENABLE_AMR
 
#include "Moose.h"
#include "MooseError.h"
#include "ConsoleStreamInterface.h"
#include "MooseTypes.h"
#include "PerfGraphInterface.h"
 
#include "libmesh/parallel_object.h"
 
// libMesh
#include "libmesh/mesh_refinement.h"
#include "libmesh/hp_coarsentest.h"
#include "libmesh/sibling_coupling.h"
 
class FEProblemBase;
class MooseMesh;
class DisplacedProblem;
template <typename>
class MooseVariableFE;
typedef MooseVariableFE<Real> MooseVariable;
typedef MooseVariableFE<libMesh::VectorValue<Real>> VectorMooseVariable;
class MooseEnum;
class MultiMooseEnum;
 
// Forward declare classes in libMesh
namespace libMesh
{
class SystemNorm;
class ErrorVector;
class ErrorEstimator;
}
 
enum class AdaptivityType
{
  H = 0,
  P = 1,
  HP = 2
};
 
class Adaptivity : public ConsoleStreamInterface,
                   public PerfGraphInterface,
                   public libMesh::ParallelObject
{
public:
  Adaptivity(FEProblemBase & fe_problem);
  virtual ~Adaptivity();
 
  void init(const unsigned int steps,
            const unsigned int initial_steps,
            const AdaptivityType adaptivity_type);
 
  template <typename T>
  void setParam(const std::string & param_name, const T & param_value);
 
  void setErrorEstimator(const MooseEnum & error_estimator_name);
 
  void setErrorNorm(libMesh::SystemNorm & sys_norm);
 
  void setPrintMeshChanged(bool state = true) { _print_mesh_changed = state; }
 
  unsigned int getInitialSteps() const { return _initial_steps; }
 
  unsigned int getSteps() const { return _steps; }
 
  unsigned int getCyclesPerStep() const { return _cycles_per_step; }
 
  void setCyclesPerStep(const unsigned int & num) { _cycles_per_step = num; }
 
  bool getRecomputeMarkersFlag() const { return _recompute_markers_during_cycles; }
 
  void setRecomputeMarkersFlag(const bool flag) { _recompute_markers_during_cycles = flag; }
 
  bool adaptMesh(std::string marker_name = std::string());
 
  bool initialAdaptMesh();
 
  static void uniformRefine(MooseMesh * mesh, unsigned int level = libMesh::invalid_uint);
 
  void uniformRefineWithProjection();
 
  void setAdaptivityOn(bool state);
 
  bool isOn() { return _mesh_refinement_on; }
 
  bool isInitialized() { return _initialized; }
 
  void setTimeActive(Real start_time, Real stop_time);
 
  void setAdaptivityControlFlag(const bool * adapt_control_flag);
 
  void setUseNewSystem();
 
  void setMarkerVariableName(std::string marker_field);
 
  void setInitialMarkerVariableName(std::string marker_field);
 
  void setMaxHLevel(unsigned int level) { _max_h_level = level; }
 
  unsigned int getMaxHLevel() { return _max_h_level; }
 
  void setInterval(unsigned int interval) { _interval = interval; }
 
  libMesh::ErrorVector & getErrorVector(const std::string & indicator_field);
 
  void updateErrorVectors();
 
  bool isAdaptivityDue();
 
protected:
  FEProblemBase & _fe_problem;
  MooseMesh & _mesh;
 
  bool _mesh_refinement_on;
  bool _initialized;
  std::unique_ptr<libMesh::MeshRefinement> _mesh_refinement;
  std::unique_ptr<libMesh::ErrorEstimator> _error_estimator;
  std::unique_ptr<libMesh::ErrorVector> _error;
 
  std::shared_ptr<DisplacedProblem> _displaced_problem;
 
  std::unique_ptr<libMesh::MeshRefinement> _displaced_mesh_refinement;
 
  unsigned int _initial_steps;
  unsigned int _steps;
 
  bool _print_mesh_changed;
 
  Real & _t;
  int & _step;
  unsigned int _interval;
  Real _start_time;
  Real _stop_time;
  const bool * _controls_allow_adaptivity;
  unsigned int _cycles_per_step;
 
  bool _use_new_system;
 
  std::string _marker_variable_name;
 
  AdaptivityType _adaptivity_type;
 
  std::string _initial_marker_variable_name;
 
  unsigned int _max_h_level;
 
  bool _recompute_markers_during_cycles;
 
  std::unique_ptr<libMesh::SiblingCoupling> _sibling_coupling;
 
  std::unique_ptr<libMesh::HPCoarsenTest> _hp_coarsen_test;
 
  std::map<std::string, std::unique_ptr<libMesh::ErrorVector>> _indicator_field_to_error_vector;
};
 
template <typename T>
void
Adaptivity::setParam(const std::string & param_name, const T & param_value)
{
  if (param_name == "refine fraction")
  {
    _mesh_refinement->refine_fraction() = param_value;
    if (_displaced_mesh_refinement)
      _displaced_mesh_refinement->refine_fraction() = param_value;
  }
  else if (param_name == "coarsen fraction")
  {
    _mesh_refinement->coarsen_fraction() = param_value;
    if (_displaced_mesh_refinement)
      _displaced_mesh_refinement->coarsen_fraction() = param_value;
  }
  else if (param_name == "max h-level")
  {
    _mesh_refinement->max_h_level() = param_value;
    if (_displaced_mesh_refinement)
      _displaced_mesh_refinement->max_h_level() = param_value;
  }
  else if (param_name == "cycles_per_step")
    _cycles_per_step = param_value;
  else if (param_name == "recompute_markers_during_cycles")
    _recompute_markers_during_cycles = param_value;
  else
    mooseError("Invalid Param in adaptivity object");
}
#endif // LIBMESH_ENABLE_AMR