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;
};