doxygen/modules/SolidModel_8h_source.html

//* This file is part of the MOOSE framework

//* https://www.mooseframework.org

//*

//* All rights reserved, see COPYRIGHT for full restrictions

//* https://github.com/idaholab/moose/blob/master/COPYRIGHT

//*

//* Licensed under LGPL 2.1, please see LICENSE for details

//* https://www.gnu.org/licenses/lgpl-2.1.html


#pragma once


#include "DerivativeMaterialInterface.h"

#include "SymmTensor.h"

#include "RankTwoTensor.h"


// Forward declarations

class ConstitutiveModel;

class SolidModel;

class SymmElasticityTensor;

class PiecewiseLinear;

class VolumetricModel;

namespace SolidMechanics

{

class Element;

}


template <>

InputParameters validParams<SolidModel>();


class SolidModel : public DerivativeMaterialInterface<Material>

{

public:

  SolidModel(const InputParameters & parameters);

  virtual ~SolidModel();


  virtual void initStatefulProperties(unsigned n_points);


  virtual void applyThermalStrain();

  virtual void applyVolumetricStrain();


  static void

  rotateSymmetricTensor(const ColumnMajorMatrix & R, const SymmTensor & T, SymmTensor & result);


  enum CRACKING_RELEASE

  {

    CR_ABRUPT = 0,

    CR_EXPONENTIAL,

    CR_POWER,

    CR_UNKNOWN

  };


  const QBase * qrule() { return _qrule; }

  const Point & q_point(unsigned i) const { return _q_point[i]; }

  Real JxW(unsigned i) const { return _JxW[i]; }


protected:

  Moose::CoordinateSystemType _coord_type;


  const std::string _appended_property_name;


  bool _bulk_modulus_set;

  bool _lambda_set;

  bool _poissons_ratio_set;

  bool _shear_modulus_set;

  bool _youngs_modulus_set;


  Real _bulk_modulus;

  Real _lambda;

  Real _poissons_ratio;

  Real _shear_modulus;

  Real _youngs_modulus;


  const Function * _youngs_modulus_function;

  const Function * _poissons_ratio_function;


  const CRACKING_RELEASE _cracking_release;

  Real _cracking_stress;

  const Real _cracking_residual_stress;

  const Real _cracking_beta;

  const std::string _compute_method;

  const Function * const _cracking_stress_function;


  Real _cracking_alpha;

  std::vector<unsigned int> _active_crack_planes;

  const unsigned int _max_cracks;

  const Real _cracking_neg_fraction;

  // std::map<Point, unsigned> _cracked_this_step_count;

  // std::map<Point, unsigned> _cracked_this_step;


  const bool _has_temp;

  const VariableValue & _temperature;

  const VariableValue & _temperature_old;

  const VariableGradient & _temp_grad;

  const Real _alpha;

  const Function * _alpha_function;

  PiecewiseLinear * _piecewise_linear_alpha_function;

  bool _has_stress_free_temp;

  Real _stress_free_temp;

  bool _mean_alpha_function;

  Real _ref_temp;


  std::map<SubdomainID, std::vector<MooseSharedPointer<VolumetricModel>>> _volumetric_models;

  std::set<std::string> _dep_matl_props;


  MaterialProperty<SymmTensor> & _stress;


private:

  const MaterialProperty<SymmTensor> & _stress_old_prop;


protected:

  SymmTensor _stress_old;


  MaterialProperty<SymmTensor> & _total_strain;

  const MaterialProperty<SymmTensor> & _total_strain_old;


  MaterialProperty<SymmTensor> & _elastic_strain;

  const MaterialProperty<SymmTensor> & _elastic_strain_old;


  MaterialProperty<RealVectorValue> * _crack_flags;

  const MaterialProperty<RealVectorValue> * _crack_flags_old;

  RealVectorValue _crack_flags_local;

  MaterialProperty<RealVectorValue> * _crack_count;

  const MaterialProperty<RealVectorValue> * _crack_count_old;

  MaterialProperty<ColumnMajorMatrix> * _crack_rotation;

  const MaterialProperty<ColumnMajorMatrix> * _crack_rotation_old;

  MaterialProperty<RealVectorValue> * _crack_strain;

  const MaterialProperty<RealVectorValue> * _crack_strain_old;

  MaterialProperty<RealVectorValue> * _crack_max_strain;

  const MaterialProperty<RealVectorValue> * _crack_max_strain_old;

  ColumnMajorMatrix _principal_strain;


  MaterialProperty<SymmElasticityTensor> & _elasticity_tensor;

  MaterialProperty<SymmElasticityTensor> & _Jacobian_mult;


  // Accumulate derivatives of strain tensors with respect to Temperature into this

  SymmTensor _d_strain_dT;


  // The derivative of the stress with respect to Temperature

  MaterialProperty<SymmTensor> & _d_stress_dT;


  SymmTensor _total_strain_increment;

  SymmTensor _mechanical_strain_increment;

  SymmTensor _strain_increment;


  const bool _compute_JIntegral;

  const bool _compute_InteractionIntegral;


  // These are used in calculation of the J integral

  MaterialProperty<Real> * _SED;

  const MaterialProperty<Real> * _SED_old;

  MaterialProperty<RankTwoTensor> * _Eshelby_tensor;

  MaterialProperty<RealVectorValue> * _J_thermal_term_vec;


  // This is used in calculation of the J Integral and Interaction Integral

  MaterialProperty<Real> * _current_instantaneous_thermal_expansion_coef;


  virtual void initQpStatefulProperties();


  virtual void initialSetup();

  virtual void timestepSetup();

  virtual void jacobianSetup();


  virtual void computeProperties();


  void computeElasticityTensor();

  virtual bool updateElasticityTensor(SymmElasticityTensor & tensor);


  virtual void elementInit() {}


  virtual void modifyStrainIncrement();


  virtual void crackingStrainDirections();


  virtual unsigned int getNumKnownCrackDirs() const;


  virtual void computeStress()

  {

    mooseError("SolidModel::computeStress must be defined by the derived class");

  }


  // Compute Eshelby tensor, used in J Integral calculation

  virtual void computeEshelby();


  // Compute strain energy density, used in Eshelby tensor calculation

  virtual void computeStrainEnergyDensity();


  // Compute quantity used in thermal term of J Integral

  virtual void computeThermalJvec();


  // Compute current thermal expansion coefficient, used in J Integral and Interaction Integral

  virtual void computeCurrentInstantaneousThermalExpansionCoefficient();


  /*

   * Determine whether new cracks have formed.

   * Rotate old and new stress to global, if cracking active

   */

  virtual void crackingStressRotation();


  virtual Real computeCrackFactor(int i, Real & sigma, Real & flagVal);


  virtual void finalizeStress();


  virtual void computePreconditioning();


  void applyCracksToTensor(SymmTensor & tensor, const RealVectorValue & sigma);


  void elasticityTensor(SymmElasticityTensor * e);


  SymmElasticityTensor * elasticityTensor() const { return _local_elasticity_tensor; }


  const SolidMechanics::Element * element() const { return _element; }


  int delta(int i, int j) const { return i == j; }


  template <typename T>

  MaterialProperty<T> & createProperty(const std::string & prop_name)

  {

    std::string name(prop_name + _appended_property_name);

    return declareProperty<T>(name);

  }


  template <typename T>

  const MaterialProperty<T> & getPropertyOld(const std::string & prop_name)

  {

    std::string name(prop_name + _appended_property_name);

    return getMaterialPropertyOld<T>(name);

  }


  virtual void checkElasticConstants();


  virtual void createElasticityTensor();


  std::vector<SubdomainID> _block_id;


  std::map<SubdomainID, MooseSharedPointer<ConstitutiveModel>> _constitutive_model;

  // This set keeps track of the dynamic memory allocated in this object

  std::set<MooseSharedPointer<ConstitutiveModel>> _models_to_free;

  bool _constitutive_active;


  virtual void computeConstitutiveModelStress();


  void createConstitutiveModel(const std::string & cm_name);


  bool & _step_zero;

  bool & _step_one;


private:

  void computeCrackStrainAndOrientation(ColumnMajorMatrix & principal_strain);


  SolidMechanics::Element * createElement();


  SolidMechanics::Element * _element;


  SymmElasticityTensor * _local_elasticity_tensor;

};