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 _aqSSE;
  Real _aqSPD;
  Real _aqSCD;

  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;

  MaterialProperty<Real> & _elastic_strain_energy;
  MaterialProperty<Real> & _plastic_dissipation;
  MaterialProperty<Real> & _creep_dissipation;

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