Output euler angles from user object to an AuxVariable. More...

#include <EulerAngleProvider2RGBAux.h>

Inheritance diagram for EulerAngleProvider2RGBAux:

Public Member Functions
	EulerAngleProvider2RGBAux (const InputParameters &parameters)

virtual unsigned int	getNumGrains () const

Protected Member Functions
virtual Real	computeValue ()

virtual void	precalculateValue ()

Protected Attributes
const unsigned int	_phase
	Optional phase number needed for global grain index retrieval. More...

const unsigned int	_sd
	Reference direction of the sample. More...

const unsigned int	_xtal_class
	Crystal structure of the sample. More...

const unsigned int	_output_type
	Type of value to be outputted. More...

const EulerAngleProvider &	_euler
	Object providing the Euler angles. More...

const EBSDReader *	_ebsd_reader
	EBSDReader Object. More...

const GrainTrackerInterface &	_grain_tracker
	Grain tracker object. More...

Real	_value
	precalculated element value More...

const Point	_no_grain_color
	Vector containing values for color in regions without grains. More...

Detailed Description

Output euler angles from user object to an AuxVariable.

Definition at line 27 of file EulerAngleProvider2RGBAux.h.

Constructor & Destructor Documentation

◆ EulerAngleProvider2RGBAux()

EulerAngleProvider2RGBAux::EulerAngleProvider2RGBAux ( const InputParameters & parameters )

Definition at line 46 of file EulerAngleProvider2RGBAux.C.

   : AuxKernel(parameters),
     _phase(isParamValid("phase") ? getParam<unsigned int>("phase") : libMesh::invalid_uint),
     _sd(getParam<MooseEnum>("sd")),
     _xtal_class(getParam<MooseEnum>("crystal_structure")),
     _output_type(getParam<MooseEnum>("output_type")),
     _euler(getUserObject<EulerAngleProvider>("euler_angle_provider")),
     _ebsd_reader(isParamValid("phase") ? dynamic_cast<const EBSDReader *>(&_euler) : nullptr),
     _grain_tracker(getUserObject<GrainTrackerInterface>("grain_tracker")),
     _no_grain_color(getParam<Point>("no_grain_color"))
 {
 }

Member Function Documentation

◆ computeValue()

Real EulerAngleProvider2RGBAux::computeValue ( )

protectedvirtual

Definition at line 122 of file EulerAngleProvider2RGBAux.C.

 {
   return _value;
 }

◆ getNumGrains()

unsigned int EulerAngleProvider2RGBAux::getNumGrains ( ) const

virtual

Definition at line 60 of file EulerAngleProvider2RGBAux.C.

 {
   if (_phase != libMesh::invalid_uint)
     return _ebsd_reader->getGrainNum(_phase);
   else
     return _euler.getGrainNum();
 }

Referenced by precalculateValue().

◆ precalculateValue()

void EulerAngleProvider2RGBAux::precalculateValue ( )

protectedvirtual

Definition at line 69 of file EulerAngleProvider2RGBAux.C.

 {
   const auto grain_id =
       _grain_tracker.getEntityValue(isNodal() ? _current_node->id() : _current_elem->id(),
                                     FeatureFloodCount::FieldType::UNIQUE_REGION,
                                     0);
  
   // Recover Euler angles for current grain and assign correct RGB value either
   // from Euler2RGB or from _no_grain_color
   Point RGB;
   if (grain_id < 0)
     RGB = _no_grain_color;
   else
   {
     /* The grain index retrieved from FeatureFloodCount is the "global_id" unless
        the "phase" option is used in the simulation.  For the phase dependent case,
        the returned grain index is the "local_id." This must be converted to a
        "global_id" using the getGlobalID function of EBSDREader before the Euler
        Angles are retrieved. */
  
     auto global_id =
         _phase != libMesh::invalid_uint ? _ebsd_reader->getGlobalID(_phase, grain_id) : grain_id;
     const auto num_grns = getNumGrains();
     if (global_id > num_grns)
       mooseError(" global_id ", global_id, " out of index range");
  
     // Retrieve Euler Angle values from the EulerAngleProvider
     const RealVectorValue & angles = _euler.getEulerAngles(global_id);
  
     // Convert Euler Angle values to RGB colorspace for visualization purposes
     RGB = euler2RGB(_sd,
                     angles(0) / 180.0 * libMesh::pi,
                     angles(1) / 180.0 * libMesh::pi,
                     angles(2) / 180.0 * libMesh::pi,
                     1.0,
                     _xtal_class);
   }
  
   // Create correct scalar output
   if (_output_type < 3)
     _value = RGB(_output_type);
   else if (_output_type == 3)
   {
     Real RGBint = 0.0;
     for (unsigned int i = 0; i < 3; ++i)
       RGBint = 256 * RGBint + (RGB(i) >= 1 ? 255 : std::floor(RGB(i) * 256.0));
     _value = RGBint;
   }
   else
     mooseError("Incorrect value for output_type in EulerAngleProvider2RGBAux");
 }