Protected Class

[Emmanuel-324]

Check these boxes if you have followed the posting rules.

• Q&A General is the most appropriate section for my question
• I have consulted the posting Guidelines on the Discussions front page
• I have searched the Discussions forum and my question has not been asked before
• I have searched the MOOSE website and the documentation does not answer my question
• I have formatted my post following the posting guidelines (screenshots as a last resort, triple back quotes around pasted text)

Question

What is the right way to get a value from the protected class in MOOSE if it's possible.

I added this line in one of the source codes

public:
  // Getter for slip increment
  const std::vector<Real>& getSlipIncrement() const { return _slip_increment.value();}

I get this error when I try to compile

/home/emmanuel324/projects/moose/modules/solid_mechanics/build/header_symlinks/CrystalPlasticityStressUpdateBase.h:247:78: error: 'class MaterialProperty<std::vector<double> >' has no member
 named 'value'; did you mean 'MooseArray<std::vector<double> > MaterialPropertyBase<std::vector<double>, false>::_value'? (not accessible from this context)
  247 |   const std::vector<Real>& getSlipIncrement() const { return _slip_increment.value();}
      |                                                                              ^~~~~
In file included from /home/emmanuel324/projects/moose/framework/build/header_symlinks/MaterialData.h:12,
                 from /home/emmanuel324/projects/moose/framework/build/header_symlinks/BlockRestrictable.h:15,
                 from /home/emmanuel324/projects/moose/framework/build/header_symlinks/MaterialBase.h:14,
                 from /home/emmanuel324/projects/moose/framework/build/header_symlinks/Material.h:13,
                 from /home/emmanuel324/projects/moose/modules/solid_mechanics/build/header_symlinks/ADSmearedCrackSofteningBase.h:14,
                 from /home/emmanuel324/projects/moose/modules/solid_mechanics/build/header_symlinks/ADAbruptSoftening.h:12,
                 from /home/emmanuel324/projects/moose/modules/solid_mechanics/src/materials/ADAbruptSoftening.C:10,
                 from /home/emmanuel324/projects/moose/modules/solid_mechanics/build/unity_src/materials_Unity.C:2:
/home/emmanuel324/projects/moose/framework/build/header_symlinks/MaterialProperty.h:199:44: note: declared protected here
  199 |   MooseArray<Moose::GenericType<T, is_ad>> _value;
      |                                            ^~~~~~
make: *** [/home/emmanuel324/projects/moose/modules/solid_mechanics/build/unity_src/materials_Unity.x86_64-pc-linux-gnu.opt.lo] Error 1
(python-stack) [emmanuel324@tinkercliffs1 belson]$ 

Any suggestions

[GiudGiud]

Hello

A material property in moose is an array (indexed by quadrature point) of the type of the property. So here, you have an array of std::vector.

And you are trying to cast it into a vector, with this value() function which does not exist for arrays.
So instead, I think you mean to index into the array? Which quadrature point value do you need?

[Emmanuel-324]

Next

/home/emmanuel324/My_Current_Work/projects/moose/modules/solid_mechanics/src/materials/crystal_plasticity/ComputeMultipleCrystalPlasticityStress.C: In constructor 'ComputeMultipleCrystalPlas
ticityStress::ComputeMultipleCrystalPlasticityStress(const InputParameters&)':
/home/emmanuel324/My_Current_Work/projects/moose/modules/solid_mechanics/src/materials/crystal_plasticity/ComputeMultipleCrystalPlasticityStress.C:113:1: error: expected identifier before '{' token
  113 | {
      | ^
/home/emmanuel324/My_Current_Work/projects/moose/modules/solid_mechanics/src/materials/crystal_plasticity/ComputeMultipleCrystalPlasticityStress.C: In member function 'virtual void ComputeMultipleCrystalPlasticityStress::initQpStatefulProperties()':
/home/emmanuel324/My_Current_Work/projects/moose/modules/solid_mechanics/src/materials/crystal_plasticity/ComputeMultipleCrystalPlasticityStress.C:148:19: error: request for member 'resize' in '(&((ComputeMultipleCrystalPlasticityStress*)this)->ComputeMultipleCrystalPlasticityStress::_acc_slip)->MaterialProperty<double>::<anonymous>.MaterialPropertyBase<double, false>::operator
[](qp)', which is of non-class type 'Moose::GenericType<double, false>' {aka 'double'}
  148 |     _acc_slip[qp].resize(_num_slip_systems, 0.0); // Initialize with zeros
      |                   ^~~~~~
/home/emmanuel324/My_Current_Work/projects/moose/modules/solid_mechanics/src/materials/crystal_plasticity/ComputeMultipleCrystalPlasticityStress.C: In member function 'void ComputeMultipleCr
ystalPlasticityStress::solveStateVariables()':
/home/emmanuel324/My_Current_Work/projects/moose/modules/solid_mechanics/src/materials/crystal_plasticity/ComputeMultipleCrystalPlasticityStress.C:376:60: error: 'MaterialProperty<std::vecto
r<double> >& CrystalPlasticityStressUpdateBase::_slip_increment' is protected within this context
  376 |     const std::vector<Real> & slip_increment = _models[i]->_slip_increment[_qp];
      |                                                            ^~~~~~~~~~~~~~~
In file included from /home/emmanuel324/My_Current_Work/projects/moose/modules/solid_mechanics/build/header_symlinks/ComputeMultipleCrystalPlasticityStress.h:14,
                 from /home/emmanuel324/My_Current_Work/projects/moose/modules/solid_mechanics/src/materials/crystal_plasticity/ComputeMultipleCrystalPlasticityStress.C:10:
/home/emmanuel324/My_Current_Work/projects/moose/modules/solid_mechanics/build/header_symlinks/CrystalPlasticityStressUpdateBase.h:222:42: note: declared protected here
  222 |    MaterialProperty<std::vector<Real>> & _slip_increment;
      |                                          ^~~~~~~~~~~~~~~
/home/emmanuel324/My_Current_Work/projects/moose/modules/solid_mechanics/src/materials/crystal_plasticity/ComputeMultipleCrystalPlasticityStress.C:380:21: error: invalid types 'Moose::Generi
cType<double, false> {aka double}[size_t {aka long unsigned int}]' for array subscript
  380 |       _acc_slip[_qp][j] += slip_increment[j];
      |                     ^
/home/emmanuel324/My_Current_Work/projects/moose/modules/solid_mechanics/src/materials/crystal_plasticity/ComputeMultipleCrystalPlasticityStress.C: In member function 'void ComputeMultipleCr
ystalPlasticityStress::calculateResidual()':
/home/emmanuel324/My_Current_Work/projects/moose/modules/solid_mechanics/src/materials/crystal_plasticity/ComputeMultipleCrystalPlasticityStress.C:530:24: error: 'class MaterialProperty<doub
le>' has no member named 'begin'
  530 |    std::fill(_acc_slip.begin(), _acc_slip.end(), std::vector<Real>(_num_slip_systems, 0.0));
      |                        ^~~~~

[GiudGiud]

first one is a missing symbol, maybe a comma

_acc_slip[qp] is not a vector.
did you declare it as a single valued material property? (with <double> in the template instantiation)

[Emmanuel-324]

This is my header file now. @GiudGiud

//* 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 "ComputeFiniteStrainElasticStress.h"

#include "CrystalPlasticityStressUpdateBase.h"
#include "ComputeCrystalPlasticityEigenstrainBase.h"

#include "RankTwoTensor.h"
#include "RankFourTensor.h"

/**
 * ComputeMultipleCrystalPlasticityStress (used together with CrystalPlasticityStressUpdateBase)
 * uses the multiplicative decomposition of the deformation gradient and solves the PK2 stress
 * residual equation at the intermediate configuration to evolve the material state. The internal
 * variables are updated using an iterative predictor-corrector algorithm. Backward Euler
 * integration rule is used for the rate equations.
 *
 * This material that is not called by MOOSE because of the compute=false flag
 * set in the parameter list.
 */
class ComputeMultipleCrystalPlasticityStress : public ComputeFiniteStrainElasticStress
{
public:
  static InputParameters validParams();

  ComputeMultipleCrystalPlasticityStress(const InputParameters & parameters);

  virtual void initialSetup() override;

protected:
  virtual void computeQpStress() override;

  /**
   * Updates the stress (PK2) at a quadrature point by calling constiutive
   * relationship as defined in a child class
   * Solves stress residual equation using Newton - Raphson: Updates slip
   * system resistances iteratively
   */
  virtual void updateStress(RankTwoTensor & cauchy_stress, RankFourTensor & jacobian_mult);

  /**
   * initializes the stateful properties such as PK2 stress, resolved shear
   * stress, plastic deformation gradient, slip system resistances, etc.
   * This class is often overwritten by inherting classes.
   */
  virtual void initQpStatefulProperties() override;

  /**
   * Calls the residual and jacobian functions used in the stress update
   * algorithm.
   */
  void calculateResidualAndJacobian();

  /**
   * Reset the PK2 stress and the inverse deformation gradient to old values and
   * provide an interface for inheriting classes to reset material properties
   */
  void preSolveQp();

  /**
   * Solve the stress and internal state variables (e.g. slip increment,
   * slip system resistance) at each qp points
   */
  void solveQp();

  /**
   * Save the final stress and internal variable values after the iterative solve.
   */
  void postSolveQp(RankTwoTensor & stress_new, RankFourTensor & jacobian_mult);

  /**
   * Solves the internal variables stress as a function of the slip specified
   * by the constitutive model defined in the inheriting class
   */
  void solveStateVariables();

  /**
   * solves for stress, updates plastic deformation gradient.
   */
  void solveStress();

  /**
   * Calculate stress residual as the difference between the stored material
   * property PK2 stress and the elastic PK2 stress calculated from the
   * constitutively defined equivalent_slip_increment.
   * The equivalent_slip_increment is passed in as an input arguement.
   */
  void calculateResidual();

  /**
   * Calculates the jacobian as
   * $\mathbf{J} = \mathbf{I} - \mathbf{C} \frac{d\mathbf{E}^e}{d\mathbf{F}^e}
   * \frac{d\mathbf{F}^e}{d\mathbf{F}^P^{-1}} \frac{d\mathbf{F}^P^{-1}}{d\mathbf{PK2}}$
   */
  void calculateJacobian();

  ///@{Calculates the tangent moduli for use as a preconditioner, using the elastic or elastic-plastic option as specified by the user
  void calcTangentModuli(RankFourTensor & jacobian_mult);
  void elasticTangentModuli(RankFourTensor & jacobian_mult);
  void elastoPlasticTangentModuli(RankFourTensor & jacobian_mult);
  ///@}

  /// performs the line search update
  bool lineSearchUpdate(const Real & rnorm_prev, const RankTwoTensor & dpk2);

  /**
   * Calculates the deformation gradient due to eigenstrain
   */
  void calculateEigenstrainDeformationGrad();

  /// number of plastic models
  const unsigned _num_models;

  /// The user supplied cyrstal plasticity consititutive models
  std::vector<CrystalPlasticityStressUpdateBase *> _models;

  /// number of eigenstrains
  const unsigned _num_eigenstrains;

  /// The user supplied cyrstal plasticity eigenstrains
  std::vector<ComputeCrystalPlasticityEigenstrainBase *> _eigenstrains;

  /// optional parameter to define several mechanical systems on the same block, e.g. multiple phases
  const std::string _base_name;

  /// Elasticity tensor as defined by a separate class
  const MaterialProperty<RankFourTensor> & _elasticity_tensor;

  /// Stress residual equation relative tolerance
  Real _rtol;
  /// Stress residual equation absolute tolerance
  Real _abs_tol;

  /// Residual tensor
  RankTwoTensor _residual_tensor;
  /// Jacobian tensor
  RankFourTensor _jacobian;

  /// Maximum number of iterations for stress update
  unsigned int _maxiter;
  /// Maximum number of iterations for internal variable update
  unsigned int _maxiterg;

  /// Type of tangent moduli calculation
  const enum class TangentModuliType { EXACT, NONE } _tan_mod_type;

  /// Maximum number of substep iterations
  unsigned int _max_substep_iter;
  
  /// time step size during substepping
  Real _substep_dt;

  /// Flag to activate line serach
  bool _use_line_search;

  /// Minimum line search step size
  Real _min_line_search_step_size;

  /// Line search bisection method tolerance
  Real _line_search_tolerance;

  /// Line search bisection method maximum iteration number
  unsigned int _line_search_max_iterations;

  /// strain formulation
  const enum class LineSearchMethod { CutHalf, Bisection } _line_search_method;
  
  unsigned int _num_slip_systems;
  unsigned int _num_qp_points;

  ///@{Plastic deformation gradient RankTwoTensor for the crystal
  MaterialProperty<RankTwoTensor> & _plastic_deformation_gradient;
  const MaterialProperty<RankTwoTensor> & _plastic_deformation_gradient_old;
  ///@}

  ///@{ Generalized eigenstrain deformation gradient RankTwoTensor for the crystal
  MaterialProperty<RankTwoTensor> * _eigenstrain_deformation_gradient;
  const MaterialProperty<RankTwoTensor> * _eigenstrain_deformation_gradient_old;
  ///@}

  ///@{Total deformation gradient RankTwoTensor for the crystal
  const MaterialProperty<RankTwoTensor> & _deformation_gradient;
  const MaterialProperty<RankTwoTensor> & _deformation_gradient_old;
  ///@}

  ///@{Second Piola-Kirchoff stress measure
  MaterialProperty<RankTwoTensor> & _pk2;
  const MaterialProperty<RankTwoTensor> & _pk2_old;
  ///@}
  
  /// Lagrangian total strain measure for the entire crystal
  MaterialProperty<RankTwoTensor> & _total_lagrangian_strain;

  /**
   * Tracks the rotation of the crystal during deformation
   * Note: this rotation tensor is not applied to the crystal lattice
   */
  MaterialProperty<RankTwoTensor> & _updated_rotation;

  /**
   * Crystal rotation in the original, or reference, configuration as defined by
   * Euler angle arguments in the ComputeElasticityTensor classes
   */
  const MaterialProperty<RankTwoTensor> & _crysrot;
  
  ///@{Helper deformation gradient tensor variables used in iterative solve
  RankTwoTensor _temporary_deformation_gradient;
  RankTwoTensor _elastic_deformation_gradient;
  RankTwoTensor _inverse_plastic_deformation_grad;
  RankTwoTensor _inverse_plastic_deformation_grad_old;
  RankTwoTensor _inverse_eigenstrain_deformation_grad;
  ///@}
  
  
  MaterialProperty<Real> & _acc_slip;

  /// Flag to print to console warning messages on stress, constitutive model convergence
  const bool _print_convergence_message;

  /// Flag to check whether convergence is achieved or if substepping is needed
  bool _convergence_failed;

  ///@{ Used for substepping; Uniformly divides the increment in deformation gradient
  RankTwoTensor _delta_deformation_gradient;
  RankTwoTensor _temporary_deformation_gradient_old;
  ///@}

  /// Scales the substepping increment to obtain deformation gradient at a substep iteration
  Real _dfgrd_scale_factor;
};

And below is a snippet of my constructor

ComputeMultipleCrystalPlasticityStress::ComputeMultipleCrystalPlasticityStress(
    const InputParameters & parameters)
  : ComputeFiniteStrainElasticStress(parameters),
    _num_models(getParam<std::vector<MaterialName>>("crystal_plasticity_models").size()),
    _num_eigenstrains(getParam<std::vector<MaterialName>>("eigenstrain_names").size()),
    _base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : ""),
    _elasticity_tensor(getMaterialPropertyByName<RankFourTensor>(_base_name + "elasticity_tensor")),
    _rtol(getParam<Real>("rtol")),
    _abs_tol(getParam<Real>("abs_tol")),
    _maxiter(getParam<unsigned int>("maxiter")),
    _maxiterg(getParam<unsigned int>("maxiter_state_variable")),
    _tan_mod_type(getParam<MooseEnum>("tan_mod_type").getEnum<TangentModuliType>()),
    _max_substep_iter(getParam<unsigned int>("maximum_substep_iteration")),
    _use_line_search(getParam<bool>("use_line_search")),
    _min_line_search_step_size(getParam<Real>("min_line_search_step_size")),
    _line_search_tolerance(getParam<Real>("line_search_tol")),
    _line_search_max_iterations(getParam<unsigned int>("line_search_maxiter")),
    _line_search_method(getParam<MooseEnum>("line_search_method").getEnum<LineSearchMethod>()),
    _num_slip_systems(getParam<unsigned int>("num_slip_systems")),
    _num_qp_points(getParam<unsigned int>("num_qp_points")),
    _plastic_deformation_gradient(declareProperty<RankTwoTensor>(_base_name + "plastic_deformation_gradient")),
    _plastic_deformation_gradient_old(
        getMaterialPropertyOld<RankTwoTensor>(_base_name + "plastic_deformation_gradient")),
    _eigenstrain_deformation_gradient(
        _num_eigenstrains ? &declareProperty<RankTwoTensor>(_base_name + "eigenstrain_deformation_gradient")
                          : nullptr),
    _eigenstrain_deformation_gradient_old(
        _num_eigenstrains
            ? &getMaterialPropertyOld<RankTwoTensor>(_base_name + "eigenstrain_deformation_gradient")
            : nullptr),
    _deformation_gradient(getMaterialProperty<RankTwoTensor>(_base_name + "deformation_gradient")),
    _deformation_gradient_old(
        getMaterialPropertyOld<RankTwoTensor>(_base_name + "deformation_gradient")),
    _pk2(declareProperty<RankTwoTensor>(_base_name + "second_piola_kirchhoff_stress")),
    _pk2_old(getMaterialPropertyOld<RankTwoTensor>(_base_name + "second_piola_kirchhoff_stress")),
    _total_lagrangian_strain(
        declareProperty<RankTwoTensor>(_base_name + "total_lagrangian_strain")),
    _updated_rotation(declareProperty<RankTwoTensor>(_base_name + "updated_rotation")),
    _crysrot(getMaterialProperty<RankTwoTensor>(
         _base_name + "crysrot")), // defined in the elasticity tensor classes for crystal plasticity
    _acc_slip(declareProperty<Real>("acc_slip")), // Accumulated slip,
    _print_convergence_message(getParam<bool>("print_state_variable_convergence_error_messages")),
{
  _convergence_failed = false;
}

[Emmanuel-324]

I started all over again and this is the only error I have now when I compile

(python-stack) [emmanuel324@tinkercliffs1 belson]$ make -j8
Compiling C++ (in opt mode) /home/emmanuel324/My_Current_Work/projects/moose/modules/solid_mechanics/build/unity_src/materials_Unity.C...
In file included from /home/emmanuel324/My_Current_Work/projects/moose/modules/solid_mechanics/build/unity_src/materials_Unity.C:224:
/home/emmanuel324/My_Current_Work/projects/moose/modules/solid_mechanics/src/materials/crystal_plasticity/ComputeMultipleCrystalPlasticityStress.C: In member function 'virtual void ComputeMu
ltipleCrystalPlasticityStress::computeQpStress()':
/home/emmanuel324/My_Current_Work/projects/moose/modules/solid_mechanics/src/materials/crystal_plasticity/ComputeMultipleCrystalPlasticityStress.C:208:39: error: 'class CrystalPlasticityStre
ssUpdateBase' has no member named 'getSlipIncrement'; did you mean 'MaterialProperty<std::vector<double> >& CrystalPlasticityStressUpdateBase::_slip_increment'? (not accessible from this con
text)
  208 |     Real slip_increment = _models[i]->getSlipIncrement(); // Assuming getSlipIncrement() returns the slip increment
      |                                       ^~~~~~~~~~~~~~~~
In file included from /home/emmanuel324/My_Current_Work/projects/moose/modules/solid_mechanics/build/header_symlinks/ComputeMultipleCrystalPlasticityStress.h:14,
                 from /home/emmanuel324/My_Current_Work/projects/moose/modules/solid_mechanics/src/materials/crystal_plasticity/ComputeMultipleCrystalPlasticityStress.C:10:
/home/emmanuel324/My_Current_Work/projects/moose/modules/solid_mechanics/build/header_symlinks/CrystalPlasticityStressUpdateBase.h:222:42: note: declared protected here
  222 |    MaterialProperty<std::vector<Real>> & _slip_increment;
      |                                          ^~~~~~~~~~~~~~~
make: *** [/home/emmanuel324/My_Current_Work/projects/moose/modules/solid_mechanics/build/unity_src/materials_Unity.x86_64-pc-linux-gnu.opt.lo] Error 1

What is the best way to do this?

1. Do I change the access modifier for _slip_increment from protected to public in the CrystalPlasticityStressUpdateBase class

2. Do I calculate the slip increment in the ComputeMultipleCrystalPlasticityStress

3. Add a public getter method to the CrystalPlasticityStressUpdateBase class.

[GiudGiud]

The first error is one too many comma in the initializer list

The second error is tryin g to resize a double because you are already accessing into the array. You don't need to resize the components of the array, just the array