PolycrystalEBSD Class Reference

#include <PolycrystalEBSD.h>

Inheritance diagram for PolycrystalEBSD:

Public Types
enum	FieldType {   FieldType::UNIQUE_REGION, FieldType::VARIABLE_COLORING, FieldType::GHOSTED_ENTITIES, FieldType::HALOS,   FieldType::CENTROID, FieldType::ACTIVE_BOUNDS }
enum	Status : unsigned char { Status::CLEAR = 0x0, Status::MARKED = 0x1, Status::DIRTY = 0x2, Status::INACTIVE = 0x4 }
	This enumeration is used to indicate status of the grains in the _unique_grains data structure. More...
enum	BoundaryIntersection : unsigned char {   BoundaryIntersection::NONE = 0x0, BoundaryIntersection::ANY_BOUNDARY = 0x1, BoundaryIntersection::PRIMARY_PERCOLATION_BOUNDARY = 0x2, BoundaryIntersection::SECONDARY_PERCOLATION_BOUNDARY = 0x4,   BoundaryIntersection::SPECIFIED_BOUNDARY = 0x8 }
	This enumeration is used to inidacate status of boundary intersections. More...

Public Member Functions
	PolycrystalEBSD (const InputParameters &parameters)
virtual void	getGrainsBasedOnPoint (const Point &point, std::vector< unsigned int > &grains) const override
	Method for retrieving active grain IDs based on some point in the mesh. More...
virtual Real	getVariableValue (unsigned int op_index, const Point &p) const override
	Returns the variable value for a given op_index and mesh point. More...
virtual Real	getNodalVariableValue (unsigned int op_index, const Node &n) const override
	Similarly to the getVariableValue method, this method also returns values but may be optimized for returning nodal values. More...
virtual unsigned int	getNumGrains () const override
	Must be overridden by the deriving class to provide the number of grains in the polycrystal structure. More...
virtual void	precomputeGrainStructure ()
	This callback is triggered after the object is initialized and may be optionally overridden to do precompute the element to grain identifiers ahead of time. More...
virtual void	getGrainsBasedOnElem (const Elem &elem, std::vector< unsigned int > &grains) const
	This method may be defined in addition to the point based initialization to speed up lookups. More...
virtual const std::vector< unsigned int > &	getGrainToOps () const
	Method for retrieving the initial grain OP assignments. More...
virtual void	initialSetup () override
	UserObject interface overrides. More...
virtual void	initialize () override
virtual void	execute () override
virtual void	finalize () override
virtual void	meshChanged () override
virtual Real	getValue () override
std::size_t	getNumberActiveFeatures () const
	Return the number of active features. More...
virtual std::size_t	getTotalFeatureCount () const
	Returns the total feature count (active and inactive ids, useful for sizing vectors) More...
virtual bool	doesFeatureIntersectBoundary (unsigned int feature_id) const
	Returns a Boolean indicating whether this feature intersects any boundary. More...
virtual bool	doesFeatureIntersectSpecifiedBoundary (unsigned int feature_id) const
	Returns a Boolean indicating whether this feature intersects boundaries in a user-supplied list. More...
virtual bool	isFeaturePercolated (unsigned int feature_id) const
	Returns a Boolean indicating whether this feature is percolated (e.g. More...
virtual Point	featureCentroid (unsigned int feature_id) const
	Returns the centroid of the designated feature (only supported without periodic boundaries) More...
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. More...
virtual unsigned int	getFeatureVar (unsigned int feature_id) const
	Returns the variable representing the passed in feature. More...
std::size_t	numCoupledVars () const
	Returns the number of coupled varaibles. More...
const std::vector< MooseVariable * > &	getCoupledVars () const
	Returns a const vector to the coupled variable pointers. More...
const std::vector< MooseVariableFEBase * > &	getFECoupledVars () const
	Returns a const vector to the coupled MooseVariableFEBase pointers. More...
virtual Real	getEntityValue (dof_id_type entity_id, FieldType field_type, std::size_t var_index=0) const
bool	isElemental () const
const std::vector< FeatureData > &	getFeatures () const
	Return a constant reference to the vector of all discovered features. More...

Static Public Member Functions
static MooseEnum	coloringAlgorithms ()
	Returns all available coloring algorithms as an enumeration type for input files. More...
static std::string	coloringAlgorithmDescriptions ()
	Returns corresponding descriptions of available coloring algorithms. More...

Static Public Attributes
static const std::size_t	invalid_size_t = std::numeric_limits<std::size_t>::max()
static const unsigned int	invalid_id = std::numeric_limits<unsigned int>::max()

Protected Member Functions
virtual bool	areFeaturesMergeable (const FeatureData &f1, const FeatureData &f2) const override
	Method for determining whether two features are mergeable. More...
virtual bool	isNewFeatureOrConnectedRegion (const DofObject *dof_object, std::size_t &current_index, FeatureData *&feature, Status &status, unsigned int &new_id) override
	Method called during the recursive flood routine that should return whether or not the current entity is part of the current feature (if one is being explored), or if it's the start of a new feature. More...
virtual void	mergeSets () override
	This routine is called on the master rank only and stitches together the partial feature pieces seen on any processor. More...
void	buildGrainAdjacencyMatrix ()
	Builds a dense adjacency matrix based on the discovery of grain neighbors and halos surrounding each grain. More...
void	assignOpsToGrains ()
	Method that runs a coloring algorithm to assign OPs to grains. More...
bool	colorGraph (unsigned int vertex)
	Built-in simple "back-tracking" algorithm to assign colors to a graph. More...
bool	isGraphValid (unsigned int vertex, unsigned int color)
	Helper method for the back-tracking graph coloring algorithm. More...
void	printGrainAdjacencyMatrix () const
	Prints out the adjacency matrix in a nicely spaced integer format. More...
template<typename T >
bool	isBoundaryEntity (const T *entity) const
	Returns a Boolean indicating whether the entity is on one of the desired boundaries. More...
virtual void	updateFieldInfo ()
	This method is used to populate any of the data structures used for storing field data (nodal or elemental). More...
bool	flood (const DofObject *dof_object, std::size_t current_index)
	This method will check if the current entity is above the supplied threshold and "mark" it. More...
virtual Real	getThreshold (std::size_t current_index) const
	Return the starting comparison threshold to use when inspecting an entity during the flood stage. More...
virtual Real	getConnectingThreshold (std::size_t current_index) const
	Return the "connecting" comparison threshold to use when inspecting an entity during the flood stage. More...
bool	compareValueWithThreshold (Real entity_value, Real threshold) const
	This method is used to determine whether the current entity value is part of a feature or not. More...
void	expandPointHalos ()
	This method takes all of the partial features and expands the local, ghosted, and halo sets around those regions to account for the diffuse interface. More...
void	expandEdgeHalos (unsigned int num_layers_to_expand)
	This method expands the existing halo set by some width determined by the passed in value. More...
template<typename T >
void	visitNeighborsHelper (const T *curr_entity, std::vector< const T * > neighbor_entities, FeatureData *feature, bool expand_halos_only, bool topological_neighbor, bool disjoint_only)
	The actual logic for visiting neighbors is abstracted out here. More...
void	prepareDataForTransfer ()
	This routine uses the local flooded data to build up the local feature data structures (_feature_sets). More...
void	serialize (std::string &serialized_buffer, unsigned int var_num=invalid_id)
	This routines packs the _partial_feature_sets data into a structure suitable for parallel communication operations. More...
void	deserialize (std::vector< std::string > &serialized_buffers, unsigned int var_num=invalid_id)
	This routine takes the vector of byte buffers (one for each processor), deserializes them into a series of FeatureSet objects, and appends them to the _feature_sets data structure. More...
void	communicateAndMerge ()
	This routine handles all of the serialization, communication and deserialization of the data structures containing FeatureData objects. More...
void	sortAndLabel ()
	Sort and assign ids to features based on their position in the container after sorting. More...
void	scatterAndUpdateRanks ()
	Calls buildLocalToGlobalIndices to build the individual local to global indicies for each rank and scatters that information to all ranks. More...
virtual void	buildLocalToGlobalIndices (std::vector< std::size_t > &local_to_global_all, std::vector< int > &counts) const
	This routine populates a stacked vector of local to global indices per rank and the associated count vector for scattering the vector to the ranks. More...
void	buildFeatureIdToLocalIndices (unsigned int max_id)
	This method builds a lookup map for retrieving the right local feature (by index) given a global index or id. More...
virtual void	clearDataStructures ()
	Helper routine for clearing up data structures during initialize and prior to parallel communication. More...
void	updateBoundaryIntersections (FeatureData &feature) const
	Update the feature's attributes to indicate boundary intersections. More...
void	appendPeriodicNeighborNodes (FeatureData &feature) const
	This routine adds the periodic node information to our data structure prior to packing the data this makes those periodic neighbors appear much like ghosted nodes in a multiprocessor setting. More...
void	updateRegionOffsets ()
	This routine updates the _region_offsets variable which is useful for quickly determining the proper global number for a feature when using multimap mode. More...
void	visitNodalNeighbors (const Node *node, FeatureData *feature, bool expand_halos_only)
	These two routines are utility routines used by the flood routine and by derived classes for visiting neighbors. More...
void	visitElementalNeighbors (const Elem *elem, FeatureData *feature, bool expand_halos_only, bool disjoint_only)

Static Protected Member Functions
template<class InputIterator >
static bool	setsIntersect (InputIterator first1, InputIterator last1, InputIterator first2, InputIterator last2)
	This method detects whether two sets intersect without building a result set. More...

Protected Attributes
const unsigned int	_phase
const EBSDReader &	_ebsd_reader
const std::map< dof_id_type, std::vector< Real > > &	_node_to_grain_weight_map
std::unique_ptr< DenseMatrix< Real > >	_adjacency_matrix
	The dense adjacency matrix. More...
const unsigned int	_dim
	mesh dimension More...
const unsigned int	_op_num
	The maximum number of order parameters (colors) available to assign to the grain structure. More...
std::vector< unsigned int >	_grain_to_op
	A vector indicating which op is assigned to each grain. More...
const MooseEnum	_coloring_algorithm
	The selected graph coloring algorithm used by this object. More...
bool	_colors_assigned
	A Boolean indicating whether the object has assigned colors to grains (internal use) More...
const bool	_output_adjacency_matrix
	A user controllable Boolean which can be used to print the adjacency matrix to the console. More...
std::vector< MooseVariableFEBase * >	_fe_vars
	The vector of coupled in variables. More...
std::vector< MooseVariable * >	_vars
	The vector of coupled in variables cast to MooseVariable. More...
const DofMap &	_dof_map
	Reference to the dof_map containing the coupled variables. More...
const Real	_threshold
	The threshold above (or below) where an entity may begin a new region (feature) More...
Real	_step_threshold
const Real	_connecting_threshold
	The threshold above (or below) which neighboring entities are flooded (where regions can be extended but not started) More...
Real	_step_connecting_threshold
MooseMesh &	_mesh
	A reference to the mesh. More...
unsigned long	_var_number
	This variable is used to build the periodic node map. More...
const bool	_single_map_mode
	This variable is used to indicate whether or not multiple maps are used during flooding. More...
const bool	_condense_map_info
const bool	_global_numbering
	This variable is used to indicate whether or not we identify features with unique numbers on multiple maps. More...
const bool	_var_index_mode
	This variable is used to indicate whether the maps will contain unique region information or just the variable numbers owning those regions. More...
const bool	_compute_halo_maps
	Indicates whether or not to communicate halo map information with all ranks. More...
const bool	_compute_var_to_feature_map
	Indicates whether or not the var to feature map is populated. More...
const bool	_use_less_than_threshold_comparison
	Use less-than when comparing values against the threshold value. More...
const std::size_t	_n_vars
const std::size_t	_maps_size
	Convenience variable holding the size of all the datastructures size by the number of maps. More...
const processor_id_type	_n_procs
	Convenience variable holding the number of processors in this simulation. More...
std::vector< std::set< dof_id_type > >	_entities_visited
	This variable keeps track of which nodes have been visited during execution. More...
std::vector< std::map< dof_id_type, int > >	_var_index_maps
	This map keeps track of which variables own which nodes. More...
std::vector< std::vector< const Elem * > >	_nodes_to_elem_map
	The data structure used to find neighboring elements give a node ID. More...
std::vector< unsigned int >	_feature_counts_per_map
	The number of features seen by this object per map. More...
unsigned int	_feature_count
	The number of features seen by this object (same as summing _feature_counts_per_map) More...
std::vector< std::list< FeatureData > >	_partial_feature_sets
	The data structure used to hold partial and communicated feature data, during the discovery and merging phases. More...
std::vector< FeatureData > &	_feature_sets
	The data structure used to hold the globally unique features. More...
std::vector< FeatureData >	_volatile_feature_sets
	Derived objects (e.g. More...
std::vector< std::map< dof_id_type, int > >	_feature_maps
	The feature maps contain the raw flooded node information and eventually the unique grain numbers. More...
std::vector< std::size_t >	_local_to_global_feature_map
	The vector recording the local to global feature indices. More...
std::vector< std::size_t >	_feature_id_to_local_index
	The vector recording the grain_id to local index (several indices will contain invalid_size_t) More...
PeriodicBoundaries *	_pbs
	A pointer to the periodic boundary constraints object. More...
std::unique_ptr< PointLocatorBase >	_point_locator
const PostprocessorValue &	_element_average_value
	Average value of the domain which can optionally be used to find features in a field. More...
std::map< dof_id_type, int >	_ghosted_entity_ids
	The map for holding reconstructed ghosted element information. More...
std::vector< std::map< dof_id_type, int > >	_halo_ids
	The data structure for looking up halos around features. More...
std::multimap< dof_id_type, dof_id_type >	_periodic_node_map
	The data structure which is a list of nodes that are constrained to other nodes based on the imposed periodic boundary conditions. More...
std::unordered_set< dof_id_type >	_all_boundary_entity_ids
	The set of entities on the boundary of the domain used for determining if features intersect any boundary. More...
std::map< dof_id_type, std::vector< unsigned int > >	_entity_var_to_features
std::vector< unsigned int >	_empty_var_to_features
std::vector< BoundaryID >	_primary_perc_bnds
std::vector< BoundaryID >	_secondary_perc_bnds
std::vector< BoundaryID >	_specified_bnds
const bool	_is_elemental
	Determines if the flood counter is elements or not (nodes) More...
bool	_is_boundary_restricted
	Indicates that this object should only run on one or more boundaries. More...
ConstBndElemRange *	_bnd_elem_range
	Boundary element range pointer. More...
const bool	_is_master
	Convenience variable for testing master rank. More...

Static Protected Attributes
static const unsigned int	INVALID_COLOR
	Used to indicate an invalid coloring for the built-in back-tracking algorithm. More...
static const unsigned int	HALO_THICKNESS = 4
	Used to hold the thickness of the halo that should be constructed for detecting adjacency. More...

Private Member Functions
void	consolidateMergedFeatures (std::vector< std::list< FeatureData >> *saved_data=nullptr)
	This method consolidates all of the merged information from _partial_feature_sets into the _feature_sets vectors. More...

Static Private Member Functions
template<class T >
static void	sort (std::set< T > &)
template<class T >
static void	sort (std::vector< T > &container)
template<class T >
static void	reserve (std::set< T > &, std::size_t)
template<class T >
static void	reserve (std::vector< T > &container, std::size_t size)

Private Attributes
std::vector< unsigned int >	_prealloc_tmp_grains
	Temporary storage area for current grains at a point to avoid memory churn. More...
std::map< dof_id_type, std::vector< unsigned int > >	_entity_to_grain_cache
const PerfID	_execute_timer
	Timers. More...
const PerfID	_finalize_timer
std::deque< const DofObject * >	_entity_queue
	The data structure for maintaining entities to flood during discovery. More...
const bool	_distribute_merge_work
	Keeps track of whether we are distributing the merge work. More...
const PerfID	_merge_timer
const PerfID	_comm_and_merge
const PerfID	_expand_halos
const PerfID	_update_field_info
const PerfID	_prepare_for_transfer
const PerfID	_consolidate_merged_features

Detailed Description

Definition at line 21 of file PolycrystalEBSD.h.

Member Enumeration Documentation

BoundaryIntersection

enum FeatureFloodCount::BoundaryIntersection : unsigned char

stronginherited

This enumeration is used to inidacate status of boundary intersections.

Enumerator
NONE
ANY_BOUNDARY
PRIMARY_PERCOLATION_BOUNDARY
SECONDARY_PERCOLATION_BOUNDARY
SPECIFIED_BOUNDARY

Definition at line 129 of file FeatureFloodCount.h.

                                  : unsigned char
  {
    NONE = 0x0,
    ANY_BOUNDARY = 0x1,
    PRIMARY_PERCOLATION_BOUNDARY = 0x2,
    SECONDARY_PERCOLATION_BOUNDARY = 0x4,
    SPECIFIED_BOUNDARY = 0x8
  };

FieldType

enum FeatureFloodCount::FieldType

stronginherited

Enumerator
UNIQUE_REGION
VARIABLE_COLORING
GHOSTED_ENTITIES
HALOS
CENTROID
ACTIVE_BOUNDS

Definition at line 103 of file FeatureFloodCount.h.

  {
    UNIQUE_REGION,
    VARIABLE_COLORING,
    GHOSTED_ENTITIES,
    HALOS,
    CENTROID,
    ACTIVE_BOUNDS,
  };

Status

enum FeatureFloodCount::Status : unsigned char

stronginherited

This enumeration is used to indicate status of the grains in the _unique_grains data structure.

Enumerator
CLEAR
MARKED
DIRTY
INACTIVE

Definition at line 120 of file FeatureFloodCount.h.

                    : unsigned char
  {
    CLEAR = 0x0,
    MARKED = 0x1,
    DIRTY = 0x2,
    INACTIVE = 0x4
  };

Constructor & Destructor Documentation

PolycrystalEBSD()

PolycrystalEBSD::PolycrystalEBSD

(

const InputParameters &

parameters

)

Definition at line 26 of file PolycrystalEBSD.C.

  : PolycrystalUserObjectBase(parameters),
    _phase(isParamValid("phase") ? getParam<unsigned int>("phase") : libMesh::invalid_uint),
    _ebsd_reader(getUserObject<EBSDReader>("ebsd_reader")),
    _node_to_grain_weight_map(_ebsd_reader.getNodeToGrainWeightMap())
{
}

Member Function Documentation

appendPeriodicNeighborNodes()

void FeatureFloodCount::appendPeriodicNeighborNodes ( FeatureData &  feature ) const

protectedinherited

This routine adds the periodic node information to our data structure prior to packing the data this makes those periodic neighbors appear much like ghosted nodes in a multiprocessor setting.

Definition at line 1771 of file FeatureFloodCount.C.

{
  if (_is_elemental)
  {
    for (auto entity : feature._local_ids)
    {
      Elem * elem = _mesh.elemPtr(entity);
 
      for (MooseIndex(elem->n_nodes()) node_n = 0; node_n < elem->n_nodes(); ++node_n)
      {
        auto iters = _periodic_node_map.equal_range(elem->node_id(node_n));
 
        for (auto it = iters.first; it != iters.second; ++it)
        {
          feature._periodic_nodes.insert(feature._periodic_nodes.end(), it->first);
          feature._periodic_nodes.insert(feature._periodic_nodes.end(), it->second);
        }
      }
    }
  }
  else
  {
    for (auto entity : feature._local_ids)
    {
      auto iters = _periodic_node_map.equal_range(entity);
 
      for (auto it = iters.first; it != iters.second; ++it)
      {
        feature._periodic_nodes.insert(feature._periodic_nodes.end(), it->first);
        feature._periodic_nodes.insert(feature._periodic_nodes.end(), it->second);
      }
    }
  }
 
  // TODO: Remove duplicates
}

Referenced by FeatureFloodCount::prepareDataForTransfer().

areFeaturesMergeable()

bool PolycrystalUserObjectBase::areFeaturesMergeable ( const FeatureData &  f1, const FeatureData &  f2  ) const

overrideprotectedvirtualinherited

Method for determining whether two features are mergeable.

This routine exists because derived classes may need to override this function rather than use the mergeable method in the FeatureData object.

Reimplemented from FeatureFloodCount.

Definition at line 380 of file PolycrystalUserObjectBase.C.

{
  if (f1._id != f2._id)
    return false;
 
  mooseAssert(f1._var_index == f2._var_index, "Feature should be mergeable but aren't");
  return true;
}

Referenced by PolycrystalUserObjectBase::mergeSets().

assignOpsToGrains()

void PolycrystalUserObjectBase::assignOpsToGrains ( )

protectedinherited

Method that runs a coloring algorithm to assign OPs to grains.

Definition at line 413 of file PolycrystalUserObjectBase.C.

{
  mooseAssert(_is_master, "This routine should only be called on the master rank");
 
  Moose::perf_log.push("assignOpsToGrains()", "PolycrystalICTools");
 
  // Use a simple backtracking coloring algorithm
  if (_coloring_algorithm == "bt")
  {
    paramInfo("coloring_algorithm",
              "The backtracking algorithm has exponential complexity. If you are using very few "
              "order parameters,\nor you have several hundred grains or more, you should use one "
              "of the PETSc coloring algorithms such as \"jp\".");
 
    if (!colorGraph(0))
      paramError("op_num",
                 "Unable to find a valid grain to op coloring, Make sure you have created enough "
                 "variables to hold a\nvalid polycrystal initial condition (no grains represented "
                 "by the same variable should be allowed to\ntouch, ~8 for 2D, ~25 for 3D)?");
  }
  else // PETSc Coloring algorithms
  {
#ifdef LIBMESH_HAVE_PETSC
    const std::string & ca_str = _coloring_algorithm;
    Real * am_data = _adjacency_matrix->get_values().data();
 
    try
    {
      Moose::PetscSupport::colorAdjacencyMatrix(
          am_data, _feature_count, _vars.size(), _grain_to_op, ca_str.c_str());
    }
    catch (std::runtime_error & e)
    {
      paramError("op_num",
                 "Unable to find a valid grain to op coloring, Make sure you have created enough "
                 "variables to hold a\nvalid polycrystal initial condition (no grains represented "
                 "by the same variable should be allowed to\ntouch, ~8 for 2D, ~25 for 3D)?");
    }
#else
    mooseError("Selected coloring algorithm requires PETSc");
#endif
  }
 
  Moose::perf_log.pop("assignOpsToGrains()", "PolycrystalICTools");
}

Referenced by PolycrystalUserObjectBase::finalize().

buildFeatureIdToLocalIndices()

void FeatureFloodCount::buildFeatureIdToLocalIndices ( unsigned int  max_id )

protectedinherited

This method builds a lookup map for retrieving the right local feature (by index) given a global index or id.

max_id is passed to size the vector properly and may or may not be a globally consistent number. The assumption is that any id that is later queried from this object that is higher simply doesn't exist on the local processor.

Definition at line 665 of file FeatureFloodCount.C.

{
  _feature_id_to_local_index.assign(max_id + 1, invalid_size_t);
  for (MooseIndex(_feature_sets) feature_index = 0; feature_index < _feature_sets.size();
       ++feature_index)
  {
    if (_feature_sets[feature_index]._status != Status::INACTIVE)
    {
      mooseAssert(_feature_sets[feature_index]._id <= max_id,
                  "Feature ID out of range(" << _feature_sets[feature_index]._id << ')');
      _feature_id_to_local_index[_feature_sets[feature_index]._id] = feature_index;
    }
  }
}

Referenced by GrainTracker::assignGrains(), FeatureFloodCount::scatterAndUpdateRanks(), and GrainTracker::trackGrains().

buildGrainAdjacencyMatrix()

void PolycrystalUserObjectBase::buildGrainAdjacencyMatrix ( )

protectedinherited

Builds a dense adjacency matrix based on the discovery of grain neighbors and halos surrounding each grain.

Definition at line 391 of file PolycrystalUserObjectBase.C.

{
  mooseAssert(_is_master, "This routine should only be called on the master rank");
 
  _adjacency_matrix = libmesh_make_unique<DenseMatrix<Real>>(_feature_count, _feature_count);
  for (auto & grain1 : _feature_sets)
  {
    for (auto & grain2 : _feature_sets)
    {
      if (&grain1 == &grain2)
        continue;
 
      if (grain1.boundingBoxesIntersect(grain2) && grain1.halosIntersect(grain2))
      {
        (*_adjacency_matrix)(grain1._id, grain2._id) = 1.;
        (*_adjacency_matrix)(grain1._id, grain2._id) = 1.;
      }
    }
  }
}

Referenced by PolycrystalUserObjectBase::finalize().

buildLocalToGlobalIndices()

void FeatureFloodCount::buildLocalToGlobalIndices ( std::vector< std::size_t > &  local_to_global_all, std::vector< int > &  counts  ) const

protectedvirtualinherited

This routine populates a stacked vector of local to global indices per rank and the associated count vector for scattering the vector to the ranks.

The individual vectors can be different sizes. The ith vector will be distributed to the ith processor including the master rank. e.g. [ ... n_0 ] [ ... n_1 ] ... [ ... n_m ]

It is intended to be overridden in derived classes.

Definition at line 619 of file FeatureFloodCount.C.

{
  mooseAssert(_is_master, "This method must only be called on the root processor");
 
  counts.assign(_n_procs, 0);
  // Now size the individual counts vectors based on the largest index seen per processor
  for (const auto & feature : _feature_sets)
    for (const auto & local_index_pair : feature._orig_ids)
    {
      // local_index_pair.first = ranks, local_index_pair.second = local_index
      mooseAssert(local_index_pair.first < _n_procs, "Processor ID is out of range");
      if (local_index_pair.second >= static_cast<std::size_t>(counts[local_index_pair.first]))
        counts[local_index_pair.first] = local_index_pair.second + 1;
    }
 
  // Build the offsets vector
  unsigned int globalsize = 0;
  std::vector<int> offsets(_n_procs); // Type is signed for use with the MPI API
  for (MooseIndex(offsets) i = 0; i < offsets.size(); ++i)
  {
    offsets[i] = globalsize;
    globalsize += counts[i];
  }
 
  // Finally populate the master vector
  local_to_global_all.resize(globalsize, FeatureFloodCount::invalid_size_t);
  for (const auto & feature : _feature_sets)
  {
    // Get the local indices from the feature and build a map
    for (const auto & local_index_pair : feature._orig_ids)
    {
      auto rank = local_index_pair.first;
      mooseAssert(rank < _n_procs, rank << ", " << _n_procs);
 
      auto local_index = local_index_pair.second;
      auto stacked_local_index = offsets[rank] + local_index;
 
      mooseAssert(stacked_local_index < globalsize,
                  "Global index: " << stacked_local_index << " is out of range");
      local_to_global_all[stacked_local_index] = feature._id;
    }
  }
}

Referenced by FeatureFloodCount::scatterAndUpdateRanks().

clearDataStructures()

void FeatureFloodCount::clearDataStructures ( )

protectedvirtualinherited

Helper routine for clearing up data structures during initialize and prior to parallel communication.

Definition at line 330 of file FeatureFloodCount.C.

{
}

Referenced by FeatureFloodCount::communicateAndMerge().

colorGraph()

bool PolycrystalUserObjectBase::colorGraph ( unsigned int  vertex )

protectedinherited

Built-in simple "back-tracking" algorithm to assign colors to a graph.

Definition at line 460 of file PolycrystalUserObjectBase.C.

{
  // Base case: All grains are assigned
  if (vertex == _feature_count)
    return true;
 
  // Consider this grain and try different ops
  for (unsigned int color_idx = 0; color_idx < _op_num; ++color_idx)
  {
    // We'll try to spread these colors around a bit rather than
    // packing them all on the first few colors if we have several colors.
    unsigned int color = (vertex + color_idx) % _op_num;
 
    if (isGraphValid(vertex, color))
    {
      _grain_to_op[vertex] = color;
 
      if (colorGraph(vertex + 1))
        return true;
 
      // Backtrack...
      _grain_to_op[vertex] = PolycrystalUserObjectBase::INVALID_COLOR;
    }
  }
 
  return false;
}

Referenced by PolycrystalUserObjectBase::assignOpsToGrains().

coloringAlgorithmDescriptions()

std::string PolycrystalUserObjectBase::coloringAlgorithmDescriptions ( )

staticinherited

Returns corresponding descriptions of available coloring algorithms.

Definition at line 522 of file PolycrystalUserObjectBase.C.

{
  return "The grain neighbor graph coloring algorithm to use: \"jp\" (DEFAULT) Jones and "
         "Plassmann, an efficient coloring algorithm, \"power\" an alternative stochastic "
         "algorithm, \"greedy\", a greedy assignment algorithm with stochastic updates to "
         "guarantee a valid coloring, \"bt\", a back tracking algorithm that produces good "
         "distributions but may experience exponential run time in the worst case scenario "
         "(works well on medium to large 2D problems)";
}

Referenced by validParams< PolycrystalUserObjectBase >().

coloringAlgorithms()

MooseEnum PolycrystalUserObjectBase::coloringAlgorithms ( )

staticinherited

Returns all available coloring algorithms as an enumeration type for input files.

Definition at line 516 of file PolycrystalUserObjectBase.C.

{
  return MooseEnum("jp power greedy bt", "jp");
}

Referenced by validParams< PolycrystalUserObjectBase >().

communicateAndMerge()

void FeatureFloodCount::communicateAndMerge ( )

protectedinherited

This routine handles all of the serialization, communication and deserialization of the data structures containing FeatureData objects.

The libMesh packed range routines handle the communication of the individual string buffers. Here we need to create a container to hold our type to serialize. It'll always be size one because we are sending a single byte stream of all the data to other processors. The stream need not be the same size on all processors.

Additionally we need to create a different container to hold the received byte buffers. The container type need not match the send container type. However, We do know the number of incoming buffers (num processors) so we'll go ahead and use a vector.

When we distribute merge work, we are reducing computational work by adding more communication. Each of the first _n_vars processors will receive one variable worth of information to merge. After each of those processors has merged that information, it'll be sent to the master processor where final consolidation will occur.

Send the data from all processors to the first _n_vars processors to create a complete global feature maps for each variable.

A call to gather_packed_range seems to populate the receiving buffer on all processors, not just the receiving buffer on the actual receiving processor. If we plan to call this function repeatedly, we must clear the buffers each time on all non-receiving processors. On the actual receiving processor, we'll save off the buffer for use later.

The FeatureFloodCount and derived algorithms rely on having the data structures intact on all non-zero ranks. This is because local-only information (local entities) is never communicated and thus must remain intact. However, the distributed merging will destroy that information. The easiest thing to do is to swap out the data structure while we perform the distributed merge work.

Send the data from the merging processors to the root to create a complete global feature map.

Send the data from all processors to the root to create a complete global feature map.

Definition at line 412 of file FeatureFloodCount.C.

{
  TIME_SECTION(_comm_and_merge);
 
  // First we need to transform the raw data into a usable data structure
  prepareDataForTransfer();
 
  std::vector<std::string> send_buffers(1);
 
  std::vector<std::string> recv_buffers, deserialize_buffers;
 
  if (_distribute_merge_work)
  {
    auto rank = processor_id();
    bool is_merging_processor = rank < _n_vars;
 
    if (is_merging_processor)
      recv_buffers.reserve(_app.n_processors());
 
    for (MooseIndex(_n_vars) i = 0; i < _n_vars; ++i)
    {
      serialize(send_buffers[0], i);
 
      _communicator.gather_packed_range(i,
                                        (void *)(nullptr),
                                        send_buffers.begin(),
                                        send_buffers.end(),
                                        std::back_inserter(recv_buffers));
 
      if (rank == i)
        recv_buffers.swap(deserialize_buffers);
      else
        recv_buffers.clear();
    }
 
    // Setup a new communicator for doing merging communication operations
    Parallel::Communicator merge_comm;
 
    // TODO: Update to MPI_UNDEFINED when libMesh bug is fixed.
    _communicator.split(is_merging_processor ? 0 : 1, rank, merge_comm);
 
    if (is_merging_processor)
    {
      std::vector<std::list<FeatureData>> tmp_data(_partial_feature_sets.size());
      tmp_data.swap(_partial_feature_sets);
 
      deserialize(deserialize_buffers, processor_id());
 
      send_buffers[0].clear();
      recv_buffers.clear();
      deserialize_buffers.clear();
 
      // Merge one variable's worth of data
      mergeSets();
 
      // Now we need to serialize again to send to the master (only the processors who did work)
      serialize(send_buffers[0]);
 
      // Free up as much memory as possible here before we do global communication
      clearDataStructures();
 
      merge_comm.gather_packed_range(0,
                                     (void *)(nullptr),
                                     send_buffers.begin(),
                                     send_buffers.end(),
                                     std::back_inserter(recv_buffers));
 
      if (_is_master)
      {
        // The root process now needs to deserialize all of the data
        deserialize(recv_buffers);
 
        send_buffers[0].clear();
        recv_buffers.clear();
 
        consolidateMergedFeatures(&tmp_data);
      }
      else
        // Restore our original data on non-zero ranks
        tmp_data.swap(_partial_feature_sets);
    }
  }
 
  // Serialized merging (master does all the work)
  else
  {
    if (_is_master)
      recv_buffers.reserve(_app.n_processors());
 
    serialize(send_buffers[0]);
 
    // Free up as much memory as possible here before we do global communication
    clearDataStructures();
 
    _communicator.gather_packed_range(0,
                                      (void *)(nullptr),
                                      send_buffers.begin(),
                                      send_buffers.end(),
                                      std::back_inserter(recv_buffers));
 
    if (_is_master)
    {
      // The root process now needs to deserialize all of the data
      deserialize(recv_buffers);
      recv_buffers.clear();
 
      mergeSets();
 
      consolidateMergedFeatures();
    }
  }
 
  // Make sure that feature count is communicated to all ranks
  _communicator.broadcast(_feature_count);
}

Referenced by GrainTracker::finalize(), and FeatureFloodCount::finalize().

compareValueWithThreshold()

bool FeatureFloodCount::compareValueWithThreshold ( Real  entity_value, Real  threshold  ) const

protectedinherited

This method is used to determine whether the current entity value is part of a feature or not.

Comparisons can either be greater than or less than the threshold which is controlled via input parameter.

Definition at line 1418 of file FeatureFloodCount.C.

{
  return ((_use_less_than_threshold_comparison && (entity_value >= threshold)) ||
          (!_use_less_than_threshold_comparison && (entity_value <= threshold)));
}

Referenced by FeatureFloodCount::isNewFeatureOrConnectedRegion().

consolidateMergedFeatures()

void FeatureFloodCount::consolidateMergedFeatures ( std::vector< std::list< FeatureData >> *  saved_data = nullptr )

privateinherited

This method consolidates all of the merged information from _partial_feature_sets into the _feature_sets vectors.

Now that the merges are complete we need to adjust the centroid, and halos. Additionally, To make several of the sorting and tracking algorithms more straightforward, we will move the features into a flat vector. Finally we can count the final number of features and find the max local index seen on any processor Note: This is all occurring on rank 0 only!

IMPORTANT: FeatureFloodCount::_feature_count is set on rank 0 at this point but we can't broadcast it here because this routine is not collective.

Definition at line 1176 of file FeatureFloodCount.C.

{
  TIME_SECTION(_consolidate_merged_features);
 
  mooseAssert(_is_master, "cosolidateMergedFeatures() may only be called on the master processor");
 
  // Offset where the current set of features with the same variable id starts in the flat vector
  unsigned int feature_offset = 0;
  // Set the member feature count to zero and start counting the actual features
  _feature_count = 0;
 
  for (MooseIndex(_maps_size) map_num = 0; map_num < _maps_size; ++map_num)
  {
    for (auto & feature : _partial_feature_sets[map_num])
    {
      if (saved_data)
      {
        for (auto it = (*saved_data)[map_num].begin(); it != (*saved_data)[map_num].end();
             /* no increment */)
        {
          if (feature.canConsolidate(*it))
          {
            feature.consolidate(std::move(*it));
            it = (*saved_data)[map_num].erase(it); // increment
          }
          else
            ++it;
        }
      }
 
      // If after merging we still have an inactive feature, discard it
      if (feature._status == Status::CLEAR)
      {
        // First we need to calculate the centroid now that we are doing merging all partial
        // features
        if (feature._vol_count != 0)
          feature._centroid /= feature._vol_count;
 
        _feature_sets.emplace_back(std::move(feature));
        ++_feature_count;
      }
    }
 
    // Record the feature numbers just for the current map
    _feature_counts_per_map[map_num] = _feature_count - feature_offset;
 
    // Now update the running feature count so we can calculate the next map's contribution
    feature_offset = _feature_count;
 
    // Clean up the "moved" objects
    _partial_feature_sets[map_num].clear();
  }
 
}

Referenced by FeatureFloodCount::communicateAndMerge().

deserialize()

void FeatureFloodCount::deserialize ( std::vector< std::string > &  serialized_buffers, unsigned int  var_num = invalid_id  )

protectedinherited

This routine takes the vector of byte buffers (one for each processor), deserializes them into a series of FeatureSet objects, and appends them to the _feature_sets data structure.

Note: It is assumed that local processor information may already be stored in the _feature_sets data structure so it is not cleared before insertion.

Usually we have the local processor data already in the _partial_feature_sets data structure. However, if we are doing distributed merge work, we also need to preserve all of the original data for use in later stages of the algorithm so it'll have been swapped out with clean buffers. This leaves us a choice, either we just duplicate the Features from the original data structure after we've swapped out the buffer, or we go ahead and unpack data that we would normally already have. So during distributed merging, that's exactly what we'll do. Later however when the master is doing the final consolidating, we'll opt to just skip the local unpacking. To tell the difference, between these two modes, we just need to see if a var_num was passed in.

Definition at line 1086 of file FeatureFloodCount.C.

{
  // The input string stream used for deserialization
  std::istringstream iss;
 
  auto rank = processor_id();
 
  for (MooseIndex(serialized_buffers) proc_id = 0; proc_id < serialized_buffers.size(); ++proc_id)
  {
    if (var_num == invalid_id && proc_id == rank)
      continue;
 
    iss.str(serialized_buffers[proc_id]); // populate the stream with a new buffer
    iss.clear();                          // reset the string stream state
 
    // Load the gathered data into the data structure.
    if (var_num == invalid_id)
      dataLoad(iss, _partial_feature_sets, this);
    else
      dataLoad(iss, _partial_feature_sets[var_num], this);
  }
}

Referenced by FeatureFloodCount::communicateAndMerge().

doesFeatureIntersectBoundary()

bool FeatureFloodCount::doesFeatureIntersectBoundary ( unsigned int  feature_id ) const

virtualinherited

Returns a Boolean indicating whether this feature intersects any boundary.

Reimplemented in GrainTracker, and FauxGrainTracker.

Definition at line 828 of file FeatureFloodCount.C.

{
  // TODO: This information is not parallel consistent when using FeatureFloodCounter
 
  // Some processors don't contain the largest feature id, in that case we just return invalid_id
  if (feature_id >= _feature_id_to_local_index.size())
    return false;
 
  auto local_index = _feature_id_to_local_index[feature_id];
 
  if (local_index != invalid_size_t)
  {
    mooseAssert(local_index < _feature_sets.size(), "local_index out of bounds");
    return _feature_sets[local_index]._status != Status::INACTIVE
               ? _feature_sets[local_index]._boundary_intersection != BoundaryIntersection::NONE
               : false;
  }
 
  return false;
}

Referenced by FeatureVolumeVectorPostprocessor::execute().

doesFeatureIntersectSpecifiedBoundary()

bool FeatureFloodCount::doesFeatureIntersectSpecifiedBoundary ( unsigned int  feature_id ) const

virtualinherited

Returns a Boolean indicating whether this feature intersects boundaries in a user-supplied list.

Reimplemented in GrainTracker.

Definition at line 850 of file FeatureFloodCount.C.

{
  // TODO: This information is not parallel consistent when using FeatureFloodCounter
 
  // Some processors don't contain the largest feature id, in that case we just return invalid_id
  if (feature_id >= _feature_id_to_local_index.size())
    return false;
 
  auto local_index = _feature_id_to_local_index[feature_id];
 
  if (local_index != invalid_size_t)
  {
    mooseAssert(local_index < _feature_sets.size(), "local_index out of bounds");
    return _feature_sets[local_index]._status != Status::INACTIVE
               ? ((_feature_sets[local_index]._boundary_intersection &
                   BoundaryIntersection::SPECIFIED_BOUNDARY) ==
                  BoundaryIntersection::SPECIFIED_BOUNDARY)
               : false;
  }
 
  return false;
}

Referenced by FeatureVolumeVectorPostprocessor::execute().

execute()

void PolycrystalUserObjectBase::execute ( )

overridevirtualinherited

We need one map per grain when creating the initial condition to support overlapping features. Luckily, this is a fairly sparse structure.

This loop is similar to the one found in the base class however, there are two key differences between building up the initial condition and discovering features based on solution variables:

1) When building up the initial condition, we aren't inspecting the actual variable values so we don't need to loop over all of the coupled variables. 2) We want to discover all features on a single pass since there may be thousands of features in a simulation. However, we can only actively flood a single feature at a time. To make sure that we pick up all features that might start on a given entity, we'll keep retrying the flood routine on the same entity as long as new discoveries are being made. We know this information from the return value of flood.

Reimplemented from FeatureFloodCount.

Definition at line 116 of file PolycrystalUserObjectBase.C.

{
  if (!_colors_assigned)
    precomputeGrainStructure();
  // No need to rerun the object if the mesh hasn't changed
  else if (!_fe_problem.hasInitialAdaptivity())
    return;
 
  TIME_SECTION(_execute_timer);
  CONSOLE_TIMED_PRINT("Computing Polycrystal Initial Condition");
 
  _entities_visited.resize(getNumGrains());
 
  for (const auto & current_elem : _fe_problem.getEvaluableElementRange())
  {
    // Loop over elements or nodes
    if (_is_elemental)
      while (flood(current_elem, invalid_size_t))
        ;
    else
    {
      auto n_nodes = current_elem->n_vertices();
      for (auto i = decltype(n_nodes)(0); i < n_nodes; ++i)
      {
        const Node * current_node = current_elem->node_ptr(i);
 
        while (flood(current_node, invalid_size_t))
          ;
      }
    }
  }
}

expandEdgeHalos()

void FeatureFloodCount::expandEdgeHalos ( unsigned int  num_layers_to_expand )

protectedinherited

This method expands the existing halo set by some width determined by the passed in value.

This method does NOT mask off any local IDs.

Create a copy of the halo set so that as we insert new ids into the set we don't continue to iterate on those new ids.

We have to handle disjoint halo IDs slightly differently. Once you are disjoint, you can't go back so make sure that we keep placing these IDs in the disjoint set.

Definition at line 1527 of file FeatureFloodCount.C.

{
  if (num_layers_to_expand == 0)
    return;
 
  TIME_SECTION(_expand_halos);
 
  for (auto & list_ref : _partial_feature_sets)
  {
    for (auto & feature : list_ref)
    {
      for (MooseIndex(num_layers_to_expand) halo_level = 0; halo_level < num_layers_to_expand;
           ++halo_level)
      {
        FeatureData::container_type orig_halo_ids(feature._halo_ids);
        for (auto entity : orig_halo_ids)
        {
          if (_is_elemental)
            visitElementalNeighbors(_mesh.elemPtr(entity),
                                    &feature,
                                    /*expand_halos_only =*/true,
                                    /*disjoint_only =*/false);
          else
            visitNodalNeighbors(_mesh.nodePtr(entity),
                                &feature,
                                /*expand_halos_only =*/true);
        }
 
        FeatureData::container_type disjoint_orig_halo_ids(feature._disjoint_halo_ids);
        for (auto entity : disjoint_orig_halo_ids)
        {
          if (_is_elemental)
            visitElementalNeighbors(_mesh.elemPtr(entity),
 
                                    &feature,
                                    /*expand_halos_only =*/true,
                                    /*disjoint_only =*/true);
          else
            visitNodalNeighbors(_mesh.nodePtr(entity),
 
                                &feature,
                                /*expand_halos_only =*/true);
        }
      }
    }
  }
}

Referenced by GrainTracker::finalize(), and PolycrystalUserObjectBase::finalize().

expandPointHalos()

void FeatureFloodCount::expandPointHalos ( )

protectedinherited

This method takes all of the partial features and expands the local, ghosted, and halo sets around those regions to account for the diffuse interface.

Rather than using any kind of recursion here, we simply expand the region by all "point" neighbors from the actual grain cells since all point neighbors will contain contributions to the region.

To expand the feature element region to the actual flooded region (nodal basis) we need to add in all point neighbors of the current local region for each feature. This is because the elemental variable influence spreads from the elemental data out exactly one element from every mesh point.

Definition at line 1465 of file FeatureFloodCount.C.

{
  const auto & node_to_elem_map = _mesh.nodeToActiveSemilocalElemMap();
  FeatureData::container_type expanded_local_ids;
  auto my_processor_id = processor_id();
 
  for (auto & list_ref : _partial_feature_sets)
  {
    for (auto & feature : list_ref)
    {
      expanded_local_ids.clear();
 
      for (auto entity : feature._local_ids)
      {
        const Elem * elem = _mesh.elemPtr(entity);
        mooseAssert(elem, "elem pointer is NULL");
 
        // Get the nodes on a current element so that we can add in point neighbors
        auto n_nodes = elem->n_vertices();
        for (MooseIndex(n_nodes) i = 0; i < n_nodes; ++i)
        {
          const Node * current_node = elem->node_ptr(i);
 
          auto elem_vector_it = node_to_elem_map.find(current_node->id());
          if (elem_vector_it == node_to_elem_map.end())
            mooseError("Error in node to elem map");
 
          const auto & elem_vector = elem_vector_it->second;
 
          std::copy(elem_vector.begin(),
                    elem_vector.end(),
                    std::insert_iterator<FeatureData::container_type>(expanded_local_ids,
                                                                      expanded_local_ids.end()));
 
          // Now see which elements need to go into the ghosted set
          for (auto entity : elem_vector)
          {
            const Elem * neighbor = _mesh.elemPtr(entity);
            mooseAssert(neighbor, "neighbor pointer is NULL");
 
            if (neighbor->processor_id() != my_processor_id)
              feature._ghosted_ids.insert(feature._ghosted_ids.end(), elem->id());
          }
        }
      }
 
      // Replace the existing local ids with the expanded local ids
      feature._local_ids.swap(expanded_local_ids);
 
      // Copy the expanded local_ids into the halo_ids container
      feature._halo_ids = feature._local_ids;
    }
  }
}

featureCentroid()

Point FeatureFloodCount::featureCentroid ( unsigned int  feature_id ) const

virtualinherited

Returns the centroid of the designated feature (only supported without periodic boundaries)

Definition at line 900 of file FeatureFloodCount.C.

{
  if (feature_id >= _feature_id_to_local_index.size())
    return invalid_id;
 
  auto local_index = _feature_id_to_local_index[feature_id];
 
  Real invalid_coord = std::numeric_limits<Real>::max();
  Point p(invalid_coord, invalid_coord, invalid_coord);
  if (local_index != invalid_size_t)
  {
    mooseAssert(local_index < _feature_sets.size(), "local_index out of bounds");
    p = _feature_sets[local_index]._centroid;
  }
  return p;
}

Referenced by FeatureVolumeVectorPostprocessor::execute().

finalize()

void PolycrystalUserObjectBase::finalize ( )

overridevirtualinherited

All ranks: Update the variable indices based on the graph coloring algorithm. Here we index into the _grain_to_op vector based on the grain_id to obtain the right assignment.

Reimplemented from FeatureFloodCount.

Definition at line 166 of file PolycrystalUserObjectBase.C.

{
  if (_colors_assigned && !_fe_problem.hasInitialAdaptivity())
    return;
 
  TIME_SECTION(_finalize_timer);
  CONSOLE_TIMED_PRINT("Finalizing Polycrystal Initial Condition");
 
  // TODO: Possibly retrieve the halo thickness from the active GrainTracker object?
  constexpr unsigned int halo_thickness = 2;
 
  expandEdgeHalos(halo_thickness - 1);
 
  FeatureFloodCount::finalize();
 
  if (!_colors_assigned)
  {
    // Resize the color assignment vector here. All ranks need a copy of this
    _grain_to_op.resize(_feature_count, PolycrystalUserObjectBase::INVALID_COLOR);
    if (_is_master)
    {
      buildGrainAdjacencyMatrix();
 
      assignOpsToGrains();
 
      if (_output_adjacency_matrix)
        printGrainAdjacencyMatrix();
    }
 
    // Communicate the coloring with all ranks
    _communicator.broadcast(_grain_to_op);
 
    for (auto & grain : _feature_sets)
      grain._var_index = _grain_to_op[grain._id];
  }
 
  _colors_assigned = true;
}

flood()

bool FeatureFloodCount::flood ( const DofObject *  dof_object, std::size_t  current_index  )

protectedinherited

This method will check if the current entity is above the supplied threshold and "mark" it.

It will then inspect neighboring entities that are above the connecting threshold and add them to the current feature.

Returns

Boolean indicating whether a new feature was found while exploring the current entity.

If we reach this point (i.e. we haven't continued to the next queue entry), we've found a new mesh entity that's part of a feature. We need to mark the entity as visited at this point (and not before!) to avoid infinite recursion. If you mark the node too early you risk not coloring in a whole feature any time a "connecting threshold" is used since we may have already visited this entity earlier but it was in-between two thresholds.

See if this particular entity cell contributes to the centroid calculation. We only deal with elemental floods and only count it if it's owned by the current processor to avoid skewing the result.

Definition at line 1294 of file FeatureFloodCount.C.

{
  //  if (dof_object == nullptr || dof_object == libMesh::remote_elem)
  //    return false;
  mooseAssert(dof_object, "DOF object is nullptr");
  mooseAssert(_entity_queue.empty(), "Entity queue is not empty when starting a feature");
 
  // Kick off the exploration of a new feature
  _entity_queue.push_front(dof_object);
 
  bool return_value = false;
  FeatureData * feature = nullptr;
  while (!_entity_queue.empty())
  {
    const DofObject * curr_dof_object = _entity_queue.back();
    const Elem * elem = _is_elemental ? static_cast<const Elem *>(curr_dof_object) : nullptr;
    _entity_queue.pop_back();
 
    // Retrieve the id of the current entity
    auto entity_id = curr_dof_object->id();
 
    // Has this entity already been marked? - if so move along
    if (current_index != invalid_size_t &&
        _entities_visited[current_index].find(entity_id) != _entities_visited[current_index].end())
      continue;
 
    // Are we outside of the range we should be working in?
    if (_is_elemental && !_dof_map.is_evaluable(*elem))
      continue;
 
    // See if the current entity either starts a new feature or continues an existing feature
    auto new_id = invalid_id; // Writable reference to hold an optional id;
    Status status =
        Status::INACTIVE; // Status is inactive until we find an entity above the starting threshold
 
    // Make sure that the Assembly object has the right element and subdomain information set
    // since we are moving through the mesh in a manual fashion.
    if (_is_elemental)
      _fe_problem.setCurrentSubdomainID(elem, 0);
 
    if (!isNewFeatureOrConnectedRegion(curr_dof_object, current_index, feature, status, new_id))
    {
      // If we have an active feature, we just found a halo entity
      if (feature)
        feature->_halo_ids.insert(feature->_halo_ids.end(), entity_id);
      continue;
    }
 
    mooseAssert(current_index != invalid_size_t, "current_index is invalid");
 
    return_value = true;
    _entities_visited[current_index].insert(entity_id);
 
    auto map_num = _single_map_mode ? decltype(current_index)(0) : current_index;
 
    // New Feature (we need to create it and add it to our data structure)
    if (!feature)
    {
      _partial_feature_sets[map_num].emplace_back(
          current_index, _feature_count++, processor_id(), status);
 
      // Get a handle to the feature we will update (always the last feature in the data structure)
      feature = &_partial_feature_sets[map_num].back();
 
      // If new_id is valid, we'll set it in the feature here.
      if (new_id != invalid_id)
        feature->_id = new_id;
    }
 
    // Insert the current entity into the local ids data structure
    feature->_local_ids.insert(feature->_local_ids.end(), entity_id);
 
    if (_is_elemental && processor_id() == curr_dof_object->processor_id())
    {
      // Keep track of how many elements participate in the centroid averaging
      feature->_vol_count++;
 
      // Sum the centroid values for now, we'll average them later
      feature->_centroid += elem->centroid();
 
      //      // Does the volume intersect the boundary?
      //      if (_all_boundary_entity_ids.find(elem->id()) != _all_boundary_entity_ids.end())
      //        feature->_intersects_boundary = true;
    }
 
    if (_is_elemental)
      visitElementalNeighbors(elem,
                              feature,
                              /*expand_halos_only =*/false,
                              /*disjoint_only =*/false);
    else
      visitNodalNeighbors(static_cast<const Node *>(curr_dof_object),
                          feature,
                          /*expand_halos_only =*/false);
  }
 
  return return_value;
}

Referenced by FeatureFloodCount::execute(), and PolycrystalUserObjectBase::execute().

getConnectingThreshold()

Real FeatureFloodCount::getConnectingThreshold ( std::size_t  current_index ) const

protectedvirtualinherited

Return the "connecting" comparison threshold to use when inspecting an entity during the flood stage.

Definition at line 1412 of file FeatureFloodCount.C.

{
  return _step_connecting_threshold;
}

Referenced by FeatureFloodCount::isNewFeatureOrConnectedRegion().

getCoupledVars()

const std::vector<MooseVariable *>& FeatureFloodCount::getCoupledVars ( ) const

inlineinherited

Returns a const vector to the coupled variable pointers.

Definition at line 98 of file FeatureFloodCount.h.

{ return _vars; }

Referenced by AverageGrainVolume::AverageGrainVolume(), and FeatureVolumeVectorPostprocessor::FeatureVolumeVectorPostprocessor().

getEntityValue()

Real FeatureFloodCount::getEntityValue ( dof_id_type  entity_id, FieldType  field_type, std::size_t  var_index = 0  ) const

virtualinherited

Reimplemented in GrainTracker, and FauxGrainTracker.

Definition at line 918 of file FeatureFloodCount.C.

{
  auto use_default = false;
  if (var_index == invalid_size_t)
  {
    use_default = true;
    var_index = 0;
  }
 
  mooseAssert(var_index < _maps_size, "Index out of range");
 
  switch (field_type)
  {
    case FieldType::UNIQUE_REGION:
    {
      const auto entity_it = _feature_maps[var_index].find(entity_id);
 
      if (entity_it != _feature_maps[var_index].end())
        return entity_it->second; // + _region_offsets[var_index];
      else
        return -1;
    }
 
    case FieldType::VARIABLE_COLORING:
    {
      mooseAssert(
          _var_index_mode,
          "\"enable_var_coloring\" must be set to true to pull back the VARIABLE_COLORING field");
 
      const auto entity_it = _var_index_maps[var_index].find(entity_id);
 
      if (entity_it != _var_index_maps[var_index].end())
        return entity_it->second;
      else
        return -1;
    }
 
    case FieldType::GHOSTED_ENTITIES:
    {
      const auto entity_it = _ghosted_entity_ids.find(entity_id);
 
      if (entity_it != _ghosted_entity_ids.end())
        return entity_it->second;
      else
        return -1;
    }
 
    case FieldType::HALOS:
    {
      if (!use_default)
      {
        const auto entity_it = _halo_ids[var_index].find(entity_id);
        if (entity_it != _halo_ids[var_index].end())
          return entity_it->second;
      }
      else
      {
        // Showing halos in reverse order for backwards compatibility
        for (auto map_num = _maps_size;
             map_num-- /* don't compare greater than zero for unsigned */;)
        {
          const auto entity_it = _halo_ids[map_num].find(entity_id);
 
          if (entity_it != _halo_ids[map_num].end())
            return entity_it->second;
        }
      }
      return -1;
    }
 
    case FieldType::CENTROID:
    {
      if (_periodic_node_map.size())
        mooseDoOnce(mooseWarning(
            "Centroids are not correct when using periodic boundaries, contact the MOOSE team"));
 
      // If this element contains the centroid of one of features, return one
      const auto * elem_ptr = _mesh.elemPtr(entity_id);
 
      for (const auto & feature : _feature_sets)
      {
        if (feature._status == Status::INACTIVE)
          continue;
 
        if (elem_ptr->contains_point(feature._centroid))
          return 1;
      }
 
      return 0;
    }
 
    default:
      return 0;
  }
}

Referenced by GrainTracker::getEntityValue(), and FeatureFloodCountAux::precalculateValue().

getFeatures()

const std::vector<FeatureData>& FeatureFloodCount::getFeatures ( ) const

inlineinherited

Return a constant reference to the vector of all discovered features.

Definition at line 340 of file FeatureFloodCount.h.

{ return _feature_sets; }

Referenced by GrainTracker::prepopulateState().

getFeatureVar()

unsigned int FeatureFloodCount::getFeatureVar ( unsigned int  feature_id ) const

virtualinherited

Returns the variable representing the passed in feature.

Reimplemented in GrainTracker, and FauxGrainTracker.

Definition at line 809 of file FeatureFloodCount.C.

{
  // Some processors don't contain the largest feature id, in that case we just return invalid_id
  if (feature_id >= _feature_id_to_local_index.size())
    return invalid_id;
 
  auto local_index = _feature_id_to_local_index[feature_id];
  if (local_index != invalid_size_t)
  {
    mooseAssert(local_index < _feature_sets.size(), "local_index out of bounds");
    return _feature_sets[local_index]._status != Status::INACTIVE
               ? _feature_sets[local_index]._var_index
               : invalid_id;
  }
 
  return invalid_id;
}

Referenced by FeatureVolumeVectorPostprocessor::execute(), and GrainTracker::getFeatureVar().

getFECoupledVars()

const std::vector<MooseVariableFEBase *>& FeatureFloodCount::getFECoupledVars ( ) const

inlineinherited

Returns a const vector to the coupled MooseVariableFEBase pointers.

Definition at line 101 of file FeatureFloodCount.h.

{ return _fe_vars; }

Referenced by AverageGrainVolume::AverageGrainVolume().

getGrainsBasedOnElem()

virtual void PolycrystalUserObjectBase::getGrainsBasedOnElem ( const Elem &  elem, std::vector< unsigned int > &  grains  ) const

inlinevirtualinherited

This method may be defined in addition to the point based initialization to speed up lookups.

It returns grain IDs based on the current element. Note: If your simulation contains adaptivity the point based method may be used to retrieve grain information as well as this method.

Definition at line 52 of file PolycrystalUserObjectBase.h.

  {
    getGrainsBasedOnPoint(elem.centroid(), grains);
  }

Referenced by VoronoiICAux::computeValue(), and PolycrystalUserObjectBase::isNewFeatureOrConnectedRegion().

getGrainsBasedOnPoint()

void PolycrystalEBSD::getGrainsBasedOnPoint ( const Point &  point, std::vector< unsigned int > &  grains  ) const

overridevirtual

Method for retrieving active grain IDs based on some point in the mesh.

Typically these are element centroids or nodes depending on the basis functions being initialized. ICs that have fixed resolution data (i.e. experimental datasets) may choose to implement the element based method as well for added convenience.

Implements PolycrystalUserObjectBase.

Definition at line 35 of file PolycrystalEBSD.C.

{
  const EBSDAccessFunctors::EBSDPointData & d = _ebsd_reader.getData(point);
 
  // See if we are in a phase that we are actually tracking
  if (_phase != libMesh::invalid_uint && _phase != d._phase)
  {
    grains.resize(0);
    return;
  }
 
  // Get the ids from the EBSD reader
  const auto global_id = _ebsd_reader.getGlobalID(d._feature_id);
  const auto local_id = _ebsd_reader.getAvgData(global_id)._local_id;
 
  grains.resize(1);
  grains[0] = _phase != libMesh::invalid_uint ? local_id : global_id;
}

Referenced by getVariableValue().

getGrainToOps()

virtual const std::vector<unsigned int>& PolycrystalUserObjectBase::getGrainToOps ( ) const

inlinevirtualinherited

Method for retrieving the initial grain OP assignments.

Definition at line 83 of file PolycrystalUserObjectBase.h.

{ return _grain_to_op; }

getNodalVariableValue()

Real PolycrystalEBSD::getNodalVariableValue ( unsigned int  op_index, const Node &  n  ) const

overridevirtual

Similarly to the getVariableValue method, this method also returns values but may be optimized for returning nodal values.

Reimplemented from PolycrystalUserObjectBase.

Definition at line 65 of file PolycrystalEBSD.C.

{
  // Make sure the _current_node is in the node_to_grain_weight_map (return error if not in map)
  const auto it = _node_to_grain_weight_map.find(n.id());
 
  if (it == _node_to_grain_weight_map.end())
    mooseError("The following node id is not in the node map: ", n.id());
 
  // Increment through all grains at node_index (these are global IDs if consider_phase is false and
  // local IDs otherwise)
  const auto num_grains = getNumGrains();
  for (MooseIndex(num_grains) index = 0; index < num_grains; ++index)
  {
    // If the current order parameter index (_op_index) is equal to the assigned index
    // (_assigned_op),
    // set the value from node_to_grain_weight_map
    auto grain_index =
        _phase != libMesh::invalid_uint ? _ebsd_reader.getGlobalID(_phase, index) : index;
    mooseAssert(grain_index < it->second.size(), "grain_index out of range");
    auto value = (it->second)[grain_index];
    if (_grain_to_op[index] == op_index && value > 0.0)
      return value;
  }
 
  return 0.0;
}

getNumberActiveFeatures()

std::size_t FeatureFloodCount::getNumberActiveFeatures ( ) const

inherited

Return the number of active features.

Definition at line 791 of file FeatureFloodCount.C.

{
  // Note: This value is parallel consistent, see FeatureFloodCount::communicateAndMerge()
  return _feature_count;
}

Referenced by AverageGrainVolume::getValue().

getNumGrains()

unsigned int PolycrystalEBSD::getNumGrains ( ) const

overridevirtual

Must be overridden by the deriving class to provide the number of grains in the polycrystal structure.

Implements PolycrystalUserObjectBase.

Definition at line 56 of file PolycrystalEBSD.C.

{
  if (_phase != libMesh::invalid_uint)
    return _ebsd_reader.getGrainNum(_phase);
  else
    return _ebsd_reader.getGrainNum();
}

Referenced by getNodalVariableValue().

getThreshold()

Real FeatureFloodCount::getThreshold ( std::size_t  current_index ) const

protectedvirtualinherited

Return the starting comparison threshold to use when inspecting an entity during the flood stage.

Reimplemented in GrainTracker.

Definition at line 1407 of file FeatureFloodCount.C.

{
  return _step_threshold;
}

Referenced by FeatureFloodCount::isNewFeatureOrConnectedRegion().

getTotalFeatureCount()

std::size_t FeatureFloodCount::getTotalFeatureCount ( ) const

virtualinherited

Returns the total feature count (active and inactive ids, useful for sizing vectors)

Since the FeatureFloodCount object doesn't maintain any information about features between invocations. The maximum id in use is simply the number of features.

Reimplemented in FauxGrainTracker, and GrainTracker.

Definition at line 798 of file FeatureFloodCount.C.

{
  return _feature_count;
}

Referenced by FeatureVolumeVectorPostprocessor::execute(), and AverageGrainVolume::initialize().

getValue()

Real FeatureFloodCount::getValue ( )

overridevirtualinherited

Reimplemented in FauxGrainTracker.

Definition at line 785 of file FeatureFloodCount.C.

{
  return static_cast<Real>(_feature_count);
}

getVariableValue()

Real PolycrystalEBSD::getVariableValue ( unsigned int  op_index, const Point &  p  ) const

overridevirtual

Returns the variable value for a given op_index and mesh point.

This is the method used by the initial condition after the Polycrystal grain structure has be setup. Those grains are then distributed to the typically smaller number of order parameters by this class. This method is then used to return those values but it may be overridden in a derived class.

Implements PolycrystalUserObjectBase.

Definition at line 93 of file PolycrystalEBSD.C.

{
  std::vector<unsigned int> grain_ids;
  getGrainsBasedOnPoint(p, grain_ids);
 
  if (grain_ids.empty())
    return -1.0;
 
  mooseAssert(grain_ids.size() == 1, "Expected only one grain at point in EBSDReader");
  auto index = grain_ids[0];
  mooseAssert(index < _grain_to_op.size(), "Index out of range");
 
  return _grain_to_op[index] == op_index ? 1.0 : 0.0;
}

getVarToFeatureVector()

const std::vector< unsigned int > & FeatureFloodCount::getVarToFeatureVector ( dof_id_type  elem_id ) const

virtualinherited

Returns a list of active unique feature ids for a particular element.

The vector is indexed by variable number with each entry containing either an invalid size_t type (no feature active at that location) or a feature id if the variable is non-zero at that location.

Reimplemented in GrainTracker, and FauxGrainTracker.

Definition at line 701 of file FeatureFloodCount.C.

{
  mooseDoOnce(if (!_compute_var_to_feature_map) mooseError(
      "Please set \"compute_var_to_feature_map = true\" to use this interface method"));
 
  const auto pos = _entity_var_to_features.find(elem_id);
  if (pos != _entity_var_to_features.end())
  {
    mooseAssert(pos->second.size() == _n_vars, "Variable to feature vector not sized properly");
    return pos->second;
  }
  else
    return _empty_var_to_features;
}

Referenced by AverageGrainVolume::execute(), FeatureVolumeVectorPostprocessor::execute(), GrainTracker::getVarToFeatureVector(), and FeatureFloodCountAux::precalculateValue().

initialize()

void PolycrystalUserObjectBase::initialize ( )

overridevirtualinherited

Reimplemented from FeatureFloodCount.

Definition at line 105 of file PolycrystalUserObjectBase.C.

{
  if (_colors_assigned && !_fe_problem.hasInitialAdaptivity())
    return;
 
  _entity_to_grain_cache.clear();
 
  FeatureFloodCount::initialize();
}

initialSetup()

void PolycrystalUserObjectBase::initialSetup ( )

overridevirtualinherited

UserObject interface overrides.

Derived classes should not override any of these methods.

For polycrystal ICs we need to assume that each of the variables has the same periodicity. Since BCs are handled elsewhere in the system, we'll have to check this case explicitly.

Reimplemented from FeatureFloodCount.

Definition at line 83 of file PolycrystalUserObjectBase.C.

{
  if (_op_num < 1)
    mooseError("No coupled variables found");
 
  for (unsigned int dim = 0; dim < _dim; ++dim)
  {
    bool first_variable_value = _mesh.isTranslatedPeriodic(_vars[0]->number(), dim);
 
    for (unsigned int i = 1; i < _vars.size(); ++i)
      if (_mesh.isTranslatedPeriodic(_vars[i]->number(), dim) != first_variable_value)
        mooseError("Coupled polycrystal variables differ in periodicity");
  }
 
  FeatureFloodCount::initialSetup();
}

isBoundaryEntity()

template<typename T >

bool FeatureFloodCount::isBoundaryEntity ( const T *  entity ) const

protectedinherited

Returns a Boolean indicating whether the entity is on one of the desired boundaries.

Definition at line 1810 of file FeatureFloodCount.C.

{
  mooseAssert(_bnd_elem_range, "Boundary Element Range is nullptr");
 
  if (entity)
    for (const auto & belem : *_bnd_elem_range)
      // Only works for Elements
      if (belem->_elem->id() == entity->id() && hasBoundary(belem->_bnd_id))
        return true;
 
  return false;
}

Referenced by FeatureFloodCount::visitNeighborsHelper().

isElemental()

bool FeatureFloodCount::isElemental ( ) const

inlineinherited

Definition at line 117 of file FeatureFloodCount.h.

{ return _is_elemental; }

Referenced by FeatureFloodCountAux::FeatureFloodCountAux().

isFeaturePercolated()

bool FeatureFloodCount::isFeaturePercolated ( unsigned int  feature_id ) const

virtualinherited

Returns a Boolean indicating whether this feature is percolated (e.g.

intersects at least two different boundaries from sets supplied by the user)

Reimplemented in GrainTracker.

Definition at line 874 of file FeatureFloodCount.C.

{
  // TODO: This information is not parallel consistent when using FeatureFloodCounter
 
  // Some processors don't contain the largest feature id, in that case we just return invalid_id
  if (feature_id >= _feature_id_to_local_index.size())
    return false;
 
  auto local_index = _feature_id_to_local_index[feature_id];
 
  if (local_index != invalid_size_t)
  {
    mooseAssert(local_index < _feature_sets.size(), "local_index out of bounds");
    bool primary = ((_feature_sets[local_index]._boundary_intersection &
                     BoundaryIntersection::PRIMARY_PERCOLATION_BOUNDARY) ==
                    BoundaryIntersection::PRIMARY_PERCOLATION_BOUNDARY);
    bool secondary = ((_feature_sets[local_index]._boundary_intersection &
                       BoundaryIntersection::SECONDARY_PERCOLATION_BOUNDARY) ==
                      BoundaryIntersection::SECONDARY_PERCOLATION_BOUNDARY);
    return _feature_sets[local_index]._status != Status::INACTIVE ? (primary && secondary) : false;
  }
 
  return false;
}

Referenced by FeatureVolumeVectorPostprocessor::execute().

isGraphValid()

bool PolycrystalUserObjectBase::isGraphValid ( unsigned int  vertex, unsigned int  color  )

protectedinherited

Helper method for the back-tracking graph coloring algorithm.

Definition at line 489 of file PolycrystalUserObjectBase.C.

{
  // See if the proposed color is valid based on the current neighbor colors
  for (unsigned int neighbor = 0; neighbor < _feature_count; ++neighbor)
    if ((*_adjacency_matrix)(vertex, neighbor) && color == _grain_to_op[neighbor])
      return false;
  return true;
}

Referenced by PolycrystalUserObjectBase::colorGraph().

isNewFeatureOrConnectedRegion()

bool PolycrystalUserObjectBase::isNewFeatureOrConnectedRegion ( const DofObject *  dof_object, std::size_t &  current_index, FeatureData *&  feature, Status &  status, unsigned int &  new_id  )

overrideprotectedvirtualinherited

Method called during the recursive flood routine that should return whether or not the current entity is part of the current feature (if one is being explored), or if it's the start of a new feature.

When building the IC, we can't use the _entities_visited data structure the same way as we do for the base class. We need to discover multiple overlapping grains in a single pass. However we don't know what grain we are working on when we enter the flood routine (when that check is normally made). Only after we've made the callback to the child class do we know which grains we are operating on (at least until we've triggered the recursion). We need to see if there is at least one active grain where we haven't already visited the current entity before continuing.

If we get here the current entity is not part of the active feature, however we now want to look at neighbors.

Retrieve only the active neighbors for each side of this element, append them to the list of active neighbors

If the current element (passed into this method) doesn't have a connected neighbor but does have a topological neighbor, this might be a new disjoint region that we'll need to represent with a separate bounding box. To find out for sure, we'll need see if the new neighbors are present in any of the halo or disjoint halo sets. If they are not present, this is a new region.

If the value is only above the connecting threshold, it's still part of a feature but possibly part of one that we'll discard if there is never any starting threshold encountered.

Reimplemented from FeatureFloodCount.

Definition at line 238 of file PolycrystalUserObjectBase.C.

{
  mooseAssert(_t_step == 0, "PolyIC only works if we begin in the initial condition");
 
  // Retrieve the id of the current entity
  auto entity_id = dof_object->id();
  auto grains_it = _entity_to_grain_cache.lower_bound(entity_id);
 
  if (grains_it == _entity_to_grain_cache.end() || grains_it->first != entity_id)
  {
    std::vector<unsigned int> grain_ids;
 
    if (_is_elemental)
      getGrainsBasedOnElem(*static_cast<const Elem *>(dof_object), grain_ids);
    else
      getGrainsBasedOnPoint(*static_cast<const Node *>(dof_object), grain_ids);
 
    grains_it = _entity_to_grain_cache.emplace_hint(grains_it, entity_id, std::move(grain_ids));
  }
 
  auto saved_grain_id = invalid_id;
  if (current_index == invalid_size_t)
  {
    for (auto grain_id : grains_it->second)
    {
      mooseAssert(!_colors_assigned || grain_id < _grain_to_op.size(), "grain_id out of range");
      auto map_num = _colors_assigned ? _grain_to_op[grain_id] : grain_id;
      if (_entities_visited[map_num].find(entity_id) == _entities_visited[map_num].end())
      {
        saved_grain_id = grain_id;
 
        if (!_colors_assigned)
          current_index = grain_id;
        else
          current_index = _grain_to_op[grain_id];
 
        break;
      }
    }
 
    if (current_index == invalid_size_t)
      return false;
  }
  else if (_entities_visited[current_index].find(entity_id) !=
           _entities_visited[current_index].end())
    return false;
 
  if (!feature)
  {
    new_id = saved_grain_id;
    status &= ~Status::INACTIVE;
 
    return true;
  }
  else
  {
    const auto & grain_ids = grains_it->second;
    if (std::find(grain_ids.begin(), grain_ids.end(), feature->_id) != grain_ids.end())
      return true;
 
    if (_is_elemental)
    {
      Elem * elem = _mesh.queryElemPtr(entity_id);
      mooseAssert(elem, "Element is nullptr");
 
      std::vector<const Elem *> all_active_neighbors;
      MeshBase & mesh = _mesh.getMesh();
 
      for (auto i = decltype(elem->n_neighbors())(0); i < elem->n_neighbors(); ++i)
      {
        const Elem * neighbor_ancestor = nullptr;
 
        neighbor_ancestor = elem->neighbor_ptr(i);
        if (neighbor_ancestor)
          neighbor_ancestor->active_family_tree_by_neighbor(all_active_neighbors, elem, false);
        else // if (expand_halos_only /*&& feature->_periodic_nodes.empty()*/)
        {
          neighbor_ancestor = elem->topological_neighbor(i, mesh, *_point_locator, _pbs);
 
          if (neighbor_ancestor)
            neighbor_ancestor->active_family_tree_by_topological_neighbor(
                all_active_neighbors, elem, mesh, *_point_locator, _pbs, false);
        }
      }
 
      for (const auto neighbor : all_active_neighbors)
      {
        // Retrieve the id of the current entity
        auto neighbor_id = neighbor->id();
        auto neighbor_it = _entity_to_grain_cache.lower_bound(neighbor_id);
 
        if (neighbor_it == _entity_to_grain_cache.end() || neighbor_it->first != neighbor_id)
        {
          std::vector<unsigned int> more_grain_ids;
 
          getGrainsBasedOnElem(*static_cast<const Elem *>(neighbor), more_grain_ids);
 
          neighbor_it = _entity_to_grain_cache.emplace_hint(
              neighbor_it, neighbor_id, std::move(more_grain_ids));
        }
 
        const auto & more_grain_ids = neighbor_it->second;
        if (std::find(more_grain_ids.begin(), more_grain_ids.end(), feature->_id) !=
            more_grain_ids.end())
          return true;
      }
    }
 
    return false;
  }
}

mergeSets()

void PolycrystalUserObjectBase::mergeSets ( )

overrideprotectedvirtualinherited

This routine is called on the master rank only and stitches together the partial feature pieces seen on any processor.

With initial conditions we know the grain IDs of every grain (even partial grains). We can use this information to put all mergeable features adjacent to one and other in the list so that merging is simply O(n).

Insert the new entity at the end of the list so that it may be checked against all other partial features again.

Now remove both halves the merged features: it2 contains the "moved" feature cell just inserted at the back of the list, it1 contains the mostly empty other half. We have to be careful about the order in which these two elements are deleted. We delete it2 first since we don't care where its iterator points after the deletion. We are going to break out of this loop anyway. If we delete it1 first, it may end up pointing at the same location as it2 which after the second deletion would cause both of the iterators to be invalidated.

Reimplemented from FeatureFloodCount.

Definition at line 210 of file PolycrystalUserObjectBase.C.

{
  _partial_feature_sets[0].sort();
 
  auto it1 = _partial_feature_sets[0].begin();
  auto it_end = _partial_feature_sets[0].end();
  while (it1 != it_end)
  {
    auto it2 = it1;
    if (++it2 == it_end)
      break;
 
    if (areFeaturesMergeable(*it1, *it2))
    {
      it1->merge(std::move(*it2));
      _partial_feature_sets[0].erase(it2);
    }
    else
      ++it1; // Only increment if we have a mismatch
  }
}

meshChanged()

void FeatureFloodCount::meshChanged ( )

overridevirtualinherited

We need to build a set containing all of the boundary entities to compare against. This will be elements for elemental flooding. Volumes for nodal flooding is not supported

Reimplemented in GrainTracker.

Definition at line 335 of file FeatureFloodCount.C.

{
  _point_locator = _mesh.getMesh().sub_point_locator();
 
  _mesh.buildPeriodicNodeMap(_periodic_node_map, _var_number, _pbs);
 
  // Build a new node to element map
  _nodes_to_elem_map.clear();
  MeshTools::build_nodes_to_elem_map(_mesh.getMesh(), _nodes_to_elem_map);
 
  _all_boundary_entity_ids.clear();
  if (_is_elemental)
    for (auto elem_it = _mesh.bndElemsBegin(), elem_end = _mesh.bndElemsEnd(); elem_it != elem_end;
         ++elem_it)
      _all_boundary_entity_ids.insert((*elem_it)->_elem->id());
}

Referenced by FeatureFloodCount::initialSetup(), and GrainTracker::meshChanged().

numCoupledVars()

std::size_t FeatureFloodCount::numCoupledVars ( ) const

inlineinherited

Returns the number of coupled varaibles.

Definition at line 89 of file FeatureFloodCount.h.

{ return _n_vars; }

precomputeGrainStructure()

virtual void PolycrystalUserObjectBase::precomputeGrainStructure ( )

inlinevirtualinherited

This callback is triggered after the object is initialized and may be optionally overridden to do precompute the element to grain identifiers ahead of time.

Reimplemented in PolycrystalCircles, PolycrystalVoronoi, and PolycrystalHex.

Definition at line 36 of file PolycrystalUserObjectBase.h.

{}

Referenced by PolycrystalUserObjectBase::execute().

prepareDataForTransfer()

void FeatureFloodCount::prepareDataForTransfer ( )

protectedinherited

This routine uses the local flooded data to build up the local feature data structures (_feature_sets).

This routine does not perform any communication so the _feature_sets data structure will only contain information from the local processor after calling this routine. Any existing data in the _feature_sets structure is destroyed by calling this routine.

_feature_sets layout: The outer vector is sized to one when _single_map_mode == true, otherwise it is sized for the number of coupled variables. The inner list represents the flooded regions (local only after this call but fully populated after parallel communication and stitching).

If using a vector container, we need to sort all of the data structures for later operations such as checking for intersection and merging. The following "sort" function does nothing when invoked on a std::set.

Save off the min entity id present in the feature to uniquely identify the feature regardless of n_procs

Definition at line 1017 of file FeatureFloodCount.C.

{
  TIME_SECTION(_prepare_for_transfer);
 
  MeshBase & mesh = _mesh.getMesh();
 
  FeatureData::container_type local_ids_no_ghost, set_difference;
 
  for (auto & list_ref : _partial_feature_sets)
  {
    for (auto & feature : list_ref)
    {
      // See if the feature intersects a boundary or perhaps one of the percolation boundaries.
      updateBoundaryIntersections(feature);
 
      // Periodic node ids
      appendPeriodicNeighborNodes(feature);
 
      FeatureFloodCount::sort(feature._ghosted_ids);
      FeatureFloodCount::sort(feature._local_ids);
      FeatureFloodCount::sort(feature._halo_ids);
      FeatureFloodCount::sort(feature._disjoint_halo_ids);
      FeatureFloodCount::sort(feature._periodic_nodes);
 
      // Now extend the bounding box by the halo region
      if (_is_elemental)
        feature.updateBBoxExtremes(mesh);
      else
      {
        for (auto & halo_id : feature._halo_ids)
          updateBBoxExtremesHelper(feature._bboxes[0], mesh.point(halo_id));
      }
 
      mooseAssert(!feature._local_ids.empty(), "local entity ids cannot be empty");
 
      feature._min_entity_id = *feature._local_ids.begin();
    }
  }
}

Referenced by FeatureFloodCount::communicateAndMerge().

printGrainAdjacencyMatrix()

void PolycrystalUserObjectBase::printGrainAdjacencyMatrix ( ) const

protectedinherited

Prints out the adjacency matrix in a nicely spaced integer format.

Definition at line 499 of file PolycrystalUserObjectBase.C.

{
  _console << "Grain Adjacency Matrix:\n";
  for (unsigned int i = 0; i < _adjacency_matrix->m(); i++)
  {
    for (unsigned int j = 0; j < _adjacency_matrix->n(); j++)
      _console << _adjacency_matrix->el(i, j) << "  ";
    _console << '\n';
  }
 
  _console << "Grain to OP assignments:\n";
  for (auto op : _grain_to_op)
    _console << op << "  ";
  _console << '\n' << std::endl;
}

Referenced by PolycrystalUserObjectBase::finalize().

reserve() [1/2]

template<class T >

static void FeatureFloodCount::reserve ( std::set< T > &  , std::size_t    )

inlinestaticprivateinherited

Definition at line 748 of file FeatureFloodCount.h.

  {
    // Sets are trees, no reservations necessary

Referenced by FeatureFloodCount::FeatureData::consolidate(), FeatureFloodCount::FeatureData::merge(), and FeatureFloodCount::FeatureData::updateBBoxExtremes().

reserve() [2/2]

template<class T >

static void FeatureFloodCount::reserve ( std::vector< T > &  container, std::size_t  size  )

inlinestaticprivateinherited

Definition at line 754 of file FeatureFloodCount.h.

  {
    container.reserve(size);

scatterAndUpdateRanks()

void FeatureFloodCount::scatterAndUpdateRanks ( )

protectedinherited

Calls buildLocalToGlobalIndices to build the individual local to global indicies for each rank and scatters that information to all ranks.

Finally, the non-master ranks update their own data structures to reflect the global mappings.

On non-root processors we can't maintain the full _feature_sets data structure since we don't have all of the global information. We'll move the items from the partial feature sets into a flat structure maintaining order and update the internal IDs with the proper global ID.

Important: Make sure we clear the local status if we received a valid global index for this feature. It's possible that we have a status of INVALID on the local processor because there was never any starting threshold found. However, the root processor wouldn't have sent an index if it didn't find a starting threshold connected to our local piece.

Definition at line 717 of file FeatureFloodCount.C.

{
  // local to global map (one per processor)
  std::vector<int> counts;
  std::vector<std::size_t> local_to_global_all;
  if (_is_master)
    buildLocalToGlobalIndices(local_to_global_all, counts);
 
  // Scatter local_to_global indices to all processors and store in class member variable
  _communicator.scatter(local_to_global_all, counts, _local_to_global_feature_map);
 
  std::size_t largest_global_index = std::numeric_limits<std::size_t>::lowest();
  if (!_is_master)
  {
    _feature_sets.resize(_local_to_global_feature_map.size());
 
    for (auto & list_ref : _partial_feature_sets)
    {
      for (auto & feature : list_ref)
      {
        mooseAssert(feature._orig_ids.size() == 1, "feature._orig_ids length doesn't make sense");
 
        auto global_index = FeatureFloodCount::invalid_size_t;
        auto local_index = feature._orig_ids.begin()->second;
 
        if (local_index < _local_to_global_feature_map.size())
          global_index = _local_to_global_feature_map[local_index];
 
        if (global_index != FeatureFloodCount::invalid_size_t)
        {
          if (global_index > largest_global_index)
            largest_global_index = global_index;
 
          // Set the correct global index
          feature._id = global_index;
 
          feature._status &= ~Status::INACTIVE;
 
          // Move the feature into the correct place
          _feature_sets[local_index] = std::move(feature);
        }
      }
    }
  }
  else
  {
    for (auto global_index : local_to_global_all)
      if (global_index != FeatureFloodCount::invalid_size_t && global_index > largest_global_index)
        largest_global_index = global_index;
  }
 
  buildFeatureIdToLocalIndices(largest_global_index);
}

Referenced by GrainTracker::assignGrains(), FeatureFloodCount::finalize(), and GrainTracker::trackGrains().

serialize()

void FeatureFloodCount::serialize ( std::string &  serialized_buffer, unsigned int  var_num = invalid_id  )

protectedinherited

This routines packs the _partial_feature_sets data into a structure suitable for parallel communication operations.

Definition at line 1067 of file FeatureFloodCount.C.

{
  // stream for serializing the _partial_feature_sets data structure to a byte stream
  std::ostringstream oss;
 
  mooseAssert(var_num == invalid_id || var_num < _partial_feature_sets.size(),
              "var_num out of range");
 
  // Serialize everything
  if (var_num == invalid_id)
    dataStore(oss, _partial_feature_sets, this);
  else
    dataStore(oss, _partial_feature_sets[var_num], this);
 
  // Populate the passed in string pointer with the string stream's buffer contents
  serialized_buffer.assign(oss.str());
}

Referenced by FeatureFloodCount::communicateAndMerge().

setsIntersect()

template<class InputIterator >

static bool FeatureFloodCount::setsIntersect ( InputIterator  first1, InputIterator  last1, InputIterator  first2, InputIterator  last2  )

inlinestaticprotectedinherited

This method detects whether two sets intersect without building a result set.

It exits as soon as any intersection is detected.

Definition at line 543 of file FeatureFloodCount.h.

  {
    while (first1 != last1 && first2 != last2)
    {
      if (*first1 == *first2)
        return true;
 
      if (*first1 < *first2)
        ++first1;
      else if (*first1 > *first2)
        ++first2;
    }
    return false;
  }

Referenced by FeatureFloodCount::FeatureData::ghostedIntersect(), FeatureFloodCount::FeatureData::halosIntersect(), and FeatureFloodCount::FeatureData::periodicBoundariesIntersect().

sort() [1/2]

template<class T >

static void FeatureFloodCount::sort ( std::set< T > &  )

inlinestaticprivateinherited

Definition at line 736 of file FeatureFloodCount.h.

  {
    // Sets are already sorted, do nothing

Referenced by FeatureFloodCount::prepareDataForTransfer().

sort() [2/2]

template<class T >

static void FeatureFloodCount::sort ( std::vector< T > &  container )

inlinestaticprivateinherited

Definition at line 742 of file FeatureFloodCount.h.

  {
    std::sort(container.begin(), container.end());

sortAndLabel()

void FeatureFloodCount::sortAndLabel ( )

protectedinherited

Sort and assign ids to features based on their position in the container after sorting.

Perform a sort to give a parallel unique sorting to the identified features. We use the "min_entity_id" inside each feature to assign it's position in the sorted vector.

Sanity check. Now that we've sorted the flattened vector of features we need to make sure that the counts vector still lines up appropriately with each feature's _var_index.

Definition at line 573 of file FeatureFloodCount.C.

{
  mooseAssert(_is_master, "sortAndLabel can only be called on the master");
 
  std::sort(_feature_sets.begin(), _feature_sets.end());
 
#ifndef NDEBUG
 
  unsigned int feature_offset = 0;
  for (MooseIndex(_maps_size) map_num = 0; map_num < _maps_size; ++map_num)
  {
    // Skip empty map checks
    if (_feature_counts_per_map[map_num] == 0)
      continue;
 
    // Check the begin and end of the current range
    auto range_front = feature_offset;
    auto range_back = feature_offset + _feature_counts_per_map[map_num] - 1;
 
    mooseAssert(range_front <= range_back && range_back < _feature_count,
                "Indexing error in feature sets");
 
    if (!_single_map_mode && (_feature_sets[range_front]._var_index != map_num ||
                              _feature_sets[range_back]._var_index != map_num))
      mooseError("Error in _feature_sets sorting, map index: ", map_num);
 
    feature_offset += _feature_counts_per_map[map_num];
  }
#endif
 
  // Label the features with an ID based on the sorting (processor number independent value)
  for (MooseIndex(_feature_sets) i = 0; i < _feature_sets.size(); ++i)
    if (_feature_sets[i]._id == invalid_id)
      _feature_sets[i]._id = i;
}

Referenced by GrainTracker::assignGrains(), and FeatureFloodCount::finalize().

updateBoundaryIntersections()

void FeatureFloodCount::updateBoundaryIntersections ( FeatureData &  feature ) const

protectedinherited

Update the feature's attributes to indicate boundary intersections.

Definition at line 1724 of file FeatureFloodCount.C.

{
  if (_is_elemental)
  {
    for (auto entity : feature._local_ids)
    {
      // See if this feature is on a boundary if we haven't already figured that out
      if ((feature._boundary_intersection & BoundaryIntersection::ANY_BOUNDARY) ==
          BoundaryIntersection::NONE)
      {
        Elem * elem = _mesh.elemPtr(entity);
        if (elem && elem->on_boundary())
          feature._boundary_intersection |= BoundaryIntersection::ANY_BOUNDARY;
      }
 
      // Now see if the feature touches the primary and/or secondary boundary IDs if we haven't
      // figured that out already
      if ((feature._boundary_intersection & BoundaryIntersection::PRIMARY_PERCOLATION_BOUNDARY) ==
          BoundaryIntersection::NONE)
      {
        for (auto primary_id : _primary_perc_bnds)
          if (_mesh.isBoundaryElem(entity, primary_id))
            feature._boundary_intersection |= BoundaryIntersection::PRIMARY_PERCOLATION_BOUNDARY;
      }
 
      if ((feature._boundary_intersection & BoundaryIntersection::SECONDARY_PERCOLATION_BOUNDARY) ==
          BoundaryIntersection::NONE)
      {
        for (auto secondary_id : _secondary_perc_bnds)
          if (_mesh.isBoundaryElem(entity, secondary_id))
            feature._boundary_intersection |= BoundaryIntersection::SECONDARY_PERCOLATION_BOUNDARY;
      }
 
      // See if the feature contacts any of the user-specified boundaries if we haven't
      // done so already
      if ((feature._boundary_intersection & BoundaryIntersection::SPECIFIED_BOUNDARY) ==
          BoundaryIntersection::NONE)
      {
        for (auto specified_id : _specified_bnds)
          if (_mesh.isBoundaryElem(entity, specified_id))
            feature._boundary_intersection |= BoundaryIntersection::SPECIFIED_BOUNDARY;
      }
    }
  }
}

Referenced by FeatureFloodCount::prepareDataForTransfer().

updateFieldInfo()

void FeatureFloodCount::updateFieldInfo ( )

protectedvirtualinherited

This method is used to populate any of the data structures used for storing field data (nodal or elemental).

It is called at the end of finalize and can make use of any of the data structures created during the execution of this postprocessor.

Reimplemented in GrainTracker.

Definition at line 1249 of file FeatureFloodCount.C.

{
  for (MooseIndex(_feature_sets) i = 0; i < _feature_sets.size(); ++i)
  {
    auto & feature = _feature_sets[i];
 
    // If the developer has requested _condense_map_info we'll make sure we only update the zeroth
    // map
    auto map_index = (_single_map_mode || _condense_map_info) ? decltype(feature._var_index)(0)
                                                              : feature._var_index;
 
    // Loop over the entity ids of this feature and update our local map
    for (auto entity : feature._local_ids)
    {
      _feature_maps[map_index][entity] = static_cast<int>(feature._id);
 
      if (_var_index_mode)
        _var_index_maps[map_index][entity] = feature._var_index;
 
      // Fill in the data structure that keeps track of all features per elem
      if (_compute_var_to_feature_map)
      {
        auto insert_pair = moose_try_emplace(
            _entity_var_to_features, entity, std::vector<unsigned int>(_n_vars, invalid_id));
        auto & vec_ref = insert_pair.first->second;
        vec_ref[feature._var_index] = feature._id;
      }
    }
 
    if (_compute_halo_maps)
      // Loop over the halo ids to update cells with halo information
      for (auto entity : feature._halo_ids)
        _halo_ids[map_index][entity] = static_cast<int>(feature._id);
 
    // Loop over the ghosted ids to update cells with ghost information
    for (auto entity : feature._ghosted_ids)
      _ghosted_entity_ids[entity] = 1;
 
    // TODO: Fixme
    if (!_global_numbering)
      mooseError("Local numbering currently disabled");
  }
}

Referenced by FeatureFloodCount::finalize().

updateRegionOffsets()

void FeatureFloodCount::updateRegionOffsets ( )

protectedinherited

This routine updates the _region_offsets variable which is useful for quickly determining the proper global number for a feature when using multimap mode.

visitElementalNeighbors()

void FeatureFloodCount::visitElementalNeighbors ( const Elem *  elem, FeatureData *  feature, bool  expand_halos_only, bool  disjoint_only  )

protectedinherited

Retrieve only the active neighbors for each side of this element, append them to the list of active neighbors

If the current element (passed into this method) doesn't have a connected neighbor but does have a topological neighbor, this might be a new disjoint region that we'll need to represent with a separate bounding box. To find out for sure, we'll need see if the new neighbors are present in any of the halo or disjoint halo sets. If they are not present, this is a new region.

This neighbor is NULL which means we need to expand the bounding box here in case this grain is up against multiple domain edges so we don't end up with a degenerate bounding box.

Definition at line 1584 of file FeatureFloodCount.C.

{
  mooseAssert(elem, "Elem is NULL");
 
  std::vector<const Elem *> all_active_neighbors;
  MeshBase & mesh = _mesh.getMesh();
 
  // Loop over all neighbors (at the the same level as the current element)
  for (MooseIndex(elem->n_neighbors()) i = 0; i < elem->n_neighbors(); ++i)
  {
    const Elem * neighbor_ancestor = nullptr;
    bool topological_neighbor = false;
 
    neighbor_ancestor = elem->neighbor_ptr(i);
    if (neighbor_ancestor)
    {
      if (neighbor_ancestor == libMesh::remote_elem)
        continue;
 
      neighbor_ancestor->active_family_tree_by_neighbor(all_active_neighbors, elem, false);
    }
    else
    {
      neighbor_ancestor = elem->topological_neighbor(i, mesh, *_point_locator, _pbs);
 
      if (neighbor_ancestor)
      {
        neighbor_ancestor->active_family_tree_by_topological_neighbor(
            all_active_neighbors, elem, mesh, *_point_locator, _pbs, false);
 
        topological_neighbor = true;
      }
      else
      {
        updateBBoxExtremesHelper(feature->_bboxes[0], *elem);
      }
    }
 
    visitNeighborsHelper(elem,
                         all_active_neighbors,
                         feature,
                         expand_halos_only,
                         topological_neighbor,
                         disjoint_only);
 
    all_active_neighbors.clear();
  }
}

Referenced by FeatureFloodCount::expandEdgeHalos(), and FeatureFloodCount::flood().

visitNeighborsHelper()

template<typename T >

void FeatureFloodCount::visitNeighborsHelper ( const T *  curr_entity, std::vector< const T * >  neighbor_entities, FeatureData *  feature, bool  expand_halos_only, bool  topological_neighbor, bool  disjoint_only  )

protectedinherited

The actual logic for visiting neighbors is abstracted out here.

This method is templated to handle the Nodal and Elemental cases together.

Only recurse where we own this entity and it's a topologically connected entity. We shouldn't even attempt to flood to the periodic boundary because we won't have solution information and if we are using DistributedMesh we probably won't have geometric information either.

When we only recurse on entities we own, we can never get more than one away from a local entity which should be in the ghosted zone.

Premark neighboring entities with a halo mark. These entities may or may not end up being part of the feature. We will not update the _entities_visited data structure here.

Definition at line 1667 of file FeatureFloodCount.C.

{
  // Loop over all active element neighbors
  for (const auto neighbor : neighbor_entities)
  {
    if (neighbor && (!_is_boundary_restricted || isBoundaryEntity(neighbor)))
    {
      if (expand_halos_only)
      {
        auto entity_id = neighbor->id();
 
        if (topological_neighbor || disjoint_only)
          feature->_disjoint_halo_ids.insert(feature->_disjoint_halo_ids.end(), entity_id);
        else if (feature->_local_ids.find(entity_id) == feature->_local_ids.end())
          feature->_halo_ids.insert(feature->_halo_ids.end(), entity_id);
      }
      else
      {
        auto my_processor_id = processor_id();
 
        if (!topological_neighbor && neighbor->processor_id() != my_processor_id)
          feature->_ghosted_ids.insert(feature->_ghosted_ids.end(), curr_entity->id());
 
        if (curr_entity->processor_id() == my_processor_id ||
            neighbor->processor_id() == my_processor_id)
        {
          if (topological_neighbor || disjoint_only)
            feature->_disjoint_halo_ids.insert(feature->_disjoint_halo_ids.end(), neighbor->id());
          else
            _entity_queue.push_front(neighbor);
        }
      }
    }
  }
}

Referenced by FeatureFloodCount::visitElementalNeighbors(), and FeatureFloodCount::visitNodalNeighbors().

visitNodalNeighbors()

void FeatureFloodCount::visitNodalNeighbors ( const Node *  node, FeatureData *  feature, bool  expand_halos_only  )

protectedinherited

These two routines are utility routines used by the flood routine and by derived classes for visiting neighbors.

Since the logic is different for the elemental versus nodal case it's easier to split them up.

Definition at line 1653 of file FeatureFloodCount.C.

{
  mooseAssert(node, "Node is NULL");
 
  std::vector<const Node *> all_active_neighbors;
  MeshTools::find_nodal_neighbors(_mesh.getMesh(), *node, _nodes_to_elem_map, all_active_neighbors);
 
  visitNeighborsHelper(node, all_active_neighbors, feature, expand_halos_only, false, false);
}

Referenced by FeatureFloodCount::expandEdgeHalos(), and FeatureFloodCount::flood().

Member Data Documentation

_adjacency_matrix

std::unique_ptr<DenseMatrix<Real> > PolycrystalUserObjectBase::_adjacency_matrix

protectedinherited

The dense adjacency matrix.

Definition at line 141 of file PolycrystalUserObjectBase.h.

Referenced by PolycrystalUserObjectBase::assignOpsToGrains(), PolycrystalUserObjectBase::buildGrainAdjacencyMatrix(), PolycrystalUserObjectBase::isGraphValid(), and PolycrystalUserObjectBase::printGrainAdjacencyMatrix().

_all_boundary_entity_ids

std::unordered_set<dof_id_type> FeatureFloodCount::_all_boundary_entity_ids

protectedinherited

The set of entities on the boundary of the domain used for determining if features intersect any boundary.

Definition at line 711 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::meshChanged().

_bnd_elem_range

ConstBndElemRange* FeatureFloodCount::_bnd_elem_range

protectedinherited

Boundary element range pointer.

Definition at line 729 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::execute(), and FeatureFloodCount::isBoundaryEntity().

_coloring_algorithm

const MooseEnum PolycrystalUserObjectBase::_coloring_algorithm

protectedinherited

The selected graph coloring algorithm used by this object.

Definition at line 153 of file PolycrystalUserObjectBase.h.

Referenced by PolycrystalUserObjectBase::assignOpsToGrains().

_colors_assigned

bool PolycrystalUserObjectBase::_colors_assigned

protectedinherited

A Boolean indicating whether the object has assigned colors to grains (internal use)

Definition at line 156 of file PolycrystalUserObjectBase.h.

Referenced by PolycrystalUserObjectBase::execute(), PolycrystalUserObjectBase::finalize(), PolycrystalUserObjectBase::initialize(), and PolycrystalUserObjectBase::isNewFeatureOrConnectedRegion().

_comm_and_merge

const PerfID FeatureFloodCount::_comm_and_merge

privateinherited

Definition at line 775 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::communicateAndMerge().

_compute_halo_maps

const bool FeatureFloodCount::_compute_halo_maps

protectedinherited

Indicates whether or not to communicate halo map information with all ranks.

Definition at line 604 of file FeatureFloodCount.h.

Referenced by GrainTracker::communicateHaloMap(), GrainTracker::meshChanged(), GrainTracker::updateFieldInfo(), and FeatureFloodCount::updateFieldInfo().

_compute_var_to_feature_map

const bool FeatureFloodCount::_compute_var_to_feature_map

protectedinherited

Indicates whether or not the var to feature map is populated.

Definition at line 607 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::getVarToFeatureVector(), GrainTracker::updateFieldInfo(), and FeatureFloodCount::updateFieldInfo().

_condense_map_info

const bool FeatureFloodCount::_condense_map_info

protectedinherited

Definition at line 593 of file FeatureFloodCount.h.

Referenced by GrainTracker::updateFieldInfo(), and FeatureFloodCount::updateFieldInfo().

_connecting_threshold

const Real FeatureFloodCount::_connecting_threshold

protectedinherited

The threshold above (or below) which neighboring entities are flooded (where regions can be extended but not started)

Definition at line 577 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::initialize().

_consolidate_merged_features

const PerfID FeatureFloodCount::_consolidate_merged_features

privateinherited

Definition at line 779 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::consolidateMergedFeatures().

_dim

const unsigned int PolycrystalUserObjectBase::_dim

protectedinherited

mesh dimension

Definition at line 144 of file PolycrystalUserObjectBase.h.

Referenced by PolycrystalUserObjectBase::initialSetup(), and PolycrystalHex::precomputeGrainStructure().

_distribute_merge_work

const bool FeatureFloodCount::_distribute_merge_work

privateinherited

Keeps track of whether we are distributing the merge work.

Definition at line 769 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::communicateAndMerge().

_dof_map

const DofMap& FeatureFloodCount::_dof_map

protectedinherited

Reference to the dof_map containing the coupled variables.

Definition at line 569 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::flood().

_ebsd_reader

const EBSDReader& PolycrystalEBSD::_ebsd_reader

protected

Definition at line 34 of file PolycrystalEBSD.h.

Referenced by getGrainsBasedOnPoint(), getNodalVariableValue(), and getNumGrains().

_element_average_value

const PostprocessorValue& FeatureFloodCount::_element_average_value

protectedinherited

Average value of the domain which can optionally be used to find features in a field.

Definition at line 692 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::initialize().

_empty_var_to_features

std::vector<unsigned int> FeatureFloodCount::_empty_var_to_features

protectedinherited

Definition at line 715 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::getVarToFeatureVector(), and FeatureFloodCount::initialSetup().

_entities_visited

std::vector<std::set<dof_id_type> > FeatureFloodCount::_entities_visited

protectedinherited

This variable keeps track of which nodes have been visited during execution.

We don't use the _feature_map for this since we don't want to explicitly store data for all the unmarked nodes in a serialized datastructures. This keeps our overhead down since this variable never needs to be communicated.

Definition at line 631 of file FeatureFloodCount.h.

Referenced by PolycrystalUserObjectBase::execute(), FeatureFloodCount::flood(), FeatureFloodCount::initialize(), FeatureFloodCount::initialSetup(), and PolycrystalUserObjectBase::isNewFeatureOrConnectedRegion().

_entity_queue

std::deque<const DofObject *> FeatureFloodCount::_entity_queue

privateinherited

The data structure for maintaining entities to flood during discovery.

Definition at line 766 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::flood(), and FeatureFloodCount::visitNeighborsHelper().

_entity_to_grain_cache

std::map<dof_id_type, std::vector<unsigned int> > PolycrystalUserObjectBase::_entity_to_grain_cache

privateinherited

Definition at line 171 of file PolycrystalUserObjectBase.h.

Referenced by PolycrystalUserObjectBase::initialize(), and PolycrystalUserObjectBase::isNewFeatureOrConnectedRegion().

_entity_var_to_features

std::map<dof_id_type, std::vector<unsigned int> > FeatureFloodCount::_entity_var_to_features

protectedinherited

Definition at line 713 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::getVarToFeatureVector(), FeatureFloodCount::initialize(), GrainTracker::updateFieldInfo(), and FeatureFloodCount::updateFieldInfo().

_execute_timer

const PerfID PolycrystalUserObjectBase::_execute_timer

privateinherited

Timers.

Definition at line 174 of file PolycrystalUserObjectBase.h.

Referenced by PolycrystalUserObjectBase::execute().

_expand_halos

const PerfID FeatureFloodCount::_expand_halos

privateinherited

Definition at line 776 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::expandEdgeHalos().

_fe_vars

std::vector<MooseVariableFEBase *> FeatureFloodCount::_fe_vars

protectedinherited

The vector of coupled in variables.

Definition at line 564 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::FeatureFloodCount(), and FeatureFloodCount::getFECoupledVars().

_feature_count

unsigned int FeatureFloodCount::_feature_count

protectedinherited

The number of features seen by this object (same as summing _feature_counts_per_map)

Definition at line 648 of file FeatureFloodCount.h.

Referenced by PolycrystalUserObjectBase::assignOpsToGrains(), PolycrystalUserObjectBase::buildGrainAdjacencyMatrix(), PolycrystalUserObjectBase::colorGraph(), FeatureFloodCount::communicateAndMerge(), FeatureFloodCount::consolidateMergedFeatures(), PolycrystalUserObjectBase::finalize(), FeatureFloodCount::flood(), FeatureFloodCount::getNumberActiveFeatures(), GrainTracker::getNumberActiveGrains(), FeatureFloodCount::getTotalFeatureCount(), FeatureFloodCount::getValue(), FeatureFloodCount::initialize(), PolycrystalUserObjectBase::isGraphValid(), GrainTracker::prepopulateState(), and FeatureFloodCount::sortAndLabel().

_feature_counts_per_map

std::vector<unsigned int> FeatureFloodCount::_feature_counts_per_map

protectedinherited

The number of features seen by this object per map.

Definition at line 645 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::consolidateMergedFeatures(), FeatureFloodCount::sortAndLabel(), and GrainTracker::trackGrains().

_feature_id_to_local_index

std::vector<std::size_t> FeatureFloodCount::_feature_id_to_local_index

protectedinherited

The vector recording the grain_id to local index (several indices will contain invalid_size_t)

Definition at line 684 of file FeatureFloodCount.h.

Referenced by GrainTracker::broadcastAndUpdateGrainData(), FeatureFloodCount::buildFeatureIdToLocalIndices(), FeatureFloodCount::doesFeatureIntersectBoundary(), GrainTracker::doesFeatureIntersectBoundary(), FeatureFloodCount::doesFeatureIntersectSpecifiedBoundary(), GrainTracker::doesFeatureIntersectSpecifiedBoundary(), FeatureFloodCount::featureCentroid(), FeatureFloodCount::getFeatureVar(), GrainTracker::getGrainCentroid(), GrainTracker::isFeaturePercolated(), FeatureFloodCount::isFeaturePercolated(), and GrainTracker::newGrainCreated().

_feature_maps

std::vector<std::map<dof_id_type, int> > FeatureFloodCount::_feature_maps

protectedinherited

The feature maps contain the raw flooded node information and eventually the unique grain numbers.

We have a vector of them so we can create one per variable if that level of detail is desired.

Definition at line 678 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::getEntityValue(), FeatureFloodCount::initialize(), GrainTracker::updateFieldInfo(), and FeatureFloodCount::updateFieldInfo().

_feature_sets

std::vector<FeatureData>& FeatureFloodCount::_feature_sets

protectedinherited

The data structure used to hold the globally unique features.

The sorting of the vector is implementation defined and may not correspond to anything useful. The ID of each feature should be queried from the FeatureData objects.

Definition at line 662 of file FeatureFloodCount.h.

Referenced by GrainTracker::assignGrains(), GrainTracker::attemptGrainRenumber(), GrainTracker::broadcastAndUpdateGrainData(), FeatureFloodCount::buildFeatureIdToLocalIndices(), PolycrystalUserObjectBase::buildGrainAdjacencyMatrix(), FeatureFloodCount::buildLocalToGlobalIndices(), GrainTracker::communicateHaloMap(), GrainTracker::computeMinDistancesFromGrain(), FeatureFloodCount::consolidateMergedFeatures(), FeatureFloodCount::doesFeatureIntersectBoundary(), GrainTracker::doesFeatureIntersectBoundary(), FeatureFloodCount::doesFeatureIntersectSpecifiedBoundary(), GrainTracker::doesFeatureIntersectSpecifiedBoundary(), FeatureFloodCount::featureCentroid(), PolycrystalUserObjectBase::finalize(), FeatureFloodCount::getEntityValue(), FeatureFloodCount::getFeatures(), FeatureFloodCount::getFeatureVar(), GrainTracker::getGrainCentroid(), GrainTracker::initialize(), FeatureFloodCount::initialize(), GrainTracker::isFeaturePercolated(), FeatureFloodCount::isFeaturePercolated(), GrainTracker::newGrainCreated(), GrainTracker::prepopulateState(), GrainTracker::remapGrains(), FeatureFloodCount::scatterAndUpdateRanks(), FeatureFloodCount::sortAndLabel(), GrainTracker::trackGrains(), GrainTracker::updateFieldInfo(), and FeatureFloodCount::updateFieldInfo().

_finalize_timer

const PerfID PolycrystalUserObjectBase::_finalize_timer

privateinherited

Definition at line 175 of file PolycrystalUserObjectBase.h.

Referenced by PolycrystalUserObjectBase::finalize().

_ghosted_entity_ids

std::map<dof_id_type, int> FeatureFloodCount::_ghosted_entity_ids

protectedinherited

The map for holding reconstructed ghosted element information.

Definition at line 695 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::getEntityValue(), FeatureFloodCount::initialize(), GrainTracker::updateFieldInfo(), and FeatureFloodCount::updateFieldInfo().

_global_numbering

const bool FeatureFloodCount::_global_numbering

protectedinherited

This variable is used to indicate whether or not we identify features with unique numbers on multiple maps.

Definition at line 597 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::updateFieldInfo().

_grain_to_op

std::vector<unsigned int> PolycrystalUserObjectBase::_grain_to_op

protectedinherited

A vector indicating which op is assigned to each grain.

Definition at line 150 of file PolycrystalUserObjectBase.h.

Referenced by PolycrystalUserObjectBase::assignOpsToGrains(), PolycrystalUserObjectBase::colorGraph(), PolycrystalUserObjectBase::finalize(), PolycrystalUserObjectBase::getGrainToOps(), getNodalVariableValue(), getVariableValue(), PolycrystalVoronoi::getVariableValue(), PolycrystalCircles::getVariableValue(), PolycrystalUserObjectBase::isGraphValid(), PolycrystalUserObjectBase::isNewFeatureOrConnectedRegion(), and PolycrystalUserObjectBase::printGrainAdjacencyMatrix().

_halo_ids

std::vector<std::map<dof_id_type, int> > FeatureFloodCount::_halo_ids

protectedinherited

The data structure for looking up halos around features.

The outer vector is for splitting out the information per variable. The inner map holds the actual halo information

Definition at line 701 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::FeatureData::clear(), GrainTracker::communicateHaloMap(), FeatureFloodCount::getEntityValue(), FeatureFloodCount::FeatureData::halosIntersect(), FeatureFloodCount::initialize(), FeatureFloodCount::FeatureData::merge(), GrainTracker::updateFieldInfo(), and FeatureFloodCount::updateFieldInfo().

_is_boundary_restricted

bool FeatureFloodCount::_is_boundary_restricted

protectedinherited

Indicates that this object should only run on one or more boundaries.

Definition at line 726 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::execute(), FeatureFloodCount::FeatureFloodCount(), and FeatureFloodCount::visitNeighborsHelper().

_is_elemental

const bool FeatureFloodCount::_is_elemental

protectedinherited

Determines if the flood counter is elements or not (nodes)

Definition at line 723 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::appendPeriodicNeighborNodes(), GrainTracker::communicateHaloMap(), FauxGrainTracker::execute(), FeatureFloodCount::execute(), PolycrystalUserObjectBase::execute(), FeatureFloodCount::expandEdgeHalos(), FauxGrainTracker::finalize(), FeatureFloodCount::flood(), FauxGrainTracker::initialize(), FeatureFloodCount::isElemental(), PolycrystalUserObjectBase::isNewFeatureOrConnectedRegion(), FeatureFloodCount::isNewFeatureOrConnectedRegion(), FeatureFloodCount::meshChanged(), FeatureFloodCount::prepareDataForTransfer(), GrainTracker::swapSolutionValues(), FeatureFloodCount::updateBoundaryIntersections(), and GrainTracker::updateFieldInfo().

_is_master

const bool FeatureFloodCount::_is_master

protectedinherited

Convenience variable for testing master rank.

Definition at line 732 of file FeatureFloodCount.h.

Referenced by GrainTracker::assignGrains(), PolycrystalUserObjectBase::assignOpsToGrains(), GrainTracker::broadcastAndUpdateGrainData(), PolycrystalUserObjectBase::buildGrainAdjacencyMatrix(), FeatureFloodCount::buildLocalToGlobalIndices(), FeatureFloodCount::communicateAndMerge(), GrainTracker::communicateHaloMap(), FeatureFloodCount::consolidateMergedFeatures(), FeatureFloodCount::finalize(), PolycrystalUserObjectBase::finalize(), GrainTracker::newGrainCreated(), GrainTracker::prepopulateState(), GrainTracker::remapGrains(), FeatureFloodCount::scatterAndUpdateRanks(), FeatureFloodCount::sortAndLabel(), and GrainTracker::trackGrains().

_local_to_global_feature_map

std::vector<std::size_t> FeatureFloodCount::_local_to_global_feature_map

protectedinherited

The vector recording the local to global feature indices.

Definition at line 681 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::scatterAndUpdateRanks().

_maps_size

const std::size_t FeatureFloodCount::_maps_size

protectedinherited

Convenience variable holding the size of all the datastructures size by the number of maps.

Definition at line 620 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::consolidateMergedFeatures(), FeatureFloodCount::FeatureFloodCount(), FeatureFloodCount::getEntityValue(), FeatureFloodCount::initialize(), FeatureFloodCount::mergeSets(), FeatureFloodCount::sortAndLabel(), GrainTracker::trackGrains(), and GrainTracker::updateFieldInfo().

_merge_timer

const PerfID FeatureFloodCount::_merge_timer

privateinherited

Definition at line 773 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::mergeSets().

_mesh

MooseMesh& FeatureFloodCount::_mesh

protectedinherited

A reference to the mesh.

Definition at line 581 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::appendPeriodicNeighborNodes(), GrainTracker::centroidRegionDistance(), GrainTracker::communicateHaloMap(), PolycrystalCircles::computeDiffuseInterface(), FauxGrainTracker::execute(), FeatureFloodCount::execute(), FeatureFloodCount::expandEdgeHalos(), FeatureFloodCount::expandPointHalos(), FeatureFloodCount::FeatureFloodCount(), PolycrystalVoronoi::findCenterPoint(), PolycrystalVoronoi::findNormalVector(), FauxGrainTracker::getEntityValue(), FeatureFloodCount::getEntityValue(), PolycrystalVoronoi::getGrainsBasedOnPoint(), PolycrystalCircles::getGrainsBasedOnPoint(), PolycrystalUserObjectBase::initialSetup(), PolycrystalUserObjectBase::isNewFeatureOrConnectedRegion(), GrainTracker::meshChanged(), FeatureFloodCount::meshChanged(), PolycrystalVoronoi::precomputeGrainStructure(), PolycrystalHex::precomputeGrainStructure(), FeatureFloodCount::prepareDataForTransfer(), GrainTracker::swapSolutionValues(), FeatureFloodCount::updateBoundaryIntersections(), GrainTracker::updateFieldInfo(), FeatureFloodCount::visitElementalNeighbors(), and FeatureFloodCount::visitNodalNeighbors().

_n_procs

const processor_id_type FeatureFloodCount::_n_procs

protectedinherited

Convenience variable holding the number of processors in this simulation.

Definition at line 623 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::buildLocalToGlobalIndices(), and GrainTracker::communicateHaloMap().

_n_vars

const std::size_t FeatureFloodCount::_n_vars

protectedinherited

Definition at line 617 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::communicateAndMerge(), FeatureFloodCount::getVarToFeatureVector(), FeatureFloodCount::initialSetup(), FeatureFloodCount::numCoupledVars(), GrainTracker::remapGrains(), GrainTracker::updateFieldInfo(), and FeatureFloodCount::updateFieldInfo().

_node_to_grain_weight_map

const std::map<dof_id_type, std::vector<Real> >& PolycrystalEBSD::_node_to_grain_weight_map

protected

Definition at line 35 of file PolycrystalEBSD.h.

Referenced by getNodalVariableValue().

_nodes_to_elem_map

std::vector<std::vector<const Elem *> > FeatureFloodCount::_nodes_to_elem_map

protectedinherited

The data structure used to find neighboring elements give a node ID.

Definition at line 642 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::meshChanged(), and FeatureFloodCount::visitNodalNeighbors().

_op_num

const unsigned int PolycrystalUserObjectBase::_op_num

protectedinherited

The maximum number of order parameters (colors) available to assign to the grain structure.

Definition at line 147 of file PolycrystalUserObjectBase.h.

Referenced by PolycrystalUserObjectBase::colorGraph(), and PolycrystalUserObjectBase::initialSetup().

_output_adjacency_matrix

const bool PolycrystalUserObjectBase::_output_adjacency_matrix

protectedinherited

A user controllable Boolean which can be used to print the adjacency matrix to the console.

Definition at line 159 of file PolycrystalUserObjectBase.h.

Referenced by PolycrystalUserObjectBase::finalize().

_partial_feature_sets

std::vector<std::list<FeatureData> > FeatureFloodCount::_partial_feature_sets

protectedinherited

The data structure used to hold partial and communicated feature data, during the discovery and merging phases.

The outer vector is indexed by map number (often variable number). The inner list is an unordered list of partially discovered features.

Definition at line 655 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::communicateAndMerge(), FeatureFloodCount::consolidateMergedFeatures(), FeatureFloodCount::deserialize(), FeatureFloodCount::expandEdgeHalos(), FeatureFloodCount::expandPointHalos(), FeatureFloodCount::flood(), FeatureFloodCount::initialize(), PolycrystalUserObjectBase::mergeSets(), FeatureFloodCount::mergeSets(), FeatureFloodCount::prepareDataForTransfer(), GrainTracker::prepopulateState(), FeatureFloodCount::scatterAndUpdateRanks(), and FeatureFloodCount::serialize().

_pbs

PeriodicBoundaries* FeatureFloodCount::_pbs

protectedinherited

A pointer to the periodic boundary constraints object.

Definition at line 687 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::initialSetup(), PolycrystalUserObjectBase::isNewFeatureOrConnectedRegion(), FeatureFloodCount::meshChanged(), and FeatureFloodCount::visitElementalNeighbors().

_periodic_node_map

std::multimap<dof_id_type, dof_id_type> FeatureFloodCount::_periodic_node_map

protectedinherited

The data structure which is a list of nodes that are constrained to other nodes based on the imposed periodic boundary conditions.

Definition at line 707 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::appendPeriodicNeighborNodes(), FauxGrainTracker::getEntityValue(), FeatureFloodCount::getEntityValue(), and FeatureFloodCount::meshChanged().

_phase

const unsigned int PolycrystalEBSD::_phase

protected

Definition at line 33 of file PolycrystalEBSD.h.

Referenced by getGrainsBasedOnPoint(), getNodalVariableValue(), and getNumGrains().

_point_locator

std::unique_ptr<PointLocatorBase> FeatureFloodCount::_point_locator

protectedinherited

Definition at line 689 of file FeatureFloodCount.h.

Referenced by PolycrystalUserObjectBase::isNewFeatureOrConnectedRegion(), FeatureFloodCount::meshChanged(), and FeatureFloodCount::visitElementalNeighbors().

_prealloc_tmp_grains

std::vector<unsigned int> PolycrystalUserObjectBase::_prealloc_tmp_grains

privateinherited

Temporary storage area for current grains at a point to avoid memory churn.

Definition at line 169 of file PolycrystalUserObjectBase.h.

_prepare_for_transfer

const PerfID FeatureFloodCount::_prepare_for_transfer

privateinherited

Definition at line 778 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::prepareDataForTransfer().

_primary_perc_bnds

std::vector<BoundaryID> FeatureFloodCount::_primary_perc_bnds

protectedinherited

Definition at line 717 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::FeatureFloodCount(), and FeatureFloodCount::updateBoundaryIntersections().

_secondary_perc_bnds

std::vector<BoundaryID> FeatureFloodCount::_secondary_perc_bnds

protectedinherited

Definition at line 718 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::FeatureFloodCount(), and FeatureFloodCount::updateBoundaryIntersections().

_single_map_mode

const bool FeatureFloodCount::_single_map_mode

protectedinherited

This variable is used to indicate whether or not multiple maps are used during flooding.

Definition at line 591 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::flood(), PolycrystalUserObjectBase::PolycrystalUserObjectBase(), FeatureFloodCount::sortAndLabel(), GrainTracker::updateFieldInfo(), and FeatureFloodCount::updateFieldInfo().

_specified_bnds

std::vector<BoundaryID> FeatureFloodCount::_specified_bnds

protectedinherited

Definition at line 720 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::FeatureFloodCount(), and FeatureFloodCount::updateBoundaryIntersections().

_step_connecting_threshold

Real FeatureFloodCount::_step_connecting_threshold

protectedinherited

Definition at line 578 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::getConnectingThreshold(), and FeatureFloodCount::initialize().

_step_threshold

Real FeatureFloodCount::_step_threshold

protectedinherited

Definition at line 573 of file FeatureFloodCount.h.

Referenced by GrainTracker::getThreshold(), FeatureFloodCount::getThreshold(), and FeatureFloodCount::initialize().

_threshold

const Real FeatureFloodCount::_threshold

protectedinherited

The threshold above (or below) where an entity may begin a new region (feature)

Definition at line 572 of file FeatureFloodCount.h.

Referenced by FauxGrainTracker::execute(), and FeatureFloodCount::initialize().

_update_field_info

const PerfID FeatureFloodCount::_update_field_info

privateinherited

Definition at line 777 of file FeatureFloodCount.h.

_use_less_than_threshold_comparison

const bool FeatureFloodCount::_use_less_than_threshold_comparison

protectedinherited

Use less-than when comparing values against the threshold value.

True by default. If false, then greater-than comparison is used instead.

Definition at line 614 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::compareValueWithThreshold(), and FauxGrainTracker::execute().

_var_index_maps

std::vector<std::map<dof_id_type, int> > FeatureFloodCount::_var_index_maps

protectedinherited

This map keeps track of which variables own which nodes.

We need a vector of them for multimap mode where multiple variables can own a single mode.

Note: This map is only populated when "show_var_coloring" is set to true.

Definition at line 639 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::FeatureFloodCount(), FeatureFloodCount::getEntityValue(), FeatureFloodCount::initialize(), GrainTracker::updateFieldInfo(), and FeatureFloodCount::updateFieldInfo().

_var_index_mode

const bool FeatureFloodCount::_var_index_mode

protectedinherited

This variable is used to indicate whether the maps will contain unique region information or just the variable numbers owning those regions.

Definition at line 601 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::FeatureFloodCount(), FeatureFloodCount::getEntityValue(), FeatureFloodCount::initialize(), GrainTracker::updateFieldInfo(), and FeatureFloodCount::updateFieldInfo().

_var_number

unsigned long FeatureFloodCount::_var_number

protectedinherited

This variable is used to build the periodic node map.

Assumption: We are going to assume that either all variables are periodic or none are. This assumption can be relaxed at a later time if necessary.

Definition at line 588 of file FeatureFloodCount.h.

Referenced by GrainTracker::centroidRegionDistance(), and FeatureFloodCount::meshChanged().

_vars

std::vector<MooseVariable *> FeatureFloodCount::_vars

protectedinherited

The vector of coupled in variables cast to MooseVariable.

Definition at line 566 of file FeatureFloodCount.h.

Referenced by PolycrystalUserObjectBase::assignOpsToGrains(), GrainTracker::attemptGrainRenumber(), PolycrystalCircles::computeDiffuseInterface(), GrainTracker::computeMinDistancesFromGrain(), FauxGrainTracker::execute(), FeatureFloodCount::execute(), FeatureFloodCount::FeatureFloodCount(), FauxGrainTracker::finalize(), PolycrystalVoronoi::findCenterPoint(), PolycrystalVoronoi::findNormalVector(), FeatureFloodCount::getCoupledVars(), FauxGrainTracker::getEntityValue(), PolycrystalVoronoi::getGrainsBasedOnPoint(), PolycrystalCircles::getGrainsBasedOnPoint(), FeatureFloodCount::initialSetup(), PolycrystalUserObjectBase::initialSetup(), FeatureFloodCount::isNewFeatureOrConnectedRegion(), GrainTracker::swapSolutionValuesHelper(), and GrainTracker::updateFieldInfo().

_volatile_feature_sets

std::vector<FeatureData> FeatureFloodCount::_volatile_feature_sets

protectedinherited

Derived objects (e.g.

the GrainTracker) may require restartable data to track information across time steps. The FeatureFloodCounter however does not. This container is here so that we have the flexabilty to switch between volatile and non-volatile storage. The _feature_sets data structure can conditionally refer to this structure or a MOOSE-provided structure, which is backed up.

Definition at line 671 of file FeatureFloodCount.h.

HALO_THICKNESS

const unsigned int PolycrystalUserObjectBase::HALO_THICKNESS = 4

staticprotectedinherited

Used to hold the thickness of the halo that should be constructed for detecting adjacency.

Definition at line 165 of file PolycrystalUserObjectBase.h.

INVALID_COLOR

const unsigned int PolycrystalUserObjectBase::INVALID_COLOR

staticprotectedinherited

Initial value:

=
    std::numeric_limits<unsigned int>::max()

Used to indicate an invalid coloring for the built-in back-tracking algorithm.

Definition at line 162 of file PolycrystalUserObjectBase.h.

Referenced by PolycrystalUserObjectBase::colorGraph(), and PolycrystalUserObjectBase::finalize().

invalid_id

const unsigned int FeatureFloodCount::invalid_id = std::numeric_limits<unsigned int>::max()

staticinherited

Definition at line 94 of file FeatureFloodCount.h.

Referenced by FeatureVolumeVectorPostprocessor::accumulateBoundaryFaces(), AverageGrainVolume::accumulateVolumes(), FeatureVolumeVectorPostprocessor::accumulateVolumes(), GrainTracker::assignGrains(), MultiGrainRigidBodyMotion::calculateAdvectionVelocity(), SingleGrainRigidBodyMotion::calculateAdvectionVelocity(), ComputePolycrystalElasticityTensor::computeQpElasticityTensor(), DeformedGrainMaterial::computeQpProperties(), FeatureFloodCount::deserialize(), FauxGrainTracker::execute(), FeatureVolumeVectorPostprocessor::execute(), FauxGrainTracker::FauxGrainTracker(), FeatureFloodCount::featureCentroid(), FeatureFloodCount::flood(), FeatureFloodCount::getFeatureVar(), GrainTracker::getNextUniqueID(), GrainTracker::getTotalFeatureCount(), SingleGrainRigidBodyMotion::getUserObjectJacobian(), MultiGrainRigidBodyMotion::getUserObjectJacobian(), PolycrystalVoronoi::getVariableValue(), PolycrystalCircles::getVariableValue(), FeatureFloodCount::initialSetup(), PolycrystalUserObjectBase::isNewFeatureOrConnectedRegion(), FeatureFloodCount::FeatureData::operator<(), operator<<(), FeatureFloodCountAux::precalculateValue(), FeatureFloodCount::serialize(), FeatureFloodCount::sortAndLabel(), GrainTracker::trackGrains(), GrainTracker::updateFieldInfo(), and FeatureFloodCount::updateFieldInfo().

invalid_size_t

const std::size_t FeatureFloodCount::invalid_size_t = std::numeric_limits<std::size_t>::max()

staticinherited

Constants used for invalid indices set to the max value of std::size_t type

Definition at line 93 of file FeatureFloodCount.h.

Referenced by GrainTracker::broadcastAndUpdateGrainData(), FeatureFloodCount::buildFeatureIdToLocalIndices(), FeatureFloodCount::buildLocalToGlobalIndices(), FeatureFloodCount::doesFeatureIntersectBoundary(), GrainTracker::doesFeatureIntersectBoundary(), FeatureFloodCount::doesFeatureIntersectSpecifiedBoundary(), GrainTracker::doesFeatureIntersectSpecifiedBoundary(), PolycrystalUserObjectBase::execute(), FeatureFloodCount::featureCentroid(), FeatureFloodCount::flood(), FauxGrainTracker::getEntityValue(), FeatureFloodCount::getEntityValue(), FeatureFloodCount::getFeatureVar(), GrainTracker::getGrainCentroid(), GrainTracker::isFeaturePercolated(), FeatureFloodCount::isFeaturePercolated(), PolycrystalUserObjectBase::isNewFeatureOrConnectedRegion(), GrainTracker::newGrainCreated(), FeatureFloodCount::scatterAndUpdateRanks(), and GrainTracker::trackGrains().

---

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

• phase_field/include/userobjects/PolycrystalEBSD.h
• phase_field/src/userobjects/PolycrystalEBSD.C