AbaqusUMATStress.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 "ComputeGeneralStressBase.h"
#include "DynamicLibraryLoader.h"
#include "ComputeFiniteStrain.h"
#include "RotationTensor.h"
#include "AnalysisStepUOInterface.h"
 
class AnalysisStepUserObject;
 
class AbaqusUMATStress : public ComputeGeneralStressBase, public AnalysisStepUOInterface
{
public:
  static InputParameters validParams();
 
  AbaqusUMATStress(const InputParameters & parameters);
 
  void initialSetup() override;
 
  void computeProperties() override;
 
protected:
  typedef void (*umat_t)(Real STRESS[],
                         Real STATEV[],
                         Real DDSDDE[],
                         Real * SSE,
                         Real * SPD,
                         Real * SCD,
                         Real * RPL,
                         Real DDSDDT[],
                         Real DRPLDE[],
                         Real * DRPLDT,
                         Real STRAN[],
                         Real DSTRAN[],
                         Real TIME[],
                         Real * DTIME,
                         Real * TEMP,
                         Real * DTEMP,
                         Real PREDEF[],
                         Real DPRED[],
                         char * CMNAME,
                         int * NDI,
                         int * NSHR,
                         int * NTENS,
                         int * NSTATV,
                         Real PROPS[],
                         int * NPROPS,
                         Real COORDS[],
                         Real DROT[],
                         Real * PNEWDT,
                         Real * CELENT,
                         Real DFGRD0[],
                         Real DFGRD1[],
                         int * NOEL,
                         unsigned int * NPT,
                         int * LAYER,
                         int * KSPT,
                         int * KSTEP,
                         int * KINC);
 
  // The plugin file name
  FileName _plugin;
 
  // The plugin library wrapper
  DynamicLibraryLoader _library;
 
  // Function pointer to the dynamically loaded function
  umat_t _umat;
 
  Real _aqRPL;
 
  Real _aqDRPLDT;
 
  Real _aqPNEWDT;
 
  Real _aqDTIME;
 
  Real _aqTEMP;
 
  Real _aqDTEMP;
 
  Real _aqCELENT;
 
  char _aqCMNAME[80];
 
  int _aqNDI;
 
  int _aqNSHR;
 
  int _aqNTENS;
 
  int _aqNSTATV;
 
  int _aqNOEL;
 
  unsigned int _aqNPT;
 
  int _aqLAYER;
 
  int _aqKSPT;
 
  int _aqKSTEP;
 
  int _aqKINC;
 
  // An array containing the solution-dependent state variables
  std::vector<Real> _aqSTATEV;
 
  std::vector<Real> _aqDDSDDT;
 
  std::vector<Real> _aqDRPLDE;
 
  std::vector<Real> _aqSTRAN;
 
  std::vector<Real> _aqDFGRD0;
 
  std::vector<Real> _aqDFGRD1;
 
  std::vector<Real> _aqSTRESS;
 
  std::vector<Real> _aqDDSDDE;
 
  std::vector<Real> _aqDSTRAN;
 
  std::vector<Real> _aqPROPS;
 
  std::array<Real, 2> _aqTIME;
 
  std::array<Real, 3> _aqCOORDS;
 
  std::vector<Real> _aqDROT;
 
  int _aqNPROPS;
 
  std::vector<Real> _aqPREDEF;
 
  std::vector<Real> _aqDPRED;
 
  void initQpStatefulProperties() override;
  void computeQpStress() override;
 
  const MaterialProperty<RankTwoTensor> & _stress_old;
  const MaterialProperty<RankTwoTensor> & _total_strain_old;
  const OptionalMaterialProperty<RankTwoTensor> & _strain_increment;
 
  MaterialProperty<RankFourTensor> & _jacobian_mult;
 
  const OptionalMaterialProperty<RankTwoTensor> & _Fbar;
  const OptionalMaterialProperty<RankTwoTensor> & _Fbar_old;
 
  MaterialProperty<std::vector<Real>> & _state_var;
  const MaterialProperty<std::vector<Real>> & _state_var_old;
 
  // energy quantities
  MaterialProperty<Real> & _elastic_strain_energy;
  const MaterialProperty<Real> & _elastic_strain_energy_old;
  MaterialProperty<Real> & _plastic_dissipation;
  const MaterialProperty<Real> & _plastic_dissipation_old;
  MaterialProperty<Real> & _creep_dissipation;
  const MaterialProperty<Real> & _creep_dissipation_old;
 
  MaterialProperty<Real> & _material_timestep;
 
  // Time step rotation increment
  const OptionalMaterialProperty<RankTwoTensor> & _rotation_increment;
  const OptionalMaterialProperty<RankTwoTensor> & _rotation_increment_old;
 
  // Coupled temperature field
  const VariableValue & _temperature;
  const VariableValue & _temperature_old;
 
  // Coupled user-defined field
  const std::vector<const VariableValue *> _external_fields;
  const std::vector<const VariableValue *> _external_fields_old;
 
  // External field names
  std::vector<VariableName> _external_field_names;
 
  // Number of external fields provided by the user
  const std::size_t _number_external_fields;
 
  const std::vector<MaterialPropertyName> _external_property_names;
  const std::size_t _number_external_properties;
  std::vector<const MaterialProperty<Real> *> _external_properties;
  std::vector<const MaterialProperty<Real> *> _external_properties_old;
 
  const bool _use_one_based_indexing;
 
  const bool _use_orientation;
  const RotationTensor _R;
  MaterialProperty<RankTwoTensor> & _total_rotation;
  const MaterialProperty<RankTwoTensor> & _total_rotation_old;
 
private:
  const ComputeFiniteStrain::DecompMethod _decomposition_method;
 
  const AnalysisStepUserObject * _step_user_object;
};