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 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 & _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
 
QBase *& _qrule
 
const MooseArray< Real > & _JxW
 
const MooseArray< Real > & _coord
 
QBase *& _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 34 of file FeatureVolumeVectorPostprocessor.h.

Constructor & Destructor Documentation

◆ FeatureVolumeVectorPostprocessor()

FeatureVolumeVectorPostprocessor::FeatureVolumeVectorPostprocessor ( const InputParameters &  parameters)

Definition at line 45 of file FeatureVolumeVectorPostprocessor.C.

47  : GeneralVectorPostprocessor(parameters),
48  MooseVariableDependencyInterface(),
49  BoundaryRestrictable(this, false),
50  _single_feature_per_elem(getParam<bool>("single_feature_per_element")),
51  _output_centroids(getParam<bool>("output_centroids")),
52  _feature_counter(getUserObject<FeatureFloodCount>("flood_counter")),
53  _var_num(declareVector("var_num")),
54  _feature_volumes(declareVector("feature_volumes")),
55  _intersects_bounds(declareVector("intersects_bounds")),
56  _percolated(declareVector("percolated")),
58  _mesh(_subproblem.mesh()),
59  _assembly(_subproblem.assembly(_tid)),
60  _q_point(_assembly.qPoints()),
61  _qrule(_assembly.qRule()),
62  _JxW(_assembly.JxW()),
63  _coord(_assembly.coordTransformation()),
64  _qrule_face(_assembly.qRuleFace()),
65  _JxW_face(_assembly.JxWFace())
66 {
67  addMooseVariableDependency(_vars);
68 
69  _is_boundary_restricted = boundaryRestricted();
70 
71  _coupled_sln.reserve(_vars.size());
72  for (auto & var : _feature_counter.getCoupledVars())
73  _coupled_sln.push_back(&var->sln());
74 }
const std::vector< MooseVariableFEBase * > & _vars
const std::vector< MooseVariable * > & getCoupledVars() const
Returns a const vector to the coupled variable pointers.
bool _is_boundary_restricted
Indicates whether the calculation should be run on volumes or area of a boundary. ...
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.
const std::vector< MooseVariableFEBase * > & getFECoupledVars() const
Returns a const vector to the coupled MooseVariableFEBase pointers.

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

Referenced by execute().

240 {
241  unsigned int dominant_feature_id = FeatureFloodCount::invalid_id;
242  Real max_var_value = std::numeric_limits<Real>::lowest();
243 
244  for (MooseIndex(var_to_features) var_index = 0; var_index < var_to_features.size(); ++var_index)
245  {
246  // Only sample "active" variables
247  if (var_to_features[var_index] != FeatureFloodCount::invalid_id)
248  {
249  auto feature_id = var_to_features[var_index];
250  mooseAssert(feature_id < num_features, "Feature ID out of range");
251  auto integral_value = computeFaceIntegral(var_index);
252 
254  {
255  if (integral_value > max_var_value)
256  {
257  // Update the current dominant feature and associated value
258  max_var_value = integral_value;
259  dominant_feature_id = feature_id;
260  }
261  }
262  // Solution based boundary area/length calculation (integral value)
263  else
264  _feature_volumes[feature_id] += integral_value;
265  }
266  }
267 
268  // Accumulate the boundary area/length into the dominant feature. Do not use the integral value
269  if (_single_feature_per_elem && dominant_feature_id != FeatureFloodCount::invalid_id)
270  _feature_volumes[dominant_feature_id] += elem->side_ptr(side)->volume();
271 }
static const unsigned int invalid_id
Real computeFaceIntegral(std::size_t var_index) const
Calculate the integral on the face if boundary is supplied as input.
const bool _single_feature_per_elem
A Boolean indicating how the volume is calculated.

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

Referenced by execute().

189 {
190  unsigned int dominant_feature_id = FeatureFloodCount::invalid_id;
191  Real max_var_value = std::numeric_limits<Real>::lowest();
192 
193  for (MooseIndex(var_to_features) var_index = 0; var_index < var_to_features.size(); ++var_index)
194  {
195  // Only sample "active" variables
196  if (var_to_features[var_index] != FeatureFloodCount::invalid_id)
197  {
198  auto feature_id = var_to_features[var_index];
199  mooseAssert(feature_id < num_features, "Feature ID out of range");
200  auto integral_value = computeIntegral(var_index);
201 
202  // Compute volumes in a simplistic but domain conservative fashion
204  {
205  if (integral_value > max_var_value)
206  {
207  // Update the current dominant feature and associated value
208  max_var_value = integral_value;
209  dominant_feature_id = feature_id;
210  }
211  }
212  // Solution based volume calculation (integral value)
213  else
214  _feature_volumes[feature_id] += integral_value;
215  }
216  }
217 
218  // Accumulate the entire element volume into the dominant feature. Do not use the integral value
219  if (_single_feature_per_elem && dominant_feature_id != FeatureFloodCount::invalid_id)
220  _feature_volumes[dominant_feature_id] += elem->volume();
221 }
static const unsigned int invalid_id
const bool _single_feature_per_elem
A Boolean indicating how the volume is calculated.
Real computeIntegral(std::size_t var_index) const
Calculate the integral value of the passed in variable (index)

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

Referenced by accumulateBoundaryFaces().

275 {
276  Real sum = 0;
277  for (unsigned int qp = 0; qp < _qrule_face->n_points(); ++qp)
278  sum += _JxW_face[qp] * _coord[qp] * (*_coupled_sln[var_index])[qp];
279 
280  return sum;
281 }
std::vector< const VariableValue * > _coupled_sln

◆ computeIntegral()

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

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

Definition at line 224 of file FeatureVolumeVectorPostprocessor.C.

Referenced by accumulateVolumes().

225 {
226  Real sum = 0;
227 
228  for (unsigned int qp = 0; qp < _qrule->n_points(); ++qp)
229  sum += _JxW[qp] * _coord[qp] * (*_coupled_sln[var_index])[qp];
230 
231  return sum;
232 }
std::vector< const VariableValue * > _coupled_sln

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

83 {
84  const auto num_features = _feature_counter.getTotalFeatureCount();
85 
86  // Reset the variable index and intersect bounds vectors
87  _var_num.assign(num_features, -1); // Invalid
88  _intersects_bounds.assign(num_features, -1); // Invalid
89  _percolated.assign(num_features, -1); // Invalid
90  for (MooseIndex(num_features) feature_num = 0; feature_num < num_features; ++feature_num)
91  {
92  auto var_num = _feature_counter.getFeatureVar(feature_num);
93  if (var_num != FeatureFloodCount::invalid_id)
94  _var_num[feature_num] = var_num;
95 
96  _intersects_bounds[feature_num] =
97  static_cast<unsigned int>(_feature_counter.doesFeatureIntersectBoundary(feature_num));
98 
99  _percolated[feature_num] =
100  static_cast<unsigned int>(_feature_counter.isFeaturePercolated(feature_num));
101  }
102 
103  if (_output_centroids)
104  {
105  VectorPostprocessorValue & center_x = declareVector("centroid_x");
106  center_x.resize(num_features);
107  VectorPostprocessorValue & center_y = declareVector("centroid_y");
108  center_y.resize(num_features);
109  VectorPostprocessorValue & center_z = declareVector("centroid_z");
110  center_z.resize(num_features);
111 
112  for (MooseIndex(_var_num) feature_num = 0; feature_num < num_features; ++feature_num)
113  {
114  auto p = _feature_counter.featureCentroid(feature_num);
115  center_x[feature_num] = p(0);
116  center_y[feature_num] = p(1);
117  center_z[feature_num] = p(2);
118  }
119  }
120 
121  // Reset the volume vector
122  _feature_volumes.assign(num_features, 0);
123 
124  // Calculate coverage of a boundary if one has been supplied in the input file
126  {
127  const std::set<BoundaryID> supplied_bnd_ids = BoundaryRestrictable::boundaryIDs();
128  for (auto elem_it = _mesh.bndElemsBegin(), elem_end = _mesh.bndElemsEnd(); elem_it != elem_end;
129  ++elem_it)
130 
131  // loop over only boundaries supplied by user in boundary param
132  for (auto & supplied_bnd_id : supplied_bnd_ids)
133  if (((*elem_it)->_bnd_id) == supplied_bnd_id)
134  {
135  const auto & elem = (*elem_it)->_elem;
136  auto rank = processor_id();
137 
138  if (elem->processor_id() == rank)
139  {
140  _fe_problem.setCurrentSubdomainID(elem, 0);
141  _fe_problem.prepare(elem, 0);
142  _fe_problem.reinitElem(elem, 0);
143  _fe_problem.reinitElemFace(elem, (*elem_it)->_side, (*elem_it)->_bnd_id, 0);
144 
145  const auto & var_to_features = _feature_counter.getVarToFeatureVector(elem->id());
146 
147  accumulateBoundaryFaces(elem, var_to_features, num_features, (*elem_it)->_side);
148  }
149  }
150  }
151  else // If no boundary is supplied, calculate volumes of features as normal
152  for (const auto & elem : _mesh.getMesh().active_local_element_ptr_range())
153  {
154  _fe_problem.setCurrentSubdomainID(elem, 0);
155  _fe_problem.prepare(elem, 0);
156  _fe_problem.reinitElem(elem, 0);
157 
164  const auto & var_to_features = _feature_counter.getVarToFeatureVector(elem->id());
165 
166  accumulateVolumes(elem, var_to_features, num_features);
167  }
168 }
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 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 std::size_t getTotalFeatureCount() const
Returns the total feature count (active and inactive ids, useful for sizing vectors) ...
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.
virtual bool isFeaturePercolated(unsigned int feature_id) const
Returns a Boolean indicating whether this feature is percolated (e.g.
virtual unsigned int getFeatureVar(unsigned int feature_id) const
Returns the variable representing the passed in feature.
bool _is_boundary_restricted
Indicates whether the calculation should be run on volumes or area of a boundary. ...
const FeatureFloodCount & _feature_counter
A reference to the feature flood count object.
static const unsigned int invalid_id
virtual bool doesFeatureIntersectBoundary(unsigned int feature_id) const
Returns a Boolean indicating whether this feature intersects any boundary.
virtual Point featureCentroid(unsigned int feature_id) const
Returns the centroid of the designated feature (only supported without periodic boundaries) ...

◆ finalize()

void FeatureVolumeVectorPostprocessor::finalize ( )
overridevirtual

Definition at line 171 of file FeatureVolumeVectorPostprocessor.C.

172 {
173  // Do the parallel sum
174  _communicator.sum(_feature_volumes);
175 }

◆ getFeatureVolume()

Real FeatureVolumeVectorPostprocessor::getFeatureVolume ( unsigned int  feature_id) const

Returns the volume for the given grain number.

Definition at line 178 of file FeatureVolumeVectorPostprocessor.C.

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

◆ initialize()

void FeatureVolumeVectorPostprocessor::initialize ( )
overridevirtual

Definition at line 77 of file FeatureVolumeVectorPostprocessor.C.

78 {
79 }

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

◆ _feature_counter

const FeatureFloodCount& FeatureVolumeVectorPostprocessor::_feature_counter
protected

A reference to the feature flood count object.

Definition at line 56 of file FeatureVolumeVectorPostprocessor.h.

Referenced by execute(), and FeatureVolumeVectorPostprocessor().

◆ _feature_volumes

VectorPostprocessorValue& FeatureVolumeVectorPostprocessor::_feature_volumes
protected

◆ _intersects_bounds

VectorPostprocessorValue& FeatureVolumeVectorPostprocessor::_intersects_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 53 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

QBase*& FeatureVolumeVectorPostprocessor::_qrule
private

Definition at line 90 of file FeatureVolumeVectorPostprocessor.h.

Referenced by computeIntegral().

◆ _qrule_face

QBase*& 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 52 of file FeatureVolumeVectorPostprocessor.h.

Referenced by accumulateBoundaryFaces(), and accumulateVolumes().

◆ _var_num

VectorPostprocessorValue& FeatureVolumeVectorPostprocessor::_var_num
protected

Definition at line 58 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: