24 "The material objects used to compute softening behavior for loading a crack." 25 "Either 1 or 3 models must be specified. If a single model is specified, it is" 26 "used for all directions. If 3 models are specified, they will be used for the" 27 "3 crack directions in sequence");
30 "The stress threshold beyond which cracking occurs. Negative values prevent cracking.");
33 "prescribed_crack_directions", direction,
"Prescribed directions of first cracks");
35 "max_cracks", 3,
"The maximum number of cracks allowed at a material point.");
38 "cracking_neg_fraction <= 1 & cracking_neg_fraction >= 0",
39 "The fraction of the cracking strain at which " 40 "a transition begins during decreasing " 41 "strain to the original stiffness.");
43 "max_stress_correction",
45 "Maximum permitted correction to the predicted stress as a ratio of the " 46 "stress change to the predicted stress from the previous step's damage level. " 47 "Values less than 1 will improve robustness, but not be as accurate.");
50 "shear_retention_factor",
52 "shear_retention_factor>=0 & shear_retention_factor<=1.0",
53 "Fraction of original shear stiffness to be retained after cracking");
54 params.
set<std::vector<MaterialName>>(
"inelastic_models") = {};
56 MooseEnum crackedElasticityType(
"DIAGONAL FULL",
"DIAGONAL");
58 "DIAGONAL",
"Zero out terms coupling with directions orthogonal to a crack (legacy)");
60 "FULL",
"Consistently scale all entries based on damage (recommended)");
62 "cracked_elasticity_type",
63 crackedElasticityType,
64 "Method to modify the local elasticity tensor to account for cracking");
71 _cracking_stress(coupledValue(
"cracking_stress")),
72 _max_cracks(getParam<unsigned
int>(
"max_cracks")),
73 _cracking_neg_fraction(getParam<
Real>(
"cracking_neg_fraction")),
74 _shear_retention_factor(getParam<
Real>(
"shear_retention_factor")),
75 _max_stress_correction(getParam<
Real>(
"max_stress_correction")),
76 _cracked_elasticity_type(
78 _crack_damage(declareProperty<
RealVectorValue>(_base_name +
"crack_damage")),
79 _crack_damage_old(getMaterialPropertyOld<
RealVectorValue>(_base_name +
"crack_damage")),
80 _crack_flags(declareProperty<
RealVectorValue>(_base_name +
"crack_flags")),
81 _crack_rotation(declareProperty<
RankTwoTensor>(_base_name +
"crack_rotation")),
82 _crack_rotation_old(getMaterialPropertyOld<
RankTwoTensor>(_base_name +
"crack_rotation")),
83 _crack_initiation_strain(
84 declareProperty<
RealVectorValue>(_base_name +
"crack_initiation_strain")),
85 _crack_initiation_strain_old(
86 getMaterialPropertyOld<
RealVectorValue>(_base_name +
"crack_initiation_strain")),
87 _crack_max_strain(declareProperty<
RealVectorValue>(_base_name +
"crack_max_strain")),
88 _crack_max_strain_old(getMaterialPropertyOld<
RealVectorValue>(_base_name +
"crack_max_strain"))
91 getParam<MultiMooseEnum>(
"prescribed_crack_directions");
92 if (prescribed_crack_directions.
size() > 0)
94 if (prescribed_crack_directions.
size() > 3)
95 mooseError(
"A maximum of three crack directions may be specified");
96 for (
unsigned int i = 0; i < prescribed_crack_directions.
size(); ++i)
98 for (
unsigned int j = 0;
j < i; ++
j)
99 if (prescribed_crack_directions[i] == prescribed_crack_directions[
j])
100 mooseError(
"Entries in 'prescribed_crack_directions' cannot be repeated");
102 static_cast<unsigned int>(prescribed_crack_directions.
get(i)));
108 std::set<unsigned int> available_dirs = {0, 1, 2};
110 if (available_dirs.erase(dir) != 1)
112 if (available_dirs.size() != 1)
113 mooseError(
"Error in finding remaining available crack direction");
119 "cracked_elasticity_type",
120 "Defaulting to the legacy option of 'DIAGONAL', but the 'FULL' option is preferred");
173 mooseError(
"Number of prescribed crack directions cannot be 2");
194 mooseError(
"ComputeSmearedCrackingStress requires that the elasticity tensor be " 195 "guaranteed isotropic");
197 std::vector<MaterialName> soft_matls = getParam<std::vector<MaterialName>>(
"softening_models");
198 for (
auto soft_matl : soft_matls)
205 paramError(
"softening_models",
"Model " + soft_matl +
" is not a softening model");
214 paramError(
"softening_models",
"Either 1 or 3 softening models must be specified");
220 bool force_elasticity_rotation =
false;
233 model->propagateQpStatefulProperties();
246 force_elasticity_rotation =
true;
262 const Real youngs_modulus =
265 bool cracking_locally_active =
false;
269 if (cracking_stress > 0)
276 for (
unsigned int i = 0; i < 3; ++i)
282 stiffness_ratio_local(i) = 1.0;
290 const Real a = (Ec - Eo) / (4 * etr);
291 const Real b = (Ec + Eo) / 2;
293 stiffness_ratio_local(i) = (2.0 *
a * etr +
b) / Eo;
294 cracking_locally_active =
true;
299 cracking_locally_active =
true;
304 if (cracking_locally_active)
313 const Real c01 = (c0_coupled && c1_coupled ? 1.0 : 0.0);
314 const Real c02 = (c0_coupled && c2_coupled ? 1.0 : 0.0);
315 const Real c12 = (c1_coupled && c2_coupled ? 1.0 : 0.0);
322 : stiffness_ratio_local(0) * youngs_modulus);
326 : stiffness_ratio_local(1) * youngs_modulus);
329 : stiffness_ratio_local(2) * youngs_modulus);
336 const Real & c0 = stiffness_ratio_local(0);
337 const Real & c1 = stiffness_ratio_local(1);
338 const Real & c2 = stiffness_ratio_local(2);
340 const Real c01 = c0 * c1;
341 const Real c02 = c0 * c2;
342 const Real c12 = c1 * c2;
368 if (!cracking_locally_active)
375 const Real youngs_modulus =
380 if (cracking_stress > 0)
385 for (
unsigned i = 0; i < 3; ++i)
396 for (
unsigned i = 0; i < 3; ++i)
406 sigmaPrime.
rotate(
R.transpose());
408 unsigned int num_cracks = 0;
409 for (
unsigned int i = 0; i < 3; ++i)
418 for (
unsigned int i = 0; i < 3; ++i)
420 sigma(i) = sigmaPrime(i, i);
425 const bool met_stress_criterion = (
sigma(i) > cracking_stress);
427 const bool allowed_to_crack = (pre_existing_crack || num_cracks <
_max_cracks);
428 bool new_crack =
false;
430 cracked |= pre_existing_crack;
433 if (met_stress_criterion && !pre_existing_crack && allowed_to_crack)
447 if (new_crack || (pre_existing_crack && loading_existing_crack))
452 strain_in_crack_dir(i),
467 const Real a = (Ec - Eo) / (4.0 * etr);
468 const Real b = 0.5 * (Ec + Eo);
469 const Real c = 0.25 * (Ec - Eo) * etr;
470 sigma(i) = (
a * strain_in_crack_dir(i) +
b) * strain_in_crack_dir(i) +
c;
492 if (num_known_dirs == 0)
494 std::vector<Real> eigval(3, 0.0);
506 strain_in_crack_dir(0) = eigval[2];
507 strain_in_crack_dir(1) = eigval[1];
508 strain_in_crack_dir(2) = eigval[0];
510 else if (num_known_dirs == 1)
526 e2x2(0, 0) = ePrime(1, 1);
527 e2x2(1, 0) = ePrime(2, 1);
528 e2x2(0, 1) = ePrime(1, 2);
529 e2x2(1, 1) = ePrime(2, 2);
534 e2x2.
eigen(e_val2x1, e_vec2x2);
538 1.0, 0.0, 0.0, 0.0, e_vec2x2(0, 1), e_vec2x2(1, 1), 0.0, e_vec2x2(0, 0), e_vec2x2(1, 0));
542 strain_in_crack_dir(0) = ePrime(0, 0);
543 strain_in_crack_dir(1) = e_val2x1(1, 0);
544 strain_in_crack_dir(2) = e_val2x1(0, 0);
546 else if (num_known_dirs == 2 || num_known_dirs == 3)
554 strain_in_crack_dir(0) = ePrime(0, 0);
555 strain_in_crack_dir(1) = ePrime(1, 1);
556 strain_in_crack_dir(2) = ePrime(2, 2);
559 mooseError(
"Invalid number of known crack directions");
565 unsigned int num_known_dirs = 0;
566 for (
unsigned int i = 0; i < 3; ++i)
571 return num_known_dirs;
584 for (
unsigned int i = 0; i < 3; ++i)
587 const Real stress_correction_ratio = (tensor(i, i) -
sigma(i)) / tensor(i, i);
593 tensor(i, i) =
sigma(i);
603 for (
unsigned int i = 0; i < 3; ++i)
ComputeSmearedCrackingStress computes the stress for a finite strain material with smeared cracking...
MaterialProperty< RankFourTensor > & _Jacobian_mult
derivative of stress w.r.t. strain (_dstress_dstrain)
virtual void computeQpStress() override
Compute the stress and store it in the _stress material property for the current quadrature point...
void updateStressTensorForCracking(RankTwoTensor &tensor, const RealVectorValue &sigma)
Updates the full stress tensor to account for the effect of cracking using the provided stresses in t...
ComputeMultipleInelasticStress computes the stress, the consistent tangent operator (or an approximat...
const MaterialProperty< RankTwoTensor > & _rotation_increment
Rotation increment material property.
MaterialProperty< RealVectorValue > & _crack_max_strain
MaterialProperty< RealVectorValue > & _crack_initiation_strain
const unsigned int _max_cracks
Maximum number of cracks permitted at a material point.
bool absoluteFuzzyEqual(const T &var1, const T2 &var2, const T3 &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
const MaterialProperty< RankTwoTensor > & _crack_rotation_old
virtual void finiteStrainRotation(const bool force_elasticity_rotation=false)
Rotate _elastic_strain, _stress, _inelastic_strain, and _Jacobian_mult to the new configuration...
virtual void initialSetup() override
void updateLocalElasticityTensor()
Update the local elasticity tensor (_local_elasticity_tensor) due to the effects of cracking...
registerMooseObject("SolidMechanicsApp", ComputeSmearedCrackingStress)
const MaterialProperty< RealVectorValue > & _crack_max_strain_old
MaterialProperty< RankTwoTensor > & _crack_rotation
VectorValue< Real > column(const unsigned int i) const
const MaterialProperty< RankFourTensor > & _elasticity_tensor
Elasticity tensor material property.
const MaterialProperty< RankTwoTensor > & _strain_increment
bool previouslyCracked()
Check to see whether there was cracking in any diretion in the previous time step.
std::vector< SmearedCrackSofteningBase * > _softening_models
The user-supplied list of softening models to be used in the 3 crack directions.
unsigned int size() const
ComputeSmearedCrackingStress(const InputParameters ¶meters)
virtual void initQpStatefulProperties() override
static InputParameters validParams()
std::vector< StressUpdateBase * > _models
The user supplied list of inelastic models to use in the simulation.
void fillFromInputVector(const std::vector< T > &input, FillMethod fill_method)
std::vector< Real > _local_elastic_vector
Vector helper to update local elasticity tensor.
static RankTwoTensorTempl Identity()
const std::string _elasticity_tensor_name
Name of the elasticity tensor material property.
void eigen(ColumnMajorMatrixTempl< Real > &eval, ColumnMajorMatrixTempl< Real > &evec) const
void rotate(const RankTwoTensorTempl< Real > &R)
enum ComputeSmearedCrackingStress::CrackedElasticityType _cracked_elasticity_type
void computeCrackStrainAndOrientation(RealVectorValue &strain_in_crack_dir)
Compute the crack strain in the crack coordinate system.
const VariableValue & _cracking_stress
Input parameters for smeared crack models.
const Real _max_stress_correction
Controls the maximum amount that the damaged elastic stress is corrected to folow the release model d...
virtual void initQpStatefulProperties() override
bool absoluteFuzzyLessThan(const T &var1, const T2 &var2, const T3 &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
MaterialProperty< RealVectorValue > & _crack_flags
Vector of values going from 1 to 0 as crack damage accumulates.
void paramError(const std::string ¶m, Args... args) const
MaterialProperty< RankTwoTensor > & _inelastic_strain
The sum of the inelastic strains that come from the plastic models.
std::string stringify(const T &t)
CrackedElasticityType
Enum defining the method used to adjust the elasticity tensor for cracking.
void rotate(const TypeTensor< T > &R)
const PertinentGeochemicalSystem model(database, {"H2O", "H+", "HCO3-", "O2(aq)", "Ca++", ">(s)FeOH", "radius_neg1", "radius_neg1.5"}, {"Calcite"}, {}, {"Calcite_asdf"}, {"CH4(aq)"}, {">(s)FeOCa+"}, "O2(aq)", "e-")
MaterialBase & getMaterialByName(const std::string &name, bool no_warn=false, bool no_dep=false)
MaterialProperty< Real > & _material_timestep_limit
virtual unsigned int getNumKnownCrackDirs() const
Get the number of known crack directions.
SmearedCrackSofteningBase is the base class for a set of models that define the softening behavior of...
static const std::string R
bool isParamSetByUser(const std::string &nm) const
unsigned int get(unsigned int i) const
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
virtual void initialSetup() override
const Real _cracking_neg_fraction
Defines transition to changed stiffness during unloading.
MaterialProperty< RealVectorValue > & _crack_damage
const Real _shear_retention_factor
Controls the amount of shear retained.
void addDocumentation(const std::string &name, const std::string &doc)
const MaterialProperty< RealVectorValue > & _crack_damage_old
std::vector< unsigned int > _prescribed_crack_directions
User-prescribed cracking directions.
const MaterialProperty< RealVectorValue > & _crack_initiation_strain_old
MaterialProperty< RankTwoTensor > & _elastic_strain
Elastic strain material property.
void mooseError(Args &&... args) const
const bool _perform_finite_strain_rotations
after updateQpState, rotate the stress, elastic_strain, inelastic_strain and Jacobian_mult using _rot...
static const std::complex< double > j(0, 1)
Complex number "j" (also known as "i")
MaterialProperty< RankTwoTensor > & _stress
Stress material property.
static InputParameters validParams()
void paramWarning(const std::string ¶m, Args... args) const
RankFourTensor _local_elasticity_tensor
bool hasGuaranteedMaterialProperty(const MaterialPropertyName &prop, Guarantee guarantee)
virtual void computeQpStressIntermediateConfiguration()
Compute the stress for the current QP, but do not rotate tensors from the intermediate configuration ...
const MaterialProperty< RankTwoTensor > & _inelastic_strain_old
old value of inelastic strain
virtual void updateCrackingStateAndStress()
Update all cracking-related state variables and the stress tensor due to cracking in all directions...
const MaterialProperty< RankTwoTensor > & _elastic_strain_old
Strain tensors.
void ErrorVector unsigned int