FeatureFloodCount::FeatureData Class Reference

#include <FeatureFloodCount.h>

Public Types
using	container_type = std::set< dof_id_type >
	The primary underlying container type used to hold the data in each FeatureData. More...

Public Member Functions
	FeatureData ()
	FeatureData (std::size_t var_index, unsigned int local_index, processor_id_type rank, Status status)
	FeatureData (std::size_t var_index, Status status, unsigned int id=invalid_id, std::vector< BoundingBox > bboxes={BoundingBox()})
bool	boundingBoxesIntersect (const FeatureData &rhs) const
	Determines if any of this FeatureData's bounding boxes overlap with the other FeatureData's bounding boxes. More...
bool	mergeable (const FeatureData &rhs) const
	The routine called to see if two features are mergeable: More...
bool	canConsolidate (const FeatureData &rhs) const
	This routine indicates whether two features can be consolidated, that is, one feature is reasonably expected to be part of another. More...
void	expandBBox (const FeatureData &rhs)
	Located the overlapping bounding box between this Feature and the other Feature and expands that overlapping box accordingly. More...
void	merge (FeatureData &&rhs)
	Merges another Feature Data into this one. More...
void	consolidate (FeatureData &&rhs)
	Consolidates features, i.e. More...
void	clear ()
bool	operator< (const FeatureData &rhs) const
	Comparison operator for sorting individual FeatureDatas. More...
FeatureData	duplicate () const
	FeatureData (FeatureData &&)=default
FeatureData &	operator= (FeatureData &&)=default
void	updateBBoxExtremes (MeshBase &mesh)
	Update the minimum and maximum coordinates of a bounding box given a Point, Elem or BBox parameter. More...
void	updateBBoxExtremes (BoundingBox &bbox, const BoundingBox &rhs_bbox)
bool	halosIntersect (const FeatureData &rhs) const
	Determine if one of this FeaturesData's member sets intersects the other FeatureData's corresponding set. More...
bool	periodicBoundariesIntersect (const FeatureData &rhs) const
bool	ghostedIntersect (const FeatureData &rhs) const

Public Attributes
container_type	_ghosted_ids
	Holds the ghosted ids for a feature (the ids which will be used for stitching. More...
container_type	_local_ids
	Holds the local ids in the interior of a feature. More...
container_type	_halo_ids
	Holds the ids surrounding the feature. More...
container_type	_disjoint_halo_ids
	Holds halo ids that extend onto a non-topologically connected surface. More...
container_type	_periodic_nodes
	Holds the nodes that belong to the feature on a periodic boundary. More...
std::size_t	_var_index
	The Moose variable where this feature was found (often the "order parameter") More...
unsigned int	_id
	An ID for this feature. More...
std::vector< BoundingBox >	_bboxes
	The vector of bounding boxes completely enclosing this feature (multiple used with periodic constraints) More...
std::list< std::pair< processor_id_type, unsigned int > >	_orig_ids
	Original processor/local ids. More...
dof_id_type	_min_entity_id
	The minimum entity seen in the _local_ids, used for sorting features. More...
std::size_t	_vol_count
	The count of entities contributing to the volume calculation. More...
Point	_centroid
	The centroid of the feature (average of coordinates from entities participating in the volume calculation) More...
Status	_status
	The status of a feature (used mostly in derived classes like the GrainTracker) More...
BoundaryIntersection	_boundary_intersection
	Enumaration indicating boundary intersection status. More...

Private Member Functions
	FeatureData (const FeatureData &)=default
	2016-07-14 The INTEL compiler we are currently using (2013 with GCC 4.8) appears to have a bug introduced by the addition of the Point member in this structure. More...
FeatureData &	operator= (const FeatureData &)=default

Friends
std::ostream &	operator<< (std::ostream &out, const FeatureData &feature)
	stream output operator More...

Detailed Description

Definition at line 138 of file FeatureFloodCount.h.

Member Typedef Documentation

container_type

using FeatureFloodCount::FeatureData::container_type = std::set<dof_id_type>

The primary underlying container type used to hold the data in each FeatureData.

Supported types are std::set<dof_id_type> (with minor adjustmnets) or std::vector<dof_id_type>.

Note: Testing has shown that the vector container is nearly 10x faster. There's really no reason to use sets.

Definition at line 149 of file FeatureFloodCount.h.

Constructor & Destructor Documentation

FeatureData() [1/5]

FeatureFloodCount::FeatureData::FeatureData ( )

inline

Definition at line 151 of file FeatureFloodCount.h.

: FeatureData(std::numeric_limits<std::size_t>::max(), Status::INACTIVE) {}

Referenced by duplicate().

FeatureData() [2/5]

FeatureFloodCount::FeatureData::FeatureData ( std::size_t  var_index, unsigned int  local_index, processor_id_type  rank, Status  status  )

inline

Definition at line 153 of file FeatureFloodCount.h.

      : FeatureData(var_index, status)
    {
      _orig_ids = {std::make_pair(rank, local_index)};
    }

FeatureData() [3/5]

FeatureFloodCount::FeatureData::FeatureData ( std::size_t  var_index, Status  status, unsigned int  id = invalid_id, std::vector< BoundingBox >  bboxes = {BoundingBox()}  )

inline

Definition at line 162 of file FeatureFloodCount.h.

                                                {BoundingBox()})
      : _var_index(var_index),
        _id(id),
        _bboxes(bboxes), // Assume at least one bounding box
        _min_entity_id(DofObject::invalid_id),
        _vol_count(0),
        _status(status),
        _boundary_intersection(BoundaryIntersection::NONE)
    {
    }

FeatureData() [4/5]

FeatureFloodCount::FeatureData::FeatureData ( FeatureData &&  )

default

FeatureData() [5/5]

FeatureFloodCount::FeatureData::FeatureData ( const FeatureData &  )

privatedefault

2016-07-14 The INTEL compiler we are currently using (2013 with GCC 4.8) appears to have a bug introduced by the addition of the Point member in this structure.

Even though it supports move semantics on other non-POD types like libMesh::BoundingBox, it fails to compile this class with the "centroid" member. Specifically, it supports the move operation into the vector type but fails to work with the bracket operator on std::map and the std::sort algorithm used in this class. It does work with std::map::emplace() but that syntax is much less appealing and still doesn't work around the issue. For now, I'm allowing the copy constructor to be called where it shouldn't so that this class works under the Intel compiler but there may be a degradation in performance in that case. We do not expect these objects to ever be copied. This is important since they are stored in standard containers directly. To enforce this, we are explicitly marking these methods private. They can be triggered through an explicit call to "duplicate".

Member Function Documentation

boundingBoxesIntersect()

bool FeatureFloodCount::FeatureData::boundingBoxesIntersect

(

const FeatureData &

rhs

)

const

Determines if any of this FeatureData's bounding boxes overlap with the other FeatureData's bounding boxes.

Definition at line 1918 of file FeatureFloodCount.C.

{
  // See if any of the bounding boxes in either FeatureData object intersect
  for (const auto & bbox_lhs : _bboxes)
    for (const auto & bbox_rhs : rhs._bboxes)
      if (bbox_lhs.intersects(bbox_rhs, libMesh::TOLERANCE * libMesh::TOLERANCE))
        return true;
 
  return false;
}

canConsolidate()

bool FeatureFloodCount::FeatureData::canConsolidate

(

const FeatureData &

rhs

)

const

This routine indicates whether two features can be consolidated, that is, one feature is reasonably expected to be part of another.

This is different than mergable in that a portion of the feature is expected to be completely identical. This happens in the distributed work scenario when a feature that is partially owned by a processor is merged on a different processor (where local entities are not sent or available). However, later that feature ends back up on the original processor and just needs to be consolidated.

Definition at line 1963 of file FeatureFloodCount.C.

{
  for (const auto & orig_id_pair1 : _orig_ids)
    for (const auto & orig_id_pair2 : rhs._orig_ids)
      if (orig_id_pair1 == orig_id_pair2)
        return true;
 
  return false;
}

clear()

void FeatureFloodCount::FeatureData::clear

(

)

Definition at line 2087 of file FeatureFloodCount.C.

{
  _local_ids.clear();
  _periodic_nodes.clear();
  _halo_ids.clear();
  _disjoint_halo_ids.clear();
  _ghosted_ids.clear();
  _bboxes.clear();
  _orig_ids.clear();
}

consolidate()

void FeatureFloodCount::FeatureData::consolidate

(

FeatureData &&

rhs

)

Consolidates features, i.e.

merges local entities but leaves everything else untouched.

Definition at line 2068 of file FeatureFloodCount.C.

{
  mooseAssert(_var_index == rhs._var_index, "Mismatched variable index in merge");
  mooseAssert(_id == rhs._id, "Mismatched auxiliary id in merge");
 
  FeatureData::container_type set_union;
  FeatureFloodCount::reserve(_local_ids, _local_ids.size() + rhs._local_ids.size());
  std::set_union(_local_ids.begin(),
                 _local_ids.end(),
                 rhs._local_ids.begin(),
                 rhs._local_ids.end(),
                 std::insert_iterator<FeatureData::container_type>(set_union, set_union.begin()));
  _local_ids.swap(set_union);
 
  mooseAssert((_status & Status::MARKED & Status::DIRTY) == Status::CLEAR,
              "Flags in invalid state");
}

duplicate()

FeatureData FeatureFloodCount::FeatureData::duplicate ( ) const

inline

Definition at line 312 of file FeatureFloodCount.h.

{ return FeatureData(*this); }

expandBBox()

void FeatureFloodCount::FeatureData::expandBBox

(

const FeatureData &

rhs

)

Located the overlapping bounding box between this Feature and the other Feature and expands that overlapping box accordingly.

Definition at line 2099 of file FeatureFloodCount.C.

{
  std::vector<bool> intersected_boxes(rhs._bboxes.size(), false);
 
  auto box_expanded = false;
  for (auto & bbox : _bboxes)
    for (MooseIndex(rhs._bboxes) j = 0; j < rhs._bboxes.size(); ++j)
    {
      if (bbox.intersects(rhs._bboxes[j], libMesh::TOLERANCE * libMesh::TOLERANCE))
      {
        updateBBoxExtremes(bbox, rhs._bboxes[j]);
        intersected_boxes[j] = true;
        box_expanded = true;
      }
    }
 
  // Error check
  if (!box_expanded)
  {
    std::ostringstream oss;
    oss << "LHS BBoxes:\n";
    for (MooseIndex(_bboxes) i = 0; i < _bboxes.size(); ++i)
      oss << "Max: " << _bboxes[i].max() << " Min: " << _bboxes[i].min() << '\n';
 
    oss << "RHS BBoxes:\n";
    for (MooseIndex(rhs._bboxes) i = 0; i < rhs._bboxes.size(); ++i)
      oss << "Max: " << rhs._bboxes[i].max() << " Min: " << rhs._bboxes[i].min() << '\n';
 
    ::mooseError("No Bounding Boxes Expanded - This is a catastrophic error!\n", oss.str());
  }
 
  // Any bounding box in the rhs vector that doesn't intersect
  // needs to be appended to the lhs vector
  for (MooseIndex(intersected_boxes) j = 0; j < intersected_boxes.size(); ++j)
    if (!intersected_boxes[j])
      _bboxes.push_back(rhs._bboxes[j]);
}

ghostedIntersect()

bool FeatureFloodCount::FeatureData::ghostedIntersect

(

const FeatureData &

rhs

)

const

Definition at line 1946 of file FeatureFloodCount.C.

{
  return setsIntersect(
      _ghosted_ids.begin(), _ghosted_ids.end(), rhs._ghosted_ids.begin(), rhs._ghosted_ids.end());
}

halosIntersect()

bool FeatureFloodCount::FeatureData::halosIntersect

(

const FeatureData &

rhs

)

const

Determine if one of this FeaturesData's member sets intersects the other FeatureData's corresponding set.

Definition at line 1930 of file FeatureFloodCount.C.

{
  return setsIntersect(
      _halo_ids.begin(), _halo_ids.end(), rhs._halo_ids.begin(), rhs._halo_ids.end());
}

Referenced by GrainTracker::attemptGrainRenumber().

merge()

void FeatureFloodCount::FeatureData::merge

(

FeatureData &&

rhs

)

Merges another Feature Data into this one.

This method leaves rhs in an inconsistent state.

Even though we've determined that these two partial regions need to be merged, we don't necessarily know if the _ghost_ids intersect. We could be in this branch because the periodic boundaries intersect but that doesn't tell us anything about whether or not the ghost_region also intersects. If the _ghost_ids intersect, that means that we are merging along a periodic boundary, not across one. In this case the bounding box(s) need to be expanded.

If we had a physical intersection, we need to expand boxes. If we had a virtual (periodic) intersection we need to preserve all of the boxes from each of the regions' sets.

Combine the status flags: Currently we only expect to combine CLEAR and INACTIVE. Any other combination is currently a logic error. In this case of CLEAR and INACTIVE though, we want to make sure that CLEAR wins.

Definition at line 1974 of file FeatureFloodCount.C.

{
  mooseAssert(_var_index == rhs._var_index, "Mismatched variable index in merge");
  mooseAssert(_id == rhs._id, "Mismatched auxiliary id in merge");
 
  FeatureData::container_type set_union;
 
  FeatureFloodCount::reserve(set_union, _local_ids.size() + rhs._local_ids.size());
  std::set_union(_local_ids.begin(),
                 _local_ids.end(),
                 rhs._local_ids.begin(),
                 rhs._local_ids.end(),
                 std::insert_iterator<FeatureData::container_type>(set_union, set_union.begin()));
  _local_ids.swap(set_union);
 
  set_union.clear();
  FeatureFloodCount::reserve(set_union, _periodic_nodes.size() + rhs._periodic_nodes.size());
  std::set_union(_periodic_nodes.begin(),
                 _periodic_nodes.end(),
                 rhs._periodic_nodes.begin(),
                 rhs._periodic_nodes.end(),
                 std::insert_iterator<FeatureData::container_type>(set_union, set_union.begin()));
  _periodic_nodes.swap(set_union);
 
  set_union.clear();
  FeatureFloodCount::reserve(set_union, _ghosted_ids.size() + rhs._ghosted_ids.size());
  std::set_union(_ghosted_ids.begin(),
                 _ghosted_ids.end(),
                 rhs._ghosted_ids.begin(),
                 rhs._ghosted_ids.end(),
                 std::insert_iterator<FeatureData::container_type>(set_union, set_union.begin()));
 
  bool physical_intersection = (_ghosted_ids.size() + rhs._ghosted_ids.size() > set_union.size());
  _ghosted_ids.swap(set_union);
 
  if (physical_intersection)
    expandBBox(rhs);
  else
    std::move(rhs._bboxes.begin(), rhs._bboxes.end(), std::back_inserter(_bboxes));
 
  set_union.clear();
  FeatureFloodCount::reserve(set_union, _disjoint_halo_ids.size() + rhs._disjoint_halo_ids.size());
  std::set_union(_disjoint_halo_ids.begin(),
                 _disjoint_halo_ids.end(),
                 rhs._disjoint_halo_ids.begin(),
                 rhs._disjoint_halo_ids.end(),
                 std::insert_iterator<FeatureData::container_type>(set_union, set_union.begin()));
  _disjoint_halo_ids.swap(set_union);
 
  set_union.clear();
  FeatureFloodCount::reserve(set_union, _halo_ids.size() + rhs._halo_ids.size());
  std::set_union(_halo_ids.begin(),
                 _halo_ids.end(),
                 rhs._halo_ids.begin(),
                 rhs._halo_ids.end(),
                 std::insert_iterator<FeatureData::container_type>(set_union, set_union.begin()));
  _halo_ids.swap(set_union);
 
  // Keep track of the original ids so we can notify other processors of the local to global mapping
  _orig_ids.splice(_orig_ids.end(), std::move(rhs._orig_ids));
 
  // Update the min feature id
  _min_entity_id = std::min(_min_entity_id, rhs._min_entity_id);
 
  mooseAssert((_status & Status::MARKED & Status::DIRTY) == Status::CLEAR,
              "Flags in invalid state");
 
  // Logical AND here to combine flags (INACTIVE & INACTIVE == INACTIVE, all other combos are CLEAR)
  _status &= rhs._status;
 
  // Logical OR here to make sure we maintain boundary intersection attribute when joining
  _boundary_intersection |= rhs._boundary_intersection;
 
  _vol_count += rhs._vol_count;
  _centroid += rhs._centroid;
}

mergeable()

bool FeatureFloodCount::FeatureData::mergeable

(

const FeatureData &

rhs

)

const

The routine called to see if two features are mergeable:

• Features must be represented by the same variable (_var_index)
• Features must either intersect on halos or
• Features must intersect on a periodic BC

Optimization: We may use the bounding boxes as a coarse-level check before checking halo intersection.

Definition at line 1953 of file FeatureFloodCount.C.

{
  return (_var_index == rhs._var_index &&      // the sets have matching variable indices and
          ((boundingBoxesIntersect(rhs) &&     //  (if the feature's bboxes intersect and
            ghostedIntersect(rhs))             //   the ghosted entities also intersect)
           ||                                  //   or
           periodicBoundariesIntersect(rhs))); //   periodic node sets intersect)
}

Referenced by FeatureFloodCount::areFeaturesMergeable().

operator<()

bool FeatureFloodCount::FeatureData::operator< ( const FeatureData &  rhs ) const

inline

Comparison operator for sorting individual FeatureDatas.

Definition at line 249 of file FeatureFloodCount.h.

    {
      if (_id != invalid_id)
      {
        mooseAssert(rhs._id != invalid_id, "Asymmetric setting of ids detected during sort");
 
        // Sort based on ids
        return _id < rhs._id;
      }
      else
        // Sort based on processor independent information (mesh and variable info)
        return _var_index < rhs._var_index ||
               (_var_index == rhs._var_index && _min_entity_id < rhs._min_entity_id);
    }

operator=() [1/2]

FeatureData& FeatureFloodCount::FeatureData::operator= ( const FeatureData &  )

privatedefault

operator=() [2/2]

FeatureData& FeatureFloodCount::FeatureData::operator= ( FeatureData &&  )

default

periodicBoundariesIntersect()

bool FeatureFloodCount::FeatureData::periodicBoundariesIntersect

(

const FeatureData &

rhs

)

const

Definition at line 1937 of file FeatureFloodCount.C.

{
  return setsIntersect(_periodic_nodes.begin(),
                       _periodic_nodes.end(),
                       rhs._periodic_nodes.begin(),
                       rhs._periodic_nodes.end());
}

updateBBoxExtremes() [1/2]

void FeatureFloodCount::FeatureData::updateBBoxExtremes	(	BoundingBox &	bbox,
		const BoundingBox &	rhs_bbox
	)

Definition at line 1908 of file FeatureFloodCount.C.

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

updateBBoxExtremes() [2/2]

void FeatureFloodCount::FeatureData::updateBBoxExtremes

(

MeshBase &

mesh

)

Update the minimum and maximum coordinates of a bounding box given a Point, Elem or BBox parameter.

Now we need to find how many distinct topologically disconnected sets of elements we have. We've already removed elements that are part of the primary halo, we'll start by assuming that element left is part of the same disjoint set. For each element, we'll see if it is a neighbor of any other element in the current set. If it's not, then it must be part of yet another set. The process repeats until every element is processed and put in the right bucket.

Definition at line 1824 of file FeatureFloodCount.C.

{
  // First update the primary bounding box (all topologically connected)
  for (auto & halo_id : _halo_ids)
    updateBBoxExtremesHelper(_bboxes[0], mesh.elem_ref(halo_id));
  for (auto & ghost_id : _ghosted_ids)
    updateBBoxExtremesHelper(_bboxes[0], mesh.elem_ref(ghost_id));
 
  // Remove all of the IDs that are in the primary region
  std::list<dof_id_type> disjoint_elem_id_list;
  std::set_difference(_disjoint_halo_ids.begin(),
                      _disjoint_halo_ids.end(),
                      _halo_ids.begin(),
                      _halo_ids.end(),
                      std::insert_iterator<std::list<dof_id_type>>(disjoint_elem_id_list,
                                                                   disjoint_elem_id_list.begin()));
 
  if (!disjoint_elem_id_list.empty())
  {
    std::list<std::list<dof_id_type>> disjoint_regions;
    for (auto elem_id : _disjoint_halo_ids)
    {
      disjoint_regions.emplace_back(std::list<dof_id_type>({elem_id}));
    }
 
    for (auto it1 = disjoint_regions.begin(); it1 != disjoint_regions.end(); /* No increment */)
    {
      bool merge_occured = false;
      for (auto it2 = disjoint_regions.begin(); it2 != disjoint_regions.end(); ++it2)
      {
        if (it1 != it2 && areElemListsMergeable(*it1, *it2, mesh))
        {
          it2->splice(it2->begin(), *it1);
 
          disjoint_regions.emplace_back(std::move(*it2));
          disjoint_regions.erase(it2);
          it1 = disjoint_regions.erase(it1);
 
          merge_occured = true;
 
          break;
        }
      }
 
      if (!merge_occured)
        ++it1;
    }
 
    // Finally create new bounding boxes for each disjoint region
    auto num_regions = disjoint_regions.size();
    // We have num_regions *new* bounding boxes plus the existing bounding box
    _bboxes.resize(num_regions + 1);
 
    decltype(num_regions) region = 1;
    for (const auto list_ref : disjoint_regions)
    {
      for (const auto elem_id : list_ref)
        updateBBoxExtremesHelper(_bboxes[region], *mesh.elem_ptr(elem_id));
 
      FeatureData::container_type set_union;
      FeatureFloodCount::reserve(set_union, _halo_ids.size() + _disjoint_halo_ids.size());
      std::set_union(
          _halo_ids.begin(),
          _halo_ids.end(),
          _disjoint_halo_ids.begin(),
          _disjoint_halo_ids.end(),
          std::insert_iterator<FeatureData::container_type>(set_union, set_union.begin()));
      _halo_ids.swap(set_union);
 
      _disjoint_halo_ids.clear();
      ++region;
    }
  }
}

Friends And Related Function Documentation

operator<<

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

friend

stream output operator

Definition at line 2138 of file FeatureFloodCount.C.

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

Member Data Documentation

_bboxes

std::vector<BoundingBox> FeatureFloodCount::FeatureData::_bboxes

The vector of bounding boxes completely enclosing this feature (multiple used with periodic constraints)

Definition at line 291 of file FeatureFloodCount.h.

Referenced by boundingBoxesIntersect(), GrainTracker::computeMinDistancesFromGrain(), dataLoad(), dataStore(), expandBBox(), operator<<(), updateBBoxExtremes(), and FeatureFloodCount::visitElementalNeighbors().

_boundary_intersection

BoundaryIntersection FeatureFloodCount::FeatureData::_boundary_intersection

Enumaration indicating boundary intersection status.

Definition at line 310 of file FeatureFloodCount.h.

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

_centroid

Point FeatureFloodCount::FeatureData::_centroid

The centroid of the feature (average of coordinates from entities participating in the volume calculation)

Definition at line 304 of file FeatureFloodCount.h.

Referenced by dataLoad(), dataStore(), and FeatureFloodCount::flood().

_disjoint_halo_ids

container_type FeatureFloodCount::FeatureData::_disjoint_halo_ids

Holds halo ids that extend onto a non-topologically connected surface.

Definition at line 278 of file FeatureFloodCount.h.

Referenced by dataLoad(), dataStore(), updateBBoxExtremes(), and FeatureFloodCount::visitNeighborsHelper().

_ghosted_ids

container_type FeatureFloodCount::FeatureData::_ghosted_ids

Holds the ghosted ids for a feature (the ids which will be used for stitching.

Definition at line 268 of file FeatureFloodCount.h.

Referenced by dataLoad(), dataStore(), ghostedIntersect(), operator<<(), updateBBoxExtremes(), and FeatureFloodCount::visitNeighborsHelper().

_halo_ids

container_type FeatureFloodCount::FeatureData::_halo_ids

Holds the ids surrounding the feature.

Definition at line 275 of file FeatureFloodCount.h.

Referenced by dataLoad(), dataStore(), FeatureFloodCount::flood(), halosIntersect(), operator<<(), updateBBoxExtremes(), and FeatureFloodCount::visitNeighborsHelper().

_id

unsigned int FeatureFloodCount::FeatureData::_id

An ID for this feature.

Definition at line 287 of file FeatureFloodCount.h.

Referenced by PolycrystalUserObjectBase::areFeaturesMergeable(), GrainTracker::attemptGrainRenumber(), dataLoad(), dataStore(), FeatureFloodCount::flood(), PolycrystalUserObjectBase::isNewFeatureOrConnectedRegion(), operator<(), and operator<<().

_local_ids

container_type FeatureFloodCount::FeatureData::_local_ids

Holds the local ids in the interior of a feature.

This data structure is only maintained on the local processor

Definition at line 272 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::appendPeriodicNeighborNodes(), FeatureFloodCount::flood(), operator<<(), GrainTracker::swapSolutionValues(), FeatureFloodCount::updateBoundaryIntersections(), and FeatureFloodCount::visitNeighborsHelper().

_min_entity_id

dof_id_type FeatureFloodCount::FeatureData::_min_entity_id

The minimum entity seen in the _local_ids, used for sorting features.

Definition at line 297 of file FeatureFloodCount.h.

Referenced by dataLoad(), dataStore(), operator<(), and operator<<().

_orig_ids

std::list<std::pair<processor_id_type, unsigned int> > FeatureFloodCount::FeatureData::_orig_ids

Original processor/local ids.

Definition at line 294 of file FeatureFloodCount.h.

Referenced by canConsolidate(), dataLoad(), dataStore(), FeatureData(), and operator<<().

_periodic_nodes

container_type FeatureFloodCount::FeatureData::_periodic_nodes

Holds the nodes that belong to the feature on a periodic boundary.

Definition at line 281 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::appendPeriodicNeighborNodes(), dataLoad(), dataStore(), operator<<(), and periodicBoundariesIntersect().

_status

Status FeatureFloodCount::FeatureData::_status

The status of a feature (used mostly in derived classes like the GrainTracker)

Definition at line 307 of file FeatureFloodCount.h.

Referenced by GrainTracker::attemptGrainRenumber(), dataLoad(), dataStore(), FeatureFloodCount::isNewFeatureOrConnectedRegion(), and operator<<().

_var_index

std::size_t FeatureFloodCount::FeatureData::_var_index

The Moose variable where this feature was found (often the "order parameter")

Definition at line 284 of file FeatureFloodCount.h.

Referenced by PolycrystalUserObjectBase::areFeaturesMergeable(), GrainTracker::attemptGrainRenumber(), GrainTracker::computeMinDistancesFromGrain(), dataLoad(), dataStore(), mergeable(), operator<(), operator<<(), GrainTracker::swapSolutionValues(), and GrainTracker::trackGrains().

_vol_count

std::size_t FeatureFloodCount::FeatureData::_vol_count

The count of entities contributing to the volume calculation.

Definition at line 300 of file FeatureFloodCount.h.

Referenced by dataLoad(), dataStore(), and FeatureFloodCount::flood().

---

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

• phase_field/include/postprocessors/FeatureFloodCount.h
• phase_field/src/postprocessors/FeatureFloodCount.C