Class that controls the time-dependent (but not space-dependent) geochemistry reactions. More...

#include <GeochemistryTimeDependentReactor.h>

Inheritance diagram for GeochemistryTimeDependentReactor:

Public Types
enum	TEST_TYPE

typedef DataFileName	DataFileParameterType

Public Member Functions
	GeochemistryTimeDependentReactor (const InputParameters &parameters)

virtual void	initialize () override

virtual void	finalize () override

virtual void	initialSetup () override

virtual void	execute () override

virtual const GeochemicalSystem &	getGeochemicalSystem (dof_id_type node_id) const override

virtual const std::stringstream &	getSolverOutput (dof_id_type node_id) const override

virtual unsigned	getSolverIterations (dof_id_type node_id) const override

virtual Real	getSolverResidual (dof_id_type node_id) const override

virtual const DenseVector< Real > &	getMoleAdditions (dof_id_type node_id) const override

virtual Real	getMolesDumped (dof_id_type node_id, const std::string &species) const override

virtual void	threadJoin (const UserObject &) override

const PertinentGeochemicalSystem &	getPertinentGeochemicalSystem () const
	returns a reference to the PertinentGeochemicalSystem used to creat the ModelGeochemicalDatabase More...

virtual void	subdomainSetup () override

bool	isUniqueNodeExecute ()

SubProblem &	getSubProblem () const

bool	shouldDuplicateInitialExecution () const

virtual Real	spatialValue (const Point &) const

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

void	gatherSum (T &value)

void	gatherMax (T &value)

void	gatherMin (T &value)

void	gatherProxyValueMax (T1 &proxy, T2 &value)

void	gatherProxyValueMin (T1 &proxy, T2 &value)

void	setPrimaryThreadCopy (UserObject *primary)

UserObject *	primaryThreadCopy ()

std::set< UserObjectName >	getDependObjects () const

virtual bool	needThreadedCopy () const

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

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

unsigned int	systemNumber () const

virtual bool	enabled () const

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 *	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 &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 &relative_path) const

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

virtual void	timestepSetup ()

virtual void	jacobianSetup ()

virtual void	residualSetup ()

virtual void	customSetup (const ExecFlagType &)

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

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

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

virtual const ArrayVariableValue &	coupledArrayValueByName (const std::string &var_name)

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 ADVectorVariableCurl &	getADDefaultCurl () const

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

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

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

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

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

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

void	addMooseVariableDependency (MooseVariableFieldBase *var)

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

bool	isImplicit ()

Moose::StateArg	determineState () const

void	setRandomResetFrequency (ExecFlagType exec_flag)

unsigned long	getRandomLong () const

Real	getRandomReal () const

unsigned int	getSeed (std::size_t id)

unsigned int	getMasterSeed () const

bool	isNodal () const

ExecFlagType	getResetOnTime () const

void	setRandomDataPointer (RandomData *random_data)

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

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

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 Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	sharedParams ()
	params that are shared with AddTimeDependentReactionSolverAction More...

static InputParameters	validParams ()

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)

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

Public Attributes
	ALL

	ANY

const ConsoleStream	_console

Static Public Attributes
static constexpr auto	SYSTEM

static constexpr auto	NAME

Protected Member Functions
Real	newTemperature (const DenseVector< Real > &mole_additions) const
	Based on _temperature[0], mole_additions, the current mass of the system and the current temperature of the system, work out the resulting temperature. More...

void	preSolveDump ()
	Activate the special "dump" mode prior to solving the geochemical system: More...

void	preSolveFlush ()
	Activate the special "flush" mode prior to solving the geochemical system: More...

void	postSolveFlowThrough ()
	Activate the special "flow-through" mode after solving the geochemical system: More...

void	removeCurrentSpecies ()
	Alter _mole_additions so that it will represent the situation in which all current species are removed and replaced with source_species. More...

void	postSolveExchanger ()
	This is relevant for mode=4 simulations (heat-exchanger simulations). More...

virtual void	addPostprocessorDependencyHelper (const PostprocessorName &name) const override

virtual void	addVectorPostprocessorDependencyHelper (const VectorPostprocessorName &name) const override

virtual void	addUserObjectDependencyHelper (const UserObject &uo) const override

void	addReporterDependencyHelper (const ReporterName &reporter_name) override

const 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

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

void	initializeBlockRestrictable (const MooseObject *moose_object)

Moose::CoordinateSystemType	getBlockCoordSystem ()

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

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

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

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

Static Protected Member Functions
static std::string	meshPropertyName (const std::string &data_name, const std::string &prefix)

Protected Attributes
const VariableValue &	_temperature
	Temperature specified by user. More...

const VariableValue &	_cold_temperature
	Cold temperature specified by user, which is used only when mode==4. More...

const unsigned	_heating_increments
	If mode=4 then temperature is ramped from _cold_temperature to _temperature in heating_increments increments. More...

Real	_new_temperature
	Temperature at which the solution is required. More...

Real	_previous_temperature
	Temperature at which the _egs was last made consistent. More...

GeochemicalSystem	_egs
	The equilibrium geochemical system that holds all the molalities, activities, etc. More...

GeochemicalSolver	_solver
	The solver. More...

const unsigned	_num_kin
	Number of kinetic species. More...

const Real	_close_system_at_time
	Defines the time at which to close the system. More...

bool	_closed_system
	Whether the system has been closed. More...

const std::vector< std::string >	_source_species_names
	Names of the source species. More...

const unsigned	_num_source_species
	Number of source species. More...

const std::vector< const VariableValue * >	_source_species_rates
	Rates of the source species. More...

const std::vector< std::string >	_remove_fixed_activity_name
	Names of species to remove the fixed activity or fugacity constraint from. More...

const std::vector< Real >	_remove_fixed_activity_time
	Times at which to remove the fixed activity or fugacity from the species in _remove_fixed_activity_name. More...

const unsigned	_num_removed_fixed
	Number of elements in the vector _remove_fixed_activity_name;. More...

std::vector< bool >	_removed_fixed_activity
	Whether the activity or activity constraint has been removfed. More...

const std::vector< std::string >	_controlled_activity_species_names
	Names of the species with controlled activity or fugacity. More...

const unsigned	_num_controlled_activity
	Number of species with controlled activity or fugacity. More...

const std::vector< const VariableValue * >	_controlled_activity_species_values
	Activity or fugacity of the species with controlled activity or fugacity. More...

DenseVector< Real >	_mole_additions
	Moles of each basis species added at the current timestep, along with kinetic rates. More...

DenseMatrix< Real >	_dmole_additions
	Derivative of moles_added. More...

const VariableValue &	_mode
	Mode of the system (flush, flow-through, etc) More...

std::unordered_map< std::string, Real >	_minerals_dumped
	Moles of mineral removed by dump and flow-through. More...

const unsigned	_ramp_subsequent
	the ramp_max_ionic_strength to use during time-stepping More...

const unsigned	_num_my_nodes
	Number of nodes handled by this processor (will need to be made un-const when mesh adaptivity is handled) More...

ModelGeochemicalDatabase	_mgd
	my copy of the underlying ModelGeochemicalDatabase More...

const PertinentGeochemicalSystem &	_pgs
	Reference to the original PertinentGeochemicalSystem used to create the ModelGeochemicalDatabase. More...

const unsigned	_num_basis
	number of basis species More...

const unsigned	_num_eqm
	number of equilibrium species More...

const Real	_initial_max_ionic_str
	Initial value of maximum ionic strength. More...

GeochemistryIonicStrength	_is
	The ionic strength calculator. More...

GeochemistryActivityCoefficientsDebyeHuckel	_gac
	The activity calculator. More...

const unsigned	_max_swaps_allowed
	Maximum number of swaps allowed during a single solve. More...

GeochemistrySpeciesSwapper	_swapper
	The species swapper. More...

const Real	_small_molality
	A small value of molality. More...

std::vector< std::stringstream >	_solver_output
	The solver output at each node. More...

std::vector< unsigned >	_tot_iter
	Number of iterations used by the solver at each node. More...

std::vector< Real >	_abs_residual
	L1norm of the solver residual at each node. More...

MooseMesh &	_mesh

const unsigned int	_qp

const Node *const &	_current_node

const bool &	_unique_node_execute

SubProblem &	_subproblem

FEProblemBase &	_fe_problem

SystemBase &	_sys

const THREAD_ID	_tid

Assembly &	_assembly

const Moose::CoordinateSystemType &	_coord_sys

const bool	_duplicate_initial_execution

std::set< std::string >	_depend_uo

const bool &	_enabled

MooseApp &	_app

const std::string	_type

const std::string	_name

const InputParameters &	_pars

Factory &	_factory

ActionFactory &	_action_factory

const ExecFlagEnum &	_execute_enum

const ExecFlagType &	_current_execute_flag

MooseApp &	_restartable_app

const std::string	_restartable_system_name

const THREAD_ID	_restartable_tid

const bool	_restartable_read_only

FEProblemBase &	_mci_feproblem

FEProblemBase &	_mdi_feproblem

MooseApp &	_pg_moose_app

const std::string	_prefix

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

FEProblemBase &	_sc_fe_problem

const THREAD_ID	_sc_tid

const Real &	_real_zero

const VariableValue &	_scalar_zero

const Point &	_point_zero

const InputParameters &	_ti_params

FEProblemBase &	_ti_feproblem

bool	_is_implicit

Real &	_t

const Real &	_t_old

int &	_t_step

Real &	_dt

Real &	_dt_old

bool	_is_transient

const Parallel::Communicator &	_communicator

Detailed Description

Class that controls the time-dependent (but not space-dependent) geochemistry reactions.

Definition at line 18 of file GeochemistryTimeDependentReactor.h.

Constructor & Destructor Documentation

◆ GeochemistryTimeDependentReactor()

GeochemistryTimeDependentReactor::GeochemistryTimeDependentReactor ( const InputParameters & parameters )

Definition at line 139 of file GeochemistryTimeDependentReactor.C.

   : GeochemistryReactorBase(parameters),
     _temperature(coupledValue("temperature")),
     _cold_temperature(coupledValue("cold_temperature")),
     _heating_increments(getParam<unsigned>("heating_increments")),
     _new_temperature(getParam<Real>("initial_temperature")),
     _previous_temperature(getParam<Real>("initial_temperature")),
     _egs(_mgd,
          _gac,
          _is,
          _swapper,
          getParam<std::vector<std::string>>("swap_out_of_basis"),
          getParam<std::vector<std::string>>("swap_into_basis"),
          getParam<std::string>("charge_balance_species"),
          getParam<std::vector<std::string>>("constraint_species"),
          getParam<std::vector<Real>>("constraint_value"),
          getParam<MultiMooseEnum>("constraint_unit"),
          getParam<MultiMooseEnum>("constraint_meaning"),
          _previous_temperature,
          getParam<unsigned>("extra_iterations_to_make_consistent"),
          getParam<Real>("min_initial_molality"),
          getParam<std::vector<std::string>>("kinetic_species_name"),
          getParam<std::vector<Real>>("kinetic_species_initial_value"),
          getParam<MultiMooseEnum>("kinetic_species_unit")),
     _solver(_mgd.basis_species_name.size(),
             _mgd.kin_species_name.size(),
             _is,
             getParam<Real>("abs_tol"),
             getParam<Real>("rel_tol"),
             getParam<unsigned>("max_iter"),
             getParam<Real>("max_initial_residual"),
             _small_molality,
             _max_swaps_allowed,
             getParam<std::vector<std::string>>("prevent_precipitation"),
             getParam<Real>("max_ionic_strength"),
             getParam<unsigned>("ramp_max_ionic_strength_initial"),
             getParam<bool>("evaluate_kinetic_rates_always")),
     _num_kin(_egs.getNumKinetic()),
     _close_system_at_time(getParam<Real>("close_system_at_time")),
     _closed_system(false),
     _source_species_names(getParam<std::vector<std::string>>("source_species_names")),
     _num_source_species(_source_species_names.size()),
     _source_species_rates(coupledValues("source_species_rates")),
     _remove_fixed_activity_name(getParam<std::vector<std::string>>("remove_fixed_activity_name")),
     _remove_fixed_activity_time(getParam<std::vector<Real>>("remove_fixed_activity_time")),
     _num_removed_fixed(_remove_fixed_activity_name.size()),
     _removed_fixed_activity(_num_removed_fixed, false),
     _controlled_activity_species_names(
         getParam<std::vector<std::string>>("controlled_activity_name")),
     _num_controlled_activity(_controlled_activity_species_names.size()),
     _controlled_activity_species_values(coupledValues("controlled_activity_value")),
     _mole_additions(_num_basis + _num_kin),
     _dmole_additions(_num_basis + _num_kin, _num_basis + _num_kin),
     _mode(coupledValue("mode")),
     _minerals_dumped(),
     _ramp_subsequent(getParam<unsigned>("ramp_max_ionic_strength_subsequent"))
 {
   // check sources and set the rates
   if (coupledComponents("source_species_rates") != _num_source_species)
     paramError("source_species_names", "must have the same size as source_species_rates");
   for (unsigned i = 0; i < _num_source_species; ++i)
     if (!(_mgd.basis_species_index.count(_source_species_names[i]) == 1 ||
           _mgd.eqm_species_index.count(_source_species_names[i]) == 1 ||
           _mgd.kin_species_index.count(_source_species_names[i]) == 1))
       paramError("source_species_names",
                  "The name " + _source_species_names[i] +
                      " does not appear in the basis, equilibrium or kinetic species list");
 
   // check and set activity controllers
   for (unsigned i = 0; i < _num_removed_fixed; ++i)
   {
     if (_mgd.basis_species_index.count(_remove_fixed_activity_name[i]) == 0)
       paramError(
           "remove_fixed_activity_name",
           "The species ",
           _remove_fixed_activity_name[i],
           " is not in the basis, so cannot have its activity or fugacity constraint removed");
     else
     {
       const unsigned basis_ind = _mgd.basis_species_index.at(_remove_fixed_activity_name[i]);
       const GeochemicalSystem::ConstraintMeaningEnum cm = _egs.getConstraintMeaning()[basis_ind];
       if (!(cm == GeochemicalSystem::ConstraintMeaningEnum::ACTIVITY ||
             cm == GeochemicalSystem::ConstraintMeaningEnum::FUGACITY))
         paramError("remove_fixed_activity_name",
                    "The species ",
                    _remove_fixed_activity_name[i],
                    " is does not have an activity or fugacity constraint so cannot have such a "
                    "constraint removed");
     }
   }
   if (_num_removed_fixed != _remove_fixed_activity_time.size())
     paramError("remove_fixed_activity_name",
                "must be of the same size as remove_fixed_activity_time");
   if (coupledComponents("controlled_activity_value") != _num_controlled_activity)
     paramError("controlled_activity_name", "must have the same size as controlled_activity_value");
 
   // record coupled variables
   const std::vector<MooseVariableFEBase *> & coupled_vars = getCoupledMooseVars();
   for (unsigned int i = 0; i < coupled_vars.size(); i++)
     addMooseVariableDependency(coupled_vars[i]);
 
   // setup minerals_dumped
   for (unsigned i = 0; i < _mgd.basis_species_name.size(); ++i)
     if (_mgd.basis_species_mineral[i])
       _minerals_dumped[_mgd.basis_species_name[i]] = 0.0;
   for (unsigned j = 0; j < _mgd.eqm_species_name.size(); ++j)
     if (_mgd.eqm_species_mineral[j])
       _minerals_dumped[_mgd.eqm_species_name[j]] = 0.0;
   for (unsigned k = 0; k < _mgd.kin_species_name.size(); ++k)
     if (_mgd.kin_species_mineral[k])
       _minerals_dumped[_mgd.kin_species_name[k]] = 0.0;
 }

Member Function Documentation

◆ execute()

void GeochemistryTimeDependentReactor::execute ( )

overridevirtual

Reimplemented from GeochemistryReactorBase.

Definition at line 282 of file GeochemistryTimeDependentReactor.C.

 {
   if (_current_node->id() != 0)
     return;
 
   _solver.setRampMaxIonicStrength(_ramp_subsequent);
 
   _mole_additions.zero();
   _dmole_additions.zero();
 
   // remove appropriate constraints
   if (!_closed_system && _t >= _close_system_at_time)
   {
     _egs.closeSystem();
     _closed_system = true;
   }
   for (unsigned i = 0; i < _num_removed_fixed; ++i)
   {
     if (!_removed_fixed_activity[i] && _t >= _remove_fixed_activity_time[i])
     {
       if (_mgd.basis_species_index.count(_remove_fixed_activity_name[i]))
         _egs.changeConstraintToBulk(_mgd.basis_species_index.at(_remove_fixed_activity_name[i]));
       _removed_fixed_activity[i] = true;
     }
   }
 
   // control activity
   for (unsigned ca = 0; ca < _num_controlled_activity; ++ca)
   {
     const std::vector<GeochemicalSystem::ConstraintMeaningEnum> & cm = _egs.getConstraintMeaning();
     if (_mgd.basis_species_index.count(_controlled_activity_species_names[ca]))
     {
       const unsigned basis_ind =
           _mgd.basis_species_index.at(_controlled_activity_species_names[ca]);
       if (cm[basis_ind] == GeochemicalSystem::ConstraintMeaningEnum::ACTIVITY ||
           cm[basis_ind] == GeochemicalSystem::ConstraintMeaningEnum::FUGACITY)
         _egs.setConstraintValue(basis_ind, (*_controlled_activity_species_values[ca])[0]);
     }
   }
 
   // compute moles added
   for (unsigned i = 0; i < _num_source_species; ++i)
   {
     const Real this_rate = (*_source_species_rates[i])[0];
     if (_mgd.basis_species_index.count(_source_species_names[i]))
     {
       const unsigned basis_ind = _mgd.basis_species_index.at(_source_species_names[i]);
       _mole_additions(basis_ind) += this_rate;
     }
     else if (_mgd.eqm_species_index.count(_source_species_names[i]))
     {
       const unsigned eqm_j = _mgd.eqm_species_index.at(_source_species_names[i]);
       for (unsigned basis_ind = 0; basis_ind < _num_basis; ++basis_ind)
         _mole_additions(basis_ind) += _mgd.eqm_stoichiometry(eqm_j, basis_ind) * this_rate;
     }
     else
     {
       const unsigned kin_ind = _mgd.kin_species_index.at(_source_species_names[i]);
       _mole_additions(_num_basis + kin_ind) += this_rate;
     }
   }
   for (unsigned i = 0; i < _num_basis + _num_kin; ++i)
     _mole_additions(i) *= _dt;
 
   // activate special modes
   if (_mode[0] == 1.0)
     preSolveDump();
   else if (_mode[0] == 3.0)
     preSolveFlush();
   else if (_mode[0] == 4.0)
   {
     removeCurrentSpecies();
     _new_temperature = _cold_temperature[0];
   }
   else // nothing special: simply compute the desired temperature
     _new_temperature = newTemperature(_mole_additions);
 
   // set temperature, if necessary
   if (_new_temperature != _previous_temperature)
   {
     _egs.setTemperature(_new_temperature);
     _egs.computeConsistentConfiguration();
   }
   _previous_temperature = _new_temperature;
 
   // solve the geochemical system
   _solver.solveSystem(_egs,
                       _solver_output[0],
                       _tot_iter[0],
                       _abs_residual[0],
                       _dt,
                       _mole_additions,
                       _dmole_additions);
 
   // activate special modes
   if (_mode[0] == 2.0)
     postSolveFlowThrough();
   else if (_mode[0] == 4.0)
     postSolveExchanger();
 }

◆ finalize()

void GeochemistryTimeDependentReactor::finalize ( )

overridevirtual

Reimplemented from GeochemistryReactorBase.

Definition at line 259 of file GeochemistryTimeDependentReactor.C.

 {
   GeochemistryReactorBase::finalize();
 }

◆ getGeochemicalSystem()

const GeochemicalSystem & GeochemistryTimeDependentReactor::getGeochemicalSystem ( dof_id_type node_id ) const

overridevirtual

Returns: a reference to the equilibrium geochemical system at the given node

Parameters

node_id the ID of the node

Implements GeochemistryReactorBase.

Definition at line 384 of file GeochemistryTimeDependentReactor.C.

 {
   return _egs;
 }

◆ getMoleAdditions()

const DenseVector< Real > & GeochemistryTimeDependentReactor::getMoleAdditions ( dof_id_type node_id ) const

overridevirtual

Returns: the mole additions (the first num_basis of these are additions to the bulk composition of the equilibrium system, the last num_kin of these are -dt*kinetic_reaction_rate, ie dt*dissolution_rate) at the specified node_id

Parameters

node_id the node ID

Implements GeochemistryReactorBase.

Definition at line 390 of file GeochemistryTimeDependentReactor.C.

 {
   return _mole_additions;
 }

◆ getMolesDumped()

Real GeochemistryTimeDependentReactor::getMolesDumped	(	dof_id_type	node_id,
		const std::string &	species
	)		const

overridevirtual

Returns: the moles dumped of the given species at the specified node_id

Parameters

species	the name of the species
node_id	the node ID

Implements GeochemistryReactorBase.

Definition at line 412 of file GeochemistryTimeDependentReactor.C.

 {
   if (_minerals_dumped.count(species) == 1)
     return _minerals_dumped.at(species);
   return 0.0;
 }

◆ getPertinentGeochemicalSystem()

const PertinentGeochemicalSystem& GeochemistryReactorBase::getPertinentGeochemicalSystem ( ) const

inlineinherited

returns a reference to the PertinentGeochemicalSystem used to creat the ModelGeochemicalDatabase

Definition at line 73 of file GeochemistryReactorBase.h.

Referenced by GeochemistryQuantityAux::computeValue(), GeochemistryQuantityAux::GeochemistryQuantityAux(), and GeochemistryConsoleOutput::output().

73 { return _pgs; };

GeochemistryReactorBase::_pgs

const PertinentGeochemicalSystem & _pgs

Reference to the original PertinentGeochemicalSystem used to create the ModelGeochemicalDatabase.

Definition: GeochemistryReactorBase.h:81

◆ getSolverIterations()

unsigned GeochemistryTimeDependentReactor::getSolverIterations ( dof_id_type node_id ) const

overridevirtual

Returns: the total number of iterations used by the most recent solve at the specified node_id

Parameters

node_id the node ID

Implements GeochemistryReactorBase.

Definition at line 401 of file GeochemistryTimeDependentReactor.C.

 {
   return _tot_iter[0];
 }

◆ getSolverOutput()

const std::stringstream & GeochemistryTimeDependentReactor::getSolverOutput ( dof_id_type node_id ) const

overridevirtual

Returns: a reference to the most recent solver output (containing iteration info, swap info, residuals, etc) at the specified node_id

Parameters

node_id the node ID

Implements GeochemistryReactorBase.

Definition at line 396 of file GeochemistryTimeDependentReactor.C.

 {
   return _solver_output[0];
 }

◆ getSolverResidual()

Real GeochemistryTimeDependentReactor::getSolverResidual ( dof_id_type node_id ) const

overridevirtual

Returns: the L1norm of the residual at the end of the most recent solve at the specified node_id

Parameters

node_id the node ID

Implements GeochemistryReactorBase.

Definition at line 406 of file GeochemistryTimeDependentReactor.C.

 {
   return _abs_residual[0];
 }

◆ initialize()

void GeochemistryTimeDependentReactor::initialize ( )

overridevirtual

Reimplemented from GeochemistryReactorBase.

Definition at line 254 of file GeochemistryTimeDependentReactor.C.

 {
   GeochemistryReactorBase::initialize();
 }

◆ initialSetup()

void GeochemistryTimeDependentReactor::initialSetup ( )

overridevirtual

Reimplemented from NodalUserObject.

Definition at line 265 of file GeochemistryTimeDependentReactor.C.

 {
   // solve the geochemical system with its initial composition and with dt=0 so no kinetic additions
   if (_num_my_nodes == 0)
     return; // rather peculiar case where user has used many processors
   _mole_additions.zero();
   _dmole_additions.zero();
   _solver.solveSystem(_egs,
                       _solver_output[0],
                       _tot_iter[0],
                       _abs_residual[0],
                       0.0,
                       _mole_additions,
                       _dmole_additions);
 }

◆ newTemperature()

Real GeochemistryTimeDependentReactor::newTemperature ( const DenseVector< Real > & mole_additions ) const

protected

Based on _temperature[0], mole_additions, the current mass of the system and the current temperature of the system, work out the resulting temperature.

This is either:

_temperature[0] if no mole_additions are positive (nothing is being added to the system)
a weighted sum of _temperature[0] (the temperature of the reactants being added) and the current system temperature, assuming the heat capacities of the inputs equal the heat capacities of the existing constituents in the system
Parameters

mole_additions Number of moles of each species being added to the system

Definition at line 421 of file GeochemistryTimeDependentReactor.C.

Referenced by execute(), preSolveDump(), and preSolveFlush().

 {
   if (_temperature[0] == _previous_temperature)
     return _temperature[0];
 
   // if no reactants are being added, the system temperature will be _temperature[0]
   bool any_additions = false;
   for (unsigned i = 0; i < _num_basis + _num_kin; ++i)
     if (mole_additions(i) > 0)
     {
       any_additions = true;
       break;
     }
   if (!any_additions)
     return _temperature[0];
 
   // assume heat capacities of inputs and outputs are the same, so final temperature is dictated
   // by masses, also assume that the input happens first, then temperature equilibration, then
   // the outputs occur
   Real new_temperature = _temperature[0];
   const std::vector<Real> & current_bulk = _egs.getBulkMolesOld();
   Real current_kg = current_bulk[0] / GeochemistryConstants::MOLES_PER_KG_WATER;
   Real input_kg = std::max(mole_additions(0), 0.0) / GeochemistryConstants::MOLES_PER_KG_WATER;
   for (unsigned i = 1; i < _num_basis; ++i)
   {
     current_kg += current_bulk[i] * _mgd.basis_species_molecular_weight[i] / 1000.0;
     input_kg += std::max(mole_additions(i), 0.0) * _mgd.basis_species_molecular_weight[i] / 1000.0;
   }
   for (unsigned k = 0; k < _num_kin; ++k)
     input_kg += std::max(mole_additions(k + _num_basis), 0.0) *
                 _mgd.kin_species_molecular_weight[k] / 1000.0;
   new_temperature =
       (_previous_temperature * current_kg + _temperature[0] * input_kg) / (current_kg + input_kg);
   return new_temperature;
 }

◆ postSolveExchanger()

void GeochemistryTimeDependentReactor::postSolveExchanger ( )

protected

This is relevant for mode=4 simulations (heat-exchanger simulations).

Any precipitates are removed from the system, the system is then heated to temperature and re-solved, and any precipitates are removed from the system

Definition at line 602 of file GeochemistryTimeDependentReactor.C.

Referenced by execute().

 {
   // remove precipitates
   postSolveFlowThrough();
 
   DenseVector<Real> zero_mole_additions(_num_basis + _num_kin);
   DenseMatrix<Real> zero_dmole_additions(_num_basis + _num_kin, _num_basis + _num_kin);
 
   const Real del_temperature = (_temperature[0] - _previous_temperature) / _heating_increments;
 
   for (unsigned incr = 0; incr < _heating_increments; ++incr)
   {
     // set temperature
     _new_temperature = _previous_temperature + del_temperature;
     _egs.setTemperature(_new_temperature);
     _egs.computeConsistentConfiguration();
     _previous_temperature = _new_temperature;
 
     zero_mole_additions.zero();
     zero_dmole_additions.zero();
 
     // solve the geochemical system
     _solver.solveSystem(_egs,
                         _solver_output[0],
                         _tot_iter[0],
                         _abs_residual[0],
                         _dt,
                         zero_mole_additions,
                         zero_dmole_additions);
 
     // remove precipitates
     postSolveFlowThrough();
   }
 }

◆ postSolveFlowThrough()

void GeochemistryTimeDependentReactor::postSolveFlowThrough ( )

protected

Activate the special "flow-through" mode after solving the geochemical system:

precipitated minerals are removed by setting the free mole number of minerals (basis and kinetic) is set to a small number
_minerals_dumped is updated accordingly

Definition at line 558 of file GeochemistryTimeDependentReactor.C.

Referenced by execute(), and postSolveExchanger().

 {
   // copy the current_molal values into a new vector
   const std::vector<Real> current_molal = _egs.getSolventMassAndFreeMolalityAndMineralMoles();
   // remove minerals
   for (unsigned i = 1; i < _num_basis; ++i)
     if (_mgd.basis_species_mineral[i])
     {
       const Real to_remove = current_molal[i] - _small_molality * 10.0;
       _egs.addToBulkMoles(i, -to_remove);
       _minerals_dumped[_mgd.basis_species_name[i]] += to_remove;
     }
 
   // copy the current kinetic moles into a new vector
   const std::vector<Real> kin_moles = _egs.getKineticMoles();
   // remove minerals
   for (unsigned k = 0; k < _num_kin; ++k)
     if (_mgd.kin_species_mineral[k])
     {
       const Real to_remove = kin_moles[k] - _small_molality;
       for (unsigned i = 0; i < _num_basis; ++i)
         if (_mgd.kin_stoichiometry(k, i) != 0)
           _egs.addToBulkMoles(i,
                               -_mgd.kin_stoichiometry(k, i) *
                                   to_remove); // remember bulk moles contains kinetic contributions
       _egs.setKineticMoles(k, _small_molality);
       _minerals_dumped[_mgd.kin_species_name[k]] += to_remove;
     }
 
   _egs.setMineralRelatedFreeMoles(_small_molality * 10.0);
 }

◆ preSolveDump()

void GeochemistryTimeDependentReactor::preSolveDump ( )

protected

Activate the special "dump" mode prior to solving the geochemical system:

_mole_additions for basis mineral moles are set to the free mineral mole numbers (potentially overwriting a user's choice)
_minerals_dumped is updated
the new temperature is computed
the free mineral moles and bulk mole numbers in the GeochemicalSystem are updated accordingly, and _mole_additions is zero
all minerals are swapped out of the basis

Definition at line 458 of file GeochemistryTimeDependentReactor.C.

Referenced by execute().

 {
   // remove basis mineral moles
   const std::vector<Real> & current_molal = _egs.getSolventMassAndFreeMolalityAndMineralMoles();
   for (unsigned i = 1; i < _num_basis; ++i)
     if (_mgd.basis_species_mineral[i])
     {
       _mole_additions(i) = -current_molal[i]; // might overwrite the rates set above, which is good
       _minerals_dumped[_mgd.basis_species_name[i]] += current_molal[i];
     }
 
   _new_temperature = newTemperature(_mole_additions);
 
   // add the chemicals immediately instead of during the solve (as occurs for other modes)
   for (unsigned basis_ind = 0; basis_ind < _num_basis; ++basis_ind)
   {
     _egs.addToBulkMoles(basis_ind, _mole_additions(basis_ind));
     _mole_additions(basis_ind) = 0.0;
   }
   // dump needs free mineral moles to be exactly zero and the above addToBulkMoles will have set
   // this for standard minerals, but not things related to sorption or kinetic minerals, so:
   _egs.setMineralRelatedFreeMoles(0.0);
 
   // Now need to swap all minerals out of the basis
   const std::vector<Real> & eqm_molality = _egs.getEquilibriumMolality();
   unsigned swap_into_basis = 0;
   for (unsigned i = 0; i < _num_basis; ++i)
     if (_mgd.basis_species_mineral[i])
     {
       const bool legitimate_swap_found = _egs.getSwapper().findBestEqmSwap(
           i, _mgd, eqm_molality, false, false, false, swap_into_basis);
       if (legitimate_swap_found)
       {
         try
         {
           _egs.performSwap(i, swap_into_basis);
         }
         catch (const MooseException & e)
         {
           mooseError(e.what());
         }
       }
     }
 }

◆ preSolveFlush()

void GeochemistryTimeDependentReactor::preSolveFlush ( )

protected

Activate the special "flush" mode prior to solving the geochemical system:

the new temperature is computed
the total mass of aqueous solution entering the system (ie, without free mineral moles and kinetic-mineral moles) is computed
the current mass of the aqueous solution is computed
_mole_additions is updated by removing species from the current aqueous solution so that the final mass (after _mole_additions has been added) will be the same as the current mass of aqueous solution

Definition at line 504 of file GeochemistryTimeDependentReactor.C.

Referenced by execute().

 {
   _new_temperature = newTemperature(_mole_additions);
 
   // Here we conserve mass, so compute the mass of the solution, without the free mineral moles.
   // We don't include the free mineral moles because users of GeochemistWorkbench will want
   // "flush" to operate like Bethke Eqn(13.14)
   // I assume we also don't include kinetic-mineral moles
   Real kg_in = _mole_additions(0) / GeochemistryConstants::MOLES_PER_KG_WATER;
   for (unsigned i = 1; i < _num_basis; ++i)
     if (!_mgd.basis_species_mineral[i])
       kg_in += _mole_additions(i) * _mgd.basis_species_molecular_weight[i] / 1000.0;
   for (unsigned kin = 0; kin < _num_kin; ++kin)
     if (!_mgd.kin_species_mineral[kin])
       kg_in += _mole_additions(kin + _num_basis) * _mgd.kin_species_molecular_weight[kin] / 1000.0;
 
   const std::vector<Real> & current_bulk = _egs.getBulkMolesOld();
   const std::vector<Real> & current_molal = _egs.getSolventMassAndFreeMolalityAndMineralMoles();
   const std::vector<Real> & kin_moles = _egs.getKineticMoles();
 
   // compute the current mass, without moles from free minerals and without kinetic minerals
   Real current_kg = current_bulk[0] / GeochemistryConstants::MOLES_PER_KG_WATER;
   for (unsigned i = 1; i < _num_basis; ++i)
   {
     Real kinetic_contribution = 0.0;
     for (unsigned k = 0; k < _num_kin; ++k)
       if (_mgd.kin_species_mineral[k])
         kinetic_contribution += kin_moles[k] * _mgd.kin_stoichiometry(k, i);
     if (_mgd.basis_species_mineral[i])
       current_kg += (current_bulk[i] - current_molal[i] - kinetic_contribution) *
                     _mgd.basis_species_molecular_weight[i] / 1000.0;
     else
       current_kg += (current_bulk[i] - kinetic_contribution) *
                     _mgd.basis_species_molecular_weight[i] / 1000.0;
   }
 
   const Real fraction_to_remove = kg_in / current_kg;
   for (unsigned i = 0; i < _num_basis; ++i)
   {
     Real all_kinetic_contribution = 0.0;
     for (unsigned k = 0; k < _num_kin; ++k)
       all_kinetic_contribution += kin_moles[k] * _mgd.kin_stoichiometry(k, i);
     if (_mgd.basis_species_mineral[i])
       _mole_additions(i) -=
           fraction_to_remove * (current_bulk[i] - current_molal[i] - all_kinetic_contribution);
     else
       _mole_additions(i) -= fraction_to_remove * (current_bulk[i] - all_kinetic_contribution);
   }
   for (unsigned k = 0; k < _num_kin; ++k)
     if (!_mgd.kin_species_mineral[k])
       _mole_additions(k + _num_basis) -= fraction_to_remove * kin_moles[k];
 }

◆ removeCurrentSpecies()

void GeochemistryTimeDependentReactor::removeCurrentSpecies ( )

protected

Alter _mole_additions so that it will represent the situation in which all current species are removed and replaced with source_species.

Definition at line 591 of file GeochemistryTimeDependentReactor.C.

Referenced by execute().

 {
   const std::vector<Real> & current_bulk = _egs.getBulkMolesOld();
   for (unsigned i = 0; i < _num_basis; ++i)
     _mole_additions(i) -= current_bulk[i];
   const std::vector<Real> & kin_moles = _egs.getKineticMoles();
   for (unsigned k = 0; k < _num_kin; ++k)
     _mole_additions(k + _num_basis) -= kin_moles[k];
 }

◆ sharedParams()

InputParameters GeochemistryTimeDependentReactor::sharedParams ( )

static

params that are shared with AddTimeDependentReactionSolverAction

Definition at line 15 of file GeochemistryTimeDependentReactor.C.

Referenced by AddTimeDependentReactionSolverAction::validParams(), and validParams().

 {
   InputParameters params = emptyInputParameters();
   params.addParam<unsigned>(
       "ramp_max_ionic_strength_subsequent",
       0,
       "The number of iterations over which to progressively increase the maximum ionic strength "
       "(from zero to max_ionic_strength) during time-stepping.  Unless a great deal occurs in each "
       "time step, this parameter can be set quite small");
   params.addCoupledVar(
       "mode",
       0.0,
       "This may vary temporally.  If mode=1 then 'dump' mode is used, which means all non-kinetic "
       "mineral masses are removed from the system before the equilibrium solution is sought (ie, "
       "removal occurs at the beginning of the time step).  If mode=2 then 'flow-through' mode is "
       "used, which means all mineral masses are removed from the system after it the "
       "equilbrium solution has been found (ie, at the end of a time step).  If mode=3 then 'flush' "
       "mode is used, then before the equilibrium solution is sought (ie, at the start of a time "
       "step) water+species is removed from the system at the same rate as pure water + non-mineral "
       "solutes are entering the system (specified in source_species_rates).  If mode=4 then "
       "'heat-exchanger' mode is used, which means the entire current aqueous solution is removed, "
       "then the source_species are added, then the temperature is set to 'cold_temperature', the "
       "system is solved and any precipitated minerals are removed, then the temperature is set to "
       "'temperature', the system re-solved and any precipitated minerals are removed.  If mode is "
       "any other number, no special mode is active (the system simply responds to the "
       "source_species_rates, controlled_activity_value, etc).");
   params.addCoupledVar(
       "temperature",
       25,
       "Temperature.  This has two different meanings if mode!=4.  (1) If no species are being "
       "added to the solution (no source_species_rates are positive) then this is the temperature "
       "of the aqueous solution.  (2) If species are being added, this is the temperature of the "
       "species being added.  In case (2), the final aqueous-solution temperature is computed "
       "assuming the species are added, temperature is equilibrated and then, if species are also "
       "being removed, they are removed.  If you wish to add species and simultaneously alter the "
       "temperature, you will have to use a sequence of heat-add-heat-add, etc steps.  In the case "
       "that mode=4, temperature is the final temperature of the aqueous solution");
   params.addCoupledVar(
       "cold_temperature",
       25,
       "This is only used if mode=4, where it is the cold temperature of the heat exchanger.");
   params.addRangeCheckedParam<unsigned>(
       "heating_increments",
       1,
       "heating_increments > 0",
       "This is only used if mode=4.  Internal to this object, the temperature is ramped from "
       "cold_temperature to temperature in heating_increments increments.  This helps difficult "
       "problems converge");
   params.addParam<Real>("initial_temperature",
                         25.0,
                         "The initial aqueous solution is equilibrated at this system before adding "
                         "reactants, changing temperature, etc.");
   params.addParam<Real>("close_system_at_time",
                         0.0,
                         "Time at which to 'close' the system, that is, change a kg_solvent_water "
                         "constraint to moles_bulk_water, and all free_molality and "
                         "free_moles_mineral_species to moles_bulk_species");
   params.addParam<std::vector<std::string>>(
       "remove_fixed_activity_name",
       {},
       "The name of the species that should have their activity or fugacity constraint removed at "
       "time given in remove_fixed_activity_time.  There should be an equal number of these names "
       "as times given in remove_fixed_activity_time.  Each of these must be in the basis and have "
       "an activity or fugacity constraint");
   params.addParam<std::vector<Real>>("remove_fixed_activity_time",
                                      {},
                                      "The times at which the species in remove_fixed_activity_name "
                                      "should have their activity or fugacity constraint removed.");
   params.addParam<std::vector<std::string>>(
       "source_species_names",
       {},
       "The name of the species that are added at rates given in source_species_rates.  There must "
       "be an equal number of these as source_species_rates.");
   params.addCoupledVar("source_species_rates",
                        "Rates, in mols/time_unit, of addition of the species with names given in "
                        "source_species_names.  A negative value corresponds to removing a species: "
                        "be careful that you don't cause negative mass problems!");
   params.addParam<std::vector<std::string>>(
       "controlled_activity_name",
       {},
       "The names of the species that have their activity or fugacity constrained.  There should be "
       "an equal number of these names as values given in controlled_activity_value.  NOTE: if "
       "these species are not in the basis, or they do not have an activity (or fugacity) "
       "constraint then their activity cannot be controlled: in this case MOOSE will ignore the "
       "value you prescribe in controlled_activity_value.");
   params.addCoupledVar("controlled_activity_value",
                        "Values of the activity or fugacity of the species in "
                        "controlled_activity_name list.  These should always be positive");
   params.addParam<bool>(
       "evaluate_kinetic_rates_always",
       true,
       "If true, then, evaluate the kinetic rates at every Newton step during the solve using the "
       "current values of molality, activity, etc (ie, implement an implicit solve).  If false, "
       "then evaluate the kinetic rates using the values of molality, activity, etc, at the start "
       "of the current time step (ie, implement an explicit solve)");
   params.addParam<std::vector<std::string>>(
       "kinetic_species_name",
       {},
       "Names of the kinetic species given initial values in kinetic_species_initial_value");
   params.addParam<std::vector<Real>>(
       "kinetic_species_initial_value",
       {},
       "Initial number of moles, mass or volume (depending on kinetic_species_unit) for each of the "
       "species named in kinetic_species_name");
   MultiMooseEnum kin_species_unit("dimensionless moles molal kg g mg ug kg_per_kg_solvent "
                                   "g_per_kg_solvent mg_per_kg_solvent ug_per_kg_solvent cm3");
   params.addParam<MultiMooseEnum>(
       "kinetic_species_unit",
       kin_species_unit,
       "Units of the numerical values given in kinetic_species_initial_value.  Moles: mole number.  "
       "kg: kilograms.  g: grams.  mg: milligrams.  ug: micrograms.  cm3: cubic centimeters");
   return params;
 }

◆ threadJoin()

virtual void GeochemistryReactorBase::threadJoin ( const UserObject & )

inlineoverridevirtualinherited

Implements NodalUserObject.

Reimplemented in GeochemistrySpatialReactor.

Definition at line 28 of file GeochemistryReactorBase.h.

28 {}

◆ validParams()

InputParameters GeochemistryTimeDependentReactor::validParams ( )

static

Definition at line 130 of file GeochemistryTimeDependentReactor.C.

 {
   InputParameters params = GeochemistryReactorBase::validParams();
   params += GeochemistryTimeDependentReactor::sharedParams();
   params.addClassDescription("UserObject that controls the time-dependent geochemistry reaction "
                              "processes.  Spatial dependence is not possible using this class");
   return params;
 }

Member Data Documentation

◆ _abs_residual

std::vector<Real> GeochemistryReactorBase::_abs_residual

protectedinherited

L1norm of the solver residual at each node.

Definition at line 103 of file GeochemistryReactorBase.h.

Referenced by execute(), GeochemistrySpatialReactor::execute(), GeochemistryTimeIndependentReactor::getSolverResidual(), getSolverResidual(), GeochemistrySpatialReactor::getSolverResidual(), GeochemistryTimeIndependentReactor::initialSetup(), initialSetup(), GeochemistrySpatialReactor::initialSetup(), postSolveExchanger(), and GeochemistrySpatialReactor::threadJoin().

◆ _close_system_at_time

const Real GeochemistryTimeDependentReactor::_close_system_at_time

protected

Defines the time at which to close the system.

Definition at line 58 of file GeochemistryTimeDependentReactor.h.

Referenced by execute().

◆ _closed_system

bool GeochemistryTimeDependentReactor::_closed_system

protected

Whether the system has been closed.

Definition at line 60 of file GeochemistryTimeDependentReactor.h.

Referenced by execute().

◆ _cold_temperature

const VariableValue& GeochemistryTimeDependentReactor::_cold_temperature

protected

Cold temperature specified by user, which is used only when mode==4.

Definition at line 44 of file GeochemistryTimeDependentReactor.h.

Referenced by execute().

◆ _controlled_activity_species_names

const std::vector<std::string> GeochemistryTimeDependentReactor::_controlled_activity_species_names

protected

Names of the species with controlled activity or fugacity.

Definition at line 76 of file GeochemistryTimeDependentReactor.h.

Referenced by execute().

◆ _controlled_activity_species_values

const std::vector<const VariableValue *> GeochemistryTimeDependentReactor::_controlled_activity_species_values

protected

Activity or fugacity of the species with controlled activity or fugacity.

Definition at line 80 of file GeochemistryTimeDependentReactor.h.

Referenced by execute().

◆ _dmole_additions

DenseMatrix<Real> GeochemistryTimeDependentReactor::_dmole_additions

protected

Derivative of moles_added.

Definition at line 84 of file GeochemistryTimeDependentReactor.h.

Referenced by execute(), and initialSetup().

◆ _egs

GeochemicalSystem GeochemistryTimeDependentReactor::_egs

protected

The equilibrium geochemical system that holds all the molalities, activities, etc.

Definition at line 52 of file GeochemistryTimeDependentReactor.h.

Referenced by execute(), GeochemistryTimeDependentReactor(), getGeochemicalSystem(), initialSetup(), newTemperature(), postSolveExchanger(), postSolveFlowThrough(), preSolveDump(), preSolveFlush(), and removeCurrentSpecies().

◆ _gac

GeochemistryActivityCoefficientsDebyeHuckel GeochemistryReactorBase::_gac

protectedinherited

The activity calculator.

Definition at line 91 of file GeochemistryReactorBase.h.

Referenced by GeochemistrySpatialReactor::GeochemistrySpatialReactor().

◆ _heating_increments

const unsigned GeochemistryTimeDependentReactor::_heating_increments

protected

If mode=4 then temperature is ramped from _cold_temperature to _temperature in heating_increments increments.

Definition at line 46 of file GeochemistryTimeDependentReactor.h.

Referenced by postSolveExchanger().

◆ _initial_max_ionic_str

const Real GeochemistryReactorBase::_initial_max_ionic_str

protectedinherited

Initial value of maximum ionic strength.

Definition at line 87 of file GeochemistryReactorBase.h.

◆ _is

GeochemistryIonicStrength GeochemistryReactorBase::_is

protectedinherited

The ionic strength calculator.

Definition at line 89 of file GeochemistryReactorBase.h.

Referenced by GeochemistrySpatialReactor::GeochemistrySpatialReactor().

◆ _max_swaps_allowed

const unsigned GeochemistryReactorBase::_max_swaps_allowed

protectedinherited

Maximum number of swaps allowed during a single solve.

Definition at line 93 of file GeochemistryReactorBase.h.

◆ _mgd

ModelGeochemicalDatabase GeochemistryReactorBase::_mgd

protectedinherited

my copy of the underlying ModelGeochemicalDatabase

Definition at line 79 of file GeochemistryReactorBase.h.

Referenced by execute(), GeochemistrySpatialReactor::GeochemistrySpatialReactor(), GeochemistryTimeDependentReactor(), newTemperature(), postSolveFlowThrough(), preSolveDump(), and preSolveFlush().

◆ _minerals_dumped

std::unordered_map<std::string, Real> GeochemistryTimeDependentReactor::_minerals_dumped

protected

Moles of mineral removed by dump and flow-through.

Definition at line 88 of file GeochemistryTimeDependentReactor.h.

Referenced by GeochemistryTimeDependentReactor(), getMolesDumped(), postSolveFlowThrough(), and preSolveDump().

◆ _mode

const VariableValue& GeochemistryTimeDependentReactor::_mode

protected

Mode of the system (flush, flow-through, etc)

Definition at line 86 of file GeochemistryTimeDependentReactor.h.

Referenced by execute().

◆ _mole_additions

DenseVector<Real> GeochemistryTimeDependentReactor::_mole_additions

protected

Moles of each basis species added at the current timestep, along with kinetic rates.

Definition at line 82 of file GeochemistryTimeDependentReactor.h.

Referenced by execute(), getMoleAdditions(), initialSetup(), preSolveDump(), preSolveFlush(), and removeCurrentSpecies().

◆ _new_temperature

Real GeochemistryTimeDependentReactor::_new_temperature

protected

Temperature at which the solution is required.

Definition at line 48 of file GeochemistryTimeDependentReactor.h.

Referenced by execute(), postSolveExchanger(), preSolveDump(), and preSolveFlush().

◆ _num_basis

const unsigned GeochemistryReactorBase::_num_basis

protectedinherited

number of basis species

Definition at line 83 of file GeochemistryReactorBase.h.

Referenced by execute(), GeochemistrySpatialReactor::execute(), GeochemistryTimeIndependentReactor::initialSetup(), newTemperature(), postSolveExchanger(), postSolveFlowThrough(), preSolveDump(), preSolveFlush(), and removeCurrentSpecies().

◆ _num_controlled_activity

const unsigned GeochemistryTimeDependentReactor::_num_controlled_activity

protected

Number of species with controlled activity or fugacity.

Definition at line 78 of file GeochemistryTimeDependentReactor.h.

Referenced by execute(), and GeochemistryTimeDependentReactor().

◆ _num_eqm

const unsigned GeochemistryReactorBase::_num_eqm

protectedinherited

number of equilibrium species

Definition at line 85 of file GeochemistryReactorBase.h.

◆ _num_kin

const unsigned GeochemistryTimeDependentReactor::_num_kin

protected

Number of kinetic species.

Definition at line 56 of file GeochemistryTimeDependentReactor.h.

Referenced by execute(), newTemperature(), postSolveExchanger(), postSolveFlowThrough(), preSolveFlush(), and removeCurrentSpecies().

◆ _num_my_nodes

const unsigned GeochemistryReactorBase::_num_my_nodes

protectedinherited

Number of nodes handled by this processor (will need to be made un-const when mesh adaptivity is handled)

Definition at line 73 of file GeochemistryReactorBase.h.

Referenced by GeochemistrySpatialReactor::buildMyNodeNumber(), GeochemistrySpatialReactor::GeochemistrySpatialReactor(), GeochemistrySpatialReactor::initialize(), GeochemistryTimeIndependentReactor::initialSetup(), initialSetup(), GeochemistrySpatialReactor::initialSetup(), and GeochemistrySpatialReactor::threadJoin().

◆ _num_removed_fixed

const unsigned GeochemistryTimeDependentReactor::_num_removed_fixed

protected

Number of elements in the vector _remove_fixed_activity_name;.

Definition at line 72 of file GeochemistryTimeDependentReactor.h.

Referenced by execute(), and GeochemistryTimeDependentReactor().

◆ _num_source_species

const unsigned GeochemistryTimeDependentReactor::_num_source_species

protected

Number of source species.

Definition at line 64 of file GeochemistryTimeDependentReactor.h.

Referenced by execute(), and GeochemistryTimeDependentReactor().

◆ _pgs

const PertinentGeochemicalSystem& GeochemistryReactorBase::_pgs

protectedinherited

Reference to the original PertinentGeochemicalSystem used to create the ModelGeochemicalDatabase.

Definition at line 81 of file GeochemistryReactorBase.h.

Referenced by GeochemistryReactorBase::getPertinentGeochemicalSystem().

◆ _previous_temperature

Real GeochemistryTimeDependentReactor::_previous_temperature

protected

Temperature at which the _egs was last made consistent.

Definition at line 50 of file GeochemistryTimeDependentReactor.h.

Referenced by execute(), newTemperature(), and postSolveExchanger().

◆ _ramp_subsequent

const unsigned GeochemistryTimeDependentReactor::_ramp_subsequent

protected

the ramp_max_ionic_strength to use during time-stepping

Definition at line 90 of file GeochemistryTimeDependentReactor.h.

Referenced by execute().

◆ _remove_fixed_activity_name

const std::vector<std::string> GeochemistryTimeDependentReactor::_remove_fixed_activity_name

protected

Names of species to remove the fixed activity or fugacity constraint from.

Definition at line 68 of file GeochemistryTimeDependentReactor.h.

Referenced by execute(), and GeochemistryTimeDependentReactor().

◆ _remove_fixed_activity_time

const std::vector<Real> GeochemistryTimeDependentReactor::_remove_fixed_activity_time

protected

Times at which to remove the fixed activity or fugacity from the species in _remove_fixed_activity_name.

Definition at line 70 of file GeochemistryTimeDependentReactor.h.

Referenced by execute(), and GeochemistryTimeDependentReactor().

◆ _removed_fixed_activity

std::vector<bool> GeochemistryTimeDependentReactor::_removed_fixed_activity

protected

Whether the activity or activity constraint has been removfed.

Definition at line 74 of file GeochemistryTimeDependentReactor.h.

Referenced by execute().

◆ _small_molality

const Real GeochemistryReactorBase::_small_molality

protectedinherited

A small value of molality.

Definition at line 97 of file GeochemistryReactorBase.h.

Referenced by postSolveFlowThrough().

◆ _solver

GeochemicalSolver GeochemistryTimeDependentReactor::_solver

protected

The solver.

Definition at line 54 of file GeochemistryTimeDependentReactor.h.

Referenced by execute(), initialSetup(), and postSolveExchanger().

◆ _solver_output

std::vector<std::stringstream> GeochemistryReactorBase::_solver_output

protectedinherited

The solver output at each node.

Definition at line 99 of file GeochemistryReactorBase.h.

Referenced by execute(), GeochemistrySpatialReactor::execute(), GeochemistryTimeIndependentReactor::getSolverOutput(), getSolverOutput(), GeochemistrySpatialReactor::getSolverOutput(), GeochemistryTimeIndependentReactor::initialSetup(), initialSetup(), GeochemistrySpatialReactor::initialSetup(), postSolveExchanger(), and GeochemistrySpatialReactor::threadJoin().

◆ _source_species_names

const std::vector<std::string> GeochemistryTimeDependentReactor::_source_species_names

protected

Names of the source species.

Definition at line 62 of file GeochemistryTimeDependentReactor.h.

Referenced by execute(), and GeochemistryTimeDependentReactor().

◆ _source_species_rates

const std::vector<const VariableValue *> GeochemistryTimeDependentReactor::_source_species_rates

protected

Rates of the source species.

Definition at line 66 of file GeochemistryTimeDependentReactor.h.

Referenced by execute().

◆ _swapper

GeochemistrySpeciesSwapper GeochemistryReactorBase::_swapper

protectedinherited

The species swapper.

Definition at line 95 of file GeochemistryReactorBase.h.

Referenced by GeochemistrySpatialReactor::GeochemistrySpatialReactor().

◆ _temperature

const VariableValue& GeochemistryTimeDependentReactor::_temperature

protected

Temperature specified by user.

Definition at line 42 of file GeochemistryTimeDependentReactor.h.

Referenced by newTemperature(), and postSolveExchanger().

◆ _tot_iter

std::vector<unsigned> GeochemistryReactorBase::_tot_iter

protectedinherited

Number of iterations used by the solver at each node.

Definition at line 101 of file GeochemistryReactorBase.h.

Referenced by execute(), GeochemistrySpatialReactor::execute(), GeochemistryTimeIndependentReactor::getSolverIterations(), getSolverIterations(), GeochemistrySpatialReactor::getSolverIterations(), GeochemistryTimeIndependentReactor::initialSetup(), initialSetup(), GeochemistrySpatialReactor::initialSetup(), postSolveExchanger(), and GeochemistrySpatialReactor::threadJoin().

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

geochemistry/include/userobjects/GeochemistryTimeDependentReactor.h
geochemistry/src/userobjects/GeochemistryTimeDependentReactor.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ GeochemistryTimeDependentReactor()

Member Function Documentation

◆ execute()

◆ finalize()

◆ getGeochemicalSystem()

◆ getMoleAdditions()

◆ getMolesDumped()

◆ getPertinentGeochemicalSystem()

◆ getSolverIterations()

◆ getSolverOutput()

◆ getSolverResidual()

◆ initialize()

◆ initialSetup()

◆ newTemperature()

◆ postSolveExchanger()

◆ postSolveFlowThrough()

◆ preSolveDump()

◆ preSolveFlush()

◆ removeCurrentSpecies()

◆ sharedParams()

◆ threadJoin()

◆ validParams()

Member Data Documentation

◆ _abs_residual

◆ _close_system_at_time

◆ _closed_system

◆ _cold_temperature

◆ _controlled_activity_species_names

◆ _controlled_activity_species_values

◆ _dmole_additions

◆ _egs

◆ _gac

◆ _heating_increments

◆ _initial_max_ionic_str

◆ _is

◆ _max_swaps_allowed

◆ _mgd

◆ _minerals_dumped

◆ _mode

◆ _mole_additions

◆ _new_temperature

◆ _num_basis

◆ _num_controlled_activity

◆ _num_eqm

◆ _num_kin

◆ _num_my_nodes

◆ _num_removed_fixed

◆ _num_source_species

◆ _pgs

◆ _previous_temperature

◆ _ramp_subsequent

◆ _remove_fixed_activity_name

◆ _remove_fixed_activity_time

◆ _removed_fixed_activity

◆ _small_molality

◆ _solver

◆ _solver_output

◆ _source_species_names

◆ _source_species_rates

◆ _swapper

◆ _temperature

◆ _tot_iter