Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #include "GrainTrackerElasticity.h"
      11             : #include "EulerAngleProvider.h"
      12             : #include "RotationTensor.h"
      13             : 
      14             : registerMooseObject("PhaseFieldApp", GrainTrackerElasticity);
      15             : 
      16             : InputParameters
      17          14 : GrainTrackerElasticity::validParams()
      18             : {
      19          14 :   InputParameters params = GrainTracker::validParams();
      20          28 :   params.addParam<bool>("random_rotations",
      21          28 :                         true,
      22             :                         "Generate random rotations when the Euler Angle "
      23             :                         "provider runs out of data (otherwise error "
      24             :                         "out)");
      25          28 :   params.addRequiredParam<std::vector<Real>>("C_ijkl", "Unrotated stiffness tensor");
      26          28 :   params.addParam<MooseEnum>(
      27          28 :       "fill_method", RankFourTensor::fillMethodEnum() = "symmetric9", "The fill method");
      28          28 :   params.addRequiredParam<UserObjectName>("euler_angle_provider",
      29             :                                           "Name of Euler angle provider user object");
      30          14 :   return params;
      31           0 : }
      32             : 
      33           7 : GrainTrackerElasticity::GrainTrackerElasticity(const InputParameters & parameters)
      34             :   : GrainDataTracker<RankFourTensor>(parameters),
      35           7 :     _random_rotations(getParam<bool>("random_rotations")),
      36          21 :     _C_ijkl(getParam<std::vector<Real>>("C_ijkl"),
      37           7 :             getParam<MooseEnum>("fill_method").getEnum<RankFourTensor::FillMethod>()),
      38          14 :     _euler(getUserObject<EulerAngleProvider>("euler_angle_provider"))
      39             : {
      40           7 : }
      41             : 
      42             : RankFourTensor
      43          54 : GrainTrackerElasticity::newGrain(unsigned int new_grain_id)
      44             : {
      45          54 :   EulerAngles angles;
      46             : 
      47          54 :   if (new_grain_id < _euler.getGrainNum())
      48          54 :     angles = _euler.getEulerAngles(new_grain_id);
      49             :   else
      50             :   {
      51           0 :     if (_random_rotations)
      52           0 :       angles.random();
      53             :     else
      54           0 :       mooseError("GrainTrackerElasticity has run out of grain rotation data.");
      55             :   }
      56             : 
      57          54 :   RankFourTensor C_ijkl = _C_ijkl;
      58          54 :   C_ijkl.rotate(RotationTensor(RealVectorValue(angles)));
      59             : 
      60          54 :   return C_ijkl;
      61             : }