Adaptivity.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/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"

class FEProblemBase;
class MooseMesh;
class DisplacedProblem;
template <typename>
class MooseVariableFE;
typedef MooseVariableFE<Real> MooseVariable;
typedef MooseVariableFE<VectorValue<Real>> VectorMooseVariable;
class MooseEnum;
class MultiMooseEnum;

// Forward declare classes in libMesh
namespace libMesh
{
class SystemNorm;
class ErrorVector;
class ErrorEstimator;
}

class Adaptivity : public ConsoleStreamInterface,
                   public PerfGraphInterface,
                   public libMesh::ParallelObject
{
public:
  Adaptivity(FEProblemBase & fe_problem);
  virtual ~Adaptivity();

  void init(unsigned int steps, unsigned int initial_steps);

  template <typename T>
  void setParam(const std::string & param_name, const T & param_value);

  void setErrorEstimator(const MooseEnum & error_estimator_name);

  void setErrorNorm(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; }

  void doingPRefinement(bool doing_p_refinement,
                        const MultiMooseEnum & disable_p_refinement_for_families);

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

  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<MeshRefinement> _mesh_refinement;
  std::unique_ptr<ErrorEstimator> _error_estimator;
  std::unique_ptr<ErrorVector> _error;

  std::shared_ptr<DisplacedProblem> _displaced_problem;

  std::unique_ptr<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;
  unsigned int _cycles_per_step;

  bool _use_new_system;

  std::string _marker_variable_name;

  std::string _initial_marker_variable_name;

  unsigned int _max_h_level;

  bool _recompute_markers_during_cycles;

  std::map<std::string, std::unique_ptr<ErrorVector>> _indicator_field_to_error_vector;

  bool _p_refinement_flag = false;
};

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