FeatureFloodCount.h File Reference

Go to the source code of this file.

Classes
class	FeatureFloodCount
	This object will mark nodes or elements of continuous regions all with a unique number for the purpose of counting or "coloring" unique regions in a solution. More...
class	FeatureFloodCount::FeatureData
struct	enable_bitmask_operators< FeatureFloodCount::Status >
struct	enable_bitmask_operators< FeatureFloodCount::BoundaryIntersection >

Functions
template<>
InputParameters	validParams< FeatureFloodCount > ()
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)

Function Documentation

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

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