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:

[legend]

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

VectorPostprocessorValue &	_intersects_specified_bounds

VectorPostprocessorValue &	_percolated

bool	_is_boundary_restricted
	Indicates whether the calculation should be run on volumes or area of a boundary. More...

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...

void	accumulateBoundaryFaces (const Elem *elem, const std::vector< unsigned int > &var_to_features, std::size_t num_features, unsigned int side)
	When boundary is supplied as input, compute coverage of that boundary by each feature. More...

Real	computeIntegral (std::size_t var_index) const
	Calculate the integral value of the passed in variable (index) More...

Real	computeFaceIntegral (std::size_t var_index) const
	Calculate the integral on the face if boundary is supplied as input. More...

Private Attributes
const std::vector< MooseVariableFEBase * > &	_vars

std::vector< const VariableValue * >	_coupled_sln

MooseMesh &	_mesh

Assembly &	_assembly

const MooseArray< Point > &	_q_point

const QBase *const &	_qrule

const MooseArray< Real > &	_JxW

const MooseArray< Real > &	_coord

const QBase *const &	_qrule_face

const MooseArray< Real > &	_JxW_face

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 47 of file FeatureVolumeVectorPostprocessor.C.

   : GeneralVectorPostprocessor(parameters),
     MooseVariableDependencyInterface(),
     BoundaryRestrictable(this, false),
     _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")),
     _intersects_specified_bounds(declareVector("intersects_specified_bounds")),
     _percolated(declareVector("percolated")),
     _vars(_feature_counter.getFECoupledVars()),
     _mesh(_subproblem.mesh()),
     _assembly(_subproblem.assembly(_tid)),
     _q_point(_assembly.qPoints()),
     _qrule(_assembly.qRule()),
     _JxW(_assembly.JxW()),
     _coord(_assembly.coordTransformation()),
     _qrule_face(_assembly.qRuleFace()),
     _JxW_face(_assembly.JxWFace())
 {
   addMooseVariableDependency(_vars);
  
   _is_boundary_restricted = boundaryRestricted();
  
   _coupled_sln.reserve(_vars.size());
   for (auto & var : _feature_counter.getCoupledVars())
     _coupled_sln.push_back(&var->sln());
 }

Member Function Documentation

◆ accumulateBoundaryFaces()

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

private

When boundary is supplied as input, compute coverage of that boundary by each feature.

Definition at line 242 of file FeatureVolumeVectorPostprocessor.C.

 {
   unsigned int dominant_feature_id = FeatureFloodCount::invalid_id;
   Real max_var_value = std::numeric_limits<Real>::lowest();
  
   for (MooseIndex(var_to_features) var_index = 0; 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 = computeFaceIntegral(var_index);
  
       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 boundary area/length calculation (integral value)
       else
         _feature_volumes[feature_id] += integral_value;
     }
   }
  
   // Accumulate the boundary area/length 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->side_ptr(side)->volume();
 }

Referenced by execute().

◆ 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 192 of file FeatureVolumeVectorPostprocessor.C.

 {
   unsigned int dominant_feature_id = FeatureFloodCount::invalid_id;
   Real max_var_value = std::numeric_limits<Real>::lowest();
  
   for (MooseIndex(var_to_features) var_index = 0; 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();
 }

Referenced by execute().

◆ computeFaceIntegral()

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

private

Calculate the integral on the face if boundary is supplied as input.

Definition at line 281 of file FeatureVolumeVectorPostprocessor.C.

 {
   Real sum = 0;
   for (unsigned int qp = 0; qp < _qrule_face->n_points(); ++qp)
     sum += _JxW_face[qp] * _coord[qp] * (*_coupled_sln[var_index])[qp];
  
   return sum;
 }

Referenced by accumulateBoundaryFaces().

◆ computeIntegral()

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

private

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

Definition at line 231 of file FeatureVolumeVectorPostprocessor.C.

 {
   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;
 }

Referenced by accumulateVolumes().

◆ 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 85 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
   _intersects_specified_bounds.assign(num_features, -1); // Invalid
   _percolated.assign(num_features, -1);                  // Invalid
   for (MooseIndex(num_features) feature_num = 0; 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));
  
     _intersects_specified_bounds[feature_num] = static_cast<unsigned int>(
         _feature_counter.doesFeatureIntersectSpecifiedBoundary(feature_num));
  
     _percolated[feature_num] =
         static_cast<unsigned int>(_feature_counter.isFeaturePercolated(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 (MooseIndex(_var_num) feature_num = 0; 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);
  
   // Calculate coverage of a boundary if one has been supplied in the input file
   if (_is_boundary_restricted)
   {
     const std::set<BoundaryID> supplied_bnd_ids = BoundaryRestrictable::boundaryIDs();
     for (auto elem_it = _mesh.bndElemsBegin(), elem_end = _mesh.bndElemsEnd(); elem_it != elem_end;
          ++elem_it)
  
       // loop over only boundaries supplied by user in boundary param
       for (auto & supplied_bnd_id : supplied_bnd_ids)
         if (((*elem_it)->_bnd_id) == supplied_bnd_id)
         {
           const auto & elem = (*elem_it)->_elem;
           auto rank = processor_id();
  
           if (elem->processor_id() == rank)
           {
             _fe_problem.setCurrentSubdomainID(elem, 0);
             _fe_problem.prepare(elem, 0);
             _fe_problem.reinitElem(elem, 0);
             _fe_problem.reinitElemFace(elem, (*elem_it)->_side, (*elem_it)->_bnd_id, 0);
  
             const auto & var_to_features = _feature_counter.getVarToFeatureVector(elem->id());
  
             accumulateBoundaryFaces(elem, var_to_features, num_features, (*elem_it)->_side);
           }
         }
   }
   else // If no boundary is supplied, calculate volumes of features as normal
     for (const auto & elem : _mesh.getMesh().active_local_element_ptr_range())
     {
       _fe_problem.setCurrentSubdomainID(elem, 0);
       _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 178 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 185 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 80 of file FeatureVolumeVectorPostprocessor.C.

81 {

82 }

Member Data Documentation

◆ _assembly

Assembly& FeatureVolumeVectorPostprocessor::_assembly

private

Definition at line 88 of file FeatureVolumeVectorPostprocessor.h.

◆ _coord

const MooseArray<Real>& FeatureVolumeVectorPostprocessor::_coord

private

Definition at line 92 of file FeatureVolumeVectorPostprocessor.h.

Referenced by computeFaceIntegral(), and computeIntegral().

◆ _coupled_sln

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

private

Definition at line 85 of file FeatureVolumeVectorPostprocessor.h.

Referenced by computeFaceIntegral(), computeIntegral(), and FeatureVolumeVectorPostprocessor().

◆ _feature_counter

const FeatureFloodCount& FeatureVolumeVectorPostprocessor::_feature_counter

protected

A reference to the feature flood count object.

Definition at line 55 of file FeatureVolumeVectorPostprocessor.h.

Referenced by execute(), and FeatureVolumeVectorPostprocessor().

◆ _feature_volumes

VectorPostprocessorValue& FeatureVolumeVectorPostprocessor::_feature_volumes

protected

Definition at line 58 of file FeatureVolumeVectorPostprocessor.h.

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

◆ _intersects_bounds

VectorPostprocessorValue& FeatureVolumeVectorPostprocessor::_intersects_bounds

protected

Definition at line 59 of file FeatureVolumeVectorPostprocessor.h.

Referenced by execute().

◆ _intersects_specified_bounds

VectorPostprocessorValue& FeatureVolumeVectorPostprocessor::_intersects_specified_bounds

protected

Definition at line 60 of file FeatureVolumeVectorPostprocessor.h.

Referenced by execute().

◆ _is_boundary_restricted

bool FeatureVolumeVectorPostprocessor::_is_boundary_restricted

protected

Indicates whether the calculation should be run on volumes or area of a boundary.

Definition at line 64 of file FeatureVolumeVectorPostprocessor.h.

Referenced by execute(), and FeatureVolumeVectorPostprocessor().

◆ _JxW

const MooseArray<Real>& FeatureVolumeVectorPostprocessor::_JxW

private

Definition at line 91 of file FeatureVolumeVectorPostprocessor.h.

Referenced by computeIntegral().

◆ _JxW_face

const MooseArray<Real>& FeatureVolumeVectorPostprocessor::_JxW_face

private

Definition at line 94 of file FeatureVolumeVectorPostprocessor.h.

Referenced by computeFaceIntegral().

◆ _mesh

MooseMesh& FeatureVolumeVectorPostprocessor::_mesh

private

Definition at line 87 of file FeatureVolumeVectorPostprocessor.h.

Referenced by execute().

◆ _output_centroids

const bool FeatureVolumeVectorPostprocessor::_output_centroids

protected

Definition at line 52 of file FeatureVolumeVectorPostprocessor.h.

Referenced by execute().

◆ _percolated

VectorPostprocessorValue& FeatureVolumeVectorPostprocessor::_percolated

protected

Definition at line 61 of file FeatureVolumeVectorPostprocessor.h.

Referenced by execute().

◆ _q_point

const MooseArray<Point>& FeatureVolumeVectorPostprocessor::_q_point

private

Definition at line 89 of file FeatureVolumeVectorPostprocessor.h.

◆ _qrule

const QBase* const & FeatureVolumeVectorPostprocessor::_qrule

private

Definition at line 90 of file FeatureVolumeVectorPostprocessor.h.

Referenced by computeIntegral().

◆ _qrule_face

const QBase* const & FeatureVolumeVectorPostprocessor::_qrule_face

private

Definition at line 93 of file FeatureVolumeVectorPostprocessor.h.

Referenced by computeFaceIntegral().

◆ _single_feature_per_elem

const bool FeatureVolumeVectorPostprocessor::_single_feature_per_elem

protected

A Boolean indicating how the volume is calculated.

Definition at line 51 of file FeatureVolumeVectorPostprocessor.h.

Referenced by accumulateBoundaryFaces(), and accumulateVolumes().

◆ _var_num

VectorPostprocessorValue& FeatureVolumeVectorPostprocessor::_var_num

protected

Definition at line 57 of file FeatureVolumeVectorPostprocessor.h.

Referenced by execute().

◆ _vars

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

private

Definition at line 84 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

Public Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ FeatureVolumeVectorPostprocessor()

Member Function Documentation

◆ accumulateBoundaryFaces()

◆ accumulateVolumes()

◆ computeFaceIntegral()

◆ computeIntegral()

◆ execute()

◆ finalize()

◆ getFeatureVolume()

◆ initialize()

Member Data Documentation

◆ _assembly

◆ _coord

◆ _coupled_sln

◆ _feature_counter

◆ _feature_volumes

◆ _intersects_bounds

◆ _intersects_specified_bounds

◆ _is_boundary_restricted

◆ _JxW

◆ _JxW_face

◆ _mesh

◆ _output_centroids

◆ _percolated

◆ _q_point

◆ _qrule

◆ _qrule_face

◆ _single_feature_per_elem

◆ _var_num

◆ _vars