www.mooseframework.org
Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | Protected Member Functions | Static Protected Member Functions | Protected Attributes | Static Protected Attributes | List of all members
GrainTrackerElasticity Class Referenceabstract

Manage a list of elasticity tensors for the grains. More...

#include <GrainTrackerElasticity.h>

Inheritance diagram for GrainTrackerElasticity:
[legend]

Public Types

enum  RemapCacheMode { RemapCacheMode::FILL, RemapCacheMode::USE, RemapCacheMode::BYPASS }
 
enum  FieldType {
  FieldType::UNIQUE_REGION, FieldType::VARIABLE_COLORING, FieldType::GHOSTED_ENTITIES, FieldType::HALOS,
  FieldType::CENTROID, FieldType::ACTIVE_BOUNDS, FieldType::INTERSECTS_SPECIFIED_BOUNDARY
}
 
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...
 
typedef DataFileName DataFileParameterType
 
typedef FunctorBase< RealFunctorType
 
typedef Real ValueType
 
typedef typename FunctorReturnType< Real, FunctorEvaluationKind::Gradient >::type GradientType
 
typedef ValueType DotType
 
enum  TEST_TYPE
 

Public Member Functions

 GrainTrackerElasticity (const InputParameters &parameters)
 
const RankFourTensorgetData (unsigned int grain_id) const
 return data for selected grain More...
 
virtual void meshChanged () override
 
virtual void initialize () override
 
virtual void execute () override
 
virtual void finalize () override
 
virtual std::size_t getTotalFeatureCount () const override
 Returns the total feature count (active and inactive ids, useful for sizing vectors) More...
 
virtual Real getEntityValue (dof_id_type node_id, FieldType field_type, std::size_t var_index=0) const override
 
virtual const std::vector< unsigned int > & getVarToFeatureVector (dof_id_type elem_id) const override
 Returns a list of active unique feature ids for a particular element. More...
 
virtual unsigned int getFeatureVar (unsigned int feature_id) const override
 Returns the variable representing the passed in feature. More...
 
virtual std::size_t getNumberActiveGrains () const override
 Returns the number of active grains current stored in the GrainTracker. More...
 
virtual Point getGrainCentroid (unsigned int grain_id) const override
 Returns the centroid for the given grain number. More...
 
virtual bool doesFeatureIntersectBoundary (unsigned int feature_id) const override
 Returns a Boolean indicating whether this feature intersects any boundary. More...
 
virtual bool doesFeatureIntersectSpecifiedBoundary (unsigned int feature_id) const override
 Returns a Boolean indicating whether this feature intersects boundaries in a user-supplied list. More...
 
virtual bool isFeaturePercolated (unsigned int feature_id) const override
 Returns a Boolean indicating whether this feature is percolated (e.g. More...
 
virtual std::vector< unsigned intgetNewGrainIDs () const override
 This method returns all of the new ids generated in an invocation of the GrainTracker. More...
 
virtual void initialSetup () override
 
virtual Real getValue () const override
 
std::size_t getNumberActiveFeatures () const
 Return the number of active features. More...
 
virtual Point featureCentroid (unsigned int feature_id) const
 Returns the centroid of the designated feature (only supported without periodic boundaries) 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...
 
bool isElemental () const
 
const std::vector< FeatureData > & getFeatures () const
 Return a constant reference to the vector of all discovered features. More...
 
SubProblemgetSubProblem () const
 
bool shouldDuplicateInitialExecution () const
 
virtual Real spatialValue (const Point &) const
 
virtual const std::vector< Point > spatialPoints () const
 
void gatherSum (T &value)
 
void gatherMax (T &value)
 
void gatherMin (T &value)
 
void gatherProxyValueMax (T1 &value, T2 &proxy)
 
void gatherProxyValueMin (T1 &value, T2 &proxy)
 
void setPrimaryThreadCopy (UserObject *primary)
 
UserObjectprimaryThreadCopy ()
 
std::set< UserObjectName > getDependObjects () const
 
virtual bool needThreadedCopy () const
 
const std::set< std::string > & getRequestedItems () override
 
const std::set< std::string > & getSuppliedItems () override
 
unsigned int systemNumber () const
 
virtual bool enabled () const
 
MooseAppgetMooseApp () const
 
const std::string & type () const
 
virtual const std::string & name () const
 
std::string typeAndName () const
 
std::string errorPrefix (const std::string &error_type) const
 
void callMooseError (std::string msg, const bool with_prefix) const
 
MooseObjectParameterName uniqueParameterName (const std::string &parameter_name) const
 
const InputParametersparameters () const
 
MooseObjectName uniqueName () const
 
const T & getParam (const std::string &name) const
 
std::vector< std::pair< T1, T2 > > getParam (const std::string &param1, const std::string &param2) const
 
const T & getRenamedParam (const std::string &old_name, const std::string &new_name) const
 
getCheckedPointerParam (const std::string &name, const std::string &error_string="") const
 
bool isParamValid (const std::string &name) const
 
bool isParamSetByUser (const std::string &nm) const
 
void paramError (const std::string &param, Args... args) const
 
void paramWarning (const std::string &param, Args... args) const
 
void paramInfo (const std::string &param, Args... args) const
 
void connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
 
void mooseError (Args &&... args) const
 
void mooseErrorNonPrefixed (Args &&... args) const
 
void mooseWarning (Args &&... args) const
 
void mooseWarningNonPrefixed (Args &&... args) const
 
void mooseDeprecated (Args &&... args) const
 
void mooseInfo (Args &&... args) const
 
std::string getDataFileName (const std::string &param) const
 
std::string getDataFileNameByName (const std::string &name, const std::string *param=nullptr) const
 
virtual void timestepSetup ()
 
virtual void timestepSetup () override
 
virtual void jacobianSetup ()
 
virtual void jacobianSetup () override
 
virtual void residualSetup ()
 
virtual void residualSetup () override
 
virtual void customSetup (const ExecFlagType &)
 
virtual void customSetup (const ExecFlagType &exec_type) override
 
const ExecFlagEnumgetExecuteOnEnum () const
 
UserObjectName getUserObjectName (const std::string &param_name) const
 
const T & getUserObject (const std::string &param_name, bool is_dependency=true) const
 
const T & getUserObjectByName (const UserObjectName &object_name, bool is_dependency=true) const
 
const UserObjectgetUserObjectBase (const std::string &param_name, bool is_dependency=true) const
 
const UserObjectgetUserObjectBaseByName (const UserObjectName &object_name, bool is_dependency=true) const
 
const GenericMaterialProperty< T, is_ad > & getGenericMaterialProperty (const std::string &name, MaterialData &material_data, const unsigned int state=0)
 
const GenericMaterialProperty< T, is_ad > & getGenericMaterialProperty (const std::string &name, const unsigned int state=0)
 
const GenericMaterialProperty< T, is_ad > & getGenericMaterialProperty (const std::string &name, const unsigned int state=0)
 
const MaterialProperty< T > & getMaterialProperty (const std::string &name, MaterialData &material_data, const unsigned int state=0)
 
const MaterialProperty< T > & getMaterialProperty (const std::string &name, const unsigned int state=0)
 
const MaterialProperty< T > & getMaterialProperty (const std::string &name, const unsigned int state=0)
 
const ADMaterialProperty< T > & getADMaterialProperty (const std::string &name, MaterialData &material_data)
 
const ADMaterialProperty< T > & getADMaterialProperty (const std::string &name)
 
const ADMaterialProperty< T > & getADMaterialProperty (const std::string &name)
 
const MaterialProperty< T > & getMaterialPropertyOld (const std::string &name, MaterialData &material_data)
 
const MaterialProperty< T > & getMaterialPropertyOld (const std::string &name)
 
const MaterialProperty< T > & getMaterialPropertyOld (const std::string &name)
 
const MaterialProperty< T > & getMaterialPropertyOlder (const std::string &name, MaterialData &material_data)
 
const MaterialProperty< T > & getMaterialPropertyOlder (const std::string &name)
 
const MaterialProperty< T > & getMaterialPropertyOlder (const std::string &name)
 
const GenericMaterialProperty< T, is_ad > & getGenericMaterialPropertyByName (const MaterialPropertyName &name, MaterialData &material_data, const unsigned int state)
 
const GenericMaterialProperty< T, is_ad > & getGenericMaterialPropertyByName (const MaterialPropertyName &name, const unsigned int state=0)
 
const GenericMaterialProperty< T, is_ad > & getGenericMaterialPropertyByName (const MaterialPropertyName &name, const unsigned int state=0)
 
const MaterialProperty< T > & getMaterialPropertyByName (const MaterialPropertyName &name, MaterialData &material_data, const unsigned int state=0)
 
const MaterialProperty< T > & getMaterialPropertyByName (const MaterialPropertyName &name, const unsigned int state=0)
 
const MaterialProperty< T > & getMaterialPropertyByName (const MaterialPropertyName &name, const unsigned int state=0)
 
const ADMaterialProperty< T > & getADMaterialPropertyByName (const MaterialPropertyName &name, MaterialData &material_data)
 
const ADMaterialProperty< T > & getADMaterialPropertyByName (const MaterialPropertyName &name)
 
const ADMaterialProperty< T > & getADMaterialPropertyByName (const MaterialPropertyName &name)
 
const MaterialProperty< T > & getMaterialPropertyOldByName (const MaterialPropertyName &name, MaterialData &material_data)
 
const MaterialProperty< T > & getMaterialPropertyOldByName (const MaterialPropertyName &name)
 
const MaterialProperty< T > & getMaterialPropertyOldByName (const MaterialPropertyName &name)
 
const MaterialProperty< T > & getMaterialPropertyOlderByName (const MaterialPropertyName &name, MaterialData &material_data)
 
const MaterialProperty< T > & getMaterialPropertyOlderByName (const MaterialPropertyName &name)
 
const MaterialProperty< T > & getMaterialPropertyOlderByName (const MaterialPropertyName &name)
 
std::pair< const MaterialProperty< T > *, std::set< SubdomainID > > getBlockMaterialProperty (const MaterialPropertyName &name)
 
const GenericMaterialProperty< T, is_ad > & getGenericZeroMaterialProperty (const std::string &name)
 
const GenericMaterialProperty< T, is_ad > & getGenericZeroMaterialProperty ()
 
const GenericMaterialProperty< T, is_ad > & getGenericZeroMaterialPropertyByName (const std::string &prop_name)
 
const MaterialProperty< T > & getZeroMaterialProperty (Ts... args)
 
std::set< SubdomainIDgetMaterialPropertyBlocks (const std::string &name)
 
std::vector< SubdomainName > getMaterialPropertyBlockNames (const std::string &name)
 
std::set< BoundaryIDgetMaterialPropertyBoundaryIDs (const std::string &name)
 
std::vector< BoundaryName > getMaterialPropertyBoundaryNames (const std::string &name)
 
void checkBlockAndBoundaryCompatibility (std::shared_ptr< MaterialBase > discrete)
 
std::unordered_map< SubdomainID, std::vector< MaterialBase *> > buildRequiredMaterials (bool allow_stateful=true)
 
void statefulPropertiesAllowed (bool)
 
bool getMaterialPropertyCalled () const
 
const std::unordered_set< unsigned int > & getMatPropDependencies () const
 
virtual void resolveOptionalProperties ()
 
const GenericMaterialProperty< T, is_ad > & getPossiblyConstantGenericMaterialPropertyByName (const MaterialPropertyName &prop_name, MaterialData &material_data, const unsigned int state)
 
bool isImplicit ()
 
const PostprocessorValuegetCurrentValue () const
 
const std::string & PPName () const
 
virtual bool hasBlocks (SubdomainID) const override
 
bool supportsFaceArg () const override final
 
bool supportsElemSideQpArg () const override final
 
void buildOutputHideVariableList (std::set< std::string > variable_names)
 
const std::set< OutputName > & getOutputs ()
 
FunctorReturnType< Real, FET >::type genericEvaluate (const Space &r, const State &state) const
 
const MooseFunctorName & functorName () const
 
void setCacheClearanceSchedule (const std::set< ExecFlagType > &clearance_schedule)
 
virtual bool isExtrapolatedBoundaryFace (const FaceInfo &, const Elem *, const StateArg &) const
 
bool isInternalFace (const FaceInfo &) const
 
virtual bool isConstant () const
 
virtual bool hasFaceSide (const FaceInfo &fi, const bool fi_elem_side) const override
 
Moose::FaceArg checkFace (const Moose::FaceArg &face) const
 
virtual void threadJoin (const UserObject &) override
 
virtual void threadJoin (const UserObject &) override
 
virtual void subdomainSetup () override
 
virtual void subdomainSetup () override
 
bool hasUserObject (const std::string &param_name) const
 
bool hasUserObject (const std::string &param_name) const
 
bool hasUserObject (const std::string &param_name) const
 
bool hasUserObject (const std::string &param_name) const
 
bool hasUserObjectByName (const UserObjectName &object_name) const
 
bool hasUserObjectByName (const UserObjectName &object_name) const
 
bool hasUserObjectByName (const UserObjectName &object_name) const
 
bool hasUserObjectByName (const UserObjectName &object_name) const
 
const GenericOptionalMaterialProperty< T, is_ad > & getGenericOptionalMaterialProperty (const std::string &name, const unsigned int state=0)
 
const GenericOptionalMaterialProperty< T, is_ad > & getGenericOptionalMaterialProperty (const std::string &name, const unsigned int state=0)
 
const OptionalMaterialProperty< T > & getOptionalMaterialProperty (const std::string &name, const unsigned int state=0)
 
const OptionalMaterialProperty< T > & getOptionalMaterialProperty (const std::string &name, const unsigned int state=0)
 
const OptionalADMaterialProperty< T > & getOptionalADMaterialProperty (const std::string &name)
 
const OptionalADMaterialProperty< T > & getOptionalADMaterialProperty (const std::string &name)
 
const OptionalMaterialProperty< T > & getOptionalMaterialPropertyOld (const std::string &name)
 
const OptionalMaterialProperty< T > & getOptionalMaterialPropertyOld (const std::string &name)
 
const OptionalMaterialProperty< T > & getOptionalMaterialPropertyOlder (const std::string &name)
 
const OptionalMaterialProperty< T > & getOptionalMaterialPropertyOlder (const std::string &name)
 
MaterialBasegetMaterial (const std::string &name)
 
MaterialBasegetMaterial (const std::string &name)
 
MaterialBasegetMaterialByName (const std::string &name, bool no_warn=false)
 
MaterialBasegetMaterialByName (const std::string &name, bool no_warn=false)
 
bool hasMaterialProperty (const std::string &name)
 
bool hasMaterialProperty (const std::string &name)
 
bool hasMaterialPropertyByName (const std::string &name)
 
bool hasMaterialPropertyByName (const std::string &name)
 
bool hasADMaterialProperty (const std::string &name)
 
bool hasADMaterialProperty (const std::string &name)
 
bool hasADMaterialPropertyByName (const std::string &name)
 
bool hasADMaterialPropertyByName (const std::string &name)
 
bool hasGenericMaterialProperty (const std::string &name)
 
bool hasGenericMaterialProperty (const std::string &name)
 
bool hasGenericMaterialPropertyByName (const std::string &name)
 
bool hasGenericMaterialPropertyByName (const std::string &name)
 
ValueType operator() (const ElemArg &elem, const StateArg &state) const
 
ValueType operator() (const FaceArg &face, const StateArg &state) const
 
ValueType operator() (const ElemQpArg &qp, const StateArg &state) const
 
ValueType operator() (const ElemSideQpArg &qp, const StateArg &state) const
 
ValueType operator() (const ElemPointArg &elem_point, const StateArg &state) const
 
ValueType operator() (const NodeArg &node, const StateArg &state) const
 
ValueType operator() (const ElemArg &elem, const StateArg &state) const
 
ValueType operator() (const FaceArg &face, const StateArg &state) const
 
ValueType operator() (const ElemQpArg &qp, const StateArg &state) const
 
ValueType operator() (const ElemSideQpArg &qp, const StateArg &state) const
 
ValueType operator() (const ElemPointArg &elem_point, const StateArg &state) const
 
ValueType operator() (const NodeArg &node, const StateArg &state) const
 
ValueType operator() (const ElemArg &elem, const StateArg &state) const
 
ValueType operator() (const FaceArg &face, const StateArg &state) const
 
ValueType operator() (const ElemQpArg &qp, const StateArg &state) const
 
ValueType operator() (const ElemSideQpArg &qp, const StateArg &state) const
 
ValueType operator() (const ElemPointArg &elem_point, const StateArg &state) const
 
ValueType operator() (const NodeArg &node, const StateArg &state) const
 
GradientType gradient (const ElemArg &elem, const StateArg &state) const
 
GradientType gradient (const FaceArg &face, const StateArg &state) const
 
GradientType gradient (const ElemQpArg &qp, const StateArg &state) const
 
GradientType gradient (const ElemSideQpArg &qp, const StateArg &state) const
 
GradientType gradient (const ElemPointArg &elem_point, const StateArg &state) const
 
GradientType gradient (const NodeArg &node, const StateArg &state) const
 
GradientType gradient (const ElemArg &elem, const StateArg &state) const
 
GradientType gradient (const FaceArg &face, const StateArg &state) const
 
GradientType gradient (const ElemQpArg &qp, const StateArg &state) const
 
GradientType gradient (const ElemSideQpArg &qp, const StateArg &state) const
 
GradientType gradient (const ElemPointArg &elem_point, const StateArg &state) const
 
GradientType gradient (const NodeArg &node, const StateArg &state) const
 
GradientType gradient (const ElemArg &elem, const StateArg &state) const
 
GradientType gradient (const FaceArg &face, const StateArg &state) const
 
GradientType gradient (const ElemQpArg &qp, const StateArg &state) const
 
GradientType gradient (const ElemSideQpArg &qp, const StateArg &state) const
 
GradientType gradient (const ElemPointArg &elem_point, const StateArg &state) const
 
GradientType gradient (const NodeArg &node, const StateArg &state) const
 
DotType dot (const ElemArg &elem, const StateArg &state) const
 
DotType dot (const FaceArg &face, const StateArg &state) const
 
DotType dot (const ElemQpArg &qp, const StateArg &state) const
 
DotType dot (const ElemSideQpArg &qp, const StateArg &state) const
 
DotType dot (const ElemPointArg &elem_point, const StateArg &state) const
 
DotType dot (const NodeArg &node, const StateArg &state) const
 
DotType dot (const ElemArg &elem, const StateArg &state) const
 
DotType dot (const FaceArg &face, const StateArg &state) const
 
DotType dot (const ElemQpArg &qp, const StateArg &state) const
 
DotType dot (const ElemSideQpArg &qp, const StateArg &state) const
 
DotType dot (const ElemPointArg &elem_point, const StateArg &state) const
 
DotType dot (const NodeArg &node, const StateArg &state) const
 
DotType dot (const ElemArg &elem, const StateArg &state) const
 
DotType dot (const FaceArg &face, const StateArg &state) const
 
DotType dot (const ElemQpArg &qp, const StateArg &state) const
 
DotType dot (const ElemSideQpArg &qp, const StateArg &state) const
 
DotType dot (const ElemPointArg &elem_point, const StateArg &state) const
 
DotType dot (const NodeArg &node, const StateArg &state) const
 
GradientType gradDot (const ElemArg &elem, const StateArg &state) const
 
GradientType gradDot (const FaceArg &face, const StateArg &state) const
 
GradientType gradDot (const ElemQpArg &qp, const StateArg &state) const
 
GradientType gradDot (const ElemSideQpArg &qp, const StateArg &state) const
 
GradientType gradDot (const ElemPointArg &elem_point, const StateArg &state) const
 
GradientType gradDot (const NodeArg &node, const StateArg &state) const
 
GradientType gradDot (const ElemArg &elem, const StateArg &state) const
 
GradientType gradDot (const FaceArg &face, const StateArg &state) const
 
GradientType gradDot (const ElemQpArg &qp, const StateArg &state) const
 
GradientType gradDot (const ElemSideQpArg &qp, const StateArg &state) const
 
GradientType gradDot (const ElemPointArg &elem_point, const StateArg &state) const
 
GradientType gradDot (const NodeArg &node, const StateArg &state) const
 
GradientType gradDot (const ElemArg &elem, const StateArg &state) const
 
GradientType gradDot (const FaceArg &face, const StateArg &state) const
 
GradientType gradDot (const ElemQpArg &qp, const StateArg &state) const
 
GradientType gradDot (const ElemSideQpArg &qp, const StateArg &state) const
 
GradientType gradDot (const ElemPointArg &elem_point, const StateArg &state) const
 
GradientType gradDot (const NodeArg &node, const StateArg &state) const
 
const FunctiongetFunction (const std::string &name) const
 
const FunctiongetFunctionByName (const FunctionName &name) const
 
bool hasFunction (const std::string &param_name) const
 
bool hasFunctionByName (const FunctionName &name) const
 
bool isDefaultPostprocessorValue (const std::string &param_name, const unsigned int index=0) const
 
bool hasPostprocessor (const std::string &param_name, const unsigned int index=0) const
 
bool hasPostprocessorByName (const PostprocessorName &name) const
 
std::size_t coupledPostprocessors (const std::string &param_name) const
 
const PostprocessorName & getPostprocessorName (const std::string &param_name, const unsigned int index=0) const
 
const VectorPostprocessorValuegetVectorPostprocessorValue (const std::string &param_name, const std::string &vector_name) const
 
const VectorPostprocessorValuegetVectorPostprocessorValue (const std::string &param_name, const std::string &vector_name, bool needs_broadcast) const
 
const VectorPostprocessorValuegetVectorPostprocessorValueByName (const VectorPostprocessorName &name, const std::string &vector_name) const
 
const VectorPostprocessorValuegetVectorPostprocessorValueByName (const VectorPostprocessorName &name, const std::string &vector_name, bool needs_broadcast) const
 
const VectorPostprocessorValuegetVectorPostprocessorValueOld (const std::string &param_name, const std::string &vector_name) const
 
const VectorPostprocessorValuegetVectorPostprocessorValueOld (const std::string &param_name, const std::string &vector_name, bool needs_broadcast) const
 
const VectorPostprocessorValuegetVectorPostprocessorValueOldByName (const VectorPostprocessorName &name, const std::string &vector_name) const
 
const VectorPostprocessorValuegetVectorPostprocessorValueOldByName (const VectorPostprocessorName &name, const std::string &vector_name, bool needs_broadcast) const
 
const ScatterVectorPostprocessorValuegetScatterVectorPostprocessorValue (const std::string &param_name, const std::string &vector_name) const
 
const ScatterVectorPostprocessorValuegetScatterVectorPostprocessorValueByName (const VectorPostprocessorName &name, const std::string &vector_name) const
 
const ScatterVectorPostprocessorValuegetScatterVectorPostprocessorValueOld (const std::string &param_name, const std::string &vector_name) const
 
const ScatterVectorPostprocessorValuegetScatterVectorPostprocessorValueOldByName (const VectorPostprocessorName &name, const std::string &vector_name) const
 
bool hasVectorPostprocessor (const std::string &param_name, const std::string &vector_name) const
 
bool hasVectorPostprocessor (const std::string &param_name) const
 
bool hasVectorPostprocessorByName (const VectorPostprocessorName &name, const std::string &vector_name) const
 
bool hasVectorPostprocessorByName (const VectorPostprocessorName &name) const
 
const VectorPostprocessorName & getVectorPostprocessorName (const std::string &param_name) const
 
T & getSampler (const std::string &name)
 
SamplergetSampler (const std::string &name)
 
T & getSamplerByName (const SamplerName &name)
 
SamplergetSamplerByName (const SamplerName &name)
 
const std::vector< MooseVariableScalar *> & getCoupledMooseScalarVars ()
 
const std::set< TagID > & getScalarVariableCoupleableVectorTags () const
 
const std::set< TagID > & getScalarVariableCoupleableMatrixTags () const
 
PerfGraphperfGraph ()
 
const PostprocessorValuegetPostprocessorValue (const std::string &param_name, const unsigned int index=0) const
 
const PostprocessorValuegetPostprocessorValue (const std::string &param_name, const unsigned int index=0) const
 
const PostprocessorValuegetPostprocessorValueOld (const std::string &param_name, const unsigned int index=0) const
 
const PostprocessorValuegetPostprocessorValueOld (const std::string &param_name, const unsigned int index=0) const
 
const PostprocessorValuegetPostprocessorValueOlder (const std::string &param_name, const unsigned int index=0) const
 
const PostprocessorValuegetPostprocessorValueOlder (const std::string &param_name, const unsigned int index=0) const
 
virtual const PostprocessorValuegetPostprocessorValueByName (const PostprocessorName &name) const
 
virtual const PostprocessorValuegetPostprocessorValueByName (const PostprocessorName &name) const
 
const PostprocessorValuegetPostprocessorValueOldByName (const PostprocessorName &name) const
 
const PostprocessorValuegetPostprocessorValueOldByName (const PostprocessorName &name) const
 
const PostprocessorValuegetPostprocessorValueOlderByName (const PostprocessorName &name) const
 
const PostprocessorValuegetPostprocessorValueOlderByName (const PostprocessorName &name) const
 
bool isVectorPostprocessorDistributed (const std::string &param_name) const
 
bool isVectorPostprocessorDistributed (const std::string &param_name) const
 
bool isVectorPostprocessorDistributedByName (const VectorPostprocessorName &name) const
 
bool isVectorPostprocessorDistributedByName (const VectorPostprocessorName &name) const
 
const DistributiongetDistribution (const std::string &name) const
 
const T & getDistribution (const std::string &name) const
 
const DistributiongetDistribution (const std::string &name) const
 
const T & getDistribution (const std::string &name) const
 
const DistributiongetDistributionByName (const DistributionName &name) const
 
const T & getDistributionByName (const std::string &name) const
 
const DistributiongetDistributionByName (const DistributionName &name) const
 
const T & getDistributionByName (const std::string &name) const
 
const Parallel::Communicator & comm () const
 
processor_id_type n_processors () const
 
processor_id_type processor_id () const
 
const ADVariableValuegetADDefaultValue (const std::string &var_name) const
 
const std::vector< MooseVariableFieldBase *> & getCoupledMooseVars () const
 
const std::vector< MooseVariable *> & getCoupledStandardMooseVars () const
 
const std::vector< VectorMooseVariable *> & getCoupledVectorMooseVars () const
 
const std::vector< ArrayMooseVariable *> & getCoupledArrayMooseVars () const
 
void addFEVariableCoupleableVectorTag (TagID tag)
 
void addFEVariableCoupleableMatrixTag (TagID tag)
 
std::set< TagID > & getFEVariableCoupleableVectorTags ()
 
const std::set< TagID > & getFEVariableCoupleableVectorTags () const
 
std::set< TagID > & getFEVariableCoupleableMatrixTags ()
 
const std::set< TagID > & getFEVariableCoupleableMatrixTags () const
 
auto & getWritableCoupledVariables () const
 
bool hasWritableCoupledVariables () const
 
const ADVectorVariableValuegetADDefaultVectorValue (const std::string &var_name) const
 
const ADVariableGradientgetADDefaultGradient () const
 
const ADVectorVariableGradientgetADDefaultVectorGradient () const
 
const ADVariableSecondgetADDefaultSecond () const
 
const std::set< MooseVariableFieldBase *> & getMooseVariableDependencies () const
 
std::set< MooseVariableFieldBase *> checkAllVariables (const DofObjectType &dof_object, const std::set< MooseVariableFieldBase * > &vars_to_omit={})
 
std::set< MooseVariableFieldBase *> checkVariables (const DofObjectType &dof_object, const std::set< MooseVariableFieldBase * > &vars_to_check)
 
virtual const std::set< BoundaryID > & boundaryIDs () const
 
const std::vector< BoundaryName > & boundaryNames () const
 
unsigned int numBoundaryIDs () const
 
bool hasBoundary (const BoundaryName &name) const
 
bool hasBoundary (const std::vector< BoundaryName > &names) const
 
bool hasBoundary (const BoundaryID &id) const
 
bool hasBoundary (const std::vector< BoundaryID > &ids, TEST_TYPE type=ALL) const
 
bool hasBoundary (const std::set< BoundaryID > &ids, TEST_TYPE type=ALL) const
 
bool isBoundarySubset (const std::set< BoundaryID > &ids) const
 
bool isBoundarySubset (const std::vector< BoundaryID > &ids) const
 
bool hasBoundaryMaterialProperty (const std::string &prop_name) const
 
virtual bool boundaryRestricted () const
 
const std::set< BoundaryID > & meshBoundaryIDs () const
 
virtual bool checkVariableBoundaryIntegrity () const
 

Static Public Member Functions

static InputParameters validParams ()
 
static void sortDFS (typename std::vector< T > &vector)
 
static void cyclicDependencyError (CyclicDependencyException< T2 > &e, const std::string &header)
 
static std::string deduceFunctorName (const std::string &name, const InputParameters &params)
 
static bool restricted (const std::set< BoundaryID > &ids)
 

Public Attributes

const ConsoleStream _console
 
 ALL
 
 ANY
 

Static Public Attributes

static constexpr PropertyValue::id_type default_property_id
 
static constexpr PropertyValue::id_type zero_property_id
 
static constexpr auto SYSTEM
 
static constexpr auto NAME
 
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()
 
static const processor_id_type invalid_proc_id
 

Protected Member Functions

RankFourTensor newGrain (unsigned int new_grain_id)
 implement this method to initialize the data for the new grain More...
 
virtual void newGrainCreated (unsigned int new_grain_id)
 This method is called when a new grain is detected. More...
 
virtual void updateFieldInfo () override
 This method is used to populate any of the data structures used for storing field data (nodal or elemental). More...
 
virtual Real getThreshold (std::size_t current_index) const override
 Return the starting comparison threshold to use when inspecting an entity during the flood stage. More...
 
void prepopulateState (const FeatureFloodCount &ffc_object)
 This method extracts the necessary state from the passed in object necessary to continue tracking grains. More...
 
void communicateHaloMap ()
 
void assignGrains ()
 When the tracking phase starts (_t_step == _tracking_step) it assigns a unique id to every FeatureData object found by the FeatureFloodCount object. More...
 
void trackGrains ()
 On subsequent time_steps, incoming FeatureData objects are compared to previous time_step information to track grains between time steps. More...
 
void remapGrains ()
 This method is called after trackGrains to remap grains that are too close to each other. More...
 
void broadcastAndUpdateGrainData ()
 Broadcast essential Grain information to all processors. More...
 
void computeMinDistancesFromGrain (FeatureData &grain, std::vector< std::list< GrainDistance >> &min_distances)
 Populates and sorts a min_distances vector with the minimum distances to all grains in the simulation for a given grain. More...
 
bool attemptGrainRenumber (FeatureData &grain, unsigned int depth, unsigned int max_depth)
 This is the recursive part of the remapping algorithm. More...
 
void swapSolutionValues (FeatureData &grain, std::size_t new_var_index, std::vector< std::map< Node *, CacheValues >> &cache, RemapCacheMode cache_mode)
 A routine for moving all of the solution values from a given grain to a new variable number. More...
 
void swapSolutionValuesHelper (Node *curr_node, std::size_t curr_var_index, std::size_t new_var_index, std::vector< std::map< Node *, CacheValues >> &cache, RemapCacheMode cache_mode)
 Helper method for actually performing the swaps. More...
 
Real boundingRegionDistance (std::vector< BoundingBox > &bboxes1, std::vector< BoundingBox > &bboxes2) const
 This method returns the minimum periodic distance between two vectors of bounding boxes. More...
 
Real centroidRegionDistance (std::vector< BoundingBox > &bboxes1, std::vector< BoundingBox > &bboxes2) const
 This method returns the minimum periodic distance between the centroids of two vectors of bounding boxes. More...
 
unsigned int getNextUniqueID ()
 Retrieve the next unique grain number if a new grain is detected during trackGrains. 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...
 
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 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...
 
virtual bool isNewFeatureOrConnectedRegion (const DofObject *dof_object, std::size_t &current_index, FeatureData *&feature, Status &status, unsigned int &new_id)
 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...
 
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...
 
virtual void prepareDataForTransfer ()
 This routine uses the local flooded data to build up the local feature data structures (_partial 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...
 
virtual void mergeSets ()
 This routine is called on the primary rank only and stitches together the partial feature pieces seen on any processor. More...
 
virtual 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...
 
virtual bool areFeaturesMergeable (const FeatureData &f1, const FeatureData &f2) const
 Method for determining whether two features are mergeable. More...
 
virtual processor_id_type numberOfDistributedMergeHelpers () const
 Returns a number indicating the number of merge helpers when running in parallel based on certain implementer decided criteria. More...
 
void communicateAndMerge ()
 This routine handles all of the serialization, communication and deserialization of the data structures containing FeatureData objects. More...
 
virtual void restoreOriginalDataStructures (std::vector< std::list< FeatureData >> &)
 
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...
 
std::string deduceFunctorName (const std::string &name) const
 
virtual void addPostprocessorDependencyHelper (const PostprocessorName &name) const override
 
virtual void addVectorPostprocessorDependencyHelper (const VectorPostprocessorName &name) const override
 
virtual void addUserObjectDependencyHelper (const UserObject &uo) const override
 
void addReporterDependencyHelper (const ReporterName &reporter_name) override
 
const ReporterNamegetReporterName (const std::string &param_name) const
 
T & declareRestartableData (const std::string &data_name, Args &&... args)
 
ManagedValue< T > declareManagedRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)
 
const T & getRestartableData (const std::string &data_name) const
 
T & declareRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)
 
T & declareRecoverableData (const std::string &data_name, Args &&... args)
 
T & declareRestartableDataWithObjectName (const std::string &data_name, const std::string &object_name, Args &&... args)
 
T & declareRestartableDataWithObjectNameWithContext (const std::string &data_name, const std::string &object_name, void *context, Args &&... args)
 
std::string restartableName (const std::string &data_name) const
 
const T & getMeshProperty (const std::string &data_name, const std::string &prefix)
 
const T & getMeshProperty (const std::string &data_name)
 
bool hasMeshProperty (const std::string &data_name, const std::string &prefix) const
 
bool hasMeshProperty (const std::string &data_name, const std::string &prefix) const
 
bool hasMeshProperty (const std::string &data_name) const
 
bool hasMeshProperty (const std::string &data_name) const
 
std::string meshPropertyName (const std::string &data_name) const
 
bool isCoupledScalar (const std::string &var_name, unsigned int i=0) const
 
unsigned int coupledScalarComponents (const std::string &var_name) const
 
unsigned int coupledScalar (const std::string &var_name, unsigned int comp=0) const
 
Order coupledScalarOrder (const std::string &var_name, unsigned int comp=0) const
 
const VariableValuecoupledScalarValue (const std::string &var_name, unsigned int comp=0) const
 
const ADVariableValueadCoupledScalarValue (const std::string &var_name, unsigned int comp=0) const
 
const GenericVariableValue< is_ad > & coupledGenericScalarValue (const std::string &var_name, unsigned int comp=0) const
 
const GenericVariableValue< false > & coupledGenericScalarValue (const std::string &var_name, const unsigned int comp) const
 
const GenericVariableValue< true > & coupledGenericScalarValue (const std::string &var_name, const unsigned int comp) const
 
const VariableValuecoupledVectorTagScalarValue (const std::string &var_name, TagID tag, unsigned int comp=0) const
 
const VariableValuecoupledMatrixTagScalarValue (const std::string &var_name, TagID tag, unsigned int comp=0) const
 
const VariableValuecoupledScalarValueOld (const std::string &var_name, unsigned int comp=0) const
 
const VariableValuecoupledScalarValueOlder (const std::string &var_name, unsigned int comp=0) const
 
const VariableValuecoupledScalarDot (const std::string &var_name, unsigned int comp=0) const
 
const ADVariableValueadCoupledScalarDot (const std::string &var_name, unsigned int comp=0) const
 
const VariableValuecoupledScalarDotDot (const std::string &var_name, unsigned int comp=0) const
 
const VariableValuecoupledScalarDotOld (const std::string &var_name, unsigned int comp=0) const
 
const VariableValuecoupledScalarDotDotOld (const std::string &var_name, unsigned int comp=0) const
 
const VariableValuecoupledScalarDotDu (const std::string &var_name, unsigned int comp=0) const
 
const VariableValuecoupledScalarDotDotDu (const std::string &var_name, unsigned int comp=0) const
 
const MooseVariableScalargetScalarVar (const std::string &var_name, unsigned int comp) const
 
PerfID registerTimedSection (const std::string &section_name, const unsigned int level) const
 
PerfID registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
 
std::string timedSectionName (const std::string &section_name) const
 
virtual void checkMaterialProperty (const std::string &name, const unsigned int state)
 
void markMatPropRequested (const std::string &)
 
MaterialPropertyName getMaterialPropertyName (const std::string &name) const
 
void checkExecutionStage ()
 
Moose::StateArg determineState () const
 
const Moose::Functor< T > & getFunctor (const std::string &name)
 
const Moose::Functor< T > & getFunctor (const std::string &name, THREAD_ID tid)
 
const Moose::Functor< T > & getFunctor (const std::string &name, SubProblem &subproblem)
 
const Moose::Functor< T > & getFunctor (const std::string &name, SubProblem &subproblem, THREAD_ID tid)
 
bool isFunctor (const std::string &name) const
 
bool isFunctor (const std::string &name, const SubProblem &subproblem) const
 
Moose::ElemArg makeElemArg (const Elem *elem, bool correct_skewnewss=false) const
 
void checkFunctorSupportsSideIntegration (const std::string &name, bool qp_integration)
 
const T & getReporterValue (const std::string &param_name, const std::size_t time_index=0)
 
const T & getReporterValue (const std::string &param_name, ReporterMode mode, const std::size_t time_index=0)
 
const T & getReporterValue (const std::string &param_name, const std::size_t time_index=0)
 
const T & getReporterValue (const std::string &param_name, ReporterMode mode, const std::size_t time_index=0)
 
const T & getReporterValueByName (const ReporterName &reporter_name, const std::size_t time_index=0)
 
const T & getReporterValueByName (const ReporterName &reporter_name, ReporterMode mode, const std::size_t time_index=0)
 
const T & getReporterValueByName (const ReporterName &reporter_name, const std::size_t time_index=0)
 
const T & getReporterValueByName (const ReporterName &reporter_name, ReporterMode mode, const std::size_t time_index=0)
 
bool hasReporterValue (const std::string &param_name) const
 
bool hasReporterValue (const std::string &param_name) const
 
bool hasReporterValue (const std::string &param_name) const
 
bool hasReporterValue (const std::string &param_name) const
 
bool hasReporterValueByName (const ReporterName &reporter_name) const
 
bool hasReporterValueByName (const ReporterName &reporter_name) const
 
bool hasReporterValueByName (const ReporterName &reporter_name) const
 
bool hasReporterValueByName (const ReporterName &reporter_name) const
 
const GenericMaterialProperty< T, is_ad > * defaultGenericMaterialProperty (const std::string &name)
 
const GenericMaterialProperty< T, is_ad > * defaultGenericMaterialProperty (const std::string &name)
 
const MaterialProperty< T > * defaultMaterialProperty (const std::string &name)
 
const MaterialProperty< T > * defaultMaterialProperty (const std::string &name)
 
const ADMaterialProperty< T > * defaultADMaterialProperty (const std::string &name)
 
const ADMaterialProperty< T > * defaultADMaterialProperty (const std::string &name)
 
virtual GradientType evaluateGradDot (const ElemArg &, const StateArg &) const
 
virtual GradientType evaluateGradDot (const FaceArg &, const StateArg &) const
 
virtual GradientType evaluateGradDot (const ElemQpArg &, const StateArg &) const
 
virtual GradientType evaluateGradDot (const ElemSideQpArg &, const StateArg &) const
 
virtual GradientType evaluateGradDot (const ElemPointArg &, const StateArg &) const
 
virtual GradientType evaluateGradDot (const NodeArg &, const StateArg &) const
 
virtual GradientType evaluateGradDot (const ElemArg &, const StateArg &) const
 
virtual GradientType evaluateGradDot (const FaceArg &, const StateArg &) const
 
virtual GradientType evaluateGradDot (const ElemQpArg &, const StateArg &) const
 
virtual GradientType evaluateGradDot (const ElemSideQpArg &, const StateArg &) const
 
virtual GradientType evaluateGradDot (const ElemPointArg &, const StateArg &) const
 
virtual GradientType evaluateGradDot (const NodeArg &, const StateArg &) const
 
virtual GradientType evaluateGradDot (const ElemArg &, const StateArg &) const
 
virtual GradientType evaluateGradDot (const FaceArg &, const StateArg &) const
 
virtual GradientType evaluateGradDot (const ElemQpArg &, const StateArg &) const
 
virtual GradientType evaluateGradDot (const ElemSideQpArg &, const StateArg &) const
 
virtual GradientType evaluateGradDot (const ElemPointArg &, const StateArg &) const
 
virtual GradientType evaluateGradDot (const NodeArg &, const StateArg &) const
 
bool checkVar (const std::string &var_name, unsigned int comp=0, unsigned int comp_bound=0) const
 
void validateExecutionerType (const std::string &name, const std::string &fn_name) const
 
virtual ValueType evaluate (const ElemArg &elem, const StateArg &state) const =0
 
virtual ValueType evaluate (const FaceArg &face, const StateArg &state) const =0
 
virtual ValueType evaluate (const ElemQpArg &qp, const StateArg &state) const =0
 
virtual ValueType evaluate (const ElemSideQpArg &side_qp, const StateArg &state) const =0
 
virtual ValueType evaluate (const ElemPointArg &elem_point, const StateArg &state) const =0
 
virtual ValueType evaluate (const NodeArg &node, const StateArg &state) const =0
 
virtual GradientType evaluateGradient (const ElemArg &, const StateArg &) const
 
virtual GradientType evaluateGradient (const FaceArg &, const StateArg &) const
 
virtual GradientType evaluateGradient (const ElemQpArg &, const StateArg &) const
 
virtual GradientType evaluateGradient (const ElemSideQpArg &, const StateArg &) const
 
virtual GradientType evaluateGradient (const ElemPointArg &, const StateArg &) const
 
virtual GradientType evaluateGradient (const NodeArg &, const StateArg &) const
 
virtual DotType evaluateDot (const ElemArg &, const StateArg &) const
 
virtual DotType evaluateDot (const FaceArg &, const StateArg &) const
 
virtual DotType evaluateDot (const ElemQpArg &, const StateArg &) const
 
virtual DotType evaluateDot (const ElemSideQpArg &, const StateArg &) const
 
virtual DotType evaluateDot (const ElemPointArg &, const StateArg &) const
 
virtual DotType evaluateDot (const NodeArg &, const StateArg &) const
 
virtual void coupledCallback (const std::string &, bool) const
 
virtual bool isCoupled (const std::string &var_name, unsigned int i=0) const
 
virtual bool isCoupledConstant (const std::string &var_name) const
 
unsigned int coupledComponents (const std::string &var_name) const
 
VariableName coupledName (const std::string &var_name, unsigned int comp=0) const
 
std::vector< VariableName > coupledNames (const std::string &var_name) const
 
virtual unsigned int coupled (const std::string &var_name, unsigned int comp=0) const
 
std::vector< unsigned intcoupledIndices (const std::string &var_name) const
 
virtual const VariableValuecoupledValue (const std::string &var_name, unsigned int comp=0) const
 
std::vector< const VariableValue *> coupledValues (const std::string &var_name) const
 
std::vector< const VectorVariableValue *> coupledVectorValues (const std::string &var_name) const
 
const GenericVariableValue< is_ad > & coupledGenericValue (const std::string &var_name, unsigned int comp=0) const
 
const GenericVariableValue< false > & coupledGenericValue (const std::string &var_name, unsigned int comp) const
 
const GenericVariableValue< true > & coupledGenericValue (const std::string &var_name, unsigned int comp) const
 
std::vector< const GenericVariableValue< is_ad > *> coupledGenericValues (const std::string &var_name) const
 
std::vector< const GenericVariableValue< false > *> coupledGenericValues (const std::string &var_name) const
 
std::vector< const GenericVariableValue< true > *> coupledGenericValues (const std::string &var_name) const
 
const GenericVariableValue< is_ad > & coupledGenericDofValue (const std::string &var_name, unsigned int comp=0) const
 
const GenericVariableValue< false > & coupledGenericDofValue (const std::string &var_name, unsigned int comp) const
 
const GenericVariableValue< true > & coupledGenericDofValue (const std::string &var_name, unsigned int comp) const
 
virtual const VariableValuecoupledValueLower (const std::string &var_name, unsigned int comp=0) const
 
const ADVariableValueadCoupledValue (const std::string &var_name, unsigned int comp=0) const
 
std::vector< const ADVariableValue *> adCoupledValues (const std::string &var_name) const
 
const ADVariableValueadCoupledLowerValue (const std::string &var_name, unsigned int comp=0) const
 
const ADVectorVariableValueadCoupledVectorValue (const std::string &var_name, unsigned int comp=0) const
 
std::vector< const ADVectorVariableValue *> adCoupledVectorValues (const std::string &var_name) const
 
virtual const VariableValuecoupledVectorTagValue (const std::string &var_names, TagID tag, unsigned int index=0) const
 
virtual const VariableValuecoupledVectorTagValue (const std::string &var_names, const std::string &tag_name, unsigned int index=0) const
 
std::vector< const VariableValue *> coupledVectorTagValues (const std::string &var_names, TagID tag) const
 
std::vector< const VariableValue *> coupledVectorTagValues (const std::string &var_names, const std::string &tag_name) const
 
virtual const ArrayVariableValuecoupledVectorTagArrayValue (const std::string &var_names, TagID tag, unsigned int index=0) const
 
virtual const ArrayVariableValuecoupledVectorTagArrayValue (const std::string &var_names, const std::string &tag_name, unsigned int index=0) const
 
std::vector< const ArrayVariableValue *> coupledVectorTagArrayValues (const std::string &var_names, TagID tag) const
 
std::vector< const ArrayVariableValue *> coupledVectorTagArrayValues (const std::string &var_names, const std::string &tag_name) const
 
virtual const VariableGradientcoupledVectorTagGradient (const std::string &var_names, TagID tag, unsigned int index=0) const
 
virtual const VariableGradientcoupledVectorTagGradient (const std::string &var_names, const std::string &tag_name, unsigned int index=0) const
 
std::vector< const VariableGradient *> coupledVectorTagGradients (const std::string &var_names, TagID tag) const
 
std::vector< const VariableGradient *> coupledVectorTagGradients (const std::string &var_names, const std::string &tag_name) const
 
virtual const ArrayVariableGradientcoupledVectorTagArrayGradient (const std::string &var_names, TagID tag, unsigned int index=0) const
 
virtual const ArrayVariableGradientcoupledVectorTagArrayGradient (const std::string &var_names, const std::string &tag_name, unsigned int index=0) const
 
std::vector< const ArrayVariableGradient *> coupledVectorTagArrayGradients (const std::string &var_names, TagID tag) const
 
std::vector< const ArrayVariableGradient *> coupledVectorTagArrayGradients (const std::string &var_names, const std::string &tag_name) const
 
virtual const VariableValuecoupledVectorTagDofValue (const std::string &var_name, TagID tag, unsigned int index=0) const
 
virtual const VariableValuecoupledVectorTagDofValue (const std::string &var_names, const std::string &tag_name, unsigned int index=0) const
 
const ArrayVariableValuecoupledVectorTagArrayDofValue (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const
 
std::vector< const VariableValue *> coupledVectorTagDofValues (const std::string &var_names, TagID tag) const
 
std::vector< const VariableValue *> coupledVectorTagDofValues (const std::string &var_names, const std::string &tag_name) const
 
virtual const VariableValuecoupledMatrixTagValue (const std::string &var_names, TagID tag, unsigned int index=0) const
 
virtual const VariableValuecoupledMatrixTagValue (const std::string &var_names, const std::string &tag_name, unsigned int index=0) const
 
std::vector< const VariableValue *> coupledMatrixTagValues (const std::string &var_names, TagID tag) const
 
std::vector< const VariableValue *> coupledMatrixTagValues (const std::string &var_names, const std::string &tag_name) const
 
virtual const VectorVariableValuecoupledVectorValue (const std::string &var_name, unsigned int comp=0) const
 
virtual const ArrayVariableValuecoupledArrayValue (const std::string &var_name, unsigned int comp=0) const
 
std::vector< const ArrayVariableValue *> coupledArrayValues (const std::string &var_name) const
 
MooseWritableVariablewritableVariable (const std::string &var_name, unsigned int comp=0)
 
virtual VariableValuewritableCoupledValue (const std::string &var_name, unsigned int comp=0)
 
void checkWritableVar (MooseWritableVariable *var)
 
virtual const VariableValuecoupledValueOld (const std::string &var_name, unsigned int comp=0) const
 
std::vector< const VariableValue *> coupledValuesOld (const std::string &var_name) const
 
virtual const VariableValuecoupledValueOlder (const std::string &var_name, unsigned int comp=0) const
 
std::vector< const VariableValue *> coupledValuesOlder (const std::string &var_name) const
 
virtual const VariableValuecoupledValuePreviousNL (const std::string &var_name, unsigned int comp=0) const
 
virtual const VectorVariableValuecoupledVectorValueOld (const std::string &var_name, unsigned int comp=0) const
 
virtual const VectorVariableValuecoupledVectorValueOlder (const std::string &var_name, unsigned int comp=0) const
 
virtual const ArrayVariableValuecoupledArrayValueOld (const std::string &var_name, unsigned int comp=0) const
 
virtual const ArrayVariableValuecoupledArrayValueOlder (const std::string &var_name, unsigned int comp=0) const
 
virtual const VariableGradientcoupledGradient (const std::string &var_name, unsigned int comp=0) const
 
std::vector< const VariableGradient *> coupledGradients (const std::string &var_name) const
 
const ADVariableGradientadCoupledGradient (const std::string &var_name, unsigned int comp=0) const
 
const ADVariableGradientadCoupledGradientDot (const std::string &var_name, unsigned int comp=0) const
 
std::vector< const ADVariableGradient *> adCoupledGradients (const std::string &var_name) const
 
const GenericVariableGradient< is_ad > & coupledGenericGradient (const std::string &var_name, unsigned int comp=0) const
 
const GenericVariableGradient< false > & coupledGenericGradient (const std::string &var_name, unsigned int comp) const
 
const GenericVariableGradient< true > & coupledGenericGradient (const std::string &var_name, unsigned int comp) const
 
std::vector< const GenericVariableGradient< is_ad > *> coupledGenericGradients (const std::string &var_name) const
 
std::vector< const GenericVariableGradient< false > *> coupledGenericGradients (const std::string &var_name) const
 
std::vector< const GenericVariableGradient< true > *> coupledGenericGradients (const std::string &var_name) const
 
const ADVectorVariableGradientadCoupledVectorGradient (const std::string &var_name, unsigned int comp=0) const
 
const ADVariableSecondadCoupledSecond (const std::string &var_name, unsigned int comp=0) const
 
const ADVectorVariableSecondadCoupledVectorSecond (const std::string &var_name, unsigned int comp=0) const
 
virtual const VariableGradientcoupledGradientOld (const std::string &var_name, unsigned int comp=0) const
 
std::vector< const VariableGradient *> coupledGradientsOld (const std::string &var_name) const
 
virtual const VariableGradientcoupledGradientOlder (const std::string &var_name, unsigned int comp=0) const
 
virtual const VariableGradientcoupledGradientPreviousNL (const std::string &var_name, unsigned int comp=0) const
 
virtual const VariableGradientcoupledGradientDot (const std::string &var_name, unsigned int comp=0) const
 
virtual const VariableGradientcoupledGradientDotDot (const std::string &var_name, unsigned int comp=0) const
 
virtual const VectorVariableGradientcoupledVectorGradient (const std::string &var_name, unsigned int comp=0) const
 
virtual const VectorVariableGradientcoupledVectorGradientOld (const std::string &var_name, unsigned int comp=0) const
 
virtual const VectorVariableGradientcoupledVectorGradientOlder (const std::string &var_name, unsigned int comp=0) const
 
virtual const ArrayVariableGradientcoupledArrayGradient (const std::string &var_name, unsigned int comp=0) const
 
virtual const ArrayVariableGradientcoupledArrayGradientOld (const std::string &var_name, unsigned int comp=0) const
 
virtual const ArrayVariableGradientcoupledArrayGradientOlder (const std::string &var_name, unsigned int comp=0) const
 
virtual const ArrayVariableGradientcoupledArrayGradientDot (const std::string &var_name, unsigned int comp=0) const
 
virtual const VectorVariableCurlcoupledCurl (const std::string &var_name, unsigned int comp=0) const
 
virtual const VectorVariableCurlcoupledCurlOld (const std::string &var_name, unsigned int comp=0) const
 
virtual const VectorVariableCurlcoupledCurlOlder (const std::string &var_name, unsigned int comp=0) const
 
virtual const VariableSecondcoupledSecond (const std::string &var_name, unsigned int comp=0) const
 
virtual const VariableSecondcoupledSecondOld (const std::string &var_name, unsigned int comp=0) const
 
virtual const VariableSecondcoupledSecondOlder (const std::string &var_name, unsigned int comp=0) const
 
virtual const VariableSecondcoupledSecondPreviousNL (const std::string &var_name, unsigned int comp=0) const
 
virtual const VariableValuecoupledDot (const std::string &var_name, unsigned int comp=0) const
 
std::vector< const VariableValue *> coupledDots (const std::string &var_name) const
 
virtual const VariableValuecoupledDotDot (const std::string &var_name, unsigned int comp=0) const
 
virtual const VariableValuecoupledDotOld (const std::string &var_name, unsigned int comp=0) const
 
virtual const VariableValuecoupledDotDotOld (const std::string &var_name, unsigned int comp=0) const
 
const ADVariableValueadCoupledDot (const std::string &var_name, unsigned int comp=0) const
 
std::vector< const ADVariableValue *> adCoupledDots (const std::string &var_name) const
 
const ADVariableValueadCoupledDotDot (const std::string &var_name, unsigned int comp=0) const
 
const ADVectorVariableValueadCoupledVectorDot (const std::string &var_name, unsigned int comp=0) const
 
virtual const VectorVariableValuecoupledVectorDot (const std::string &var_name, unsigned int comp=0) const
 
virtual const VectorVariableValuecoupledVectorDotDot (const std::string &var_name, unsigned int comp=0) const
 
virtual const VectorVariableValuecoupledVectorDotOld (const std::string &var_name, unsigned int comp=0) const
 
virtual const VectorVariableValuecoupledVectorDotDotOld (const std::string &var_name, unsigned int comp=0) const
 
virtual const VariableValuecoupledVectorDotDu (const std::string &var_name, unsigned int comp=0) const
 
virtual const VariableValuecoupledVectorDotDotDu (const std::string &var_name, unsigned int comp=0) const
 
virtual const ArrayVariableValuecoupledArrayDot (const std::string &var_name, unsigned int comp=0) const
 
virtual const ArrayVariableValuecoupledArrayDotDot (const std::string &var_name, unsigned int comp=0) const
 
virtual const ArrayVariableValuecoupledArrayDotOld (const std::string &var_name, unsigned int comp=0) const
 
virtual const ArrayVariableValuecoupledArrayDotDotOld (const std::string &var_name, unsigned int comp=0) const
 
virtual const VariableValuecoupledDotDu (const std::string &var_name, unsigned int comp=0) const
 
virtual const VariableValuecoupledDotDotDu (const std::string &var_name, unsigned int comp=0) const
 
const VariableValuecoupledArrayDotDu (const std::string &var_name, unsigned int comp=0) const
 
const T & coupledNodalValue (const std::string &var_name, unsigned int comp=0) const
 
const Moose::ADType< T >::typeadCoupledNodalValue (const std::string &var_name, unsigned int comp=0) const
 
const T & coupledNodalValueOld (const std::string &var_name, unsigned int comp=0) const
 
const T & coupledNodalValueOlder (const std::string &var_name, unsigned int comp=0) const
 
const T & coupledNodalValuePreviousNL (const std::string &var_name, unsigned int comp=0) const
 
const T & coupledNodalDot (const std::string &var_name, unsigned int comp=0) const
 
virtual const VariableValuecoupledNodalDotDot (const std::string &var_name, unsigned int comp=0) const
 
virtual const VariableValuecoupledNodalDotOld (const std::string &var_name, unsigned int comp=0) const
 
virtual const VariableValuecoupledNodalDotDotOld (const std::string &var_name, unsigned int comp=0) const
 
virtual const VariableValuecoupledDofValues (const std::string &var_name, unsigned int comp=0) const
 
std::vector< const VariableValue *> coupledAllDofValues (const std::string &var_name) const
 
virtual const VariableValuecoupledDofValuesOld (const std::string &var_name, unsigned int comp=0) const
 
std::vector< const VariableValue *> coupledAllDofValuesOld (const std::string &var_name) const
 
virtual const VariableValuecoupledDofValuesOlder (const std::string &var_name, unsigned int comp=0) const
 
std::vector< const VariableValue *> coupledAllDofValuesOlder (const std::string &var_name) const
 
virtual const ArrayVariableValuecoupledArrayDofValues (const std::string &var_name, unsigned int comp=0) const
 
virtual const ADVariableValueadCoupledDofValues (const std::string &var_name, unsigned int comp=0) const
 
const ADVariableValueadZeroValue () const
 
const ADVariableGradientadZeroGradient () const
 
const ADVariableSecondadZeroSecond () const
 
const GenericVariableValue< is_ad > & genericZeroValue ()
 
const GenericVariableValue< false > & genericZeroValue ()
 
const GenericVariableValue< true > & genericZeroValue ()
 
const GenericVariableGradient< is_ad > & genericZeroGradient ()
 
const GenericVariableGradient< false > & genericZeroGradient ()
 
const GenericVariableGradient< true > & genericZeroGradient ()
 
const GenericVariableSecond< is_ad > & genericZeroSecond ()
 
const GenericVariableSecond< false > & genericZeroSecond ()
 
const GenericVariableSecond< true > & genericZeroSecond ()
 
const MooseVariableFieldBasegetFEVar (const std::string &var_name, unsigned int comp) const
 
const MooseVariableFieldBasegetFieldVar (const std::string &var_name, unsigned int comp) const
 
MooseVariableFieldBasegetFieldVar (const std::string &var_name, unsigned int comp)
 
const T * getVarHelper (const std::string &var_name, unsigned int comp) const
 
T * getVarHelper (const std::string &var_name, unsigned int comp)
 
MooseVariablegetVar (const std::string &var_name, unsigned int comp)
 
const MooseVariablegetVar (const std::string &var_name, unsigned int comp) const
 
VectorMooseVariablegetVectorVar (const std::string &var_name, unsigned int comp)
 
const VectorMooseVariablegetVectorVar (const std::string &var_name, unsigned int comp) const
 
ArrayMooseVariablegetArrayVar (const std::string &var_name, unsigned int comp)
 
const ArrayMooseVariablegetArrayVar (const std::string &var_name, unsigned int comp) const
 
std::vector< T > coupledVectorHelper (const std::string &var_name, const Func &func) const
 
void addMooseVariableDependency (MooseVariableFieldBase *var)
 
void addMooseVariableDependency (const std::vector< MooseVariableFieldBase * > &vars)
 
bool hasBoundaryMaterialPropertyHelper (const std::string &prop_name) const
 
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

static std::string meshPropertyName (const std::string &data_name, const std::string &prefix)
 

Protected Attributes

const bool _random_rotations
 generate random rotations when the Euler Angle provider runs out of data (otherwise error out) More...
 
RankFourTensor _C_ijkl
 unrotated elasticity tensor More...
 
const EulerAngleProvider_euler
 object providing the Euler angles More...
 
std::vector< RankFourTensor > & _grain_data
 per grain data More...
 
const int _tracking_step
 The timestep to begin tracking grains. More...
 
const unsigned short _halo_level
 The thickness of the halo surrounding each grain. More...
 
const unsigned short _max_remap_recursion_depth
 Depth of renumbering recursion (a depth of zero means no recursion) More...
 
const unsigned short _n_reserve_ops
 The number of reserved order parameters. More...
 
const std::size_t _reserve_op_index
 The cutoff index where if variable index >= this number, no remapping TO that variable will occur. More...
 
const Real _reserve_op_threshold
 The threshold above (or below) where a grain may be found on a reserve op field. More...
 
const Real _bound_value
 Absolute value of the lower bound used to represent a region not assigned to this grain, used when a grain is remapped to another order parameter. More...
 
const bool _remap
 Inidicates whether remapping should be done or not (remapping is independent of tracking) More...
 
const bool _tolerate_failure
 Indicates whether we should continue after a remap failure (will result in non-physical results) More...
 
NonlinearSystemBase_nl
 A reference to the nonlinear system (used for retrieving solution vectors) More...
 
std::vector< FeatureData_feature_sets_old
 This data structure holds the map of unique grains from the previous time step. More...
 
const PolycrystalUserObjectBase *const _poly_ic_uo
 An optional IC UserObject which can provide initial data structures to this object. More...
 
const short _verbosity_level
 Verbosity level controlling the amount of information printed to the console. More...
 
bool & _first_time
 Boolean to indicate the first time this object executes. More...
 
const bool _error_on_grain_creation
 Boolean to terminate with an error if a new grain is created during the simulation. 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::unordered_map< dof_id_type, 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_primary
 Convenience variable for testing primary rank. More...
 
SubProblem_subproblem
 
FEProblemBase_fe_problem
 
SystemBase_sys
 
const THREAD_ID _tid
 
Assembly_assembly
 
const Moose::CoordinateSystemType_coord_sys
 
const bool _duplicate_initial_execution
 
std::set< std::string > _depend_uo
 
const bool & _enabled
 
MooseApp_app
 
const std::string _type
 
const std::string _name
 
const InputParameters_pars
 
Factory_factory
 
ActionFactory_action_factory
 
const ExecFlagEnum_execute_enum
 
const ExecFlagType_current_execute_flag
 
MooseApp_restartable_app
 
const std::string _restartable_system_name
 
const THREAD_ID _restartable_tid
 
const bool _restartable_read_only
 
FEProblemBase_mci_feproblem
 
FEProblemBase_sc_fe_problem
 
const THREAD_ID _sc_tid
 
const Real_real_zero
 
const VariableValue_scalar_zero
 
const Point & _point_zero
 
MooseApp_pg_moose_app
 
const std::string _prefix
 
const InputParameters_mi_params
 
const std::string _mi_name
 
const MooseObjectName _mi_moose_object_name
 
FEProblemBase_mi_feproblem
 
SubProblem_mi_subproblem
 
const THREAD_ID _mi_tid
 
const Moose::MaterialDataType _material_data_type
 
MaterialData_material_data
 
bool _stateful_allowed
 
bool _get_material_property_called
 
std::vector< std::unique_ptr< PropertyValue > > _default_properties
 
std::unordered_set< unsigned int_material_property_dependencies
 
const MaterialPropertyName _get_suffix
 
const bool _use_interpolated_state
 
const InputParameters_ti_params
 
FEProblemBase_ti_feproblem
 
bool _is_implicit
 
Real_t
 
int_t_step
 
Real_dt
 
Real_dt_old
 
const std::string & _pp_name
 
const PostprocessorValue_current_value
 
const Parallel::Communicator & _communicator
 
std::unordered_map< std::string, std::vector< std::unique_ptr< VariableValue > > > _default_value
 
const InputParameters_c_parameters
 
const std::string & _c_name
 
const std::string & _c_type
 
FEProblemBase_c_fe_problem
 
const SystemBase *const _c_sys
 
std::unordered_map< std::string, std::vector< MooseVariableFieldBase *> > _coupled_vars
 
std::vector< MooseVariableFieldBase *> _coupled_moose_vars
 
std::vector< MooseVariable *> _coupled_standard_moose_vars
 
std::vector< VectorMooseVariable *> _coupled_vector_moose_vars
 
std::vector< ArrayMooseVariable *> _coupled_array_moose_vars
 
std::vector< MooseVariableFV< Real > *> _coupled_standard_fv_moose_vars
 
const std::unordered_map< std::string, std::string > & _new_to_deprecated_coupled_vars
 
bool _c_nodal
 
bool _c_is_implicit
 
const bool _c_allow_element_to_nodal_coupling
 
THREAD_ID _c_tid
 
std::unordered_map< std::string, std::unique_ptr< MooseArray< DualReal > > > _ad_default_value
 
std::unordered_map< std::string, std::unique_ptr< VectorVariableValue > > _default_vector_value
 
std::unordered_map< std::string, std::unique_ptr< ArrayVariableValue > > _default_array_value
 
std::unordered_map< std::string, std::unique_ptr< MooseArray< ADRealVectorValue > > > _ad_default_vector_value
 
VariableValue _default_value_zero
 
VariableGradient _default_gradient
 
MooseArray< ADRealVectorValue_ad_default_gradient
 
MooseArray< ADRealTensorValue_ad_default_vector_gradient
 
VariableSecond _default_second
 
MooseArray< ADRealTensorValue_ad_default_second
 
const VariableValue_zero
 
const VariablePhiValue_phi_zero
 
const MooseArray< DualReal > & _ad_zero
 
const VariableGradient_grad_zero
 
const MooseArray< ADRealVectorValue > & _ad_grad_zero
 
const VariablePhiGradient_grad_phi_zero
 
const VariableSecond_second_zero
 
const MooseArray< ADRealTensorValue > & _ad_second_zero
 
const VariablePhiSecond_second_phi_zero
 
const VectorVariableValue_vector_zero
 
const VectorVariableCurl_vector_curl_zero
 
VectorVariableValue _default_vector_value_zero
 
VectorVariableGradient _default_vector_gradient
 
VectorVariableCurl _default_vector_curl
 
ArrayVariableValue _default_array_value_zero
 
ArrayVariableGradient _default_array_gradient
 
ArrayVariableCurl _default_array_curl
 
bool _coupleable_neighbor
 

Static Protected Attributes

static const std::string _interpolated_old
 
static const std::string _interpolated_older
 

Detailed Description

Manage a list of elasticity tensors for the grains.

Definition at line 20 of file GrainTrackerElasticity.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.

129  : unsigned char
130  {
131  NONE = 0x0,
132  ANY_BOUNDARY = 0x1,
133  PRIMARY_PERCOLATION_BOUNDARY = 0x2,
134  SECONDARY_PERCOLATION_BOUNDARY = 0x4,
135  SPECIFIED_BOUNDARY = 0x8
136  };
NONE

◆ FieldType

enum FeatureFloodCount::FieldType
stronginherited
Enumerator
UNIQUE_REGION 
VARIABLE_COLORING 
GHOSTED_ENTITIES 
HALOS 
CENTROID 
ACTIVE_BOUNDS 
INTERSECTS_SPECIFIED_BOUNDARY 

Definition at line 102 of file FeatureFloodCount.h.

103  {
104  UNIQUE_REGION,
105  VARIABLE_COLORING,
106  GHOSTED_ENTITIES,
107  HALOS,
108  CENTROID,
109  ACTIVE_BOUNDS,
110  INTERSECTS_SPECIFIED_BOUNDARY,
111  };

◆ RemapCacheMode

enum GrainTracker::RemapCacheMode
stronginherited
Enumerator
FILL 
USE 
BYPASS 

Definition at line 51 of file GrainTracker.h.

52  {
53  FILL,
54  USE,
55  BYPASS
56  };

◆ 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.

120  : unsigned char
121  {
122  CLEAR = 0x0,
123  MARKED = 0x1,
124  DIRTY = 0x2,
125  INACTIVE = 0x4
126  };

Constructor & Destructor Documentation

◆ GrainTrackerElasticity()

GrainTrackerElasticity::GrainTrackerElasticity ( const InputParameters parameters)

Definition at line 33 of file GrainTrackerElasticity.C.

35  _random_rotations(getParam<bool>("random_rotations")),
36  _C_ijkl(getParam<std::vector<Real>>("C_ijkl"),
37  getParam<MooseEnum>("fill_method").getEnum<RankFourTensor::FillMethod>()),
38  _euler(getUserObject<EulerAngleProvider>("euler_angle_provider"))
39 {
40 }
const bool _random_rotations
generate random rotations when the Euler Angle provider runs out of data (otherwise error out) ...
const T & getParam(const std::string &name) const
RankFourTensor _C_ijkl
unrotated elasticity tensor
const EulerAngleProvider & _euler
object providing the Euler angles
const InputParameters & parameters() const

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 1819 of file FeatureFloodCount.C.

Referenced by FeatureFloodCount::prepareDataForTransfer().

1820 {
1821  if (_is_elemental)
1822  {
1823  for (auto entity : feature._local_ids)
1824  {
1825  Elem * elem = _mesh.elemPtr(entity);
1826 
1827  for (const auto node_n : make_range(elem->n_nodes()))
1828  {
1829  auto iters = _periodic_node_map.equal_range(elem->node_id(node_n));
1830 
1831  for (auto it = iters.first; it != iters.second; ++it)
1832  {
1833  feature._periodic_nodes.insert(feature._periodic_nodes.end(), it->first);
1834  feature._periodic_nodes.insert(feature._periodic_nodes.end(), it->second);
1835  }
1836  }
1837  }
1838  }
1839  else
1840  {
1841  for (auto entity : feature._local_ids)
1842  {
1843  auto iters = _periodic_node_map.equal_range(entity);
1844 
1845  for (auto it = iters.first; it != iters.second; ++it)
1846  {
1847  feature._periodic_nodes.insert(feature._periodic_nodes.end(), it->first);
1848  feature._periodic_nodes.insert(feature._periodic_nodes.end(), it->second);
1849  }
1850  }
1851  }
1852 
1853  // TODO: Remove duplicates
1854 }
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 ...
virtual Elem * elemPtr(const dof_id_type i)
const bool _is_elemental
Determines if the flood counter is elements or not (nodes)
IntRange< T > make_range(T beg, T end)
MooseMesh & _mesh
A reference to the mesh.

◆ areFeaturesMergeable()

bool FeatureFloodCount::areFeaturesMergeable ( const FeatureData f1,
const FeatureData f2 
) const
protectedvirtualinherited

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 in PolycrystalUserObjectBase.

Definition at line 1276 of file FeatureFloodCount.C.

Referenced by FeatureFloodCount::mergeSets().

1277 {
1278  return f1.mergeable(f2);
1279 }

◆ assignGrains()

void GrainTracker::assignGrains ( )
protectedinherited

When the tracking phase starts (_t_step == _tracking_step) it assigns a unique id to every FeatureData object found by the FeatureFloodCount object.

We need to assign grainIDs to get the simulation going. We'll use the default sorting that doesn't require valid grainIDs (relies on _min_entity_id and _var_index). These will be the unique grain numbers that we must track for remainder of the simulation.

Definition at line 451 of file GrainTracker.C.

Referenced by GrainTracker::finalize().

452 {
453  mooseAssert(_first_time, "assignGrains may only be called on the first tracking step");
454 
460  if (_is_primary)
461  {
462  // Find the largest grain ID, this requires sorting if the ID is not already set
463  sortAndLabel();
464 
465  if (_feature_sets.empty())
466  {
469  }
470  else
471  {
472  _max_curr_grain_id = _feature_sets.back()._id;
474  }
475 
476  for (auto & grain : _feature_sets)
477  grain._status = Status::MARKED; // Mark the grain
478 
479  } // is_primary
480 
481  /*************************************************************
482  ****************** COLLECTIVE WORK SECTION ******************
483  *************************************************************/
484 
485  // Make IDs on all non-primary ranks consistent
487 
488  // Build up an id to index map
491 
492  // Now trigger the newGrainCreated() callback on all ranks
494  for (unsigned int new_id = 0; new_id <= _max_curr_grain_id; ++new_id)
495  newGrainCreated(new_id);
496 }
bool & _first_time
Boolean to indicate the first time this object executes.
Definition: GrainTracker.h:230
std::vector< FeatureData > & _feature_sets
The data structure used to hold the globally unique features.
const bool _is_primary
Convenience variable for testing primary rank.
const Parallel::Communicator & _communicator
unsigned int & _max_curr_grain_id
Holds the next "regular" grain ID (a grain found or remapped to the standard op vars) ...
Definition: GrainTracker.h:247
void sortAndLabel()
Sort and assign ids to features based on their position in the container after sorting.
static const unsigned int invalid_id
void broadcast(T &data, const unsigned int root_id=0, const bool identical_sizes=false) const
unsigned int _reserve_grain_first_index
Holds the first unique grain index when using _reserve_op (all the remaining indices are sequential) ...
Definition: GrainTracker.h:241
void buildFeatureIdToLocalIndices(unsigned int max_id)
This method builds a lookup map for retrieving the right local feature (by index) given a global inde...
void scatterAndUpdateRanks()
Calls buildLocalToGlobalIndices to build the individual local to global indicies for each rank and sc...
virtual void newGrainCreated(unsigned int new_grain_id)
This method is called when a new grain is detected.
Definition: GrainTracker.C:877

◆ attemptGrainRenumber()

bool GrainTracker::attemptGrainRenumber ( FeatureData grain,
unsigned int  depth,
unsigned int  max_depth 
)
protectedinherited

This is the recursive part of the remapping algorithm.

It attempts to remap a grain to a new index and recurses until max_depth is reached.

We have two grains that are getting close represented by the same order parameter. We need to map to the variable whose closest grain to this one is furthest away by bounding region to bounding region distance.

We have a vector of the distances to the closest grains represented by each of our variables. We just need to pick a suitable grain to replace with. We will start with the maximum of this this list: (max of the mins), but will settle for next to largest and so forth as we make more attempts at remapping grains. This is a graph coloring problem so more work will be required to optimize this process.

Note: We don't have an explicit check here to avoid remapping a variable to itself. This is unnecessary since the min_distance of a variable is explicitly set up above.

If we get to this case and the best distance is less than -1, we are in big trouble. This means that grains represented by all of the remaining order parameters are overlapping this one in at least two places. We'd have to maintain multiple recursive chains, or just start over from scratch... Let's just return false and see if there is another remapping option.

Propose a new variable index for the current grain and recurse. We don't need to mark the status as DIRTY here since the recursion may fail. For now, we'll just add MARKED to the status.

Definition at line 1252 of file GrainTracker.C.

Referenced by GrainTracker::remapGrains().

1253 {
1254  // End the recursion of our breadth first search
1255  if (depth > max_depth)
1256  return false;
1257 
1258  std::size_t curr_var_index = grain._var_index;
1259 
1260  std::vector<std::map<Node *, CacheValues>> cache;
1261 
1262  std::vector<std::list<GrainDistance>> min_distances(_vars.size());
1263 
1269  computeMinDistancesFromGrain(grain, min_distances);
1270 
1281  // clang-format off
1282  std::sort(min_distances.begin(), min_distances.end(),
1283  [](const std::list<GrainDistance> & lhs, const std::list<GrainDistance> & rhs)
1284  {
1285  // Sort lists in reverse order (largest distance first)
1286  // These empty cases are here to make this comparison stable
1287  if (lhs.empty())
1288  return false;
1289  else if (rhs.empty())
1290  return true;
1291  else
1292  return lhs.begin()->_distance > rhs.begin()->_distance;
1293  });
1294  // clang-format on
1295 
1296  for (auto & list_ref : min_distances)
1297  {
1298  const auto target_it = list_ref.begin();
1299  if (target_it == list_ref.end())
1300  continue;
1301 
1302  // If the distance is positive we can just remap and be done
1303  if (target_it->_distance > 0)
1304  {
1305  if (_verbosity_level > 0)
1306  {
1307  _console << COLOR_GREEN << "- Depth " << depth << ": Remapping grain #" << grain._id
1308  << " from variable index " << curr_var_index << " to " << target_it->_var_index;
1309  if (target_it->_distance == std::numeric_limits<Real>::max())
1310  _console << " which currently contains zero grains.\n\n" << COLOR_DEFAULT;
1311  else
1312  _console << " whose closest grain (#" << target_it->_grain_id << ") is at a distance of "
1313  << std::sqrt(target_it->_distance) << "\n\n"
1314  << COLOR_DEFAULT;
1315  }
1316 
1317  grain._status |= Status::DIRTY;
1318  grain._var_index = target_it->_var_index;
1319  return true;
1320  }
1321 
1322  // If the distance isn't positive we just need to make sure that none of the grains represented
1323  // by the target variable index would intersect this one if we were to remap
1324  {
1325  auto next_target_it = target_it;
1326  bool intersection_hit = false;
1327  unsigned short num_close_targets = 0;
1328  std::ostringstream oss;
1329  while (!intersection_hit && next_target_it != list_ref.end())
1330  {
1331  if (next_target_it->_distance > 0)
1332  break;
1333 
1334  mooseAssert(next_target_it->_grain_index < _feature_sets.size(),
1335  "Error in indexing target grain in attemptGrainRenumber");
1336  FeatureData & next_target_grain = _feature_sets[next_target_it->_grain_index];
1337 
1338  // If any grains touch we're done here
1339  if (grain.halosIntersect(next_target_grain))
1340  intersection_hit = true;
1341  else
1342  {
1343  if (num_close_targets > 0)
1344  oss << ", "; // delimiter
1345  oss << "#" << next_target_it->_grain_id;
1346  }
1347 
1348  ++next_target_it;
1349  ++num_close_targets;
1350  }
1351 
1352  if (!intersection_hit)
1353  {
1354  if (_verbosity_level > 0)
1355  {
1356  _console << COLOR_GREEN << "- Depth " << depth << ": Remapping grain #" << grain._id
1357  << " from variable index " << curr_var_index << " to " << target_it->_var_index;
1358 
1359  if (num_close_targets == 1)
1360  _console << " whose closest grain (" << oss.str()
1361  << ") is inside our bounding box but whose halo is not touching.\n\n"
1362  << COLOR_DEFAULT;
1363  else
1364  _console << " whose closest grains (" << oss.str()
1365  << ") are inside our bounding box but whose halos are not touching.\n\n"
1366  << COLOR_DEFAULT;
1367  }
1368 
1369  grain._status |= Status::DIRTY;
1370  grain._var_index = target_it->_var_index;
1371  return true;
1372  }
1373  }
1374 
1375  // If we reach this part of the loop, there is no simple renumbering that can be done.
1376  mooseAssert(target_it->_grain_index < _feature_sets.size(),
1377  "Error in indexing target grain in attemptGrainRenumber");
1378  FeatureData & target_grain = _feature_sets[target_it->_grain_index];
1379 
1387  if (target_it->_distance < -1)
1388  return false;
1389 
1390  // Make sure this grain isn't marked. If it is, we can't recurse here
1391  if ((target_grain._status & Status::MARKED) == Status::MARKED)
1392  return false;
1393 
1399  grain._var_index = target_it->_var_index;
1400  grain._status |= Status::MARKED;
1401  if (attemptGrainRenumber(target_grain, depth + 1, max_depth))
1402  {
1403  // SUCCESS!
1404  if (_verbosity_level > 0)
1405  _console << COLOR_GREEN << "- Depth " << depth << ": Remapping grain #" << grain._id
1406  << " from variable index " << curr_var_index << " to " << target_it->_var_index
1407  << "\n\n"
1408  << COLOR_DEFAULT;
1409 
1410  // Now we need to mark the grain as DIRTY since the recursion succeeded.
1411  grain._status |= Status::DIRTY;
1412  return true;
1413  }
1414  else
1415  // FAILURE, We need to set our var index back after failed recursive step
1416  grain._var_index = curr_var_index;
1417 
1418  // ALWAYS "unmark" (or clear the MARKED status) after recursion so it can be used by other remap
1419  // operations
1420  grain._status &= ~Status::MARKED;
1421  }
1422 
1423  return false;
1424 }
Status
This enumeration is used to indicate status of the grains in the _unique_grains data structure...
std::vector< FeatureData > & _feature_sets
The data structure used to hold the globally unique features.
ADRealEigenVector< T, D, asd > sqrt(const ADRealEigenVector< T, D, asd > &)
std::vector< MooseVariable * > _vars
The vector of coupled in variables cast to MooseVariable.
void computeMinDistancesFromGrain(FeatureData &grain, std::vector< std::list< GrainDistance >> &min_distances)
Populates and sorts a min_distances vector with the minimum distances to all grains in the simulation...
const short _verbosity_level
Verbosity level controlling the amount of information printed to the console.
Definition: GrainTracker.h:224
bool attemptGrainRenumber(FeatureData &grain, unsigned int depth, unsigned int max_depth)
This is the recursive part of the remapping algorithm.
const ConsoleStream _console

◆ boundingRegionDistance()

Real GrainTracker::boundingRegionDistance ( std::vector< BoundingBox > &  bboxes1,
std::vector< BoundingBox > &  bboxes2 
) const
protectedinherited

This method returns the minimum periodic distance between two vectors of bounding boxes.

If the bounding boxes overlap the result is always -1.0.

The region that each grain covers is represented by a bounding box large enough to encompassing all the points within that grain. When using periodic boundaries, we may have several discrete "pieces" of a grain each represented by a bounding box. The distance between any two grains is defined as the minimum distance between any pair of boxes, one selected from each grain.

Definition at line 1736 of file GrainTracker.C.

Referenced by GrainTracker::computeMinDistancesFromGrain().

1738 {
1745  auto min_distance = std::numeric_limits<Real>::max();
1746  for (const auto & bbox1 : bboxes1)
1747  {
1748  for (const auto & bbox2 : bboxes2)
1749  {
1750  // AABB squared distance
1751  Real curr_distance = 0.0;
1752  bool boxes_overlap = true;
1753  for (unsigned int dim = 0; dim < LIBMESH_DIM; ++dim)
1754  {
1755  const auto & min1 = bbox1.min()(dim);
1756  const auto & max1 = bbox1.max()(dim);
1757  const auto & min2 = bbox2.min()(dim);
1758  const auto & max2 = bbox2.max()(dim);
1759 
1760  if (min1 > max2)
1761  {
1762  const auto delta = max2 - min1;
1763  curr_distance += delta * delta;
1764  boxes_overlap = false;
1765  }
1766  else if (min2 > max1)
1767  {
1768  const auto delta = max1 - min2;
1769  curr_distance += delta * delta;
1770  boxes_overlap = false;
1771  }
1772  }
1773 
1774  if (boxes_overlap)
1775  return -1.0; /* all overlaps are treated the same */
1776 
1777  if (curr_distance < min_distance)
1778  min_distance = curr_distance;
1779  }
1780  }
1781 
1782  return min_distance;
1783 }
unsigned int dim
int delta(unsigned int i, unsigned int j)
Delta function, which returns zero if $i j$ and unity if $i=j$.
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

◆ broadcastAndUpdateGrainData()

void GrainTracker::broadcastAndUpdateGrainData ( )
protectedinherited

Broadcast essential Grain information to all processors.

This method is used to get certain attributes like centroids distributed and whether or not a grain intersects a boundary updated.

Definition at line 388 of file GrainTracker.C.

Referenced by GrainTracker::finalize().

389 {
390  TIME_SECTION("broadcastAndUpdateGrainData", 3, "Broadcasting and Updating Grain Data");
391 
392  std::vector<PartialFeatureData> root_feature_data;
393  std::vector<std::string> send_buffer(1), recv_buffer;
394 
395  if (_is_primary)
396  {
397  root_feature_data.reserve(_feature_sets.size());
398 
399  // Populate a subset of the information in a small data structure
400  std::transform(_feature_sets.begin(),
401  _feature_sets.end(),
402  std::back_inserter(root_feature_data),
403  [](FeatureData & feature)
404  {
405  PartialFeatureData partial_feature;
406  partial_feature.boundary_intersection = feature._boundary_intersection;
407  partial_feature.id = feature._id;
408  partial_feature.centroid = feature._centroid;
409  partial_feature.status = feature._status;
410  return partial_feature;
411  });
412 
413  std::ostringstream oss;
414  dataStore(oss, root_feature_data, this);
415  send_buffer[0].assign(oss.str());
416  }
417 
418  // Broadcast the data to all ranks
419  _communicator.broadcast_packed_range((void *)(nullptr),
420  send_buffer.begin(),
421  send_buffer.end(),
422  (void *)(nullptr),
423  std::back_inserter(recv_buffer));
424 
425  // Unpack and update
426  if (!_is_primary)
427  {
428  std::istringstream iss;
429  iss.str(recv_buffer[0]);
430  iss.clear();
431 
432  dataLoad(iss, root_feature_data, this);
433 
434  for (const auto & partial_data : root_feature_data)
435  {
436  // See if this processor has a record of this grain
437  if (partial_data.id < _feature_id_to_local_index.size() &&
438  _feature_id_to_local_index[partial_data.id] != invalid_size_t)
439  {
440  auto & grain = _feature_sets[_feature_id_to_local_index[partial_data.id]];
441  grain._boundary_intersection = partial_data.boundary_intersection;
442  grain._centroid = partial_data.centroid;
443  if (partial_data.status == Status::INACTIVE)
444  grain._status = Status::INACTIVE;
445  }
446  }
447  }
448 }
void broadcast_packed_range(const Context *context1, Iter range_begin, const Iter range_end, OutputContext *context2, OutputIter out, const unsigned int root_id=0, std::size_t approx_buffer_size=1000000) const
static const std::size_t invalid_size_t
std::vector< FeatureData > & _feature_sets
The data structure used to hold the globally unique features.
const bool _is_primary
Convenience variable for testing primary rank.
const Parallel::Communicator & _communicator
void dataLoad(std::istream &stream, GrainTracker::PartialFeatureData &feature, void *context)
Definition: GrainTracker.C:38
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) ...
void dataStore(std::ostream &stream, GrainTracker::PartialFeatureData &feature, void *context)
Definition: GrainTracker.C:28

◆ 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 660 of file FeatureFloodCount.C.

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

661 {
662  _feature_id_to_local_index.assign(max_id + 1, invalid_size_t);
663  for (const auto feature_index : index_range(_feature_sets))
664  {
665  if (_feature_sets[feature_index]._status != Status::INACTIVE)
666  {
667  mooseAssert(_feature_sets[feature_index]._id <= max_id,
668  "Feature ID out of range(" << _feature_sets[feature_index]._id << ')');
669  _feature_id_to_local_index[_feature_sets[feature_index]._id] = feature_index;
670  }
671  }
672 }
static const std::size_t invalid_size_t
std::vector< FeatureData > & _feature_sets
The data structure used to hold the globally unique features.
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) ...
auto index_range(const T &sizable)

◆ 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 primary rank. e.g. [ ... n_0 ] [ ... n_1 ] ... [ ... n_m ]

It is intended to be overridden in derived classes.

Definition at line 614 of file FeatureFloodCount.C.

Referenced by FeatureFloodCount::scatterAndUpdateRanks().

616 {
617  mooseAssert(_is_primary, "This method must only be called on the root processor");
618 
619  counts.assign(_n_procs, 0);
620  // Now size the individual counts vectors based on the largest index seen per processor
621  for (const auto & feature : _feature_sets)
622  for (const auto & local_index_pair : feature._orig_ids)
623  {
624  // local_index_pair.first = ranks, local_index_pair.second = local_index
625  mooseAssert(local_index_pair.first < _n_procs, "Processor ID is out of range");
626  if (local_index_pair.second >= static_cast<std::size_t>(counts[local_index_pair.first]))
627  counts[local_index_pair.first] = local_index_pair.second + 1;
628  }
629 
630  // Build the offsets vector
631  unsigned int globalsize = 0;
632  std::vector<int> offsets(_n_procs); // Type is signed for use with the MPI API
633  for (const auto i : index_range(offsets))
634  {
635  offsets[i] = globalsize;
636  globalsize += counts[i];
637  }
638 
639  // Finally populate the primary vector
640  local_to_global_all.resize(globalsize, FeatureFloodCount::invalid_size_t);
641  for (const auto & feature : _feature_sets)
642  {
643  // Get the local indices from the feature and build a map
644  for (const auto & local_index_pair : feature._orig_ids)
645  {
646  auto rank = local_index_pair.first;
647  mooseAssert(rank < _n_procs, rank << ", " << _n_procs);
648 
649  auto local_index = local_index_pair.second;
650  auto stacked_local_index = offsets[rank] + local_index;
651 
652  mooseAssert(stacked_local_index < globalsize,
653  "Global index: " << stacked_local_index << " is out of range");
654  local_to_global_all[stacked_local_index] = feature._id;
655  }
656  }
657 }
static const std::size_t invalid_size_t
std::vector< FeatureData > & _feature_sets
The data structure used to hold the globally unique features.
const bool _is_primary
Convenience variable for testing primary rank.
const processor_id_type _n_procs
Convenience variable holding the number of processors in this simulation.
auto index_range(const T &sizable)

◆ centroidRegionDistance()

Real GrainTracker::centroidRegionDistance ( std::vector< BoundingBox > &  bboxes1,
std::vector< BoundingBox > &  bboxes2 
) const
protectedinherited

This method returns the minimum periodic distance between the centroids of two vectors of bounding boxes.

Find the minimum centroid distance between any to pieces of the grains.

Definition at line 1709 of file GrainTracker.C.

Referenced by GrainTracker::trackGrains().

1711 {
1715  auto min_distance = std::numeric_limits<Real>::max();
1716  for (const auto & bbox1 : bboxes1)
1717  {
1718  const auto centroid_point1 = (bbox1.max() + bbox1.min()) / 2.0;
1719 
1720  for (const auto & bbox2 : bboxes2)
1721  {
1722  const auto centroid_point2 = (bbox2.max() + bbox2.min()) / 2.0;
1723 
1724  // Here we'll calculate a distance between the centroids
1725  auto curr_distance = _mesh.minPeriodicDistance(_var_number, centroid_point1, centroid_point2);
1726 
1727  if (curr_distance < min_distance)
1728  min_distance = curr_distance;
1729  }
1730  }
1731 
1732  return min_distance;
1733 }
unsigned long _var_number
This variable is used to build the periodic node map.
Real minPeriodicDistance(unsigned int nonlinear_var_num, Point p, Point q) const
MooseMesh & _mesh
A reference to the mesh.

◆ clearDataStructures()

void FeatureFloodCount::clearDataStructures ( )
protectedvirtualinherited

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

Definition at line 316 of file FeatureFloodCount.C.

Referenced by FeatureFloodCount::communicateAndMerge().

317 {
318 }

◆ 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 primary processor where final consolidation will occur.

Send the data from all processors to the first 'n_merging_procs' 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 objects rely on having the original 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 403 of file FeatureFloodCount.C.

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

404 {
405  TIME_SECTION("communicateAndMerge", 3, "Communicating and Merging");
406 
407  // First we need to transform the raw data into a usable data structure
409 
417  std::vector<std::string> send_buffers(1);
418 
425  std::vector<std::string> recv_buffers, deserialize_buffers;
426 
433  const auto n_merging_procs = numberOfDistributedMergeHelpers();
434 
435  if (n_merging_procs > 1)
436  {
437  auto rank = processor_id();
438  bool is_merging_processor = rank < n_merging_procs;
439 
440  if (is_merging_processor)
441  recv_buffers.reserve(_app.n_processors());
442 
443  for (const auto i : make_range(n_merging_procs))
444  {
445  serialize(send_buffers[0], i);
446 
452  (void *)(nullptr),
453  send_buffers.begin(),
454  send_buffers.end(),
455  std::back_inserter(recv_buffers));
456 
463  if (rank == i)
464  recv_buffers.swap(deserialize_buffers);
465  else
466  recv_buffers.clear();
467  }
468 
469  // Setup a new communicator for doing merging communication operations
470  Parallel::Communicator merge_comm;
471 
472  _communicator.split(is_merging_processor ? 0 : MPI_UNDEFINED, rank, merge_comm);
473 
474  if (is_merging_processor)
475  {
483  std::vector<std::list<FeatureData>> tmp_data(_partial_feature_sets.size());
484  tmp_data.swap(_partial_feature_sets);
485 
486  deserialize(deserialize_buffers, processor_id());
487 
488  send_buffers[0].clear();
489  recv_buffers.clear();
490  deserialize_buffers.clear();
491 
492  // Merge one variable's worth of data
493  mergeSets();
494 
495  // Now we need to serialize again to send to the primary (only the processors who did work)
496  serialize(send_buffers[0]);
497 
498  // Free up as much memory as possible here before we do global communication
500 
505  merge_comm.gather_packed_range(0,
506  (void *)(nullptr),
507  send_buffers.begin(),
508  send_buffers.end(),
509  std::back_inserter(recv_buffers));
510 
511  if (_is_primary)
512  {
513  // The root process now needs to deserialize all of the data
514  deserialize(recv_buffers);
515 
516  send_buffers[0].clear();
517  recv_buffers.clear();
518 
519  consolidateMergedFeatures(&tmp_data);
520  }
521  else
522  // Restore our original data on non-zero ranks
523  tmp_data.swap(_partial_feature_sets);
524  }
525  }
526 
527  // Serialized merging (primary does all the work)
528  else
529  {
530  if (_is_primary)
531  recv_buffers.reserve(_app.n_processors());
532 
533  serialize(send_buffers[0]);
534 
535  // Free up as much memory as possible here before we do global communication
537 
543  (void *)(nullptr),
544  send_buffers.begin(),
545  send_buffers.end(),
546  std::back_inserter(recv_buffers));
547 
548  if (_is_primary)
549  {
550  // The root process now needs to deserialize all of the data
551  deserialize(recv_buffers);
552  recv_buffers.clear();
553 
554  mergeSets();
555 
557  }
558  }
559 
560  if (!_is_primary)
562 
563  // Make sure that feature count is communicated to all ranks
565 }
void gather_packed_range(const unsigned int root_id, Context *context, Iter range_begin, const Iter range_end, OutputIter out, std::size_t approx_buffer_size=1000000) const
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 communicati...
const bool _is_primary
Convenience variable for testing primary rank.
const Parallel::Communicator & _communicator
virtual 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_s...
processor_id_type n_processors() const
virtual void clearDataStructures()
Helper routine for clearing up data structures during initialize and prior to parallel communication...
virtual processor_id_type numberOfDistributedMergeHelpers() const
Returns a number indicating the number of merge helpers when running in parallel based on certain imp...
void split(int color, int key, Communicator &target) const
unsigned int _feature_count
The number of features seen by this object (same as summing _feature_counts_per_map) ...
void broadcast(T &data, const unsigned int root_id=0, const bool identical_sizes=false) const
virtual void mergeSets()
This routine is called on the primary rank only and stitches together the partial feature pieces seen...
std::vector< std::list< FeatureData > > _partial_feature_sets
The data structure used to hold partial and communicated feature data, during the discovery and mergi...
virtual void restoreOriginalDataStructures(std::vector< std::list< FeatureData >> &)
IntRange< T > make_range(T beg, T end)
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 seri...
processor_id_type processor_id() const
virtual void prepareDataForTransfer()
This routine uses the local flooded data to build up the local feature data structures (_partial feat...

◆ communicateHaloMap()

void GrainTracker::communicateHaloMap ( )
protectedinherited

Finally remove halo markings from interior regions. This step is necessary because we expand halos before we do communication but that expansion can and will likely go into the interior of the grain (from a single processor's perspective). We could expand halos after merging, but that would likely be less scalable.

Definition at line 1624 of file GrainTracker.C.

Referenced by GrainTracker::updateFieldInfo().

1625 {
1626  if (_compute_halo_maps)
1627  {
1628  // rank var_index entity_id
1629  std::vector<std::pair<std::size_t, dof_id_type>> halo_ids_all;
1630 
1631  std::vector<int> counts;
1632  std::vector<std::pair<std::size_t, dof_id_type>> local_halo_ids;
1633  std::size_t counter = 0;
1634 
1635  const bool isDistributedMesh = _mesh.isDistributedMesh();
1636 
1637  if (_is_primary)
1638  {
1639  std::vector<std::vector<std::pair<std::size_t, dof_id_type>>> root_halo_ids(_n_procs);
1640  counts.resize(_n_procs);
1641 
1642  // Loop over the _halo_ids "field" and build minimal lists for all of the other ranks
1643  for (const auto var_index : index_range(_halo_ids))
1644  {
1645  for (const auto & entity_pair : _halo_ids[var_index])
1646  {
1647  auto entity_id = entity_pair.first;
1648  if (isDistributedMesh)
1649  {
1650  // Check to see which contiguous range this entity ID falls into
1651  auto range_it =
1652  std::lower_bound(_all_ranges.begin(),
1653  _all_ranges.end(),
1654  entity_id,
1655  [](const std::pair<dof_id_type, dof_id_type> range,
1656  dof_id_type entity_id) { return range.second < entity_id; });
1657 
1658  mooseAssert(range_it != _all_ranges.end(), "No range round?");
1659 
1660  // Recover the index from the iterator
1661  auto proc_id = std::distance(_all_ranges.begin(), range_it);
1662 
1663  // Now add this halo entity to the map for the corresponding proc to scatter latter
1664  root_halo_ids[proc_id].push_back(std::make_pair(var_index, entity_id));
1665  }
1666  else
1667  {
1668  DofObject * halo_entity;
1669  if (_is_elemental)
1670  halo_entity = _mesh.queryElemPtr(entity_id);
1671  else
1672  halo_entity = _mesh.queryNodePtr(entity_id);
1673 
1674  if (halo_entity)
1675  root_halo_ids[halo_entity->processor_id()].push_back(
1676  std::make_pair(var_index, entity_id));
1677  }
1678  }
1679  }
1680 
1681  // Build up the counts vector for MPI scatter
1682  for (const auto & vector_ref : root_halo_ids)
1683  {
1684  std::copy(vector_ref.begin(), vector_ref.end(), std::back_inserter(halo_ids_all));
1685  counts[counter] = vector_ref.size();
1686  counter++;
1687  }
1688  }
1689 
1690  _communicator.scatter(halo_ids_all, counts, local_halo_ids);
1691 
1692  // Now add the contributions from the root process to the processor local maps
1693  for (const auto & halo_pair : local_halo_ids)
1694  _halo_ids[halo_pair.first].emplace(std::make_pair(halo_pair.second, halo_pair.first));
1695 
1702  for (const auto & grain : _feature_sets)
1703  for (auto local_id : grain._local_ids)
1704  _halo_ids[grain._var_index].erase(local_id);
1705  }
1706 }
void scatter(const std::vector< T, A > &data, T &recv, const unsigned int root_id=0) const
bool isDistributedMesh() const
std::vector< FeatureData > & _feature_sets
The data structure used to hold the globally unique features.
virtual const Node * queryNodePtr(const dof_id_type i) const
const bool _is_primary
Convenience variable for testing primary rank.
const Parallel::Communicator & _communicator
virtual Elem * queryElemPtr(const dof_id_type i)
std::vector< std::map< dof_id_type, int > > _halo_ids
The data structure for looking up halos around features.
const bool _compute_halo_maps
Indicates whether or not to communicate halo map information with all ranks.
std::vector< std::pair< dof_id_type, dof_id_type > > _all_ranges
Data structure to hold element ID ranges when using Distributed Mesh (populated on rank 0 only) ...
Definition: GrainTracker.h:253
const bool _is_elemental
Determines if the flood counter is elements or not (nodes)
const processor_id_type _n_procs
Convenience variable holding the number of processors in this simulation.
MooseMesh & _mesh
A reference to the mesh.
auto index_range(const T &sizable)
uint8_t dof_id_type

◆ 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 1451 of file FeatureFloodCount.C.

Referenced by FeatureFloodCount::isNewFeatureOrConnectedRegion().

1452 {
1453  return ((_use_less_than_threshold_comparison && (entity_value >= threshold)) ||
1454  (!_use_less_than_threshold_comparison && (entity_value <= threshold)));
1455 }
const bool _use_less_than_threshold_comparison
Use less-than when comparing values against the threshold value.

◆ computeMinDistancesFromGrain()

void GrainTracker::computeMinDistancesFromGrain ( FeatureData grain,
std::vector< std::list< GrainDistance >> &  min_distances 
)
protectedinherited

Populates and sorts a min_distances vector with the minimum distances to all grains in the simulation for a given grain.

There are _vars.size() entries in the outer vector, one for each order parameter. A list of grains with the same OP are ordered in lists per OP.

In the diagram below assume we have 4 order parameters. The grain with the asterisk needs to be remapped. All order parameters are used in neighboring grains. For all "touching" grains, the value of the corresponding entry in min_distances will be a negative integer representing the number of immediate neighbors with that order parameter.

Note: Only the first member of the pair (the distance) is shown in the array below. e.g. [-2.0, -max, -1.0, -2.0]

After sorting, variable index 2 (value: -1.0) be at the end of the array and will be the first variable we attempt to renumber the current grain to.

   __       ___
     \  0  /   \
   2  \___/  1  \___
      /   \     /   \
   __/  1  \___/  2  \
     \  *  /   \     /
   3  \___/  3  \___/
      /   \     /
   __/  0  \___/

See if we have any completely open OPs (excluding reserve order parameters) or the order parameter corresponding to this grain, we need to put them in the list or the grain tracker won't realize that those vars are available for remapping.

Definition at line 1178 of file GrainTracker.C.

Referenced by GrainTracker::attemptGrainRenumber().

1180 {
1204  for (const auto i : index_range(_feature_sets))
1205  {
1206  auto & other_grain = _feature_sets[i];
1207 
1208  if (other_grain._var_index == grain._var_index || other_grain._var_index >= _reserve_op_index)
1209  continue;
1210 
1211  auto target_var_index = other_grain._var_index;
1212  auto target_grain_index = i;
1213  auto target_grain_id = other_grain._id;
1214 
1215  Real curr_bbox_diff = boundingRegionDistance(grain._bboxes, other_grain._bboxes);
1216 
1217  GrainDistance grain_distance_obj(
1218  curr_bbox_diff, target_var_index, target_grain_index, target_grain_id);
1219 
1220  // To handle touching halos we penalize the top pick each time we see another
1221  if (curr_bbox_diff == -1.0 && !min_distances[target_var_index].empty())
1222  {
1223  Real last_distance = min_distances[target_var_index].begin()->_distance;
1224  if (last_distance < 0)
1225  grain_distance_obj._distance += last_distance;
1226  }
1227 
1228  // Insertion sort into a list
1229  auto insert_it = min_distances[target_var_index].begin();
1230  while (insert_it != min_distances[target_var_index].end() && !(grain_distance_obj < *insert_it))
1231  ++insert_it;
1232  min_distances[target_var_index].insert(insert_it, grain_distance_obj);
1233  }
1234 
1240  for (const auto var_index : make_range(_reserve_op_index))
1241  {
1242  // Don't put an entry in for matching variable indices (i.e. we can't remap to ourselves)
1243  if (grain._var_index == var_index)
1244  continue;
1245 
1246  if (min_distances[var_index].empty())
1247  min_distances[var_index].emplace_front(std::numeric_limits<Real>::max(), var_index);
1248  }
1249 }
std::vector< FeatureData > & _feature_sets
The data structure used to hold the globally unique features.
This struct is used to hold distance information to other grains in the simulation.
Definition: GrainTracker.h:260
Real boundingRegionDistance(std::vector< BoundingBox > &bboxes1, std::vector< BoundingBox > &bboxes2) const
This method returns the minimum periodic distance between two vectors of bounding boxes...
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
IntRange< T > make_range(T beg, T end)
const std::size_t _reserve_op_index
The cutoff index where if variable index >= this number, no remapping TO that variable will occur...
Definition: GrainTracker.h:192
auto index_range(const T &sizable)

◆ consolidateMergedFeatures()

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

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 1193 of file FeatureFloodCount.C.

Referenced by FeatureFloodCount::communicateAndMerge().

1194 {
1195  TIME_SECTION("consolidateMergedFeatures", 3, "Consolidating Merged Features");
1196 
1205  mooseAssert(_is_primary,
1206  "cosolidateMergedFeatures() may only be called on the primary processor");
1207  mooseAssert(saved_data == nullptr || saved_data->size() == _partial_feature_sets.size(),
1208  "Data structure size mismatch");
1209 
1210  // Offset where the current set of features with the same variable id starts in the flat vector
1211  unsigned int feature_offset = 0;
1212  // Set the member feature count to zero and start counting the actual features
1213  _feature_count = 0;
1214  for (const auto map_num : index_range(_partial_feature_sets))
1215  {
1216  for (auto & feature : _partial_feature_sets[map_num])
1217  {
1218  if (saved_data)
1219  {
1220  for (auto it = (*saved_data)[map_num].begin(); it != (*saved_data)[map_num].end();
1221  /* no increment */)
1222  {
1223  if (feature.canConsolidate(*it))
1224  {
1225  feature.consolidate(std::move(*it));
1226  it = (*saved_data)[map_num].erase(it); // increment
1227  }
1228  else
1229  ++it;
1230  }
1231  }
1232 
1233  // If after merging we still have an inactive feature, discard it
1234  if (feature._status == Status::CLEAR)
1235  {
1236  // First we need to calculate the centroid now that we are doing merging all partial
1237  // features
1238  if (feature._vol_count != 0)
1239  feature._centroid /= feature._vol_count;
1240 
1241  _feature_sets.emplace_back(std::move(feature));
1242  ++_feature_count;
1243  }
1244  }
1245 
1246  // Record the feature numbers just for the current map
1247  _feature_counts_per_map[map_num] = _feature_count - feature_offset;
1248 
1249  // Now update the running feature count so we can calculate the next map's contribution
1250  feature_offset = _feature_count;
1251 
1252  // Clean up the "moved" objects
1253  _partial_feature_sets[map_num].clear();
1254  if (saved_data)
1255  (*saved_data)[map_num].clear();
1256  }
1257 
1258  // We may have resided our data structures for the communicateAndMerge step. We'll restore the
1259  // original size here just in case we need to loop over the assumed size (i.e. _maps_size)
1260  // elsewhere in this or derived objects.
1261  if (_partial_feature_sets.size() != _maps_size)
1262  {
1264 
1267  }
1268 
1273 }
std::vector< FeatureData > & _feature_sets
The data structure used to hold the globally unique features.
const bool _is_primary
Convenience variable for testing primary rank.
const std::size_t _maps_size
Convenience variable holding the size of all the datastructures size by the number of maps...
unsigned int _feature_count
The number of features seen by this object (same as summing _feature_counts_per_map) ...
std::vector< std::list< FeatureData > > _partial_feature_sets
The data structure used to hold partial and communicated feature data, during the discovery and mergi...
std::vector< unsigned int > _feature_counts_per_map
The number of features seen by this object per map.
auto index_range(const T &sizable)

◆ 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 primary 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 1103 of file FeatureFloodCount.C.

Referenced by FeatureFloodCount::communicateAndMerge().

1104 {
1105  // The input string stream used for deserialization
1106  std::istringstream iss;
1107 
1108  auto rank = processor_id();
1109 
1110  for (const auto proc_id : index_range(serialized_buffers))
1111  {
1123  if (var_num == invalid_id && proc_id == rank)
1124  continue;
1125 
1126  iss.str(serialized_buffers[proc_id]); // populate the stream with a new buffer
1127  iss.clear(); // reset the string stream state
1128 
1129  // Load the gathered data into the data structure.
1130  if (var_num == invalid_id)
1131  dataLoad(iss, _partial_feature_sets, this);
1132  else
1133  dataLoad(iss, _partial_feature_sets[var_num], this);
1134  }
1135 }
void dataLoad(std::istream &stream, FeatureFloodCount::FeatureData &feature, void *context)
static const unsigned int invalid_id
std::vector< std::list< FeatureData > > _partial_feature_sets
The data structure used to hold partial and communicated feature data, during the discovery and mergi...
processor_id_type processor_id() const
auto index_range(const T &sizable)

◆ doesFeatureIntersectBoundary()

bool GrainTracker::doesFeatureIntersectBoundary ( unsigned int  feature_id) const
overridevirtualinherited

Returns a Boolean indicating whether this feature intersects any boundary.

Reimplemented from FeatureFloodCount.

Definition at line 175 of file GrainTracker.C.

176 {
177  // TODO: This data structure may need to be turned into a Multimap
178  mooseAssert(feature_id < _feature_id_to_local_index.size(), "Grain ID out of bounds");
179 
180  auto feature_index = _feature_id_to_local_index[feature_id];
181  if (feature_index != invalid_size_t)
182  {
183  mooseAssert(feature_index < _feature_sets.size(), "Grain index out of bounds");
184  return _feature_sets[feature_index]._boundary_intersection != BoundaryIntersection::NONE;
185  }
186 
187  return false;
188 }
static const std::size_t invalid_size_t
std::vector< FeatureData > & _feature_sets
The data structure used to hold the globally unique features.
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) ...

◆ doesFeatureIntersectSpecifiedBoundary()

bool GrainTracker::doesFeatureIntersectSpecifiedBoundary ( unsigned int  feature_id) const
overridevirtualinherited

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

Reimplemented from FeatureFloodCount.

Definition at line 191 of file GrainTracker.C.

192 {
193  // TODO: This data structure may need to be turned into a Multimap
194  mooseAssert(feature_id < _feature_id_to_local_index.size(), "Grain ID out of bounds");
195 
196  auto feature_index = _feature_id_to_local_index[feature_id];
197  if (feature_index != invalid_size_t)
198  {
199  mooseAssert(feature_index < _feature_sets.size(), "Grain index out of bounds");
200  return ((_feature_sets[feature_index]._boundary_intersection &
202  }
203 
204  return false;
205 }
static const std::size_t invalid_size_t
std::vector< FeatureData > & _feature_sets
The data structure used to hold the globally unique features.
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) ...

◆ execute()

void GrainTracker::execute ( )
overridevirtualinherited

Reimplemented from FeatureFloodCount.

Definition at line 273 of file GrainTracker.C.

274 {
275  // Don't track grains if the current simulation step is before the specified tracking step
276  if (_t_step < _tracking_step)
277  return;
278 
279  if (_poly_ic_uo && _first_time)
280  return;
281 
283 }
bool & _first_time
Boolean to indicate the first time this object executes.
Definition: GrainTracker.h:230
const PolycrystalUserObjectBase *const _poly_ic_uo
An optional IC UserObject which can provide initial data structures to this object.
Definition: GrainTracker.h:219
virtual void execute() override
const int _tracking_step
The timestep to begin tracking grains.
Definition: GrainTracker.h:179

◆ 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 1560 of file FeatureFloodCount.C.

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

1561 {
1562  if (num_layers_to_expand == 0)
1563  return;
1564 
1565  TIME_SECTION("expandEdgeHalos", 3, "Expanding Edge Halos");
1566 
1567  for (auto & list_ref : _partial_feature_sets)
1568  {
1569  for (auto & feature : list_ref)
1570  {
1571  for (unsigned short halo_level = 0; halo_level < num_layers_to_expand; ++halo_level)
1572  {
1577  FeatureData::container_type orig_halo_ids(feature._halo_ids);
1578  for (auto entity : orig_halo_ids)
1579  {
1580  if (_is_elemental)
1582  &feature,
1583  /*expand_halos_only =*/true,
1584  /*disjoint_only =*/false);
1585  else
1587  &feature,
1588  /*expand_halos_only =*/true);
1589  }
1590 
1595  FeatureData::container_type disjoint_orig_halo_ids(feature._disjoint_halo_ids);
1596  for (auto entity : disjoint_orig_halo_ids)
1597  {
1598  if (_is_elemental)
1600 
1601  &feature,
1602  /*expand_halos_only =*/true,
1603  /*disjoint_only =*/true);
1604  else
1606 
1607  &feature,
1608  /*expand_halos_only =*/true);
1609  }
1610  }
1611  }
1612  }
1613 }
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...
std::vector< dof_id_type > container_type
The primary underlying container type used to hold the data in each FeatureData.
virtual Elem * elemPtr(const dof_id_type i)
virtual const Node * nodePtr(const dof_id_type i) const
void visitElementalNeighbors(const Elem *elem, FeatureData *feature, bool expand_halos_only, bool disjoint_only)
std::vector< std::list< FeatureData > > _partial_feature_sets
The data structure used to hold partial and communicated feature data, during the discovery and mergi...
const bool _is_elemental
Determines if the flood counter is elements or not (nodes)
MooseMesh & _mesh
A reference to the mesh.

◆ 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 1498 of file FeatureFloodCount.C.

1499 {
1500  const auto & node_to_elem_map = _mesh.nodeToActiveSemilocalElemMap();
1501  FeatureData::container_type expanded_local_ids;
1502  auto my_processor_id = processor_id();
1503 
1510  for (auto & list_ref : _partial_feature_sets)
1511  {
1512  for (auto & feature : list_ref)
1513  {
1514  expanded_local_ids.clear();
1515 
1516  for (auto entity : feature._local_ids)
1517  {
1518  const Elem * elem = _mesh.elemPtr(entity);
1519  mooseAssert(elem, "elem pointer is NULL");
1520 
1521  // Get the nodes on a current element so that we can add in point neighbors
1522  auto n_nodes = elem->n_vertices();
1523  for (const auto i : make_range(n_nodes))
1524  {
1525  const Node * current_node = elem->node_ptr(i);
1526 
1527  auto elem_vector_it = node_to_elem_map.find(current_node->id());
1528  if (elem_vector_it == node_to_elem_map.end())
1529  mooseError("Error in node to elem map");
1530 
1531  const auto & elem_vector = elem_vector_it->second;
1532 
1533  std::copy(elem_vector.begin(),
1534  elem_vector.end(),
1535  std::insert_iterator<FeatureData::container_type>(expanded_local_ids,
1536  expanded_local_ids.end()));
1537 
1538  // Now see which elements need to go into the ghosted set
1539  for (auto entity : elem_vector)
1540  {
1541  const Elem * neighbor = _mesh.elemPtr(entity);
1542  mooseAssert(neighbor, "neighbor pointer is NULL");
1543 
1544  if (neighbor->processor_id() != my_processor_id)
1545  feature._ghosted_ids.insert(feature._ghosted_ids.end(), elem->id());
1546  }
1547  }
1548  }
1549 
1550  // Replace the existing local ids with the expanded local ids
1551  feature._local_ids.swap(expanded_local_ids);
1552 
1553  // Copy the expanded local_ids into the halo_ids container
1554  feature._halo_ids = feature._local_ids;
1555  }
1556  }
1557 }
std::vector< dof_id_type > container_type
The primary underlying container type used to hold the data in each FeatureData.
virtual Elem * elemPtr(const dof_id_type i)
const std::map< dof_id_type, std::vector< dof_id_type > > & nodeToActiveSemilocalElemMap()
const dof_id_type n_nodes
std::vector< std::list< FeatureData > > _partial_feature_sets
The data structure used to hold partial and communicated feature data, during the discovery and mergi...
IntRange< T > make_range(T beg, T end)
void mooseError(Args &&... args) const
MooseMesh & _mesh
A reference to the mesh.
processor_id_type processor_id() const

◆ 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 909 of file FeatureFloodCount.C.

Referenced by FeatureVolumeVectorPostprocessor::execute().

910 {
911  if (feature_id >= _feature_id_to_local_index.size())
912  return invalid_id;
913 
914  auto local_index = _feature_id_to_local_index[feature_id];
915 
916  Real invalid_coord = std::numeric_limits<Real>::max();
917  Point p(invalid_coord, invalid_coord, invalid_coord);
918  if (local_index != invalid_size_t)
919  {
920  mooseAssert(local_index < _feature_sets.size(), "local_index out of bounds");
921  p = _feature_sets[local_index]._centroid;
922  }
923  return p;
924 }
static const std::size_t invalid_size_t
std::vector< FeatureData > & _feature_sets
The data structure used to hold the globally unique features.
static const unsigned int invalid_id
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
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) ...

◆ finalize()

void GrainTracker::finalize ( )
overridevirtualinherited

Assign or Track Grains

Broadcast essential data

Remap Grains

Reimplemented from FeatureFloodCount.

Definition at line 330 of file GrainTracker.C.

331 {
332  // Don't track grains if the current simulation step is before the specified tracking step
333  if (_t_step < _tracking_step)
334  return;
335 
336  TIME_SECTION("finalize", 3, "Finalizing GrainTracker");
337 
338  // Expand the depth of the halos around all grains
339  auto num_halo_layers = _halo_level >= 1
340  ? _halo_level - 1
341  : 0; // The first level of halos already exists so subtract one
342 
343  if (_poly_ic_uo && _first_time)
345  else
346  {
347  expandEdgeHalos(num_halo_layers);
348 
349  // Build up the grain map on the root processor
351  }
352 
356  if (_first_time)
357  assignGrains();
358  else
359  trackGrains();
360 
361  if (_verbosity_level > 1)
362  _console << "Finished inside of trackGrains" << std::endl;
363 
368 
372  if (_remap)
373  remapGrains();
374 
375  updateFieldInfo();
376  if (_verbosity_level > 1)
377  _console << "Finished inside of updateFieldInfo" << std::endl;
378 
379  // Set the first time flag false here (after all methods of finalize() have completed)
380  _first_time = false;
381 
382  // TODO: Release non essential memory
383  if (_verbosity_level > 0)
384  _console << "Finished inside of GrainTracker\n" << std::endl;
385 }
void remapGrains()
This method is called after trackGrains to remap grains that are too close to each other...
Definition: GrainTracker.C:910
void expandEdgeHalos(unsigned int num_layers_to_expand)
This method expands the existing halo set by some width determined by the passed in value...
bool & _first_time
Boolean to indicate the first time this object executes.
Definition: GrainTracker.h:230
void trackGrains()
On subsequent time_steps, incoming FeatureData objects are compared to previous time_step information...
Definition: GrainTracker.C:499
void communicateAndMerge()
This routine handles all of the serialization, communication and deserialization of the data structur...
const PolycrystalUserObjectBase *const _poly_ic_uo
An optional IC UserObject which can provide initial data structures to this object.
Definition: GrainTracker.h:219
virtual void updateFieldInfo() override
This method is used to populate any of the data structures used for storing field data (nodal or elem...
void prepopulateState(const FeatureFloodCount &ffc_object)
This method extracts the necessary state from the passed in object necessary to continue tracking gra...
Definition: GrainTracker.C:298
void broadcastAndUpdateGrainData()
Broadcast essential Grain information to all processors.
Definition: GrainTracker.C:388
const short _verbosity_level
Verbosity level controlling the amount of information printed to the console.
Definition: GrainTracker.h:224
const bool _remap
Inidicates whether remapping should be done or not (remapping is independent of tracking) ...
Definition: GrainTracker.h:204
void assignGrains()
When the tracking phase starts (_t_step == _tracking_step) it assigns a unique id to every FeatureDat...
Definition: GrainTracker.C:451
const ConsoleStream _console
const int _tracking_step
The timestep to begin tracking grains.
Definition: GrainTracker.h:179
const unsigned short _halo_level
The thickness of the halo surrounding each grain.
Definition: GrainTracker.h:182

◆ 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 1327 of file FeatureFloodCount.C.

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

1329 {
1330  // if (dof_object == nullptr || dof_object == libMesh::remote_elem)
1331  // return false;
1332  mooseAssert(dof_object, "DOF object is nullptr");
1333  mooseAssert(_entity_queue.empty(), "Entity queue is not empty when starting a feature");
1334 
1335  // Kick off the exploration of a new feature
1336  _entity_queue.push_front(dof_object);
1337 
1338  bool return_value = false;
1339  FeatureData * feature = nullptr;
1340  while (!_entity_queue.empty())
1341  {
1342  const DofObject * curr_dof_object = _entity_queue.back();
1343  const Elem * elem = _is_elemental ? static_cast<const Elem *>(curr_dof_object) : nullptr;
1344  _entity_queue.pop_back();
1345 
1346  // Retrieve the id of the current entity
1347  auto entity_id = curr_dof_object->id();
1348 
1349  // Has this entity already been marked? - if so move along
1350  if (current_index != invalid_size_t &&
1351  _entities_visited[current_index].find(entity_id) != _entities_visited[current_index].end())
1352  continue;
1353 
1354  // Are we outside of the range we should be working in?
1355  if (_is_elemental && !_dof_map.is_evaluable(*elem))
1356  continue;
1357 
1358  // See if the current entity either starts a new feature or continues an existing feature
1359  auto new_id = invalid_id; // Writable reference to hold an optional id;
1360  Status status =
1361  Status::INACTIVE; // Status is inactive until we find an entity above the starting threshold
1362 
1363  // Make sure that the Assembly object has the right element and subdomain information set
1364  // since we are moving through the mesh in a manual fashion.
1365  if (_is_elemental)
1367 
1368  if (!isNewFeatureOrConnectedRegion(curr_dof_object, current_index, feature, status, new_id))
1369  {
1370  // If we have an active feature, we just found a halo entity
1371  if (feature)
1372  feature->_halo_ids.insert(feature->_halo_ids.end(), entity_id);
1373  continue;
1374  }
1375 
1376  mooseAssert(current_index != invalid_size_t, "current_index is invalid");
1377 
1386  return_value = true;
1387  _entities_visited[current_index].insert(entity_id);
1388 
1389  auto map_num = _single_map_mode ? decltype(current_index)(0) : current_index;
1390 
1391  // New Feature (we need to create it and add it to our data structure)
1392  if (!feature)
1393  {
1394  _partial_feature_sets[map_num].emplace_back(
1395  current_index, _feature_count++, processor_id(), status);
1396 
1397  // Get a handle to the feature we will update (always the last feature in the data structure)
1398  feature = &_partial_feature_sets[map_num].back();
1399 
1400  // If new_id is valid, we'll set it in the feature here.
1401  if (new_id != invalid_id)
1402  feature->_id = new_id;
1403  }
1404 
1405  // Insert the current entity into the local ids data structure
1406  feature->_local_ids.insert(feature->_local_ids.end(), entity_id);
1407 
1413  if (_is_elemental && processor_id() == curr_dof_object->processor_id())
1414  {
1415  // Keep track of how many elements participate in the centroid averaging
1416  feature->_vol_count++;
1417 
1418  // Sum the centroid values for now, we'll average them later
1419  feature->_centroid += elem->vertex_average();
1420 
1421  // // Does the volume intersect the boundary?
1422  // if (_all_boundary_entity_ids.find(elem->id()) != _all_boundary_entity_ids.end())
1423  // feature->_intersects_boundary = true;
1424  }
1425 
1426  if (_is_elemental)
1428  feature,
1429  /*expand_halos_only =*/false,
1430  /*disjoint_only =*/false);
1431  else
1432  visitNodalNeighbors(static_cast<const Node *>(curr_dof_object),
1433  feature,
1434  /*expand_halos_only =*/false);
1435  }
1436 
1437  return return_value;
1438 }
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...
static const std::size_t invalid_size_t
Status
This enumeration is used to indicate status of the grains in the _unique_grains data structure...
std::vector< std::set< dof_id_type > > _entities_visited
This variable keeps track of which nodes have been visited during execution.
MPI_Status status
void visitElementalNeighbors(const Elem *elem, FeatureData *feature, bool expand_halos_only, bool disjoint_only)
const DofMap & _dof_map
Reference to the dof_map containing the coupled variables.
static const unsigned int invalid_id
const bool _single_map_mode
This variable is used to indicate whether or not multiple maps are used during flooding.
unsigned int _feature_count
The number of features seen by this object (same as summing _feature_counts_per_map) ...
virtual void setCurrentSubdomainID(const Elem *elem, const THREAD_ID tid) override
virtual bool isNewFeatureOrConnectedRegion(const DofObject *dof_object, std::size_t &current_index, FeatureData *&feature, Status &status, unsigned int &new_id)
Method called during the recursive flood routine that should return whether or not the current entity...
std::vector< std::list< FeatureData > > _partial_feature_sets
The data structure used to hold partial and communicated feature data, during the discovery and mergi...
const bool _is_elemental
Determines if the flood counter is elements or not (nodes)
FEProblemBase & _fe_problem
processor_id_type processor_id() const
std::deque< const DofObject * > _entity_queue
The data structure for maintaining entities to flood during discovery.

◆ 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 1445 of file FeatureFloodCount.C.

Referenced by FeatureFloodCount::isNewFeatureOrConnectedRegion().

1446 {
1448 }

◆ getCoupledVars()

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

Returns a const vector to the coupled variable pointers.

Definition at line 97 of file FeatureFloodCount.h.

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

97 { return _vars; }
std::vector< MooseVariable * > _vars
The vector of coupled in variables cast to MooseVariable.

◆ getData()

const RankFourTensor & GrainDataTracker< RankFourTensor >::getData ( unsigned int  grain_id) const
inherited

return data for selected grain

Definition at line 45 of file GrainDataTracker.h.

46 {
47  mooseAssert(grain_id < _grain_data.size(), "Requested data for invalid grain index.");
48  return _grain_data[grain_id];
49 }
std::vector< RankFourTensor > & _grain_data
per grain data

◆ getEntityValue()

Real GrainTracker::getEntityValue ( dof_id_type  node_id,
FieldType  field_type,
std::size_t  var_index = 0 
) const
overridevirtualinherited

Reimplemented from FeatureFloodCount.

Definition at line 120 of file GrainTracker.C.

Referenced by OutputEulerAngles::precalculateValue().

123 {
124  if (_t_step < _tracking_step)
125  return 0;
126 
127  return FeatureFloodCount::getEntityValue(entity_id, field_type, var_index);
128 }
const int _tracking_step
The timestep to begin tracking grains.
Definition: GrainTracker.h:179
virtual Real getEntityValue(dof_id_type entity_id, FieldType field_type, std::size_t var_index=0) const

◆ getFeatures()

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

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

Definition at line 328 of file FeatureFloodCount.h.

Referenced by GrainTracker::prepopulateState().

328 { return _feature_sets; }
std::vector< FeatureData > & _feature_sets
The data structure used to hold the globally unique features.

◆ getFeatureVar()

unsigned int GrainTracker::getFeatureVar ( unsigned int  feature_id) const
overridevirtualinherited

Returns the variable representing the passed in feature.

Reimplemented from FeatureFloodCount.

Definition at line 137 of file GrainTracker.C.

138 {
139  return FeatureFloodCount::getFeatureVar(feature_id);
140 }
virtual unsigned int getFeatureVar(unsigned int feature_id) const
Returns the variable representing the passed in feature.

◆ getFECoupledVars()

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

Returns a const vector to the coupled MooseVariableFEBase pointers.

Definition at line 100 of file FeatureFloodCount.h.

Referenced by AverageGrainVolume::AverageGrainVolume().

100 { return _fe_vars; }
std::vector< MooseVariableFEBase * > _fe_vars
The vector of coupled in variables.

◆ getGrainCentroid()

Point GrainTracker::getGrainCentroid ( unsigned int  grain_id) const
overridevirtualinherited

Returns the centroid for the given grain number.

Implements GrainTrackerInterface.

Definition at line 157 of file GrainTracker.C.

158 {
159  mooseAssert(grain_id < _feature_id_to_local_index.size(), "Grain ID out of bounds");
160  auto grain_index = _feature_id_to_local_index[grain_id];
161 
162  if (grain_index != invalid_size_t)
163  {
164  mooseAssert(_feature_id_to_local_index[grain_id] < _feature_sets.size(),
165  "Grain index out of bounds");
166  // Note: This value is parallel consistent, see GrainTracker::broadcastAndUpdateGrainData()
167  return _feature_sets[_feature_id_to_local_index[grain_id]]._centroid;
168  }
169 
170  // Inactive grain
171  return Point();
172 }
static const std::size_t invalid_size_t
std::vector< FeatureData > & _feature_sets
The data structure used to hold the globally unique features.
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) ...

◆ getNewGrainIDs()

std::vector< unsigned int > GrainTracker::getNewGrainIDs ( ) const
overridevirtualinherited

This method returns all of the new ids generated in an invocation of the GrainTracker.

Reimplemented from GrainTrackerInterface.

Definition at line 898 of file GrainTracker.C.

899 {
900  std::vector<unsigned int> new_ids(_max_curr_grain_id - _old_max_grain_id);
901  auto new_id = _old_max_grain_id + 1;
902 
903  // Generate the new ids
904  std::iota(new_ids.begin(), new_ids.end(), new_id);
905 
906  return new_ids;
907 }
unsigned int _old_max_grain_id
The previous max grain id (needed to figure out which ids are new in a given step) ...
Definition: GrainTracker.h:244
unsigned int & _max_curr_grain_id
Holds the next "regular" grain ID (a grain found or remapped to the standard op vars) ...
Definition: GrainTracker.h:247

◆ getNextUniqueID()

unsigned int GrainTracker::getNextUniqueID ( )
protectedinherited

Retrieve the next unique grain number if a new grain is detected during trackGrains.

This method handles reserve order parameter indices properly. Direct access to the next index should be avoided.

Get the next unique grain ID but make sure to respect reserve ids. Note, that the first valid ID for a new grain is _reserve_grain_first_index + _n_reserve_ops because _reserve_grain_first_index IS a valid index. It does not point to the last valid index of the non-reserved grains.

Definition at line 1786 of file GrainTracker.C.

Referenced by GrainTracker::trackGrains().

1787 {
1796  _reserve_grain_first_index + _n_reserve_ops /* no +1 here!*/);
1797 
1798  return _max_curr_grain_id;
1799 }
unsigned int & _max_curr_grain_id
Holds the next "regular" grain ID (a grain found or remapped to the standard op vars) ...
Definition: GrainTracker.h:247
static const unsigned int invalid_id
unsigned int _reserve_grain_first_index
Holds the first unique grain index when using _reserve_op (all the remaining indices are sequential) ...
Definition: GrainTracker.h:241
const unsigned short _n_reserve_ops
The number of reserved order parameters.
Definition: GrainTracker.h:188

◆ getNumberActiveFeatures()

std::size_t FeatureFloodCount::getNumberActiveFeatures ( ) const
inherited

Return the number of active features.

Definition at line 806 of file FeatureFloodCount.C.

Referenced by AverageGrainVolume::getValue().

807 {
808  // Note: This value is parallel consistent, see FeatureFloodCount::communicateAndMerge()
809  return _feature_count;
810 }
unsigned int _feature_count
The number of features seen by this object (same as summing _feature_counts_per_map) ...

◆ getNumberActiveGrains()

std::size_t GrainTracker::getNumberActiveGrains ( ) const
overridevirtualinherited

Returns the number of active grains current stored in the GrainTracker.

This value is the same value reported when the GrainTracker (FeatureFloodObject) is used as a Postprocessor.

Note: This value will count each piece of a split grain (often encountered in EBSD data sets).

Implements GrainTrackerInterface.

Definition at line 143 of file GrainTracker.C.

144 {
145  // Note: This value is parallel consistent, see FeatureFloodCount::communicateAndMerge()
146  return _feature_count;
147 }
unsigned int _feature_count
The number of features seen by this object (same as summing _feature_counts_per_map) ...

◆ getThreshold()

Real GrainTracker::getThreshold ( std::size_t  current_index) const
overrideprotectedvirtualinherited

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

Reimplemented from FeatureFloodCount.

Definition at line 286 of file GrainTracker.C.

287 {
288  // If we are inspecting a reserve op parameter, we need to make sure
289  // that there is an entity above the reserve_op threshold before
290  // starting the flood of the feature.
291  if (var_index >= _reserve_op_index)
292  return _reserve_op_threshold;
293  else
294  return _step_threshold;
295 }
const Real _reserve_op_threshold
The threshold above (or below) where a grain may be found on a reserve op field.
Definition: GrainTracker.h:195
const std::size_t _reserve_op_index
The cutoff index where if variable index >= this number, no remapping TO that variable will occur...
Definition: GrainTracker.h:192

◆ getTotalFeatureCount()

std::size_t GrainTracker::getTotalFeatureCount ( ) const
overridevirtualinherited

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 from FeatureFloodCount.

Definition at line 150 of file GrainTracker.C.

151 {
152  // Note: This value is parallel consistent, see assignGrains()/trackGrains()
154 }
unsigned int & _max_curr_grain_id
Holds the next "regular" grain ID (a grain found or remapped to the standard op vars) ...
Definition: GrainTracker.h:247
static const unsigned int invalid_id

◆ getValue()

Real FeatureFloodCount::getValue ( ) const
overridevirtualinherited

Implements GeneralPostprocessor.

Reimplemented in FauxGrainTracker.

Definition at line 800 of file FeatureFloodCount.C.

801 {
802  return static_cast<Real>(_feature_count);
803 }
unsigned int _feature_count
The number of features seen by this object (same as summing _feature_counts_per_map) ...
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

◆ getVarToFeatureVector()

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

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 from FeatureFloodCount.

Definition at line 131 of file GrainTracker.C.

Referenced by ComputePolycrystalElasticityTensor::computeQpElasticityTensor(), and ComputeGBMisorientationType::computeQpProperties().

132 {
134 }
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.

◆ initialize()

void GrainTracker::initialize ( )
overridevirtualinherited

If we are passed the first time, we need to save the existing grains before beginning the tracking on the current step. We'll do that with a swap since the _feature_sets contents will be cleared anyway.

Reimplemented from FeatureFloodCount.

Definition at line 230 of file GrainTracker.C.

231 {
232  // Don't track grains if the current simulation step is before the specified tracking step
233  if (_t_step < _tracking_step)
234  return;
235 
241  if (!_first_time)
243 
245 }
bool & _first_time
Boolean to indicate the first time this object executes.
Definition: GrainTracker.h:230
std::vector< FeatureData > & _feature_sets
The data structure used to hold the globally unique features.
std::vector< FeatureData > _feature_sets_old
This data structure holds the map of unique grains from the previous time step.
Definition: GrainTracker.h:216
virtual void initialize() override
const int _tracking_step
The timestep to begin tracking grains.
Definition: GrainTracker.h:179

◆ initialSetup()

void FeatureFloodCount::initialSetup ( )
overridevirtualinherited

Size the empty var to features vector to the number of coupled variables. This empty vector (but properly sized) vector is returned for elements that are queried but are not in the structure (which also shouldn't happen). The user is warned in this case but this helps avoid extra bounds checking in user code and avoids segfaults.

Reimplemented from GeneralPostprocessor.

Reimplemented in PolycrystalUserObjectBase, and FauxPolycrystalVoronoi.

Definition at line 263 of file FeatureFloodCount.C.

Referenced by PolycrystalUserObjectBase::initialSetup().

264 {
265  // We need one map per coupled variable for normal runs to support overlapping features
266  _entities_visited.resize(_vars.size());
267 
268  // Get a pointer to the PeriodicBoundaries buried in libMesh
269  _pbs = _fe_problem.getNonlinearSystemBase(_sys.number()).dofMap().get_periodic_boundaries();
270 
271  meshChanged();
272 
281 }
const std::size_t _n_vars
std::vector< std::set< dof_id_type > > _entities_visited
This variable keeps track of which nodes have been visited during execution.
std::vector< MooseVariable * > _vars
The vector of coupled in variables cast to MooseVariable.
static const unsigned int invalid_id
NonlinearSystemBase & getNonlinearSystemBase(const unsigned int sys_num)
unsigned int number() const
PeriodicBoundaries * _pbs
A pointer to the periodic boundary constraints object.
std::vector< unsigned int > _empty_var_to_features
FEProblemBase & _fe_problem
virtual void meshChanged() override

◆ 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 1858 of file FeatureFloodCount.C.

Referenced by FeatureFloodCount::visitNeighborsHelper().

1859 {
1860  mooseAssert(_bnd_elem_range, "Boundary Element Range is nullptr");
1861 
1862  if (entity)
1863  for (const auto & belem : *_bnd_elem_range)
1864  // Only works for Elements
1865  if (belem->_elem->id() == entity->id() && hasBoundary(belem->_bnd_id))
1866  return true;
1867 
1868  return false;
1869 }
bool hasBoundary(const BoundaryName &name) const
ConstBndElemRange * _bnd_elem_range
Boundary element range pointer.

◆ isElemental()

bool FeatureFloodCount::isElemental ( ) const
inlineinherited

Definition at line 117 of file FeatureFloodCount.h.

Referenced by FeatureFloodCountAux::FeatureFloodCountAux().

117 { return _is_elemental; }
const bool _is_elemental
Determines if the flood counter is elements or not (nodes)

◆ isFeaturePercolated()

bool GrainTracker::isFeaturePercolated ( unsigned int  feature_id) const
overridevirtualinherited

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

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

Reimplemented from FeatureFloodCount.

Definition at line 208 of file GrainTracker.C.

209 {
210  // TODO: This data structure may need to be turned into a Multimap
211  mooseAssert(feature_id < _feature_id_to_local_index.size(), "Grain ID out of bounds");
212 
213  auto feature_index = _feature_id_to_local_index[feature_id];
214  if (feature_index != invalid_size_t)
215  {
216  mooseAssert(feature_index < _feature_sets.size(), "Grain index out of bounds");
217  bool primary = ((_feature_sets[feature_index]._boundary_intersection &
220  bool secondary = ((_feature_sets[feature_index]._boundary_intersection &
223  return (primary && secondary);
224  }
225 
226  return false;
227 }
static const std::size_t invalid_size_t
std::vector< FeatureData > & _feature_sets
The data structure used to hold the globally unique features.
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) ...

◆ isNewFeatureOrConnectedRegion()

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

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.

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 in PolycrystalUserObjectBase.

Definition at line 1458 of file FeatureFloodCount.C.

Referenced by FeatureFloodCount::flood().

1463 {
1464  // Get the value of the current variable for the current entity
1465  Real entity_value;
1466  if (_is_elemental)
1467  {
1468  const Elem * elem = static_cast<const Elem *>(dof_object);
1469  std::vector<Point> centroid(1, elem->vertex_average());
1470  _subproblem.reinitElemPhys(elem, centroid, 0);
1471  entity_value = _vars[current_index]->sln()[0];
1472  }
1473  else
1474  entity_value = _vars[current_index]->getNodalValue(*static_cast<const Node *>(dof_object));
1475 
1476  // If the value compares against our starting threshold, this is definitely part of a feature
1477  // we'll keep
1478  if (compareValueWithThreshold(entity_value, getThreshold(current_index)))
1479  {
1480  Status * status_ptr = &status;
1481 
1482  if (feature)
1483  status_ptr = &feature->_status;
1484 
1485  // Update an existing feature's status or clear the flag on the passed in status
1486  *status_ptr &= ~Status::INACTIVE;
1487  return true;
1488  }
1489 
1494  return compareValueWithThreshold(entity_value, getConnectingThreshold(current_index));
1495 }
Status
This enumeration is used to indicate status of the grains in the _unique_grains data structure...
SubProblem & _subproblem
MPI_Status status
std::vector< MooseVariable * > _vars
The vector of coupled in variables cast to MooseVariable.
virtual Real getConnectingThreshold(std::size_t current_index) const
Return the "connecting" comparison threshold to use when inspecting an entity during the flood stage...
virtual void reinitElemPhys(const Elem *elem, const std::vector< Point > &phys_points_in_elem, const THREAD_ID tid)=0
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
const bool _is_elemental
Determines if the flood counter is elements or not (nodes)
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...
virtual Real getThreshold(std::size_t current_index) const
Return the starting comparison threshold to use when inspecting an entity during the flood stage...

◆ mergeSets()

void FeatureFloodCount::mergeSets ( )
protectedvirtualinherited

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

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 in PolycrystalUserObjectBase.

Definition at line 1138 of file FeatureFloodCount.C.

Referenced by FeatureFloodCount::communicateAndMerge().

1139 {
1140  TIME_SECTION("mergeSets", 3, "Merging Sets");
1141 
1142  // When working with _distribute_merge_work all of the maps will be empty except for one
1143  for (const auto map_num : make_range(_maps_size))
1144  {
1145  for (auto it1 = _partial_feature_sets[map_num].begin();
1146  it1 != _partial_feature_sets[map_num].end();
1147  /* No increment on it1 */)
1148  {
1149  bool merge_occured = false;
1150  for (auto it2 = _partial_feature_sets[map_num].begin();
1151  it2 != _partial_feature_sets[map_num].end();
1152  ++it2)
1153  {
1154  if (it1 != it2 && areFeaturesMergeable(*it1, *it2))
1155  {
1156  it2->merge(std::move(*it1));
1157 
1162  _partial_feature_sets[map_num].emplace_back(std::move(*it2));
1163 
1173  _partial_feature_sets[map_num].erase(it2);
1174  it1 = _partial_feature_sets[map_num].erase(it1); // it1 is incremented here!
1175 
1176  // A merge occurred, this is used to determine whether or not we increment the outer
1177  // iterator
1178  merge_occured = true;
1179 
1180  // We need to start the list comparison over for the new it1 so break here
1181  break;
1182  }
1183  } // it2 loop
1184 
1185  if (!merge_occured) // No merges so we need to manually increment the outer iterator
1186  ++it1;
1187 
1188  } // it1 loop
1189  } // map loop
1190 }
virtual bool areFeaturesMergeable(const FeatureData &f1, const FeatureData &f2) const
Method for determining whether two features are mergeable.
const std::size_t _maps_size
Convenience variable holding the size of all the datastructures size by the number of maps...
std::vector< std::list< FeatureData > > _partial_feature_sets
The data structure used to hold partial and communicated feature data, during the discovery and mergi...
IntRange< T > make_range(T beg, T end)

◆ meshChanged()

void GrainTracker::meshChanged ( )
overridevirtualinherited

Reimplemented from FeatureFloodCount.

Definition at line 248 of file GrainTracker.C.

249 {
250  // Update the element ID ranges for use when computing halo maps
252  {
253  _all_ranges.clear();
254 
255  auto range = std::make_pair(std::numeric_limits<dof_id_type>::max(),
256  std::numeric_limits<dof_id_type>::min());
257  for (const auto & current_elem : _mesh.getMesh().active_local_element_ptr_range())
258  {
259  auto id = current_elem->id();
260  if (id < range.first)
261  range.first = id;
262  else if (id > range.second)
263  range.second = id;
264  }
265 
266  _communicator.gather(0, range, _all_ranges);
267  }
268 
270 }
bool isDistributedMesh() const
void gather(const unsigned int root_id, const T &send_data, std::vector< T, A > &recv) const
const Parallel::Communicator & _communicator
MeshBase & getMesh()
const bool _compute_halo_maps
Indicates whether or not to communicate halo map information with all ranks.
std::vector< std::pair< dof_id_type, dof_id_type > > _all_ranges
Data structure to hold element ID ranges when using Distributed Mesh (populated on rank 0 only) ...
Definition: GrainTracker.h:253
virtual void meshChanged() override
MooseMesh & _mesh
A reference to the mesh.

◆ newGrain()

RankFourTensor GrainTrackerElasticity::newGrain ( unsigned int  new_grain_id)
protectedvirtual

implement this method to initialize the data for the new grain

Implements GrainDataTracker< RankFourTensor >.

Definition at line 43 of file GrainTrackerElasticity.C.

44 {
45  EulerAngles angles;
46 
47  if (new_grain_id < _euler.getGrainNum())
48  angles = _euler.getEulerAngles(new_grain_id);
49  else
50  {
52  angles.random();
53  else
54  mooseError("GrainTrackerElasticity has run out of grain rotation data.");
55  }
56 
57  RankFourTensor C_ijkl = _C_ijkl;
58  C_ijkl.rotate(RotationTensor(RealVectorValue(angles)));
59 
60  return C_ijkl;
61 }
virtual unsigned int getGrainNum() const =0
const bool _random_rotations
generate random rotations when the Euler Angle provider runs out of data (otherwise error out) ...
void random()
Definition: EulerAngles.C:73
void rotate(const TypeTensor< T > &R)
This is a RealTensor version of a rotation matrix It is instantiated with the Euler angles...
virtual const EulerAngles & getEulerAngles(unsigned int) const =0
RankFourTensor _C_ijkl
unrotated elasticity tensor
Euler angle triplet.
Definition: EulerAngles.h:24
void mooseError(Args &&... args) const
const EulerAngleProvider & _euler
object providing the Euler angles

◆ newGrainCreated()

void GrainDataTracker< RankFourTensor >::newGrainCreated ( unsigned int  new_grain_id)
protectedvirtualinherited

This method is called when a new grain is detected.

It can be overridden by a derived class to handle setting new properties on the newly created grain.

Reimplemented from GrainTracker.

Definition at line 53 of file GrainDataTracker.h.

54 {
55  if (_grain_data.size() <= new_grain_id)
56  _grain_data.resize(new_grain_id + 1);
57 
58  _grain_data[new_grain_id] = newGrain(new_grain_id);
59 }
std::vector< RankFourTensor > & _grain_data
per grain data
virtual RankFourTensor newGrain(unsigned int new_grain_id)=0
implement this method to initialize the data for the new grain

◆ numberOfDistributedMergeHelpers()

processor_id_type FeatureFloodCount::numberOfDistributedMergeHelpers ( ) const
protectedvirtualinherited

Returns a number indicating the number of merge helpers when running in parallel based on certain implementer decided criteria.

This is a communication versus computation trade-off that we are almost always willing to make except for small problems. The decision however may be more complicated for some derived classes.

Reimplemented in PolycrystalUserObjectBase.

Definition at line 397 of file FeatureFloodCount.C.

Referenced by FeatureFloodCount::communicateAndMerge().

398 {
399  return _app.n_processors() >= _maps_size ? _maps_size : 1;
400 }
processor_id_type n_processors() const
const std::size_t _maps_size
Convenience variable holding the size of all the datastructures size by the number of maps...

◆ numCoupledVars()

std::size_t FeatureFloodCount::numCoupledVars ( ) const
inlineinherited

Returns the number of coupled varaibles.

Definition at line 87 of file FeatureFloodCount.h.

87 { return _n_vars; }
const std::size_t _n_vars

◆ prepareDataForTransfer()

void FeatureFloodCount::prepareDataForTransfer ( )
protectedvirtualinherited

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

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

_partial_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

Reimplemented in PolycrystalUserObjectBase.

Definition at line 1034 of file FeatureFloodCount.C.

Referenced by FeatureFloodCount::communicateAndMerge(), and PolycrystalUserObjectBase::prepareDataForTransfer().

1035 {
1036  TIME_SECTION("prepareDataForTransfer", 3, "Preparing Data For Transfer");
1037 
1038  MeshBase & mesh = _mesh.getMesh();
1039 
1040  FeatureData::container_type local_ids_no_ghost, set_difference;
1041 
1042  for (auto & list_ref : _partial_feature_sets)
1043  {
1044  for (auto & feature : list_ref)
1045  {
1046  // See if the feature intersects a boundary or perhaps one of the percolation boundaries.
1047  updateBoundaryIntersections(feature);
1048 
1049  // Periodic node ids
1050  appendPeriodicNeighborNodes(feature);
1051 
1057  FeatureFloodCount::sort(feature._ghosted_ids);
1058  FeatureFloodCount::sort(feature._local_ids);
1059  FeatureFloodCount::sort(feature._halo_ids);
1060  FeatureFloodCount::sort(feature._disjoint_halo_ids);
1061  FeatureFloodCount::sort(feature._periodic_nodes);
1062 
1063  // Now extend the bounding box by the halo region
1064  if (_is_elemental)
1065  feature.updateBBoxExtremes(mesh);
1066  else
1067  {
1068  for (auto & halo_id : feature._halo_ids)
1069  updateBBoxExtremesHelper(feature._bboxes[0], mesh.point(halo_id));
1070  }
1071 
1072  mooseAssert(!feature._local_ids.empty(), "local entity ids cannot be empty");
1073 
1078  feature._min_entity_id = *feature._local_ids.begin();
1079  }
1080  }
1081 }
std::vector< dof_id_type > container_type
The primary underlying container type used to hold the data in each FeatureData.
void appendPeriodicNeighborNodes(FeatureData &feature) const
This routine adds the periodic node information to our data structure prior to packing the data this ...
static void sort(std::set< T > &)
MeshBase & mesh
MeshBase & getMesh()
std::vector< std::list< FeatureData > > _partial_feature_sets
The data structure used to hold partial and communicated feature data, during the discovery and mergi...
const bool _is_elemental
Determines if the flood counter is elements or not (nodes)
void updateBoundaryIntersections(FeatureData &feature) const
Update the feature&#39;s attributes to indicate boundary intersections.
void updateBBoxExtremesHelper(BoundingBox &bbox, const Point &node)
MooseMesh & _mesh
A reference to the mesh.

◆ prepopulateState()

void GrainTracker::prepopulateState ( const FeatureFloodCount ffc_object)
protectedinherited

This method extracts the necessary state from the passed in object necessary to continue tracking grains.

This method is meant to be used with the PolycrystalUserobjectBase class that sets up initial conditions for Polycrystal simulations. We can use the state of that object rather than rediscovering everything ourselves.

The minimum information needed to bootstrap the GrainTracker is as follows: _feature_sets _feature_count

Definition at line 298 of file GrainTracker.C.

Referenced by GrainTracker::finalize().

299 {
300  mooseAssert(_first_time, "This method should only be called on the first invocation");
301 
302  _feature_sets.clear();
303 
309  if (_is_primary)
310  {
311  const auto & features = ffc_object.getFeatures();
312  for (auto & feature : features)
313  _feature_sets.emplace_back(feature.duplicate());
314 
315  _feature_count = _feature_sets.size();
316  }
317  else
318  {
319  const auto & features = ffc_object.getFeatures();
320  _partial_feature_sets[0].clear();
321  for (auto & feature : features)
322  _partial_feature_sets[0].emplace_back(feature.duplicate());
323  }
324 
325  // Make sure that feature count is communicated to all ranks
327 }
bool & _first_time
Boolean to indicate the first time this object executes.
Definition: GrainTracker.h:230
std::vector< FeatureData > & _feature_sets
The data structure used to hold the globally unique features.
const bool _is_primary
Convenience variable for testing primary rank.
const Parallel::Communicator & _communicator
const std::vector< FeatureData > & getFeatures() const
Return a constant reference to the vector of all discovered features.
unsigned int _feature_count
The number of features seen by this object (same as summing _feature_counts_per_map) ...
void broadcast(T &data, const unsigned int root_id=0, const bool identical_sizes=false) const
std::vector< std::list< FeatureData > > _partial_feature_sets
The data structure used to hold partial and communicated feature data, during the discovery and mergi...

◆ remapGrains()

void GrainTracker::remapGrains ( )
protectedinherited

This method is called after trackGrains to remap grains that are too close to each other.

Map used for communicating remap indices to all ranks This map isn't populated until after the remap loop. It's declared here before we enter the root scope since it's needed by all ranks during the broadcast.

The remapping algorithm is recursive. We will use the status variable in each FeatureData to track which grains are currently being remapped so we don't have runaway recursion. To begin we need to clear all of the active (MARKED) flags (CLEAR).

Additionally we need to record each grain's variable index so that we can communicate changes to the non-root ranks later in a single batch.

We're not going to try very hard to look for a suitable remapping. Just set it to what we want and hope it all works out. Make the GrainTracker great again!

Loop over each grain and see if any grains represented by the same variable are "touching"

The remapping loop is complete but only on the primary process. Now we need to build the remap map and communicate it to the remaining processors.

Since the remapping algorithm only runs on the root process, the variable index on the primary's grains is inconsistent from the rest of the ranks. These are the grains with a status of DIRTY. As we build this map we will temporarily switch these variable indices back to the correct value so that all processors use the same algorithm to remap.

Definition at line 910 of file GrainTracker.C.

Referenced by GrainTracker::finalize().

911 {
912  // Don't remap grains if the current simulation step is before the specified tracking step
913  if (_t_step < _tracking_step)
914  return;
915 
916  TIME_SECTION("remapGrains", 3, "Remapping Grains");
917 
918  if (_verbosity_level > 1)
919  _console << "Running remap Grains\n" << std::endl;
920 
927  std::map<unsigned int, std::size_t> grain_id_to_new_var;
928 
929  // Items are added to this list when split grains are found
930  std::list<std::pair<std::size_t, std::size_t>> split_pairs;
931 
940  if (_is_primary)
941  {
942  // Build the map to detect difference in _var_index mappings after the remap operation
943  std::map<unsigned int, std::size_t> grain_id_to_existing_var_index;
944  for (auto & grain : _feature_sets)
945  {
946  // Unmark the grain so it can be used in the remap loop
947  grain._status = Status::CLEAR;
948 
949  grain_id_to_existing_var_index[grain._id] = grain._var_index;
950  }
951 
952  // Make sure that all split pieces of any grain are on the same OP
953  for (const auto i : index_range(_feature_sets))
954  {
955  auto & grain1 = _feature_sets[i];
956 
957  for (const auto j : index_range(_feature_sets))
958  {
959  auto & grain2 = _feature_sets[j];
960  if (i == j)
961  continue;
962 
963  // The first condition below is there to prevent symmetric checks (duplicate values)
964  if (i < j && grain1._id == grain2._id)
965  {
966  split_pairs.push_front(std::make_pair(i, j));
967  if (grain1._var_index != grain2._var_index)
968  {
969  if (_verbosity_level > 0)
970  _console << COLOR_YELLOW << "Split Grain (#" << grain1._id
971  << ") detected on unmatched OPs (" << grain1._var_index << ", "
972  << grain2._var_index << ") attempting to remap to " << grain1._var_index
973  << ".\n"
974  << COLOR_DEFAULT;
975 
980  grain1._var_index = grain2._var_index;
981  grain1._status |= Status::DIRTY;
982  }
983  }
984  }
985  }
986 
990  bool grains_remapped;
991 
992  std::set<unsigned int> notify_ids;
993  do
994  {
995  grains_remapped = false;
996  notify_ids.clear();
997 
998  for (auto & grain1 : _feature_sets)
999  {
1000  // We need to remap any grains represented on any variable index above the cuttoff
1001  if (grain1._var_index >= _reserve_op_index)
1002  {
1003  if (_verbosity_level > 0)
1004  _console << COLOR_YELLOW << "\nGrain #" << grain1._id
1005  << " detected on a reserved order parameter #" << grain1._var_index
1006  << ", remapping to another variable\n"
1007  << COLOR_DEFAULT;
1008 
1009  for (const auto max : make_range(0, _max_remap_recursion_depth + 1))
1010  if (max < _max_remap_recursion_depth)
1011  {
1012  if (attemptGrainRenumber(grain1, 0, max))
1013  break;
1014  }
1015  else if (!attemptGrainRenumber(grain1, 0, max))
1016  {
1017  _console << std::flush;
1018  std::stringstream oss;
1019  oss << "Unable to find any suitable order parameters for remapping while working "
1020  << "with Grain #" << grain1._id << ", which is on a reserve order parameter.\n"
1021  << "\n\nPossible Resolutions:\n"
1022  << "\t- Add more order parameters to your simulation (8 for 2D, 28 for 3D)\n"
1023  << "\t- Increase adaptivity or reduce your grain boundary widths\n"
1024  << "\t- Make sure you are not starting with too many grains for the mesh size\n";
1025  mooseError(oss.str());
1026  }
1027 
1028  grains_remapped = true;
1029  }
1030 
1031  for (auto & grain2 : _feature_sets)
1032  {
1033  // Don't compare a grain with itself and don't try to remap inactive grains
1034  if (&grain1 == &grain2)
1035  continue;
1036 
1037  if (grain1._var_index == grain2._var_index && // grains represented by same variable?
1038  grain1._id != grain2._id && // are they part of different grains?
1039  grain1.boundingBoxesIntersect(grain2) && // do bboxes intersect (coarse level)?
1040  grain1.halosIntersect(grain2)) // do they actually overlap (fine level)?
1041  {
1042  if (_verbosity_level > 0)
1043  _console << COLOR_YELLOW << "Grain #" << grain1._id << " intersects Grain #"
1044  << grain2._id << " (variable index: " << grain1._var_index << ")\n"
1045  << COLOR_DEFAULT;
1046 
1047  for (const auto max : make_range(0, _max_remap_recursion_depth + 1))
1048  {
1049  if (max < _max_remap_recursion_depth)
1050  {
1051  if (attemptGrainRenumber(grain1, 0, max))
1052  {
1053  grains_remapped = true;
1054  break;
1055  }
1056  }
1057  else if (!attemptGrainRenumber(grain1, 0, max) &&
1058  !attemptGrainRenumber(grain2, 0, max))
1059  {
1060  notify_ids.insert(grain1._id);
1061  notify_ids.insert(grain2._id);
1062  }
1063  }
1064  }
1065  }
1066  }
1067  } while (grains_remapped);
1068 
1069  if (!notify_ids.empty())
1070  {
1071  _console << std::flush;
1072  std::stringstream oss;
1073  oss << "Unable to find any suitable order parameters for remapping while working "
1074  << "with the following grain IDs:\n"
1075  << Moose::stringify(notify_ids, ", ", "", true) << "\n\nPossible Resolutions:\n"
1076  << "\t- Add more order parameters to your simulation (8 for 2D, 28 for 3D)\n"
1077  << "\t- Increase adaptivity or reduce your grain boundary widths\n"
1078  << "\t- Make sure you are not starting with too many grains for the mesh size\n";
1079 
1080  if (_tolerate_failure)
1081  mooseWarning(oss.str());
1082  else
1083  mooseError(oss.str());
1084  }
1085 
1086  // Verify that split grains are still intact
1087  for (auto & split_pair : split_pairs)
1088  if (_feature_sets[split_pair.first]._var_index != _feature_sets[split_pair.first]._var_index)
1089  mooseError("Split grain remapped - This case is currently not handled");
1090 
1096  for (auto & grain : _feature_sets)
1097  {
1098  mooseAssert(grain_id_to_existing_var_index.find(grain._id) !=
1099  grain_id_to_existing_var_index.end(),
1100  "Missing unique ID");
1101 
1102  auto old_var_index = grain_id_to_existing_var_index[grain._id];
1103 
1104  if (old_var_index != grain._var_index)
1105  {
1106  mooseAssert(static_cast<bool>(grain._status & Status::DIRTY), "grain status is incorrect");
1107 
1108  grain_id_to_new_var.emplace_hint(
1109  grain_id_to_new_var.end(),
1110  std::pair<unsigned int, std::size_t>(grain._id, grain._var_index));
1111 
1120  grain._var_index = old_var_index;
1121  // Clear the DIRTY status as well for consistency
1122  grain._status &= ~Status::DIRTY;
1123  }
1124  }
1125 
1126  if (!grain_id_to_new_var.empty())
1127  {
1128  if (_verbosity_level > 1)
1129  {
1130  _console << "Final remapping tally:\n";
1131  for (const auto & remap_pair : grain_id_to_new_var)
1132  _console << "Grain #" << remap_pair.first << " var_index "
1133  << grain_id_to_existing_var_index[remap_pair.first] << " -> "
1134  << remap_pair.second << '\n';
1135  _console << "Communicating swaps with remaining processors..." << std::endl;
1136  }
1137  }
1138  } // root processor
1139 
1140  // Communicate the std::map to all ranks
1141  _communicator.broadcast(grain_id_to_new_var);
1142 
1143  // Perform swaps if any occurred
1144  if (!grain_id_to_new_var.empty())
1145  {
1146  // Cache for holding values during swaps
1147  std::vector<std::map<Node *, CacheValues>> cache(_n_vars);
1148 
1149  // Perform the actual swaps on all processors
1150  for (auto & grain : _feature_sets)
1151  {
1152  // See if this grain was remapped
1153  auto new_var_it = grain_id_to_new_var.find(grain._id);
1154  if (new_var_it != grain_id_to_new_var.end())
1155  swapSolutionValues(grain, new_var_it->second, cache, RemapCacheMode::FILL);
1156  }
1157 
1158  for (auto & grain : _feature_sets)
1159  {
1160  // See if this grain was remapped
1161  auto new_var_it = grain_id_to_new_var.find(grain._id);
1162  if (new_var_it != grain_id_to_new_var.end())
1163  swapSolutionValues(grain, new_var_it->second, cache, RemapCacheMode::USE);
1164  }
1165 
1166  _nl.solution().close();
1167  _nl.solutionOld().close();
1168  _nl.solutionOlder().close();
1169 
1170  _nl.system().update();
1171 
1172  if (_verbosity_level > 1)
1173  _console << "Swaps complete" << std::endl;
1174  }
1175 }
const std::size_t _n_vars
NumericVector< Number > & solution()
Status
This enumeration is used to indicate status of the grains in the _unique_grains data structure...
std::vector< FeatureData > & _feature_sets
The data structure used to hold the globally unique features.
const bool _is_primary
Convenience variable for testing primary rank.
NumericVector< Number > & solutionOlder()
const Parallel::Communicator & _communicator
void mooseWarning(Args &&... args) const
NonlinearSystemBase & _nl
A reference to the nonlinear system (used for retrieving solution vectors)
Definition: GrainTracker.h:210
void swapSolutionValues(FeatureData &grain, std::size_t new_var_index, std::vector< std::map< Node *, CacheValues >> &cache, RemapCacheMode cache_mode)
A routine for moving all of the solution values from a given grain to a new variable number...
const short _verbosity_level
Verbosity level controlling the amount of information printed to the console.
Definition: GrainTracker.h:224
std::string stringify(const T &t)
void broadcast(T &data, const unsigned int root_id=0, const bool identical_sizes=false) const
virtual void close()=0
virtual System & system() override
bool attemptGrainRenumber(FeatureData &grain, unsigned int depth, unsigned int max_depth)
This is the recursive part of the remapping algorithm.
IntRange< T > make_range(T beg, T end)
void mooseError(Args &&... args) const
static const std::complex< double > j(0, 1)
Complex number "j" (also known as "i")
const ConsoleStream _console
const int _tracking_step
The timestep to begin tracking grains.
Definition: GrainTracker.h:179
const std::size_t _reserve_op_index
The cutoff index where if variable index >= this number, no remapping TO that variable will occur...
Definition: GrainTracker.h:192
NumericVector< Number > & solutionOld()
const unsigned short _max_remap_recursion_depth
Depth of renumbering recursion (a depth of zero means no recursion)
Definition: GrainTracker.h:185
auto index_range(const T &sizable)
const bool _tolerate_failure
Indicates whether we should continue after a remap failure (will result in non-physical results) ...
Definition: GrainTracker.h:207

◆ restoreOriginalDataStructures()

virtual void FeatureFloodCount::restoreOriginalDataStructures ( std::vector< std::list< FeatureData >> &  )
inlineprotectedvirtualinherited

Reimplemented in PolycrystalUserObjectBase.

Definition at line 487 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::communicateAndMerge().

487 {}

◆ 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-primary 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 710 of file FeatureFloodCount.C.

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

711 {
712  // local to global map (one per processor)
713  std::vector<int> counts;
714  std::vector<std::size_t> local_to_global_all;
715  if (_is_primary)
716  buildLocalToGlobalIndices(local_to_global_all, counts);
717 
718  // Scatter local_to_global indices to all processors and store in class member variable
719  _communicator.scatter(local_to_global_all, counts, _local_to_global_feature_map);
720 
721  std::size_t largest_global_index = std::numeric_limits<std::size_t>::lowest();
722  if (!_is_primary)
723  {
725 
732  for (auto & list_ref : _partial_feature_sets)
733  {
734  for (auto & feature : list_ref)
735  {
736  mooseAssert(feature._orig_ids.size() == 1, "feature._orig_ids length doesn't make sense");
737 
738  auto global_index = FeatureFloodCount::invalid_size_t;
739  auto local_index = feature._orig_ids.begin()->second;
740 
741  if (local_index < _local_to_global_feature_map.size())
742  global_index = _local_to_global_feature_map[local_index];
743 
744  if (global_index != FeatureFloodCount::invalid_size_t)
745  {
746  if (global_index > largest_global_index)
747  largest_global_index = global_index;
748 
749  // Set the correct global index
750  feature._id = global_index;
751 
759  feature._status &= ~Status::INACTIVE;
760 
761  // Move the feature into the correct place
762  _feature_sets[local_index] = std::move(feature);
763  }
764  }
765  }
766  }
767  else
768  {
769  for (auto global_index : local_to_global_all)
770  if (global_index != FeatureFloodCount::invalid_size_t && global_index > largest_global_index)
771  largest_global_index = global_index;
772  }
773 
774  // communicate the boundary intersection state
775  std::vector<std::pair<unsigned int, int>> intersection_state;
776  for (auto & feature : _feature_sets)
777  intersection_state.emplace_back(feature._id, static_cast<int>(feature._boundary_intersection));
778 
779  // gather on root
780  _communicator.gather(0, intersection_state);
781 
782  // consolidate
783  std::map<unsigned int, int> consolidated_intersection_state;
784  if (_is_primary)
785  for (const auto & [id, state] : intersection_state)
786  consolidated_intersection_state[id] |= state;
787 
788  // broadcast result
789  _communicator.broadcast(consolidated_intersection_state, 0);
790 
791  // apply broadcast changes
792  for (auto & feature : _feature_sets)
793  feature._boundary_intersection |=
794  static_cast<BoundaryIntersection>(consolidated_intersection_state[feature._id]);
795 
796  buildFeatureIdToLocalIndices(largest_global_index);
797 }
void scatter(const std::vector< T, A > &data, T &recv, const unsigned int root_id=0) const
static const std::size_t invalid_size_t
void gather(const unsigned int root_id, const T &send_data, std::vector< T, A > &recv) const
Status
This enumeration is used to indicate status of the grains in the _unique_grains data structure...
std::vector< FeatureData > & _feature_sets
The data structure used to hold the globally unique features.
const bool _is_primary
Convenience variable for testing primary rank.
const Parallel::Communicator & _communicator
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 ...
BoundaryIntersection
This enumeration is used to inidacate status of boundary intersections.
void broadcast(T &data, const unsigned int root_id=0, const bool identical_sizes=false) const
std::vector< std::list< FeatureData > > _partial_feature_sets
The data structure used to hold partial and communicated feature data, during the discovery and mergi...
void buildFeatureIdToLocalIndices(unsigned int max_id)
This method builds a lookup map for retrieving the right local feature (by index) given a global inde...
std::vector< std::size_t > _local_to_global_feature_map
The vector recording the local to global feature indices.

◆ 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 1084 of file FeatureFloodCount.C.

Referenced by FeatureFloodCount::communicateAndMerge().

1085 {
1086  // stream for serializing the _partial_feature_sets data structure to a byte stream
1087  std::ostringstream oss;
1088 
1089  mooseAssert(var_num == invalid_id || var_num < _partial_feature_sets.size(),
1090  "var_num out of range");
1091 
1092  // Serialize everything
1093  if (var_num == invalid_id)
1094  dataStore(oss, _partial_feature_sets, this);
1095  else
1096  dataStore(oss, _partial_feature_sets[var_num], this);
1097 
1098  // Populate the passed in string pointer with the string stream's buffer contents
1099  serialized_buffer.assign(oss.str());
1100 }
void dataStore(std::ostream &stream, FeatureFloodCount::FeatureData &feature, void *context)
static const unsigned int invalid_id
std::vector< std::list< FeatureData > > _partial_feature_sets
The data structure used to hold partial and communicated feature data, during the discovery and mergi...

◆ 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 568 of file FeatureFloodCount.C.

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

569 {
570  mooseAssert(_is_primary, "sortAndLabel can only be called on the primary");
571 
577  std::sort(_feature_sets.begin(), _feature_sets.end());
578 
579 #ifndef NDEBUG
580 
585  unsigned int feature_offset = 0;
586  for (const auto map_num : make_range(_maps_size))
587  {
588  // Skip empty map checks
589  if (_feature_counts_per_map[map_num] == 0)
590  continue;
591 
592  // Check the begin and end of the current range
593  auto range_front = feature_offset;
594  auto range_back = feature_offset + _feature_counts_per_map[map_num] - 1;
595 
596  mooseAssert(range_front <= range_back && range_back < _feature_count,
597  "Indexing error in feature sets");
598 
599  if (!_single_map_mode && (_feature_sets[range_front]._var_index != map_num ||
600  _feature_sets[range_back]._var_index != map_num))
601  mooseError("Error in _feature_sets sorting, map index: ", map_num);
602 
603  feature_offset += _feature_counts_per_map[map_num];
604  }
605 #endif
606 
607  // Label the features with an ID based on the sorting (processor number independent value)
608  for (const auto i : index_range(_feature_sets))
609  if (_feature_sets[i]._id == invalid_id)
610  _feature_sets[i]._id = i;
611 }
std::vector< FeatureData > & _feature_sets
The data structure used to hold the globally unique features.
const bool _is_primary
Convenience variable for testing primary rank.
const std::size_t _maps_size
Convenience variable holding the size of all the datastructures size by the number of maps...
static const unsigned int invalid_id
const bool _single_map_mode
This variable is used to indicate whether or not multiple maps are used during flooding.
unsigned int _feature_count
The number of features seen by this object (same as summing _feature_counts_per_map) ...
IntRange< T > make_range(T beg, T end)
std::vector< unsigned int > _feature_counts_per_map
The number of features seen by this object per map.
void mooseError(Args &&... args) const
auto index_range(const T &sizable)

◆ swapSolutionValues()

void GrainTracker::swapSolutionValues ( FeatureData grain,
std::size_t  new_var_index,
std::vector< std::map< Node *, CacheValues >> &  cache,
RemapCacheMode  cache_mode 
)
protectedinherited

A routine for moving all of the solution values from a given grain to a new variable number.

It is called with different modes to only cache, or actually do the work, or bypass the cache altogether.

Definition at line 1427 of file GrainTracker.C.

Referenced by GrainTracker::remapGrains().

1431 {
1432  MeshBase & mesh = _mesh.getMesh();
1433 
1434  // Remap the grain
1435  std::set<Node *> updated_nodes_tmp; // Used only in the elemental case
1436  for (auto entity : grain._local_ids)
1437  {
1438  if (_is_elemental)
1439  {
1440  Elem * elem = mesh.query_elem_ptr(entity);
1441  if (!elem)
1442  continue;
1443 
1444  for (unsigned int i = 0; i < elem->n_nodes(); ++i)
1445  {
1446  Node * curr_node = elem->node_ptr(i);
1447  if (updated_nodes_tmp.find(curr_node) == updated_nodes_tmp.end())
1448  {
1449  // cache this node so we don't attempt to remap it again within this loop
1450  updated_nodes_tmp.insert(curr_node);
1451  swapSolutionValuesHelper(curr_node, grain._var_index, new_var_index, cache, cache_mode);
1452  }
1453  }
1454  }
1455  else
1457  mesh.query_node_ptr(entity), grain._var_index, new_var_index, cache, cache_mode);
1458  }
1459 
1460  // Update the variable index in the unique grain datastructure after swaps are complete
1461  if (cache_mode == RemapCacheMode::USE || cache_mode == RemapCacheMode::BYPASS)
1462  grain._var_index = new_var_index;
1463 }
MeshBase & mesh
void swapSolutionValuesHelper(Node *curr_node, std::size_t curr_var_index, std::size_t new_var_index, std::vector< std::map< Node *, CacheValues >> &cache, RemapCacheMode cache_mode)
Helper method for actually performing the swaps.
MeshBase & getMesh()
const bool _is_elemental
Determines if the flood counter is elements or not (nodes)
MooseMesh & _mesh
A reference to the mesh.

◆ swapSolutionValuesHelper()

void GrainTracker::swapSolutionValuesHelper ( Node *  curr_node,
std::size_t  curr_var_index,
std::size_t  new_var_index,
std::vector< std::map< Node *, CacheValues >> &  cache,
RemapCacheMode  cache_mode 
)
protectedinherited

Helper method for actually performing the swaps.

Finally zero out the old variable. When using the FILL/USE combination to read/write variables, it's important to zero the variable on the FILL stage and not the USE stage. The reason for this is handling swaps as illustrated in the following diagram


/ \/ \ If adjacent grains (overlapping flood region) end up / 1 /\ 2 \ swapping variable indices and variables are zeroed on \ 2*\/ 1* / "USE", the overlap region will be incorrectly zeroed ___/___/ by whichever variable is written to second.

Definition at line 1466 of file GrainTracker.C.

Referenced by GrainTracker::swapSolutionValues().

1471 {
1472  if (curr_node && curr_node->processor_id() == processor_id())
1473  {
1474  // Reinit the node so we can get and set values of the solution here
1475  _subproblem.reinitNode(curr_node, 0);
1476 
1477  // Local variables to hold values being transferred
1478  Real current, old = 0, older = 0;
1479  // Retrieve the value either from the old variable or cache
1480  if (cache_mode == RemapCacheMode::FILL || cache_mode == RemapCacheMode::BYPASS)
1481  {
1482  current = _vars[curr_var_index]->dofValues()[0];
1483  if (_is_transient)
1484  {
1485  old = _vars[curr_var_index]->dofValuesOld()[0];
1486  older = _vars[curr_var_index]->dofValuesOlder()[0];
1487  }
1488  }
1489  else // USE
1490  {
1491  const auto cache_it = cache[curr_var_index].find(curr_node);
1492  mooseAssert(cache_it != cache[curr_var_index].end(), "Error in cache");
1493  current = cache_it->second.current;
1494  old = cache_it->second.old;
1495  older = cache_it->second.older;
1496  }
1497 
1498  // Cache the value or use it!
1499  if (cache_mode == RemapCacheMode::FILL)
1500  {
1501  cache[curr_var_index][curr_node].current = current;
1502  cache[curr_var_index][curr_node].old = old;
1503  cache[curr_var_index][curr_node].older = older;
1504  }
1505  else // USE or BYPASS
1506  {
1507  const auto & dof_index = _vars[new_var_index]->nodalDofIndex();
1508 
1509  // Transfer this solution from the old to the current
1510  _nl.solution().set(dof_index, current);
1511  if (_is_transient)
1512  {
1513  _nl.solutionOld().set(dof_index, old);
1514  _nl.solutionOlder().set(dof_index, older);
1515  }
1516  }
1517 
1530  if (cache_mode == RemapCacheMode::FILL || cache_mode == RemapCacheMode::BYPASS)
1531  {
1532  const auto & dof_index = _vars[curr_var_index]->nodalDofIndex();
1533 
1534  // Set the DOF for the current variable to zero
1535  _nl.solution().set(dof_index, -_bound_value);
1536  if (_is_transient)
1537  {
1538  _nl.solutionOld().set(dof_index, -_bound_value);
1539  _nl.solutionOlder().set(dof_index, -_bound_value);
1540  }
1541  }
1542  }
1543 }
NumericVector< Number > & solution()
NumericVector< Number > & solutionOlder()
NonlinearSystemBase & _nl
A reference to the nonlinear system (used for retrieving solution vectors)
Definition: GrainTracker.h:210
SubProblem & _subproblem
const Real _bound_value
Absolute value of the lower bound used to represent a region not assigned to this grain...
Definition: GrainTracker.h:201
virtual void reinitNode(const Node *node, const THREAD_ID tid)=0
std::vector< MooseVariable * > _vars
The vector of coupled in variables cast to MooseVariable.
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
const bool _is_transient
Boolean to indicate whether this is a Steady or Transient solve.
Definition: GrainTracker.h:250
virtual void set(const numeric_index_type i, const Number value)=0
NumericVector< Number > & solutionOld()
processor_id_type processor_id() const

◆ trackGrains()

void GrainTracker::trackGrains ( )
protectedinherited

On subsequent time_steps, incoming FeatureData objects are compared to previous time_step information to track grains between time steps.

This method updates the _feature_sets data structure. This method should only be called on the root processor

Only the primary rank does tracking, the remaining ranks wait to receive local to global indices from the primary.

To track grains across time steps, we will loop over our unique grains and link each one up with one of our new unique grains. The criteria for doing this will be to find the unique grain in the new list with a matching variable index whose centroid is closest to this unique grain.

The _feature_sets vector is constructed by _var_index so we can avoid looping over all indices. We can quickly jump to the first matching index to reduce the number of comparisons and terminate our loop when our variable index stops matching.

Don't try to do any matching unless the bounding boxes at least overlap. This is to avoid the corner case of having a grain split and a grain disappear during the same time step!

It's possible that multiple existing grains will map to a single new grain (indicated by finding multiple matches when we are building this map). This will happen any time a grain disappears during this time step. We need to figure out the rightful owner in this case and inactivate the old grain.

If the grain we just marked inactive was the one whose index was in the new grain to existing grain map (other_old_grain). Then we need to update the map to point to the new match winner.

At this point we have should have only two cases left to handle: Case 1: A grain in the new set who has an unset status (These are new grains, previously untracked) This case is easy to understand. Since we are matching up grains by looking at the old set and finding closest matches in the new set, any grain in the new set that isn't matched up is simply new since some other grain satisfied each and every request from the old set.

Case 2: A grain in the old set who has an unset status (These are inactive grains that haven't been marked) We can only fall into this case when the very last grain on a given variable disappears during the current time step. In that case we never have a matching _var_index in the comparison loop above so that old grain never competes for any new grain which means it can't be marked inactive in the loop above.

Now we need to figure out what kind of "new" grain this is. Is it a nucleating grain that we're just barely seeing for the first time or is it a "splitting" grain. A grain that gets pinched into two or more pieces usually as it is being absorbed by other grains or possibly due to external forces. We have to handle splitting grains this way so as to no confuse them with regular grains that just happen to be in contact in this step.

Splitting Grain: An grain that is unmatched by any old grain on the same order parameter with touching halos.

Nucleating Grain: A completely new grain appearing somewhere in the domain not overlapping any other grain's halo.

To figure out which case we are dealing with, we have to make another pass over all of the existing grains with matching variable indices to see if any of them have overlapping halos.

The "try-harder loop": OK so we still have an extra grain in the new set that isn't matched up against the old set and since the order parameter isn't reserved. We aren't really expecting a new grain. Let's try to make a few more attempts to see if this is a split grain even though it failed to match the criteria above. This might happen if the halo front is advancing too fast!

In this loop we'll make an attempt to match up this new grain to the old halos. If adaptivity is happening this could fail as elements in the new set may be at a different level than in the old set. If we get multiple matches, we'll compare the grain volumes (based on elements, not integrated to choose the closest).

Future ideas: Look at the volume fraction of the new grain and overlay it over the volume fraction of the old grain (would require more saved information, or an aux field hanging around (subject to projection problems).

Note that the old grains we are looking at will already be marked from the earlier tracking phase. We are trying to see if this unmatched grain is part of a larger whole. To do that we'll look at the halos across the time step.

Trigger callback for new grains

Definition at line 499 of file GrainTracker.C.

Referenced by GrainTracker::finalize().

500 {
501  TIME_SECTION("trackGrains", 3, "Tracking Grains");
502 
503  mooseAssert(!_first_time, "Track grains may only be called when _tracking_step > _t_step");
504 
505  // Used to track indices for which to trigger the new grain callback on (used on all ranks)
507 
512  if (_is_primary)
513  {
514  // Reset Status on active unique grains
515  std::vector<unsigned int> map_sizes(_maps_size);
516  for (auto & grain : _feature_sets_old)
517  {
518  if (grain._status != Status::INACTIVE)
519  {
520  grain._status = Status::CLEAR;
521  map_sizes[grain._var_index]++;
522  }
523  }
524 
525  // Print out stats on overall tracking changes per var_index
526  if (_verbosity_level > 0)
527  {
528  _console << "\nGrain Tracker Status:";
529  for (const auto map_num : make_range(_maps_size))
530  {
531  _console << "\nGrains active index " << map_num << ": " << map_sizes[map_num] << " -> "
532  << _feature_counts_per_map[map_num];
533  if (map_sizes[map_num] > _feature_counts_per_map[map_num])
534  _console << "--";
535  else if (map_sizes[map_num] < _feature_counts_per_map[map_num])
536  _console << "++";
537  }
538  _console << '\n' << std::endl;
539  }
540 
541  // Before we track grains, lets sort them so that we get parallel consistent answers
542  std::sort(_feature_sets.begin(), _feature_sets.end());
543 
550  std::vector<std::size_t> new_grain_index_to_existing_grain_index(_feature_sets.size(),
552 
553  for (const auto old_grain_index : index_range(_feature_sets_old))
554  {
555  auto & old_grain = _feature_sets_old[old_grain_index];
556 
557  if (old_grain._status == Status::INACTIVE) // Don't try to find matches for inactive grains
558  continue;
559 
560  std::size_t closest_match_index = invalid_size_t;
561  Real min_centroid_diff = std::numeric_limits<Real>::max();
562 
568  // clang-format off
569  auto start_it =
570  std::lower_bound(_feature_sets.begin(), _feature_sets.end(), old_grain._var_index,
571  [](const FeatureData & item, std::size_t var_index)
572  {
573  return item._var_index < var_index;
574  });
575  // clang-format on
576 
577  // We only need to examine grains that have matching variable indices
578  bool any_boxes_intersect = false;
579  for (MooseIndex(_feature_sets)
580  new_grain_index = std::distance(_feature_sets.begin(), start_it);
581  new_grain_index < _feature_sets.size() &&
582  _feature_sets[new_grain_index]._var_index == old_grain._var_index;
583  ++new_grain_index)
584  {
585  auto & new_grain = _feature_sets[new_grain_index];
586 
591  if (new_grain.boundingBoxesIntersect(old_grain))
592  {
593  any_boxes_intersect = true;
594  Real curr_centroid_diff = centroidRegionDistance(old_grain._bboxes, new_grain._bboxes);
595  if (curr_centroid_diff <= min_centroid_diff)
596  {
597  closest_match_index = new_grain_index;
598  min_centroid_diff = curr_centroid_diff;
599  }
600  }
601  }
602 
603  if (_verbosity_level > 2 && !any_boxes_intersect)
604  _console << "\nNo intersecting bounding boxes found while trying to match grain "
605  << old_grain;
606 
607  // found a match
608  if (closest_match_index != invalid_size_t)
609  {
616  auto curr_index = new_grain_index_to_existing_grain_index[closest_match_index];
617  if (curr_index != invalid_size_t)
618  {
619  // The new feature being competed for
620  auto & new_grain = _feature_sets[closest_match_index];
621 
622  // The other old grain competing to match up to the same new grain
623  auto & other_old_grain = _feature_sets_old[curr_index];
624 
625  auto centroid_diff1 = centroidRegionDistance(new_grain._bboxes, old_grain._bboxes);
626  auto centroid_diff2 = centroidRegionDistance(new_grain._bboxes, other_old_grain._bboxes);
627 
628  auto & inactive_grain = (centroid_diff1 < centroid_diff2) ? other_old_grain : old_grain;
629 
630  inactive_grain._status = Status::INACTIVE;
631  if (_verbosity_level > 0)
632  {
633  _console << COLOR_GREEN << "Marking Grain " << inactive_grain._id
634  << " as INACTIVE (variable index: " << inactive_grain._var_index << ")\n"
635  << COLOR_DEFAULT;
636  if (_verbosity_level > 1)
637  _console << inactive_grain;
638  }
639 
645  if (&inactive_grain == &other_old_grain)
646  new_grain_index_to_existing_grain_index[closest_match_index] = old_grain_index;
647  }
648  else
649  new_grain_index_to_existing_grain_index[closest_match_index] = old_grain_index;
650  }
651  }
652 
653  // Mark all resolved grain matches
654  for (const auto new_index : index_range(new_grain_index_to_existing_grain_index))
655  {
656  auto curr_index = new_grain_index_to_existing_grain_index[new_index];
657 
658  // This may be a new grain, we'll handle that case below
659  if (curr_index == invalid_size_t)
660  continue;
661 
662  mooseAssert(_feature_sets_old[curr_index]._id != invalid_id,
663  "Invalid ID in old grain structure");
664 
665  _feature_sets[new_index]._id = _feature_sets_old[curr_index]._id; // Transfer ID
666  _feature_sets[new_index]._status = Status::MARKED; // Mark the status in the new set
667  _feature_sets_old[curr_index]._status = Status::MARKED; // Mark the status in the old set
668  }
669 
684  // Case 1 (new grains in _feature_sets):
685  for (const auto grain_num : index_range(_feature_sets))
686  {
687  auto & grain = _feature_sets[grain_num];
688 
689  // New Grain
690  if (grain._status == Status::CLEAR)
691  {
710  // clang-format off
711  auto start_it =
712  std::lower_bound(_feature_sets.begin(), _feature_sets.end(), grain._var_index,
713  [](const FeatureData & item, std::size_t var_index)
714  {
715  return item._var_index < var_index;
716  });
717  // clang-format on
718 
719  // Loop over matching variable indices
720  for (MooseIndex(_feature_sets)
721  new_grain_index = std::distance(_feature_sets.begin(), start_it);
722  new_grain_index < _feature_sets.size() &&
723  _feature_sets[new_grain_index]._var_index == grain._var_index;
724  ++new_grain_index)
725  {
726  auto & other_grain = _feature_sets[new_grain_index];
727 
728  // Splitting grain?
729  if (grain_num != new_grain_index && // Make sure indices aren't pointing at the same grain
730  other_grain._status == Status::MARKED && // and that the other grain is indeed marked
731  other_grain.boundingBoxesIntersect(grain) && // and the bboxes intersect
732  other_grain.halosIntersect(grain)) // and the halos also intersect
733  // TODO: Inspect combined volume and see if it's "close" to the expected value
734  {
735  grain._id = other_grain._id; // Set the duplicate ID
736  grain._status = Status::MARKED; // Mark it
737 
738  if (_verbosity_level > 0)
739  _console << COLOR_YELLOW << "Split Grain Detected #" << grain._id
740  << " (variable index: " << grain._var_index << ")\n"
741  << COLOR_DEFAULT;
742  if (_verbosity_level > 1)
743  _console << grain << other_grain;
744  }
745  }
746 
747  if (grain._var_index < _reserve_op_index)
748  {
767  if (_verbosity_level > 1)
768  _console << COLOR_YELLOW
769  << "Trying harder to detect a split grain while examining grain on variable "
770  "index "
771  << grain._var_index << '\n'
772  << COLOR_DEFAULT;
773 
774  std::vector<std::size_t> old_grain_indices;
775  for (const auto old_grain_index : index_range(_feature_sets_old))
776  {
777  auto & old_grain = _feature_sets_old[old_grain_index];
778 
779  if (old_grain._status == Status::INACTIVE)
780  continue;
781 
787  if (grain._var_index == old_grain._var_index &&
788  grain.boundingBoxesIntersect(old_grain) && grain.halosIntersect(old_grain))
789  old_grain_indices.push_back(old_grain_index);
790  }
791 
792  if (old_grain_indices.size() == 1)
793  {
794  grain._id = _feature_sets_old[old_grain_indices[0]]._id;
795  grain._status = Status::MARKED;
796 
797  if (_verbosity_level > 0)
798  _console << COLOR_YELLOW << "Split Grain Detected #" << grain._id
799  << " (variable index: " << grain._var_index << ")\n"
800  << COLOR_DEFAULT;
801  }
802  else if (old_grain_indices.size() > 1)
803  _console
804  << COLOR_RED << "Split Grain Likely Detected #" << grain._id
805  << " Need more information to find correct candidate - contact a developer!\n\n"
806  << COLOR_DEFAULT;
807  }
808 
809  // Must be a nucleating grain (status is still not set)
810  if (grain._status == Status::CLEAR)
811  {
812  auto new_index = getNextUniqueID();
813  grain._id = new_index; // Set the ID
814  grain._status = Status::MARKED; // Mark it
815 
816  if (_verbosity_level > 0)
817  _console << COLOR_YELLOW << "Nucleating Grain Detected "
818  << " (variable index: " << grain._var_index << ")\n"
819  << COLOR_DEFAULT;
820  if (_verbosity_level > 1)
821  _console << grain;
822  }
823  }
824  }
825 
826  // Case 2 (inactive grains in _feature_sets_old)
827  for (auto & grain : _feature_sets_old)
828  {
829  if (grain._status == Status::CLEAR)
830  {
831  grain._status = Status::INACTIVE;
832  if (_verbosity_level > 0)
833  {
834  _console << COLOR_GREEN << "Marking Grain " << grain._id
835  << " as INACTIVE (variable index: " << grain._var_index << ")\n"
836  << COLOR_DEFAULT;
837  if (_verbosity_level > 1)
838  _console << grain;
839  }
840  }
841  }
842  } // is_primary
843 
844  /*************************************************************
845  ****************** COLLECTIVE WORK SECTION ******************
846  *************************************************************/
847 
848  // Make IDs on all non-primary ranks consistent
850 
851  // Build up an id to index map
854 
859  {
860  for (auto new_id = _old_max_grain_id + 1; new_id <= _max_curr_grain_id; ++new_id)
861  {
862  // Don't trigger the callback on the reserve IDs
864  {
865  // See if we've been instructed to terminate with an error
867  mooseError(
868  "Error: New grain detected and \"error_on_new_grain_creation\" is set to true");
869  else
870  newGrainCreated(new_id);
871  }
872  }
873  }
874 }
static const std::size_t invalid_size_t
bool & _first_time
Boolean to indicate the first time this object executes.
Definition: GrainTracker.h:230
std::vector< FeatureData > & _feature_sets
The data structure used to hold the globally unique features.
std::vector< FeatureData > _feature_sets_old
This data structure holds the map of unique grains from the previous time step.
Definition: GrainTracker.h:216
const bool _error_on_grain_creation
Boolean to terminate with an error if a new grain is created during the simulation.
Definition: GrainTracker.h:237
const bool _is_primary
Convenience variable for testing primary rank.
const Parallel::Communicator & _communicator
unsigned int _old_max_grain_id
The previous max grain id (needed to figure out which ids are new in a given step) ...
Definition: GrainTracker.h:244
unsigned int & _max_curr_grain_id
Holds the next "regular" grain ID (a grain found or remapped to the standard op vars) ...
Definition: GrainTracker.h:247
Real centroidRegionDistance(std::vector< BoundingBox > &bboxes1, std::vector< BoundingBox > &bboxes2) const
This method returns the minimum periodic distance between the centroids of two vectors of bounding bo...
const std::size_t _maps_size
Convenience variable holding the size of all the datastructures size by the number of maps...
const short _verbosity_level
Verbosity level controlling the amount of information printed to the console.
Definition: GrainTracker.h:224
static const unsigned int invalid_id
void broadcast(T &data, const unsigned int root_id=0, const bool identical_sizes=false) const
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
IntRange< T > make_range(T beg, T end)
std::vector< unsigned int > _feature_counts_per_map
The number of features seen by this object per map.
void mooseError(Args &&... args) const
const ConsoleStream _console
unsigned int _reserve_grain_first_index
Holds the first unique grain index when using _reserve_op (all the remaining indices are sequential) ...
Definition: GrainTracker.h:241
const std::size_t _reserve_op_index
The cutoff index where if variable index >= this number, no remapping TO that variable will occur...
Definition: GrainTracker.h:192
void buildFeatureIdToLocalIndices(unsigned int max_id)
This method builds a lookup map for retrieving the right local feature (by index) given a global inde...
void scatterAndUpdateRanks()
Calls buildLocalToGlobalIndices to build the individual local to global indicies for each rank and sc...
virtual void newGrainCreated(unsigned int new_grain_id)
This method is called when a new grain is detected.
Definition: GrainTracker.C:877
auto index_range(const T &sizable)
unsigned int getNextUniqueID()
Retrieve the next unique grain number if a new grain is detected during trackGrains.
const unsigned short _n_reserve_ops
The number of reserved order parameters.
Definition: GrainTracker.h:188

◆ updateBoundaryIntersections()

void FeatureFloodCount::updateBoundaryIntersections ( FeatureData feature) const
protectedinherited

Update the feature's attributes to indicate boundary intersections.

Definition at line 1772 of file FeatureFloodCount.C.

Referenced by FeatureFloodCount::prepareDataForTransfer().

1773 {
1774  if (_is_elemental)
1775  {
1776  for (auto entity : feature._local_ids)
1777  {
1778  // See if this feature is on a boundary if we haven't already figured that out
1779  if ((feature._boundary_intersection & BoundaryIntersection::ANY_BOUNDARY) ==
1781  {
1782  Elem * elem = _mesh.elemPtr(entity);
1783  if (elem && elem->on_boundary())
1784  feature._boundary_intersection |= BoundaryIntersection::ANY_BOUNDARY;
1785  }
1786 
1787  // Now see if the feature touches the primary and/or secondary boundary IDs if we haven't
1788  // figured that out already
1789  if ((feature._boundary_intersection & BoundaryIntersection::PRIMARY_PERCOLATION_BOUNDARY) ==
1791  {
1792  for (auto primary_id : _primary_perc_bnds)
1793  if (_mesh.isBoundaryElem(entity, primary_id))
1794  feature._boundary_intersection |= BoundaryIntersection::PRIMARY_PERCOLATION_BOUNDARY;
1795  }
1796 
1797  if ((feature._boundary_intersection & BoundaryIntersection::SECONDARY_PERCOLATION_BOUNDARY) ==
1799  {
1800  for (auto secondary_id : _secondary_perc_bnds)
1801  if (_mesh.isBoundaryElem(entity, secondary_id))
1802  feature._boundary_intersection |= BoundaryIntersection::SECONDARY_PERCOLATION_BOUNDARY;
1803  }
1804 
1805  // See if the feature contacts any of the user-specified boundaries if we haven't
1806  // done so already
1807  if ((feature._boundary_intersection & BoundaryIntersection::SPECIFIED_BOUNDARY) ==
1809  {
1810  for (auto specified_id : _specified_bnds)
1811  if (_mesh.isBoundaryElem(entity, specified_id))
1812  feature._boundary_intersection |= BoundaryIntersection::SPECIFIED_BOUNDARY;
1813  }
1814  }
1815  }
1816 }
std::vector< BoundaryID > _primary_perc_bnds
std::vector< BoundaryID > _specified_bnds
std::vector< BoundaryID > _secondary_perc_bnds
virtual Elem * elemPtr(const dof_id_type i)
const bool _is_elemental
Determines if the flood counter is elements or not (nodes)
bool isBoundaryElem(dof_id_type elem_id) const
MooseMesh & _mesh
A reference to the mesh.

◆ updateFieldInfo()

void GrainTracker::updateFieldInfo ( )
overrideprotectedvirtualinherited

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 from FeatureFloodCount.

Definition at line 1546 of file GrainTracker.C.

Referenced by GrainTracker::finalize().

1547 {
1548  TIME_SECTION("updateFieldInfo", 3, "Updating Field Info");
1549 
1550  for (const auto map_num : make_range(_maps_size))
1551  _feature_maps[map_num].clear();
1552 
1553  std::map<dof_id_type, Real> tmp_map;
1554 
1555  for (const auto & grain : _feature_sets)
1556  {
1557  std::size_t curr_var = grain._var_index;
1558  std::size_t map_index = (_single_map_mode || _condense_map_info) ? 0 : curr_var;
1559 
1560  for (auto entity : grain._local_ids)
1561  {
1562  // Highest variable value at this entity wins
1563  Real entity_value = std::numeric_limits<Real>::lowest();
1564  if (_is_elemental)
1565  {
1566  const Elem * elem = _mesh.elemPtr(entity);
1567  std::vector<Point> centroid(1, elem->vertex_average());
1568  if (_poly_ic_uo && _first_time)
1569  {
1570  entity_value = _poly_ic_uo->getVariableValue(grain._var_index, centroid[0]);
1571  }
1572  else
1573  {
1574  _fe_problem.reinitElemPhys(elem, centroid, 0);
1575  entity_value = _vars[curr_var]->sln()[0];
1576  }
1577  }
1578  else
1579  {
1580  auto node_ptr = _mesh.nodePtr(entity);
1581  entity_value = _vars[curr_var]->getNodalValue(*node_ptr);
1582  }
1583 
1584  if (entity_value != std::numeric_limits<Real>::lowest() &&
1585  (tmp_map.find(entity) == tmp_map.end() || entity_value > tmp_map[entity]))
1586  {
1587  mooseAssert(grain._id != invalid_id, "Missing Grain ID");
1588  _feature_maps[map_index][entity] = grain._id;
1589 
1590  if (_var_index_mode)
1591  _var_index_maps[map_index][entity] = grain._var_index;
1592 
1593  tmp_map[entity] = entity_value;
1594  }
1595 
1597  {
1598  auto insert_pair = moose_try_emplace(
1599  _entity_var_to_features, entity, std::vector<unsigned int>(_n_vars, invalid_id));
1600  auto & vec_ref = insert_pair.first->second;
1601 
1602  if (insert_pair.second)
1603  {
1604  // insert the reserve op numbers (if appropriate)
1605  for (const auto reserve_index : make_range(_n_reserve_ops))
1606  vec_ref[reserve_index] = _reserve_grain_first_index + reserve_index;
1607  }
1608  vec_ref[grain._var_index] = grain._id;
1609  }
1610  }
1611 
1612  if (_compute_halo_maps)
1613  for (auto entity : grain._halo_ids)
1614  _halo_ids[grain._var_index][entity] = grain._var_index;
1615 
1616  for (auto entity : grain._ghosted_ids)
1617  _ghosted_entity_ids[entity] = 1;
1618  }
1619 
1621 }
const std::size_t _n_vars
virtual Elem * elemPtr(const dof_id_type i)
const bool _condense_map_info
virtual Real getVariableValue(unsigned int op_index, const Point &p) const =0
Returns the variable value for a given op_index and mesh point.
bool & _first_time
Boolean to indicate the first time this object executes.
Definition: GrainTracker.h:230
std::vector< FeatureData > & _feature_sets
The data structure used to hold the globally unique features.
std::map< dof_id_type, std::vector< unsigned int > > _entity_var_to_features
std::pair< typename M::iterator, bool > moose_try_emplace(M &m, const typename M::key_type &k, Args &&... args)
const PolycrystalUserObjectBase *const _poly_ic_uo
An optional IC UserObject which can provide initial data structures to this object.
Definition: GrainTracker.h:219
std::map< dof_id_type, int > _ghosted_entity_ids
The map for holding reconstructed ghosted element information.
void communicateHaloMap()
std::vector< std::map< dof_id_type, int > > _halo_ids
The data structure for looking up halos around features.
std::vector< MooseVariable * > _vars
The vector of coupled in variables cast to MooseVariable.
virtual const Node * nodePtr(const dof_id_type i) const
const std::size_t _maps_size
Convenience variable holding the size of all the datastructures size by the number of maps...
static const unsigned int invalid_id
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...
const bool _single_map_mode
This variable is used to indicate whether or not multiple maps are used during flooding.
const bool _compute_halo_maps
Indicates whether or not to communicate halo map information with all ranks.
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
const bool _is_elemental
Determines if the flood counter is elements or not (nodes)
FEProblemBase & _fe_problem
IntRange< T > make_range(T beg, T end)
unsigned int _reserve_grain_first_index
Holds the first unique grain index when using _reserve_op (all the remaining indices are sequential) ...
Definition: GrainTracker.h:241
MooseMesh & _mesh
A reference to the mesh.
virtual void reinitElemPhys(const Elem *elem, const std::vector< Point > &phys_points_in_elem, const THREAD_ID tid) override
const bool _compute_var_to_feature_map
Indicates whether or not the var to feature map is populated.
const bool _var_index_mode
This variable is used to indicate whether the maps will contain unique region information or just the...
std::vector< std::map< dof_id_type, int > > _var_index_maps
This map keeps track of which variables own which nodes.
const unsigned short _n_reserve_ops
The number of reserved order parameters.
Definition: GrainTracker.h:188

◆ 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.

◆ validParams()

InputParameters GrainTrackerElasticity::validParams ( )
static

Definition at line 17 of file GrainTrackerElasticity.C.

18 {
20  params.addParam<bool>("random_rotations",
21  true,
22  "Generate random rotations when the Euler Angle "
23  "provider runs out of data (otherwise error "
24  "out)");
25  params.addRequiredParam<std::vector<Real>>("C_ijkl", "Unrotated stiffness tensor");
26  params.addParam<MooseEnum>(
27  "fill_method", RankFourTensor::fillMethodEnum() = "symmetric9", "The fill method");
28  params.addRequiredParam<UserObjectName>("euler_angle_provider",
29  "Name of Euler angle provider user object");
30  return params;
31 }
void addParam(const std::string &name, const std::initializer_list< typename T::value_type > &value, const std::string &doc_string)
void addRequiredParam(const std::string &name, const std::string &doc_string)
static InputParameters validParams()
Definition: GrainTracker.C:49
static MooseEnum fillMethodEnum()

◆ 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

In general, {evaluable elements} >= {local elements} U {algebraic ghosting elements}. That is, the number of evaluable elements does NOT necessarily equal to the number of local and algebraic ghosting elements. The neighbors of evaluable elements can be remote even though we have two layers of geometric ghosting elements.

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.

In general, {evaluable elements} >= {local elements} U {algebraic ghosting elements}. That is, the number of evaluable elements does NOT necessarily equal to the number of local and algebraic ghosting elements. The neighbors of evaluable elements can be remote even though we have two layers of geometric ghosting elements.

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 1616 of file FeatureFloodCount.C.

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

1620 {
1621  mooseAssert(elem, "Elem is NULL");
1622 
1623  std::vector<const Elem *> all_active_neighbors;
1624  MeshBase & mesh = _mesh.getMesh();
1625 
1626  // Loop over all neighbors (at the the same level as the current element)
1627  for (const auto i : make_range(elem->n_neighbors()))
1628  {
1629  const Elem * neighbor_ancestor = nullptr;
1630  bool topological_neighbor = false;
1631 
1636  neighbor_ancestor = elem->neighbor_ptr(i);
1637 
1638  if (neighbor_ancestor)
1639  {
1646  if (neighbor_ancestor->is_remote())
1647  continue;
1648 
1649  neighbor_ancestor->active_family_tree_by_neighbor(all_active_neighbors, elem, false);
1650  }
1651  else
1652  {
1653  neighbor_ancestor = elem->topological_neighbor(i, mesh, *_point_locator, _pbs);
1654 
1662  if (neighbor_ancestor)
1663  {
1670  if (neighbor_ancestor->is_remote())
1671  continue;
1672 
1673  neighbor_ancestor->active_family_tree_by_topological_neighbor(
1674  all_active_neighbors, elem, mesh, *_point_locator, _pbs, false);
1675 
1676  topological_neighbor = true;
1677  }
1678  else
1679  {
1685  updateBBoxExtremesHelper(feature->_bboxes[0], *elem);
1686  }
1687  }
1688 
1689  visitNeighborsHelper(elem,
1690  all_active_neighbors,
1691  feature,
1692  expand_halos_only,
1693  topological_neighbor,
1694  disjoint_only);
1695 
1696  all_active_neighbors.clear();
1697  }
1698 }
MeshBase & mesh
MeshBase & getMesh()
std::unique_ptr< PointLocatorBase > _point_locator
PeriodicBoundaries * _pbs
A pointer to the periodic boundary constraints object.
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.
IntRange< T > make_range(T beg, T end)
void updateBBoxExtremesHelper(BoundingBox &bbox, const Point &node)
MooseMesh & _mesh
A reference to the mesh.

◆ 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 1715 of file FeatureFloodCount.C.

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

1721 {
1722  // Loop over all active element neighbors
1723  for (const auto neighbor : neighbor_entities)
1724  {
1725  if (neighbor && (!_is_boundary_restricted || isBoundaryEntity(neighbor)))
1726  {
1727  if (expand_halos_only)
1728  {
1729  auto entity_id = neighbor->id();
1730 
1731  if (topological_neighbor || disjoint_only)
1732  feature->_disjoint_halo_ids.insert(feature->_disjoint_halo_ids.end(), entity_id);
1733  else if (!FeatureFloodCount::contains(feature->_local_ids, entity_id))
1734  feature->_halo_ids.insert(feature->_halo_ids.end(), entity_id);
1735  }
1736  else
1737  {
1738  auto my_processor_id = processor_id();
1739 
1740  if (!topological_neighbor && neighbor->processor_id() != my_processor_id)
1741  feature->_ghosted_ids.insert(feature->_ghosted_ids.end(), curr_entity->id());
1742 
1752  if (curr_entity->processor_id() == my_processor_id ||
1753  neighbor->processor_id() == my_processor_id)
1754  {
1761  if (topological_neighbor || disjoint_only)
1762  feature->_disjoint_halo_ids.insert(feature->_disjoint_halo_ids.end(), neighbor->id());
1763  else
1764  _entity_queue.push_front(neighbor);
1765  }
1766  }
1767  }
1768  }
1769 }
bool isBoundaryEntity(const T *entity) const
Returns a Boolean indicating whether the entity is on one of the desired boundaries.
static bool contains(std::set< T > &container, const T &item)
bool _is_boundary_restricted
Indicates that this object should only run on one or more boundaries.
processor_id_type processor_id() const
std::deque< const DofObject * > _entity_queue
The data structure for maintaining entities to flood during discovery.

◆ 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 1701 of file FeatureFloodCount.C.

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

1704 {
1705  mooseAssert(node, "Node is NULL");
1706 
1707  std::vector<const Node *> all_active_neighbors;
1708  MeshTools::find_nodal_neighbors(_mesh.getMesh(), *node, _nodes_to_elem_map, all_active_neighbors);
1709 
1710  visitNeighborsHelper(node, all_active_neighbors, feature, expand_halos_only, false, false);
1711 }
MeshBase & getMesh()
std::unordered_map< dof_id_type, std::vector< const Elem * > > _nodes_to_elem_map
The data structure used to find neighboring elements give a node ID.
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.
MooseMesh & _mesh
A reference to the mesh.

Member Data Documentation

◆ _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 695 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::meshChanged().

◆ _bnd_elem_range

ConstBndElemRange* FeatureFloodCount::_bnd_elem_range
protectedinherited

Boundary element range pointer.

Definition at line 713 of file FeatureFloodCount.h.

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

◆ _bound_value

const Real GrainTracker::_bound_value
protectedinherited

Absolute value of the lower bound used to represent a region not assigned to this grain, used when a grain is remapped to another order parameter.

The actual value used is -_bound_value

Definition at line 201 of file GrainTracker.h.

Referenced by GrainTracker::swapSolutionValuesHelper().

◆ _C_ijkl

RankFourTensor GrainTrackerElasticity::_C_ijkl
protected

unrotated elasticity tensor

Definition at line 34 of file GrainTrackerElasticity.h.

Referenced by newGrain().

◆ _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 588 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 591 of file FeatureFloodCount.h.

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

◆ _condense_map_info

const bool FeatureFloodCount::_condense_map_info
protectedinherited

◆ _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 561 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::initialize().

◆ _dof_map

const DofMap& FeatureFloodCount::_dof_map
protectedinherited

Reference to the dof_map containing the coupled variables.

Definition at line 553 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::flood().

◆ _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 676 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::initialize().

◆ _empty_var_to_features

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

◆ _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 615 of file FeatureFloodCount.h.

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

◆ _entity_var_to_features

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

◆ _error_on_grain_creation

const bool GrainTracker::_error_on_grain_creation
protectedinherited

Boolean to terminate with an error if a new grain is created during the simulation.

This is for simulations where new grains are not expected. Note, this does not impact the initial callback to newGrainCreated() nor does it get triggered for splitting grains.

Definition at line 237 of file GrainTracker.h.

Referenced by GrainTracker::trackGrains().

◆ _euler

const EulerAngleProvider& GrainTrackerElasticity::_euler
protected

object providing the Euler angles

Definition at line 37 of file GrainTrackerElasticity.h.

Referenced by newGrain().

◆ _fe_vars

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

The vector of coupled in variables.

Definition at line 548 of file FeatureFloodCount.h.

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

◆ _feature_count

unsigned int FeatureFloodCount::_feature_count
protectedinherited

◆ _feature_counts_per_map

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

◆ _feature_id_to_local_index

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

◆ _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 662 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 646 of file FeatureFloodCount.h.

Referenced by GrainTracker::assignGrains(), PolycrystalUserObjectBase::assignOpsToGrains(), 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().

◆ _feature_sets_old

std::vector<FeatureData> GrainTracker::_feature_sets_old
protectedinherited

This data structure holds the map of unique grains from the previous time step.

The information is updated each timestep to track grains over time.

Definition at line 216 of file GrainTracker.h.

Referenced by GrainTracker::initialize(), and GrainTracker::trackGrains().

◆ _first_time

bool& GrainTracker::_first_time
protectedinherited

Boolean to indicate the first time this object executes.

Note: _tracking_step isn't enough if people skip initial or execute more than once per step.

Definition at line 230 of file GrainTracker.h.

Referenced by GrainTracker::assignGrains(), GrainTracker::execute(), GrainTracker::finalize(), GrainTracker::initialize(), GrainTracker::newGrainCreated(), GrainTracker::prepopulateState(), GrainTracker::trackGrains(), and GrainTracker::updateFieldInfo().

◆ _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 679 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 581 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::updateFieldInfo().

◆ _grain_data

std::vector<RankFourTensor >& GrainDataTracker< RankFourTensor >::_grain_data
protectedinherited

per grain data

Definition at line 34 of file GrainDataTracker.h.

◆ _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 685 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().

◆ _halo_level

const unsigned short GrainTracker::_halo_level
protectedinherited

The thickness of the halo surrounding each grain.

Definition at line 182 of file GrainTracker.h.

Referenced by GrainTracker::finalize().

◆ _is_boundary_restricted

bool FeatureFloodCount::_is_boundary_restricted
protectedinherited

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

Definition at line 710 of file FeatureFloodCount.h.

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

◆ _is_elemental

const bool FeatureFloodCount::_is_elemental
protectedinherited

◆ _is_primary

const bool FeatureFloodCount::_is_primary
protectedinherited

◆ _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 665 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::scatterAndUpdateRanks().

◆ _maps_size

const std::size_t FeatureFloodCount::_maps_size
protectedinherited

◆ _max_remap_recursion_depth

const unsigned short GrainTracker::_max_remap_recursion_depth
protectedinherited

Depth of renumbering recursion (a depth of zero means no recursion)

Definition at line 185 of file GrainTracker.h.

Referenced by GrainTracker::remapGrains().

◆ _mesh

MooseMesh& FeatureFloodCount::_mesh
protectedinherited

◆ _n_procs

const processor_id_type FeatureFloodCount::_n_procs
protectedinherited

Convenience variable holding the number of processors in this simulation.

Definition at line 607 of file FeatureFloodCount.h.

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

◆ _n_reserve_ops

const unsigned short GrainTracker::_n_reserve_ops
protectedinherited

The number of reserved order parameters.

Definition at line 188 of file GrainTracker.h.

Referenced by GrainTracker::getNextUniqueID(), GrainTracker::trackGrains(), and GrainTracker::updateFieldInfo().

◆ _n_vars

const std::size_t FeatureFloodCount::_n_vars
protectedinherited

◆ _nl

NonlinearSystemBase& GrainTracker::_nl
protectedinherited

A reference to the nonlinear system (used for retrieving solution vectors)

Definition at line 210 of file GrainTracker.h.

Referenced by GrainTracker::remapGrains(), and GrainTracker::swapSolutionValuesHelper().

◆ _nodes_to_elem_map

std::unordered_map<dof_id_type, 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 626 of file FeatureFloodCount.h.

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

◆ _partial_feature_sets

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

◆ _pbs

PeriodicBoundaries* FeatureFloodCount::_pbs
protectedinherited

◆ _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 691 of file FeatureFloodCount.h.

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

◆ _point_locator

std::unique_ptr<PointLocatorBase> FeatureFloodCount::_point_locator
protectedinherited

◆ _poly_ic_uo

const PolycrystalUserObjectBase* const GrainTracker::_poly_ic_uo
protectedinherited

An optional IC UserObject which can provide initial data structures to this object.

Definition at line 219 of file GrainTracker.h.

Referenced by GrainTracker::execute(), GrainTracker::finalize(), GrainTracker::GrainTracker(), and GrainTracker::updateFieldInfo().

◆ _primary_perc_bnds

std::vector<BoundaryID> FeatureFloodCount::_primary_perc_bnds
protectedinherited

◆ _random_rotations

const bool GrainTrackerElasticity::_random_rotations
protected

generate random rotations when the Euler Angle provider runs out of data (otherwise error out)

Definition at line 31 of file GrainTrackerElasticity.h.

Referenced by newGrain().

◆ _remap

const bool GrainTracker::_remap
protectedinherited

Inidicates whether remapping should be done or not (remapping is independent of tracking)

Definition at line 204 of file GrainTracker.h.

Referenced by GrainTracker::finalize().

◆ _reserve_op_index

const std::size_t GrainTracker::_reserve_op_index
protectedinherited

The cutoff index where if variable index >= this number, no remapping TO that variable will occur.

Definition at line 192 of file GrainTracker.h.

Referenced by GrainTracker::computeMinDistancesFromGrain(), GrainTracker::getThreshold(), GrainTracker::remapGrains(), and GrainTracker::trackGrains().

◆ _reserve_op_threshold

const Real GrainTracker::_reserve_op_threshold
protectedinherited

The threshold above (or below) where a grain may be found on a reserve op field.

Definition at line 195 of file GrainTracker.h.

Referenced by GrainTracker::getThreshold().

◆ _secondary_perc_bnds

std::vector<BoundaryID> FeatureFloodCount::_secondary_perc_bnds
protectedinherited

◆ _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 575 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

◆ _step_connecting_threshold

Real FeatureFloodCount::_step_connecting_threshold
protectedinherited

◆ _step_threshold

Real FeatureFloodCount::_step_threshold
protectedinherited

◆ _threshold

const Real FeatureFloodCount::_threshold
protectedinherited

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

Definition at line 556 of file FeatureFloodCount.h.

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

◆ _tolerate_failure

const bool GrainTracker::_tolerate_failure
protectedinherited

Indicates whether we should continue after a remap failure (will result in non-physical results)

Definition at line 207 of file GrainTracker.h.

Referenced by GrainTracker::GrainTracker(), and GrainTracker::remapGrains().

◆ _tracking_step

const int GrainTracker::_tracking_step
protectedinherited

◆ _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 598 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 623 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 585 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 572 of file FeatureFloodCount.h.

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

◆ _vars

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

◆ _verbosity_level

const short GrainTracker::_verbosity_level
protectedinherited

Verbosity level controlling the amount of information printed to the console.

Definition at line 224 of file GrainTracker.h.

Referenced by GrainTracker::attemptGrainRenumber(), GrainTracker::finalize(), GrainTracker::remapGrains(), and GrainTracker::trackGrains().

◆ _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 655 of file FeatureFloodCount.h.

◆ invalid_id

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

◆ invalid_proc_id

const processor_id_type FeatureFloodCount::invalid_proc_id
staticinherited
Initial value:
=
std::numeric_limits<processor_id_type>::max()

Definition at line 93 of file FeatureFloodCount.h.

Referenced by PolycrystalUserObjectBase::numberOfDistributedMergeHelpers().

◆ invalid_size_t

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

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