GrainTracker derived class template to base objects on which maintain physical parameters for individual grains. More...

#include <GrainDataTracker.h>

Inheritance diagram for GrainDataTracker< T >:

[legend]

Public Types
enum class	RemapCacheMode { FILL , USE , BYPASS }

enum class	FieldType { UNIQUE_REGION , VARIABLE_COLORING , GHOSTED_ENTITIES , HALOS , CENTROID , ACTIVE_BOUNDS , INTERSECTS_SPECIFIED_BOUNDARY }

enum class	Status : unsigned char { CLEAR = 0x0 , MARKED = 0x1 , DIRTY = 0x2 , INACTIVE = 0x4 }
	This enumeration is used to indicate status of the grains in the _unique_grains data structure. More...

enum class	BoundaryIntersection : unsigned char { NONE = 0x0 , ANY_BOUNDARY = 0x1 , PRIMARY_PERCOLATION_BOUNDARY = 0x2 , SECONDARY_PERCOLATION_BOUNDARY = 0x4 , SPECIFIED_BOUNDARY = 0x8 }
	This enumeration is used to inidacate status of boundary intersections. More...

typedef DataFileName	DataFileParameterType

typedef FunctorBase< Real >	FunctorType

typedef Real	ValueType

typedef typename FunctorReturnType< Real, FunctorEvaluationKind::Gradient >::type	GradientType

typedef ValueType	DotType

enum	TEST_TYPE

Public Member Functions
	GrainDataTracker (const InputParameters &parameters)

const T &	getData (unsigned int grain_id) const
	return data for selected grain

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)

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.

virtual unsigned int	getFeatureVar (unsigned int feature_id) const override
	Returns the variable representing the passed in feature.

virtual std::size_t	getNumberActiveGrains () const override
	Returns the number of active grains current stored in the GrainTracker.

virtual Point	getGrainCentroid (unsigned int grain_id) const override
	Returns the centroid for the given grain number.

virtual bool	doesFeatureIntersectBoundary (unsigned int feature_id) const override
	Returns a Boolean indicating whether this feature intersects any boundary.

virtual bool	doesFeatureIntersectSpecifiedBoundary (unsigned int feature_id) const override
	Returns a Boolean indicating whether this feature intersects boundaries in a user-supplied list.

virtual bool	isFeaturePercolated (unsigned int feature_id) const override
	Returns a Boolean indicating whether this feature is percolated (e.g.

virtual std::vector< unsigned int >	getNewGrainIDs () const override
	This method returns all of the new ids generated in an invocation of the GrainTracker.

virtual void	initialSetup () override

virtual Real	getValue () const override

std::size_t	getNumberActiveFeatures () const
	Return the number of active features.

virtual Point	featureCentroid (unsigned int feature_id) const
	Returns the centroid of the designated feature (only supported without periodic boundaries)

std::size_t	numCoupledVars () const
	Returns the number of coupled varaibles.

const std::vector< MooseVariable * > &	getCoupledVars () const
	Returns a const vector to the coupled variable pointers.

const std::vector< MooseVariableFEBase * > &	getFECoupledVars () const
	Returns a const vector to the coupled MooseVariableFEBase pointers.

bool	isElemental () const

const std::vector< FeatureData > &	getFeatures () const
	Return a constant reference to the vector of all discovered features.

virtual Real	spatialValue (const Point &) const

virtual const std::vector< Point >	spatialPoints () const

void	setPrimaryThreadCopy (UserObject *primary)

UserObject *	primaryThreadCopy ()

SubProblem &	getSubProblem () const

bool	shouldDuplicateInitialExecution () const

void	gatherSum (T &value)

void	gatherMax (T &value)

void	gatherMin (T &value)

void	gatherProxyValueMax (T1 &proxy, T2 &value)

void	gatherProxyValueMin (T1 &proxy, T2 &value)

std::set< UserObjectName >	getDependObjects () const

const std::set< std::string > &	getRequestedItems () override

const std::set< std::string > &	getSuppliedItems () override

unsigned int	systemNumber () const

virtual bool	needThreadedCopy () const

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

std::shared_ptr< const MooseObject >	getSharedPtr () const

bool	isKokkosObject () const

MooseApp &	getMooseApp () const

const std::string &	type () const

const std::string &	name () const

std::string	typeAndName () const

MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const

MooseObjectName	uniqueName () const

const InputParameters &	parameters () const

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () 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 *	queryParam (const std::string &name) const

const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const

T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const

bool	isParamValid (const std::string &name) const

bool	isParamSetByUser (const std::string &name) const

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const

void	paramError (const std::string &param, Args... args) const

void	paramWarning (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

std::string	messagePrefix (const bool hit_prefix=true) const

std::string	errorPrefix (const std::string &) const

void	mooseError (Args &&... args) const

void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const

void	mooseErrorNonPrefixed (Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseDeprecatedNoTrace (Args &&... args) const

void	mooseInfo (Args &&... args) const

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const

std::string	getDataFileName (const std::string &param) const

std::string	getDataFileNameByName (const std::string &relative_path) const

std::string	getDataFilePath (const std::string &relative_path) 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 ExecFlagEnum &	getExecuteOnEnum () 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 UserObjectBase &	getUserObjectBase (const std::string &param_name, bool is_dependency=true) const

const UserObjectBase &	getUserObjectBaseByName (const UserObjectName &object_name, bool is_dependency=true) const

const std::vector< MooseVariableScalar * > &	getCoupledMooseScalarVars ()

const std::set< TagID > &	getScalarVariableCoupleableVectorTags () const

const std::set< TagID > &	getScalarVariableCoupleableMatrixTags () 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)

Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialPropertyByName (const std::string &prop_name_in)

Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialPropertyOldByName (const std::string &prop_name)

Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialPropertyOlderByName (const std::string &prop_name)

Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialProperty (const std::string &name)

Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialPropertyOld (const std::string &name)

Moose::Kokkos::MaterialProperty< T, dimension >	getKokkosMaterialPropertyOlder (const std::string &name)

std::pair< const MaterialProperty< T > *, std::set< SubdomainID > >	getBlockMaterialProperty (const MaterialPropertyName &name)

std::pair< Moose::Kokkos::MaterialProperty< T, dimension >, std::set< SubdomainID > >	getKokkosBlockMaterialProperty (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< SubdomainID >	getMaterialPropertyBlocks (const std::string &name)

std::vector< SubdomainName >	getMaterialPropertyBlockNames (const std::string &name)

std::set< BoundaryID >	getMaterialPropertyBoundaryIDs (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)

virtual bool	getMaterialPropertyCalled () const

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

Moose::StateArg	determineState () const

const PostprocessorValue &	getCurrentValue () 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 ()

const Moose::Functor< Real > *	defaultFunctor (const std::string &name)

const Moose::Functor< ADReal > *	defaultFunctor (const std::string &name)

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

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

void	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)

MaterialBase &	getMaterial (const std::string &name)

MaterialBase &	getMaterial (const std::string &name)

MaterialBase &	getMaterialByName (const std::string &name, bool no_warn=false)

MaterialBase &	getMaterialByName (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	hasKokkosMaterialProperty (const std::string &name)

bool	hasKokkosMaterialProperty (const std::string &name)

bool	hasKokkosMaterialPropertyByName (const std::string &name)

bool	hasKokkosMaterialPropertyByName (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 Function &	getFunction (const std::string &name) const

const Function &	getFunctionByName (const FunctionName &name) const

bool	hasFunction (const std::string &param_name) const

bool	hasFunctionByName (const FunctionName &name) const

Moose::Kokkos::Function	getKokkosFunction (const std::string &name) const

const T &	getKokkosFunction (const std::string &name) const

Moose::Kokkos::Function	getKokkosFunctionByName (const FunctionName &name) const

const T &	getKokkosFunctionByName (const FunctionName &name) const

bool	hasKokkosFunction (const std::string &param_name) const

bool	hasKokkosFunctionByName (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 VectorPostprocessorValue &	getVectorPostprocessorValue (const std::string &param_name, const std::string &vector_name) const

const VectorPostprocessorValue &	getVectorPostprocessorValue (const std::string &param_name, const std::string &vector_name, bool needs_broadcast) const

const VectorPostprocessorValue &	getVectorPostprocessorValueByName (const VectorPostprocessorName &name, const std::string &vector_name) const

const VectorPostprocessorValue &	getVectorPostprocessorValueByName (const VectorPostprocessorName &name, const std::string &vector_name, bool needs_broadcast) const

const VectorPostprocessorValue &	getVectorPostprocessorValueOld (const std::string &param_name, const std::string &vector_name) const

const VectorPostprocessorValue &	getVectorPostprocessorValueOld (const std::string &param_name, const std::string &vector_name, bool needs_broadcast) const

const VectorPostprocessorValue &	getVectorPostprocessorValueOldByName (const VectorPostprocessorName &name, const std::string &vector_name) const

const VectorPostprocessorValue &	getVectorPostprocessorValueOldByName (const VectorPostprocessorName &name, const std::string &vector_name, bool needs_broadcast) const

const ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValue (const std::string &param_name, const std::string &vector_name) const

const ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValueByName (const VectorPostprocessorName &name, const std::string &vector_name) const

const ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValueOld (const std::string &param_name, const std::string &vector_name) const

const ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValueOldByName (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)

Sampler &	getSampler (const std::string &name)

T &	getSamplerByName (const SamplerName &name)

Sampler &	getSamplerByName (const SamplerName &name)

virtual void	meshDisplaced ()

PerfGraph &	perfGraph ()

const PostprocessorValue &	getPostprocessorValue (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValue (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOld (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOld (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOlder (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOlder (const std::string &param_name, const unsigned int index=0) const

virtual const PostprocessorValue &	getPostprocessorValueByName (const PostprocessorName &name) const

virtual const PostprocessorValue &	getPostprocessorValueByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOldByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOldByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOlderByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOlderByName (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 Distribution &	getDistribution (const std::string &name) const

const T &	getDistribution (const std::string &name) const

const Distribution &	getDistribution (const std::string &name) const

const T &	getDistribution (const std::string &name) const

const Distribution &	getDistributionByName (const DistributionName &name) const

const T &	getDistributionByName (const std::string &name) const

const Distribution &	getDistributionByName (const DistributionName &name) const

const T &	getDistributionByName (const std::string &name) const

const ADVariableValue *	getADDefaultValue (const std::string &var_name) const

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () 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 ADVectorVariableValue *	getADDefaultVectorValue (const std::string &var_name) const

const ADVariableGradient &	getADDefaultGradient () const

const ADVectorVariableGradient &	getADDefaultVectorGradient () const

const ADVariableSecond &	getADDefaultSecond () const

const ADVectorVariableCurl &	getADDefaultCurl () const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagValueByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagValuesByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::VariableGradient	kokkosCoupledVectorTagGradientByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::VariableGradient	kokkosCoupledVectorTagGradientsByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagNodalValueByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagNodalValuesByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagDofValueByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagDofValuesByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagValues (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::VariableGradient	kokkosCoupledVectorTagGradient (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::VariableGradient	kokkosCoupledVectorTagGradients (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagNodalValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagNodalValues (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagDofValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledVectorTagDofValues (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorValueByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorValuesByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorTagVectorGradientByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorTagVectorGradientsByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorNodalValueByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorNodalValuesByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorDofValueByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorDofValuesByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorValues (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorTagVectorGradient (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorTagVectorGradients (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorNodalValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorNodalValues (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorDofValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorTagVectorDofValues (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::VariableValue	kokkosCoupledValue (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledValues (const std::string &var_name) const

Moose::Kokkos::VariableGradient	kokkosCoupledGradient (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableGradient	kokkosCoupledGradients (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledNodalValue (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledNodalValues (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledDofValue (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledDofValues (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledValueOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledValuesOld (const std::string &var_name) const

Moose::Kokkos::VariableGradient	kokkosCoupledGradientOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableGradient	kokkosCoupledGradientsOld (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledNodalValueOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledNodalValuesOld (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledDofValueOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledDofValuesOld (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledValueOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledValuesOlder (const std::string &var_name) const

Moose::Kokkos::VariableGradient	kokkosCoupledGradientOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableGradient	kokkosCoupledGradientsOlder (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledNodalValueOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledNodalValuesOlder (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledDofValueOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledDofValuesOlder (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledDot (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledDots (const std::string &var_name) const

Moose::Kokkos::VariableValue	kokkosCoupledNodalDot (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosCoupledNodalDots (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorValue (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorGradient (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorNodalValue (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorDofValue (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorValues (const std::string &var_name) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorGradients (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorNodalValues (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorDofValues (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorValueOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorGradientOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorNodalValueOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorDofValueOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorValuesOld (const std::string &var_name) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorGradientsOld (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorNodalValuesOld (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorDofValuesOld (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorValueOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorGradientOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorNodalValueOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorDofValueOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorValuesOlder (const std::string &var_name) const

Moose::Kokkos::VectorVariableGradient	kokkosCoupledVectorGradientsOlder (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorNodalValuesOlder (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorDofValuesOlder (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorDot (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorNodalDot (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorDots (const std::string &var_name) const

Moose::Kokkos::VectorVariableValue	kokkosCoupledVectorNodalDots (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagValueByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagValuesByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledVectorTagGradientByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledVectorTagGradientsByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagNodalValueByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagNodalValuesByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagDofValueByName (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagDofValuesByName (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagValues (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledVectorTagGradient (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledVectorTagGradients (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagNodalValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagNodalValues (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagDofValue (const std::string &var_name, const std::string &tag_param_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledVectorTagDofValues (const std::string &var_name, const std::string &tag_param_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledValue (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledValues (const std::string &var_name) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledGradient (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledGradients (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledNodalValue (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledNodalValues (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledDofValue (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledDofValues (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledValueOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledValuesOld (const std::string &var_name) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledGradientOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledGradientsOld (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledNodalValueOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledNodalValuesOld (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledDofValueOld (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledDofValuesOld (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledValueOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledValuesOlder (const std::string &var_name) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledGradientOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableGradient	kokkosADCoupledGradientsOlder (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledNodalValueOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledNodalValuesOlder (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledDofValueOlder (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledDofValuesOlder (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledDot (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledDots (const std::string &var_name) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledNodalDot (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::ADVariableValue	kokkosADCoupledNodalDots (const std::string &var_name) const

Moose::Kokkos::Scalar< const Real >	kokkosCoupledDotDu (const std::string &var_name, unsigned int comp=0) const

Moose::Kokkos::VariableValue	kokkosZeroValue () const

Moose::Kokkos::VariableGradient	kokkosZeroGradient () const

Moose::Kokkos::VariableValue	kokkosZeroNodalValue () const

const std::set< MooseVariableFieldBase * > &	getMooseVariableDependencies () const

std::set< MooseVariableFieldBase * >	checkAllVariables (const DofObjectType &dof_object, const std::set< MooseVariableFieldBase * > &vars_to_omit={})

virtual std::set< MooseVariableFieldBase * >	checkVariables (const libMesh::Node &node, const std::set< MooseVariableFieldBase * > &vars_to_check)

std::set< MooseVariableFieldBase * >	checkVariables (const libMesh::Elem &element, const std::set< MooseVariableFieldBase * > &vars_to_check)

void	addMooseVariableDependency (MooseVariableFieldBase *var)

void	addMooseVariableDependency (const std::vector< MooseVariableFieldBase * > &vars)

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	callMooseError (MooseApp const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node node, const bool show_trace=true)

static void	sortDFS (typename std::vector< T > &vector)

static void	cyclicDependencyError (CyclicDependencyException< T2 > &e, const std::string &header, NameFunc &&name_func)

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
	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console

	ALL

	ANY

Static Public Attributes
static const std::string	type_param

static const std::string	name_param

static const std::string	unique_name_param

static const std::string	app_param

static const std::string	moose_base_param

static const std::string	kokkos_object_param

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
virtual T	newGrain (unsigned int new_grain_id)=0
	implement this method to initialize the data for the new grain

virtual void	newGrainCreated (unsigned int new_grain_id)
	This method is called when a new grain is detected.

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

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.

void	prepopulateState (const FeatureFloodCount &ffc_object)
	This method extracts the necessary state from the passed in object necessary to continue tracking grains.

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.

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

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

void	broadcastAndUpdateGrainData ()
	Broadcast essential Grain information to all processors.

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.

bool	attemptGrainRenumber (FeatureData &grain, unsigned int depth, unsigned int max_depth)
	This is the recursive part of the remapping algorithm.

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.

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.

Real	boundingRegionDistance (std::vector< BoundingBox > &bboxes1, std::vector< BoundingBox > &bboxes2) const
	This method returns the minimum periodic distance between two vectors of bounding boxes.

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.

unsigned int	getNextUniqueID ()
	Retrieve the next unique grain number if a new grain is detected during trackGrains.

template<typename T >
bool	isBoundaryEntity (const T *entity) const
	Returns a Boolean indicating whether the entity is on one of the desired boundaries.

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.

virtual Real	getConnectingThreshold (std::size_t current_index) const
	Return the "connecting" comparison threshold to use when inspecting an entity during the flood stage.

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

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.

void	expandEdgeHalos (unsigned int num_layers_to_expand)
	This method expands the existing halo set by some width determined by the passed in value.

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.

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

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.

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.

virtual void	mergeSets ()
	This routine is called on the primary rank only and stitches together the partial feature pieces seen on any processor.

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.

virtual bool	areFeaturesMergeable (const FeatureData &f1, const FeatureData &f2) const
	Method for determining whether two features are mergeable.

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.

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

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.

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

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.

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.

virtual void	clearDataStructures ()
	Helper routine for clearing up data structures during initialize and prior to parallel communication.

void	updateBoundaryIntersections (FeatureData &feature) const
	Update the feature's attributes to indicate boundary intersections.

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.

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.

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 UserObjectBase &uo) const override

void	addReporterDependencyHelper (const ReporterName &reporter_name) override

void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) const

const ReporterContextBase &	getReporterContextBaseByName (const ReporterName &reporter_name) const

const ReporterName &	getReporterName (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

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

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

libMesh::Order	coupledScalarOrder (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarValue (const std::string &var_name, unsigned int comp=0) const

const ADVariableValue &	adCoupledScalarValue (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 VariableValue &	coupledVectorTagScalarValue (const std::string &var_name, TagID tag, unsigned int comp=0) const

const VariableValue &	coupledMatrixTagScalarValue (const std::string &var_name, TagID tag, unsigned int comp=0) const

const VariableValue &	coupledScalarValueOld (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarValueOlder (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDot (const std::string &var_name, unsigned int comp=0) const

const ADVariableValue &	adCoupledScalarDot (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotDot (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotOld (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotDotOld (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotDu (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledScalarDotDotDu (const std::string &var_name, unsigned int comp=0) const

const MooseVariableScalar *	getScalarVar (const std::string &var_name, unsigned int comp) const

virtual void	checkMaterialProperty (const std::string &name, const unsigned int state)

virtual void	getKokkosMaterialPropertyHook (const std::string &, const unsigned int)

void	markMatPropRequested (const std::string &)

MaterialPropertyName	getMaterialPropertyName (const std::string &name) const

void	checkExecutionStage ()

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 Moose::Functor< T > &	getFunctorByName (const std::string &name)

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 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 int >	coupledIndices (const std::string &var_name) const

virtual const VariableValue &	coupledValue (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

const GenericVectorVariableValue< is_ad > &	coupledGenericVectorValue (const std::string &var_name, unsigned int comp=0) const

const GenericVectorVariableValue< false > &	coupledGenericVectorValue (const std::string &var_name, unsigned int comp) const

const GenericVectorVariableValue< true > &	coupledGenericVectorValue (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

const GenericVariableValue< is_ad > &	coupledGenericDot (const std::string &var_name, unsigned int comp=0) const

const GenericVariableValue< false > &	coupledGenericDot (const std::string &var_name, unsigned int comp) const

const GenericVariableValue< true > &	coupledGenericDot (const std::string &var_name, unsigned int comp) const

const GenericVariableValue< is_ad > &	coupledGenericDotDot (const std::string &var_name, unsigned int comp=0) const

const GenericVariableValue< false > &	coupledGenericDotDot (const std::string &var_name, unsigned int comp) const

const GenericVariableValue< true > &	coupledGenericDotDot (const std::string &var_name, unsigned int comp) const

virtual const VariableValue &	coupledValueLower (const std::string &var_name, unsigned int comp=0) const

const ADVariableValue &	adCoupledValue (const std::string &var_name, unsigned int comp=0) const

std::vector< const ADVariableValue * >	adCoupledValues (const std::string &var_name) const

const ADVariableValue &	adCoupledLowerValue (const std::string &var_name, unsigned int comp=0) const

const ADVectorVariableValue &	adCoupledVectorValue (const std::string &var_name, unsigned int comp=0) const

std::vector< const ADVectorVariableValue * >	adCoupledVectorValues (const std::string &var_name) const

virtual const VariableValue &	coupledVectorTagValue (const std::string &var_names, TagID tag, unsigned int index=0) const

virtual const VariableValue &	coupledVectorTagValue (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 ArrayVariableValue &	coupledVectorTagArrayValue (const std::string &var_names, TagID tag, unsigned int index=0) const

virtual const ArrayVariableValue &	coupledVectorTagArrayValue (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 VariableGradient &	coupledVectorTagGradient (const std::string &var_names, TagID tag, unsigned int index=0) const

virtual const VariableGradient &	coupledVectorTagGradient (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 ArrayVariableGradient &	coupledVectorTagArrayGradient (const std::string &var_names, TagID tag, unsigned int index=0) const

virtual const ArrayVariableGradient &	coupledVectorTagArrayGradient (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 VariableValue &	coupledVectorTagDofValue (const std::string &var_name, TagID tag, unsigned int index=0) const

virtual const VariableValue &	coupledVectorTagDofValue (const std::string &var_names, const std::string &tag_name, unsigned int index=0) const

const ArrayVariableValue &	coupledVectorTagArrayDofValue (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 VariableValue &	coupledMatrixTagValue (const std::string &var_names, TagID tag, unsigned int index=0) const

virtual const VariableValue &	coupledMatrixTagValue (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 VectorVariableValue &	coupledVectorValue (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableValue &	coupledArrayValue (const std::string &var_name, unsigned int comp=0) const

std::vector< const ArrayVariableValue * >	coupledArrayValues (const std::string &var_name) const

MooseWritableVariable &	writableVariable (const std::string &var_name, unsigned int comp=0)

virtual VariableValue &	writableCoupledValue (const std::string &var_name, unsigned int comp=0)

void	checkWritableVar (MooseWritableVariable *var)

virtual const VariableValue &	coupledValueOld (const std::string &var_name, unsigned int comp=0) const

std::vector< const VariableValue * >	coupledValuesOld (const std::string &var_name) const

std::vector< const VectorVariableValue * >	coupledVectorValuesOld (const std::string &var_name) const

virtual const VariableValue &	coupledValueOlder (const std::string &var_name, unsigned int comp=0) const

std::vector< const VariableValue * >	coupledValuesOlder (const std::string &var_name) const

virtual const VariableValue &	coupledValuePreviousNL (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableValue &	coupledVectorValueOld (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableValue &	coupledVectorValueOlder (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableValue &	coupledArrayValueOld (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableValue &	coupledArrayValueOlder (const std::string &var_name, unsigned int comp=0) const

virtual const VariableGradient &	coupledGradient (const std::string &var_name, unsigned int comp=0) const

std::vector< const VariableGradient * >	coupledGradients (const std::string &var_name) const

const ADVariableGradient &	adCoupledGradient (const std::string &var_name, unsigned int comp=0) const

const ADVariableGradient &	adCoupledGradientDot (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 ADVectorVariableGradient &	adCoupledVectorGradient (const std::string &var_name, unsigned int comp=0) const

const ADVariableSecond &	adCoupledSecond (const std::string &var_name, unsigned int comp=0) const

const ADVectorVariableSecond &	adCoupledVectorSecond (const std::string &var_name, unsigned int comp=0) const

virtual const VariableGradient &	coupledGradientOld (const std::string &var_name, unsigned int comp=0) const

std::vector< const VariableGradient * >	coupledGradientsOld (const std::string &var_name) const

virtual const VariableGradient &	coupledGradientOlder (const std::string &var_name, unsigned int comp=0) const

virtual const VariableGradient &	coupledGradientPreviousNL (const std::string &var_name, unsigned int comp=0) const

virtual const VariableGradient &	coupledGradientDot (const std::string &var_name, unsigned int comp=0) const

virtual const VariableGradient &	coupledGradientDotDot (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableGradient &	coupledVectorGradient (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableGradient &	coupledVectorGradientOld (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableGradient &	coupledVectorGradientOlder (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableGradient &	coupledArrayGradient (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableGradient &	coupledArrayGradientOld (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableGradient &	coupledArrayGradientOlder (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableGradient &	coupledArrayGradientDot (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableCurl &	coupledCurl (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableCurl &	coupledCurlOld (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableCurl &	coupledCurlOlder (const std::string &var_name, unsigned int comp=0) const

const ADVectorVariableCurl &	adCoupledCurl (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableDivergence &	coupledDiv (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableDivergence &	coupledDivOld (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableDivergence &	coupledDivOlder (const std::string &var_name, unsigned int comp=0) const

virtual const VariableSecond &	coupledSecond (const std::string &var_name, unsigned int comp=0) const

virtual const VariableSecond &	coupledSecondOld (const std::string &var_name, unsigned int comp=0) const

virtual const VariableSecond &	coupledSecondOlder (const std::string &var_name, unsigned int comp=0) const

virtual const VariableSecond &	coupledSecondPreviousNL (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledDot (const std::string &var_name, unsigned int comp=0) const

std::vector< const VariableValue * >	coupledDots (const std::string &var_name) const

virtual const VariableValue &	coupledDotDot (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledDotOld (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledDotDotOld (const std::string &var_name, unsigned int comp=0) const

const ADVariableValue &	adCoupledDot (const std::string &var_name, unsigned int comp=0) const

std::vector< const ADVariableValue * >	adCoupledDots (const std::string &var_name) const

const ADVariableValue &	adCoupledDotDot (const std::string &var_name, unsigned int comp=0) const

const ADVectorVariableValue &	adCoupledVectorDot (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableValue &	coupledVectorDot (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableValue &	coupledVectorDotDot (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableValue &	coupledVectorDotOld (const std::string &var_name, unsigned int comp=0) const

virtual const VectorVariableValue &	coupledVectorDotDotOld (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledVectorDotDu (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledVectorDotDotDu (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableValue &	coupledArrayDot (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableValue &	coupledArrayDotDot (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableValue &	coupledArrayDotOld (const std::string &var_name, unsigned int comp=0) const

virtual const ArrayVariableValue &	coupledArrayDotDotOld (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledDotDu (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledDotDotDu (const std::string &var_name, unsigned int comp=0) const

const VariableValue &	coupledArrayDotDu (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 >::type &	adCoupledNodalValue (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 VariableValue &	coupledNodalDotDot (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledNodalDotOld (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledNodalDotDotOld (const std::string &var_name, unsigned int comp=0) const

virtual const VariableValue &	coupledDofValues (const std::string &var_name, unsigned int comp=0) const

std::vector< const VariableValue * >	coupledAllDofValues (const std::string &var_name) const

virtual const VariableValue &	coupledDofValuesOld (const std::string &var_name, unsigned int comp=0) const

std::vector< const VariableValue * >	coupledAllDofValuesOld (const std::string &var_name) const

virtual const VariableValue &	coupledDofValuesOlder (const std::string &var_name, unsigned int comp=0) const

std::vector< const VariableValue * >	coupledAllDofValuesOlder (const std::string &var_name) const

virtual const ArrayVariableValue &	coupledArrayDofValues (const std::string &var_name, unsigned int comp=0) const

virtual const ADVariableValue &	adCoupledDofValues (const std::string &var_name, unsigned int comp=0) const

const ADVariableValue &	adZeroValue () const

const ADVariableGradient &	adZeroGradient () const

const ADVariableSecond &	adZeroSecond () 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 MooseVariableFieldBase *	getFEVar (const std::string &var_name, unsigned int comp) const

const MooseVariableFieldBase *	getFieldVar (const std::string &var_name, unsigned int comp) const

MooseVariableFieldBase *	getFieldVar (const std::string &var_name, unsigned int comp)

std::vector< const MooseVariableFieldBase * >	getFieldVars (const std::string &var_name) const

const T *	getVarHelper (const std::string &var_name, unsigned int comp) const

T *	getVarHelper (const std::string &var_name, unsigned int comp)

std::vector< const T * >	getVarsHelper (const std::string &var_name) const

MooseVariable *	getVar (const std::string &var_name, unsigned int comp)

const MooseVariable *	getVar (const std::string &var_name, unsigned int comp) const

VectorMooseVariable *	getVectorVar (const std::string &var_name, unsigned int comp)

const VectorMooseVariable *	getVectorVar (const std::string &var_name, unsigned int comp) const

ArrayMooseVariable *	getArrayVar (const std::string &var_name, unsigned int comp)

const ArrayMooseVariable *	getArrayVar (const std::string &var_name, unsigned int comp) const

std::vector< T >	coupledVectorHelper (const std::string &var_name, const Func &func) const

bool	hasBoundaryMaterialPropertyHelper (const std::string &prop_name) const

KOKKOS_FUNCTION dof_id_type	numKokkosBoundaryNodes () const

KOKKOS_FUNCTION dof_id_type	numKokkosBoundarySides () const

KOKKOS_FUNCTION ContiguousNodeID	kokkosBoundaryNodeID (Moose::Kokkos::ThreadID tid) const

KOKKOS_FUNCTION auto	kokkosBoundaryElementSideID (Moose::Kokkos::ThreadID tid) 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.

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
std::vector< T > &	_grain_data
	per grain data

const int	_tracking_step
	The timestep to begin tracking grains.

const unsigned short	_halo_level
	The thickness of the halo surrounding each grain.

const unsigned short	_max_remap_recursion_depth
	Depth of renumbering recursion (a depth of zero means no recursion)

const unsigned short	_n_reserve_ops
	The number of reserved order parameters.

const std::size_t	_reserve_op_index
	The cutoff index where if variable index >= this number, no remapping TO that variable will occur.

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

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.

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

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

std::vector< FeatureData >	_feature_sets_old
	This data structure holds the map of unique grains from the previous time step.

const PolycrystalUserObjectBase *const	_poly_ic_uo
	An optional IC UserObject which can provide initial data structures to this object.

const short	_verbosity_level
	Verbosity level controlling the amount of information printed to the console.

bool &	_first_time
	Boolean to indicate the first time this object executes.

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

std::vector< MooseVariableFEBase * >	_fe_vars
	The vector of coupled in variables.

std::vector< MooseVariable * >	_vars
	The vector of coupled in variables cast to MooseVariable.

const DofMap &	_dof_map
	Reference to the dof_map containing the coupled variables.

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

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)

Real	_step_connecting_threshold

MooseMesh &	_mesh
	A reference to the mesh.

unsigned long	_var_number
	This variable is used to build the periodic node map.

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

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.

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.

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

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

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

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.

const processor_id_type	_n_procs
	Convenience variable holding the number of processors in this simulation.

std::vector< std::set< dof_id_type > >	_entities_visited
	This variable keeps track of which nodes have been visited during execution.

std::vector< std::map< dof_id_type, int > >	_var_index_maps
	This map keeps track of which variables own which nodes.

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.

std::vector< unsigned int >	_feature_counts_per_map
	The number of features seen by this object per map.

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 merging phases.

std::vector< FeatureData > &	_feature_sets
	The data structure used to hold the globally unique features.

std::vector< FeatureData >	_volatile_feature_sets
	Derived objects (e.g.

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.

std::vector< std::size_t >	_local_to_global_feature_map
	The vector recording the local to global feature indices.

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)

libMesh::PeriodicBoundaries *	_pbs
	A pointer to the periodic boundary constraints object.

std::unique_ptr< libMesh::PointLocatorBase >	_point_locator

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

std::map< dof_id_type, int >	_ghosted_entity_ids
	The map for holding reconstructed ghosted element information.

std::vector< std::map< dof_id_type, int > >	_halo_ids
	The data structure for looking up halos around features.

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.

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.

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)

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

ConstBndElemRange *	_bnd_elem_range
	Boundary element range pointer.

const bool	_is_primary
	Convenience variable for testing primary rank.

const Moose::CoordinateSystemType &	_coord_sys

const THREAD_ID	_tid

SubProblem &	_subproblem

FEProblemBase &	_fe_problem

SystemBase &	_sys

Assembly &	_assembly

const bool	_duplicate_initial_execution

std::set< std::string >	_depend_uo

const bool &	_enabled

MooseApp &	_app

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

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 &	_mdi_feproblem

MooseApp &	_pg_moose_app

const std::string	_prefix

FEProblemBase &	_sc_fe_problem

const THREAD_ID	_sc_tid

const Real &	_real_zero

const VariableValue &	_scalar_zero

const Point &	_point_zero

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 bool	_is_kokkos_object

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

const Real &	_t_old

int &	_t_step

Real &	_dt

Real &	_dt_old

const std::string &	_pp_name

const PostprocessorValue &	_current_value

std::unordered_map< std::string, std::vector< std::unique_ptr< VariableValue > > >	_default_value

const Parallel::Communicator &	_communicator

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< MooseVariableField< Real > * >	_coupled_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< ADReal > > >	_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

MooseArray< ADRealVectorValue >	_ad_default_curl

const VariableValue &	_zero

const VariablePhiValue &	_phi_zero

const MooseArray< ADReal > &	_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

VectorVariableDivergence	_default_div

ArrayVariableValue	_default_array_value_zero

ArrayVariableGradient	_default_array_gradient

bool	_coupleable_neighbor

Static Protected Attributes
static const std::string	_interpolated_old

static const std::string	_interpolated_older

Private Types
typedef Moose::ElemArg	ElemArg

typedef Moose::ElemQpArg	ElemQpArg

typedef Moose::ElemSideQpArg	ElemSideQpArg

typedef Moose::FaceArg	FaceArg

typedef Moose::ElemPointArg	ElemPointArg

typedef Moose::NodeArg	NodeArg

enum	FuncAge

enum	VarType

Private Member Functions
const Moose::Functor< T > *	defaultFunctor (const std::string &name)

const Moose::Functor< Real > *	defaultFunctor (const std::string &name)

const Moose::Functor< ADReal > *	defaultFunctor (const std::string &name)

const Moose::Functor< T > &	getFunctorByName (const std::string &name, SubProblem &subproblem, THREAD_ID tid)

const Moose::FunctionBase *	getKokkosFunctionByNameHelper (const FunctionName &name) const

const UserObjectBase &	getUserObjectFromFEProblem (const UserObjectName &object_name, const THREAD_ID tid=0) const

const T &	castUserObject (const UserObjectBase &uo_base, const std::string &param_name="") const

void	mooseObjectError (const std::string &param_name, std::stringstream &oss) const

const std::string &	userObjectType (const UserObjectBase &uo) const

const std::string &	userObjectName (const UserObjectBase &uo) const

const PostprocessorName &	getPostprocessorNameInternal (const std::string &param_name, const unsigned int index, const bool allow_default_value=true) const

bool	isDefaultPostprocessorValueByName (const PostprocessorName &name) const

PostprocessorValue	getDefaultPostprocessorValueByName (const PostprocessorName &name) const

void	checkParam (const std::string &param_name, const unsigned int index=std::numeric_limits< unsigned int >::max()) const

bool	postprocessorsAdded () const

const VectorPostprocessorValue &	getVectorPostprocessorByNameHelper (const VectorPostprocessorName &name, const std::string &vector_name, bool broadcast, std::size_t t_index) const

const VectorPostprocessorContext< VectorPostprocessorValue > &	getVectorPostprocessorContextByNameHelper (const VectorPostprocessorName &name, const std::string &vector_name) const

bool	vectorPostprocessorsAdded () const

bool	reportersAdded () const

void	possiblyCheckHasReporter (const ReporterName &reporter_name, const std::string &param_name="") const

RestartableDataValue &	registerRestartableDataOnApp (std::unique_ptr< RestartableDataValue > data, THREAD_ID tid) const

void	registerRestartableNameWithFilterOnApp (const std::string &name, Moose::RESTARTABLE_FILTER filter)

RestartableData< T > &	declareRestartableDataHelper (const std::string &data_name, void *context, Args &&... args) const

virtual std::string	meshPropertyPrefix (const std::string &data_name) const

const RestartableDataValue &	getMeshPropertyInternal (const std::string &data_name, const std::string &prefix) const

void	mooseErrorInternal (Args &&... args) const

const VariableValue *	getDefaultValue (const std::string &var_name) const

const ADVariableValue *	getADDefaultValue (const std::string &var_name) const

void	checkVar (const std::string &var_name) const

void	validateExecutionerType (const std::string &name, const std::string &fn_name) const

Moose::MaterialDataType	getMaterialDataType (const std::set< BoundaryID > &boundary_ids) const

unsigned int	getMaxQps () const

void	addConsumedPropertyName (const MooseObjectName &obj_name, const std::string &prop_name)

const PostprocessorValue &	declareValue (const MooseObject &moose_object)

ValueType	evaluate (const ElemArg &elem, const Moose::StateArg &state) const override final

ValueType	evaluate (const FaceArg &face, const Moose::StateArg &state) const override final

ValueType	evaluate (const ElemQpArg &qp, const Moose::StateArg &state) const override final

ValueType	evaluate (const ElemSideQpArg &elem_side_qp, const Moose::StateArg &state) const override final

ValueType	evaluate (const ElemPointArg &elem_point, const Moose::StateArg &state) const override final

ValueType	evaluate (const NodeArg &node, const Moose::StateArg &state) const override final

GradientType	evaluateGradient (const ElemArg &elem, const Moose::StateArg &state) const override final

GradientType	evaluateGradient (const FaceArg &face, const Moose::StateArg &state) const override final

GradientType	evaluateGradient (const ElemQpArg &qp, const Moose::StateArg &state) const override final

GradientType	evaluateGradient (const ElemSideQpArg &elem_side_qp, const Moose::StateArg &state) const override final

GradientType	evaluateGradient (const ElemPointArg &elem_point, const Moose::StateArg &state) const override final

GradientType	evaluateGradient (const NodeArg &node, const Moose::StateArg &state) const override final

DotType	evaluateDot (const ElemArg &elem, const Moose::StateArg &state) const override final

DotType	evaluateDot (const FaceArg &face, const Moose::StateArg &state) const override final

DotType	evaluateDot (const ElemQpArg &qp, const Moose::StateArg &state) const override final

DotType	evaluateDot (const ElemSideQpArg &elem_side_qp, const Moose::StateArg &state) const override final

DotType	evaluateDot (const ElemPointArg &elem_point, const Moose::StateArg &state) const override final

DotType	evaluateDot (const NodeArg &node, const Moose::StateArg &state) const override final

void	evaluateDotWarning () const

virtual bool	isADObject () const override

void	clearCacheData ()

ValueType	queryQpCache (unsigned int qp, const libMesh::QBase &qrule, std::vector< std::pair< bool, Real > > &qp_cache_data, const SpaceArg &space, const StateArg &state) const

ValueType	queryFVArgCache (std::map< SpaceArg, ValueType > &cache_data, const SpaceArg &space) const

const PostprocessorValue &	getPostprocessorValueInternal (const std::string &param_name, unsigned int index, std::size_t t_index) const

const PostprocessorValue &	getPostprocessorValueInternal (const std::string &param_name, unsigned int index, std::size_t t_index) const

const PostprocessorValue &	getPostprocessorValueByNameInternal (const PostprocessorName &name, std::size_t t_index) const

const PostprocessorValue &	getPostprocessorValueByNameInternal (const PostprocessorName &name, std::size_t t_index) const

void	possiblyCheckHasVectorPostprocessor (const std::string &param_name, const std::string &vector_name) const

void	possiblyCheckHasVectorPostprocessor (const std::string &param_name, const std::string &vector_name) const

void	possiblyCheckHasVectorPostprocessorByName (const VectorPostprocessorName &name, const std::string &vector_name) const

void	possiblyCheckHasVectorPostprocessorByName (const VectorPostprocessorName &name, const std::string &vector_name) const

const OutputTools< T >::VariableValue &	vectorTagValueHelper (const std::string &var_names, TagID tag, unsigned int index=0) const

const OutputTools< T >::VariableValue &	vectorTagValueHelper (const std::string &var_names, const std::string &tag_name, unsigned int index=0) const

const OutputTools< T >::VariableValue &	vectorTagDofValueHelper (const std::string &var_name, TagID tag, unsigned int comp=0) const

const OutputTools< T >::VariableValue &	vectorTagDofValueHelper (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const

void	requestStates (const std::string &var_name, const TagName &tag_name, const unsigned int comp)

void	checkFuncType (const std::string var_name, VarType t, FuncAge age) const

const VectorVariableValue *	getDefaultVectorValue (const std::string &var_name) const

const ArrayVariableValue *	getDefaultArrayValue (const std::string &var_name) const

const T &	getDefaultNodalValue (const std::string &var_name, unsigned int comp=0) const

const RealVectorValue &	getDefaultNodalValue (const std::string &var_name, unsigned int) const

const RealEigenVector &	getDefaultNodalValue (const std::string &var_name, unsigned int) const

const Moose::Functor< T > &	getDefaultFunctor (const std::string &var_name) const

Moose::Kokkos::Variable	kokkosCoupledVectorTagVariable (const std::string &var_name, const std::string &tag_name, unsigned int comp) const

Moose::Kokkos::Variable	kokkosCoupledVectorTagVariables (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::Variable	kokkosCoupledVectorTagVectorVariable (const std::string &var_name, const std::string &tag_name, unsigned int comp) const

Moose::Kokkos::Variable	kokkosCoupledVectorTagVectorVariables (const std::string &var_name, const std::string &tag_name) const

Moose::Kokkos::Variable	kokkosZeroVariable () const

std::set< MooseVariableFieldBase * >	checkVariablesHelper (const DofObjectType &dof_object, const std::set< MooseVariableFieldBase * > &vars_to_check)

void	initializeBoundaryRestrictable ()

void	initializeKokkosBoundaryRestrictable ()

Static Private Member Functions
template<class T >
static void	sort (std::set< T > &)

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

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

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

template<class T >
static bool	contains (std::set< T > &container, const T &item)

template<class T >
static bool	contains (std::vector< T > &container, const T &item)

static const hit::Node *	getHitNode (const InputParameters &params)

static std::string	messagePrefix (const InputParameters &params, const bool hit_prefix)

Private Attributes
unsigned int	_reserve_grain_first_index
	Holds the first unique grain index when using _reserve_op (all the remaining indices are sequential)

unsigned int	_old_max_grain_id
	The previous max grain id (needed to figure out which ids are new in a given step)

unsigned int &	_max_curr_grain_id
	Holds the next "regular" grain ID (a grain found or remapped to the standard op vars)

const bool	_is_transient
	Boolean to indicate whether this is a Steady or Transient solve.

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)

std::deque< const DofObject * >	_entity_queue
	The data structure for maintaining entities to flood during discovery.

UserObject *	_primary_thread_copy

std::set< std::string >	_supplied_uo

const ParallelParamObject &	_parent

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

ExecFlagEnum	_empty_execute_enum

const MooseObject &	_fni_object

const InputParameters &	_fni_params

FEProblemBase &	_fni_feproblem

const THREAD_ID	_fni_tid

const MooseObject &	_uoi_moose_object

const FEProblemBase &	_uoi_feproblem

const THREAD_ID	_uoi_tid

const MooseObject &	_ppi_moose_object

const InputParameters &	_ppi_params

const FEProblemBase &	_ppi_feproblem

std::map< PostprocessorName, std::unique_ptr< PostprocessorValue > >	_default_values

const bool	_broadcast_by_default

const MooseObject &	_vpi_moose_object

const FEProblemBase &	_vpi_feproblem

const THREAD_ID	_vpi_tid

const InputParameters &	_ri_params

FEProblemBase &	_ri_fe_problem_base

const ReporterData &	_ri_reporter_data

const MooseObject &	_ri_moose_object

const InputParameters &	_dni_params

FEProblemBase &	_dni_feproblem

const MooseObject *const	_dni_moose_object_ptr

const InputParameters &	_si_params

FEProblemBase &	_si_feproblem

THREAD_ID	_si_tid

const RestartableDataMapName	_metaname

std::string	_restartable_name

MooseApp &	_meta_data_app

const MooseObject *const	_meta_data_object

const InputParameters &	_sc_parameters

const std::string &	_sc_name

const bool	_sc_is_implicit

std::unordered_map< std::string, std::vector< MooseVariableScalar * > >	_coupled_scalar_vars

std::unordered_map< std::string, std::unique_ptr< VariableValue > >	_default_value

std::unordered_map< std::string, std::unique_ptr< ADVariableValue > >	_dual_default_value

std::vector< MooseVariableScalar * >	_coupled_moose_scalar_vars

std::unordered_map< std::string, std::vector< MooseVariableFieldBase * > >	_sc_coupled_vars

std::set< TagID >	_sc_coupleable_vector_tags

std::set< TagID >	_sc_coupleable_matrix_tags

const MooseObject &	_mi_moose_object

const bool	_mi_boundary_restricted

const std::set< SubdomainID > &	_mi_block_ids

const std::set< BoundaryID > &	_mi_boundary_ids

std::vector< std::unique_ptr< OptionalMaterialPropertyProxyBase< MaterialPropertyInterface > > >	_optional_property_proxies

const std::string	_ti_name

const MooseObject &	_pp_moose_object

MooseApp &	_oi_moose_app

OutputWarehouse &	_oi_output_warehouse

std::set< OutputName >	_oi_outputs

const InputParameters &	_fi_params

const std::string	_fi_name

SubProblem *const	_fi_subproblem

const THREAD_ID	_fi_tid

std::vector< std::unique_ptr< Moose::Functor< Real > > >	_default_real_functors

std::vector< std::unique_ptr< Moose::Functor< ADReal > > >	_default_ad_real_functors

std::set< ExecFlagType >	_clearance_schedule

bool	_always_evaluate

dof_id_type	_current_qp_map_key

std::vector< std::pair< bool, ValueType > > *	_current_qp_map_value

std::unordered_map< dof_id_type, std::vector< std::pair< bool, ValueType > > >	_qp_to_value

dof_id_type	_current_side_qp_map_key

std::vector< std::vector< std::pair< bool, ValueType > > > *	_current_side_qp_map_value

std::unordered_map< dof_id_type, std::vector< std::vector< std::pair< bool, ValueType > > > >	_side_qp_to_value

std::map< ElemArg, ValueType >	_elem_arg_to_value

std::map< FaceArg, ValueType >	_face_arg_to_value

std::map< NodeArg, ValueType >	_node_arg_to_value

MooseFunctorName	_functor_name

unsigned int	_coupleable_max_qps

std::unordered_map< std::string, std::vector< unsigned int > >	_optional_var_index

std::unordered_map< std::string, std::vector< MooseVariableScalar * > >	_c_coupled_scalar_vars

std::set< TagID >	_fe_coupleable_vector_tags

std::set< TagID >	_fe_coupleable_matrix_tags

const bool	_is_fv

const MooseObject *const	_obj

const std::set< std::string >	_older_state_tags

std::vector< std::set< MooseWritableVariable * > >	_writable_coupled_variables

const Real	_kokkos_default_value_zero

std::set< MooseVariableFieldBase * >	_moose_variable_dependencies

std::vector< libMesh::dof_id_type >	_dof_indices

FEProblemBase *	_bnd_feproblem

MooseMesh *	_bnd_mesh

std::set< BoundaryID >	_bnd_ids

std::vector< BoundaryID >	_vec_ids

std::vector< BoundaryName >	_boundary_names

const bool	_bnd_dual_restrictable

const std::set< SubdomainID >	_empty_block_ids

const std::set< SubdomainID > &	_block_ids

THREAD_ID	_bnd_tid

const MaterialData &	_bnd_material_data

bool	_bnd_nodal

const MooseObject &	_moose_object

Moose::Kokkos::Array< ContiguousNodeID >	_kokkos_node_ids

Moose::Kokkos::Array< Moose::Kokkos::Pair< ContiguousElementID, unsigned int > >	_kokkos_element_side_ids

Detailed Description

template<typename T>
class GrainDataTracker< T >

GrainTracker derived class template to base objects on which maintain physical parameters for individual grains.

Definition at line 19 of file GrainDataTracker.h.

Member Enumeration Documentation

◆ BoundaryIntersection

enum class 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.

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

◆ FieldType

enum class 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.

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

◆ RemapCacheMode

enum class GrainTracker::RemapCacheMode

stronginherited

Enumerator
FILL
USE
BYPASS

Definition at line 51 of file GrainTracker.h.

  {
    FILL,
    USE,
    BYPASS
  };

◆ Status

enum class 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.

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

Constructor & Destructor Documentation

◆ GrainDataTracker()

template<typename T >

GrainDataTracker< T >::GrainDataTracker ( const InputParameters & parameters )

Definition at line 38 of file GrainDataTracker.h.

  : GrainTracker(parameters), _grain_data(declareRestartableData<std::vector<T>>("grain_data"))
{
}

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

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

Referenced by FeatureFloodCount::prepareDataForTransfer().

◆ areFeaturesMergeable()

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

{
  return f1.mergeable(f2);
}

Referenced by FeatureFloodCount::mergeSets().

◆ 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 450 of file GrainTracker.C.

{
  mooseAssert(_first_time, "assignGrains may only be called on the first tracking step");
 
  if (_is_primary)
  {
    // Find the largest grain ID, this requires sorting if the ID is not already set
    sortAndLabel();
 
    if (_feature_sets.empty())
    {
      _max_curr_grain_id = invalid_id;
      _reserve_grain_first_index = 0;
    }
    else
    {
      _max_curr_grain_id = _feature_sets.back()._id;
      _reserve_grain_first_index = _max_curr_grain_id + 1;
    }
 
    for (auto & grain : _feature_sets)
      grain._status = Status::MARKED; // Mark the grain
 
  } // is_primary
 
  /*************************************************************
   ****************** COLLECTIVE WORK SECTION ******************
   *************************************************************/
 
  // Make IDs on all non-primary ranks consistent
  scatterAndUpdateRanks();
 
  // Build up an id to index map
  _communicator.broadcast(_max_curr_grain_id);
  buildFeatureIdToLocalIndices(_max_curr_grain_id);
 
  // Now trigger the newGrainCreated() callback on all ranks
  if (_max_curr_grain_id != invalid_id)
    for (unsigned int new_id = 0; new_id <= _max_curr_grain_id; ++new_id)
      newGrainCreated(new_id);
}

Referenced by GrainTracker::finalize().

◆ 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 1251 of file GrainTracker.C.

{
  // End the recursion of our breadth first search
  if (depth > max_depth)
    return false;
 
  std::size_t curr_var_index = grain._var_index;
 
  std::vector<std::map<Node *, CacheValues>> cache;
 
  std::vector<std::list<GrainDistance>> min_distances(_vars.size());
 
  computeMinDistancesFromGrain(grain, min_distances);
 
  // clang-format off
  std::sort(min_distances.begin(), min_distances.end(),
            [](const std::list<GrainDistance> & lhs, const std::list<GrainDistance> & rhs)
              {
                // Sort lists in reverse order (largest distance first)
                // These empty cases are here to make this comparison stable
                if (lhs.empty())
                  return false;
                else if (rhs.empty())
                  return true;
                else
                  return lhs.begin()->_distance > rhs.begin()->_distance;
              });
  // clang-format on
 
  for (auto & list_ref : min_distances)
  {
    const auto target_it = list_ref.begin();
    if (target_it == list_ref.end())
      continue;
 
    // If the distance is positive we can just remap and be done
    if (target_it->_distance > 0)
    {
      if (_verbosity_level > 0)
      {
        _console << COLOR_GREEN << "- Depth " << depth << ": Remapping grain #" << grain._id
                 << " from variable index " << curr_var_index << " to " << target_it->_var_index;
        if (target_it->_distance == std::numeric_limits<Real>::max())
          _console << " which currently contains zero grains.\n\n" << COLOR_DEFAULT;
        else
          _console << " whose closest grain (#" << target_it->_grain_id << ") is at a distance of "
                   << std::sqrt(target_it->_distance) << "\n\n"
                   << COLOR_DEFAULT;
      }
 
      grain._status |= Status::DIRTY;
      grain._var_index = target_it->_var_index;
      return true;
    }
 
    // If the distance isn't positive we just need to make sure that none of the grains represented
    // by the target variable index would intersect this one if we were to remap
    {
      auto next_target_it = target_it;
      bool intersection_hit = false;
      unsigned short num_close_targets = 0;
      std::ostringstream oss;
      while (!intersection_hit && next_target_it != list_ref.end())
      {
        if (next_target_it->_distance > 0)
          break;
 
        mooseAssert(next_target_it->_grain_index < _feature_sets.size(),
                    "Error in indexing target grain in attemptGrainRenumber");
        FeatureData & next_target_grain = _feature_sets[next_target_it->_grain_index];
 
        // If any grains touch we're done here
        if (grain.halosIntersect(next_target_grain))
          intersection_hit = true;
        else
        {
          if (num_close_targets > 0)
            oss << ", "; // delimiter
          oss << "#" << next_target_it->_grain_id;
        }
 
        ++next_target_it;
        ++num_close_targets;
      }
 
      if (!intersection_hit)
      {
        if (_verbosity_level > 0)
        {
          _console << COLOR_GREEN << "- Depth " << depth << ": Remapping grain #" << grain._id
                   << " from variable index " << curr_var_index << " to " << target_it->_var_index;
 
          if (num_close_targets == 1)
            _console << " whose closest grain (" << oss.str()
                     << ") is inside our bounding box but whose halo is not touching.\n\n"
                     << COLOR_DEFAULT;
          else
            _console << " whose closest grains (" << oss.str()
                     << ") are inside our bounding box but whose halos are not touching.\n\n"
                     << COLOR_DEFAULT;
        }
 
        grain._status |= Status::DIRTY;
        grain._var_index = target_it->_var_index;
        return true;
      }
    }
 
    // If we reach this part of the loop, there is no simple renumbering that can be done.
    mooseAssert(target_it->_grain_index < _feature_sets.size(),
                "Error in indexing target grain in attemptGrainRenumber");
    FeatureData & target_grain = _feature_sets[target_it->_grain_index];
 
    if (target_it->_distance < -1)
      return false;
 
    // Make sure this grain isn't marked. If it is, we can't recurse here
    if ((target_grain._status & Status::MARKED) == Status::MARKED)
      return false;
 
    grain._var_index = target_it->_var_index;
    grain._status |= Status::MARKED;
    if (attemptGrainRenumber(target_grain, depth + 1, max_depth))
    {
      // SUCCESS!
      if (_verbosity_level > 0)
        _console << COLOR_GREEN << "- Depth " << depth << ": Remapping grain #" << grain._id
                 << " from variable index " << curr_var_index << " to " << target_it->_var_index
                 << "\n\n"
                 << COLOR_DEFAULT;
 
      // Now we need to mark the grain as DIRTY since the recursion succeeded.
      grain._status |= Status::DIRTY;
      return true;
    }
    else
      // FAILURE, We need to set our var index back after failed recursive step
      grain._var_index = curr_var_index;
 
    // ALWAYS "unmark" (or clear the MARKED status) after recursion so it can be used by other remap
    // operations
    grain._status &= ~Status::MARKED;
  }
 
  return false;
}

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

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

{
  auto min_distance = std::numeric_limits<Real>::max();
  for (const auto & bbox1 : bboxes1)
  {
    for (const auto & bbox2 : bboxes2)
    {
      // AABB squared distance
      Real curr_distance = 0.0;
      bool boxes_overlap = true;
      for (unsigned int dim = 0; dim < LIBMESH_DIM; ++dim)
      {
        const auto & min1 = bbox1.min()(dim);
        const auto & max1 = bbox1.max()(dim);
        const auto & min2 = bbox2.min()(dim);
        const auto & max2 = bbox2.max()(dim);
 
        if (min1 > max2)
        {
          const auto delta = max2 - min1;
          curr_distance += delta * delta;
          boxes_overlap = false;
        }
        else if (min2 > max1)
        {
          const auto delta = max1 - min2;
          curr_distance += delta * delta;
          boxes_overlap = false;
        }
      }
 
      if (boxes_overlap)
        return -1.0; /* all overlaps are treated the same */
 
      if (curr_distance < min_distance)
        min_distance = curr_distance;
    }
  }
 
  return min_distance;
}

Referenced by GrainTracker::computeMinDistancesFromGrain().

◆ 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 387 of file GrainTracker.C.

{
  TIME_SECTION("broadcastAndUpdateGrainData", 3, "Broadcasting and Updating Grain Data");
 
  std::vector<PartialFeatureData> root_feature_data;
  std::vector<std::string> send_buffer(1), recv_buffer;
 
  if (_is_primary)
  {
    root_feature_data.reserve(_feature_sets.size());
 
    // Populate a subset of the information in a small data structure
    std::transform(_feature_sets.begin(),
                   _feature_sets.end(),
                   std::back_inserter(root_feature_data),
                   [](FeatureData & feature)
                   {
                     PartialFeatureData partial_feature;
                     partial_feature.boundary_intersection = feature._boundary_intersection;
                     partial_feature.id = feature._id;
                     partial_feature.centroid = feature._centroid;
                     partial_feature.status = feature._status;
                     return partial_feature;
                   });
 
    std::ostringstream oss;
    dataStore(oss, root_feature_data, this);
    send_buffer[0].assign(oss.str());
  }
 
  // Broadcast the data to all ranks
  _communicator.broadcast_packed_range((void *)(nullptr),
                                       send_buffer.begin(),
                                       send_buffer.end(),
                                       (void *)(nullptr),
                                       std::back_inserter(recv_buffer));
 
  // Unpack and update
  if (!_is_primary)
  {
    std::istringstream iss;
    iss.str(recv_buffer[0]);
    iss.clear();
 
    dataLoad(iss, root_feature_data, this);
 
    for (const auto & partial_data : root_feature_data)
    {
      // See if this processor has a record of this grain
      if (partial_data.id < _feature_id_to_local_index.size() &&
          _feature_id_to_local_index[partial_data.id] != invalid_size_t)
      {
        auto & grain = _feature_sets[_feature_id_to_local_index[partial_data.id]];
        grain._boundary_intersection = partial_data.boundary_intersection;
        grain._centroid = partial_data.centroid;
        if (partial_data.status == Status::INACTIVE)
          grain._status = Status::INACTIVE;
      }
    }
  }
}

Referenced by GrainTracker::finalize().

◆ buildFeatureIdToLocalIndices()

void FeatureFloodCount::buildFeatureIdToLocalIndices ( unsigned int max_id )

protectedinherited

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

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

Definition at line 660 of file FeatureFloodCount.C.

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

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

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

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

Referenced by FeatureFloodCount::scatterAndUpdateRanks().

◆ 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 1708 of file GrainTracker.C.

{
  auto min_distance = std::numeric_limits<Real>::max();
  for (const auto & bbox1 : bboxes1)
  {
    const auto centroid_point1 = (bbox1.max() + bbox1.min()) / 2.0;
 
    for (const auto & bbox2 : bboxes2)
    {
      const auto centroid_point2 = (bbox2.max() + bbox2.min()) / 2.0;
 
      // Here we'll calculate a distance between the centroids
      auto curr_distance =
          _mesh.minPeriodicDistance(*_fe_vars[0], centroid_point1, centroid_point2);
 
      if (curr_distance < min_distance)
        min_distance = curr_distance;
    }
  }
 
  return min_distance;
}

Referenced by GrainTracker::trackGrains().

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

317{

318}

Referenced by FeatureFloodCount::communicateAndMerge().

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

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

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

◆ 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 1623 of file GrainTracker.C.

{
  if (_compute_halo_maps)
  {
    // rank               var_index    entity_id
    std::vector<std::pair<std::size_t, dof_id_type>> halo_ids_all;
 
    std::vector<int> counts;
    std::vector<std::pair<std::size_t, dof_id_type>> local_halo_ids;
    std::size_t counter = 0;
 
    const bool isDistributedMesh = _mesh.isDistributedMesh();
 
    if (_is_primary)
    {
      std::vector<std::vector<std::pair<std::size_t, dof_id_type>>> root_halo_ids(_n_procs);
      counts.resize(_n_procs);
 
      // Loop over the _halo_ids "field" and build minimal lists for all of the other ranks
      for (const auto var_index : index_range(_halo_ids))
      {
        for (const auto & entity_pair : _halo_ids[var_index])
        {
          auto entity_id = entity_pair.first;
          if (isDistributedMesh)
          {
            // Check to see which contiguous range this entity ID falls into
            auto range_it =
                std::lower_bound(_all_ranges.begin(),
                                 _all_ranges.end(),
                                 entity_id,
                                 [](const std::pair<dof_id_type, dof_id_type> range,
                                    dof_id_type entity_id) { return range.second < entity_id; });
 
            mooseAssert(range_it != _all_ranges.end(), "No range round?");
 
            // Recover the index from the iterator
            auto proc_id = std::distance(_all_ranges.begin(), range_it);
 
            // Now add this halo entity to the map for the corresponding proc to scatter latter
            root_halo_ids[proc_id].push_back(std::make_pair(var_index, entity_id));
          }
          else
          {
            DofObject * halo_entity;
            if (_is_elemental)
              halo_entity = _mesh.queryElemPtr(entity_id);
            else
              halo_entity = _mesh.queryNodePtr(entity_id);
 
            if (halo_entity)
              root_halo_ids[halo_entity->processor_id()].push_back(
                  std::make_pair(var_index, entity_id));
          }
        }
      }
 
      // Build up the counts vector for MPI scatter
      for (const auto & vector_ref : root_halo_ids)
      {
        std::copy(vector_ref.begin(), vector_ref.end(), std::back_inserter(halo_ids_all));
        counts[counter] = vector_ref.size();
        counter++;
      }
    }
 
    _communicator.scatter(halo_ids_all, counts, local_halo_ids);
 
    // Now add the contributions from the root process to the processor local maps
    for (const auto & halo_pair : local_halo_ids)
      _halo_ids[halo_pair.first].emplace(std::make_pair(halo_pair.second, halo_pair.first));
 
    for (const auto & grain : _feature_sets)
      for (auto local_id : grain._local_ids)
        _halo_ids[grain._var_index].erase(local_id);
  }
}

Referenced by GrainTracker::updateFieldInfo().

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

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

Referenced by FeatureFloodCount::isNewFeatureOrConnectedRegion().

◆ 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 1177 of file GrainTracker.C.

{
  for (const auto i : index_range(_feature_sets))
  {
    auto & other_grain = _feature_sets[i];
 
    if (other_grain._var_index == grain._var_index || other_grain._var_index >= _reserve_op_index)
      continue;
 
    auto target_var_index = other_grain._var_index;
    auto target_grain_index = i;
    auto target_grain_id = other_grain._id;
 
    Real curr_bbox_diff = boundingRegionDistance(grain._bboxes, other_grain._bboxes);
 
    GrainDistance grain_distance_obj(
        curr_bbox_diff, target_var_index, target_grain_index, target_grain_id);
 
    // To handle touching halos we penalize the top pick each time we see another
    if (curr_bbox_diff == -1.0 && !min_distances[target_var_index].empty())
    {
      Real last_distance = min_distances[target_var_index].begin()->_distance;
      if (last_distance < 0)
        grain_distance_obj._distance += last_distance;
    }
 
    // Insertion sort into a list
    auto insert_it = min_distances[target_var_index].begin();
    while (insert_it != min_distances[target_var_index].end() && !(grain_distance_obj < *insert_it))
      ++insert_it;
    min_distances[target_var_index].insert(insert_it, grain_distance_obj);
  }
 
  for (const auto var_index : make_range(_reserve_op_index))
  {
    // Don't put an entry in for matching variable indices (i.e. we can't remap to ourselves)
    if (grain._var_index == var_index)
      continue;
 
    if (min_distances[var_index].empty())
      min_distances[var_index].emplace_front(std::numeric_limits<Real>::max(), var_index);
  }
}

Referenced by GrainTracker::attemptGrainRenumber().

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

{
  TIME_SECTION("consolidateMergedFeatures", 3, "Consolidating Merged Features");
 
  mooseAssert(_is_primary,
              "cosolidateMergedFeatures() may only be called on the primary processor");
  mooseAssert(saved_data == nullptr || saved_data->size() == _partial_feature_sets.size(),
              "Data structure size mismatch");
 
  // Offset where the current set of features with the same variable id starts in the flat vector
  unsigned int feature_offset = 0;
  // Set the member feature count to zero and start counting the actual features
  _feature_count = 0;
  for (const auto map_num : index_range(_partial_feature_sets))
  {
    for (auto & feature : _partial_feature_sets[map_num])
    {
      if (saved_data)
      {
        for (auto it = (*saved_data)[map_num].begin(); it != (*saved_data)[map_num].end();
             /* no increment */)
        {
          if (feature.canConsolidate(*it))
          {
            feature.consolidate(std::move(*it));
            it = (*saved_data)[map_num].erase(it); // increment
          }
          else
            ++it;
        }
      }
 
      // If after merging we still have an inactive feature, discard it
      if (feature._status == Status::CLEAR)
      {
        // First we need to calculate the centroid now that we are doing merging all partial
        // features
        if (feature._vol_count != 0)
          feature._centroid /= feature._vol_count;
 
        _feature_sets.emplace_back(std::move(feature));
        ++_feature_count;
      }
    }
 
    // Record the feature numbers just for the current map
    _feature_counts_per_map[map_num] = _feature_count - feature_offset;
 
    // Now update the running feature count so we can calculate the next map's contribution
    feature_offset = _feature_count;
 
    // Clean up the "moved" objects
    _partial_feature_sets[map_num].clear();
    if (saved_data)
      (*saved_data)[map_num].clear();
  }
 
  // We may have resided our data structures for the communicateAndMerge step. We'll restore the
  // original size here just in case we need to loop over the assumed size (i.e. _maps_size)
  // elsewhere in this or derived objects.
  if (_partial_feature_sets.size() != _maps_size)
  {
    _partial_feature_sets.resize(_maps_size);
 
    _feature_counts_per_map[0] = _feature_count;
    _feature_counts_per_map.resize(_maps_size);
  }
 
}

Referenced by FeatureFloodCount::communicateAndMerge().

◆ contains() [1/2]

template<class T >

static bool FeatureFloodCount::contains	(	std::set< T > &	container,
		const T &	item
	)

inlinestaticprivateinherited

Definition at line 744 of file FeatureFloodCount.h.

  {
    return container.find(item) != container.end();
  }

Referenced by FeatureFloodCount::visitNeighborsHelper().

◆ contains() [2/2]

template<class T >

static bool FeatureFloodCount::contains	(	std::vector< T > &	container,
		const T &	item
	)

inlinestaticprivateinherited

Definition at line 750 of file FeatureFloodCount.h.

  {
    for (const auto & cont_item : container)
      if (item == cont_item)
        return true;
    return false;
  }

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

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

Referenced by FeatureFloodCount::communicateAndMerge().

◆ doesFeatureIntersectBoundary()

bool GrainTracker::doesFeatureIntersectBoundary ( unsigned int feature_id ) const

overridevirtualinherited

Returns a Boolean indicating whether this feature intersects any boundary.

Reimplemented from FeatureFloodCount.

Definition at line 174 of file GrainTracker.C.

{
  // TODO: This data structure may need to be turned into a Multimap
  mooseAssert(feature_id < _feature_id_to_local_index.size(), "Grain ID out of bounds");
 
  auto feature_index = _feature_id_to_local_index[feature_id];
  if (feature_index != invalid_size_t)
  {
    mooseAssert(feature_index < _feature_sets.size(), "Grain index out of bounds");
    return _feature_sets[feature_index]._boundary_intersection != BoundaryIntersection::NONE;
  }
 
  return false;
}

◆ 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 190 of file GrainTracker.C.

{
  // TODO: This data structure may need to be turned into a Multimap
  mooseAssert(feature_id < _feature_id_to_local_index.size(), "Grain ID out of bounds");
 
  auto feature_index = _feature_id_to_local_index[feature_id];
  if (feature_index != invalid_size_t)
  {
    mooseAssert(feature_index < _feature_sets.size(), "Grain index out of bounds");
    return ((_feature_sets[feature_index]._boundary_intersection &
             BoundaryIntersection::SPECIFIED_BOUNDARY) == BoundaryIntersection::SPECIFIED_BOUNDARY);
  }
 
  return false;
}

◆ execute()

void GrainTracker::execute ( )

overridevirtualinherited

Reimplemented from FeatureFloodCount.

Definition at line 272 of file GrainTracker.C.

{
  // Don't track grains if the current simulation step is before the specified tracking step
  if (_t_step < _tracking_step)
    return;
 
  if (_poly_ic_uo && _first_time)
    return;
 
  FeatureFloodCount::execute();
}

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

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

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

◆ expandPointHalos()

void FeatureFloodCount::expandPointHalos ( )

protectedinherited

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

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

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

Definition at line 1500 of file FeatureFloodCount.C.

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

◆ featureCentroid()

Point FeatureFloodCount::featureCentroid ( unsigned int feature_id ) const

virtualinherited

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

Definition at line 909 of file FeatureFloodCount.C.

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

Referenced by FeatureVolumeVectorPostprocessor::execute().

◆ finalize()

void GrainTracker::finalize ( )

overridevirtualinherited

Assign or Track Grains

Broadcast essential data

Remap Grains

Reimplemented from FeatureFloodCount.

Definition at line 329 of file GrainTracker.C.

{
  // Don't track grains if the current simulation step is before the specified tracking step
  if (_t_step < _tracking_step)
    return;
 
  TIME_SECTION("finalize", 3, "Finalizing GrainTracker");
 
  // Expand the depth of the halos around all grains
  auto num_halo_layers = _halo_level >= 1
                             ? _halo_level - 1
                             : 0; // The first level of halos already exists so subtract one
 
  if (_poly_ic_uo && _first_time)
    prepopulateState(*_poly_ic_uo);
  else
  {
    expandEdgeHalos(num_halo_layers);
 
    // Build up the grain map on the root processor
    communicateAndMerge();
  }
 
  if (_first_time)
    assignGrains();
  else
    trackGrains();
 
  if (_verbosity_level > 1)
    _console << "Finished inside of trackGrains" << std::endl;
 
  broadcastAndUpdateGrainData();
 
  if (_remap)
    remapGrains();
 
  updateFieldInfo();
  if (_verbosity_level > 1)
    _console << "Finished inside of updateFieldInfo" << std::endl;
 
  // Set the first time flag false here (after all methods of finalize() have completed)
  _first_time = false;
 
  // TODO: Release non essential memory
  if (_verbosity_level > 0)
    _console << "Finished inside of GrainTracker\n" << std::endl;
}

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

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

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

◆ getConnectingThreshold()

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

protectedvirtualinherited

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

Definition at line 1447 of file FeatureFloodCount.C.

{
  return _step_connecting_threshold;
}

Referenced by FeatureFloodCount::isNewFeatureOrConnectedRegion().

◆ getCoupledVars()

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

inlineinherited

Returns a const vector to the coupled variable pointers.

Definition at line 97 of file FeatureFloodCount.h.

97{ return _vars; }

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

◆ getData()

template<typename T >

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

return data for selected grain

Definition at line 45 of file GrainDataTracker.h.

{
  mooseAssert(grain_id < _grain_data.size(), "Requested data for invalid grain index.");
  return _grain_data[grain_id];
}

Referenced by ComputePolycrystalElasticityTensor::computeQpElasticityTensor().

◆ 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 119 of file GrainTracker.C.

{
  if (_t_step < _tracking_step)
    return 0;
 
  return FeatureFloodCount::getEntityValue(entity_id, field_type, var_index);
}

Referenced by OutputEulerAngles::precalculateValue().

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

328{ return _feature_sets; }

Referenced by GrainTracker::prepopulateState().

◆ 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 136 of file GrainTracker.C.

{
  return FeatureFloodCount::getFeatureVar(feature_id);
}

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

100{ return _fe_vars; }

Referenced by AverageGrainVolume::AverageGrainVolume().

◆ getGrainCentroid()

Point GrainTracker::getGrainCentroid ( unsigned int grain_id ) const

overridevirtualinherited

Returns the centroid for the given grain number.

Implements GrainTrackerInterface.

Definition at line 156 of file GrainTracker.C.

{
  mooseAssert(grain_id < _feature_id_to_local_index.size(), "Grain ID out of bounds");
  auto grain_index = _feature_id_to_local_index[grain_id];
 
  if (grain_index != invalid_size_t)
  {
    mooseAssert(_feature_id_to_local_index[grain_id] < _feature_sets.size(),
                "Grain index out of bounds");
    // Note: This value is parallel consistent, see GrainTracker::broadcastAndUpdateGrainData()
    return _feature_sets[_feature_id_to_local_index[grain_id]]._centroid;
  }
 
  // Inactive grain
  return Point();
}

◆ 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 897 of file GrainTracker.C.

{
  std::vector<unsigned int> new_ids(_max_curr_grain_id - _old_max_grain_id);
  auto new_id = _old_max_grain_id + 1;
 
  // Generate the new ids
  std::iota(new_ids.begin(), new_ids.end(), new_id);
 
  return new_ids;
}

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

{
  _max_curr_grain_id = std::max(_max_curr_grain_id == invalid_id ? 0 : _max_curr_grain_id + 1,
                                _reserve_grain_first_index + _n_reserve_ops /* no +1 here!*/);
 
  return _max_curr_grain_id;
}

Referenced by GrainTracker::trackGrains().

◆ getNumberActiveFeatures()

std::size_t FeatureFloodCount::getNumberActiveFeatures ( ) const

inherited

Return the number of active features.

Definition at line 806 of file FeatureFloodCount.C.

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

Referenced by AverageGrainVolume::getValue().

◆ 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 142 of file GrainTracker.C.

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

◆ 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 285 of file GrainTracker.C.

{
  // If we are inspecting a reserve op parameter, we need to make sure
  // that there is an entity above the reserve_op threshold before
  // starting the flood of the feature.
  if (var_index >= _reserve_op_index)
    return _reserve_op_threshold;
  else
    return _step_threshold;
}

◆ 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 149 of file GrainTracker.C.

{
  // Note: This value is parallel consistent, see assignGrains()/trackGrains()
  return _max_curr_grain_id == invalid_id ? 0 : _max_curr_grain_id + 1;
}

◆ getValue()

Real FeatureFloodCount::getValue ( ) const

overridevirtualinherited

Implements GeneralPostprocessor.

Reimplemented in FauxGrainTracker.

Definition at line 800 of file FeatureFloodCount.C.

{
  return static_cast<Real>(_feature_count);
}

◆ 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 130 of file GrainTracker.C.

{
  return FeatureFloodCount::getVarToFeatureVector(elem_id);
}

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

◆ 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 229 of file GrainTracker.C.

{
  // Don't track grains if the current simulation step is before the specified tracking step
  if (_t_step < _tracking_step)
    return;
 
  if (!_first_time)
    _feature_sets_old.swap(_feature_sets);
 
  FeatureFloodCount::initialize();
}

◆ 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 FauxPolycrystalVoronoi, and PolycrystalUserObjectBase.

Definition at line 263 of file FeatureFloodCount.C.

{
  // We need one map per coupled variable for normal runs to support overlapping features
  _entities_visited.resize(_vars.size());
 
  // Get a pointer to the PeriodicBoundaries buried in libMesh
  _pbs = _sys.dofMap().get_periodic_boundaries();
 
  meshChanged();
 
  _empty_var_to_features.resize(_n_vars, invalid_id);
}

Referenced by PolycrystalUserObjectBase::initialSetup().

◆ isBoundaryEntity()

template<typename T >

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

protectedinherited

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

Definition at line 1860 of file FeatureFloodCount.C.

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

Referenced by FeatureFloodCount::visitNeighborsHelper().

◆ isElemental()

bool FeatureFloodCount::isElemental ( ) const

inlineinherited

Definition at line 117 of file FeatureFloodCount.h.

117{ return _is_elemental; }

Referenced by FeatureFloodCountAux::FeatureFloodCountAux().

◆ 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 207 of file GrainTracker.C.

{
  // TODO: This data structure may need to be turned into a Multimap
  mooseAssert(feature_id < _feature_id_to_local_index.size(), "Grain ID out of bounds");
 
  auto feature_index = _feature_id_to_local_index[feature_id];
  if (feature_index != invalid_size_t)
  {
    mooseAssert(feature_index < _feature_sets.size(), "Grain index out of bounds");
    bool primary = ((_feature_sets[feature_index]._boundary_intersection &
                     BoundaryIntersection::PRIMARY_PERCOLATION_BOUNDARY) ==
                    BoundaryIntersection::PRIMARY_PERCOLATION_BOUNDARY);
    bool secondary = ((_feature_sets[feature_index]._boundary_intersection &
                       BoundaryIntersection::SECONDARY_PERCOLATION_BOUNDARY) ==
                      BoundaryIntersection::SECONDARY_PERCOLATION_BOUNDARY);
    return (primary && secondary);
  }
 
  return false;
}

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

{
  // Get the value of the current variable for the current entity
  Real entity_value;
  if (_is_elemental)
  {
    const Elem * elem = static_cast<const Elem *>(dof_object);
    std::vector<Point> centroid(1, elem->vertex_average());
    _subproblem.reinitElemPhys(elem, centroid, 0);
    entity_value = _vars[current_index]->sln()[0];
  }
  else
    entity_value = _vars[current_index]->getNodalValue(*static_cast<const Node *>(dof_object));
 
  // If the value compares against our starting threshold, this is definitely part of a feature
  // we'll keep
  if (compareValueWithThreshold(entity_value, getThreshold(current_index)))
  {
    Status * status_ptr = &status;
 
    if (feature)
      status_ptr = &feature->_status;
 
    // Update an existing feature's status or clear the flag on the passed in status
    *status_ptr &= ~Status::INACTIVE;
    return true;
  }
 
  return compareValueWithThreshold(entity_value, getConnectingThreshold(current_index));
}

Referenced by FeatureFloodCount::flood().

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

{
  TIME_SECTION("mergeSets", 3, "Merging Sets");
 
  // When working with _distribute_merge_work all of the maps will be empty except for one
  for (const auto map_num : make_range(_maps_size))
  {
    for (auto it1 = _partial_feature_sets[map_num].begin();
         it1 != _partial_feature_sets[map_num].end();
         /* No increment on it1 */)
    {
      bool merge_occured = false;
      for (auto it2 = _partial_feature_sets[map_num].begin();
           it2 != _partial_feature_sets[map_num].end();
           ++it2)
      {
        if (it1 != it2 && areFeaturesMergeable(*it1, *it2))
        {
          it2->merge(std::move(*it1));
 
          _partial_feature_sets[map_num].emplace_back(std::move(*it2));
 
          _partial_feature_sets[map_num].erase(it2);
          it1 = _partial_feature_sets[map_num].erase(it1); // it1 is incremented here!
 
          // A merge occurred, this is used to determine whether or not we increment the outer
          // iterator
          merge_occured = true;
 
          // We need to start the list comparison over for the new it1 so break here
          break;
        }
      } // it2 loop
 
      if (!merge_occured) // No merges so we need to manually increment the outer iterator
        ++it1;
 
    } // it1 loop
  } // map loop
}

Referenced by FeatureFloodCount::communicateAndMerge().

◆ meshChanged()

void GrainTracker::meshChanged ( )

overridevirtualinherited

Reimplemented from FeatureFloodCount.

Definition at line 247 of file GrainTracker.C.

{
  // Update the element ID ranges for use when computing halo maps
  if (_compute_halo_maps && _mesh.isDistributedMesh())
  {
    _all_ranges.clear();
 
    auto range = std::make_pair(std::numeric_limits<dof_id_type>::max(),
                                std::numeric_limits<dof_id_type>::min());
    for (const auto & current_elem : _mesh.getMesh().active_local_element_ptr_range())
    {
      auto id = current_elem->id();
      if (id < range.first)
        range.first = id;
      else if (id > range.second)
        range.second = id;
    }
 
    _communicator.gather(0, range, _all_ranges);
  }
 
  FeatureFloodCount::meshChanged();
}

◆ newGrain()

template<typename T >

virtual T GrainDataTracker< T >::newGrain ( unsigned int new_grain_id )

protectedpure virtual

implement this method to initialize the data for the new grain

Implemented in GrainTrackerElasticity.

◆ newGrainCreated()

template<typename T >

void GrainDataTracker< T >::newGrainCreated ( unsigned int new_grain_id )

protectedvirtual

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.

{
  if (_grain_data.size() <= new_grain_id)
    _grain_data.resize(new_grain_id + 1);
 
  _grain_data[new_grain_id] = newGrain(new_grain_id);
}

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

{
  return _app.n_processors() >= _maps_size ? _maps_size : 1;
}

Referenced by FeatureFloodCount::communicateAndMerge().

◆ 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; }

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

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

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

◆ 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 297 of file GrainTracker.C.

{
  mooseAssert(_first_time, "This method should only be called on the first invocation");
 
  _feature_sets.clear();
 
  if (_is_primary)
  {
    const auto & features = ffc_object.getFeatures();
    for (auto & feature : features)
      _feature_sets.emplace_back(feature.duplicate());
 
    _feature_count = _feature_sets.size();
  }
  else
  {
    const auto & features = ffc_object.getFeatures();
    _partial_feature_sets[0].clear();
    for (auto & feature : features)
      _partial_feature_sets[0].emplace_back(feature.duplicate());
  }
 
  // Make sure that feature count is communicated to all ranks
  _communicator.broadcast(_feature_count);
}

Referenced by GrainTracker::finalize().

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

{
  // Don't remap grains if the current simulation step is before the specified tracking step
  if (_t_step < _tracking_step)
    return;
 
  TIME_SECTION("remapGrains", 3, "Remapping Grains");
 
  if (_verbosity_level > 1)
    _console << "Running remap Grains\n" << std::endl;
 
  std::map<unsigned int, std::size_t> grain_id_to_new_var;
 
  // Items are added to this list when split grains are found
  std::list<std::pair<std::size_t, std::size_t>> split_pairs;
 
  if (_is_primary)
  {
    // Build the map to detect difference in _var_index mappings after the remap operation
    std::map<unsigned int, std::size_t> grain_id_to_existing_var_index;
    for (auto & grain : _feature_sets)
    {
      // Unmark the grain so it can be used in the remap loop
      grain._status = Status::CLEAR;
 
      grain_id_to_existing_var_index[grain._id] = grain._var_index;
    }
 
    // Make sure that all split pieces of any grain are on the same OP
    for (const auto i : index_range(_feature_sets))
    {
      auto & grain1 = _feature_sets[i];
 
      for (const auto j : index_range(_feature_sets))
      {
        auto & grain2 = _feature_sets[j];
        if (i == j)
          continue;
 
        // The first condition below is there to prevent symmetric checks (duplicate values)
        if (i < j && grain1._id == grain2._id)
        {
          split_pairs.push_front(std::make_pair(i, j));
          if (grain1._var_index != grain2._var_index)
          {
            if (_verbosity_level > 0)
              _console << COLOR_YELLOW << "Split Grain (#" << grain1._id
                       << ") detected on unmatched OPs (" << grain1._var_index << ", "
                       << grain2._var_index << ") attempting to remap to " << grain1._var_index
                       << ".\n"
                       << COLOR_DEFAULT;
 
            grain1._var_index = grain2._var_index;
            grain1._status |= Status::DIRTY;
          }
        }
      }
    }
 
    bool grains_remapped;
 
    std::set<unsigned int> notify_ids;
    do
    {
      grains_remapped = false;
      notify_ids.clear();
 
      for (auto & grain1 : _feature_sets)
      {
        // We need to remap any grains represented on any variable index above the cuttoff
        if (grain1._var_index >= _reserve_op_index)
        {
          if (_verbosity_level > 0)
            _console << COLOR_YELLOW << "\nGrain #" << grain1._id
                     << " detected on a reserved order parameter #" << grain1._var_index
                     << ", remapping to another variable\n"
                     << COLOR_DEFAULT;
 
          for (const auto max : make_range(0, _max_remap_recursion_depth + 1))
            if (max < _max_remap_recursion_depth)
            {
              if (attemptGrainRenumber(grain1, 0, max))
                break;
            }
            else if (!attemptGrainRenumber(grain1, 0, max))
            {
              _console << std::flush;
              std::stringstream oss;
              oss << "Unable to find any suitable order parameters for remapping while working "
                  << "with Grain #" << grain1._id << ", which is on a reserve order parameter.\n"
                  << "\n\nPossible Resolutions:\n"
                  << "\t- Add more order parameters to your simulation (8 for 2D, 28 for 3D)\n"
                  << "\t- Increase adaptivity or reduce your grain boundary widths\n"
                  << "\t- Make sure you are not starting with too many grains for the mesh size\n";
              mooseError(oss.str());
            }
 
          grains_remapped = true;
        }
 
        for (auto & grain2 : _feature_sets)
        {
          // Don't compare a grain with itself and don't try to remap inactive grains
          if (&grain1 == &grain2)
            continue;
 
          if (grain1._var_index == grain2._var_index && // grains represented by same variable?
              grain1._id != grain2._id &&               // are they part of different grains?
              grain1.boundingBoxesIntersect(grain2) &&  // do bboxes intersect (coarse level)?
              grain1.halosIntersect(grain2))            // do they actually overlap (fine level)?
          {
            if (_verbosity_level > 0)
              _console << COLOR_YELLOW << "Grain #" << grain1._id << " intersects Grain #"
                       << grain2._id << " (variable index: " << grain1._var_index << ")\n"
                       << COLOR_DEFAULT;
 
            for (const auto max : make_range(0, _max_remap_recursion_depth + 1))
            {
              if (max < _max_remap_recursion_depth)
              {
                if (attemptGrainRenumber(grain1, 0, max))
                {
                  grains_remapped = true;
                  break;
                }
              }
              else if (!attemptGrainRenumber(grain1, 0, max) &&
                       !attemptGrainRenumber(grain2, 0, max))
              {
                notify_ids.insert(grain1._id);
                notify_ids.insert(grain2._id);
              }
            }
          }
        }
      }
    } while (grains_remapped);
 
    if (!notify_ids.empty())
    {
      _console << std::flush;
      std::stringstream oss;
      oss << "Unable to find any suitable order parameters for remapping while working "
          << "with the following grain IDs:\n"
          << Moose::stringify(notify_ids, ", ", "", true) << "\n\nPossible Resolutions:\n"
          << "\t- Add more order parameters to your simulation (8 for 2D, 28 for 3D)\n"
          << "\t- Increase adaptivity or reduce your grain boundary widths\n"
          << "\t- Make sure you are not starting with too many grains for the mesh size\n";
 
      if (_tolerate_failure)
        mooseWarning(oss.str());
      else
        mooseError(oss.str());
    }
 
    // Verify that split grains are still intact
    for (auto & split_pair : split_pairs)
      if (_feature_sets[split_pair.first]._var_index != _feature_sets[split_pair.first]._var_index)
        mooseError("Split grain remapped - This case is currently not handled");
 
    for (auto & grain : _feature_sets)
    {
      mooseAssert(grain_id_to_existing_var_index.find(grain._id) !=
                      grain_id_to_existing_var_index.end(),
                  "Missing unique ID");
 
      auto old_var_index = grain_id_to_existing_var_index[grain._id];
 
      if (old_var_index != grain._var_index)
      {
        mooseAssert(static_cast<bool>(grain._status & Status::DIRTY), "grain status is incorrect");
 
        grain_id_to_new_var.emplace_hint(
            grain_id_to_new_var.end(),
            std::pair<unsigned int, std::size_t>(grain._id, grain._var_index));
 
        grain._var_index = old_var_index;
        // Clear the DIRTY status as well for consistency
        grain._status &= ~Status::DIRTY;
      }
    }
 
    if (!grain_id_to_new_var.empty())
    {
      if (_verbosity_level > 1)
      {
        _console << "Final remapping tally:\n";
        for (const auto & remap_pair : grain_id_to_new_var)
          _console << "Grain #" << remap_pair.first << " var_index "
                   << grain_id_to_existing_var_index[remap_pair.first] << " -> "
                   << remap_pair.second << '\n';
        _console << "Communicating swaps with remaining processors..." << std::endl;
      }
    }
  } // root processor
 
  // Communicate the std::map to all ranks
  _communicator.broadcast(grain_id_to_new_var);
 
  // Perform swaps if any occurred
  if (!grain_id_to_new_var.empty())
  {
    // Cache for holding values during swaps
    std::vector<std::map<Node *, CacheValues>> cache(_n_vars);
 
    // Perform the actual swaps on all processors
    for (auto & grain : _feature_sets)
    {
      // See if this grain was remapped
      auto new_var_it = grain_id_to_new_var.find(grain._id);
      if (new_var_it != grain_id_to_new_var.end())
        swapSolutionValues(grain, new_var_it->second, cache, RemapCacheMode::FILL);
    }
 
    for (auto & grain : _feature_sets)
    {
      // See if this grain was remapped
      auto new_var_it = grain_id_to_new_var.find(grain._id);
      if (new_var_it != grain_id_to_new_var.end())
        swapSolutionValues(grain, new_var_it->second, cache, RemapCacheMode::USE);
    }
 
    _sys.solution().close();
    _sys.solutionOld().close();
    _sys.solutionOlder().close();
 
    _sys.system().update();
 
    if (_verbosity_level > 1)
      _console << "Swaps complete" << std::endl;
  }
}

Referenced by GrainTracker::finalize().

◆ reserve() [1/2]

template<class T >

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

inlinestaticprivateinherited

Definition at line 732 of file FeatureFloodCount.h.

  {
    // Sets are trees, no reservations necessary
  }

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

◆ reserve() [2/2]

template<class T >

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

inlinestaticprivateinherited

Definition at line 738 of file FeatureFloodCount.h.

  {
    container.reserve(size);
  }

◆ restoreOriginalDataStructures()

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

inlineprotectedvirtualinherited

Reimplemented in PolycrystalUserObjectBase.

Definition at line 487 of file FeatureFloodCount.h.

487{}

Referenced by FeatureFloodCount::communicateAndMerge().

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

{
  // local to global map (one per processor)
  std::vector<int> counts;
  std::vector<std::size_t> local_to_global_all;
  if (_is_primary)
    buildLocalToGlobalIndices(local_to_global_all, counts);
 
  // Scatter local_to_global indices to all processors and store in class member variable
  _communicator.scatter(local_to_global_all, counts, _local_to_global_feature_map);
 
  std::size_t largest_global_index = std::numeric_limits<std::size_t>::lowest();
  if (!_is_primary)
  {
    _feature_sets.resize(_local_to_global_feature_map.size());
 
    for (auto & list_ref : _partial_feature_sets)
    {
      for (auto & feature : list_ref)
      {
        mooseAssert(feature._orig_ids.size() == 1, "feature._orig_ids length doesn't make sense");
 
        auto global_index = FeatureFloodCount::invalid_size_t;
        auto local_index = feature._orig_ids.begin()->second;
 
        if (local_index < _local_to_global_feature_map.size())
          global_index = _local_to_global_feature_map[local_index];
 
        if (global_index != FeatureFloodCount::invalid_size_t)
        {
          if (global_index > largest_global_index)
            largest_global_index = global_index;
 
          // Set the correct global index
          feature._id = global_index;
 
          feature._status &= ~Status::INACTIVE;
 
          // Move the feature into the correct place
          _feature_sets[local_index] = std::move(feature);
        }
      }
    }
  }
  else
  {
    for (auto global_index : local_to_global_all)
      if (global_index != FeatureFloodCount::invalid_size_t && global_index > largest_global_index)
        largest_global_index = global_index;
  }
 
  // communicate the boundary intersection state
  std::vector<std::pair<unsigned int, int>> intersection_state;
  for (auto & feature : _feature_sets)
    intersection_state.emplace_back(feature._id, static_cast<int>(feature._boundary_intersection));
 
  // gather on root
  _communicator.gather(0, intersection_state);
 
  // consolidate
  std::map<unsigned int, int> consolidated_intersection_state;
  if (_is_primary)
    for (const auto & [id, state] : intersection_state)
      consolidated_intersection_state[id] |= state;
 
  // broadcast result
  _communicator.broadcast(consolidated_intersection_state, 0);
 
  // apply broadcast changes
  for (auto & feature : _feature_sets)
    feature._boundary_intersection |=
        static_cast<BoundaryIntersection>(consolidated_intersection_state[feature._id]);
 
  buildFeatureIdToLocalIndices(largest_global_index);
}

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

◆ serialize()

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

protectedinherited

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

Definition at line 1084 of file FeatureFloodCount.C.

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

Referenced by FeatureFloodCount::communicateAndMerge().

◆ sort() [1/2]

template<class T >

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

inlinestaticprivateinherited

Definition at line 720 of file FeatureFloodCount.h.

  {
    // Sets are already sorted, do nothing
  }

Referenced by FeatureFloodCount::prepareDataForTransfer().

◆ sort() [2/2]

template<class T >

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

inlinestaticprivateinherited

Definition at line 726 of file FeatureFloodCount.h.

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

◆ sortAndLabel()

void FeatureFloodCount::sortAndLabel ( )

protectedinherited

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

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

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

Definition at line 568 of file FeatureFloodCount.C.

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

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

◆ 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 1426 of file GrainTracker.C.

{
  MeshBase & mesh = _mesh.getMesh();
 
  // Remap the grain
  std::set<Node *> updated_nodes_tmp; // Used only in the elemental case
  for (auto entity : grain._local_ids)
  {
    if (_is_elemental)
    {
      Elem * elem = mesh.query_elem_ptr(entity);
      if (!elem)
        continue;
 
      for (unsigned int i = 0; i < elem->n_nodes(); ++i)
      {
        Node * curr_node = elem->node_ptr(i);
        if (updated_nodes_tmp.find(curr_node) == updated_nodes_tmp.end())
        {
          // cache this node so we don't attempt to remap it again within this loop
          updated_nodes_tmp.insert(curr_node);
          swapSolutionValuesHelper(curr_node, grain._var_index, new_var_index, cache, cache_mode);
        }
      }
    }
    else
      swapSolutionValuesHelper(
          mesh.query_node_ptr(entity), grain._var_index, new_var_index, cache, cache_mode);
  }
 
  // Update the variable index in the unique grain datastructure after swaps are complete
  if (cache_mode == RemapCacheMode::USE || cache_mode == RemapCacheMode::BYPASS)
    grain._var_index = new_var_index;
}

Referenced by GrainTracker::remapGrains().

◆ 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 1465 of file GrainTracker.C.

{
  if (curr_node && curr_node->processor_id() == processor_id())
  {
    // Reinit the node so we can get and set values of the solution here
    _subproblem.reinitNode(curr_node, 0);
 
    // Local variables to hold values being transferred
    Real current, old = 0, older = 0;
    // Retrieve the value either from the old variable or cache
    if (cache_mode == RemapCacheMode::FILL || cache_mode == RemapCacheMode::BYPASS)
    {
      current = _vars[curr_var_index]->dofValues()[0];
      if (_is_transient)
      {
        old = _vars[curr_var_index]->dofValuesOld()[0];
        older = _vars[curr_var_index]->dofValuesOlder()[0];
      }
    }
    else // USE
    {
      const auto cache_it = cache[curr_var_index].find(curr_node);
      mooseAssert(cache_it != cache[curr_var_index].end(), "Error in cache");
      current = cache_it->second.current;
      old = cache_it->second.old;
      older = cache_it->second.older;
    }
 
    // Cache the value or use it!
    if (cache_mode == RemapCacheMode::FILL)
    {
      cache[curr_var_index][curr_node].current = current;
      cache[curr_var_index][curr_node].old = old;
      cache[curr_var_index][curr_node].older = older;
    }
    else // USE or BYPASS
    {
      const auto & dof_index = _vars[new_var_index]->nodalDofIndex();
 
      // Transfer this solution from the old to the current
      _sys.solution().set(dof_index, current);
      if (_is_transient)
      {
        _sys.solutionOld().set(dof_index, old);
        _sys.solutionOlder().set(dof_index, older);
      }
    }
 
    if (cache_mode == RemapCacheMode::FILL || cache_mode == RemapCacheMode::BYPASS)
    {
      const auto & dof_index = _vars[curr_var_index]->nodalDofIndex();
 
      // Set the DOF for the current variable to zero
      _sys.solution().set(dof_index, -_bound_value);
      if (_is_transient)
      {
        _sys.solutionOld().set(dof_index, -_bound_value);
        _sys.solutionOlder().set(dof_index, -_bound_value);
      }
    }
  }
}

Referenced by GrainTracker::swapSolutionValues().

◆ 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 498 of file GrainTracker.C.

{
  TIME_SECTION("trackGrains", 3, "Tracking Grains");
 
  mooseAssert(!_first_time, "Track grains may only be called when _tracking_step > _t_step");
 
  // Used to track indices for which to trigger the new grain callback on (used on all ranks)
  auto _old_max_grain_id = _max_curr_grain_id;
 
  if (_is_primary)
  {
    // Reset Status on active unique grains
    std::vector<unsigned int> map_sizes(_maps_size);
    for (auto & grain : _feature_sets_old)
    {
      if (grain._status != Status::INACTIVE)
      {
        grain._status = Status::CLEAR;
        map_sizes[grain._var_index]++;
      }
    }
 
    // Print out stats on overall tracking changes per var_index
    if (_verbosity_level > 0)
    {
      _console << "\nGrain Tracker Status:";
      for (const auto map_num : make_range(_maps_size))
      {
        _console << "\nGrains active index " << map_num << ": " << map_sizes[map_num] << " -> "
                 << _feature_counts_per_map[map_num];
        if (map_sizes[map_num] > _feature_counts_per_map[map_num])
          _console << "--";
        else if (map_sizes[map_num] < _feature_counts_per_map[map_num])
          _console << "++";
      }
      _console << '\n' << std::endl;
    }
 
    // Before we track grains, lets sort them so that we get parallel consistent answers
    std::sort(_feature_sets.begin(), _feature_sets.end());
 
    std::vector<std::size_t> new_grain_index_to_existing_grain_index(_feature_sets.size(),
                                                                     invalid_size_t);
 
    for (const auto old_grain_index : index_range(_feature_sets_old))
    {
      auto & old_grain = _feature_sets_old[old_grain_index];
 
      if (old_grain._status == Status::INACTIVE) // Don't try to find matches for inactive grains
        continue;
 
      std::size_t closest_match_index = invalid_size_t;
      Real min_centroid_diff = std::numeric_limits<Real>::max();
 
      // clang-format off
      auto start_it =
          std::lower_bound(_feature_sets.begin(), _feature_sets.end(), old_grain._var_index,
                           [](const FeatureData & item, std::size_t var_index)
                           {
                             return item._var_index < var_index;
                           });
      // clang-format on
 
      // We only need to examine grains that have matching variable indices
      bool any_boxes_intersect = false;
      for (MooseIndex(_feature_sets)
               new_grain_index = std::distance(_feature_sets.begin(), start_it);
           new_grain_index < _feature_sets.size() &&
           _feature_sets[new_grain_index]._var_index == old_grain._var_index;
           ++new_grain_index)
      {
        auto & new_grain = _feature_sets[new_grain_index];
 
        if (new_grain.boundingBoxesIntersect(old_grain))
        {
          any_boxes_intersect = true;
          Real curr_centroid_diff = centroidRegionDistance(old_grain._bboxes, new_grain._bboxes);
          if (curr_centroid_diff <= min_centroid_diff)
          {
            closest_match_index = new_grain_index;
            min_centroid_diff = curr_centroid_diff;
          }
        }
      }
 
      if (_verbosity_level > 2 && !any_boxes_intersect)
        _console << "\nNo intersecting bounding boxes found while trying to match grain "
                 << old_grain;
 
      // found a match
      if (closest_match_index != invalid_size_t)
      {
        auto curr_index = new_grain_index_to_existing_grain_index[closest_match_index];
        if (curr_index != invalid_size_t)
        {
          // The new feature being competed for
          auto & new_grain = _feature_sets[closest_match_index];
 
          // The other old grain competing to match up to the same new grain
          auto & other_old_grain = _feature_sets_old[curr_index];
 
          auto centroid_diff1 = centroidRegionDistance(new_grain._bboxes, old_grain._bboxes);
          auto centroid_diff2 = centroidRegionDistance(new_grain._bboxes, other_old_grain._bboxes);
 
          auto & inactive_grain = (centroid_diff1 < centroid_diff2) ? other_old_grain : old_grain;
 
          inactive_grain._status = Status::INACTIVE;
          if (_verbosity_level > 0)
          {
            _console << COLOR_GREEN << "Marking Grain " << inactive_grain._id
                     << " as INACTIVE (variable index: " << inactive_grain._var_index << ")\n"
                     << COLOR_DEFAULT;
            if (_verbosity_level > 1)
              _console << inactive_grain;
          }
 
          if (&inactive_grain == &other_old_grain)
            new_grain_index_to_existing_grain_index[closest_match_index] = old_grain_index;
        }
        else
          new_grain_index_to_existing_grain_index[closest_match_index] = old_grain_index;
      }
    }
 
    // Mark all resolved grain matches
    for (const auto new_index : index_range(new_grain_index_to_existing_grain_index))
    {
      auto curr_index = new_grain_index_to_existing_grain_index[new_index];
 
      // This may be a new grain, we'll handle that case below
      if (curr_index == invalid_size_t)
        continue;
 
      mooseAssert(_feature_sets_old[curr_index]._id != invalid_id,
                  "Invalid ID in old grain structure");
 
      _feature_sets[new_index]._id = _feature_sets_old[curr_index]._id; // Transfer ID
      _feature_sets[new_index]._status = Status::MARKED;      // Mark the status in the new set
      _feature_sets_old[curr_index]._status = Status::MARKED; // Mark the status in the old set
    }
 
    // Case 1 (new grains in _feature_sets):
    for (const auto grain_num : index_range(_feature_sets))
    {
      auto & grain = _feature_sets[grain_num];
 
      // New Grain
      if (grain._status == Status::CLEAR)
      {
        // clang-format off
        auto start_it =
            std::lower_bound(_feature_sets.begin(), _feature_sets.end(), grain._var_index,
                             [](const FeatureData & item, std::size_t var_index)
                             {
                               return item._var_index < var_index;
                             });
        // clang-format on
 
        // Loop over matching variable indices
        for (MooseIndex(_feature_sets)
                 new_grain_index = std::distance(_feature_sets.begin(), start_it);
             new_grain_index < _feature_sets.size() &&
             _feature_sets[new_grain_index]._var_index == grain._var_index;
             ++new_grain_index)
        {
          auto & other_grain = _feature_sets[new_grain_index];
 
          // Splitting grain?
          if (grain_num != new_grain_index && // Make sure indices aren't pointing at the same grain
              other_grain._status == Status::MARKED && // and that the other grain is indeed marked
              other_grain.boundingBoxesIntersect(grain) && // and the bboxes intersect
              other_grain.halosIntersect(grain))           // and the halos also intersect
          // TODO: Inspect combined volume and see if it's "close" to the expected value
          {
            grain._id = other_grain._id;    // Set the duplicate ID
            grain._status = Status::MARKED; // Mark it
 
            if (_verbosity_level > 0)
              _console << COLOR_YELLOW << "Split Grain Detected #" << grain._id
                       << " (variable index: " << grain._var_index << ")\n"
                       << COLOR_DEFAULT;
            if (_verbosity_level > 1)
              _console << grain << other_grain;
          }
        }
 
        if (grain._var_index < _reserve_op_index)
        {
          if (_verbosity_level > 1)
            _console << COLOR_YELLOW
                     << "Trying harder to detect a split grain while examining grain on variable "
                        "index "
                     << grain._var_index << '\n'
                     << COLOR_DEFAULT;
 
          std::vector<std::size_t> old_grain_indices;
          for (const auto old_grain_index : index_range(_feature_sets_old))
          {
            auto & old_grain = _feature_sets_old[old_grain_index];
 
            if (old_grain._status == Status::INACTIVE)
              continue;
 
            if (grain._var_index == old_grain._var_index &&
                grain.boundingBoxesIntersect(old_grain) && grain.halosIntersect(old_grain))
              old_grain_indices.push_back(old_grain_index);
          }
 
          if (old_grain_indices.size() == 1)
          {
            grain._id = _feature_sets_old[old_grain_indices[0]]._id;
            grain._status = Status::MARKED;
 
            if (_verbosity_level > 0)
              _console << COLOR_YELLOW << "Split Grain Detected #" << grain._id
                       << " (variable index: " << grain._var_index << ")\n"
                       << COLOR_DEFAULT;
          }
          else if (old_grain_indices.size() > 1)
            _console
                << COLOR_RED << "Split Grain Likely Detected #" << grain._id
                << " Need more information to find correct candidate - contact a developer!\n\n"
                << COLOR_DEFAULT;
        }
 
        // Must be a nucleating grain (status is still not set)
        if (grain._status == Status::CLEAR)
        {
          auto new_index = getNextUniqueID();
          grain._id = new_index;          // Set the ID
          grain._status = Status::MARKED; // Mark it
 
          if (_verbosity_level > 0)
            _console << COLOR_YELLOW << "Nucleating Grain Detected "
                     << " (variable index: " << grain._var_index << ")\n"
                     << COLOR_DEFAULT;
          if (_verbosity_level > 1)
            _console << grain;
        }
      }
    }
 
    // Case 2 (inactive grains in _feature_sets_old)
    for (auto & grain : _feature_sets_old)
    {
      if (grain._status == Status::CLEAR)
      {
        grain._status = Status::INACTIVE;
        if (_verbosity_level > 0)
        {
          _console << COLOR_GREEN << "Marking Grain " << grain._id
                   << " as INACTIVE (variable index: " << grain._var_index << ")\n"
                   << COLOR_DEFAULT;
          if (_verbosity_level > 1)
            _console << grain;
        }
      }
    }
  } // is_primary
 
  /*************************************************************
   ****************** COLLECTIVE WORK SECTION ******************
   *************************************************************/
 
  // Make IDs on all non-primary ranks consistent
  scatterAndUpdateRanks();
 
  // Build up an id to index map
  _communicator.broadcast(_max_curr_grain_id);
  buildFeatureIdToLocalIndices(_max_curr_grain_id);
 
  if (_old_max_grain_id < _max_curr_grain_id)
  {
    for (auto new_id = _old_max_grain_id + 1; new_id <= _max_curr_grain_id; ++new_id)
    {
      // Don't trigger the callback on the reserve IDs
      if (new_id >= _reserve_grain_first_index + _n_reserve_ops)
      {
        // See if we've been instructed to terminate with an error
        if (!_first_time && _error_on_grain_creation)
          mooseError(
              "Error: New grain detected and \"error_on_new_grain_creation\" is set to true");
        else
          newGrainCreated(new_id);
      }
    }
  }
}

Referenced by GrainTracker::finalize().

◆ updateBoundaryIntersections()

void FeatureFloodCount::updateBoundaryIntersections ( FeatureData & feature ) const

protectedinherited

Update the feature's attributes to indicate boundary intersections.

Definition at line 1774 of file FeatureFloodCount.C.

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

Referenced by FeatureFloodCount::prepareDataForTransfer().

◆ updateFieldInfo()

void 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 1545 of file GrainTracker.C.

{
  TIME_SECTION("updateFieldInfo", 3, "Updating Field Info");
 
  for (const auto map_num : make_range(_maps_size))
    _feature_maps[map_num].clear();
 
  std::map<dof_id_type, Real> tmp_map;
 
  for (const auto & grain : _feature_sets)
  {
    std::size_t curr_var = grain._var_index;
    std::size_t map_index = (_single_map_mode || _condense_map_info) ? 0 : curr_var;
 
    for (auto entity : grain._local_ids)
    {
      // Highest variable value at this entity wins
      Real entity_value = std::numeric_limits<Real>::lowest();
      if (_is_elemental)
      {
        const Elem * elem = _mesh.elemPtr(entity);
        std::vector<Point> centroid(1, elem->vertex_average());
        if (_poly_ic_uo && _first_time)
        {
          entity_value = _poly_ic_uo->getVariableValue(grain._var_index, centroid[0]);
        }
        else
        {
          _fe_problem.reinitElemPhys(elem, centroid, 0);
          entity_value = _vars[curr_var]->sln()[0];
        }
      }
      else
      {
        auto node_ptr = _mesh.nodePtr(entity);
        entity_value = _vars[curr_var]->getNodalValue(*node_ptr);
      }
 
      if (entity_value != std::numeric_limits<Real>::lowest() &&
          (tmp_map.find(entity) == tmp_map.end() || entity_value > tmp_map[entity]))
      {
        mooseAssert(grain._id != invalid_id, "Missing Grain ID");
        _feature_maps[map_index][entity] = grain._id;
 
        if (_var_index_mode)
          _var_index_maps[map_index][entity] = grain._var_index;
 
        tmp_map[entity] = entity_value;
      }
 
      if (_compute_var_to_feature_map)
      {
        auto insert_pair = moose_try_emplace(
            _entity_var_to_features, entity, std::vector<unsigned int>(_n_vars, invalid_id));
        auto & vec_ref = insert_pair.first->second;
 
        if (insert_pair.second)
        {
          // insert the reserve op numbers (if appropriate)
          for (const auto reserve_index : make_range(_n_reserve_ops))
            vec_ref[reserve_index] = _reserve_grain_first_index + reserve_index;
        }
        vec_ref[grain._var_index] = grain._id;
      }
    }
 
    if (_compute_halo_maps)
      for (auto entity : grain._halo_ids)
        _halo_ids[grain._var_index][entity] = grain._var_index;
 
    for (auto entity : grain._ghosted_ids)
      _ghosted_entity_ids[entity] = 1;
  }
 
  communicateHaloMap();
}

Referenced by GrainTracker::finalize().

◆ updateRegionOffsets()

void FeatureFloodCount::updateRegionOffsets ( )

protectedinherited

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

◆ validParams()

InputParameters GrainTracker::validParams ( )

staticinherited

Definition at line 49 of file GrainTracker.C.

{
  InputParameters params = FeatureFloodCount::validParams();
  params += GrainTrackerInterface::validParams();
 
  // FeatureFloodCount adds a relationship manager, but we need to extend that for GrainTracker
  params.clearRelationshipManagers();
 
  params.addRelationshipManager(
      "ElementSideNeighborLayers",
      Moose::RelationshipManagerType::GEOMETRIC,
 
      [](const InputParameters & obj_params, InputParameters & rm_params)
      { rm_params.set<unsigned short>("layers") = obj_params.get<unsigned short>("halo_level"); }
 
  );
 
  params.addRelationshipManager("ElementSideNeighborLayers",
                                Moose::RelationshipManagerType::ALGEBRAIC);
 
  // The GrainTracker requires non-volatile storage for tracking grains across invocations.
  params.set<bool>("restartable_required") = true;
 
  params.addParam<Real>("bound_value",
                        0.0,
                        "Absolute value of the lower bound for the variable value that represents "
                        "a region not assigned to the grain. Must be positive, but the actual "
                        "value used is -bound_value.");
 
  params.addClassDescription("Grain Tracker object for running reduced order parameter simulations "
                             "without grain coalescence.");
 
  return params;
}

Referenced by GrainTrackerElasticity::validParams().

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

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

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

◆ visitNeighborsHelper()

template<typename T >

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

protectedinherited

The actual logic for visiting neighbors is abstracted out here.

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

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

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

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

Definition at line 1717 of file FeatureFloodCount.C.

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

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

◆ visitNodalNeighbors()

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

protectedinherited

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

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

Definition at line 1703 of file FeatureFloodCount.C.

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

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

Member Data Documentation

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

◆ _all_ranges

std::vector<std::pair<dof_id_type, dof_id_type> > GrainTracker::_all_ranges

privateinherited

Data structure to hold element ID ranges when using Distributed Mesh (populated on rank 0 only)

Definition at line 250 of file GrainTracker.h.

Referenced by GrainTracker::communicateHaloMap(), and GrainTracker::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().

◆ _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(), FeatureFloodCount::updateFieldInfo(), and GrainTracker::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(), FeatureFloodCount::updateFieldInfo(), and GrainTracker::updateFieldInfo().

◆ _condense_map_info

const bool FeatureFloodCount::_condense_map_info

protectedinherited

Definition at line 577 of file FeatureFloodCount.h.

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

◆ _connecting_threshold

const Real FeatureFloodCount::_connecting_threshold

protectedinherited

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

Definition at line 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

Definition at line 699 of file FeatureFloodCount.h.

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

◆ _entities_visited

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

protectedinherited

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

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

Definition at line 615 of file FeatureFloodCount.h.

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

◆ _entity_queue

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

privateinherited

The data structure for maintaining entities to flood during discovery.

Definition at line 759 of file FeatureFloodCount.h.

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

◆ _entity_var_to_features

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

protectedinherited

Definition at line 697 of file FeatureFloodCount.h.

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

◆ _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 234 of file GrainTracker.h.

Referenced by GrainTracker::trackGrains().

◆ _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 GrainTracker::centroidRegionDistance(), FeatureFloodCount::FeatureFloodCount(), and FeatureFloodCount::getFECoupledVars().

◆ _feature_count

unsigned int FeatureFloodCount::_feature_count

protectedinherited

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

Definition at line 632 of file FeatureFloodCount.h.

◆ _feature_counts_per_map

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

protectedinherited

The number of features seen by this object per map.

Definition at line 629 of file FeatureFloodCount.h.

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

◆ _feature_id_to_local_index

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

protectedinherited

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

Definition at line 668 of file FeatureFloodCount.h.

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

◆ _feature_maps

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

protectedinherited

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

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

Definition at line 662 of file FeatureFloodCount.h.

Referenced by FeatureFloodCount::getEntityValue(), FeatureFloodCount::initialize(), FeatureFloodCount::updateFieldInfo(), and GrainTracker::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.

◆ _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 213 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 227 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(), FeatureFloodCount::updateFieldInfo(), and GrainTracker::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

template<typename T >

std::vector<T>& GrainDataTracker< T >::_grain_data

protected

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(), FeatureFloodCount::updateFieldInfo(), and GrainTracker::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

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

Definition at line 707 of file FeatureFloodCount.h.

◆ _is_primary

const bool FeatureFloodCount::_is_primary

protectedinherited

Convenience variable for testing primary rank.

Definition at line 716 of file FeatureFloodCount.h.

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

◆ _is_transient

const bool GrainTracker::_is_transient

privateinherited

Boolean to indicate whether this is a Steady or Transient solve.

Definition at line 247 of file GrainTracker.h.

Referenced by GrainTracker::swapSolutionValuesHelper().

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

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

Definition at line 604 of file FeatureFloodCount.h.

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

◆ _max_curr_grain_id

unsigned int& GrainTracker::_max_curr_grain_id

privateinherited

Holds the next "regular" grain ID (a grain found or remapped to the standard op vars)

Definition at line 244 of file GrainTracker.h.

Referenced by GrainTracker::assignGrains(), GrainTracker::getNewGrainIDs(), GrainTracker::getNextUniqueID(), GrainTracker::getTotalFeatureCount(), and GrainTracker::trackGrains().

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

A reference to the mesh.

Definition at line 565 of file FeatureFloodCount.h.

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

Definition at line 601 of file FeatureFloodCount.h.

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

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

◆ _old_max_grain_id

unsigned int GrainTracker::_old_max_grain_id

privateinherited

The previous max grain id (needed to figure out which ids are new in a given step)

Definition at line 241 of file GrainTracker.h.

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

◆ _partial_feature_sets

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

protectedinherited

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

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

Definition at line 639 of file FeatureFloodCount.h.

◆ _pbs

libMesh::PeriodicBoundaries* FeatureFloodCount::_pbs

protectedinherited

A pointer to the periodic boundary constraints object.

Definition at line 671 of file FeatureFloodCount.h.

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

◆ _periodic_node_map

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

protectedinherited

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

Definition at line 691 of file FeatureFloodCount.h.

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

◆ _point_locator

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

protectedinherited

Definition at line 673 of file FeatureFloodCount.h.

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

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

Definition at line 701 of file FeatureFloodCount.h.

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

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

unsigned int GrainTracker::_reserve_grain_first_index

privateinherited

Holds the first unique grain index when using _reserve_op (all the remaining indices are sequential)

Definition at line 238 of file GrainTracker.h.

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

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

Definition at line 702 of file FeatureFloodCount.h.

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

◆ _single_map_mode

const bool FeatureFloodCount::_single_map_mode

protectedinherited

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

Definition at line 575 of file FeatureFloodCount.h.

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

◆ _specified_bnds

std::vector<BoundaryID> FeatureFloodCount::_specified_bnds

protectedinherited

Definition at line 704 of file FeatureFloodCount.h.

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

◆ _step_connecting_threshold

Real FeatureFloodCount::_step_connecting_threshold

protectedinherited

Definition at line 562 of file FeatureFloodCount.h.

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

◆ _step_threshold

Real FeatureFloodCount::_step_threshold

protectedinherited

Definition at line 557 of file FeatureFloodCount.h.

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

◆ _threshold

const Real FeatureFloodCount::_threshold

protectedinherited

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

Definition at line 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

The timestep to begin tracking grains.

Definition at line 179 of file GrainTracker.h.

Referenced by GrainTracker::execute(), GrainTracker::finalize(), GrainTracker::getEntityValue(), GrainTracker::GrainTracker(), GrainTracker::initialize(), and GrainTracker::remapGrains().

◆ _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(), FeatureFloodCount::updateFieldInfo(), and GrainTracker::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(), FeatureFloodCount::updateFieldInfo(), and GrainTracker::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 FeatureFloodCount::meshChanged().

◆ _vars

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

protectedinherited

The vector of coupled in variables cast to MooseVariable.

Definition at line 550 of file FeatureFloodCount.h.

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

◆ _verbosity_level

const short GrainTracker::_verbosity_level

protectedinherited

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

Definition at line 221 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

Definition at line 92 of file FeatureFloodCount.h.

◆ 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

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

Definition at line 91 of file FeatureFloodCount.h.

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

phase_field/include/postprocessors/GrainDataTracker.h

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

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ BoundaryIntersection

◆ FieldType

◆ RemapCacheMode

◆ Status

Constructor & Destructor Documentation

◆ GrainDataTracker()

Member Function Documentation

◆ appendPeriodicNeighborNodes()

◆ areFeaturesMergeable()

◆ assignGrains()

◆ attemptGrainRenumber()

◆ boundingRegionDistance()

◆ broadcastAndUpdateGrainData()

◆ buildFeatureIdToLocalIndices()

◆ buildLocalToGlobalIndices()

◆ centroidRegionDistance()

◆ clearDataStructures()

◆ communicateAndMerge()

◆ communicateHaloMap()

◆ compareValueWithThreshold()

◆ computeMinDistancesFromGrain()

◆ consolidateMergedFeatures()

◆ contains() [1/2]

◆ contains() [2/2]

◆ deserialize()

◆ doesFeatureIntersectBoundary()

◆ doesFeatureIntersectSpecifiedBoundary()

◆ execute()

◆ expandEdgeHalos()

◆ expandPointHalos()

◆ featureCentroid()

◆ finalize()

◆ flood()

◆ getConnectingThreshold()

◆ getCoupledVars()

◆ getData()

◆ getEntityValue()

◆ getFeatures()

◆ getFeatureVar()

◆ getFECoupledVars()

◆ getGrainCentroid()

◆ getNewGrainIDs()

◆ getNextUniqueID()

◆ getNumberActiveFeatures()

◆ getNumberActiveGrains()

◆ getThreshold()

◆ getTotalFeatureCount()

◆ getValue()

◆ getVarToFeatureVector()

◆ initialize()

◆ initialSetup()

◆ isBoundaryEntity()

◆ isElemental()

◆ isFeaturePercolated()

◆ isNewFeatureOrConnectedRegion()

◆ mergeSets()

◆ meshChanged()

◆ newGrain()

◆ newGrainCreated()

◆ numberOfDistributedMergeHelpers()

◆ numCoupledVars()

◆ prepareDataForTransfer()

◆ prepopulateState()

◆ remapGrains()

◆ reserve() [1/2]