www.mooseframework.org
TensorMechanicsApp.C
Go to the documentation of this file.
1 /****************************************************************/
2 /* MOOSE - Multiphysics Object Oriented Simulation Environment */
3 /* */
4 /* All contents are licensed under LGPL V2.1 */
5 /* See LICENSE for full restrictions */
6 /****************************************************************/
7 #include "TensorMechanicsApp.h"
8 #include "Moose.h"
9 #include "AppFactory.h"
10 #include "MooseSyntax.h"
11 
13 #include "TensorMechanicsAction.h"
16 #include "PoroMechanicsAction.h"
17 #include "PressureAction.h"
19 
25 #include "MomentBalancing.h"
26 #include "PoroMechanicsCoupling.h"
27 #include "InertialForce.h"
28 #include "InertialTorque.h"
29 #include "Gravity.h"
31 #include "OutOfPlanePressure.h"
32 #include "GeneralizedPlaneStrain.h"
34 #include "WeakPlaneStress.h"
35 #include "PlasticHeatEnergy.h"
37 
38 #include "LinearElasticTruss.h"
42 #include "FiniteStrainUObasedCP.h"
56 #include "TwoPhaseStressMaterial.h"
58 #include "CompositeEigenstrain.h"
64 #include "ComputeSmallStrain.h"
73 #include "ComputeFiniteStrain.h"
80 #include "ComputeEigenstrain.h"
106 #include "SumTensorIncrements.h"
109 #include "InclusionProperties.h"
114 #include "ComputeInterfaceStress.h"
115 #include "TensileStressUpdate.h"
117 #include "GeneralizedMaxwellModel.h"
122 
144 #include "ElementPropertyReadFile.h"
145 #include "EulerAngleFileReader.h"
146 #include "HEVPLinearHardening.h"
148 #include "HEVPEqvPlasticStrain.h"
150 #include "HEVPFlowRatePowerLawJ2.h"
152 
153 #include "CylindricalRankTwoAux.h"
154 #include "RankTwoAux.h"
155 #include "RankFourAux.h"
156 #include "ElasticEnergyAux.h"
157 #include "AccumulateAux.h"
159 #include "RankTwoScalarAux.h"
160 #include "NewmarkAccelAux.h"
161 #include "NewmarkVelAux.h"
164 
165 #include "CavityPressureAction.h"
167 #include "CavityPressurePPAction.h"
169 #include "CavityPressureUOAction.h"
170 
171 #include "DashpotBC.h"
172 #include "PresetVelocity.h"
173 #include "Pressure.h"
174 #include "DisplacementAboutAxis.h"
175 #include "PresetDisplacement.h"
176 #include "PresetAcceleration.h"
177 #include "StickyBC.h"
178 
183 
184 #include "Mass.h"
185 #include "TorqueReaction.h"
186 #include "MaterialTensorIntegral.h"
188 
191 
193 
194 #include "ElementJacobianDamper.h"
195 
196 #include "JIntegral.h"
197 #include "CrackDataSampler.h"
198 #include "CrackFrontData.h"
199 #include "CrackFrontDefinition.h"
200 #include "DomainIntegralAction.h"
201 #include "DomainIntegralQFunction.h"
204 #include "MixedModeEquivalentK.h"
205 #include "EshelbyTensor.h"
206 #include "InteractionIntegral.h"
207 #include "ThermalFractureIntegral.h"
208 
209 template <>
210 InputParameters
212 {
213  InputParameters params = validParams<MooseApp>();
214  return params;
215 }
216 
217 TensorMechanicsApp::TensorMechanicsApp(const InputParameters & parameters) : MooseApp(parameters)
218 {
219  Moose::registerObjects(_factory);
221 
222  Moose::associateSyntax(_syntax, _action_factory);
223  TensorMechanicsApp::associateSyntax(_syntax, _action_factory);
224 }
225 
227 
228 // External entry point for dynamic application loading
229 extern "C" void
231 {
233 }
234 void
236 {
237  registerApp(TensorMechanicsApp);
238 }
239 
240 // External entry point for dynamic object registration
241 extern "C" void
243 {
245 }
246 void
248 {
249  registerKernel(StressDivergenceTensors);
250  registerKernel(StressDivergenceTensorsTruss);
251  registerKernel(CosseratStressDivergenceTensors);
252  registerKernel(StressDivergenceRZTensors);
253  registerKernel(StressDivergenceRSphericalTensors);
254  registerKernel(MomentBalancing);
255  registerKernel(PoroMechanicsCoupling);
256  registerKernel(InertialForce);
257  registerKernel(InertialTorque);
258  registerKernel(Gravity);
259  registerKernel(DynamicStressDivergenceTensors);
260  registerKernel(OutOfPlanePressure);
261  registerKernel(GeneralizedPlaneStrain);
262  registerKernel(GeneralizedPlaneStrainOffDiag);
263  registerKernel(WeakPlaneStress);
264  registerKernel(PlasticHeatEnergy);
265  registerKernel(PhaseFieldFractureMechanicsOffDiag);
266 
267  registerMaterial(LinearElasticTruss);
268  registerMaterial(FiniteStrainPlasticMaterial);
269  registerMaterial(FiniteStrainCrystalPlasticity);
270  registerMaterial(FiniteStrainCPSlipRateRes);
271  registerMaterial(FiniteStrainUObasedCP);
272  registerMaterial(CappedMohrCoulombStressUpdate);
273  registerMaterial(CappedMohrCoulombCosseratStressUpdate);
274  registerMaterial(CappedWeakPlaneStressUpdate);
275  registerMaterial(CappedWeakInclinedPlaneStressUpdate);
276  registerMaterial(CappedWeakPlaneCosseratStressUpdate);
277  registerMaterial(CappedDruckerPragerStressUpdate);
278  registerMaterial(CappedDruckerPragerCosseratStressUpdate);
279  registerMaterial(ComputeMultiPlasticityStress);
280  registerMaterial(ComputeCosseratLinearElasticStress);
281  registerMaterial(ComputeCosseratSmallStrain);
282  registerMaterial(ComputeCosseratIncrementalSmallStrain);
283  registerMaterial(ComputeCosseratElasticityTensor);
284  registerMaterial(ComputeLayeredCosseratElasticityTensor);
285  registerMaterial(TwoPhaseStressMaterial);
286  registerMaterial(MultiPhaseStressMaterial);
287  registerMaterial(CompositeEigenstrain);
288  registerMaterial(CompositeElasticityTensor);
289  registerMaterial(ComputeElasticityTensor);
290  registerMaterial(ComputeElasticityTensorCP);
291  registerMaterial(ComputeIsotropicElasticityTensor);
293  registerMaterial(ComputeSmallStrain);
294  registerMaterial(ComputePlaneSmallStrain);
295  registerMaterial(ComputePlaneIncrementalStrain);
296  registerMaterial(ComputePlaneFiniteStrain);
297  registerMaterial(ComputeAxisymmetricRZSmallStrain);
298  registerMaterial(ComputeRSphericalSmallStrain);
299  registerMaterial(ComputeIncrementalSmallStrain);
300  registerMaterial(ComputeAxisymmetricRZIncrementalStrain);
301  registerMaterial(ComputeRSphericalIncrementalStrain);
302  registerMaterial(ComputeFiniteStrain);
303  registerMaterial(ComputeAxisymmetricRZFiniteStrain);
304  registerMaterial(ComputeRSphericalFiniteStrain);
305  registerMaterial(ComputeLinearElasticStress);
307  registerMaterial(ComputeLinearElasticPFFractureStress);
308  registerMaterial(ComputeFiniteStrainElasticStress);
309  registerMaterial(ComputeEigenstrain);
310  registerMaterial(ComputeExtraStressConstant);
311  registerMaterial(ComputeVariableBaseEigenStrain);
312  registerMaterial(ComputeVariableEigenstrain);
313  registerMaterial(ComputeThermalExpansionEigenstrain);
316  registerMaterial(ComputeReducedOrderEigenstrain);
317  registerMaterial(ComputeVolumetricEigenstrain);
319  registerMaterial(FiniteStrainHyperElasticViscoPlastic);
320  registerMaterial(LinearIsoElasticPFDamage);
321  registerMaterial(HyperElasticPhaseFieldIsoDamage);
322  registerMaterial(ComputeVolumetricDeformGrad);
323  registerMaterial(ComputeDeformGradBasedStress);
324  registerMaterial(VolumeDeformGradCorrectedStress);
325  registerMaterial(ComputeMultipleInelasticStress);
326  registerMaterial(ComputeMultipleInelasticCosseratStress);
327  registerMaterial(IsotropicPlasticityStressUpdate);
328  registerMaterial(IsotropicPowerLawHardeningStressUpdate);
329  registerMaterial(PowerLawCreepStressUpdate);
330  registerMaterial(HyperbolicViscoplasticityStressUpdate);
332  registerMaterial(StressBasedChemicalPotential);
333  registerMaterial(FluxBasedStrainIncrement);
334  registerMaterial(GBRelaxationStrainIncrement);
335  registerMaterial(SumTensorIncrements);
336  registerMaterial(ComputeStrainIncrementBasedStress);
337  registerMaterial(ComputeSmearedCrackingStress);
338  registerMaterial(InclusionProperties);
339  registerMaterial(ComputeAxisymmetric1DSmallStrain);
340  registerMaterial(ComputeAxisymmetric1DIncrementalStrain);
341  registerMaterial(ComputeAxisymmetric1DFiniteStrain);
342  registerMaterial(ComputePlasticHeatEnergy);
343  registerMaterial(ComputeInterfaceStress);
344  registerMaterial(TensileStressUpdate);
346  registerMaterial(EshelbyTensor);
347  registerMaterial(GeneralizedMaxwellModel);
348  registerMaterial(GeneralizedKelvinVoigtModel);
349  registerMaterial(LinearViscoelasticStressUpdate);
350  registerMaterial(ComputeLinearViscoelasticStress);
351  registerMaterial(ThermalFractureIntegral);
352  registerMaterial(ComputeEigenstrainFromInitialStress);
353 
354  registerUserObject(TensorMechanicsPlasticSimpleTester);
355  registerUserObject(TensorMechanicsPlasticTensile);
356  registerUserObject(TensorMechanicsPlasticTensileMulti);
357  registerUserObject(TensorMechanicsPlasticMohrCoulomb);
358  registerUserObject(TensorMechanicsPlasticMohrCoulombMulti);
359  registerUserObject(TensorMechanicsPlasticWeakPlaneTensile);
360  registerUserObject(TensorMechanicsPlasticWeakPlaneTensileN);
361  registerUserObject(TensorMechanicsPlasticWeakPlaneShear);
362  registerUserObject(TensorMechanicsPlasticJ2);
363  registerUserObject(TensorMechanicsPlasticIsotropicSD);
364  registerUserObject(TensorMechanicsPlasticOrthotropic);
365  registerUserObject(TensorMechanicsPlasticMeanCap);
366  registerUserObject(TensorMechanicsPlasticMeanCapTC);
367  registerUserObject(TensorMechanicsPlasticDruckerPrager);
369  registerUserObject(TensorMechanicsHardeningConstant);
370  registerUserObject(TensorMechanicsHardeningGaussian);
371  registerUserObject(TensorMechanicsHardeningExponential);
372  registerUserObject(TensorMechanicsHardeningPowerRule);
373  registerUserObject(TensorMechanicsHardeningCutExponential);
374  registerUserObject(TensorMechanicsHardeningCubic);
375  registerUserObject(ElementPropertyReadFile);
376  registerUserObject(EulerAngleFileReader);
377  registerUserObject(HEVPLinearHardening);
378  registerUserObject(HEVPRambergOsgoodHardening);
379  registerUserObject(HEVPEqvPlasticStrain);
380  registerUserObject(HEVPEqvPlasticStrainRate);
381  registerUserObject(HEVPFlowRatePowerLawJ2);
382  registerUserObject(CavityPressureUserObject);
383  registerUserObject(CrystalPlasticitySlipRateGSS);
384  registerUserObject(CrystalPlasticitySlipResistanceGSS);
385  registerUserObject(CrystalPlasticityStateVariable);
386  registerUserObject(CrystalPlasticityStateVarRateComponentGSS);
387  registerUserObject(GeneralizedPlaneStrainUserObject);
388  registerUserObject(CrackFrontDefinition);
389  registerUserObject(LinearViscoelasticityManager);
390 
391  registerAux(CylindricalRankTwoAux);
392  registerAux(RankTwoAux);
393  registerAux(RankFourAux);
394  registerAux(ElasticEnergyAux);
395  registerAux(AccumulateAux);
396  registerAux(CrystalPlasticityRotationOutAux);
397  registerAux(RankTwoScalarAux);
398  registerAux(NewmarkAccelAux);
399  registerAux(NewmarkVelAux);
400  registerAux(RadialDisplacementCylinderAux);
401  registerAux(RadialDisplacementSphereAux);
402  registerAux(DomainIntegralQFunction);
404 
405  registerBoundaryCondition(DashpotBC);
406  registerBoundaryCondition(PresetVelocity);
407  registerBoundaryCondition(Pressure);
408  registerBoundaryCondition(DisplacementAboutAxis);
409  registerBoundaryCondition(PresetDisplacement);
410  registerBoundaryCondition(PresetAcceleration);
411  registerBoundaryCondition(InteractionIntegralBenchmarkBC);
412  registerBoundaryCondition(StickyBC);
413 
414  registerPostprocessor(CavityPressurePostprocessor);
415  registerPostprocessor(Mass);
416  registerPostprocessor(TorqueReaction);
417  registerPostprocessor(MaterialTensorIntegral);
418  registerPostprocessor(MaterialTimeStepPostprocessor);
419  registerPostprocessor(JIntegral);
420  registerPostprocessor(InteractionIntegral);
421  registerPostprocessor(CrackFrontData);
422  registerPostprocessor(MixedModeEquivalentK);
423 
424  registerVectorPostprocessor(LineMaterialRankTwoSampler);
425  registerVectorPostprocessor(LineMaterialRankTwoScalarSampler);
426  registerVectorPostprocessor(CrackDataSampler);
427 
428  registerDamper(ElementJacobianDamper);
429 }
430 
431 // External entry point for dynamic syntax association
432 extern "C" void
433 TensorMechanicsApp__associateSyntax(Syntax & syntax, ActionFactory & action_factory)
434 {
435  TensorMechanicsApp::associateSyntax(syntax, action_factory);
436 }
437 void
438 TensorMechanicsApp::associateSyntax(Syntax & syntax, ActionFactory & action_factory)
439 {
440  registerSyntax("EmptyAction", "BCs/CavityPressure");
441  registerSyntax("CavityPressureAction", "BCs/CavityPressure/*");
442  registerSyntax("CavityPressurePPAction", "BCs/CavityPressure/*");
443  registerSyntax("CavityPressureUOAction", "BCs/CavityPressure/*");
444 
445  registerSyntax("LegacyTensorMechanicsAction", "Kernels/TensorMechanics");
446  registerSyntax("DynamicTensorMechanicsAction", "Kernels/DynamicTensorMechanics");
447  registerSyntax("PoroMechanicsAction", "Kernels/PoroMechanics");
448 
449  registerSyntax("EmptyAction", "BCs/Pressure");
450  registerSyntax("PressureAction", "BCs/Pressure/*");
451 
452  registerSyntax("GeneralizedPlaneStrainAction",
453  "Modules/TensorMechanics/GeneralizedPlaneStrain/*");
454  registerSyntax("CommonTensorMechanicsAction", "Modules/TensorMechanics/Master");
455  registerSyntax("TensorMechanicsAction", "Modules/TensorMechanics/Master/*");
456 
457  registerSyntaxTask("DomainIntegralAction", "DomainIntegral", "add_user_object");
458  registerSyntaxTask("DomainIntegralAction", "DomainIntegral", "add_aux_variable");
459  registerSyntaxTask("DomainIntegralAction", "DomainIntegral", "add_aux_kernel");
460  registerSyntaxTask("DomainIntegralAction", "DomainIntegral", "add_postprocessor");
461  registerSyntaxTask("DomainIntegralAction", "DomainIntegral", "add_vector_postprocessor");
462  registerSyntaxTask("DomainIntegralAction", "DomainIntegral", "add_material");
463 
464  registerTask("validate_coordinate_systems", /*is_required=*/false);
465  addTaskDependency("validate_coordinate_systems", "create_problem");
466 
467  registerAction(CavityPressureAction, "add_bc");
468  registerAction(CavityPressurePPAction, "add_postprocessor");
469  registerAction(CavityPressureUOAction, "add_user_object");
470 
471  registerAction(LegacyTensorMechanicsAction, "setup_mesh_complete");
472  registerAction(LegacyTensorMechanicsAction, "validate_coordinate_systems");
473  registerAction(LegacyTensorMechanicsAction, "add_kernel");
474 
475  registerAction(CommonTensorMechanicsAction, "meta_action");
476 
477  registerAction(TensorMechanicsAction, "meta_action");
478  registerAction(TensorMechanicsAction, "setup_mesh_complete");
479  registerAction(TensorMechanicsAction, "validate_coordinate_systems");
480  registerAction(TensorMechanicsAction, "add_variable");
481  registerAction(TensorMechanicsAction, "add_aux_variable");
482  registerAction(TensorMechanicsAction, "add_kernel");
483  registerAction(TensorMechanicsAction, "add_aux_kernel");
484  registerAction(TensorMechanicsAction, "add_material");
485 
486  registerAction(DynamicTensorMechanicsAction, "setup_mesh_complete");
487  registerAction(DynamicTensorMechanicsAction, "validate_coordinate_systems");
488  registerAction(DynamicTensorMechanicsAction, "add_kernel");
489 
490  registerAction(PoroMechanicsAction, "setup_mesh_complete");
491  registerAction(PoroMechanicsAction, "validate_coordinate_systems");
492  registerAction(PoroMechanicsAction, "add_kernel");
493 
494  registerAction(PressureAction, "add_bc");
495 
496  registerAction(GeneralizedPlaneStrainAction, "add_scalar_kernel");
497  registerAction(GeneralizedPlaneStrainAction, "add_kernel");
498  registerAction(GeneralizedPlaneStrainAction, "add_user_object");
499 
500  registerAction(DomainIntegralAction, "add_user_object");
501  registerAction(DomainIntegralAction, "add_aux_variable");
502  registerAction(DomainIntegralAction, "add_aux_kernel");
503  registerAction(DomainIntegralAction, "add_postprocessor");
504  registerAction(DomainIntegralAction, "add_material");
505 }
CompositeEigenstrain provides a simple RankTwoTensor type MaterialProperty that can be used as an Eig...
ComputeSmearedCrackingStress computes the stress for a finite strain material with smeared cracking...
This class is an implementation of a generalized Kelvin-Voigt model with constant mechanical properti...
This material calculates the stresses, strains, and elastic energies for an ellipsoidal inclusion in ...
CrackDataSampler is a type of VectorPostprocessor that outputs the values of domain integrals...
SumTensorIncrements update a tensor by summing tensor increments passed as property.
Calculates the radial displacement for spherical geometries.
CappedWeakPlaneCosseratStressUpdate performs the return-map algorithm and associated stress updates f...
This class solves the viscoplastic flow rate equations in the total form Involves 4 different types o...
FiniteStrainPlasticMaterial implements rate-independent associative J2 plasticity with isotropic hard...
InputParameters validParams< TensorMechanicsApp >()
This class manages a LinearViscoelasticityBase object.
CutExponential hardening The value = _val_res + (val_0 - val_res)*exp(-rate*(internal_parameter - _in...
TensorMechanicsApp(const InputParameters &parameters)
ComputeMultipleInelasticStress computes the stress, the consistent tangent operator (or an approximat...
ComputeElasticityTensor defines an elasticity tensor material for isi.
ComputeFiniteStrainElasticStressBirchMurnaghan computes the stress following elasticity theory for fi...
ComputeAxisymmetric1DIncrementalStrain defines a strain increment only for incremental small strains ...
ComputeAxisymmetricRZFiniteStrain defines a strain increment and rotation increment for finite strain...
CappedMohrCoulombStressUpdate implements rate-independent nonassociative Mohr-Coulomb plus tensile pl...
ComputeStrainIncrementBasedStress computes stress considering list of inelastic strain increments...
IsotropicSD plasticity model from Yoon (2013) the name of the paper is "Asymmetric yield function bas...
This class implements a damper that limits the change in the Jacobian of elements.
Cubic hardening value = _val_0 for p <= _intnl_0 value = _val_res for p >= _intnl_limit value = cubic...
ComputeElasticityTensor defines an elasticity tensor material object with a given base name...
Rate-independent associative weak-plane tensile failure with hardening/softening. ...
Class that can be used for testing multi-surface plasticity models.
CappedDruckerPragerCosseratStressUpdate performs the return-map algorithm and associated stress updat...
No hardening - the parameter assumes the value _val for all internal parameters.
Phenomenological constitutive model slip rate userobject class.
This user object classs Computes power law hardening.
FiniteStrainTensile implements rate-independent associative tensile failure with hardening/softening ...
Rate-independent associative weak-plane tensile failure with hardening/softening, and normal directio...
GBRelaxationStrainIncrement computes strain increment due to lattice relaxation at GB Forest et...
ComputeElasticityTensor defines an elasticity tensor material object as a function of concentration f...
This class inherits from IsotropicPlasticityStressUpdate.
Power-Rule Hardening defined by: assuming p = internal_parameter, then value = value_0 * (p / epsilon...
ComputeThermalExpansionEigenstrain computes an eigenstrain for thermal expansion with a constant expa...
This class uses the Discrete material in a radial return isotropic creep model.
ComputeVariableIsotropicElasticityTensor defines an elasticity tensor material for isotropic material...
ComputeLayeredCosseratElasticityTensor defines an elasticity tensor and an elastic flexural rigidity ...
TensileStressUpdate implements rate-independent associative tensile failure ("Rankine" plasticity) wi...
ComputeMultiPlasticityStress performs the return-map algorithm and associated stress updates for plas...
Construct a global strain from the phase strains in a manner that is consistent with the construction...
StressDivergenceRSphericalTensors is a modification of StressDivergenceTensors for 1D spherically sym...
This postprocessor computes the J-Integral.
Definition: JIntegral.h:24
ComputeElasticityTensorCP defines an elasticity tensor material object for crystal plasticity...
void TensorMechanicsApp_registerApps()
EshelbyTensor defines a strain increment and rotation increment, for finite strains.
Definition: EshelbyTensor.h:18
ComputeCosseratSmallStrain defines Cossserat strain tensor, assuming small strains.
static void registerObjects(Factory &factory)
ComputeEigenstrain computes an Eigenstrain that is a function of a single variable defined by a base ...
Sticky-type boundary condition, where if the old variable value exceeds the bounds provided u is fixe...
Definition: StickyBC.h:30
Coupled auxiliary value.
This class is an implementation of a generalized Maxwell model with constant mechanical properties...
static void registerApps()
ComputeDeformGradBasedStress computes stress based on lagrangian strain definition.
VolumeDeformGradCorrectedStress transforms the Cauchy stress calculated in the previous configuration...
This user object classs Computes linear hardening.
Gravity computes the body force (force/volume) given the acceleration of gravity (value) and the dens...
Definition: Gravity.h:22
ComputeMultipleInelasticStress computes the stress, the consistent tangent operator (or an approximat...
Construct a global strain from the phase strains in a manner that is consistent with the construction...
J2 plasticity, associative, with hardning.
Class that limits the mean stress Yield function = a*mean_stress - strength mean_stress = (stress_xx ...
This class uses the Discrete material in a radial return isotropic plasticity model.
This Kernel computes epsilon_ijk * stress_jk (sum over j and k) "i" is called _component in this clas...
Phase-field fracture This class computes the stress and energy contribution for the small strain Isot...
ComputeVolumetricEigenstrain computes an eigenstrain that is defined by a set of scalar material prop...
Works on top of NodalNormalsPreprocessor.
Provides a heat source from plastic deformation: coeff * stress * plastic_strain_rate.
void TensorMechanicsApp__registerObjects(Factory &factory)
ComputePlaneIncrementalStrain defines strain increment for small strains in a 2D planar simulation...
Phenomenological constitutive model slip resistance userobject class.
Rate-independent non-associative Drucker Prager with hardening/softening.
StressDivergenceRZTensors is a modification of StressDivergenceTensors to accommodate the Axisymmetri...
Phase-field fracture This class computes the stress and energy contribution to fracture Small strain ...
Computes grad_i(stress_{i component}) This is exactly the same as StressDivergenceTensors, only the Jacobian entries are correct for the Cosserat case.
CappedWeakInclinedPlaneStressUpdate performs the return-map algorithm and associated stress updates f...
RankTwoScalarAux uses the namespace RankTwoScalarTools to compute scalar values from Rank-2 tensors...
Rate-independent non-associative Drucker Prager with hardening/softening.
Accumulate values from one auxiliary variable into another.
Definition: AccumulateAux.h:21
Rate-independent associative weak-plane tensile failure with hardening/softening of the tensile stren...
ComputeIsotropicElasticityTensor defines an elasticity tensor material for isotropic materials...
ComputeCosseratIncrementalSmallStrain defines various incremental versions of the Cossserat strain te...
Implements a simple constant Dashpot BC where grad(u)=value on the boundary.
Definition: DashpotBC.h:23
ComputeEigenstrain computes an Eigenstrain that is a function of a single variable defined by a base ...
ComputePlaneFiniteStrain defines strain increment and rotation increment for finite strain under 2D p...
Phenomenological constitutive model state variable evolution rate component userobject class...
This class samples components of RankTwoTensor material properties for the integration points in all ...
ThermalFractureIntegral computes the summation of the derivative of the eigenstrains with respect to ...
This class computes a creep strain increment associated with a linear viscoelastic model contained in...
CappedMohrCoulombCosseratStressUpdate implements rate-independent nonassociative Mohr-Coulomb plus te...
ComputePlasticHeatEnergy computes stress * (plastic_strain - plastic_strain_old) and, if currentlyComputingJacobian, then the derivative of this quantity wrt total strain.
This class uses the Discrete material in a radial return isotropic plasticity model.
FiniteStrainUObasedCP uses the multiplicative decomposition of deformation gradient and solves the PK...
ComputeCosseratLinearElasticStress computes the Cosserat stress and couple-stress following linear el...
ComputeFiniteStrainElasticStress computes the stress following elasticity theory for finite strains...
Pressure applies a pressure on a given boundary in the direction defined by component.
Definition: Pressure.h:21
ComputeEigenstrain computes an Eigenstrain that results from an initial stress.
DynamicStressDivergenceTensors derives from StressDivergenceTensors and adds stress related Rayleigh ...
FiniteStrainMohrCoulombMulti implements rate-independent non-associative mohr-coulomb with hardening/...
Store common tensor mechanics parameters.
This class solves visco plastic model based on isotropically damaged stress The damage parameter is o...
Orthotropic plasticity model from Yoon (2013) the name of the paper is "Asymmetric yield function bas...
ComputeRSphericalSmallStrain defines a strain tensor, assuming small strains, in a 1D simulation assu...
This postprocessor computes the mass by integrating the density over the volume.
Definition: Mass.h:22
ComputeAxisymmetricRZSmallStrain defines small strains in an Axisymmetric system. ...
This user object classs Computes flow rate based on power law and Direction based on J2...
Gaussian hardening The value = _val_res + (val_0 - val_res)*exp(-0.5*rate*(p - intnl_0)^2) for p>intn...
ComputeInstantaneousThermalExpansionFunctionEigenstrain computes an eigenstrain for thermal expansion...
ComputeIncrementalSmallStrain defines a strain increment and rotation increment (=1), for small strains.
ComputeFiniteStrain defines a strain increment and rotation increment, for finite strains...
Implements a boundary condition that enforces rotational displacement around an axis on a boundary...
Phase-field fracture This class computes the energy contribution to damage growth Small strain Isotro...
This class applies a displacement time history on a given boundary in a given direction.
FluxBasedStrainIncrement computes strain increment based on flux (vacancy) Forest et...
ComputeVariableBaseEigenstrain computes an Eigenstrain based on a real tensor value material property...
This class samples RankTwoTensor material properties for the integration points in all elements that ...
This postporocessor calculates an estimated timestep size that limits an auxiliary variable to below ...
Rate-independent associative mean-cap tensile AND compressive failure with hardening/softening of the...
CompositeElasticityTensor provides a simple RankFourTensor type MaterialProperty that can be used as ...
static void associateSyntax(Syntax &syntax, ActionFactory &action_factory)
ComputeAxisymmetric1DFiniteStrain defines a strain increment for finite strains in an Axisymmetric 1D...
ComputeAxisymmetricRZIncrementalStrain defines a strain increment only for incremental strains in an ...
StressBasedChemicalPotential computes chemical potential based on stress and a direction tensor Fores...
Implements a boundary condition that enforces a displacement field around a crack tip based on applie...
CappedDruckerPragerStressUpdate performs the return-map algorithm and associated stress updates for p...
Computes the stress of a linear viscoelastic material, using total small strains. ...
Crystal plasticity state variable userobject class.
This class prescribes the acceleration on a given boundary in a given direction.
Read a set of Euler angles from a file.
Computes the inertial torque, which is density * displacement x acceleration (a cross-product is used...
ComputeRSphericalFiniteStrain defines a strain increment and a rotation increment for finite strains ...
Mohr-Coulomb plasticity, nonassociative with hardening/softening.
ComputePlaneSmallStrain defines small strains under generalized plane strain and plane stress assumpt...
Calculates the radial displacement for cylindrical geometries.
ComputeVariableEigenstrain computes an Eigenstrain that is a function of a single variable defined by...
This user object classs Computes equivalent plastic strain.
ComputeMeanThermalExpansionFunctionEigenstrain computes an eigenstrain for thermal expansion accordin...
CappedWeakPlaneStressUpdate performs the return-map algorithm and associated stress updates for plast...
This postprocessor computes the Interaction Integral.
This user object classs Computes equivalent plastic strain rate.
This postprocessor computes an element integral of a component of a material tensor as specified by t...
Exponential hardening The value = _val_res + (val_0 - val_res)*exp(-rate*internal_parameter) Note tha...
ComputeAxisymmetric1DSmallStrain defines small strains in an Axisymmetric 1D problem.
FiniteStrainTensileMulti implements rate-independent associative tensile failure with hardening/softe...
ComputeVolumetricDeformGrad is the class to compute volumetric deformation gradient Modification base...
void TensorMechanicsApp__associateSyntax(Syntax &syntax, ActionFactory &action_factory)
ComputeSmallStrain defines a strain tensor, assuming small strains.
Calculates an Extra-Stress tensor that lies in the plane of an interface defined by the gradient of a...
StressDivergenceTensors mostly copies from StressDivergence.
OutOfPlanePressure is a kernel used to apply pressure in the out-of-plane direction in 2D plane stres...
ComputeRSphericalIncrementalStrain defines a strain increment only for small strains in 1D spherical ...
PoroMechanicsCoupling computes -coefficient*porepressure*grad_test[component].
ComputeLinearElasticStress computes the stress following linear elasticity theory (small strains) ...