CrystalPlasticityStressUpdateBase.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* 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 "Material.h"
#include "RankTwoTensor.h"
#include "RankFourTensor.h"
#include "DelimitedFileReader.h"
 
class CrystalPlasticityStressUpdateBase : public Material
{
public:
  static InputParameters validParams();
 
  CrystalPlasticityStressUpdateBase(const InputParameters & parameters);
 
  void setQp(const unsigned int & qp);
 
  void setSubstepDt(const Real & substep_dt);
 
  virtual void resetQpProperties() final {}
  virtual void resetProperties() final {}
 
  virtual void initQpStatefulProperties() override;
  virtual void setMaterialVectorSize();
 
  virtual void getSlipSystems();
 
  void transformHexagonalMillerBravaisSlipSystems(const MooseUtils::DelimitedFileReader & reader);
 
  void calculateFlowDirection(const RankTwoTensor & crysrot);
 
  void calculateShearStress(const RankTwoTensor & pk2,
                            const RankTwoTensor & inverse_eigenstrain_deformation_grad,
                            const unsigned int & num_eigenstrains);
 
  virtual void calculateTotalPlasticDeformationGradientDerivative(
      RankFourTensor & dfpinvdpk2,
      const RankTwoTensor & inverse_plastic_deformation_grad_old,
      const RankTwoTensor & inverse_eigenstrain_deformation_grad_old,
      const unsigned int & num_eigenstrains);
 
  void calculateSchmidTensor(const unsigned int & number_dislocation_systems,
                             const std::vector<RealVectorValue> & plane_normal_vector,
                             const std::vector<RealVectorValue> & direction_vector,
                             std::vector<RankTwoTensor> & schmid_tensor,
                             const RankTwoTensor & crysrot);
 
  void sortCrossSlipFamilies();
 
  unsigned int identifyCrossSlipFamily(const unsigned int index);
 
  virtual void setInitialConstitutiveVariableValues() {}
 
  virtual void setSubstepConstitutiveVariableValues() {}
 
  virtual void updateSubstepConstitutiveVariableValues() {}
 
  virtual bool calculateSlipRate() = 0;
 
  virtual void calculateEquivalentSlipIncrement(RankTwoTensor & /*equivalent_slip_increment*/);
 
  virtual void calculateConstitutiveSlipDerivative(std::vector<Real> & /*dslip_dtau*/) = 0;
 
  virtual void cacheStateVariablesBeforeUpdate() {}
 
  virtual void calculateStateVariableEvolutionRateComponent() {}
 
  virtual bool updateStateVariables() = 0;
 
  virtual void calculateSlipResistance() {}
 
  virtual bool areConstitutiveStateVariablesConverged() { return true; }
 
  virtual bool isConstitutiveStateVariableConverged(const std::vector<Real> & current_var,
                                                    const std::vector<Real> & var_before_update,
                                                    const std::vector<Real> & previous_substep_var,
                                                    const Real & tolerance);
 
protected:
  const std::string _base_name;
 
  const enum class CrystalLatticeType { BCC, FCC, HCP } _crystal_lattice_type;
 
  const std::vector<Real> _unit_cell_dimension;
 
  const unsigned int _number_slip_systems;
 
  std::string _slip_sys_file_name;
 
  const Real _number_cross_slip_directions;
  const Real _number_cross_slip_planes;
 
  Real _rel_state_var_tol;
  Real _slip_incr_tol;
  Real _resistance_tol;
  Real _zero_tol;
 
  MaterialProperty<std::vector<Real>> & _slip_resistance;
  const MaterialProperty<std::vector<Real>> & _slip_resistance_old;
 
  MaterialProperty<std::vector<Real>> & _slip_increment;
 
  std::vector<RealVectorValue> _slip_direction;
  std::vector<RealVectorValue> _slip_plane_normal;
  MaterialProperty<std::vector<RankTwoTensor>> & _flow_direction;
 
  MaterialProperty<std::vector<Real>> & _tau;
 
  const bool _print_convergence_message;
 
  Real _substep_dt;
 
  std::vector<std::vector<unsigned int>> _cross_slip_familes;
 
  bool _calculate_cross_slip;
};