Queries and performs simple manipulations on a geochemical model. More...

#include <GeochemicalModelInterrogator.h>

Inheritance diagram for GeochemicalModelInterrogator:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	GeochemicalModelInterrogator (const InputParameters &parameters)

virtual Real	time ()

virtual Real	timeOld ()

virtual Real	dt ()

virtual Real	dtOld ()

virtual int	timeStep ()

const unsigned int &	interval () const

const MultiMooseEnum &	executeOn () const

bool	isAdvanced ()

virtual const OutputOnWarehouse &	advancedExecuteOn () const

void	allowOutput (bool state)

virtual void	outputStep (const ExecFlagType &type)

const std::set< Real > &	getSyncTimes ()

virtual bool	supportsMaterialPropertyOutput () 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	meshChanged ()

virtual void	initialSetup ()

virtual void	timestepSetup ()

virtual void	jacobianSetup ()

virtual void	residualSetup ()

virtual void	subdomainSetup ()

virtual void	customSetup (const ExecFlagType &)

const ExecFlagEnum &	getExecuteOnEnum () 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

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

processor_id_type	n_processors () const

processor_id_type	processor_id () const

UserObjectName	getUserObjectName (const std::string &param_name) const

const T &	getUserObject (const std::string &param_name, bool is_dependency=true) const

const T &	getUserObjectByName (const UserObjectName &object_name, bool is_dependency=true) const

const UserObject &	getUserObjectBase (const std::string &param_name, bool is_dependency=true) const

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

bool	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

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

static InputParameters	validParams ()

static ExecFlagEnum	getDefaultExecFlagEnum ()

static void	addDeprecatedInputParameters (InputParameters &params)

Public Attributes
const ConsoleStream	_console

Protected Types
enum	InterrogationChoiceEnum { InterrogationChoiceEnum::REACTION, InterrogationChoiceEnum::ACTIVITY, InterrogationChoiceEnum::EQM_TEMPERATURE }

Protected Member Functions
virtual void	output () override

virtual void	solveSetup ()

virtual bool	shouldOutput ()

virtual bool	onInterval ()

void	setWallTimeIntervalFromCommandLineParam ()

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

virtual void	addPostprocessorDependencyHelper (const PostprocessorName &) const

virtual void	addVectorPostprocessorDependencyHelper (const VectorPostprocessorName &) const

const ReporterName &	getReporterName (const std::string &param_name) const

virtual void	addReporterDependencyHelper (const ReporterName &)

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

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

virtual void	addUserObjectDependencyHelper (const UserObject &) const

Protected Attributes
ModelGeochemicalDatabase	_mgd

GeochemistrySpeciesSwapper	_swapper

const std::vector< std::string >	_swap_out

const std::vector< std::string >	_swap_in

const unsigned	_precision

enum GeochemicalModelInterrogator::InterrogationChoiceEnum	_interrogation

const Real	_temperature

const std::vector< std::string >	_activity_species

const std::vector< Real >	_activity_values

const std::string	_equilibrium_species

FEProblemBase *	_problem_ptr

bool	_transient

bool	_use_displaced

libMesh::EquationSystems *	_es_ptr

MooseMesh *	_mesh_ptr

bool	_sequence

ExecFlagEnum	_execute_on

ExecFlagType	_current_execute_flag

Real &	_time

Real &	_time_old

int &	_t_step

Real &	_dt

Real &	_dt_old

unsigned int	_num

const bool	_time_step_interval_set_by_addparam

unsigned int	_time_step_interval

const Real	_min_simulation_time_interval

const Real	_simulation_time_interval

Real	_wall_time_interval

std::set< Real >	_sync_times

const Times *const	_sync_times_object

Real	_start_time

Real	_end_time

int	_start_step

int	_end_step

Real	_t_tol

bool	_sync_only

bool	_allow_output

bool	_is_advanced

OutputOnWarehouse	_advanced_execute_on

Real &	_last_output_simulation_time

std::chrono::time_point< std::chrono::steady_clock >	_last_output_wall_time

Real	_wall_time_since_last_output

const bool &	_enabled

MooseApp &	_app

const std::string	_type

const std::string	_name

const InputParameters &	_pars

Factory &	_factory

ActionFactory &	_action_factory

MooseApp &	_restartable_app

const std::string	_restartable_system_name

const THREAD_ID	_restartable_tid

const bool	_restartable_read_only

FEProblemBase &	_mci_feproblem

const ExecFlagEnum &	_execute_enum

MooseApp &	_pg_moose_app

const std::string	_prefix

const Parallel::Communicator &	_communicator

Private Member Functions
std::vector< std::string >	eqmSpeciesOfInterest () const
	provide a list of the equilibrium species of interest to the Interrogator More...

void	outputReaction (const std::string &eqm_species) const
	output nicely-formatted reaction info to console More...

void	outputActivity (const std::string &eqm_species) const
	output activity info to console More...

void	outputTemperature (const std::string &eqm_species) const
	output temperature info to console More...

bool	knownActivity (const std::string &species) const
	return true iff the activity is known for the species (it is a mineral or the user has set the activity) More...

Real	getActivity (const std::string &species) const
	return the activity for the species. Note that knownActivity should be checked before calling getActivity. More...

Real	solveForT (const DenseMatrix< Real > &reference_log10K, Real rhs) const

Detailed Description

Queries and performs simple manipulations on a geochemical model.

Definition at line 20 of file GeochemicalModelInterrogator.h.

Member Enumeration Documentation

◆ InterrogationChoiceEnum

enum GeochemicalModelInterrogator::InterrogationChoiceEnum

strongprotected

Enumerator
REACTION
ACTIVITY
EQM_TEMPERATURE

Definition at line 38 of file GeochemicalModelInterrogator.h.

38 { REACTION, ACTIVITY, EQM_TEMPERATURE } _interrogation;

GeochemicalModelInterrogator::_interrogation

enum GeochemicalModelInterrogator::InterrogationChoiceEnum _interrogation

Constructor & Destructor Documentation

◆ GeochemicalModelInterrogator()

GeochemicalModelInterrogator::GeochemicalModelInterrogator ( const InputParameters & parameters )

Definition at line 91 of file GeochemicalModelInterrogator.C.

   : Output(parameters),
     UserObjectInterface(this),
     _mgd(getUserObject<GeochemicalModelDefinition>("model_definition").getDatabase()),
     _swapper(_mgd.basis_species_index.size(), getParam<Real>("stoichiometry_tolerance")),
     _swap_out(getParam<std::vector<std::string>>("swap_out_of_basis")),
     _swap_in(getParam<std::vector<std::string>>("swap_into_basis")),
     _precision(getParam<unsigned int>("precision")),
     _interrogation(getParam<MooseEnum>("interrogation").getEnum<InterrogationChoiceEnum>()),
     _temperature(getParam<Real>("temperature")),
     _activity_species(getParam<std::vector<std::string>>("activity_species")),
     _activity_values(getParam<std::vector<Real>>("activity_values")),
     _equilibrium_species(getParam<std::string>("equilibrium_species"))
 {
   if (_swap_out.size() != _swap_in.size())
     paramError("swap_out_of_basis must have same length as swap_into_basis");
   if (_activity_species.size() != _activity_values.size())
     paramError("activity_species must have same length as activity_values");
 }

Member Function Documentation

◆ eqmSpeciesOfInterest()

std::vector< std::string > GeochemicalModelInterrogator::eqmSpeciesOfInterest ( ) const

private

provide a list of the equilibrium species of interest to the Interrogator

Definition at line 160 of file GeochemicalModelInterrogator.C.

Referenced by output().

 {
   if (_equilibrium_species == "")
     return _mgd.eqm_species_name;
   else if (_mgd.eqm_species_index.count(_equilibrium_species) == 1)
     return {_equilibrium_species};
   return {};
 }

◆ getActivity()

Real GeochemicalModelInterrogator::getActivity ( const std::string & species ) const

private

return the activity for the species. Note that knownActivity should be checked before calling getActivity.

Definition at line 207 of file GeochemicalModelInterrogator.C.

Referenced by outputActivity(), and outputTemperature().

 {
   unsigned ind = 0;
   for (const auto & sp : _activity_species)
   {
     if (sp == species)
       return _activity_values[ind];
     ind += 1;
   }
   return 1.0; // must be a mineral
 }

◆ knownActivity()

bool GeochemicalModelInterrogator::knownActivity ( const std::string & species ) const

private

return true iff the activity is known for the species (it is a mineral or the user has set the activity)

Definition at line 194 of file GeochemicalModelInterrogator.C.

Referenced by outputActivity(), and outputTemperature().

 {
   for (const auto & sp : _activity_species)
     if (sp == species)
       return true;
   if (_mgd.basis_species_index.count(species))
     return _mgd.basis_species_mineral[_mgd.basis_species_index.at(species)];
   if (_mgd.eqm_species_index.count(species))
     return _mgd.eqm_species_mineral[_mgd.eqm_species_index.at(species)];
   return false;
 }

◆ output()

void GeochemicalModelInterrogator::output ( )

overrideprotectedvirtual

Implements Output.

Definition at line 112 of file GeochemicalModelInterrogator.C.

 {
   for (const auto & sp : eqmSpeciesOfInterest())
   {
     switch (_interrogation)
     {
       case InterrogationChoiceEnum::REACTION:
         outputReaction(sp);
         break;
       case InterrogationChoiceEnum::ACTIVITY:
         outputActivity(sp);
         break;
       case InterrogationChoiceEnum::EQM_TEMPERATURE:
         outputTemperature(sp);
         break;
     }
   }
 
   for (unsigned i = 0; i < _swap_out.size(); ++i)
   {
     // any exception here is an error
     try
     {
       _swapper.performSwap(_mgd, _swap_out[i], _swap_in[i]);
     }
     catch (const MooseException & e)
     {
       mooseError(e.what());
     }
     for (const auto & sp : eqmSpeciesOfInterest())
     {
       switch (_interrogation)
       {
         case InterrogationChoiceEnum::REACTION:
           outputReaction(sp);
           break;
         case InterrogationChoiceEnum::ACTIVITY:
           outputActivity(sp);
           break;
         case InterrogationChoiceEnum::EQM_TEMPERATURE:
           outputTemperature(sp);
           break;
       }
     }
   }
 }

◆ outputActivity()

void GeochemicalModelInterrogator::outputActivity ( const std::string & eqm_species ) const

private

output activity info to console

Definition at line 220 of file GeochemicalModelInterrogator.C.

Referenced by output().

 {
   if (_mgd.eqm_species_index.count(eqm_species) == 0)
     return;
 
   const unsigned row = _mgd.eqm_species_index.at(eqm_species);
   const unsigned num_cols = _mgd.basis_species_index.size();
   const Real cutoff = std::pow(10.0, -1.0 * _precision);
   const std::vector<Real> temps = _mgd.original_database->getTemperatures();
   const unsigned numT = temps.size();
   const std::string model_type = _mgd.original_database->getLogKModel();
   EquilibriumConstantInterpolator log10K(
       temps, _mgd.eqm_log10K.sub_matrix(row, 1, 0, numT).get_values(), model_type);
   log10K.generate();
   Real rhs = log10K.sample(_temperature);
   std::stringstream lhs;
 
   lhs << std::setprecision(_precision);
   if (knownActivity(eqm_species))
     rhs += std::log10(getActivity(eqm_species));
   else
     lhs << "(A_" << eqm_species << ")^-1 ";
 
   for (unsigned i = 0; i < num_cols; ++i)
     if (std::abs(_mgd.eqm_stoichiometry(row, i)) > cutoff)
     {
       const std::string sp = _mgd.basis_species_name[i];
       if (knownActivity(sp))
         rhs -= _mgd.eqm_stoichiometry(row, i) * std::log10(getActivity(sp));
       else
         lhs << "(A_" << sp << ")^" << _mgd.eqm_stoichiometry(row, i) << " ";
     }
 
   lhs << "= 10^" << rhs << std::endl;
   _console << lhs.str() << std::flush;
 }

◆ outputReaction()

void GeochemicalModelInterrogator::outputReaction ( const std::string & eqm_species ) const

private

output nicely-formatted reaction info to console

Definition at line 170 of file GeochemicalModelInterrogator.C.

Referenced by output(), and outputTemperature().

 {
   if (_mgd.eqm_species_index.count(eqm_species) == 0)
     return;
   std::stringstream ss;
   const unsigned row = _mgd.eqm_species_index.at(eqm_species);
   const Real cutoff = std::pow(10.0, -1.0 * _precision);
   const std::vector<Real> temps = _mgd.original_database->getTemperatures();
   const unsigned numT = temps.size();
   const std::string model_type = _mgd.original_database->getLogKModel();
   EquilibriumConstantInterpolator log10K(
       temps, _mgd.eqm_log10K.sub_matrix(row, 1, 0, numT).get_values(), model_type);
   log10K.generate();
   const Real log10_eqm_const = log10K.sample(_temperature);
   ss << std::setprecision(_precision);
   ss << eqm_species << " = ";
   ss << GeochemistryFormattedOutput::reaction(
       _mgd.eqm_stoichiometry, row, _mgd.basis_species_name, cutoff, _precision);
   ss << "  .  log10(K) = " << log10_eqm_const;
   ss << std::endl;
   _console << ss.str() << std::flush;
 }

◆ outputTemperature()

void GeochemicalModelInterrogator::outputTemperature ( const std::string & eqm_species ) const

private

output temperature info to console

Definition at line 258 of file GeochemicalModelInterrogator.C.

Referenced by output().

 {
   if (_mgd.eqm_species_index.count(eqm_species) == 0)
     return;
 
   const unsigned row = _mgd.eqm_species_index.at(eqm_species);
   const unsigned num_cols = _mgd.basis_species_index.size();
   const Real cutoff = std::pow(10.0, -1.0 * _precision);
   Real rhs = 1.0;
 
   // check that we know all the required activities, otherwise compute the RHS
   if (knownActivity(eqm_species))
     rhs = -std::log10(getActivity(eqm_species));
   else
   {
     _console << "Not enough activites known to compute equilibrium temperature for reaction\n  "
              << std::flush;
     outputReaction(eqm_species);
     return;
   }
 
   for (unsigned i = 0; i < num_cols; ++i)
     if (std::abs(_mgd.eqm_stoichiometry(row, i)) > cutoff)
     {
       const std::string sp = _mgd.basis_species_name[i];
       if (knownActivity(sp))
         rhs += _mgd.eqm_stoichiometry(row, i) * std::log10(getActivity(sp));
       else
       {
         _console << "Not enough activites known to compute equilibrium temperature for reaction\n  "
                  << std::flush;
         outputReaction(eqm_species);
         return;
       }
     }
 
   const Real tsoln = solveForT(
       _mgd.eqm_log10K.sub_matrix(row, 1, 0, _mgd.original_database->getTemperatures().size()), rhs);
   _console << eqm_species << ".  T = " << tsoln << "degC" << std::endl;
 }

◆ sharedParams()

InputParameters GeochemicalModelInterrogator::sharedParams ( )

static

params that are shared with the AddGeochemicalModelInterrogatorAction

Definition at line 18 of file GeochemicalModelInterrogator.C.

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

 {
   InputParameters params = emptyInputParameters();
   params.addRequiredParam<UserObjectName>("model_definition",
                                           "The name of the GeochemicalModelDefinition user object");
   params.addParam<std::vector<std::string>>(
       "swap_out_of_basis",
       {},
       "Species that should be removed from the model_definition's basis and be replaced with the "
       "swap_into_basis species.  There must be the same number of species in swap_out_of_basis and "
       "swap_into_basis.  If this list contains more than one species, the swapping is performed "
       "one-by-one, starting with the first pair (swap_out_of_basis[0] and swap_into_basis[0]), "
       "then the next pair, etc");
   params.addParam<std::vector<std::string>>(
       "swap_into_basis",
       {},
       "Species that should be removed from the model_definition's "
       "equilibrium species list and added to the basis");
   params.addParam<std::vector<std::string>>(
       "activity_species",
       {},
       "Species that are provided numerical values of activity (or fugacity for gases) in the "
       "activity_value input");
   params.addParam<std::vector<Real>>(
       "activity_values",
       {},
       "Numerical values for the activity (or fugacity) for the "
       "species in the activity_species list.  These are activity values, not log10(activity).");
   params.addParam<unsigned int>(
       "precision",
       4,
       "Precision for printing values.  Also, if the absolute value of a stoichiometric coefficient "
       "is less than 10^(-precision) then it is set to zero.  Also, if equilibrium temperatures are "
       "desired, they will be computed to a relative error of 10^(-precision)");
   params.addParam<std::string>("equilibrium_species",
                                "",
                                "Only output results for this equilibrium species.  If not "
                                "provided, results for all equilibrium species will be outputted");
   MooseEnum interrogation_choice("reaction activity eqm_temperature", "reaction");
   params.addParam<MooseEnum>(
       "interrogation",
       interrogation_choice,
       "Type of interrogation to perform.  reaction: Output equilibrium species reactions and "
       "log10K.  activity: determine activity products at equilibrium.  eqm_temperature: determine "
       "temperature to ensure equilibrium");
   params.addParam<Real>(
       "temperature",
       25,
       "Equilibrium constants will be computed at this temperature [degC].  This is "
       "ignored if interrogation=eqm_temperature.");
   params.addRangeCheckedParam<Real>(
       "stoichiometry_tolerance",
       1E-6,
       "stoichiometry_tolerance >= 0.0",
       "Swapping involves inverting matrices via a singular value decomposition. During this "
       "process: (1) if abs(singular value) < stoi_tol * L1norm(singular values), then the "
       "matrix is deemed singular (so the basis swap is deemed invalid); (2) if abs(any "
       "stoichiometric coefficient) < stoi_tol then it is set to zero.");
   return params;
 }

◆ solveForT()

Real GeochemicalModelInterrogator::solveForT	(	const DenseMatrix< Real > &	reference_log10K,
		Real	rhs
	)		const

private

Returns: The value of temperature for which log10K = rhs. If no solution is possible, NaN is returned

Parameters

reference_log10k values of log10K at the values of temperature in _mgd.tmperatures. Only reference_log10K(0, *) will be used. rhs The right-hand side

Definition at line 300 of file GeochemicalModelInterrogator.C.

Referenced by outputTemperature().

 {
   const std::vector<Real> temps = _mgd.original_database->getTemperatures();
   const unsigned numT = temps.size();
   const std::string model_type = _mgd.original_database->getLogKModel();
 
   // find the bracket that contains the rhs
   unsigned bracket = 0;
   for (bracket = 0; bracket < numT - 1; ++bracket)
   {
     if (reference_log10K(0, bracket) <= rhs && reference_log10K(0, bracket + 1) > rhs)
       break;
     else if (reference_log10K(0, bracket) >= rhs && reference_log10K(0, bracket + 1) < rhs)
       break;
   }
 
   if (bracket == numT - 1)
     return std::numeric_limits<double>::quiet_NaN();
 
   EquilibriumConstantInterpolator log10K(temps, reference_log10K.get_values(), model_type);
   log10K.generate();
   // now do a Newton-Raphson to find T for which log10K.sample(T) = rhs
   Real temp = _mgd.original_database->getTemperatures()[bracket + 1];
   const Real small_delT =
       (temp + GeochemistryConstants::CELSIUS_TO_KELVIN) * std::pow(10.0, -1.0 * _precision);
   Real del_temp = small_delT;
   unsigned iter = 0;
   while (std::abs(del_temp) >= small_delT && iter++ < 100)
   {
     Real residual = log10K.sample(temp) - rhs;
     del_temp = -residual / log10K.sampleDerivative(temp);
     temp += del_temp;
   }
   return temp;
 }

◆ validParams()

InputParameters GeochemicalModelInterrogator::validParams ( )

static

Definition at line 80 of file GeochemicalModelInterrogator.C.

 {
   InputParameters params = Output::validParams();
   params += GeochemicalModelInterrogator::sharedParams();
   params.addClassDescription("Performing simple manipulations of and querying a "
                              "geochemical model");
 
   params.set<ExecFlagEnum>("execute_on") = {EXEC_FINAL};
   return params;
 }