AverageGrainVolume Class Reference

Compute the average grain area in a polycrystal. More...

#include <AverageGrainVolume.h>

Inheritance diagram for AverageGrainVolume:

Public Member Functions
	AverageGrainVolume (const InputParameters &parameters)
virtual void	initialize () override
virtual void	execute () override
virtual Real	getValue () override

Protected Member Functions
void	accumulateVolumes (const std::vector< unsigned int > &var_to_features, std::size_t libmesh_dbg_var(num_features))
Real	computeIntegral (std::size_t var_index) const

Private Attributes
MooseMesh &	_mesh
	A reference to the mesh. More...
Assembly &	_assembly
std::vector< unsigned int >	_static_var_to_feature
std::vector< const VariableValue * >	_vals
std::vector< Real >	_feature_volumes
const MooseArray< Point > &	_q_point
QBase *&	_qrule
const MooseArray< Real > &	_JxW
const MooseArray< Real > &	_coord
const FeatureFloodCount *	_feature_counter

Detailed Description

Compute the average grain area in a polycrystal.

Definition at line 27 of file AverageGrainVolume.h.

Constructor & Destructor Documentation

AverageGrainVolume()

AverageGrainVolume::AverageGrainVolume

(

const InputParameters &

parameters

)

Definition at line 45 of file AverageGrainVolume.C.

  : GeneralPostprocessor(parameters),
    Coupleable(this, false),
    MooseVariableDependencyInterface(),
    _mesh(_subproblem.mesh()),
    _assembly(_subproblem.assembly(0)),
    _q_point(_assembly.qPoints()),
    _qrule(_assembly.qRule()),
    _JxW(_assembly.JxW()),
    _coord(_assembly.coordTransformation()),
    _feature_counter(isParamValid("feature_counter")
                         ? &getUserObject<FeatureFloodCount>("feature_counter")
                         : nullptr)
{
  if (!_feature_counter)
  {
    if (isParamValid("variable") && isParamValid("grain_num"))
    {
      auto num_coupled_vars = coupledComponents("variable");
      if (num_coupled_vars != getParam<unsigned int>("grain_num"))
        mooseError("The number of grains must match the number of OPs if a feature_counter is not "
                   "supplied");

      _vals.resize(num_coupled_vars);
      for (unsigned int i = 0; i < num_coupled_vars; ++i)
        _vals[i] = &coupledValue("variable", i);

      _feature_volumes.resize(num_coupled_vars);

      // Build a reflexive map (ops map to grains directly)
      _static_var_to_feature.resize(num_coupled_vars);
      for (auto i = beginIndex(_static_var_to_feature); i < num_coupled_vars; ++i)
        _static_var_to_feature[i] = i;
    }
    else
      mooseError("Must supply either a feature_counter object or coupled variables and grain_num");
  }
  else
  {
    const auto & coupled_vars = _feature_counter->getCoupledVars();
    _vals.reserve(coupled_vars.size());

    for (auto & coupled_var : coupled_vars)
      _vals.emplace_back(&coupled_var->sln());

    addMooseVariableDependency(_feature_counter->getFECoupledVars());
  }
}

Member Function Documentation

accumulateVolumes()

void AverageGrainVolume::accumulateVolumes ( const std::vector< unsigned int > &  var_to_features, std::size_t   libmesh_dbg_varnum_features  )

protected

Definition at line 124 of file AverageGrainVolume.C.

Referenced by execute().

{
  for (auto var_index = beginIndex(var_to_features); var_index < var_to_features.size();
       ++var_index)
  {
    // Only sample "active" variables
    if (var_to_features[var_index] != FeatureFloodCount::invalid_id)
    {
      auto feature_id = var_to_features[var_index];
      mooseAssert(feature_id < num_features, "Feature ID out of range");
      auto integral_value = computeIntegral(var_index);

      _feature_volumes[feature_id] += integral_value;
    }
  }
}

computeIntegral()

Real AverageGrainVolume::computeIntegral ( std::size_t  var_index ) const

protected

Definition at line 143 of file AverageGrainVolume.C.

Referenced by accumulateVolumes().

{
  Real sum = 0;

  for (unsigned int qp = 0; qp < _qrule->n_points(); ++qp)
    sum += _JxW[qp] * _coord[qp] * (*_vals[var_index])[qp];

  return sum;
}

execute()

void AverageGrainVolume::execute ( )

overridevirtual

Definition at line 107 of file AverageGrainVolume.C.

{
  auto num_features = _feature_volumes.size();
  for (const auto & elem : _mesh.getMesh().active_local_element_ptr_range())
  {
    _fe_problem.prepare(elem, 0);
    _fe_problem.reinitElem(elem, 0);

    const std::vector<unsigned int> & var_to_feature_ptr =
        _feature_counter ? _feature_counter->getVarToFeatureVector(elem->id())
                         : _static_var_to_feature;

    accumulateVolumes(var_to_feature_ptr, num_features);
  }
}

getValue()

Real AverageGrainVolume::getValue ( )

overridevirtual

Definition at line 154 of file AverageGrainVolume.C.

{
  _communicator.sum(_feature_volumes);

  Real total_volume = 0;
  for (auto & volume : _feature_volumes)
    total_volume += volume;

  unsigned int active_features =
      _feature_counter ? _feature_counter->getNumberActiveFeatures() : _feature_volumes.size();

  return total_volume / active_features;
}

initialize()

void AverageGrainVolume::initialize ( )

overridevirtual

Definition at line 95 of file AverageGrainVolume.C.

{
  auto num_features = _feature_volumes.size();

  // When using FeatureFloodCount, the number of grains may not be fixed. Resize as appropriate
  if (_feature_counter)
    num_features = _feature_counter->getTotalFeatureCount();

  _feature_volumes.assign(num_features, 0);
}

Member Data Documentation

_assembly

Assembly& AverageGrainVolume::_assembly

private

Definition at line 45 of file AverageGrainVolume.h.

_coord

const MooseArray<Real>& AverageGrainVolume::_coord

private

Definition at line 52 of file AverageGrainVolume.h.

Referenced by computeIntegral().

_feature_counter

const FeatureFloodCount* AverageGrainVolume::_feature_counter

private

Definition at line 53 of file AverageGrainVolume.h.

Referenced by AverageGrainVolume(), execute(), getValue(), and initialize().

_feature_volumes

std::vector<Real> AverageGrainVolume::_feature_volumes

private

Definition at line 48 of file AverageGrainVolume.h.

Referenced by accumulateVolumes(), AverageGrainVolume(), execute(), getValue(), and initialize().

_JxW

const MooseArray<Real>& AverageGrainVolume::_JxW

private

Definition at line 51 of file AverageGrainVolume.h.

Referenced by computeIntegral().

_mesh

MooseMesh& AverageGrainVolume::_mesh

private

A reference to the mesh.

Definition at line 44 of file AverageGrainVolume.h.

Referenced by execute().

_q_point

const MooseArray<Point>& AverageGrainVolume::_q_point

private

Definition at line 49 of file AverageGrainVolume.h.

_qrule

QBase*& AverageGrainVolume::_qrule

private

Definition at line 50 of file AverageGrainVolume.h.

Referenced by computeIntegral().

_static_var_to_feature

std::vector<unsigned int> AverageGrainVolume::_static_var_to_feature

private

Definition at line 46 of file AverageGrainVolume.h.

Referenced by AverageGrainVolume(), and execute().

_vals

std::vector<const VariableValue *> AverageGrainVolume::_vals

private

Definition at line 47 of file AverageGrainVolume.h.

Referenced by AverageGrainVolume(), and computeIntegral().

---

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

• phase_field/include/postprocessors/AverageGrainVolume.h
• phase_field/src/postprocessors/AverageGrainVolume.C