EBSDReader Class Reference

A GeneralUserObject that reads an EBSD file and stores the centroid data in a data structure which indexes on element centroids. More...

#include <EBSDReader.h>

Inheritance diagram for EBSDReader:

Public Member Functions
	EBSDReader (const InputParameters &params)
virtual	~EBSDReader ()
virtual void	readFile ()
virtual void	initialize ()
virtual void	execute ()
virtual void	finalize ()
const EBSDPointData &	getData (const Point &p) const
	Get the requested type of data at the point p. More...
const EBSDAvgData &	getAvgData (unsigned int i) const
	Get the requested type of average data for (global) grain number i. More...
const EBSDAvgData &	getAvgData (unsigned int phase, unsigned int local_id) const
	Get the requested type of average data for a given phase and (local) grain. More...
virtual const EulerAngles &	getEulerAngles (unsigned int) const
	EulerAngleProvider interface implementation to fetch a triplet of Euler angles. More...
virtual unsigned int	getGrainNum () const
	Return the total number of grains. More...
virtual unsigned int	getPhaseNum () const
	Return the total number of phases. More...
virtual unsigned int	getGrainNum (unsigned int phase) const
	Return the number of grains in a given phase. More...
unsigned int	getFeatureID (unsigned int phase, unsigned int local_id) const
	Return the EBSD feature id for a given phase and phase (local) grain number. More...
unsigned int	getFeatureID (unsigned int global_id) const
	Return the EBSD feature id for a given (global) grain number. More...
virtual unsigned int	getGlobalID (unsigned int phase, unsigned int local_id) const
	Return the (global) grain id for a given phase and (local) grain number. More...
virtual unsigned int	getGlobalID (unsigned int feature_id) const
	Return the (global) grain id for a given feature_id. More...
MooseSharedPointer< EBSDPointDataFunctor >	getPointDataAccessFunctor (const MooseEnum &field_name) const
	Factory function to return a point functor specified by name. More...
MooseSharedPointer< EBSDAvgDataFunctor >	getAvgDataAccessFunctor (const MooseEnum &field_name) const
	Factory function to return a average functor specified by name. More...
const std::map< dof_id_type, std::vector< Real > > &	getNodeToGrainWeightMap () const
	Returns a map consisting of the node index followd by a vector of all grain weights for that node. More...
const std::map< dof_id_type, std::vector< Real > > &	getNodeToPhaseWeightMap () const
	Returns a map consisting of the node index followd by a vector of all phase weights for that node. More...
void	meshChanged ()
	Maps need to be updated when the mesh changes. More...

Static Public Member Functions
static InputParameters	validParams ()
static MooseEnum	getPointDataFieldType ()
static MooseEnum	getAvgDataFieldType ()

Protected Member Functions
unsigned	indexFromPoint (const Point &p) const
	Computes a global index in the _data array given an input centroid point. More...
unsigned	indexFromIndex (unsigned int var) const
	Transfer the index into the _avg_data array from given index. More...
void	buildNodeWeightMaps ()
	Build grain and phase weight maps. More...

Protected Attributes
unsigned int	_custom_columns
	number of additional custom data columns More...
std::vector< EBSDPointData >	_data
	Logically three-dimensional data indexed by geometric points in a 1D vector. More...
std::vector< EBSDAvgData >	_avg_data
	Averages by (global) grain ID. More...
std::vector< EulerAngles >	_avg_angles
	Euler Angles by (global) grain ID. More...
std::map< unsigned int, unsigned int >	_global_id_map
	map from feature_id to global_id More...
std::vector< std::vector< unsigned int > >	_global_id
	global ID for given phases and grains More...
std::map< dof_id_type, std::vector< Real > >	_node_to_grain_weight_map
	Map of grain weights per node. More...
std::map< dof_id_type, std::vector< Real > >	_node_to_phase_weight_map
	Map of phase weights per node. More...
const int &	_time_step
	current timestep. Maps are only rebuild on mesh change during time step zero More...
unsigned int	_mesh_dimension
	Dimension of the problem domain. More...
unsigned int	_bins
	number of bins for each quaternion component More...
unsigned int	_L_norm
	L_norm value for averaging. More...
unsigned	_nx
	The number of values in the x, y and z directions. More...
unsigned	_ny
unsigned	_nz
Real	_dx
	The spacing of the values in x, y and z directions. More...
Real	_dy
Real	_dz
Real	_minx
	Grid origin. More...
Real	_miny
Real	_minz
Real	_maxx
	Maximum grid extent. More...
Real	_maxy
Real	_maxz
MooseMesh &	_mesh
	MooseMesh Variables. More...
NonlinearSystemBase &	_nl
unsigned int	_grain_num
	Variables needed to determine reduced order parameter values. More...
Point	_bottom_left
Point	_top_right
Point	_range

Detailed Description

A GeneralUserObject that reads an EBSD file and stores the centroid data in a data structure which indexes on element centroids.

Grains are indexed through multiple schemes:

• feature_id The grain number in the EBSD data file
• global_id The index into the global average data (contiguously numbered) This is also called "(global) grain ID"
• local_id The index into the per-phase grain list. (contiguously numbered and only unique when combined with phase number) This is also called "(local) grain ID"

Phases are referred to using the numbers in the EBSD data file. In case the phase number in the data file starts at 1 the phase 0 will simply contain no grains.

Definition at line 36 of file EBSDReader.h.

Constructor & Destructor Documentation

EBSDReader()

EBSDReader::EBSDReader

(

const InputParameters &

params

)

Definition at line 35 of file EBSDReader.C.

  : EulerAngleProvider(params),
    _mesh(_fe_problem.mesh()),
    _nl(_fe_problem.getNonlinearSystemBase()),
    _grain_num(0),
    _custom_columns(getParam<unsigned int>("custom_columns")),
    _time_step(_fe_problem.timeStep()),
    _mesh_dimension(_mesh.dimension()),
    _bins(getParam<unsigned int>("bins")),
    _L_norm(getParam<Real>("L_norm")),
    _nx(0),
    _ny(0),
    _nz(0),
    _dx(0.),
    _dy(0.),
    _dz(0.)
{
  readFile();
  // throws an error for zero bins
  if (_bins == 0)
    mooseError("One cannot have zero bins");
}

~EBSDReader()

EBSDReader::~EBSDReader ( )

virtual

Definition at line 342 of file EBSDReader.C.

{}

Member Function Documentation

buildNodeWeightMaps()

void EBSDReader::buildNodeWeightMaps ( )

protected

Build grain and phase weight maps.

Definition at line 461 of file EBSDReader.C.

{
  // Import nodeToElemMap from MooseMesh for current node
  // This map consists of the node index followed by a vector of element indices that are associated
  // with that node
  const std::map<dof_id_type, std::vector<dof_id_type>> & node_to_elem_map =
      _mesh.nodeToActiveSemilocalElemMap();
  libMesh::MeshBase & mesh = _mesh.getMesh();
 
  // Loop through each node in mesh and calculate eta values for each grain associated with the node
  for (const auto & node : as_range(mesh.active_nodes_begin(), mesh.active_nodes_end()))
  {
    // Get node_id
    const dof_id_type node_id = node->id();
 
    // Initialize map entries for current node
    _node_to_grain_weight_map[node_id].assign(getGrainNum(), 0.0);
    _node_to_phase_weight_map[node_id].assign(getPhaseNum(), 0.0);
 
    // Loop through element indices associated with the current node and record weighted eta value
    // in new map
    const auto & node_to_elem_pair = node_to_elem_map.find(node_id);
    if (node_to_elem_pair != node_to_elem_map.end())
    {
      unsigned int n_elems =
          node_to_elem_pair->second
              .size(); // n_elems can range from 1 to 4 for 2D and 1 to 8 for 3D problems
 
      for (unsigned int ne = 0; ne < n_elems; ++ne)
      {
        // Current element index
        unsigned int elem_id = (node_to_elem_pair->second)[ne];
 
        // Retrieve EBSD grain number for the current element index
        const Elem * elem = mesh.elem_ptr(elem_id);
        const EBSDReader::EBSDPointData & d = getData(elem->centroid());
 
        // get the (global) grain ID for the EBSD feature ID
        const unsigned int global_id = getGlobalID(d._feature_id);
 
        // Calculate eta value and add to map
        _node_to_grain_weight_map[node_id][global_id] += 1.0 / n_elems;
        _node_to_phase_weight_map[node_id][d._phase] += 1.0 / n_elems;
      }
    }
  }
}

Referenced by meshChanged(), and readFile().

execute()

virtual void EBSDReader::execute ( )

inlinevirtual

Definition at line 45 of file EBSDReader.h.

{}

finalize()

virtual void EBSDReader::finalize ( )

inlinevirtual

Definition at line 46 of file EBSDReader.h.

{}

getAvgData() [1/2]

const EBSDReader::EBSDAvgData & EBSDReader::getAvgData

(

unsigned int

i

)

const

Get the requested type of average data for (global) grain number i.

Definition at line 351 of file EBSDReader.C.

{
  return _avg_data[indexFromIndex(var)];
}

Referenced by PolycrystalEBSD::getGrainsBasedOnPoint(), and EBSDReaderAvgDataAux::precalculateValue().

getAvgData() [2/2]

const EBSDReader::EBSDAvgData & EBSDReader::getAvgData	(	unsigned int	phase,
		unsigned int	local_id
	)		const

Get the requested type of average data for a given phase and (local) grain.

Definition at line 363 of file EBSDReader.C.

{
  return _avg_data[indexFromIndex(_global_id[phase][local_id])];
}

getAvgDataAccessFunctor()

MooseSharedPointer< EBSDAccessFunctors::EBSDAvgDataFunctor > EBSDReader::getAvgDataAccessFunctor

(

const MooseEnum &

field_name

)

const

Factory function to return a average functor specified by name.

Definition at line 556 of file EBSDReader.C.

{
  EBSDAvgDataFunctor * ret_val = NULL;
 
  switch (field_name)
  {
    case 0: // phi1
      ret_val = new EBSDAvgDataPhi1();
      break;
    case 1: // phi
      ret_val = new EBSDAvgDataPhi();
      break;
    case 2: // phi2
      ret_val = new EBSDAvgDataPhi2();
      break;
    case 3: // phase
      ret_val = new EBSDAvgDataPhase();
      break;
    case 4: // symmetry
      ret_val = new EBSDAvgDataSymmetry();
      break;
    case 5: // local_id
      ret_val = new EBSDAvgDataLocalID();
      break;
    case 6: // feature_id
      ret_val = new EBSDAvgDataFeatureID();
      break;
    default:
    {
      // check for custom columns
      for (unsigned int i = 0; i < _custom_columns; ++i)
        if (field_name == "CUSTOM" + Moose::stringify(i))
        {
          ret_val = new EBSDAvgDataCustom(i);
          break;
        }
    }
  }
 
  // If ret_val was not set by any of the above cases, throw an error.
  if (!ret_val)
    mooseError("Error:  Please input supported EBSD_param");
 
  // If we made it here, wrap up the the ret_val in a
  // MooseSharedPointer and ship it off.
  return MooseSharedPointer<EBSDAvgDataFunctor>(ret_val);
}

getAvgDataFieldType()

MooseEnum EBSDAccessFunctors::getAvgDataFieldType ( )

staticinherited

Definition at line 19 of file EBSDAccessFunctors.C.

{
  return MooseEnum("phi1 phi phi2 phase symmetry local_id feature_id", "", true);
}

Referenced by validParams< EBSDReaderAvgDataAux >().

getData()

const EBSDReader::EBSDPointData & EBSDReader::getData

(

const Point &

p

)

const

Get the requested type of data at the point p.

Definition at line 345 of file EBSDReader.C.

{
  return _data[indexFromPoint(p)];
}

Referenced by buildNodeWeightMaps(), PolycrystalEBSD::getGrainsBasedOnPoint(), and EBSDReaderPointDataAux::precalculateValue().

getEulerAngles()

const EulerAngles & EBSDReader::getEulerAngles ( unsigned int  var ) const

virtual

EulerAngleProvider interface implementation to fetch a triplet of Euler angles.

Implements EulerAngleProvider.

Definition at line 357 of file EBSDReader.C.

{
  return _avg_angles[indexFromIndex(var)];
}

getFeatureID() [1/2]

unsigned int EBSDReader::getFeatureID ( unsigned int  global_id ) const

inline

Return the EBSD feature id for a given (global) grain number.

Definition at line 89 of file EBSDReader.h.

  {
    return _avg_data[global_id]._feature_id;
  }

getFeatureID() [2/2]

unsigned int EBSDReader::getFeatureID ( unsigned int  phase, unsigned int  local_id  ) const

inline

Return the EBSD feature id for a given phase and phase (local) grain number.

Definition at line 84 of file EBSDReader.h.

  {
    return _avg_data[_global_id[phase][local_id]]._feature_id;
  }

getGlobalID() [1/2]

unsigned int EBSDReader::getGlobalID ( unsigned int  feature_id ) const

virtual

Return the (global) grain id for a given feature_id.

Definition at line 444 of file EBSDReader.C.

{
  auto it = _global_id_map.find(feature_id);
  if (it == _global_id_map.end())
    mooseError("Invalid Feature ID");
  return it->second;
}

getGlobalID() [2/2]

virtual unsigned int EBSDReader::getGlobalID ( unsigned int  phase, unsigned int  local_id  ) const

inlinevirtual

Return the (global) grain id for a given phase and (local) grain number.

Definition at line 95 of file EBSDReader.h.

  {
    return _global_id[phase][local_id];
  }

Referenced by buildNodeWeightMaps(), PolycrystalEBSD::getGrainsBasedOnPoint(), PolycrystalEBSD::getNodalVariableValue(), and EulerAngleProvider2RGBAux::precalculateValue().

getGrainNum() [1/2]

unsigned int EBSDReader::getGrainNum ( ) const

virtual

Return the total number of grains.

Implements EulerAngleProvider.

Definition at line 369 of file EBSDReader.C.

{
  return _grain_num;
}

Referenced by buildNodeWeightMaps(), PolycrystalEBSD::getNumGrains(), and EulerAngleProvider2RGBAux::getNumGrains().

getGrainNum() [2/2]

unsigned int EBSDReader::getGrainNum ( unsigned int  phase ) const

virtual

Return the number of grains in a given phase.

Definition at line 375 of file EBSDReader.C.

{
  return _global_id[phase].size();
}

getNodeToGrainWeightMap()

const std::map< dof_id_type, std::vector< Real > > & EBSDReader::getNodeToGrainWeightMap

(

)

const

Returns a map consisting of the node index followd by a vector of all grain weights for that node.

Needed by ReconVarIC

Definition at line 432 of file EBSDReader.C.

{
  return _node_to_grain_weight_map;
}

getNodeToPhaseWeightMap()

const std::map< dof_id_type, std::vector< Real > > & EBSDReader::getNodeToPhaseWeightMap

(

)

const

Returns a map consisting of the node index followd by a vector of all phase weights for that node.

Needed by ReconPhaseVarIC

Definition at line 438 of file EBSDReader.C.

{
  return _node_to_phase_weight_map;
}

getPhaseNum()

virtual unsigned int EBSDReader::getPhaseNum ( ) const

inlinevirtual

Return the total number of phases.

Definition at line 76 of file EBSDReader.h.

{ return _global_id.size(); }

Referenced by buildNodeWeightMaps().

getPointDataAccessFunctor()

MooseSharedPointer< EBSDAccessFunctors::EBSDPointDataFunctor > EBSDReader::getPointDataAccessFunctor

(

const MooseEnum &

field_name

)

const

Factory function to return a point functor specified by name.

Definition at line 510 of file EBSDReader.C.

{
  EBSDPointDataFunctor * ret_val = NULL;
 
  switch (field_name)
  {
    case 0: // phi1
      ret_val = new EBSDPointDataPhi1();
      break;
    case 1: // phi
      ret_val = new EBSDPointDataPhi();
      break;
    case 2: // phi2
      ret_val = new EBSDPointDataPhi2();
      break;
    case 3: // grain
      ret_val = new EBSDPointDataFeatureID();
      break;
    case 4: // phase
      ret_val = new EBSDPointDataPhase();
      break;
    case 5: // symmetry
      ret_val = new EBSDPointDataSymmetry();
      break;
    default:
    {
      // check for custom columns
      for (unsigned int i = 0; i < _custom_columns; ++i)
        if (field_name == "CUSTOM" + Moose::stringify(i))
        {
          ret_val = new EBSDPointDataCustom(i);
          break;
        }
    }
  }
 
  // If ret_val was not set by any of the above cases, throw an error.
  if (!ret_val)
    mooseError("Error:  Please input supported EBSD_param");
 
  // If we made it here, wrap up the the ret_val in a
  // MooseSharedPointer and ship it off.
  return MooseSharedPointer<EBSDPointDataFunctor>(ret_val);
}

getPointDataFieldType()

MooseEnum EBSDAccessFunctors::getPointDataFieldType ( )

staticinherited

Definition at line 13 of file EBSDAccessFunctors.C.

{
  return MooseEnum("phi1 phi phi2 feature_id phase symmetry", "", true);
}

Referenced by validParams< EBSDReaderPointDataAux >().

indexFromIndex()

unsigned int EBSDReader::indexFromIndex ( unsigned int  var ) const

protected

Transfer the index into the _avg_data array from given index.

Definition at line 415 of file EBSDReader.C.

{
 
  // Transfer the index into the _avg_data array.
  unsigned avg_index = var;
 
  // Don't access out of range!
  if (avg_index >= _avg_data.size())
    mooseError("Error! Index out of range in EBSDReader::indexFromIndex(), index: ",
               avg_index,
               " size: ",
               _avg_data.size());
 
  return avg_index;
}

Referenced by getAvgData(), and getEulerAngles().

indexFromPoint()

unsigned int EBSDReader::indexFromPoint ( const Point &  p ) const

protected

Computes a global index in the _data array given an input centroid point.

Definition at line 381 of file EBSDReader.C.

{
  // Don't assume an ordering on the input data, use the (x, y,
  // z) values of this centroid to determine the index.
  unsigned int x_index, y_index, z_index, global_index;
 
  x_index = (unsigned int)((p(0) - _minx) / _dx);
  y_index = (unsigned int)((p(1) - _miny) / _dy);
  if (p(0) <= _minx || p(0) >= _maxx || p(1) <= _miny || p(1) >= _maxy)
    mooseError("Data points must be on the interior of the mesh elements. In EBSDReader ", name());
 
  if (_mesh_dimension == 3)
  {
    z_index = (unsigned int)((p(2) - _minz) / _dz);
    global_index = z_index * _ny;
    if (p(2) <= _minz || p(2) >= _maxz)
      mooseError("Data points must be on the interior of the mesh elements. In EBSDReader ",
                 name());
  }
  else
    global_index = 0;
 
  // Compute the global index into the _data array.  This stores points
  // in a [z][y][x] ordering.
  global_index = (global_index + y_index) * _nx + x_index;
 
  // Don't access out of range!
  mooseAssert(global_index < _data.size(),
              "global_index " << global_index << " points out of _data range: " << _data.size());
 
  return global_index;
}

Referenced by getData(), and readFile().

initialize()

virtual void EBSDReader::initialize ( )

inlinevirtual

Definition at line 44 of file EBSDReader.h.

{}

meshChanged()

void EBSDReader::meshChanged

(

)

Maps need to be updated when the mesh changes.

Definition at line 453 of file EBSDReader.C.

{
  // maps are only rebuild for use in initial conditions, which happens in time step zero
  if (_time_step == 0)
    buildNodeWeightMaps();
}

readFile()

void EBSDReader::readFile ( )

virtual

Markley, F. Landis, Yang Cheng, John Lucas Crassidis, and Yaakov Oshman. "Averaging quaternions." Journal of Guidance, Control, and Dynamics 30, no. 4 (2007): 1193-1197. A 4 by N matrix (Q) is constructed, where N is the number of quaternions. A weight matrix (W) is created. The eigen vector corresponding to the maximum eigen value of Q*W*Q' is the weighted average quaternion

If no bin exists which has atleast 50% of total quaternions in a grain then the EBSD data may not be reliable Note: The limit 50% is arbitrary

Definition at line 59 of file EBSDReader.C.

{
  // No need to re-read data upon recovery
  if (_app.isRecovering())
    return;
 
  // Fetch and check mesh
  EBSDMesh * mesh = dynamic_cast<EBSDMesh *>(&_mesh);
  if (mesh == NULL)
    mooseError("Please use an EBSDMesh in your simulation.");
  std::ifstream stream_in(mesh->getEBSDFilename().c_str());
  if (!stream_in)
    mooseError("Can't open EBSD file: ", mesh->getEBSDFilename());
 
  const EBSDMesh::EBSDMeshGeometry & g = mesh->getEBSDGeometry();
  // Copy file header data from the EBSDMesh
  _dx = g.d[0];
  _nx = g.n[0];
  _minx = g.min[0];
  _maxx = _minx + _dx * _nx;
 
  _dy = g.d[1];
  _ny = g.n[1];
  _miny = g.min[1];
  _maxy = _miny + _dy * _ny;
 
  _dz = g.d[2];
  _nz = g.n[2];
  _minz = g.min[2];
  _maxz = _minz + _dz * _nz;
 
  // Resize the _data array
  unsigned total_size = g.dim < 3 ? _nx * _ny : _nx * _ny * _nz;
  _data.resize(total_size);
 
  std::string line;
  while (std::getline(stream_in, line))
  {
    if (line.find("#") != 0)
    {
      // Temporary variables to read in on each line
      EBSDPointData d;
      Real x, y, z;
 
      std::istringstream iss(line);
      iss >> d._phi1 >> d._Phi >> d._phi2 >> x >> y >> z >> d._feature_id >> d._phase >>
          d._symmetry;
 
      // Transform angles to degrees
      d._phi1 *= 180.0 / libMesh::pi;
      d._Phi *= 180.0 / libMesh::pi;
      d._phi2 *= 180.0 / libMesh::pi;
 
      // Custom columns
      d._custom.resize(_custom_columns);
      for (unsigned int i = 0; i < _custom_columns; ++i)
        if (!(iss >> d._custom[i]))
          mooseError("Unable to read in EBSD custom data column #", i);
 
      if (x < _minx || y < _miny || x > _maxx || y > _maxy ||
          (g.dim == 3 && (z < _minz || z > _maxz)))
        mooseError("EBSD Data ouside of the domain declared in the header ([",
                   _minx,
                   ':',
                   _maxx,
                   "], [",
                   _miny,
                   ':',
                   _maxy,
                   "], [",
                   _minz,
                   ':',
                   _maxz,
                   "]) dim=",
                   g.dim,
                   "\n",
                   line);
 
      d._p = Point(x, y, z);
 
      // determine number of grains in the dataset
      if (_global_id_map.find(d._feature_id) == _global_id_map.end())
        _global_id_map[d._feature_id] = _grain_num++;
 
      unsigned int global_index = indexFromPoint(Point(x, y, z));
      _data[global_index] = d;
    }
  }
  stream_in.close();
 
  // Resize the variables
  _avg_data.resize(_grain_num);
  _avg_angles.resize(_grain_num);
 
  // clear the averages
  for (unsigned int i = 0; i < _grain_num; ++i)
  {
    EBSDAvgData & a = _avg_data[i];
    a._symmetry = a._phase = a._n = 0;
    a._p = 0.0;
    a._custom.assign(_custom_columns, 0.0);
 
    EulerAngles & b = _avg_angles[i];
    b.phi1 = b.Phi = b.phi2 = 0.0;
  }
 
  // Array of vectors to store quaternions of each grain
  std::vector<std::vector<Eigen::Quaternion<Real>>> quat(_grain_num);
 
  // Iterate through data points to store orientation information for each grain
  for (auto & j : _data)
  {
    EBSDAvgData & a = _avg_data[_global_id_map[j._feature_id]];
    EulerAngles angles;
 
    angles.phi1 = j._phi1;
    angles.Phi = j._Phi;
    angles.phi2 = j._phi2;
 
    // convert Euler angles to quaternions
    Eigen::Quaternion<Real> q = angles.toQuaternion();
 
    quat[_global_id_map[j._feature_id]].push_back(q);
 
    if (a._n == 0)
      a._phase = j._phase;
    else if (a._phase != j._phase)
      mooseError("An EBSD feature needs to have a uniform phase.");
 
    if (a._n == 0)
      a._symmetry = j._symmetry;
    else if (a._symmetry != j._symmetry)
      mooseError("An EBSD feature needs to have a uniform symmetry parameter.");
 
    for (unsigned int i = 0; i < _custom_columns; ++i)
      a._custom[i] += j._custom[i];
 
    // store the feature (or grain) ID
    a._feature_id = j._feature_id;
 
    a._p += j._p;
    a._n++;
  }
  // creating a vector of maps to store the quaternion count for each bin index
  std::vector<
      std::map<std::tuple<unsigned int, unsigned int, unsigned int, unsigned int>, unsigned int>>
      feature_weights(_grain_num);
  // creating a vector of vectors to store the bin index corresponding to a quaternion
  std::vector<std::vector<std::tuple<unsigned int, unsigned int, unsigned int, unsigned int>>>
      quat_to_bin(_grain_num);
 
  for (unsigned int i = 0; i < _grain_num; i++)
  {
    EBSDAvgData & a = _avg_data[i];
    EulerAngles & b = _avg_angles[i];
 
    if (a._n == 0)
      continue;
 
    Real w_index, x_index, y_index, z_index;
    Real w, x, y, z;
    std::vector<std::tuple<double, Eigen::VectorXd>> eigen_vectors_and_values;
 
    // creating an empty map
    feature_weights.push_back(
        std::map<std::tuple<unsigned int, unsigned int, unsigned int, unsigned int>,
                 unsigned int>());
 
    // looping through quaternions of each grain
    for (unsigned int k = 0; k < quat[i].size(); k++)
    {
      std::tuple<unsigned int, unsigned int, unsigned int, unsigned int> bin;
      w_index = int((quat[i][k].w() + 1) * 0.5 * _bins);
      x_index = int((quat[i][k].x() + 1) * 0.5 * _bins);
      y_index = int((quat[i][k].y() + 1) * 0.5 * _bins);
      z_index = int((quat[i][k].z() + 1) * 0.5 * _bins);
 
      bin = std::make_tuple(w_index, x_index, y_index, z_index);
 
      // storing the bincorresponding to the quaternion quat[i][k]
      quat_to_bin[i].push_back(bin);
 
      // storing the bin name and its corresponding size value
      auto j = feature_weights[i].find(bin);
      if (j == feature_weights[i].end())
        feature_weights[i].emplace_hint(j, bin, 1);
      else
        j->second++;
    }
 
    // creating a quaternion matrix
    Eigen::MatrixXd quat_mat(4, quat[i].size());
    // creating the weight matrix
    Eigen::MatrixXd weight = Eigen::MatrixXd::Identity(quat[i].size(), quat[i].size());
 
    unsigned int bin_size;
    bool data_quality_ok = false;
    Real total_weight = 0.0;
 
    for (unsigned int j = 0; j < quat[i].size(); j++)
    {
      bin_size = feature_weights[i][quat_to_bin[i][j]];
      w = quat[i][j].w();
      x = quat[i][j].x();
      y = quat[i][j].y();
      z = quat[i][j].z();
 
      // instantiating columns of the matrix
      quat_mat.col(j) << w, x, y, z;
      // assigning weights to each quaternion
      weight(j, j) = std::pow(bin_size, _L_norm);
      total_weight += weight(j, j);
      if (bin_size / quat[i].size() > 0.5)
        data_quality_ok = true;
    }
 
    weight = weight / total_weight;
 
    // throws a warning if EBSD data is not reliable
    if (!data_quality_ok)
      _console << COLOR_YELLOW << "EBSD data may not be reliable"
               << "\n"
               << COLOR_DEFAULT;
 
    // compute eigen values and eigen vectors
    Eigen::EigenSolver<Eigen::MatrixXd> EigenSolver(quat_mat * weight * quat_mat.transpose());
    Eigen::VectorXd eigen_values = EigenSolver.eigenvalues().real();
    Eigen::MatrixXd eigen_vectors = EigenSolver.eigenvectors().real();
 
    // creating a tuple of eigen values and eigen vectors
    for (unsigned int i = 0; i < eigen_values.size(); i++)
    {
      std::tuple<double, Eigen::VectorXd> vec_and_val(eigen_values[i], eigen_vectors.col(i));
      eigen_vectors_and_values.push_back(vec_and_val);
    }
    // Sorting the eigen values and vectors in ascending order of eigen values
    auto j = std::max_element(eigen_vectors_and_values.begin(),
                              eigen_vectors_and_values.end(),
                              [&](const std::tuple<double, Eigen::VectorXd> & a,
                                  const std::tuple<double, Eigen::VectorXd> & b) -> bool {
                                return std::get<0>(a) < std::get<0>(b);
                              });
    // Selecting eigen vector corresponding to max eigen value to compute average euler angle
    Eigen::Quaternion<Real> q(
        std::get<1>(*j)(0), std::get<1>(*j)(1), std::get<1>(*j)(2), std::get<1>(*j)(3));
 
    b = EulerAngles(q);
 
    // link the EulerAngles into the EBSDAvgData for access via the functors
    a._angles = &b;
 
    if (a._phase >= _global_id.size())
      _global_id.resize(a._phase + 1);
 
    // The averaged per grain data locally contains the phase id, local id, and
    // original feature id. It is stored contiguously indexed by global id.
    a._local_id = _global_id[a._phase].size();
    _global_id[a._phase].push_back(i);
 
    a._p *= 1.0 / Real(a._n);
 
    for (unsigned int i = 0; i < _custom_columns; ++i)
      a._custom[i] /= Real(a._n);
  }
  // Build maps to indicate the weights with which grain and phase data
  // from the surrounding elements contributes to a node fo IC purposes
  buildNodeWeightMaps();
}

Referenced by EBSDReader().

validParams()

InputParameters EulerAngleProvider::validParams ( )

staticinherited

Definition at line 15 of file EulerAngleProvider.C.

{
  return GeneralUserObject::validParams();
}

Referenced by EulerAngleFileReader::validParams().

Member Data Documentation

_avg_angles

std::vector<EulerAngles> EBSDReader::_avg_angles

protected

Euler Angles by (global) grain ID.

Definition at line 147 of file EBSDReader.h.

Referenced by getEulerAngles(), and readFile().

_avg_data

std::vector<EBSDAvgData> EBSDReader::_avg_data

protected

Averages by (global) grain ID.

Definition at line 144 of file EBSDReader.h.

Referenced by getAvgData(), getFeatureID(), indexFromIndex(), and readFile().

_bins

unsigned int EBSDReader::_bins

protected

number of bins for each quaternion component

Definition at line 168 of file EBSDReader.h.

Referenced by EBSDReader(), and readFile().

_bottom_left

Point EBSDReader::_bottom_left

protected

Definition at line 132 of file EBSDReader.h.

_custom_columns

unsigned int EBSDReader::_custom_columns

protected

number of additional custom data columns

Definition at line 138 of file EBSDReader.h.

Referenced by getAvgDataAccessFunctor(), getPointDataAccessFunctor(), and readFile().

_data

std::vector<EBSDPointData> EBSDReader::_data

protected

Logically three-dimensional data indexed by geometric points in a 1D vector.

Definition at line 141 of file EBSDReader.h.

Referenced by getData(), indexFromPoint(), and readFile().

_dx

Real EBSDReader::_dx

protected

The spacing of the values in x, y and z directions.

Definition at line 177 of file EBSDReader.h.

Referenced by indexFromPoint(), and readFile().

_dy

Real EBSDReader::_dy

protected

Definition at line 177 of file EBSDReader.h.

Referenced by indexFromPoint(), and readFile().

_dz

Real EBSDReader::_dz

protected

Definition at line 177 of file EBSDReader.h.

Referenced by indexFromPoint(), and readFile().

_global_id

std::vector<std::vector<unsigned int> > EBSDReader::_global_id

protected

global ID for given phases and grains

Definition at line 153 of file EBSDReader.h.

Referenced by getAvgData(), getFeatureID(), getGlobalID(), getGrainNum(), getPhaseNum(), and readFile().

_global_id_map

std::map<unsigned int, unsigned int> EBSDReader::_global_id_map

protected

map from feature_id to global_id

Definition at line 150 of file EBSDReader.h.

Referenced by getGlobalID(), and readFile().

_grain_num

unsigned int EBSDReader::_grain_num

protected

Variables needed to determine reduced order parameter values.

Definition at line 131 of file EBSDReader.h.

Referenced by getGrainNum(), and readFile().

_L_norm

unsigned int EBSDReader::_L_norm

protected

L_norm value for averaging.

Definition at line 171 of file EBSDReader.h.

Referenced by readFile().

_maxx

Real EBSDReader::_maxx

protected

Maximum grid extent.

Definition at line 183 of file EBSDReader.h.

Referenced by indexFromPoint(), and readFile().

_maxy

Real EBSDReader::_maxy

protected

Definition at line 183 of file EBSDReader.h.

Referenced by indexFromPoint(), and readFile().

_maxz

Real EBSDReader::_maxz

protected

Definition at line 183 of file EBSDReader.h.

Referenced by indexFromPoint(), and readFile().

_mesh

MooseMesh& EBSDReader::_mesh

protected

MooseMesh Variables.

Definition at line 126 of file EBSDReader.h.

Referenced by buildNodeWeightMaps(), and readFile().

_mesh_dimension

unsigned int EBSDReader::_mesh_dimension

protected

Dimension of the problem domain.

Definition at line 165 of file EBSDReader.h.

Referenced by indexFromPoint().

_minx

Real EBSDReader::_minx

protected

Grid origin.

Definition at line 180 of file EBSDReader.h.

Referenced by indexFromPoint(), and readFile().

_miny

Real EBSDReader::_miny

protected

Definition at line 180 of file EBSDReader.h.

Referenced by indexFromPoint(), and readFile().

_minz

Real EBSDReader::_minz

protected

Definition at line 180 of file EBSDReader.h.

Referenced by indexFromPoint(), and readFile().

_nl

NonlinearSystemBase& EBSDReader::_nl

protected

Definition at line 127 of file EBSDReader.h.

_node_to_grain_weight_map

std::map<dof_id_type, std::vector<Real> > EBSDReader::_node_to_grain_weight_map

protected

Map of grain weights per node.

Definition at line 156 of file EBSDReader.h.

Referenced by buildNodeWeightMaps(), and getNodeToGrainWeightMap().

_node_to_phase_weight_map

std::map<dof_id_type, std::vector<Real> > EBSDReader::_node_to_phase_weight_map

protected

Map of phase weights per node.

Definition at line 159 of file EBSDReader.h.

Referenced by buildNodeWeightMaps(), and getNodeToPhaseWeightMap().

_nx

unsigned EBSDReader::_nx

protected

The number of values in the x, y and z directions.

Definition at line 174 of file EBSDReader.h.

Referenced by indexFromPoint(), and readFile().

_ny

unsigned EBSDReader::_ny

protected

Definition at line 174 of file EBSDReader.h.

Referenced by indexFromPoint(), and readFile().

_nz

unsigned EBSDReader::_nz

protected

Definition at line 174 of file EBSDReader.h.

Referenced by readFile().

_range

Point EBSDReader::_range

protected

Definition at line 134 of file EBSDReader.h.

_time_step

const int& EBSDReader::_time_step

protected

current timestep. Maps are only rebuild on mesh change during time step zero

Definition at line 162 of file EBSDReader.h.

Referenced by meshChanged().

_top_right

Point EBSDReader::_top_right

protected

Definition at line 133 of file EBSDReader.h.

---

The documentation for this class was generated from the following files:

• phase_field/include/userobjects/EBSDReader.h
• phase_field/src/userobjects/EBSDReader.C