FeatureFloodCount.C File Reference

Go to the source code of this file.

Functions
template<>
void	dataStore (std::ostream &stream, FeatureFloodCount::FeatureData &feature, void *context)
template<>
void	dataStore (std::ostream &stream, BoundingBox &bbox, void *context)
template<>
void	dataLoad (std::istream &stream, FeatureFloodCount::FeatureData &feature, void *context)
template<>
void	dataLoad (std::istream &stream, BoundingBox &bbox, void *context)
void	updateBBoxExtremesHelper (BoundingBox &bbox, const Point &node)
void	updateBBoxExtremesHelper (BoundingBox &bbox, const Elem &elem)
bool	areElemListsMergeable (const std::list< dof_id_type > &elem_list1, const std::list< dof_id_type > &elem_list2, MeshBase &mesh)
	registerMooseObject ("PhaseFieldApp", FeatureFloodCount)
template<>
InputParameters	validParams< FeatureFloodCount > ()
std::ostream &	operator<< (std::ostream &out, const FeatureFloodCount::FeatureData &feature)

Function Documentation

areElemListsMergeable()

bool areElemListsMergeable	(	const std::list< dof_id_type > &	elem_list1,
		const std::list< dof_id_type > &	elem_list2,
		MeshBase &	mesh
	)

Definition at line 2222 of file FeatureFloodCount.C.

{
  for (const auto elem_id1 : elem_list1)
  {
    const auto * elem1 = mesh.elem_ptr(elem_id1);
    for (const auto elem_id2 : elem_list2)
    {
      const auto * elem2 = mesh.elem_ptr(elem_id2);
      if (elem1->has_neighbor(elem2))
        return true;
    }
  }
  return false;

Referenced by FeatureFloodCount::FeatureData::updateBBoxExtremes().

dataLoad() [1/2]

template<>

void dataLoad	(	std::istream &	stream,
		BoundingBox &	bbox,
		void *	context
	)

Definition at line 87 of file FeatureFloodCount.C.

{
  loadHelper(stream, bbox.min(), context);
  loadHelper(stream, bbox.max(), context);
}

dataLoad() [2/2]

template<>

void dataLoad	(	std::istream &	stream,
		FeatureFloodCount::FeatureData &	feature,
		void *	context
	)

Note that _local_ids is not loaded here. It's not needed for restart, and not needed during the parallel merge operation

Definition at line 64 of file FeatureFloodCount.C.

{
  loadHelper(stream, feature._ghosted_ids, context);
  loadHelper(stream, feature._halo_ids, context);
  loadHelper(stream, feature._disjoint_halo_ids, context);
  loadHelper(stream, feature._periodic_nodes, context);
  loadHelper(stream, feature._var_index, context);
  loadHelper(stream, feature._id, context);
  loadHelper(stream, feature._bboxes, context);
  loadHelper(stream, feature._orig_ids, context);
  loadHelper(stream, feature._min_entity_id, context);
  loadHelper(stream, feature._vol_count, context);
  loadHelper(stream, feature._centroid, context);
  loadHelper(stream, feature._status, context);
  loadHelper(stream, feature._boundary_intersection, context);
}

Referenced by FeatureFloodCount::deserialize().

dataStore() [1/2]

template<>

void dataStore	(	std::ostream &	stream,
		BoundingBox &	bbox,
		void *	context
	)

Definition at line 56 of file FeatureFloodCount.C.

{
  storeHelper(stream, bbox.min(), context);
  storeHelper(stream, bbox.max(), context);
}

dataStore() [2/2]

template<>

void dataStore	(	std::ostream &	stream,
		FeatureFloodCount::FeatureData &	feature,
		void *	context
	)

Note that _local_ids is not stored here. It's not needed for restart, and not needed during the parallel merge operation

Definition at line 33 of file FeatureFloodCount.C.

{
  storeHelper(stream, feature._ghosted_ids, context);
  storeHelper(stream, feature._halo_ids, context);
  storeHelper(stream, feature._disjoint_halo_ids, context);
  storeHelper(stream, feature._periodic_nodes, context);
  storeHelper(stream, feature._var_index, context);
  storeHelper(stream, feature._id, context);
  storeHelper(stream, feature._bboxes, context);
  storeHelper(stream, feature._orig_ids, context);
  storeHelper(stream, feature._min_entity_id, context);
  storeHelper(stream, feature._vol_count, context);
  storeHelper(stream, feature._centroid, context);
  storeHelper(stream, feature._status, context);
  storeHelper(stream, feature._boundary_intersection, context);
}

Referenced by FeatureFloodCount::serialize().

operator<<()

std::ostream& operator<<	(	std::ostream &	out,
		const FeatureFloodCount::FeatureData &	feature
	)

Definition at line 2138 of file FeatureFloodCount.C.

{
  static const bool debug = true;
 
  out << "Grain ID: ";
  if (feature._id != FeatureFloodCount::invalid_id)
    out << feature._id;
  else
    out << "invalid";
 
  if (debug)
  {
    out << "\nGhosted Entities: ";
    for (auto ghosted_id : feature._ghosted_ids)
      out << ghosted_id << " ";
 
    out << "\nLocal Entities: ";
    for (auto local_id : feature._local_ids)
      out << local_id << " ";
 
    out << "\nHalo Entities: ";
    for (auto halo_id : feature._halo_ids)
      out << halo_id << " ";
 
    out << "\nPeriodic Node IDs: ";
    for (auto periodic_node : feature._periodic_nodes)
      out << periodic_node << " ";
  }
 
  out << "\nBBoxes:";
  Real volume = 0;
  for (const auto & bbox : feature._bboxes)
  {
    out << "\nMax: " << bbox.max() << " Min: " << bbox.min();
    volume += (bbox.max()(0) - bbox.min()(0)) * (bbox.max()(1) - bbox.min()(1)) *
              (MooseUtils::absoluteFuzzyEqual(bbox.max()(2), bbox.min()(2))
                   ? 1
                   : bbox.max()(2) - bbox.min()(2));
  }
 
  out << "\nStatus: ";
  if (feature._status == FeatureFloodCount::Status::CLEAR)
    out << "CLEAR";
  if (static_cast<bool>(feature._status & FeatureFloodCount::Status::MARKED))
    out << " MARKED";
  if (static_cast<bool>(feature._status & FeatureFloodCount::Status::DIRTY))
    out << " DIRTY";
  if (static_cast<bool>(feature._status & FeatureFloodCount::Status::INACTIVE))
    out << " INACTIVE";
 
  if (debug)
  {
    out << "\nOrig IDs (rank, index): ";
    for (const auto & orig_pair : feature._orig_ids)
      out << '(' << orig_pair.first << ", " << orig_pair.second << ") ";
    out << "\nVar_index: " << feature._var_index;
    out << "\nMin Entity ID: " << feature._min_entity_id;
  }
  out << "\n\n";
 
  return out;
}

registerMooseObject()

registerMooseObject	(	"PhaseFieldApp"	,
		FeatureFloodCount
	)

updateBBoxExtremesHelper() [1/2]

void updateBBoxExtremesHelper	(	BoundingBox &	bbox,
		const Elem &	elem
	)

Definition at line 2215 of file FeatureFloodCount.C.

{
  for (MooseIndex(elem.n_nodes()) node_n = 0; node_n < elem.n_nodes(); ++node_n)
    updateBBoxExtremesHelper(bbox, *(elem.node_ptr(node_n)));

updateBBoxExtremesHelper() [2/2]

void updateBBoxExtremesHelper	(	BoundingBox &	bbox,
		const Point &	node
	)

Definition at line 2205 of file FeatureFloodCount.C.

{
  for (unsigned int i = 0; i < LIBMESH_DIM; ++i)
  {
    bbox.min()(i) = std::min(bbox.min()(i), node(i));
    bbox.max()(i) = std::max(bbox.max()(i), node(i));
  }

Referenced by FeatureFloodCount::prepareDataForTransfer(), FeatureFloodCount::FeatureData::updateBBoxExtremes(), updateBBoxExtremesHelper(), and FeatureFloodCount::visitElementalNeighbors().

validParams< FeatureFloodCount >()

template<>

InputParameters validParams< FeatureFloodCount >

(

)

The FeatureFloodCount and derived objects should not to operate on the displaced mesh. These objects consume variable values from the nonlinear system and use a lot of raw geometric element information from the mesh. If you use the displaced system with EBSD information for instance, you'll have difficulties reconciling the difference between the coordinates from the EBSD data file and the potential displacements applied via boundary conditions.

Definition at line 104 of file FeatureFloodCount.C.

{
  InputParameters params = validParams<GeneralPostprocessor>();
  params += validParams<BoundaryRestrictable>();
 
  params.addRequiredCoupledVar(
      "variable",
      "The variable(s) for which to find connected regions of interests, i.e. \"features\".");
  params.addParam<Real>(
      "threshold", 0.5, "The threshold value for which a new feature may be started");
  params.addParam<Real>(
      "connecting_threshold",
      "The threshold for which an existing feature may be extended (defaults to \"threshold\")");
  params.addParam<bool>("use_single_map",
                        true,
                        "Determine whether information is tracked per "
                        "coupled variable or consolidated into one "
                        "(default: true)");
  params.addParam<bool>(
      "condense_map_info",
      false,
      "Determines whether we condense all the node values when in multimap mode (default: false)");
  params.addParam<bool>("use_global_numbering",
                        true,
                        "Determine whether or not global numbers are "
                        "used to label features on multiple maps "
                        "(default: true)");
  params.addParam<bool>("enable_var_coloring",
                        false,
                        "Instruct the Postprocessor to populate the variable index map.");
  params.addParam<bool>(
      "compute_halo_maps",
      false,
      "Instruct the Postprocessor to communicate proper halo information to all ranks");
  params.addParam<bool>("compute_var_to_feature_map",
                        false,
                        "Instruct the Postprocessor to compute the active vars to features map");
  params.addParam<bool>(
      "use_less_than_threshold_comparison",
      true,
      "Controls whether features are defined to be less than or greater than the threshold value.");
 
  params.addParam<std::vector<BoundaryName>>(
      "primary_percolation_boundaries",
      "A list of boundaries used in conjunction with the corresponding "
      "\"secondary_percolation_boundaries\" parameter for determining if a feature creates a path "
      "connecting any pair of boundaries");
  params.addParam<std::vector<BoundaryName>>(
      "secondary_percolation_boundaries",
      "Paired boundaries with \"primaryary_percolation_boundaries\" parameter");
  params.addParam<std::vector<BoundaryName>>(
      "specified_boundaries",
      "An optional list of boundaries; if supplied, each feature is checked to determine whether "
      "it intersects any of the specified boundaries in this list.");
 
  params.set<bool>("use_displaced_mesh") = false;
 
  // The FeatureFloodCount object does not require that any state (restartable information) is
  // maintained. This Boolean is set to false so that we don't ask MOOSE to save a potentially
  // large data structure for no reason. It is set for true in at least one derived class
  // (GrainTracker).
  params.addPrivateParam<bool>("restartable_required", false);
 
  params.addParamNamesToGroup(
      "use_single_map condense_map_info use_global_numbering primary_percolation_boundaries",
      "Advanced");
 
  MooseEnum flood_type("NODAL ELEMENTAL", "ELEMENTAL");
  params.addParam<MooseEnum>("flood_entity_type",
                             flood_type,
                             "Determines whether the flood algorithm runs on nodes or elements");
 
  params.addClassDescription("The object is able to find and count \"connected components\" in any "
                             "solution field or number of solution fields. A primary example would "
                             "be to count \"bubbles\".");
 
  params.addRelationshipManager("ElementSideNeighborLayers",
                                Moose::RelationshipManagerType::GEOMETRIC |
                                    Moose::RelationshipManagerType::ALGEBRAIC);
 
  return params;
}

Referenced by validParams< GrainTracker >(), validParams< GrainTrackerInterface >(), and validParams< PolycrystalUserObjectBase >().