Markers System

The marker system is a sub-system of the Adaptivity system in MOOSE. The Marker objects serve to set the refinement flag to one of four states as defined by the C++ Enum MarkerValue. MOOSE will call the computeElementMarker method, which returns a MarkerValue. This value is then applied to an elemental AuxVariable. The automatic mesh refinement engine will then use this field to refine and coarsen the mesh in a consistent manner, as detailed in the Adaptivity system.

Marker Values

The four possible MarkerValue states are defined in Marker.h as follows:

  enum MarkerValue
  {
    DONT_MARK = -1,
    COARSEN,
    DO_NOTHING,
    REFINE
  };

The purpose of each value of the MarkerValue is define in the following table.

State	Description
DONT_MARK	Do not apply any refinement flag to the element.
COARSEN	Marks an element to be coarsened, if possible.
DO_NOTHING	Does not change the marker flag from the current state.
REFINE	Marks and element to be refined, if possible.

Example Syntax

[Adaptivity]
  [./Markers]
    [./box]
      type = BoxMarker
      bottom_left = '0.3 0.3 0'
      top_right = '0.6 0.6 0'
      inside = refine
      outside = do_nothing
    [../]
    [./combo]
      type = ComboMarker
      markers = 'box box2'
    [../]
    [./box2]
      type = BoxMarker
      bottom_left = '0.5 0.5 0'
      top_right = '0.8 0.8 0'
      inside = refine
      outside = coarsen
    [../]
  [../]
[]

Available Objects

Moose App
ArrayMooseVariableUsed for grouping standard field variables with the same finite element family and order
BoundaryMarkerMarks all elements with sides on a given boundary for refinement/coarsening
BoundaryPreservedMarkerMarks elements for refinement or coarsening based on the provided marker value, while preserving the given boundary.
BoxMarkerMarks the region inside and outside of a 'box' domain for refinement or coarsening.
ComboMarkerA marker that converts many markers into a single marker by considering the maximum value of the listed markers (i.e., refinement takes precedent).
ErrorFractionMarkerMarks elements for refinement or coarsening based on the fraction of the min/max error from the supplied indicator.
ErrorToleranceMarkerCoarsen or refine elements based on an absolute tolerance allowed from the supplied indicator.
MooseLinearVariableFVRealBase class for Moose variables. This should never be the terminal object type
MooseVariableRepresents standard field variables, e.g. Lagrange, Hermite, or non-constant Monomials
MooseVariableBaseBase class for Moose variables. This should never be the terminal object type
MooseVariableConstMonomialSpecialization for constant monomials that avoids unnecessary loops
MooseVariableFVRealBase class for Moose variables. This should never be the terminal object type
MooseVariableScalarMoose wrapper class around scalar variables
OrientedBoxMarkerMarks inside and outside a box that can have arbitrary orientation and center point.
ReporterPointMarkerMarks the region inside or empty if it contains a reporter defined point for refinement or coarsening.
UniformMarkerUniformly mark all elements for refinement or coarsening.
ValueRangeMarkerMark elements for adaptivity based on the supplied upper and lower bounds and the specified variable.
ValueThresholdMarkerThe refinement state based on a threshold value compared to the specified variable.
VectorMooseVariableRepresents vector field variables, e.g. Vector Lagrange, Nedelec or Raviart-Thomas

Available Actions

Moose App
AddElementalFieldActionAdds elemental auxiliary variable for adaptivity system.
AddMarkerActionAdd a Marker object to a simulation.

(moose/framework/include/markers/Marker.h)

// 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 "MooseObject.h"
#include "BlockRestrictable.h"
#include "SetupInterface.h"
#include "DependencyResolverInterface.h"
#include "MooseVariableDependencyInterface.h"
#include "UserObjectInterface.h"
#include "Restartable.h"
#include "PostprocessorInterface.h"
#include "MeshChangedInterface.h"
#include "OutputInterface.h"

// Forward declarations
class MooseMesh;
class SubProblem;
class FEProblemBase;
class SystemBase;
class Assembly;
template <typename>
class MooseVariableFE;
typedef MooseVariableFE<Real> MooseVariable;
typedef MooseVariableFE<VectorValue<Real>> VectorMooseVariable;
class Adaptivity;

class Marker : public MooseObject,
               public BlockRestrictable,
               public SetupInterface,
               public DependencyResolverInterface,
               public MooseVariableDependencyInterface,
               public UserObjectInterface,
               public Restartable,
               public PostprocessorInterface,
               public MeshChangedInterface,
               public OutputInterface
{
public:
  static InputParameters validParams();

  Marker(const InputParameters & parameters);
  virtual ~Marker() {}

  /// This mirrors the main refinement flag values in libMesh in Elem::RefinementState but adds "dont_mark"
  enum MarkerValue
  {
    DONT_MARK = -1,
    COARSEN,
    DO_NOTHING,
    REFINE
  };

  /**
   * Helper function for getting the valid refinement flag states a marker can use as a MooseEnum.
   * @return A MooseEnum that is filled with the valid states.  These are perfectly transferable to
   * libMesh Elem::RefinementStates.
   */
  static MooseEnum markerStates();

  virtual void computeMarker();

  bool isActive() const;

  /**
   * Is called before any element looping is started so any "global" computation can be done.
   */
  virtual void markerSetup();

  virtual const std::set<std::string> & getRequestedItems() override;

  virtual const std::set<std::string> & getSuppliedItems() override;

protected:
  virtual MarkerValue computeElementMarker() = 0;

  /**
   * Get an ErrorVector that will be filled up with values corresponding to the indicator passed in.
   *
   * Note that this returns a reference... and the return value should be stored as a reference!
   *
   * @param indicator The name of the indicator to get an ErrorVector for.
   */
  ErrorVector & getErrorVector(std::string indicator);

  /**
   * This is used to get the values of _other_ Markers.  This is useful for making combo-markers
   * that
   * take multiple markers and combine them to make one.
   *
   * @param name The name of the _other_ Marker that you want to have access to.
   * @return A _reference_ that will hold the value of the marker in it's 0 (zeroth) position.
   */
  const MooseArray<Real> & getMarkerValue(std::string name);

  SubProblem & _subproblem;
  FEProblemBase & _fe_problem;
  Adaptivity & _adaptivity;
  SystemBase & _sys;

  THREAD_ID _tid;

  Assembly & _assembly;

  MooseVariable & _field_var;
  const Elem * const & _current_elem;

  MooseMesh & _mesh;

  /// Depend Markers
  std::set<std::string> _depend;
  std::set<std::string> _supplied;
};

(moose/test/tests/markers/combo_marker/combo_marker_test.i)

[Mesh]
  type = GeneratedMesh
  dim = 2
  nx = 10
  ny = 10
  nz = 0
  zmax = 0
  elem_type = QUAD4
[]

[Variables]
  [./u]
    order = FIRST
    family = LAGRANGE
  [../]
[]

[Kernels]
  [./diff]
    type = Diffusion
    variable = u
  [../]
[]

[BCs]
  [./left]
    type = DirichletBC
    variable = u
    boundary = 1
    value = 0
  [../]
  [./right]
    type = DirichletBC
    variable = u
    boundary = 2
    value = 1
  [../]
[]

[Executioner]
  type = Steady

  solve_type = 'PJFNK'
[]

[Adaptivity]
  [./Markers]
    [./box]
      type = BoxMarker
      bottom_left = '0.3 0.3 0'
      top_right = '0.6 0.6 0'
      inside = refine
      outside = do_nothing
    [../]
    [./combo]
      type = ComboMarker
      markers = 'box box2'
    [../]
    [./box2]
      type = BoxMarker
      bottom_left = '0.5 0.5 0'
      top_right = '0.8 0.8 0'
      inside = refine
      outside = coarsen
    [../]
  [../]
[]

[Outputs]
  exodus = true
[]

Marker Values
Example Syntax
Available Objects
Available Actions