Adaptivity Class Reference

Takes care of everything related to mesh adaptivity. More...

#include <Adaptivity.h>

Inheritance diagram for Adaptivity:

Public Member Functions
	Adaptivity (FEProblemBase &fe_problem)
virtual	~Adaptivity ()
void	init (const unsigned int steps, const unsigned int initial_steps, const AdaptivityType adaptivity_type)
	Initialize and turn on adaptivity for the simulation.
template<typename T >
void	setParam (const std::string &param_name, const T &param_value)
	Set adaptivity parameter.
void	setErrorEstimator (const MooseEnum &error_estimator_name)
	Set the error estimator.
void	setErrorNorm (libMesh::SystemNorm &sys_norm)
	Set the error norm (FIXME: improve description)
void	setPrintMeshChanged (bool state=true)
unsigned int	getInitialSteps () const
	Pull out the number of initial steps previously set by calling init()
unsigned int	getSteps () const
	Pull out the number of steps previously set by calling init()
unsigned int	getCyclesPerStep () const
	Pull out the number of cycles_per_step previously set through the AdaptivityAction.
void	setCyclesPerStep (const unsigned int &num)
	Set the number of cycles_per_step.
bool	getRecomputeMarkersFlag () const
	Pull out the _recompute_markers_during_cycles flag previously set through the AdaptivityAction.
void	setRecomputeMarkersFlag (const bool flag)
	Set the flag to recompute markers during adaptivity cycles.
bool	adaptMesh (std::string marker_name=std::string())
	Adapts the mesh based on the error estimator used.
bool	initialAdaptMesh ()
	Used during initial adaptivity.
void	uniformRefineWithProjection ()
	Performs uniform refinement on the meshes in the current object.
void	setAdaptivityOn (bool state)
	Allow adaptivity to be toggled programatically.
bool	isOn ()
	Is adaptivity on?
bool	isInitialized ()
	Returns whether or not Adaptivity::init() has ran.
void	setTimeActive (Real start_time, Real stop_time)
	Sets the time when the adaptivity is active.
void	setUseNewSystem ()
	Tells this object we're using the "new" adaptivity system.
void	setMarkerVariableName (std::string marker_field)
	Sets the name of the field variable to actually use to flag elements for refinement / coarsening.
void	setInitialMarkerVariableName (std::string marker_field)
	Sets the name of the field variable to actually use to flag elements for initial refinement / coarsening.
void	setMaxHLevel (unsigned int level)
	Set the maximum refinement level (for the new Adaptivity system).
unsigned int	getMaxHLevel ()
	Return the maximum h-level.
void	setInterval (unsigned int interval)
	Set the interval (number of timesteps) between refinement steps.
libMesh::ErrorVector &	getErrorVector (const std::string &indicator_field)
	Get an ErrorVector that will be filled up with values corresponding to the indicator field name passed in.
void	updateErrorVectors ()
	Update the ErrorVectors that have been requested through calls to getErrorVector().
bool	isAdaptivityDue ()
	Query if an adaptivity step should be performed at the current time / time step.
PerfGraph &	perfGraph ()
	Get the PerfGraph.
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const

Static Public Member Functions
static void	uniformRefine (MooseMesh *mesh, unsigned int level=libMesh::invalid_uint)
	Performs uniform refinement of the passed Mesh object.
static InputParameters	validParams ()

Public Attributes
const ConsoleStream	_console
	An instance of helper class to write streams to the Console objects.

Protected Member Functions
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const
	Call to register a named section for timing.
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
	Call to register a named section for timing.
std::string	timedSectionName (const std::string &section_name) const

Protected Attributes
FEProblemBase &	_fe_problem
MooseMesh &	_mesh
bool	_mesh_refinement_on
	on/off flag reporting if the adaptivity is being used
bool	_initialized
	on/off flag reporting if the adaptivity system has been initialized
std::unique_ptr< libMesh::MeshRefinement >	_mesh_refinement
	A mesh refinement object to be used either with initial refinement or with Adaptivity.
std::unique_ptr< libMesh::ErrorEstimator >	_error_estimator
	Error estimator to be used by the apps.
std::unique_ptr< libMesh::ErrorVector >	_error
	Error vector for use with the error estimator.
std::shared_ptr< DisplacedProblem >	_displaced_problem
std::unique_ptr< libMesh::MeshRefinement >	_displaced_mesh_refinement
	A mesh refinement object for displaced mesh.
unsigned int	_initial_steps
	the number of adaptivity steps to do at the beginning of simulation
unsigned int	_steps
	steps of adaptivity to perform
bool	_print_mesh_changed
	True if we want to print out info when mesh has changed.
Real &	_t
	Time.
int &	_step
	Time Step.
unsigned int	_interval
	intreval between adaptivity runs
Real	_start_time
	When adaptivity start.
Real	_stop_time
	When adaptivity stops.
unsigned int	_cycles_per_step
	The number of adaptivity cycles per step.
bool	_use_new_system
	Whether or not to use the "new" adaptivity system.
std::string	_marker_variable_name
	Name of the marker variable if using the new adaptivity system.
AdaptivityType	_adaptivity_type
	Type of mesh adaptivity.
std::string	_initial_marker_variable_name
	Name of the initial marker variable if using the new adaptivity system.
unsigned int	_max_h_level
	The maximum number of refinement levels.
bool	_recompute_markers_during_cycles
	Whether or not to recompute markers during adaptivity cycles.
std::unique_ptr< libMesh::SiblingCoupling >	_sibling_coupling
	Sibling coupling object for HP adaptivity for evaluating data on elements' siblings in HPCoarsenTest.
std::unique_ptr< libMesh::HPCoarsenTest >	_hp_coarsen_test
	Object for HP adaptivity.
std::map< std::string, std::unique_ptr< libMesh::ErrorVector > >	_indicator_field_to_error_vector
	Stores pointers to ErrorVectors associated with indicator field names.
MooseApp &	_pg_moose_app
	The MooseApp that owns the PerfGraph.
const std::string	_prefix
	A prefix to use for all sections.
const Parallel::Communicator &	_communicator

Detailed Description

Takes care of everything related to mesh adaptivity.

Definition at line 61 of file Adaptivity.h.

Constructor & Destructor Documentation

Adaptivity()

Adaptivity::Adaptivity

(

FEProblemBase &

fe_problem

)

Definition at line 33 of file Adaptivity.C.

  : ConsoleStreamInterface(fe_problem.getMooseApp()),
    PerfGraphInterface(fe_problem.getMooseApp().perfGraph(), "Adaptivity"),
    ParallelObject(fe_problem.getMooseApp()),
    _fe_problem(fe_problem),
    _mesh(_fe_problem.mesh()),
    _mesh_refinement_on(false),
    _initialized(false),
    _initial_steps(0),
    _steps(0),
    _print_mesh_changed(false),
    _t(_fe_problem.time()),
    _step(_fe_problem.timeStep()),
    _interval(1),
    _start_time(-std::numeric_limits<Real>::max()),
    _stop_time(std::numeric_limits<Real>::max()),
    _cycles_per_step(1),
    _use_new_system(false),
    _adaptivity_type(AdaptivityType::H),
    _max_h_level(0),
    _recompute_markers_during_cycles(false)
{
}

~Adaptivity()

Adaptivity::~Adaptivity ( )

virtual

Definition at line 57 of file Adaptivity.C.

{}

Member Function Documentation

adaptMesh()

bool Adaptivity::adaptMesh

(

std::string

marker_name = std::string()

)

Adapts the mesh based on the error estimator used.

This method calls DisplacedProblem::undisplaceMesh, so it is necessary to update the displaced problem's mesh (undoing the undisplacement) before any objects relying on the displaced mesh are executed. However, projection of the displacement variables is required before doing so; therefore, the DisplacedProblem::updateMesh call needs to happen outside of this method.

See also

FEProblemBase::adaptMesh and FEProblemMase::meshChangedHelper.

Returns

a boolean that indicates whether the mesh was changed

Definition at line 145 of file Adaptivity.C.

{
  TIME_SECTION("adaptMesh", 3, "Adapting Mesh");
 
  // If the marker name is supplied, use it. Otherwise, use the one in _marker_variable_name
  if (marker_name.empty())
    marker_name = _marker_variable_name;
 
  bool mesh_changed = false;
 
  // If mesh adaptivity is carried out in a distributed (scalable) way
  bool distributed_adaptivity = false;
 
  if (_use_new_system)
  {
    if (!marker_name.empty()) // Only flag if a marker variable name has been set
    {
      _mesh_refinement->clean_refinement_flags();
 
      std::vector<Number> serialized_solution;
 
      auto distributed_mesh = dynamic_cast<DistributedMesh *>(&_fe_problem.mesh().getMesh());
 
      // Element range
      std::unique_ptr<ConstElemRange> all_elems;
      // If the mesh is distributed and we do not do "gather to zero" or "allgather".
      // Then it is safe to not serialize solution.
      // Some output idiom (Exodus) will do "gather to zero". That being said,
      // if you have exodus output on, mesh adaptivty is not scalable.
      if (distributed_mesh && !distributed_mesh->is_serial_on_zero())
      {
        // We update here to make sure local solution is up-to-date
        _fe_problem.getAuxiliarySystem().update();
        distributed_adaptivity = true;
 
        // We can not assume that geometric and algebraic ghosting functors cover
        // the same set of elements/nodes. That being said, in general,
        // we would expect G(e) > A(e). Here G(e) is the set of elements reserved
        // by the geometric ghosting functors, and A(e) corresponds to
        // the one covered by the algebraic ghosting functors.
        // Therefore, we have to work only on local elements instead of
        // ghosted + local elements. The ghosted solution might not be enough
        // for ghosted+local elements. But it is always sufficient for local elements.
        // After we set markers for all local elements, we will do a global
        // communication to sync markers for ghosted elements from their owners.
        all_elems = std::make_unique<ConstElemRange>(
            _fe_problem.mesh().getMesh().active_local_elements_begin(),
            _fe_problem.mesh().getMesh().active_local_elements_end());
      }
      else // This is not scalable but it might be useful for small-size problems
      {
        _fe_problem.getAuxiliarySystem().solution().close();
        _fe_problem.getAuxiliarySystem().solution().localize(serialized_solution);
        distributed_adaptivity = false;
 
        // For a replicated mesh or a serialized distributed mesh, the solution
        // is serialized to everyone. Then we update markers for all active elements.
        // In this case, we can avoid a global communication to update mesh.
        // I do not know if it is a good idea, but it the old code behavior.
        // We might not care about much since a replicated mesh
        // or a serialized distributed mesh is not scalable anyway.
        all_elems =
            std::make_unique<ConstElemRange>(_fe_problem.mesh().getMesh().active_elements_begin(),
                                             _fe_problem.mesh().getMesh().active_elements_end());
      }
 
      FlagElementsThread fet(
          _fe_problem, serialized_solution, _max_h_level, marker_name, !distributed_adaptivity);
      Threads::parallel_reduce(*all_elems, fet);
      _fe_problem.getAuxiliarySystem().solution().close();
    }
  }
  else
  {
    if (_fe_problem.numSolverSystems() > 1)
      mooseError("The old adaptivity system based on libMesh error estimators does not currently "
                 "support multiple solver systems because we currently only use the zeroth solver "
                 "system solution for estimating errors");
 
    // Compute the error for each active element
    _error_estimator->estimate_error(_fe_problem.getSolverSystem(/*nl_sys=*/0).system(), *_error);
 
    // Flag elements to be refined and coarsened
    _mesh_refinement->flag_elements_by_error_fraction(*_error);
  }
 
  // Moving some of h flagged elements to p flagged based on the
  // local smoothness and prior h & p error estimates
  if (_adaptivity_type == AdaptivityType::HP)
  {
    _hp_coarsen_test = std::make_unique<HPCoarsenTest>();
    _hp_coarsen_test->select_refinement(_fe_problem.getSolverSystem(/*nl_sys=*/0).system());
  }
 
  // If the DisplacedProblem is active, undisplace the DisplacedMesh
  // in preparation for refinement.  We can't safely refine the
  // DisplacedMesh directly, since the Hilbert keys computed on the
  // inconsistenly-displaced Mesh are different on different
  // processors, leading to inconsistent Hilbert keys.  We must do
  // this before the undisplaced Mesh is refined, so that the
  // element and node numbering is still consistent.
  if (_displaced_problem)
    _displaced_problem->undisplaceMesh();
 
  // If markers are added to only local elements,
  // we sync them here.
  if (distributed_adaptivity)
    _mesh_refinement->make_flags_parallel_consistent();
 
  // Sync flags from the reference mesh
  if (_displaced_problem)
    for (auto * const displaced_elem :
         _displaced_problem->mesh().getMesh().active_element_ptr_range())
    {
      const auto * const reference_elem = _fe_problem.mesh().elemPtr(displaced_elem->id());
      displaced_elem->set_refinement_flag(reference_elem->refinement_flag());
      displaced_elem->set_p_refinement_flag(reference_elem->p_refinement_flag());
    }
 
  if (_adaptivity_type == AdaptivityType::P)
    _mesh_refinement->switch_h_to_p_refinement();
 
  // Perform refinement and coarsening
  mesh_changed = _mesh_refinement->refine_and_coarsen_elements();
 
  if (_displaced_problem && mesh_changed)
  {
    if (_adaptivity_type == AdaptivityType::P)
      _displaced_mesh_refinement->switch_h_to_p_refinement();
 
#ifndef NDEBUG
    bool displaced_mesh_changed =
#endif
        _displaced_mesh_refinement->refine_and_coarsen_elements();
 
    // Since the undisplaced mesh changed, the displaced mesh better have changed!
    mooseAssert(displaced_mesh_changed, "Undisplaced mesh changed, but displaced mesh did not!");
  }
 
  if (mesh_changed && _print_mesh_changed)
  {
    _console << "\nMesh Changed:\n";
    _mesh.printInfo();
    _console << std::flush;
  }
 
  return mesh_changed;
}

Referenced by FEProblemBase::adaptMesh(), and initialAdaptMesh().

getCyclesPerStep()

unsigned int Adaptivity::getCyclesPerStep ( ) const

inline

Pull out the number of cycles_per_step previously set through the AdaptivityAction.

Returns

the number of cycles per step

Definition at line 126 of file Adaptivity.h.

{ return _cycles_per_step; }

Referenced by FEProblemBase::adaptMesh().

getErrorVector()

ErrorVector & Adaptivity::getErrorVector

(

const std::string &

indicator_field

)

Get an ErrorVector that will be filled up with values corresponding to the indicator field name passed in.

Note that this returns a reference... and the return value should be stored as a reference!

Parameters

indicator_field

The name of the field to get an ErrorVector for.

Definition at line 390 of file Adaptivity.C.

{
  // Insert or retrieve error vector
  auto insert_pair = moose_try_emplace(
      _indicator_field_to_error_vector, indicator_field, std::make_unique<ErrorVector>());
  return *insert_pair.first->second;
}

Referenced by Marker::getErrorVector().

getInitialSteps()

unsigned int Adaptivity::getInitialSteps ( ) const

inline

Pull out the number of initial steps previously set by calling init()

Returns

the number of initial steps

Definition at line 112 of file Adaptivity.h.

{ return _initial_steps; }

Referenced by FEProblemBase::hasInitialAdaptivity(), and FEProblemBase::initialAdaptMesh().

getMaxHLevel()

unsigned int Adaptivity::getMaxHLevel ( )

inline

Return the maximum h-level.

Definition at line 243 of file Adaptivity.h.

{ return _max_h_level; }

getRecomputeMarkersFlag()

bool Adaptivity::getRecomputeMarkersFlag ( ) const

inline

Pull out the _recompute_markers_during_cycles flag previously set through the AdaptivityAction.

Returns

the flag to recompute markers during adaptivity cycles

Definition at line 139 of file Adaptivity.h.

{ return _recompute_markers_during_cycles; }

Referenced by FEProblemBase::adaptMesh().

getSteps()

unsigned int Adaptivity::getSteps ( ) const

inline

Pull out the number of steps previously set by calling init()

Returns

the number of steps

Definition at line 119 of file Adaptivity.h.

{ return _steps; }

Referenced by Eigenvalue::execute(), and SteadyBase::execute().

init()

void Adaptivity::init	(	const unsigned int	steps,
		const unsigned int	initial_steps,
		const AdaptivityType	adaptivity_type
	)

Initialize and turn on adaptivity for the simulation.

initial_steps specifies the number of adaptivity cycles to perform before the simulation starts and steps indicates the number of adaptivity cycles to run during a steady (not transient) solve. steps is not used for transient or eigen solves. p_refinement indicates whether the refinement will be p-refinement or h-refinement.

Definition at line 60 of file Adaptivity.C.

{
  // Get the pointer to the DisplacedProblem, this cannot be done at construction because
  // DisplacedProblem
  // does not exist at that point.
  _displaced_problem = _fe_problem.getDisplacedProblem();
 
  _mesh_refinement = std::make_unique<MeshRefinement>(_mesh);
  _error = std::make_unique<ErrorVector>();
 
  EquationSystems & es = _fe_problem.es();
  es.parameters.set<bool>("adaptivity") = true;
 
  _initial_steps = initial_steps;
  _steps = steps;
 
  _adaptivity_type = adaptivity_type;
 
  _mesh_refinement_on = true;
 
  if (_adaptivity_type == AdaptivityType::P || _adaptivity_type == AdaptivityType::HP)
    _mesh.doingPRefinement(true);
 
  if (_adaptivity_type == AdaptivityType::HP)
  {
    if (_fe_problem.numSolverSystems() > 1)
      mooseError("HP adaptivity doesn't support multiple solver systems because currently only the "
                 "zeroth solver system solution is analyzed for determining whether to toggle "
                 "h-refinement flags to p-refinement flags");
 
    _sibling_coupling = std::make_unique<SiblingCoupling>();
    _fe_problem.getSolverSystem(0).system().get_dof_map().add_algebraic_ghosting_functor(
        *_sibling_coupling);
  }
 
  _mesh_refinement->set_periodic_boundaries_ptr(
      _fe_problem.getSolverSystem(/*nl_sys=*/0).dofMap().get_periodic_boundaries());
 
  if (_displaced_problem)
  {
    EquationSystems & displaced_es = _displaced_problem->es();
    displaced_es.parameters.set<bool>("adaptivity") = true;
 
    if (!_displaced_mesh_refinement)
      _displaced_mesh_refinement = std::make_unique<MeshRefinement>(_displaced_problem->mesh());
 
    // The periodic boundaries pointer allows the MeshRefinement
    // object to determine elements which are "topological" neighbors,
    // i.e. neighbors across periodic boundaries, for the purposes of
    // refinement.
    _displaced_mesh_refinement->set_periodic_boundaries_ptr(
        _fe_problem.getSolverSystem(/*nl_sys=*/0).dofMap().get_periodic_boundaries());
 
    // TODO: This is currently an empty function on the DisplacedProblem... could it be removed?
    _displaced_problem->initAdaptivity();
  }
 
  // indicate the Adaptivity system has been initialized
  _initialized = true;
}

Referenced by AdaptivityAction::act(), and SetAdaptivityOptionsAction::act().

initialAdaptMesh()

bool Adaptivity::initialAdaptMesh

(

)

Used during initial adaptivity.

Returns

a boolean that indicates whether the mesh was changed

Definition at line 295 of file Adaptivity.C.

{
  return adaptMesh(_initial_marker_variable_name);
}

Referenced by FEProblemBase::initialAdaptMesh().

isAdaptivityDue()

bool Adaptivity::isAdaptivityDue

(

)

Query if an adaptivity step should be performed at the current time / time step.

Definition at line 420 of file Adaptivity.C.

{
  return _mesh_refinement_on && (_start_time <= _t && _t < _stop_time) && _step % _interval == 0;
}

Referenced by FEProblemBase::adaptMesh().

isInitialized()

bool Adaptivity::isInitialized ( )

inline

Returns whether or not Adaptivity::init() has ran.

Can be used to indicate if mesh adaptivity is available.

Returns

true if the Adaptivity system is ready to be used, otherwise false

Definition at line 201 of file Adaptivity.h.

{ return _initialized; }

isOn()

bool Adaptivity::isOn ( )

inline

Is adaptivity on?

Returns

true if mesh adaptivity is on, otherwise false

Definition at line 193 of file Adaptivity.h.

{ return _mesh_refinement_on; }

Referenced by FEProblemBase::addAnyRedistributers(), and FEProblemBase::checkProblemIntegrity().

perfGraph()

PerfGraph & PerfGraphInterface::perfGraph ( )

inherited

Get the PerfGraph.

Definition at line 86 of file PerfGraphInterface.C.

{
  return _pg_moose_app.perfGraph();
}

Referenced by CommonOutputAction::act(), PerfGraphData::finalize(), PerfGraphReporter::finalize(), and PerfGraphOutput::output().

registerTimedSection() [1/2]

PerfID PerfGraphInterface::registerTimedSection ( const std::string &  section_name, const unsigned int  level  ) const

protectedinherited

Call to register a named section for timing.

Parameters

section_name	The name of the code section to be timed
level	The importance of the timer - lower is more important (0 will always come out)

Returns

The ID of the section - use when starting timing

Definition at line 61 of file PerfGraphInterface.C.

{
  const auto timed_section_name = timedSectionName(section_name);
  if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
    return moose::internal::getPerfGraphRegistry().registerSection(timed_section_name, level);
  else
    return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
}

registerTimedSection() [2/2]

PerfID PerfGraphInterface::registerTimedSection ( const std::string &  section_name, const unsigned int  level, const std::string &  live_message, const bool  print_dots = true  ) const

protectedinherited

Call to register a named section for timing.

Parameters

section_name	The name of the code section to be timed
level	The importance of the timer - lower is more important (0 will always come out)
live_message	The message to be printed to the screen during execution
print_dots	Whether or not progress dots should be printed for this section

Returns

The ID of the section - use when starting timing

Definition at line 72 of file PerfGraphInterface.C.

{
  const auto timed_section_name = timedSectionName(section_name);
  if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
    return moose::internal::getPerfGraphRegistry().registerSection(
        timedSectionName(section_name), level, live_message, print_dots);
  else
    return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
}

setAdaptivityOn()

void Adaptivity::setAdaptivityOn

(

bool

state

)

Allow adaptivity to be toggled programatically.

Parameters

state

The adaptivity state (on/off).

Definition at line 355 of file Adaptivity.C.

{
  // check if Adaptivity has been initialized before turning on
  if (state == true && !_initialized)
    mooseError("Mesh adaptivity system not available");
 
  _mesh_refinement_on = state;
}

setCyclesPerStep()

void Adaptivity::setCyclesPerStep ( const unsigned int &  num )

inline

Set the number of cycles_per_step.

Parameters

num	The number of cycles per step to execute

Definition at line 132 of file Adaptivity.h.

{ _cycles_per_step = num; }

Referenced by SetAdaptivityOptionsAction::act().

setErrorEstimator()

void Adaptivity::setErrorEstimator

(

const MooseEnum &

error_estimator_name

)

Set the error estimator.

Parameters

error_estimator_name

the name of the error estimator (currently: Laplacian, Kelly, and PatchRecovery)

Definition at line 124 of file Adaptivity.C.

{
  if (error_estimator_name == "KellyErrorEstimator")
    _error_estimator = std::make_unique<KellyErrorEstimator>();
  else if (error_estimator_name == "LaplacianErrorEstimator")
    _error_estimator = std::make_unique<LaplacianErrorEstimator>();
  else if (error_estimator_name == "PatchRecoveryErrorEstimator")
    _error_estimator = std::make_unique<PatchRecoveryErrorEstimator>();
  else
    mooseError(std::string("Unknown error_estimator selection: ") +
               std::string(error_estimator_name));
}

Referenced by AdaptivityAction::act().

setErrorNorm()

void Adaptivity::setErrorNorm

(

libMesh::SystemNorm &

sys_norm

)

Set the error norm (FIXME: improve description)

Definition at line 138 of file Adaptivity.C.

{
  mooseAssert(_error_estimator, "error_estimator not initialized. Did you call init_adaptivity()?");
  _error_estimator->error_norm = sys_norm;
}

Referenced by AdaptivityAction::act().

setInitialMarkerVariableName()

void Adaptivity::setInitialMarkerVariableName

(

std::string

marker_field

)

Sets the name of the field variable to actually use to flag elements for initial refinement / coarsening.

This must be a CONSTANT, MONOMIAL Auxiliary Variable Name that contains values corresponding to libMesh::Elem::RefinementState.

Parameters

marker_field

The name of the field to use for refinement / coarsening.

Definition at line 384 of file Adaptivity.C.

{
  _initial_marker_variable_name = marker_field;
}

Referenced by SetAdaptivityOptionsAction::act().

setInterval()

void Adaptivity::setInterval ( unsigned int  interval )

inline

Set the interval (number of timesteps) between refinement steps.

Definition at line 248 of file Adaptivity.h.

{ _interval = interval; }

Referenced by AdaptivityAction::act(), and SetAdaptivityOptionsAction::act().

setMarkerVariableName()

void Adaptivity::setMarkerVariableName

(

std::string

marker_field

)

Sets the name of the field variable to actually use to flag elements for refinement / coarsening.

This must be a CONSTANT, MONOMIAL Auxiliary Variable Name that contains values corresponding to libMesh::Elem::RefinementState.

Parameters

marker_field

The name of the field to use for refinement / coarsening.

Definition at line 378 of file Adaptivity.C.

{
  _marker_variable_name = marker_field;
}

Referenced by SetAdaptivityOptionsAction::act().

setMaxHLevel()

void Adaptivity::setMaxHLevel ( unsigned int  level )

inline

Set the maximum refinement level (for the new Adaptivity system).

Definition at line 238 of file Adaptivity.h.

{ _max_h_level = level; }

Referenced by SetAdaptivityOptionsAction::act().

setParam()

template<typename T >

void Adaptivity::setParam	(	const std::string &	param_name,
		const T &	param_value
	)

Set adaptivity parameter.

Parameters

param_name	the name of the parameter
param_value	the value of parameter

Definition at line 342 of file Adaptivity.h.

{
  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");
}

Referenced by AdaptivityAction::act().

setPrintMeshChanged()

void Adaptivity::setPrintMeshChanged ( bool  state = true )

inline

Definition at line 105 of file Adaptivity.h.

{ _print_mesh_changed = state; }

Referenced by AdaptivityAction::act().

setRecomputeMarkersFlag()

void Adaptivity::setRecomputeMarkersFlag ( const bool  flag )

inline

Set the flag to recompute markers during adaptivity cycles.

Parameters

flag	The flag to recompute markers

Definition at line 145 of file Adaptivity.h.

{ _recompute_markers_during_cycles = flag; }

Referenced by SetAdaptivityOptionsAction::act().

setTimeActive()

void Adaptivity::setTimeActive	(	Real	start_time,
		Real	stop_time
	)

Sets the time when the adaptivity is active.

Parameters

start_time	The time when adaptivity starts
stop_time	The time when adaptivity stops

Definition at line 365 of file Adaptivity.C.

{
  _start_time = start_time;
  _stop_time = stop_time;
}

Referenced by AdaptivityAction::act(), and SetAdaptivityOptionsAction::act().

setUseNewSystem()

void Adaptivity::setUseNewSystem

(

)

Tells this object we're using the "new" adaptivity system.

Definition at line 372 of file Adaptivity.C.

{
  _use_new_system = true;
}

Referenced by SetAdaptivityOptionsAction::act().

timedSectionName()

std::string PerfGraphInterface::timedSectionName ( const std::string &  section_name ) const

protectedinherited

Returns

The name of the timed section with the name section_name.

Optionally adds a prefix if one is defined.

Definition at line 55 of file PerfGraphInterface.C.

{
  return _prefix.empty() ? "" : (_prefix + "::") + section_name;
}

Referenced by PerfGraphInterface::registerTimedSection(), and PerfGraphInterface::registerTimedSection().

uniformRefine()

void Adaptivity::uniformRefine ( MooseMesh *  mesh, unsigned int  level = libMesh::invalid_uint  )

static

Performs uniform refinement of the passed Mesh object.

The number of levels of refinement performed is stored in the MooseMesh object. No solution projection is performed in this version.

Definition at line 301 of file Adaptivity.C.

{
  mooseAssert(mesh, "Mesh pointer must not be NULL");
 
  // NOTE: we are using a separate object here, since adaptivity may not be on, but we need to be
  // able to do refinements
  MeshRefinement mesh_refinement(*mesh);
  if (level == libMesh::invalid_uint)
    level = mesh->uniformRefineLevel();
 
  // Skip deletion and repartition will make uniform refinements run more
  // efficiently, but at the same time, there might be extra ghosting elements.
  // The number of layers of additional ghosting elements depends on the number
  // of uniform refinement levels. This should happen only when you have a "fine enough"
  // coarse mesh and want to refine the mesh by a few levels. Otherwise, it might
  // introduce an unbalanced workload and too large ghosting domain.
  if (mesh->skipDeletionRepartitionAfterRefine())
  {
    mesh->getMesh().skip_partitioning(true);
    mesh->getMesh().allow_remote_element_removal(false);
    mesh->needsRemoteElemDeletion(false);
  }
 
  mesh_refinement.uniformly_refine(level);
}

Referenced by SetupMeshCompleteAction::act(), and FEProblemBase::uniformRefine().

uniformRefineWithProjection()

void Adaptivity::uniformRefineWithProjection

(

)

Performs uniform refinement on the meshes in the current object.

Projections are performed of the solution vectors.

Definition at line 328 of file Adaptivity.C.

{
  TIME_SECTION("uniformRefineWithProjection", 2, "Uniformly Refining and Reprojecting");
 
  // NOTE: we are using a separate object here, since adaptivity may not be on, but we need to be
  // able to do refinements
  MeshRefinement mesh_refinement(_mesh);
  unsigned int level = _mesh.uniformRefineLevel();
  MeshRefinement displaced_mesh_refinement(_displaced_problem ? _displaced_problem->mesh() : _mesh);
 
  // we have to go step by step so EquationSystems::reinit() won't freak out
  for (unsigned int i = 0; i < level; i++)
  {
    // See comment above about why refining the displaced mesh is potentially unsafe.
    if (_displaced_problem)
      _displaced_problem->undisplaceMesh();
 
    mesh_refinement.uniformly_refine(1);
 
    if (_displaced_problem)
      displaced_mesh_refinement.uniformly_refine(1);
    _fe_problem.meshChanged(
        /*intermediate_step=*/false, /*contract_mesh=*/true, /*clean_refinement_flags=*/true);
  }
}

updateErrorVectors()

void Adaptivity::updateErrorVectors

(

)

Update the ErrorVectors that have been requested through calls to getErrorVector().

Definition at line 399 of file Adaptivity.C.

{
  TIME_SECTION("updateErrorVectors", 5, "Updating Error Vectors");
 
  // Resize all of the ErrorVectors in case the mesh has changed
  for (const auto & it : _indicator_field_to_error_vector)
  {
    ErrorVector & vec = *(it.second);
    vec.assign(_mesh.getMesh().max_elem_id(), 0);
  }
 
  // Fill the vectors with the local contributions
  UpdateErrorVectorsThread uevt(_fe_problem, _indicator_field_to_error_vector);
  Threads::parallel_reduce(*_mesh.getActiveLocalElementRange(), uevt);
 
  // Now sum across all processors
  for (const auto & it : _indicator_field_to_error_vector)
    _fe_problem.comm().sum((std::vector<float> &)*(it.second));
}

Referenced by FEProblemBase::computeMarkers().

validParams()

InputParameters PerfGraphInterface::validParams ( )

staticinherited

Definition at line 16 of file PerfGraphInterface.C.

{
  InputParameters params = emptyInputParameters();
  return params;
}

Referenced by Convergence::validParams().

Member Data Documentation

_adaptivity_type

AdaptivityType Adaptivity::_adaptivity_type

protected

Type of mesh adaptivity.

Definition at line 318 of file Adaptivity.h.

Referenced by adaptMesh(), and init().

_console

const ConsoleStream ConsoleStreamInterface::_console

inherited

An instance of helper class to write streams to the Console objects.

Definition at line 31 of file ConsoleStreamInterface.h.

Referenced by IterationAdaptiveDT::acceptStep(), MaterialOutputAction::act(), MeshOnlyAction::act(), SetupDebugAction::act(), FEProblemBase::adaptMesh(), adaptMesh(), PerfGraph::addToExecutionList(), SimplePredictor::apply(), SystemBase::applyScalingFactors(), MultiApp::backup(), FEProblemBase::backupMultiApps(), CoarsenedPiecewiseLinear::buildCoarsenedGrid(), DefaultSteadyStateConvergence::checkConvergence(), MeshDiagnosticsGenerator::checkElementOverlap(), MeshDiagnosticsGenerator::checkElementTypes(), MeshDiagnosticsGenerator::checkElementVolumes(), FEProblemBase::checkExceptionAndStopSolve(), SolverSystem::checkInvalidSolution(), MeshDiagnosticsGenerator::checkLocalJacobians(), MeshDiagnosticsGenerator::checkNonConformalMesh(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), MeshDiagnosticsGenerator::checkNonPlanarSides(), MeshDiagnosticsGenerator::checkPolygons(), FEProblemBase::checkProblemIntegrity(), ReferenceResidualConvergence::checkResidualConvergence(), MeshDiagnosticsGenerator::checkSidesetsOrientation(), MeshDiagnosticsGenerator::checkWatertightNodesets(), MeshDiagnosticsGenerator::checkWatertightSidesets(), IterationAdaptiveDT::computeAdaptiveDT(), TransientBase::computeConstrainedDT(), DefaultMultiAppFixedPointConvergence::computeCustomConvergencePostprocessor(), NonlinearSystemBase::computeDamping(), FixedPointIterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeFailedDT(), IterationAdaptiveDT::computeInitialDT(), IterationAdaptiveDT::computeInterpolationDT(), FEProblemBase::computeLinearSystemTags(), LinearSystem::computeLinearSystemTags(), NonlinearSystemBase::computeScaling(), Problem::console(), TimeStepper::constrainStep(), IterationAdaptiveDT::constrainStep(), MultiApp::createApp(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), Eigenvalue::execute(), SteadyBase::execute(), MFEMSteady::execute(), MessageFromInput::execute(), ActionWarehouse::executeActionsWithAction(), ActionWarehouse::executeAllActions(), MeshGeneratorSystem::executeMeshGenerators(), SidesetAroundSubdomainUpdater::finalize(), ElementQualityChecker::finalize(), FEProblemBase::finishMultiAppStep(), MeshRepairGenerator::fixOverlappingNodes(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), CoarsenBlockGenerator::generate(), OrientSurfaceMeshGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), MeshGenerator::generateInternal(), VariableCondensationPreconditioner::getDofToCondense(), InversePowerMethod::init(), NonlinearEigen::init(), FEProblemBase::initialAdaptMesh(), DefaultMultiAppFixedPointConvergence::initialize(), SubProblem::initialSetup(), EigenExecutionerBase::inversePowerIteration(), FEProblemBase::joinAndFinalize(), TransientBase::keepGoing(), IterationAdaptiveDT::limitDTByFunction(), IterationAdaptiveDT::limitDTToPostprocessorValue(), FEProblemBase::logAdd(), EigenExecutionerBase::makeBXConsistent(), Console::meshChanged(), SurfaceDelaunayGeneratorBase::meshNormalDeviation2D(), MooseBase::mooseDeprecated(), MooseBase::mooseDeprecatedNoTrace(), MooseBase::mooseInfo(), MooseBase::mooseWarning(), MooseBase::mooseWarningNonPrefixed(), ReferenceResidualConvergence::nonlinearConvergenceSetup(), Console::output(), DOFMapOutput::output(), MaterialPropertyDebugOutput::output(), PerfGraphOutput::output(), ReporterDebugOutput::output(), SolutionInvalidityOutput::output(), VariableResidualNormsDebugOutput::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Console::outputInput(), WebServerControl::outputMessage(), Console::outputPostprocessors(), PseudoTimestep::outputPseudoTimestep(), Console::outputReporters(), DefaultMultiAppFixedPointConvergence::outputResidualNorm(), Console::outputScalarVariables(), Console::outputSystemInformation(), FEProblemBase::possiblyRebuildGeomSearchPatches(), EigenExecutionerBase::postExecute(), AB2PredictorCorrector::postSolve(), ActionWarehouse::printActionDependencySets(), BlockRestrictionDebugOutput::printBlockRestrictionGroups(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), BlockRestrictionDebugOutput::printBoundaryRestrictionGroups(), SolutionInvalidity::printDebug(), EigenExecutionerBase::printEigenvalue(), PicardSolve::printFixedPointConvergenceHistory(), SecantSolve::printFixedPointConvergenceHistory(), SteffensenSolve::printFixedPointConvergenceHistory(), FixedPointSolve::printFixedPointConvergenceReason(), PerfGraphLivePrint::printLiveMessage(), MaterialPropertyDebugOutput::printMaterialMap(), PerfGraphLivePrint::printStats(), NEML2Action::printSummary(), AutomaticMortarGeneration::projectPrimaryNodesSinglePair(), AutomaticMortarGeneration::projectSecondaryNodesSinglePair(), CoarsenBlockGenerator::recursiveCoarsen(), SolutionTimeAdaptiveDT::rejectStep(), MultiApp::restore(), FEProblemBase::restoreMultiApps(), FEProblemBase::restoreSolutions(), NonlinearSystemBase::setInitialSolution(), MooseApp::setupOptions(), Checkpoint::shouldOutput(), SubProblem::showFunctorRequestors(), SubProblem::showFunctors(), FullSolveMultiApp::showStatusMessage(), FEProblemSolve::solve(), FixedPointSolve::solve(), LinearSystem::solve(), NonlinearSystem::solve(), AStableDirk4::solve(), ExplicitRK2::solve(), ExplicitTVDRK2::solve(), ImplicitMidpoint::solve(), LStableDirk2::solve(), LStableDirk3::solve(), LStableDirk4::solve(), EigenProblem::solve(), FixedPointSolve::solveStep(), TransientMultiApp::solveStep(), MeshRepairGenerator::splitNonConvexPolygons(), PerfGraphLivePrint::start(), WebServerControl::startServer(), AB2PredictorCorrector::step(), NonlinearEigen::takeStep(), TransientBase::takeStep(), MFEMTransient::takeStep(), TerminateChainControl::terminate(), SubProblem::timestepSetup(), FEProblemBase::updateMeshXFEM(), Convergence::verboseOutput(), Console::writeTimestepInformation(), Console::writeVariableNorms(), and FEProblemBase::~FEProblemBase().

_cycles_per_step

unsigned int Adaptivity::_cycles_per_step

protected

The number of adaptivity cycles per step.

Definition at line 309 of file Adaptivity.h.

Referenced by getCyclesPerStep(), setCyclesPerStep(), and setParam().

_displaced_mesh_refinement

std::unique_ptr<libMesh::MeshRefinement> Adaptivity::_displaced_mesh_refinement

protected

A mesh refinement object for displaced mesh.

Definition at line 288 of file Adaptivity.h.

Referenced by adaptMesh(), init(), and setParam().

_displaced_problem

std::shared_ptr<DisplacedProblem> Adaptivity::_displaced_problem

protected

Definition at line 285 of file Adaptivity.h.

Referenced by adaptMesh(), init(), and uniformRefineWithProjection().

_error

std::unique_ptr<libMesh::ErrorVector> Adaptivity::_error

protected

Error vector for use with the error estimator.

Definition at line 283 of file Adaptivity.h.

Referenced by adaptMesh(), and init().

_error_estimator

std::unique_ptr<libMesh::ErrorEstimator> Adaptivity::_error_estimator

protected

Error estimator to be used by the apps.

Definition at line 281 of file Adaptivity.h.

Referenced by adaptMesh(), setErrorEstimator(), and setErrorNorm().

_fe_problem

FEProblemBase& Adaptivity::_fe_problem

protected

Definition at line 271 of file Adaptivity.h.

Referenced by adaptMesh(), init(), uniformRefineWithProjection(), and updateErrorVectors().

_hp_coarsen_test

std::unique_ptr<libMesh::HPCoarsenTest> Adaptivity::_hp_coarsen_test

protected

Object for HP adaptivity.

Definition at line 334 of file Adaptivity.h.

Referenced by adaptMesh().

_indicator_field_to_error_vector

std::map<std::string, std::unique_ptr<libMesh::ErrorVector> > Adaptivity::_indicator_field_to_error_vector

protected

Stores pointers to ErrorVectors associated with indicator field names.

Definition at line 337 of file Adaptivity.h.

Referenced by getErrorVector(), and updateErrorVectors().

_initial_marker_variable_name

std::string Adaptivity::_initial_marker_variable_name

protected

Name of the initial marker variable if using the new adaptivity system.

Definition at line 321 of file Adaptivity.h.

Referenced by initialAdaptMesh(), and setInitialMarkerVariableName().

_initial_steps

unsigned int Adaptivity::_initial_steps

protected

the number of adaptivity steps to do at the beginning of simulation

Definition at line 291 of file Adaptivity.h.

Referenced by getInitialSteps(), and init().

_initialized

bool Adaptivity::_initialized

protected

on/off flag reporting if the adaptivity system has been initialized

Definition at line 277 of file Adaptivity.h.

Referenced by init(), isInitialized(), and setAdaptivityOn().

_interval

unsigned int Adaptivity::_interval

protected

intreval between adaptivity runs

Definition at line 303 of file Adaptivity.h.

Referenced by isAdaptivityDue(), and setInterval().

_marker_variable_name

std::string Adaptivity::_marker_variable_name

protected

Name of the marker variable if using the new adaptivity system.

Definition at line 315 of file Adaptivity.h.

Referenced by adaptMesh(), and setMarkerVariableName().

_max_h_level

unsigned int Adaptivity::_max_h_level

protected

The maximum number of refinement levels.

Definition at line 324 of file Adaptivity.h.

Referenced by adaptMesh(), getMaxHLevel(), and setMaxHLevel().

_mesh

MooseMesh& Adaptivity::_mesh

protected

Definition at line 272 of file Adaptivity.h.

Referenced by adaptMesh(), init(), uniformRefineWithProjection(), and updateErrorVectors().

_mesh_refinement

std::unique_ptr<libMesh::MeshRefinement> Adaptivity::_mesh_refinement

protected

A mesh refinement object to be used either with initial refinement or with Adaptivity.

Definition at line 279 of file Adaptivity.h.

Referenced by adaptMesh(), init(), and setParam().

_mesh_refinement_on

bool Adaptivity::_mesh_refinement_on

protected

on/off flag reporting if the adaptivity is being used

Definition at line 275 of file Adaptivity.h.

Referenced by init(), isAdaptivityDue(), isOn(), and setAdaptivityOn().

_pg_moose_app

MooseApp& PerfGraphInterface::_pg_moose_app

protectedinherited

The MooseApp that owns the PerfGraph.

Definition at line 135 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::perfGraph().

_prefix

const std::string PerfGraphInterface::_prefix

protectedinherited

A prefix to use for all sections.

Definition at line 138 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::timedSectionName().

_print_mesh_changed

bool Adaptivity::_print_mesh_changed

protected

True if we want to print out info when mesh has changed.

Definition at line 296 of file Adaptivity.h.

Referenced by adaptMesh(), and setPrintMeshChanged().

_recompute_markers_during_cycles

bool Adaptivity::_recompute_markers_during_cycles

protected

Whether or not to recompute markers during adaptivity cycles.

Definition at line 327 of file Adaptivity.h.

Referenced by getRecomputeMarkersFlag(), setParam(), and setRecomputeMarkersFlag().

_sibling_coupling

std::unique_ptr<libMesh::SiblingCoupling> Adaptivity::_sibling_coupling

protected

Sibling coupling object for HP adaptivity for evaluating data on elements' siblings in HPCoarsenTest.

Definition at line 331 of file Adaptivity.h.

Referenced by init().

_start_time

Real Adaptivity::_start_time

protected

When adaptivity start.

Definition at line 305 of file Adaptivity.h.

Referenced by isAdaptivityDue(), and setTimeActive().

_step

int& Adaptivity::_step

protected

Time Step.

Definition at line 301 of file Adaptivity.h.

Referenced by isAdaptivityDue().

_steps

unsigned int Adaptivity::_steps

protected

steps of adaptivity to perform

Definition at line 293 of file Adaptivity.h.

Referenced by getSteps(), and init().

_stop_time

Real Adaptivity::_stop_time

protected

When adaptivity stops.

Definition at line 307 of file Adaptivity.h.

Referenced by isAdaptivityDue(), and setTimeActive().

_t

Real& Adaptivity::_t

protected

Time.

Definition at line 299 of file Adaptivity.h.

Referenced by isAdaptivityDue().

_use_new_system

bool Adaptivity::_use_new_system

protected

Whether or not to use the "new" adaptivity system.

Definition at line 312 of file Adaptivity.h.

Referenced by adaptMesh(), and setUseNewSystem().

---

The documentation for this class was generated from the following files:

• include/base/Adaptivity.h
• src/base/Adaptivity.C