This postporocessor calculates an estimated timestep size that limits an auxiliary variable to below a given threshold. More...

#include <MaterialTimeStepPostprocessor.h>

Inheritance diagram for MaterialTimeStepPostprocessor:

[legend]

Public Member Functions
	MaterialTimeStepPostprocessor (const InputParameters &parameters)

virtual void	initialize ()

virtual void	execute ()

virtual Real	getValue ()

virtual void	threadJoin (const UserObject &y)

Static Public Member Functions
static InputParameters	validParams ()

Protected Attributes
const bool	_use_material_timestep_limit
	Flag to find the time step limit from material properties. More...

const MaterialProperty< Real > *	_matl_time_step
	Pointer to the material property containing the time step limit. More...

Real	_matl_value
	Current time step limit from the material properties. More...

const bool	_use_elements_changed
	Flag to limit the time step based on the number of elements changed. More...

const int	_elements_changed
	Target number of changed elements used to determine if we need to change the time step. More...

int	_count
	Current number of elements changed. More...

const Real	_elements_changed_threshold
	Tolerance to determine if elements have changed. More...

unsigned int	_qp
	Current quadrature point. More...


const MaterialProperty< Real > *	_changed_property
	Material property used to determine if elements have changed. More...

const MaterialProperty< Real > *	_changed_property_old

Detailed Description

This postporocessor calculates an estimated timestep size that limits an auxiliary variable to below a given threshold.

Definition at line 23 of file MaterialTimeStepPostprocessor.h.

Constructor & Destructor Documentation

◆ MaterialTimeStepPostprocessor()

MaterialTimeStepPostprocessor::MaterialTimeStepPostprocessor ( const InputParameters & parameters )

Definition at line 58 of file MaterialTimeStepPostprocessor.C.

   : ElementPostprocessor(parameters),
     _use_material_timestep_limit(getParam<bool>("use_material_timestep_limit")),
     _matl_time_step(_use_material_timestep_limit
                         ? &getMaterialPropertyByName<Real>("matl_timestep_limit")
                         : nullptr),
     _matl_value(std::numeric_limits<Real>::max()),
     _use_elements_changed(parameters.isParamSetByUser("elements_changed_property")),
     _changed_property(_use_elements_changed
                           ? &getMaterialPropertyByName<Real>(
                                 getParam<MaterialPropertyName>("elements_changed_property"))
                           : nullptr),
     _changed_property_old(_use_elements_changed
                               ? &getMaterialPropertyOldByName<Real>(
                                     getParam<MaterialPropertyName>("elements_changed_property"))
                               : nullptr),
     _elements_changed(isParamValid("elements_changed") ? getParam<int>("elements_changed") : 0),
     _count(0),
     _elements_changed_threshold(parameters.isParamSetByUser("elements_changed_threshold'")
                                     ? getParam<Real>("elements_changed_threshold'")
                                     : TOLERANCE * TOLERANCE),
     _qp(0)
 {
   if (_use_elements_changed && !parameters.isParamSetByUser("elements_changed"))
     paramError("elements_changed", "needs to be set when elements_changed_property is defined");
  
   if (!_use_material_timestep_limit && !_use_elements_changed)
     mooseError("either use_material_timestep_limit needs to be true or elements_changed_property "
                "defined");
 }

Member Function Documentation

◆ execute()

void MaterialTimeStepPostprocessor::execute ( )

virtual

Definition at line 97 of file MaterialTimeStepPostprocessor.C.

 {
   if (_use_material_timestep_limit)
   {
     for (_qp = 0; _qp < _qrule->n_points(); _qp++)
       _matl_value = std::min(_matl_value, (*_matl_time_step)[_qp]);
   }
  
   if (_use_elements_changed)
   {
     for (_qp = 0; _qp < _qrule->n_points(); ++_qp)
     {
       if (!MooseUtils::absoluteFuzzyEqual((*_changed_property)[_qp],
                                           (*_changed_property_old)[_qp],
                                           _elements_changed_threshold))
       {
         ++_count;
         return;
       }
     }
   }
 }

◆ getValue()

Real MaterialTimeStepPostprocessor::getValue ( )

virtual

Definition at line 121 of file MaterialTimeStepPostprocessor.C.

 {
   gatherMin(_matl_value);
   gatherSum(_count);
  
   if (_count == 0 || !_use_elements_changed)
     return _matl_value;
  
   return std::min(_dt * (Real)_elements_changed / (Real)_count, _matl_value);
 }

◆ initialize()

void MaterialTimeStepPostprocessor::initialize ( )

virtual

Definition at line 90 of file MaterialTimeStepPostprocessor.C.

 {
   _matl_value = std::numeric_limits<Real>::max(); // start w/ the min
   _count = 0;
 }

◆ threadJoin()

void MaterialTimeStepPostprocessor::threadJoin ( const UserObject & y )

virtual

Definition at line 133 of file MaterialTimeStepPostprocessor.C.

 {
   const MaterialTimeStepPostprocessor & pps = static_cast<const MaterialTimeStepPostprocessor &>(y);
   if (_use_material_timestep_limit)
     _matl_value = std::min(_matl_value, pps._matl_value);
   if (_use_elements_changed)
     _count += pps._count;
 }

◆ validParams()

InputParameters MaterialTimeStepPostprocessor::validParams ( )

static

Definition at line 25 of file MaterialTimeStepPostprocessor.C.

 {
   InputParameters params = ElementPostprocessor::validParams();
  
   params.addClassDescription("This postprocessor estimates a timestep that reduces the increment "
                              "change in a material property below a given threshold.");
  
   params.addParam<bool>("use_material_timestep_limit",
                         true,
                         "if true, the time step is limited by the minimum value of the "
                         "matl_timestep_limit property");
  
   params.addParam<MaterialPropertyName>("elements_changed_property",
                                         "Name of the material property used to limit the time step "
                                         "if its value changes by more than "
                                         "'elements_changed_threshold' in at least "
                                         "'elements_changed' elements");
  
   params.addRangeCheckedParam<int>("elements_changed",
                                    "elements_changed > 0",
                                    "Maximum number of elements within which the property named in "
                                    "'elements_changed_property' is allowed to change by more than "
                                    "'elements_changed_threshold' before the time step is limited.");
  
   params.addRangeCheckedParam<Real>("elements_changed_threshold",
                                     "elements_changed_threshold' > 0",
                                     "Maximum permitted change in the value of "
                                     "'elements_changed_property' in 'elements_changed' elements "
                                     "before the time step is limited.");
  
   return params;
 }