ADLAROMANCEStressUpdateBase.h

Go to the documentation of this file.

//* 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 "ADRadialReturnCreepStressUpdateBase.h"
 
#define usingADLAROMANCEStressUpdateBase                                                           \
  usingRadialReturnCreepStressUpdateBaseMembers;                                                   \
  using ADLAROMANCEStressUpdateBase<compute_stage>::getTransform;                                  \
  using ADLAROMANCEStressUpdateBase<compute_stage>::getTransformCoefs;                             \
  using ADLAROMANCEStressUpdateBase<compute_stage>::getInputLimits;                                \
  using ADLAROMANCEStressUpdateBase<compute_stage>::getCoefs
 
template <ComputeStage>
class ADLAROMANCEStressUpdateBase;
 
declareADValidParams(ADLAROMANCEStressUpdateBase);
 
enum class ROMInputTransform
{
  LINEAR,
  LOG,
  EXP
};
 
template <ComputeStage compute_stage>
class ADLAROMANCEStressUpdateBase : public ADRadialReturnCreepStressUpdateBase<compute_stage>
{
public:
  static InputParameters validParams();
 
  ADLAROMANCEStressUpdateBase(const InputParameters & parameters);
 
protected:
  virtual void initialSetup() override;
 
  virtual void initQpStatefulProperties() override;
 
  virtual ADReal computeResidual(const ADReal & effective_trial_stress,
                                 const ADReal & scalar) override;
 
  virtual ADReal computeDerivative(const ADReal & /*effective_trial_stress*/,
                                   const ADReal & /*scalar*/) override
  {
    return _derivative;
  }
 
  virtual void computeStressFinalize(const ADRankTwoTensor & plastic_strain_increment) override;
 
  virtual Real computeTimeStepLimit() override;
 
  void computeROMStrainRate(const Real dt,
                            const Real & mobile_dislocations_old,
                            const Real & immobile_dislocations_old,
                            const ADReal & trial_stress,
                            const Real & effective_strain_old,
                            const ADReal & temperature,
                            const ADReal & environmental,
                            ADReal & mobile_dislocation_increment,
                            ADReal & immobile_dislocation_increment,
                            ADReal & rom_effective_strain,
                            ADReal & rom_effective_strain_derivative);
 
  void checkInputWindows(std::vector<ADReal> & input);
 
  void convertInput(const std::vector<ADReal> & input,
                    std::vector<std::vector<ADReal>> & converted,
                    std::vector<std::vector<ADReal>> & dconverted);
 
  void buildPolynomials(const std::vector<std::vector<ADReal>> & rom_inputs,
                        const std::vector<std::vector<ADReal>> & drom_inputs,
                        std::vector<std::vector<std::vector<ADReal>>> & polynomial_inputs,
                        std::vector<std::vector<std::vector<ADReal>>> & dpolynomial_inputs);
 
  void computeValues(const std::vector<std::vector<Real>> & coefs,
                     const std::vector<std::vector<std::vector<ADReal>>> & polynomial_inputs,
                     const std::vector<std::vector<std::vector<ADReal>>> & dpolynomial_inputs,
                     std::vector<ADReal> & rom_outputs,
                     std::vector<ADReal> & drom_outputs);
 
  void convertOutput(const Real dt,
                     const std::vector<ADReal> & old_input_values,
                     const std::vector<ADReal> & rom_outputs,
                     const std::vector<ADReal> & drom_outputs,
                     std::vector<ADReal> & input_value_increments,
                     std::vector<ADReal> & dinput_value_increments);
 
  ADReal
  computePolynomial(const ADReal & value, const unsigned int degree, const bool derivative = false);
 
  /*
   * Calculates and returns the transformed limits for the ROM calculations
   * @return Multi-dimentional vector of transformed limits
   */
  std::vector<std::vector<std::vector<Real>>> getTransformedLimits() const;
 
  /*
   * Calculates and returns vector utilized in assign values
   * @return Multi-dimentional vector that preallocates calculations for polynomial calculation
   */
  std::vector<std::vector<unsigned int>> getMakeFrameHelper() const;
 
  /*
   * Returns vector of the functions to use for the conversion of input variables.
   * @return vector of the functions to use for the conversion of input variables.
   */
  virtual std::vector<std::vector<ROMInputTransform>> getTransform() = 0;
 
  /*
   * Returns factors for the functions for the conversion functions given in getTransform
   * @return factors for the functions for the conversion functions given in getTransform
   */
  virtual std::vector<std::vector<Real>> getTransformCoefs() = 0;
 
  /* Returns human-readable limits for the inputs. Inputs ordering is
   * 0: mobile_old
   * 1: immobile_old
   * 2: trial stress,
   * 3: effective strain old,
   * 4: temperature
   * 5: environmental factor (optional)
   * @return human-readable limits for the inputs
   */
  virtual std::vector<std::vector<Real>> getInputLimits() = 0;
 
  /*
   * Material specific coefficients multiplied by the Legendre polynomials for each of the input
   * variables
   * @return Legendre polynomial coefficients
   */
  virtual std::vector<std::vector<Real>> getCoefs() = 0;
 
  const ADVariableValue & _temperature;
 
  const ADVariableValue & _environmental;
 
  const Real _window;
 
  const enum class WindowFailure { ERROR, WARN, IGNORE } _window_failure;
 
  const bool _extrapolate_stress;
 
  const bool _verbose;
 
  ADMaterialProperty(Real) & _mobile_dislocations;
  const MaterialProperty<Real> & _mobile_dislocations_old;
 
  const Real _initial_mobile_dislocations;
 
  const Real _max_mobile_increment;
 
  const Function * const _mobile_function;
 
  ADReal _mobile_dislocation_increment;
 
  Real _mobile_old;
 
  ADMaterialProperty(Real) & _immobile_dislocations;
  const MaterialProperty<Real> & _immobile_dislocations_old;
 
  const Real _initial_immobile_dislocations;
 
  const Real _max_immobile_increment;
 
  const Function * const _immobile_function;
 
  ADReal _immobile_dislocation_increment;
 
  Real _immobile_old;
 
  const unsigned int _stress_index;
 
  const Function * const _creep_strain_old_forcing_function;
 
  unsigned int _num_inputs;
 
  unsigned int _num_outputs;
 
  unsigned int _degree;
 
  unsigned int _num_coefs;
 
  std::vector<std::vector<ROMInputTransform>> _transform;
 
  std::vector<std::vector<Real>> _transform_coefs;
 
  std::vector<std::vector<Real>> _input_limits;
 
  std::vector<std::vector<Real>> _coefs;
 
  bool _use_env;
 
  std::vector<std::vector<std::vector<Real>>> _transformed_limits;
 
  std::vector<std::vector<unsigned int>> _makeframe_helper;
 
  ADMaterialProperty(Real) & _creep_rate;
 
  MaterialProperty<Real> & _failed;
 
  ADReal _derivative;
 
  usingRadialReturnCreepStressUpdateBaseMembers;
};