FeatureVolumeVectorPostprocessor Class Reference

This VectorPostprocessor is intended to be used to calculate accurate volumes from the FeatureFloodCount and/or GrainTracker objects. More...

#include <FeatureVolumeVectorPostprocessor.h>

Inheritance diagram for FeatureVolumeVectorPostprocessor:

Public Member Functions
	FeatureVolumeVectorPostprocessor (const InputParameters &parameters)
virtual void	initialize () override
virtual void	execute () override
virtual void	finalize () override
Real	getFeatureVolume (unsigned int feature_id) const
	Returns the volume for the given grain number. More...

Protected Attributes
const bool	_single_feature_per_elem
	A Boolean indicating how the volume is calculated. More...
const bool	_output_centroids
const FeatureFloodCount &	_feature_counter
	A reference to the feature flood count object. More...
VectorPostprocessorValue &	_var_num
VectorPostprocessorValue &	_feature_volumes
VectorPostprocessorValue &	_intersects_bounds

Private Member Functions
void	accumulateVolumes (const Elem *elem, const std::vector< unsigned int > &var_to_features, std::size_t num_features)
	Add volume contributions to one or entries in the feature volume vector. More...
Real	computeIntegral (std::size_t var_index) const
	Calculate the integral value of the passed in variable (index) More...

Private Attributes
const std::vector< MooseVariableFEBase * > &	_vars
std::vector< const VariableValue * >	_coupled_sln
MooseMesh &	_mesh
Assembly &	_assembly
const MooseArray< Point > &	_q_point
QBase *&	_qrule
const MooseArray< Real > &	_JxW
const MooseArray< Real > &	_coord

Detailed Description

This VectorPostprocessor is intended to be used to calculate accurate volumes from the FeatureFloodCount and/or GrainTracker objects.

It is a GeneralVectorPostProcessor instead of the more natural elemental kind so that dependency resolution will work properly when an AuxVariable is not depending on the FeatureFloodCount object. It obtains the coupled variables from the FeatureFloodCount object so that there's one less thing for the user of this class to worry about.

Definition at line 33 of file FeatureVolumeVectorPostprocessor.h.

Constructor & Destructor Documentation

FeatureVolumeVectorPostprocessor()

FeatureVolumeVectorPostprocessor::FeatureVolumeVectorPostprocessor

(

const InputParameters &

parameters

)

Definition at line 44 of file FeatureVolumeVectorPostprocessor.C.

  : GeneralVectorPostprocessor(parameters),
    MooseVariableDependencyInterface(),
    _single_feature_per_elem(getParam<bool>("single_feature_per_element")),
    _output_centroids(getParam<bool>("output_centroids")),
    _feature_counter(getUserObject<FeatureFloodCount>("flood_counter")),
    _var_num(declareVector("var_num")),
    _feature_volumes(declareVector("feature_volumes")),
    _intersects_bounds(declareVector("intersects_bounds")),
    _vars(_feature_counter.getFECoupledVars()),
    _mesh(_subproblem.mesh()),
    _assembly(_subproblem.assembly(_tid)),
    _q_point(_assembly.qPoints()),
    _qrule(_assembly.qRule()),
    _JxW(_assembly.JxW()),
    _coord(_assembly.coordTransformation())
{
  addMooseVariableDependency(_vars);

  _coupled_sln.reserve(_vars.size());
  for (auto & var : _feature_counter.getCoupledVars())
    _coupled_sln.push_back(&var->sln());
}

Member Function Documentation

accumulateVolumes()

void FeatureVolumeVectorPostprocessor::accumulateVolumes ( const Elem *  elem, const std::vector< unsigned int > &  var_to_features, std::size_t  num_features  )

private

Add volume contributions to one or entries in the feature volume vector.

Definition at line 144 of file FeatureVolumeVectorPostprocessor.C.

Referenced by execute().

{
  unsigned int dominant_feature_id = FeatureFloodCount::invalid_id;
  Real max_var_value = std::numeric_limits<Real>::lowest();

  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);

      // Compute volumes in a simplistic but domain conservative fashion
      if (_single_feature_per_elem)
      {
        if (integral_value > max_var_value)
        {
          // Update the current dominant feature and associated value
          max_var_value = integral_value;
          dominant_feature_id = feature_id;
        }
      }
      // Solution based volume calculation (integral value)
      else
        _feature_volumes[feature_id] += integral_value;
    }
  }

  // Accumulate the entire element volume into the dominant feature. Do not use the integral value
  if (_single_feature_per_elem && dominant_feature_id != FeatureFloodCount::invalid_id)
    _feature_volumes[dominant_feature_id] += elem->volume();
}

computeIntegral()

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

private

Calculate the integral value of the passed in variable (index)

Definition at line 184 of file FeatureVolumeVectorPostprocessor.C.

Referenced by accumulateVolumes().

{
  Real sum = 0;

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

  return sum;
}

execute()

void FeatureVolumeVectorPostprocessor::execute ( )

overridevirtual

Here we retrieve the var to features vector on the current element. We'll use that information to figure out which variables are non-zero (from a threshold perspective) then we can sum those values into appropriate grain index locations.

Definition at line 75 of file FeatureVolumeVectorPostprocessor.C.

{
  const auto num_features = _feature_counter.getTotalFeatureCount();

  // Reset the variable index and intersect bounds vectors
  _var_num.assign(num_features, -1);           // Invalid
  _intersects_bounds.assign(num_features, -1); // Invalid
  for (auto feature_num = beginIndex(_var_num); feature_num < num_features; ++feature_num)
  {
    auto var_num = _feature_counter.getFeatureVar(feature_num);
    if (var_num != FeatureFloodCount::invalid_id)
      _var_num[feature_num] = var_num;

    _intersects_bounds[feature_num] =
        static_cast<unsigned int>(_feature_counter.doesFeatureIntersectBoundary(feature_num));
  }

  if (_output_centroids)
  {
    VectorPostprocessorValue & center_x = declareVector("centroid_x");
    center_x.resize(num_features);
    VectorPostprocessorValue & center_y = declareVector("centroid_y");
    center_y.resize(num_features);
    VectorPostprocessorValue & center_z = declareVector("centroid_z");
    center_z.resize(num_features);

    for (auto feature_num = beginIndex(_var_num); feature_num < num_features; ++feature_num)
    {
      auto p = _feature_counter.featureCentroid(feature_num);
      center_x[feature_num] = p(0);
      center_y[feature_num] = p(1);
      center_z[feature_num] = p(2);
    }
  }

  // Reset the volume vector
  _feature_volumes.assign(num_features, 0);
  for (const auto & elem : _mesh.getMesh().active_local_element_ptr_range())
  {
    _fe_problem.prepare(elem, 0);
    _fe_problem.reinitElem(elem, 0);

    const auto & var_to_features = _feature_counter.getVarToFeatureVector(elem->id());

    accumulateVolumes(elem, var_to_features, num_features);
  }
}

finalize()

void FeatureVolumeVectorPostprocessor::finalize ( )

overridevirtual

Definition at line 130 of file FeatureVolumeVectorPostprocessor.C.

{
  // Do the parallel sum
  _communicator.sum(_feature_volumes);
}

getFeatureVolume()

Real FeatureVolumeVectorPostprocessor::getFeatureVolume

(

unsigned int

feature_id

)

const

Returns the volume for the given grain number.

Definition at line 137 of file FeatureVolumeVectorPostprocessor.C.

{
  mooseAssert(feature_id < _feature_volumes.size(), "feature_id is out of range");
  return _feature_volumes[feature_id];
}

initialize()

void FeatureVolumeVectorPostprocessor::initialize ( )

overridevirtual

Definition at line 70 of file FeatureVolumeVectorPostprocessor.C.

{
}

Member Data Documentation

_assembly

Assembly& FeatureVolumeVectorPostprocessor::_assembly

private

Definition at line 73 of file FeatureVolumeVectorPostprocessor.h.

_coord

const MooseArray<Real>& FeatureVolumeVectorPostprocessor::_coord

private

Definition at line 77 of file FeatureVolumeVectorPostprocessor.h.

Referenced by computeIntegral().

_coupled_sln

std::vector<const VariableValue *> FeatureVolumeVectorPostprocessor::_coupled_sln

private

Definition at line 70 of file FeatureVolumeVectorPostprocessor.h.

Referenced by computeIntegral(), and FeatureVolumeVectorPostprocessor().

_feature_counter

const FeatureFloodCount& FeatureVolumeVectorPostprocessor::_feature_counter

protected

A reference to the feature flood count object.

Definition at line 54 of file FeatureVolumeVectorPostprocessor.h.

Referenced by execute(), and FeatureVolumeVectorPostprocessor().

_feature_volumes

VectorPostprocessorValue& FeatureVolumeVectorPostprocessor::_feature_volumes

protected

Definition at line 57 of file FeatureVolumeVectorPostprocessor.h.

Referenced by accumulateVolumes(), execute(), finalize(), and getFeatureVolume().

_intersects_bounds

VectorPostprocessorValue& FeatureVolumeVectorPostprocessor::_intersects_bounds

protected

Definition at line 58 of file FeatureVolumeVectorPostprocessor.h.

Referenced by execute().

_JxW

const MooseArray<Real>& FeatureVolumeVectorPostprocessor::_JxW

private

Definition at line 76 of file FeatureVolumeVectorPostprocessor.h.

Referenced by computeIntegral().

_mesh

MooseMesh& FeatureVolumeVectorPostprocessor::_mesh

private

Definition at line 72 of file FeatureVolumeVectorPostprocessor.h.

Referenced by execute().

_output_centroids

const bool FeatureVolumeVectorPostprocessor::_output_centroids

protected

Definition at line 51 of file FeatureVolumeVectorPostprocessor.h.

Referenced by execute().

_q_point

const MooseArray<Point>& FeatureVolumeVectorPostprocessor::_q_point

private

Definition at line 74 of file FeatureVolumeVectorPostprocessor.h.

_qrule

QBase*& FeatureVolumeVectorPostprocessor::_qrule

private

Definition at line 75 of file FeatureVolumeVectorPostprocessor.h.

Referenced by computeIntegral().

_single_feature_per_elem

const bool FeatureVolumeVectorPostprocessor::_single_feature_per_elem

protected

A Boolean indicating how the volume is calculated.

Definition at line 50 of file FeatureVolumeVectorPostprocessor.h.

Referenced by accumulateVolumes().

_var_num

VectorPostprocessorValue& FeatureVolumeVectorPostprocessor::_var_num

protected

Definition at line 56 of file FeatureVolumeVectorPostprocessor.h.

Referenced by execute().

_vars

const std::vector<MooseVariableFEBase *>& FeatureVolumeVectorPostprocessor::_vars

private

Definition at line 69 of file FeatureVolumeVectorPostprocessor.h.

Referenced by FeatureVolumeVectorPostprocessor().

---

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

• phase_field/include/vectorpostprocessors/FeatureVolumeVectorPostprocessor.h
• phase_field/src/vectorpostprocessors/FeatureVolumeVectorPostprocessor.C