BimodalInverseSuperellipsoidsIC takes a specified number of superellipsoids, each with given parameters These are intended to be the larger particles. More...

#include <BimodalInverseSuperellipsoidsIC.h>

Inheritance diagram for BimodalInverseSuperellipsoidsIC:

[legend]

Public Types
enum	TEST_TYPE

typedef OutputTools< T >::OutputShape	ValueType

typedef OutputTools< T >::OutputGradient	GradientType

typedef OutputTools< T >::OutputShapeGradient	GradientShapeType

typedef OutputTools< T >::OutputData	DataType

typedef FEGenericBase< ValueType >	FEBaseType

typedef DataFileName	DataFileParameterType

Public Member Functions
	BimodalInverseSuperellipsoidsIC (const InputParameters &parameters)

virtual Real	value (const Point &p)
	Have to do things slightly different from SmoothSuperellipsoidBaseIC because of the inverse structure. More...

virtual void	initialSetup ()

virtual void	computeSuperellipsoidCenters ()

virtual RealGradient	gradient (const Point &p)

virtual MooseVariableFEBase &	variable () override

virtual void	compute () override

virtual void	computeNodal (const Point &p) override

T	gradientComponent (GradientType grad, unsigned int i)

RealVectorValue	gradientComponent (GradientType grad, unsigned int i)

RealEigenVector	gradientComponent (GradientType grad, unsigned int i)

void	setCZeroVertices ()

void	setCZeroVertices ()

void	setHermiteVertices ()

void	setHermiteVertices ()

void	setOtherCOneVertices ()

void	setOtherCOneVertices ()

Real	dotHelper (const RealGradient &op1, const RealGradient &op2)

Real	dotHelper (const RealTensor &op1, const RealTensor &op2)

RealEigenVector	dotHelper (const RealVectorArrayValue &op1, const RealGradient &op2)

void	choleskySolve (bool is_volume)

void	choleskySolve (bool is_volume)

void	choleskyAssembly (bool is_volume)

const std::set< UserObjectName > &	getDependObjects () const

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

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

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

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

MooseApp &	getMooseApp () const

const std::string &	type () const

virtual const std::string &	name () const

std::string	typeAndName () const

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

void	callMooseError (std::string msg, const bool with_prefix) const

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

const InputParameters &	parameters () const

MooseObjectName	uniqueName () const

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

std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

std::string	getDataFileNameByName (const std::string &name, const std::string *param=nullptr) const

const std::vector< SubdomainName > &	blocks () const

unsigned int	numBlocks () const

virtual const std::set< SubdomainID > &	blockIDs () const

unsigned int	blocksMaxDimension () const

bool	hasBlocks (const SubdomainName &name) const

bool	hasBlocks (const std::vector< SubdomainName > &names) const

bool	hasBlocks (SubdomainID id) const

bool	hasBlocks (const std::vector< SubdomainID > &ids) const

bool	hasBlocks (const std::set< SubdomainID > &ids) const

bool	isBlockSubset (const std::set< SubdomainID > &ids) const

bool	isBlockSubset (const std::vector< SubdomainID > &ids) const

bool	hasBlockMaterialProperty (const std::string &prop_name)

const std::set< SubdomainID > &	meshBlockIDs () const

virtual bool	blockRestricted () const

virtual void	checkVariable (const MooseVariableFieldBase &variable) const

const std::unordered_map< std::string, std::vector< MooseVariableFieldBase *> > &	getCoupledVars () 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 ADVariableValue *	getADDefaultValue (const std::string &var_name) const

const ADVectorVariableValue *	getADDefaultVectorValue (const std::string &var_name) const

const ADVariableGradient &	getADDefaultGradient () const

const ADVectorVariableGradient &	getADDefaultVectorGradient () const

const ADVariableSecond &	getADDefaultSecond () const

const GenericMaterialProperty< T, is_ad > &	getGenericMaterialProperty (const std::string &name, MaterialData &material_data, const unsigned int state=0)

const GenericMaterialProperty< T, is_ad > &	getGenericMaterialProperty (const std::string &name, const unsigned int state=0)

const GenericMaterialProperty< T, is_ad > &	getGenericMaterialProperty (const std::string &name, const unsigned int state=0)

const MaterialProperty< T > &	getMaterialProperty (const std::string &name, MaterialData &material_data, const unsigned int state=0)

const MaterialProperty< T > &	getMaterialProperty (const std::string &name, const unsigned int state=0)

const MaterialProperty< T > &	getMaterialProperty (const std::string &name, const unsigned int state=0)

const ADMaterialProperty< T > &	getADMaterialProperty (const std::string &name, MaterialData &material_data)

const ADMaterialProperty< T > &	getADMaterialProperty (const std::string &name)

const ADMaterialProperty< T > &	getADMaterialProperty (const std::string &name)

const MaterialProperty< T > &	getMaterialPropertyOld (const std::string &name, MaterialData &material_data)

const MaterialProperty< T > &	getMaterialPropertyOld (const std::string &name)

const MaterialProperty< T > &	getMaterialPropertyOld (const std::string &name)

const MaterialProperty< T > &	getMaterialPropertyOlder (const std::string &name, MaterialData &material_data)

const MaterialProperty< T > &	getMaterialPropertyOlder (const std::string &name)

const MaterialProperty< T > &	getMaterialPropertyOlder (const std::string &name)

const GenericMaterialProperty< T, is_ad > &	getGenericMaterialPropertyByName (const MaterialPropertyName &name, MaterialData &material_data, const unsigned int state)

const GenericMaterialProperty< T, is_ad > &	getGenericMaterialPropertyByName (const MaterialPropertyName &name, const unsigned int state=0)

const GenericMaterialProperty< T, is_ad > &	getGenericMaterialPropertyByName (const MaterialPropertyName &name, const unsigned int state=0)

const MaterialProperty< T > &	getMaterialPropertyByName (const MaterialPropertyName &name, MaterialData &material_data, const unsigned int state=0)

const MaterialProperty< T > &	getMaterialPropertyByName (const MaterialPropertyName &name, const unsigned int state=0)

const MaterialProperty< T > &	getMaterialPropertyByName (const MaterialPropertyName &name, const unsigned int state=0)

const ADMaterialProperty< T > &	getADMaterialPropertyByName (const MaterialPropertyName &name, MaterialData &material_data)

const ADMaterialProperty< T > &	getADMaterialPropertyByName (const MaterialPropertyName &name)

const ADMaterialProperty< T > &	getADMaterialPropertyByName (const MaterialPropertyName &name)

const MaterialProperty< T > &	getMaterialPropertyOldByName (const MaterialPropertyName &name, MaterialData &material_data)

const MaterialProperty< T > &	getMaterialPropertyOldByName (const MaterialPropertyName &name)

const MaterialProperty< T > &	getMaterialPropertyOldByName (const MaterialPropertyName &name)

const MaterialProperty< T > &	getMaterialPropertyOlderByName (const MaterialPropertyName &name, MaterialData &material_data)

const MaterialProperty< T > &	getMaterialPropertyOlderByName (const MaterialPropertyName &name)

const MaterialProperty< T > &	getMaterialPropertyOlderByName (const MaterialPropertyName &name)

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

const GenericMaterialProperty< T, is_ad > &	getGenericZeroMaterialProperty (const std::string &name)

const GenericMaterialProperty< T, is_ad > &	getGenericZeroMaterialProperty ()

const GenericMaterialProperty< T, is_ad > &	getGenericZeroMaterialPropertyByName (const std::string &prop_name)

const MaterialProperty< T > &	getZeroMaterialProperty (Ts... args)

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

bool	getMaterialPropertyCalled () const

const std::unordered_set< unsigned int > &	getMatPropDependencies () const

virtual void	resolveOptionalProperties ()

const GenericMaterialProperty< T, is_ad > &	getPossiblyConstantGenericMaterialPropertyByName (const MaterialPropertyName &prop_name, MaterialData &material_data, const unsigned int state)

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

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 UserObject &	getUserObjectBase (const std::string &param_name, bool is_dependency=true) const

const UserObject &	getUserObjectBaseByName (const UserObjectName &object_name, bool is_dependency=true) 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

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

virtual unsigned int	getElementIDIndex (const std::string &id_parameter_name, unsigned int comp=0) const

virtual unsigned int	getElementIDIndexByName (const std::string &id_name) const

virtual const dof_id_type &	getElementID (const std::string &id_parameter_name, unsigned int comp=0) const

dof_id_type	getElementID (const Elem *elem, unsigned int elem_id_index) const

virtual const dof_id_type &	getElementIDNeighbor (const std::string &id_parameter_name, unsigned int comp=0) const

virtual const dof_id_type &	getElementIDByName (const std::string &id_name) const

virtual const dof_id_type &	getElementIDNeighborByName (const std::string &id_name) const

bool	hasElementID (const std::string &id_name) const

dof_id_type	maxElementID (unsigned int elem_id_index) const

dof_id_type	minElementID (unsigned int elem_id_index) const

bool	areElemIDsIdentical (const std::string &id_name1, const std::string &id_name2) const

std::unordered_map< dof_id_type, std::set< dof_id_type > >	getElemIDMapping (const std::string &id_name1, const std::string &id_name2) const

std::set< dof_id_type >	getAllElemIDs (unsigned int elem_id_index) const

std::set< dof_id_type >	getElemIDsOnBlocks (unsigned int elem_id_index, const std::set< SubdomainID > &blks) 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	hasGenericMaterialProperty (const std::string &name)

bool	hasGenericMaterialProperty (const std::string &name)

bool	hasGenericMaterialPropertyByName (const std::string &name)

bool	hasGenericMaterialPropertyByName (const std::string &name)

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

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()

static bool	restricted (const std::set< BoundaryID > &ids)

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

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

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

Public Attributes
	ALL

	ANY

const ConsoleStream	_console

Static Public Attributes
static constexpr PropertyValue::id_type	default_property_id

static constexpr PropertyValue::id_type	zero_property_id

Protected Member Functions
virtual void	computeSuperellipsoidSemiaxes ()

virtual void	computeSuperellipsoidExponents ()

virtual Real	computeSuperellipsoidValue (const Point &p, const Point &center, Real a, Real b, Real c, Real n)

virtual Real	computeSuperellipsoidInverseValue (const Point &p, const Point &center, Real a, Real b, Real c, Real n)

RealGradient	computeSuperellipsoidGradient (const Point &p, const Point &center, Real a, Real b, Real c, Real n)

virtual bool	hasBlockMaterialPropertyHelper (const std::string &prop_name)

void	initializeBlockRestrictable (const MooseObject *moose_object)

Moose::CoordinateSystemType	getBlockCoordSystem ()

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

std::vector< const GenericVariableValue< is_ad > *>	coupledGenericValues (const std::string &var_name) const

std::vector< const GenericVariableValue< false > *>	coupledGenericValues (const std::string &var_name) const

std::vector< const GenericVariableValue< true > *>	coupledGenericValues (const std::string &var_name) const

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

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

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

virtual const 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

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

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

bool	checkVar (const std::string &var_name, unsigned int comp=0, unsigned int comp_bound=0) const

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)

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

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

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

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

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

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

void	markMatPropRequested (const std::string &)

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

void	checkExecutionStage ()

bool	hasBoundaryMaterialPropertyHelper (const std::string &prop_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 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)

Protected Attributes
const unsigned int	_max_num_tries

Point	_bottom_left

Point	_top_right

Point	_range

std::vector< Real >	_x_positions

std::vector< Real >	_y_positions

std::vector< Real >	_z_positions

std::vector< Real >	_input_as

std::vector< Real >	_input_bs

std::vector< Real >	_input_cs

std::vector< Real >	_input_ns

MooseMesh &	_mesh

Real	_invalue

Real	_outvalue

Real	_nestedvalue

Real	_int_width

bool	_zero_gradient

unsigned int	_num_dim

std::vector< Point >	_centers

std::vector< Real >	_as

std::vector< Real >	_bs

std::vector< Real >	_cs

std::vector< Real >	_ns

MooseRandom	_random

FEProblemBase &	_fe_problem

THREAD_ID	_tid

Real &	_t

MooseVariableField< T > &	_var

MooseVariableFE< T > *	_fe_var

Assembly &	_assembly

const Moose::CoordinateSystemType &	_coord_sys

const Elem *const &	_current_elem

const Real &	_current_elem_volume

const Node *	_current_node

unsigned int	_qp

DenseMatrix< Real >	_Ke

DenseVector< DataType >	_Fe

DenseVector< DataType >	_Ue

const FEType &	_fe_type

FEContinuity	_cont

std::vector< dof_id_type >	_dof_indices

std::vector< unsigned int >	_side_dofs

unsigned int	_n_qp

unsigned int	_n_nodes

std::vector< char >	_dof_is_fixed

std::vector< int >	_free_dof

dof_id_type	_free_dofs

dof_id_type	_current_dof

dof_id_type	_nc

const std::vector< std::vector< ValueType > > *	_phi

const std::vector< std::vector< GradientShapeType > > *	_dphi

const std::vector< Real > *	_JxW

const std::vector< Point > *	_xyz_values

unsigned int	_n

unsigned int	_dim

SystemBase &	_sys

const bool	_ignore_uo_dependency

const bool &	_enabled

MooseApp &	_app

const std::string	_type

const std::string	_name

const InputParameters &	_pars

Factory &	_factory

ActionFactory &	_action_factory

const MaterialData *	_blk_material_data

const InputParameters &	_c_parameters

const std::string &	_c_name

const std::string &	_c_type

FEProblemBase &	_c_fe_problem

const SystemBase *const	_c_sys

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

std::vector< MooseVariableFieldBase *>	_coupled_moose_vars

std::vector< MooseVariable *>	_coupled_standard_moose_vars

std::vector< VectorMooseVariable *>	_coupled_vector_moose_vars

std::vector< ArrayMooseVariable *>	_coupled_array_moose_vars

std::vector< MooseVariableFV< Real > *>	_coupled_standard_fv_moose_vars

std::vector< MooseLinearVariableFV< Real > *>	_coupled_standard_linear_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::vector< std::unique_ptr< VariableValue > > >	_default_value

std::unordered_map< std::string, std::unique_ptr< MooseArray< DualReal > > >	_ad_default_value

std::unordered_map< std::string, std::unique_ptr< VectorVariableValue > >	_default_vector_value

std::unordered_map< std::string, std::unique_ptr< ArrayVariableValue > >	_default_array_value

std::unordered_map< std::string, std::unique_ptr< MooseArray< ADRealVectorValue > > >	_ad_default_vector_value

VariableValue	_default_value_zero

VariableGradient	_default_gradient

MooseArray< ADRealVectorValue >	_ad_default_gradient

MooseArray< ADRealTensorValue >	_ad_default_vector_gradient

VariableSecond	_default_second

MooseArray< ADRealTensorValue >	_ad_default_second

const VariableValue &	_zero

const VariablePhiValue &	_phi_zero

const MooseArray< DualReal > &	_ad_zero

const VariableGradient &	_grad_zero

const MooseArray< ADRealVectorValue > &	_ad_grad_zero

const VariablePhiGradient &	_grad_phi_zero

const VariableSecond &	_second_zero

const MooseArray< ADRealTensorValue > &	_ad_second_zero

const VariablePhiSecond &	_second_phi_zero

const VectorVariableValue &	_vector_zero

const VectorVariableCurl &	_vector_curl_zero

VectorVariableValue	_default_vector_value_zero

VectorVariableGradient	_default_vector_gradient

VectorVariableCurl	_default_vector_curl

VectorVariableDivergence	_default_div

ArrayVariableValue	_default_array_value_zero

ArrayVariableGradient	_default_array_gradient

bool	_coupleable_neighbor

const InputParameters &	_mi_params

const std::string	_mi_name

const MooseObjectName	_mi_moose_object_name

FEProblemBase &	_mi_feproblem

SubProblem &	_mi_subproblem

const THREAD_ID	_mi_tid

const Moose::MaterialDataType	_material_data_type

MaterialData &	_material_data

bool	_stateful_allowed

bool	_get_material_property_called

std::vector< std::unique_ptr< PropertyValue > >	_default_properties

std::unordered_set< unsigned int >	_material_property_dependencies

const MaterialPropertyName	_get_suffix

const bool	_use_interpolated_state

MooseApp &	_restartable_app

const std::string	_restartable_system_name

const THREAD_ID	_restartable_tid

const bool	_restartable_read_only

const Parallel::Communicator &	_communicator


unsigned int	_npart
	Variables to describe the randomly placed (smaller) superellipsoids. More...

Real	_small_spac

Real	_large_spac

Real	_small_a

Real	_small_b

Real	_small_c

Real	_small_n

const Real	_size_variation

const MooseEnum	_size_variation_type

Static Protected Attributes
static const std::string	_interpolated_old

static const std::string	_interpolated_older

Detailed Description

BimodalInverseSuperellipsoidsIC takes a specified number of superellipsoids, each with given parameters These are intended to be the larger particles.

Then the IC creates a specified number of particles at random locations. These are the smaller particles. Unlike in the parent class, the smaller particles are embedded inside the larger particles, which is why this IC is referred to as Inverse.

Definition at line 23 of file BimodalInverseSuperellipsoidsIC.h.

Constructor & Destructor Documentation

◆ BimodalInverseSuperellipsoidsIC()

BimodalInverseSuperellipsoidsIC::BimodalInverseSuperellipsoidsIC ( const InputParameters & parameters )

Definition at line 28 of file BimodalInverseSuperellipsoidsIC.C.

   : BimodalSuperellipsoidsIC(parameters)
 {
 }

Member Function Documentation

◆ computeSuperellipsoidCenters()

void BimodalInverseSuperellipsoidsIC::computeSuperellipsoidCenters ( )

virtual

Reimplemented from BimodalSuperellipsoidsIC.

Definition at line 72 of file BimodalInverseSuperellipsoidsIC.C.

 {
   _centers.resize(_x_positions.size() + _npart);
 
   // First place the specified (large) particles from the input file
   for (unsigned int i = 0; i < _x_positions.size(); ++i)
   {
     _centers[i](0) = _x_positions[i];
     _centers[i](1) = _y_positions[i];
     _centers[i](2) = _z_positions[i];
   }
 
   // Next place the randomly positioned (small) particles
   for (unsigned int i = _x_positions.size(); i < _x_positions.size() + _npart; ++i)
   {
     unsigned int num_tries = 0;
 
     while (num_tries < _max_num_tries)
     {
       num_tries++;
 
       RealTensorValue ran;
       ran(0, 0) = _random.rand(_tid);
       ran(1, 1) = _random.rand(_tid);
       ran(2, 2) = _random.rand(_tid);
 
       _centers[i] = _bottom_left + ran * _range;
 
       // check for collisions with the specified (large) and randomly placed small particles
       for (unsigned int j = 0; j < i; ++j)
       {
         // Compute the distance r1 from the center of each specified superellipsoid to its
         // outside edge along the vector between the specified superellipsoid and the current
         // randomly positioned one.
         // This uses the equation for a superellipse in polar coordinates and substitutes
         // distances for sin, cos functions.
         Point dist_vec = _mesh.minPeriodicVector(_var.number(), _centers[i], _centers[j]);
         const Real dist = dist_vec.norm();
 
         // First calculate rmn1 = r1^(-n), replacing sin, cos functions with distances
         Real rmn1 = (std::pow(std::abs(dist_vec(0) / dist / _as[j]), _ns[j]) +
                      std::pow(std::abs(dist_vec(1) / dist / _bs[j]), _ns[j]) +
                      std::pow(std::abs(dist_vec(2) / dist / _cs[j]), _ns[j]));
         // Then calculate r1 from rmn1
         const Real r1 = std::pow(rmn1, (-1.0 / _ns[j]));
 
         // Now calculate the distance r2 from the center of the randomly placed
         // superellipsoid to its outside edge in the same manner
         Real rmn2 = (std::pow(std::abs(dist_vec(0) / dist / _as[i]), _ns[i]) +
                      std::pow(std::abs(dist_vec(1) / dist / _bs[i]), _ns[i]) +
                      std::pow(std::abs(dist_vec(2) / dist / _cs[i]), _ns[i]));
         const Real r2 = std::pow(rmn2, (-1.0 / _ns[i]));
 
         if (j < _x_positions.size())
         {
           if (r1 - dist - r2 < _large_spac)
             goto fail;
         }
         else
         {
           if (dist - r1 - r2 < _small_spac)
             goto fail;
         }
       }
 
       // accept the position of the new center
       goto accept;
 
     // retry a new position until tries are exhausted
     fail:
       continue;
     }
 
     if (num_tries == _max_num_tries)
       mooseError("Too many tries in MultiSmoothCircleIC");
 
   accept:
     continue;
   }
 }

◆ computeSuperellipsoidExponents()

void BimodalSuperellipsoidsIC::computeSuperellipsoidExponents ( )

protectedvirtualinherited

Reimplemented from SpecifiedSmoothSuperellipsoidIC.

Definition at line 136 of file BimodalSuperellipsoidsIC.C.

 {
   _ns.resize(_input_ns.size() + _npart);
 
   // First fill in the specified (large) superellipsoids from the input file
   for (unsigned int i = 0; i < _input_ns.size(); ++i)
     _ns[i] = _input_ns[i];
 
   // Then fill in the randomly positioned (small) superellipsoids
   // The shape is assumed to stay constant so n does not vary
   for (unsigned int i = _input_ns.size(); i < _input_ns.size() + _npart; ++i)
     _ns[i] = _small_n;
 }

◆ computeSuperellipsoidGradient()

RealGradient SmoothSuperellipsoidBaseIC::computeSuperellipsoidGradient	(	const Point &	p,
		const Point &	center,
		Real	a,
		Real	b,
		Real	c,
		Real	n
	)

protectedinherited

Definition at line 194 of file SmoothSuperellipsoidBaseIC.C.

Referenced by SmoothSuperellipsoidBaseIC::gradient().

 {
   Point l_center = center;
   Point l_p = p;
   // Compute the distance between the current point and the center
   Real dist = _mesh.minPeriodicDistance(_var.number(), l_p, l_center);
 
   // When dist is 0 we are exactly at the center of the superellipsoid so return 0
   // Handle this case independently because we cannot calculate polar angles at this point
   if (dist == 0.0)
     return 0.0;
 
   // Compute the distance r from the center of the superellipsoid to its outside edge
   // along the vector from the center to the current point
   // This uses the equation for a superellipse in polar coordinates and substitutes
   // distances for sin, cos functions
   Point dist_vec = _mesh.minPeriodicVector(_var.number(), center, p);
   // First calculate rmn = r^(-n)
   Real rmn = (std::pow(std::abs(dist_vec(0) / dist / a), n) +
               std::pow(std::abs(dist_vec(1) / dist / b), n) +
               std::pow(std::abs(dist_vec(2) / dist / c), n));
   // Then calculate r from rmn
   Real r = std::pow(rmn, (-1.0 / n));
 
   Real DvalueDr = 0.0;
 
   if (dist < r + _int_width / 2.0 && dist > r - _int_width / 2.0) // in interfacial region
   {
     Real int_pos = (dist - r + _int_width / 2.0) / _int_width;
     Real Dint_posDr = 1.0 / _int_width;
     DvalueDr = Dint_posDr * (_invalue - _outvalue) *
                (-std::sin(int_pos * libMesh::pi) * libMesh::pi) / 2.0;
   }
 
   return dist_vec * (DvalueDr / dist);
 }

◆ computeSuperellipsoidInverseValue()

Real SmoothSuperellipsoidBaseIC::computeSuperellipsoidInverseValue	(	const Point &	p,
		const Point &	center,
		Real	a,
		Real	b,
		Real	c,
		Real	n
	)

protectedvirtualinherited

Definition at line 154 of file SmoothSuperellipsoidBaseIC.C.

Referenced by value().

 {
   Point l_center = center;
   Point l_p = p;
   // Compute the distance between the current point and the center
   Real dist = _mesh.minPeriodicDistance(_var.number(), l_p, l_center);
 
   // When dist is 0 we are exactly at the center of the superellipsoid so return _invalue
   // Handle this case independently because we cannot calculate polar angles at this point
   if (dist == 0.0)
     return _nestedvalue;
 
   // Compute the distance r from the center of the superellipsoid to its outside edge
   // along the vector from the center to the current point
   // This uses the equation for a superellipse in polar coordinates and substitutes
   // distances for sin, cos functions
   Point dist_vec = _mesh.minPeriodicVector(_var.number(), center, p);
 
   // First calculate rmn = r^(-n), replacing sin, cos functions with distances
   Real rmn = (std::pow(std::abs(dist_vec(0) / dist / a), n) +
               std::pow(std::abs(dist_vec(1) / dist / b), n) +
               std::pow(std::abs(dist_vec(2) / dist / c), n));
   // Then calculate r from rmn
   Real r = std::pow(rmn, (-1.0 / n));
 
   Real value = _invalue;
 
   if (dist <= r - _int_width / 2.0) // Reversing inside and outside values
     value = _nestedvalue;
   else if (dist < r + _int_width / 2.0) // Smooth interface
   {
     Real int_pos = (dist - r + _int_width / 2.0) / _int_width;
     value = _invalue + (_nestedvalue - _invalue) * (1.0 + std::cos(int_pos * libMesh::pi)) / 2.0;
   }
 
   return value;
 }

◆ computeSuperellipsoidSemiaxes()

void BimodalSuperellipsoidsIC::computeSuperellipsoidSemiaxes ( )

protectedvirtualinherited

Reimplemented from SpecifiedSmoothSuperellipsoidIC.

Definition at line 87 of file BimodalSuperellipsoidsIC.C.

 {
   _as.resize(_input_as.size() + _npart);
   _bs.resize(_input_bs.size() + _npart);
   _cs.resize(_input_cs.size() + _npart);
 
   // First fill in the specified (large) superellipsoids from the input file
   for (unsigned int i = 0; i < _input_as.size(); ++i)
   {
     _as[i] = _input_as[i];
     _bs[i] = _input_bs[i];
     _cs[i] = _input_cs[i];
   }
 
   // Then fill in the randomly positioned (small) superellipsoids
   for (unsigned int i = _input_as.size(); i < _input_as.size() + _npart; ++i)
   {
     // Vary semiaxes
     switch (_size_variation_type)
     {
       case 0: // Random distrubtion, maintaining constant shape
       {
         Real rand_num = _random.rand(_tid);
         _as[i] = _small_a * (1.0 + (1.0 - 2.0 * rand_num) * _size_variation);
         _bs[i] = _small_b * (1.0 + (1.0 - 2.0 * rand_num) * _size_variation);
         _cs[i] = _small_c * (1.0 + (1.0 - 2.0 * rand_num) * _size_variation);
         break;
       }
       case 1: // Normal distribution of semiaxis size, maintaining constant shape
         _as[i] = _random.randNormal(_tid, _small_a, _size_variation);
         _bs[i] = _as[i] * _small_b / _small_a;
         _cs[i] = _as[i] * _small_c / _small_a;
         break;
       case 2: // No variation
         _as[i] = _small_a;
         _bs[i] = _small_b;
         _cs[i] = _small_c;
     }
 
     if (_as[i] < 0.0)
       _as[i] = 0.0;
     if (_bs[i] < 0.0)
       _bs[i] = 0.0;
     if (_cs[i] < 0.0)
       _cs[i] = 0.0;
   }
 }

◆ computeSuperellipsoidValue()

Real SmoothSuperellipsoidBaseIC::computeSuperellipsoidValue	(	const Point &	p,
		const Point &	center,
		Real	a,
		Real	b,
		Real	c,
		Real	n
	)

protectedvirtualinherited

Definition at line 113 of file SmoothSuperellipsoidBaseIC.C.

Referenced by SmoothSuperellipsoidBaseIC::gradient(), SmoothSuperellipsoidBaseIC::value(), and value().

 {
   Point l_center = center;
   Point l_p = p;
   // Compute the distance between the current point and the center
   Real dist = _mesh.minPeriodicDistance(_var.number(), l_p, l_center);
 
   // When dist is 0 we are exactly at the center of the superellipsoid so return _invalue
   // Handle this case independently because we cannot calculate polar angles at this point
   if (dist == 0.0)
     return _invalue;
 
   // Compute the distance r from the center of the superellipsoid to its outside edge
   // along the vector from the center to the current point
   // This uses the equation for a superellipse in polar coordinates and substitutes
   // distances for sin, cos functions
   Point dist_vec = _mesh.minPeriodicVector(_var.number(), center, p);
 
   // First calculate rmn = r^(-n), replacing sin, cos functions with distances
   Real rmn = (std::pow(std::abs(dist_vec(0) / dist / a), n) +
               std::pow(std::abs(dist_vec(1) / dist / b), n) +
               std::pow(std::abs(dist_vec(2) / dist / c), n));
   // Then calculate r from rmn
   Real r = std::pow(rmn, (-1.0 / n));
 
   Real value = _outvalue; // Outside superellipsoid
 
   if (dist <= r - _int_width / 2.0) // Inside superellipsoid
     value = _invalue;
   else if (dist < r + _int_width / 2.0) // Smooth interface
   {
     Real int_pos = (dist - r + _int_width / 2.0) / _int_width;
     value = _outvalue + (_invalue - _outvalue) * (1.0 + std::cos(int_pos * libMesh::pi)) / 2.0;
   }
 
   return value;
 }

◆ gradient()

RealGradient SmoothSuperellipsoidBaseIC::gradient ( const Point & p )

virtualinherited

Reimplemented from InitialConditionTempl< class >.

Definition at line 88 of file SmoothSuperellipsoidBaseIC.C.

 {
   if (_zero_gradient)
     return 0.0;
 
   RealGradient gradient = 0.0;
   Real value = _outvalue;
   Real val2 = 0.0;
 
   for (unsigned int ellip = 0; ellip < _centers.size(); ++ellip)
   {
     val2 = computeSuperellipsoidValue(
         p, _centers[ellip], _as[ellip], _bs[ellip], _cs[ellip], _ns[ellip]);
     if ((val2 > value && _invalue > _outvalue) || (val2 < value && _outvalue > _invalue))
     {
       value = val2;
       gradient = computeSuperellipsoidGradient(
           p, _centers[ellip], _as[ellip], _bs[ellip], _cs[ellip], _ns[ellip]);
     }
   }
 
   return gradient;
 }

◆ initialSetup()

void BimodalInverseSuperellipsoidsIC::initialSetup ( )

virtual

Reimplemented from BimodalSuperellipsoidsIC.

Definition at line 34 of file BimodalInverseSuperellipsoidsIC.C.

 {
   if (_size_variation_type == 2 && _size_variation > 0.0)
     paramError("size_variation",
                "If size_variation > 0.0, you must pass in a size_variation_type in "
                "BimodalInverseSuperellipsoidsIC");
 
   BimodalSuperellipsoidsIC::initialSetup();
 }

◆ validParams()

InputParameters BimodalInverseSuperellipsoidsIC::validParams ( )

static

Definition at line 19 of file BimodalInverseSuperellipsoidsIC.C.

 {
   InputParameters params = BimodalSuperellipsoidsIC::validParams();
   params.addClassDescription("Bimodal size distribution of large particles (specified in input "
                              "file, value invalue) and small particles (placed randomly inside the "
                              "larger particles, value outvalue)");
   return params;
 }

◆ value()

Real BimodalInverseSuperellipsoidsIC::value ( const Point & p )

virtual

Have to do things slightly different from SmoothSuperellipsoidBaseIC because of the inverse structure.

Reimplemented from SmoothSuperellipsoidBaseIC.

Definition at line 45 of file BimodalInverseSuperellipsoidsIC.C.

 {
   Real value = _outvalue;
   Real val2 = 0.0;
 
   // First loop over the specified superellipsoids
   for (unsigned int ellip = 0; ellip < _x_positions.size() && value != _invalue; ++ellip)
   {
     val2 = computeSuperellipsoidValue(
         p, _centers[ellip], _as[ellip], _bs[ellip], _cs[ellip], _ns[ellip]);
     if ((val2 > value && _invalue > _outvalue) || (val2 < value && _outvalue > _invalue))
       value = val2;
   }
 
   // Then loop over the randomly positioned particles and set value inside them back to outvalue
   for (unsigned int ellip = _x_positions.size(); ellip < _x_positions.size() + _npart; ++ellip)
   {
     val2 = computeSuperellipsoidInverseValue(
         p, _centers[ellip], _as[ellip], _bs[ellip], _cs[ellip], _ns[ellip]);
     if ((val2 < value && _invalue > _outvalue) || (val2 > value && _outvalue > _invalue))
       value = val2;
   }
 
   return value;
 }