#include <AddCoupledSolidKinSpeciesAction.h>

Inheritance diagram for AddCoupledSolidKinSpeciesAction:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	AddCoupledSolidKinSpeciesAction (const InputParameters &params)

virtual void	act () override

void	timedAct ()

virtual void	addRelationshipManagers (Moose::RelationshipManagerType when_type)

MooseObjectName	uniqueActionName () const

const std::string &	specificTaskName () const

const std::set< std::string > &	getAllTasks () const

void	appendTask (const std::string &task)

MooseApp &	getMooseApp () const

const std::string &	type () const

const std::string &	name () const

std::string	typeAndName () const

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

MooseObjectName	uniqueName () const

const InputParameters &	parameters () const

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () const

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

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

const T *	queryParam (const std::string &name) const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

PerfGraph &	perfGraph ()

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()

static void	callMooseError (MooseApp const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node node, const bool show_trace=true)

Public Attributes
	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console

Static Public Attributes
static const std::string	unique_action_name_param

static const std::string	type_param

static const std::string	name_param

static const std::string	unique_name_param

static const std::string	app_param

static const std::string	moose_base_param

static const std::string	kokkos_object_param

static constexpr auto	SYSTEM

static constexpr auto	NAME

Protected Member Functions
bool	addRelationshipManagers (Moose::RelationshipManagerType when_type, const InputParameters &moose_object_pars)

void	associateWithParameter (const std::string &param_name, InputParameters &params) const

void	associateWithParameter (const InputParameters &from_params, const std::string &param_name, InputParameters &params) 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

void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

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

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

Protected Attributes
std::string	_registered_identifier

std::string	_specific_task_name

std::set< std::string >	_all_tasks

ActionWarehouse &	_awh

const std::string &	_current_task

std::shared_ptr< MooseMesh > &	_mesh

std::shared_ptr< MooseMesh > &	_displaced_mesh

std::shared_ptr< FEProblemBase > &	_problem

PerfID	_act_timer

MooseApp &	_app

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

MooseApp &	_pg_moose_app

const std::string	_prefix

const Parallel::Communicator &	_communicator

Private Member Functions
bool	addRelationshipManager (Moose::RelationshipManagerType input_rm_type, const InputParameters &moose_object_pars, std::string rm_name, Moose::RelationshipManagerType rm_type, Moose::RelationshipManagerInputParameterCallback rm_input_parameter_func, Moose::RMSystemType sys_type=Moose::RMSystemType::NONE)

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

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

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

Static Private Member Functions
static const hit::Node *	getHitNode (const InputParameters &params)

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

Private Attributes
const std::vector< NonlinearVariableName >	_primary_species
	Basis set of primary species.

const std::vector< AuxVariableName >	_secondary_species
	Secondary species added as AuxVariables.

std::vector< VariableName >	_solid_kinetic_species
	Secondary solid species read by the parser.

std::vector< std::vector< VariableName > >	_primary_species_involved
	Primary species involved in the ith kinetic reaction.

std::vector< std::vector< VariableName > >	_kinetic_species_involved
	Secondary solid species involved the ith primary species.

std::vector< std::vector< Real > >	_stos
	Stoichiometric coefficients for each primary species in each reaction.

std::vector< std::vector< Real > >	_weights
	Weight of each primary species in each reaction.

std::string	_input_reactions
	Reaction network read from input file.

std::vector< std::string >	_reactions
	Vector of parsed reactions.

unsigned int	_num_reactions
	Number of reactions.

const std::vector< Real >	_logk
	Log10 of equilibrium constant.

const std::vector< Real >	_r_area
	Specific reactive surface area, m^2/L solution.

const std::vector< Real >	_ref_kconst
	Reference kinetic rate constant.

const std::vector< Real >	_e_act
	Activation energy.

const Real	_gas_const
	Gas constant, (Default 8.314 J/mol/K)

const std::vector< Real >	_ref_temp
	Reference temperature.

const std::vector< VariableName >	_sys_temp
	Actual system temperature.

const ParallelParamObject &	_parent

MooseApp &	_meta_data_app

const MooseObject *const	_meta_data_object

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

Detailed Description

Definition at line 14 of file AddCoupledSolidKinSpeciesAction.h.

Constructor & Destructor Documentation

◆ AddCoupledSolidKinSpeciesAction()

AddCoupledSolidKinSpeciesAction::AddCoupledSolidKinSpeciesAction ( const InputParameters & params )

Definition at line 52 of file AddCoupledSolidKinSpeciesAction.C.

  : Action(params),
    _primary_species(getParam<std::vector<NonlinearVariableName>>("primary_species")),
    _secondary_species(getParam<std::vector<AuxVariableName>>("secondary_species")),
    _kinetic_species_involved(_primary_species.size()),
    _weights(_primary_species.size()),
    _input_reactions(getParam<std::string>("kin_reactions")),
    _logk(getParam<std::vector<Real>>("log10_keq")),
    _r_area(getParam<std::vector<Real>>("specific_reactive_surface_area")),
    _ref_kconst(getParam<std::vector<Real>>("kinetic_rate_constant")),
    _e_act(getParam<std::vector<Real>>("activation_energy")),
    _gas_const(getParam<Real>("gas_constant")),
    _ref_temp(getParam<std::vector<Real>>("reference_temperature")),
    _sys_temp(getParam<std::vector<VariableName>>("system_temperature"))
{
  // Note: as the reaction syntax has changed, check to see if the old syntax has
  // been used and throw an informative error. The number of = signs should be one
  // more than the number of commas, while the smallest number of spaces possible is 2
  bool old_syntax = false;
  if (std::count(_input_reactions.begin(), _input_reactions.end(), '=') !=
      std::count(_input_reactions.begin(), _input_reactions.end(), ',') + 1)
    old_syntax = true;
 
  if (std::count(_input_reactions.begin(), _input_reactions.end(), ' ') < 2)
    old_syntax = true;
 
  if (old_syntax)
    mooseError("Old solid kinetic reaction syntax present.\nReactions should now be comma "
               "separated, and must have spaces between species and +/-/= operators.\n"
               "See #9972 for details");
 
  // Parse the kinetic reactions
  pcrecpp::RE re_reactions("(.+?)" // A single reaction (any character until the comma delimiter)
                           "(?:,\\s*|$)" // comma or end of string
                           ,
                           pcrecpp::RE_Options().set_extended(true));
 
  pcrecpp::RE re_terms("(\\S+)");
  pcrecpp::RE re_coeff_and_species("(?: \\(? (.*?) \\)? )" // match the leading coefficent
                                   "([A-Za-z].*)"          // match the species
                                   ,
                                   pcrecpp::RE_Options().set_extended(true));
 
  pcrecpp::StringPiece input(_input_reactions);
  pcrecpp::StringPiece single_reaction, term;
  std::string single_reaction_str;
 
  // Parse reaction network to extract each individual reaction
  while (re_reactions.FindAndConsume(&input, &single_reaction_str))
    _reactions.push_back(single_reaction_str);
 
  _num_reactions = _reactions.size();
 
  if (_num_reactions == 0)
    mooseError("No solid kinetic reaction provided!");
 
  // Start parsing each reaction
  for (unsigned int i = 0; i < _num_reactions; ++i)
  {
    single_reaction = _reactions[i];
 
    // Capture all of the terms
    std::string species, coeff_str;
    Real coeff;
    int sign = 1;
    bool secondary = false;
 
    std::vector<Real> local_stos;
    std::vector<VariableName> local_species_list;
 
    // Find every single term in this reaction (species and operators)
    while (re_terms.FindAndConsume(&single_reaction, &term))
    {
      // Separating the stoichiometric coefficients from species
      if (re_coeff_and_species.PartialMatch(term, &coeff_str, &species))
      {
        if (coeff_str.length())
          coeff = std::stod(coeff_str);
        else
          coeff = 1.0;
 
        coeff *= sign;
 
        if (secondary)
          _solid_kinetic_species.push_back(species);
        else
        {
          local_stos.push_back(coeff);
          local_species_list.push_back(species);
        }
      }
      // Finding the operators and assign value of -1.0 to "-" sign
      else if (term == "+" || term == "=" || term == "-")
      {
        if (term == "-")
        {
          sign = -1;
          term = "+";
        }
 
        if (term == "=")
          secondary = true;
      }
      else
        mooseError("Error parsing term: ", term.as_string());
    }
 
    _stos.push_back(local_stos);
    _primary_species_involved.push_back(local_species_list);
  }
 
  // Start picking out primary species and coupled primary species and assigning
  // corresponding stoichiomentric coefficients
  for (unsigned int i = 0; i < _primary_species.size(); ++i)
    for (unsigned int j = 0; j < _num_reactions; ++j)
    {
      for (unsigned int k = 0; k < _primary_species_involved[j].size(); ++k)
        if (_primary_species_involved[j][k] == _primary_species[i])
        {
          _weights[i].push_back(_stos[j][k]);
          _kinetic_species_involved[i].push_back(_solid_kinetic_species[j]);
        }
    }
 
  // Print out details of the solid kinetic reactions to the console
  _console << "Solid kinetic reactions:\n";
  for (unsigned int i = 0; i < _num_reactions; ++i)
    _console << "  Reaction " << i + 1 << ": " << _reactions[i] << "\n";
  _console << std::endl;
 
  // Check that all secondary species read from the reaction network have been added
  // as AuxVariables. Note: can't sort the _solid_kinetic_species vector as it throws
  // out the species and coefficient vectors so use std::is_permutation
  if (!std::is_permutation(
          _secondary_species.begin(), _secondary_species.end(), _solid_kinetic_species.begin()))
    mooseError("All solid kinetic species must be added as secondary species");
 
  // Check that the size of property vectors is equal to the number of reactions
  if (_logk.size() != _num_reactions)
    mooseError("The number of values entered for log10_keq is not equal to the number of solid "
               "kinetic reactions");
  if (_r_area.size() != _num_reactions)
    mooseError("The number of values entered for specific_reactive_surface_area is not equal to "
               "the number of solid kinetic reactions");
  if (_ref_kconst.size() != _num_reactions)
    mooseError("The number of values entered for kinetic_rate_constant is not equal to the number "
               "of solid kinetic reactions");
  if (_e_act.size() != _num_reactions)
    mooseError("The number of values entered for activation_energy is not equal to the number of "
               "solid kinetic reactions");
  if (_ref_temp.size() != _num_reactions)
    mooseError("The number of values entered for reference_temperature is not equal to the number "
               "of solid kinetic reactions");
}

Member Function Documentation

◆ act()

void AddCoupledSolidKinSpeciesAction::act ( )

overridevirtual

Implements Action.

Definition at line 208 of file AddCoupledSolidKinSpeciesAction.C.

{
  if (_current_task == "add_kernel")
  {
    // Add Kernels for each primary species
    for (unsigned int i = 0; i < _primary_species.size(); ++i)
    {
      InputParameters params_kin = _factory.getValidParams("CoupledBEKinetic");
      params_kin.set<NonlinearVariableName>("variable") = _primary_species[i];
      params_kin.set<std::vector<Real>>("weight") = _weights[i];
      params_kin.set<std::vector<VariableName>>("v") = _kinetic_species_involved[i];
      _problem->addKernel("CoupledBEKinetic", _primary_species[i] + "_" + "_kin", params_kin);
    }
  }
 
  if (_current_task == "add_aux_kernel")
  {
    // Add AuxKernels for each solid kinetic species
    for (unsigned int i = 0; i < _num_reactions; ++i)
    {
      InputParameters params_kin = _factory.getValidParams("KineticDisPreConcAux");
      params_kin.set<AuxVariableName>("variable") = _solid_kinetic_species[i];
      params_kin.defaultCoupledValue("log_k", _logk[i]);
      params_kin.set<Real>("r_area") = _r_area[i];
      params_kin.set<Real>("ref_kconst") = _ref_kconst[i];
      params_kin.set<Real>("e_act") = _e_act[i];
      params_kin.set<Real>("gas_const") = _gas_const;
      params_kin.set<Real>("ref_temp") = _ref_temp[i];
      params_kin.set<std::vector<VariableName>>("sys_temp") = _sys_temp;
      params_kin.set<std::vector<Real>>("sto_v") = _stos[i];
      params_kin.set<std::vector<VariableName>>("v") = _primary_species_involved[i];
      _problem->addAuxKernel(
          "KineticDisPreConcAux", "aux_" + _solid_kinetic_species[i], params_kin);
    }
  }
}

◆ validParams()

InputParameters AddCoupledSolidKinSpeciesAction::validParams ( )

static

Definition at line 26 of file AddCoupledSolidKinSpeciesAction.C.

{
  InputParameters params = Action::validParams();
  params.addRequiredParam<std::vector<NonlinearVariableName>>("primary_species",
                                                              "The list of primary species to add");
  params.addParam<std::vector<AuxVariableName>>(
      "secondary_species", "The list of solid kinetic species to be output as aux variables");
  params.addRequiredParam<std::string>("kin_reactions", "The list of solid kinetic reactions");
  params.addRequiredParam<std::vector<Real>>("log10_keq",
                                             "The list of equilibrium constants for all reactions");
  params.addRequiredParam<std::vector<Real>>(
      "specific_reactive_surface_area",
      "The list of specific reactive surface area for all minerals (m^2/L)");
  params.addRequiredParam<std::vector<Real>>(
      "kinetic_rate_constant", "The list of kinetic rate constant for all reactions (mol/m^2/s)");
  params.addRequiredParam<std::vector<Real>>(
      "activation_energy", "The list of activation energy values for all reactions (J/mol)");
  params.addParam<Real>("gas_constant", 8.314, "Gas constant. Default is 8.314 (J/mol/K)");
  params.addRequiredParam<std::vector<Real>>(
      "reference_temperature", "The list of reference temperatures for all reactions (K)");
  params.addRequiredCoupledVar("system_temperature",
                               "The system temperature for all reactions (K)");
  params.addClassDescription("Adds solid kinetic Kernels and AuxKernels for primary species");
  return params;
}