Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #include "Marker.h"
      11             : 
      12             : #include "Assembly.h"
      13             : #include "FEProblem.h"
      14             : #include "MooseMesh.h"
      15             : #include "MooseVariableFE.h"
      16             : #include "SystemBase.h"
      17             : 
      18             : InputParameters
      19      217956 : Marker::validParams()
      20             : {
      21      217956 :   InputParameters params = MooseObject::validParams();
      22      217956 :   params += BlockRestrictable::validParams();
      23      217956 :   params += OutputInterface::validParams();
      24             : 
      25             :   // use of displaced meshes with markers is not supported
      26      217956 :   params.set<bool>("use_displaced_mesh") = false;
      27      217956 :   params.suppressParameter<bool>("use_displaced_mesh");
      28             : 
      29      217956 :   params.registerBase("Marker");
      30             : 
      31      217956 :   return params;
      32           0 : }
      33             : 
      34        2077 : Marker::Marker(const InputParameters & parameters)
      35             :   : MooseObject(parameters),
      36             :     BlockRestrictable(this),
      37             :     SetupInterface(this),
      38             :     DependencyResolverInterface(),
      39             :     MooseVariableDependencyInterface(this),
      40             :     UserObjectInterface(this),
      41             :     Restartable(this, "Markers"),
      42             :     PostprocessorInterface(this),
      43             :     MeshChangedInterface(parameters),
      44             :     OutputInterface(parameters),
      45        2077 :     _subproblem(*getCheckedPointerParam<SubProblem *>("_subproblem")),
      46        2077 :     _fe_problem(*getCheckedPointerParam<FEProblemBase *>("_fe_problem_base")),
      47        2077 :     _adaptivity(_fe_problem.adaptivity()),
      48        2077 :     _sys(*getCheckedPointerParam<SystemBase *>("_sys")),
      49        2077 :     _tid(parameters.get<THREAD_ID>("_tid")),
      50        2077 :     _assembly(_subproblem.assembly(_tid, 0)),
      51        2077 :     _field_var(_subproblem.getStandardVariable(_tid, name())),
      52        2077 :     _current_elem(_field_var.currentElem()),
      53             : 
      54        4154 :     _mesh(_subproblem.mesh())
      55             : {
      56        2077 :   _supplied.insert(name());
      57             : 
      58        2077 :   addMooseVariableDependency(&_field_var);
      59        2077 : }
      60             : 
      61             : MooseEnum
      62      102457 : Marker::markerStates()
      63             : {
      64      102457 :   MooseEnum marker_states("DONT_MARK=-1 COARSEN DO_NOTHING REFINE");
      65             : 
      66      102457 :   return marker_states;
      67             : }
      68             : 
      69             : void
      70     1915818 : Marker::computeMarker()
      71             : {
      72     1915818 :   int mark = computeElementMarker();
      73     1915818 :   _field_var.setNodalValue(mark);
      74     1915818 : }
      75             : 
      76             : ErrorVector &
      77         503 : Marker::getErrorVector(std::string indicator)
      78             : {
      79         503 :   return _adaptivity.getErrorVector(indicator);
      80             : }
      81             : 
      82             : const MooseArray<Real> &
      83         183 : Marker::getMarkerValue(std::string name)
      84             : {
      85         183 :   _depend.insert(name);
      86         183 :   return _sys.getFieldVariable<Real>(_tid, name).dofValues();
      87             : }
      88             : 
      89             : bool
      90           0 : Marker::isActive() const
      91             : {
      92           0 :   return true;
      93             : }
      94             : 
      95             : void
      96        5562 : Marker::markerSetup()
      97             : {
      98        5562 : }
      99             : 
     100             : const std::set<std::string> &
     101        1045 : Marker::getRequestedItems()
     102             : {
     103        1045 :   return _depend;
     104             : }
     105             : 
     106             : const std::set<std::string> &
     107        1045 : Marker::getSuppliedItems()
     108             : {
     109        1045 :   return _supplied;
     110             : }