- blockThe list of blocks (ids or names) that this object will be applied
C++ Type:std::vector<SubdomainName>
Controllable:No
Description:The list of blocks (ids or names) that this object will be applied
- elements_changedMaximum 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.
C++ Type:int
Controllable:No
Description: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.
- elements_changed_propertyName 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
C++ Type:MaterialPropertyName
Controllable:No
Description: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
- elements_changed_thresholdMaximum permitted change in the value of 'elements_changed_property' in 'elements_changed' elements before the time step is limited.
C++ Type:double
Controllable:No
Description:Maximum permitted change in the value of 'elements_changed_property' in 'elements_changed' elements before the time step is limited.
- execute_onTIMESTEP_ENDThe list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, MULTIAPP_FIXED_POINT_END, MULTIAPP_FIXED_POINT_BEGIN, FINAL, CUSTOM, ALWAYS.
Default:TIMESTEP_END
C++ Type:ExecFlagEnum
Controllable:No
Description:The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, MULTIAPP_FIXED_POINT_END, MULTIAPP_FIXED_POINT_BEGIN, FINAL, CUSTOM, ALWAYS.
- maximum_value1.79769e+308Maximum value returned by this postprocessor.
Default:1.79769e+308
C++ Type:double
Controllable:No
Description:Maximum value returned by this postprocessor.
- prop_getter_suffixAn optional suffix parameter that can be appended to any attempt to retrieve/get material properties. The suffix will be prepended with a '_' character.
C++ Type:MaterialPropertyName
Controllable:No
Description:An optional suffix parameter that can be appended to any attempt to retrieve/get material properties. The suffix will be prepended with a '_' character.
- use_material_timestep_limitTrueif true, the time step is limited by the minimum value of the material_timestep_limit property
Default:True
C++ Type:bool
Controllable:No
Description:if true, the time step is limited by the minimum value of the material_timestep_limit property
Material Time Step Postprocessor
This postprocessor estimates a timestep that reduces the increment change in a material property below a given threshold.
Description
The MaterialTimeStepPostprocessor works in conjunction with material models to compute the appropriate maximum time step allowed by individual material models. For creep or plasticity models, this maximum time step size is governed by an allowable inelastic strain increment, but a variety of methods could be used by individual material models to compute their acceptable time step. For continuum damage models, the maximum time step size is governed by the allowable increment of damage over a single time step.
Creep Strain Example
The maximum time step size is a numerical tool used to ensure the calculation of physically reasonable inelastic strains and to improve convergence of the inelastic material model. As an example, the maximum allowable time step computation for a creep model has the form (1) where is the maximum effective inelastic strain increment (a default value of 1e-4), set by the user, and is the current scalar effective inelastic strain increment.
Mesh-Wide Evaluation
The MaterialTimeStepPostprocessor collects the time step limitations from all of the quadrature points in the simulation mesh and stores the minimum value. This minimum allowable time step size value is then used by the IterationAdaptiveDT to restrict the time step size based on the limit calculated in the previous time step.
Note that the IterationAdaptiveDT will apply the limiting time step size value from the MaterialTimeStepPostprocessor only if that value is less than maximum time step size value calculated by the internal IterationAdaptiveDT adaptive time step size algorithm.
The value of the maximum allowable time step as collected by the MaterialTimeStepPostprocessor is enforced in the next simulation time step.
Minimum Time Step Calculated in Material Models
The calculation of the maximum allowable timestep is dependent on each individual material: both the maximum allowable inelastic strain increment and the method of calculating the current inelastic strain, Eq. (1), are defined separately for each material. Given this material dependent nature, the maximum time step value is calculated separately by the RadialReturnStressUpdate materials at each quadrature point. The MaterialTimeStepPostprocessor then determines the minimum time step size value from all of the quadrature points in the simulation.
Initially the value of the maximum time step size is set to std::numeric_limits<Real>::max(). Once the inelastic material model begins to calculate inelastic strain, the value of the allowable time step size varies with the inelastic strain computation.
The limiting time step size is stored within a material property called material_timestep_limit. This material property can be set up either by the ComputeMultipleInelasticStress model (for creep or plastic strains) or the ComputeDamageStress for continuum damage models.
Minimum Time Step Size Based on Number of Elements in which a Property Changes
The allowable time step size can also be controlled by the total number of elements in which a material property changes over the course of the time step. This can be used in the context of continuum damage to limit the number of elements damaged at a single time step. To do so, the user needs to define a scalar material property with the input parameter elements_changed_property as well as the maximum acceptable number of elements changed using the elements_changed input parameter. When these are defined, the MaterialTimeStepPostprocessor will sweep over the entire mesh and count the number of elements in which the selected property has changed at at least one quadrature point. The limiting time step is then calculated using the ratio between the current number of elements changed and the maximum value .
(2)
The user can define a elements_changed_threshold to detect a change in property. This can be for example used to count the number of elements in which the damage increases by at least a specific amount.
This method is optional and is only active if both elements_changed_property and elements_changed are defined. The MaterialTimeStepPostprocessor then uses the minimum between the value provided by the material model (see above) or by the number of elements changed. If the input parameter use_material_timestep_limit is set to false, only the number of elements changed is used.
Example Input File
[./matl_ts_min]
type = MaterialTimeStepPostprocessor
[../]
The name of the MaterialTimeStepPostprocessor is passed to the IterationAdaptiveDT as the argument for the timestep_limiting_postprocessor parameter
[./TimeStepper]
type = IterationAdaptiveDT
dt = 0.1
time_t = '1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0'
time_dt = '0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1'
optimal_iterations = 30
iteration_window = 9
growth_factor = 2.0
cutback_factor = 0.5
timestep_limiting_postprocessor = matl_ts_min
[../]
and the max_inelastic_increment parameter in the inelastic material model(s) must be set to run the time step limit calculation.
[./isoplas]
type = IsotropicPlasticityStressUpdate
yield_stress = 5e6
hardening_constant = 0.0
relative_tolerance = 1e-20
absolute_tolerance = 1e-8
max_inelastic_increment = 0.000001
[../]
Input Parameters
- allow_duplicate_execution_on_initialFalseIn the case where this UserObject is depended upon by an initial condition, allow it to be executed twice during the initial setup (once before the IC and again after mesh adaptivity (if applicable).
Default:False
C++ Type:bool
Controllable:No
Description:In the case where this UserObject is depended upon by an initial condition, allow it to be executed twice during the initial setup (once before the IC and again after mesh adaptivity (if applicable).
- control_tagsAdds user-defined labels for accessing object parameters via control logic.
C++ Type:std::vector<std::string>
Controllable:No
Description:Adds user-defined labels for accessing object parameters via control logic.
- enableTrueSet the enabled status of the MooseObject.
Default:True
C++ Type:bool
Controllable:Yes
Description:Set the enabled status of the MooseObject.
- execution_order_group0Execution order groups are executed in increasing order (e.g., the lowest number is executed first). Note that negative group numbers may be used to execute groups before the default (0) group. Please refer to the user object documentation for ordering of user object execution within a group.
Default:0
C++ Type:int
Controllable:No
Description:Execution order groups are executed in increasing order (e.g., the lowest number is executed first). Note that negative group numbers may be used to execute groups before the default (0) group. Please refer to the user object documentation for ordering of user object execution within a group.
- force_postauxFalseForces the UserObject to be executed in POSTAUX
Default:False
C++ Type:bool
Controllable:No
Description:Forces the UserObject to be executed in POSTAUX
- force_preauxFalseForces the UserObject to be executed in PREAUX
Default:False
C++ Type:bool
Controllable:No
Description:Forces the UserObject to be executed in PREAUX
- force_preicFalseForces the UserObject to be executed in PREIC during initial setup
Default:False
C++ Type:bool
Controllable:No
Description:Forces the UserObject to be executed in PREIC during initial setup
- implicitTrueDetermines whether this object is calculated using an implicit or explicit form
Default:True
C++ Type:bool
Controllable:No
Description:Determines whether this object is calculated using an implicit or explicit form
- outputsVector of output names where you would like to restrict the output of variables(s) associated with this object
C++ Type:std::vector<OutputName>
Controllable:No
Description:Vector of output names where you would like to restrict the output of variables(s) associated with this object
- seed0The seed for the master random number generator
Default:0
C++ Type:unsigned int
Controllable:No
Description:The seed for the master random number generator
- use_displaced_meshFalseWhether or not this object should use the displaced mesh for computation. Note that in the case this is true but no displacements are provided in the Mesh block the undisplaced mesh will still be used.
Default:False
C++ Type:bool
Controllable:No
Description:Whether or not this object should use the displaced mesh for computation. Note that in the case this is true but no displacements are provided in the Mesh block the undisplaced mesh will still be used.