www.mooseframework.org
Public Member Functions | Protected Attributes | Private Member Functions | Private Attributes | List of all members
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:
[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 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< MooseVariable * > & _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 31 of file FeatureVolumeVectorPostprocessor.h.

Constructor & Destructor Documentation

FeatureVolumeVectorPostprocessor::FeatureVolumeVectorPostprocessor ( const InputParameters &  parameters)

Definition at line 35 of file FeatureVolumeVectorPostprocessor.C.

37  : GeneralVectorPostprocessor(parameters),
38  MooseVariableDependencyInterface(),
39  _single_feature_per_elem(getParam<bool>("single_feature_per_element")),
40  _feature_counter(getUserObject<FeatureFloodCount>("flood_counter")),
41  _var_num(declareVector("var_num")),
42  _feature_volumes(declareVector("feature_volumes")),
43  _intersects_bounds(declareVector("intersects_bounds")),
45  _mesh(_subproblem.mesh()),
46  _assembly(_subproblem.assembly(_tid)),
47  _q_point(_assembly.qPoints()),
48  _qrule(_assembly.qRule()),
49  _JxW(_assembly.JxW()),
50  _coord(_assembly.coordTransformation())
51 {
52  addMooseVariableDependency(_vars);
53 
54  _coupled_sln.reserve(_vars.size());
55  for (auto & var : _vars)
56  _coupled_sln.push_back(&var->sln());
57 }
const std::vector< MooseVariable * > & _vars
const std::vector< MooseVariable * > & getCoupledVars() const
Returns a const vector to the coupled variable pointers.
const FeatureFloodCount & _feature_counter
A reference to the feature flood count object.
std::vector< const VariableValue * > _coupled_sln
const bool _single_feature_per_elem
A Boolean indicating how the volume is calculated.

Member Function Documentation

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

Referenced by execute().

122 {
123  unsigned int dominant_feature_id = FeatureFloodCount::invalid_id;
124  Real max_var_value = std::numeric_limits<Real>::lowest();
125 
126  for (auto var_index = beginIndex(var_to_features); var_index < var_to_features.size();
127  ++var_index)
128  {
129  // Only sample "active" variables
130  if (var_to_features[var_index] != FeatureFloodCount::invalid_id)
131  {
132  auto feature_id = var_to_features[var_index];
133  mooseAssert(feature_id < num_features, "Feature ID out of range");
134  auto integral_value = computeIntegral(var_index);
135 
136  // Compute volumes in a simplistic but domain conservative fashion
138  {
139  if (integral_value > max_var_value)
140  {
141  // Update the current dominant feature and associated value
142  max_var_value = integral_value;
143  dominant_feature_id = feature_id;
144  }
145  }
146  // Solution based volume calculation (integral value)
147  else
148  _feature_volumes[feature_id] += integral_value;
149  }
150  }
151 
152  // Accumulate the entire element volume into the dominant feature. Do not use the integral value
153  if (_single_feature_per_elem && dominant_feature_id != FeatureFloodCount::invalid_id)
154  _feature_volumes[dominant_feature_id] += elem->volume();
155 }
Real computeIntegral(std::size_t var_index) const
Calculate the integral value of the passed in variable (index)
static const unsigned int invalid_id
const bool _single_feature_per_elem
A Boolean indicating how the volume is calculated.
Real FeatureVolumeVectorPostprocessor::computeIntegral ( std::size_t  var_index) const
private

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

Definition at line 158 of file FeatureVolumeVectorPostprocessor.C.

Referenced by accumulateVolumes().

159 {
160  Real sum = 0;
161 
162  for (unsigned int qp = 0; qp < _qrule->n_points(); ++qp)
163  sum += _JxW[qp] * _coord[qp] * (*_coupled_sln[var_index])[qp];
164 
165  return sum;
166 }
std::vector< const VariableValue * > _coupled_sln
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 65 of file FeatureVolumeVectorPostprocessor.C.

66 {
67  const auto num_features = _feature_counter.getTotalFeatureCount();
68 
69  // Reset the variable index and intersect bounds vectors
70  _var_num.assign(num_features, -1); // Invalid
71  _intersects_bounds.assign(num_features, -1); // Invalid
72  for (auto feature_num = beginIndex(_var_num); feature_num < num_features; ++feature_num)
73  {
74  auto var_num = _feature_counter.getFeatureVar(feature_num);
75  if (var_num != FeatureFloodCount::invalid_id)
76  _var_num[feature_num] = var_num;
77 
78  _intersects_bounds[feature_num] =
79  static_cast<unsigned int>(_feature_counter.doesFeatureIntersectBoundary(feature_num));
80  }
81 
82  // Reset the volume vector
83  _feature_volumes.assign(num_features, 0);
84  const auto end = _mesh.getMesh().active_local_elements_end();
85  for (auto el = _mesh.getMesh().active_local_elements_begin(); el != end; ++el)
86  {
87  const Elem * elem = *el;
88  _fe_problem.prepare(elem, 0);
89  _fe_problem.reinitElem(elem, 0);
90 
97  const auto & var_to_features = _feature_counter.getVarToFeatureVector(elem->id());
98 
99  accumulateVolumes(elem, var_to_features, num_features);
100  }
101 }
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.
virtual unsigned int getFeatureVar(unsigned int feature_id) const
Returns the variable representing the passed in feature.
virtual std::size_t getTotalFeatureCount() const
Returns the total feature count (active and inactive ids, useful for sizing vectors) ...
const FeatureFloodCount & _feature_counter
A reference to the feature flood count object.
static const unsigned int invalid_id
virtual const std::vector< unsigned int > & getVarToFeatureVector(dof_id_type elem_id) const
Returns a list of active unique feature ids for a particular element.
virtual bool doesFeatureIntersectBoundary(unsigned int feature_id) const
Returns a Boolean indicating whether this feature intersects any boundary.
void FeatureVolumeVectorPostprocessor::finalize ( )
overridevirtual

Definition at line 104 of file FeatureVolumeVectorPostprocessor.C.

105 {
106  // Do the parallel sum
107  _communicator.sum(_feature_volumes);
108 }
Real FeatureVolumeVectorPostprocessor::getFeatureVolume ( unsigned int  feature_id) const

Returns the volume for the given grain number.

Definition at line 111 of file FeatureVolumeVectorPostprocessor.C.

112 {
113  mooseAssert(feature_id < _feature_volumes.size(), "feature_id is out of range");
114  return _feature_volumes[feature_id];
115 }
void FeatureVolumeVectorPostprocessor::initialize ( )
overridevirtual

Definition at line 60 of file FeatureVolumeVectorPostprocessor.C.

61 {
62 }

Member Data Documentation

Assembly& FeatureVolumeVectorPostprocessor::_assembly
private

Definition at line 70 of file FeatureVolumeVectorPostprocessor.h.

const MooseArray<Real>& FeatureVolumeVectorPostprocessor::_coord
private

Definition at line 74 of file FeatureVolumeVectorPostprocessor.h.

Referenced by computeIntegral().

std::vector<const VariableValue *> FeatureVolumeVectorPostprocessor::_coupled_sln
private
const FeatureFloodCount& FeatureVolumeVectorPostprocessor::_feature_counter
protected

A reference to the feature flood count object.

Definition at line 51 of file FeatureVolumeVectorPostprocessor.h.

Referenced by execute().

VectorPostprocessorValue& FeatureVolumeVectorPostprocessor::_feature_volumes
protected
VectorPostprocessorValue& FeatureVolumeVectorPostprocessor::_intersects_bounds
protected

Definition at line 55 of file FeatureVolumeVectorPostprocessor.h.

Referenced by execute().

const MooseArray<Real>& FeatureVolumeVectorPostprocessor::_JxW
private

Definition at line 73 of file FeatureVolumeVectorPostprocessor.h.

Referenced by computeIntegral().

MooseMesh& FeatureVolumeVectorPostprocessor::_mesh
private

Definition at line 69 of file FeatureVolumeVectorPostprocessor.h.

Referenced by execute().

const MooseArray<Point>& FeatureVolumeVectorPostprocessor::_q_point
private

Definition at line 71 of file FeatureVolumeVectorPostprocessor.h.

QBase*& FeatureVolumeVectorPostprocessor::_qrule
private

Definition at line 72 of file FeatureVolumeVectorPostprocessor.h.

Referenced by computeIntegral().

const bool FeatureVolumeVectorPostprocessor::_single_feature_per_elem
protected

A Boolean indicating how the volume is calculated.

Definition at line 48 of file FeatureVolumeVectorPostprocessor.h.

Referenced by accumulateVolumes().

VectorPostprocessorValue& FeatureVolumeVectorPostprocessor::_var_num
protected

Definition at line 53 of file FeatureVolumeVectorPostprocessor.h.

Referenced by execute().

const std::vector<MooseVariable *>& FeatureVolumeVectorPostprocessor::_vars
private

Definition at line 66 of file FeatureVolumeVectorPostprocessor.h.

Referenced by FeatureVolumeVectorPostprocessor().


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