AddCoupledEqSpeciesAction Class Reference

#include <AddCoupledEqSpeciesAction.h>

Inheritance diagram for AddCoupledEqSpeciesAction:

Public Member Functions
	AddCoupledEqSpeciesAction (const InputParameters &params)
virtual void	act () override

Protected Attributes
const std::vector< NonlinearVariableName >	_primary_species
	Basis set of primary species. More...
const std::vector< AuxVariableName >	_secondary_species
	Secondary species added as AuxVariables. More...
std::vector< std::vector< Real > >	_stos
	Stoichiometric coefficients for each primary species in each reaction. More...
std::vector< std::vector< Real > >	_weights
	Weight of each primary species in each reaction. More...
std::vector< Real >	_eq_const
	Equilibrium constants for each reaction. More...
std::vector< VariableName >	_eq_species
	Equilibrium species. More...
std::set< std::string >	_aux_species
	Set of auxillary species. More...
std::vector< std::vector< bool > >	_primary_participation
	Participation of primary species in each reaction. More...
std::vector< std::vector< Real > >	_sto_u
	Stoichiometric coefficients of primary variables in each reaction. More...
std::vector< std::vector< std::vector< Real > > >	_sto_v
	Stoichiometric coefficients of coupled primary variables in each reaction. More...
std::vector< std::vector< std::vector< VariableName > > >	_coupled_v
	Coupled primary species for each reaction. More...
std::vector< std::vector< VariableName > >	_primary_species_involved
	Primary species involved in the ith equilibrium reaction. More...
std::string	_input_reactions
	Reaction network read from input file. More...
std::vector< std::string >	_reactions
	Vector of parsed reactions. More...
unsigned int	_num_reactions
	Number of reactions. More...
const std::vector< VariableName >	_pressure_var
	Pressure variable. More...
const RealVectorValue	_gravity
	Gravity (default is (0, 0, 0)) More...

Detailed Description

Definition at line 21 of file AddCoupledEqSpeciesAction.h.

Constructor & Destructor Documentation

AddCoupledEqSpeciesAction()

AddCoupledEqSpeciesAction::AddCoupledEqSpeciesAction

(

const InputParameters &

params

)

Definition at line 42 of file AddCoupledEqSpeciesAction.C.

  : Action(params),
    _primary_species(getParam<std::vector<NonlinearVariableName>>("primary_species")),
    _secondary_species(getParam<std::vector<AuxVariableName>>("secondary_species")),
    _weights(_primary_species.size()),
    _primary_participation(_primary_species.size()),
    _sto_u(_primary_species.size()),
    _sto_v(_primary_species.size()),
    _coupled_v(_primary_species.size()),
    _input_reactions(getParam<std::string>("reactions")),
    _pressure_var(getParam<std::vector<VariableName>>("pressure")),
    _gravity(getParam<RealVectorValue>("gravity"))
{
  // Parse the aqueous equilibrium reactions
  pcrecpp::RE re_reaction(
      "(.+?)" // single reaction (any character until the equilibrium coefficient appears)
      "\\s"   // word boundary
      "("     // start capture
      "-?"    // optional minus sign
      "\\d+(?:\\.\\d*)?" // digits followed by optional decimal and more digits
      ")"                // end capture
      "\\b"              // word boundary
      "(?:,?\\s*|$)"     // optional 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;
  Real eq_coeff;
 
  // Parse reaction network to extract each individual reaction
  while (re_reaction.FindAndConsume(&input, &single_reaction_str, &eq_coeff))
  {
    _reactions.push_back(single_reaction_str);
    _eq_const.push_back(eq_coeff);
  }
 
  _num_reactions = _reactions.size();
 
  if (_num_reactions == 0)
    mooseError("No equilibrium reaction provided!");
 
  if (_pars.isParamValid("secondary_species"))
    for (unsigned int k = 0; k < _secondary_species.size(); ++k)
      _aux_species.insert(_secondary_species[k]);
 
  // 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)
          _eq_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 = "+";
        }
        else
          sign = 1;
 
        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)
  {
    _sto_u[i].resize(_num_reactions, 0.0);
    _sto_v[i].resize(_num_reactions);
    _coupled_v[i].resize(_num_reactions);
    _weights[i].resize(_num_reactions, 0.0);
 
    _primary_participation[i].resize(_num_reactions, false);
    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])
          _primary_participation[i][j] = true;
 
      if (_primary_participation[i][j])
      {
        for (unsigned int k = 0; k < _primary_species_involved[j].size(); ++k)
        {
          if (_primary_species_involved[j][k] == _primary_species[i])
          {
            _sto_u[i][j] = _stos[j][k];
            _weights[i][j] = _stos[j][k];
          }
          else
          {
            _sto_v[i][j].push_back(_stos[j][k]);
            _coupled_v[i][j].push_back(_primary_species_involved[j][k]);
          }
        }
      }
    }
  }
 
  // Print out details of the equilibrium reactions to the console
  _console << "Aqueous equilibrium reactions:\n";
  for (unsigned int i = 0; i < _num_reactions; ++i)
    _console << "  Reaction " << i + 1 << ": " << _reactions[i] << ", log10(Keq) = " << _eq_const[i]
             << "\n";
  _console << "\n";
}

Member Function Documentation

act()

void AddCoupledEqSpeciesAction::act ( )

overridevirtual

Definition at line 197 of file AddCoupledEqSpeciesAction.C.

{
  if (_current_task == "add_kernel")
  {
    // Add Kernels for each primary species
    for (unsigned int i = 0; i < _primary_species.size(); ++i)
    {
      for (unsigned int j = 0; j < _num_reactions; ++j)
      {
        if (_primary_participation[i][j])
        {
          InputParameters params_sub = _factory.getValidParams("CoupledBEEquilibriumSub");
          params_sub.set<NonlinearVariableName>("variable") = _primary_species[i];
          params_sub.set<Real>("weight") = _weights[i][j];
          params_sub.defaultCoupledValue("log_k", _eq_const[j]);
          params_sub.set<Real>("sto_u") = _sto_u[i][j];
          params_sub.set<std::vector<Real>>("sto_v") = _sto_v[i][j];
          params_sub.set<std::vector<VariableName>>("v") = _coupled_v[i][j];
          _problem->addKernel("CoupledBEEquilibriumSub",
                              _primary_species[i] + "_" + _eq_species[j] + "_sub",
                              params_sub);
 
          InputParameters params_cd = _factory.getValidParams("CoupledDiffusionReactionSub");
          params_cd.set<NonlinearVariableName>("variable") = _primary_species[i];
          params_cd.set<Real>("weight") = _weights[i][j];
          params_cd.defaultCoupledValue("log_k", _eq_const[j]);
          params_cd.set<Real>("sto_u") = _sto_u[i][j];
          params_cd.set<std::vector<Real>>("sto_v") = _sto_v[i][j];
          params_cd.set<std::vector<VariableName>>("v") = _coupled_v[i][j];
          _problem->addKernel("CoupledDiffusionReactionSub",
                              _primary_species[i] + "_" + _eq_species[j] + "_cd",
                              params_cd);
 
          // If pressure is coupled, add a CoupledConvectionReactionSub Kernel as well
          if (_pars.isParamValid("pressure"))
          {
            InputParameters params_conv = _factory.getValidParams("CoupledConvectionReactionSub");
            params_conv.set<NonlinearVariableName>("variable") = _primary_species[i];
            params_conv.set<Real>("weight") = _weights[i][j];
            params_conv.defaultCoupledValue("log_k", _eq_const[j]);
            params_conv.set<Real>("sto_u") = _sto_u[i][j];
            params_conv.set<std::vector<Real>>("sto_v") = _sto_v[i][j];
            params_conv.set<std::vector<VariableName>>("v") = _coupled_v[i][j];
            params_conv.set<std::vector<VariableName>>("p") = _pressure_var;
            params_conv.set<RealVectorValue>("gravity") = _gravity;
            _problem->addKernel("CoupledConvectionReactionSub",
                                _primary_species[i] + "_" + _eq_species[j] + "_conv",
                                params_conv);
          }
        }
      }
    }
  }
 
  if (_current_task == "add_aux_kernel")
  {
    // Add AqueousEquilibriumRxnAux AuxKernels for equilibrium species
    for (unsigned int j = 0; j < _num_reactions; ++j)
    {
      if (_aux_species.find(_eq_species[j]) != _aux_species.end())
      {
        InputParameters params_eq = _factory.getValidParams("AqueousEquilibriumRxnAux");
        params_eq.set<AuxVariableName>("variable") = _eq_species[j];
        params_eq.defaultCoupledValue("log_k", _eq_const[j]);
        params_eq.set<std::vector<Real>>("sto_v") = _stos[j];
        params_eq.set<std::vector<VariableName>>("v") = _primary_species_involved[j];
        _problem->addAuxKernel("AqueousEquilibriumRxnAux", "aux_" + _eq_species[j], params_eq);
      }
    }
  }
}

Member Data Documentation

_aux_species

std::set<std::string> AddCoupledEqSpeciesAction::_aux_species

protected

Set of auxillary species.

Definition at line 42 of file AddCoupledEqSpeciesAction.h.

Referenced by act(), and AddCoupledEqSpeciesAction().

_coupled_v

std::vector<std::vector<std::vector<VariableName> > > AddCoupledEqSpeciesAction::_coupled_v

protected

Coupled primary species for each reaction.

Definition at line 50 of file AddCoupledEqSpeciesAction.h.

Referenced by act(), and AddCoupledEqSpeciesAction().

_eq_const

std::vector<Real> AddCoupledEqSpeciesAction::_eq_const

protected

Equilibrium constants for each reaction.

Definition at line 38 of file AddCoupledEqSpeciesAction.h.

Referenced by act(), and AddCoupledEqSpeciesAction().

_eq_species

std::vector<VariableName> AddCoupledEqSpeciesAction::_eq_species

protected

Equilibrium species.

Definition at line 40 of file AddCoupledEqSpeciesAction.h.

Referenced by act(), and AddCoupledEqSpeciesAction().

_gravity

const RealVectorValue AddCoupledEqSpeciesAction::_gravity

protected

Gravity (default is (0, 0, 0))

Definition at line 62 of file AddCoupledEqSpeciesAction.h.

Referenced by act().

_input_reactions

std::string AddCoupledEqSpeciesAction::_input_reactions

protected

Reaction network read from input file.

Definition at line 54 of file AddCoupledEqSpeciesAction.h.

Referenced by AddCoupledEqSpeciesAction().

_num_reactions

unsigned int AddCoupledEqSpeciesAction::_num_reactions

protected

Number of reactions.

Definition at line 58 of file AddCoupledEqSpeciesAction.h.

Referenced by act(), and AddCoupledEqSpeciesAction().

_pressure_var

const std::vector<VariableName> AddCoupledEqSpeciesAction::_pressure_var

protected

Pressure variable.

Definition at line 60 of file AddCoupledEqSpeciesAction.h.

Referenced by act().

_primary_participation

std::vector<std::vector<bool> > AddCoupledEqSpeciesAction::_primary_participation

protected

Participation of primary species in each reaction.

Definition at line 44 of file AddCoupledEqSpeciesAction.h.

Referenced by act(), and AddCoupledEqSpeciesAction().

_primary_species

const std::vector<NonlinearVariableName> AddCoupledEqSpeciesAction::_primary_species

protected

Basis set of primary species.

Definition at line 30 of file AddCoupledEqSpeciesAction.h.

Referenced by act(), and AddCoupledEqSpeciesAction().

_primary_species_involved

std::vector<std::vector<VariableName> > AddCoupledEqSpeciesAction::_primary_species_involved

protected

Primary species involved in the ith equilibrium reaction.

Definition at line 52 of file AddCoupledEqSpeciesAction.h.

Referenced by act(), and AddCoupledEqSpeciesAction().

_reactions

std::vector<std::string> AddCoupledEqSpeciesAction::_reactions

protected

Vector of parsed reactions.

Definition at line 56 of file AddCoupledEqSpeciesAction.h.

Referenced by AddCoupledEqSpeciesAction().

_secondary_species

const std::vector<AuxVariableName> AddCoupledEqSpeciesAction::_secondary_species

protected

Secondary species added as AuxVariables.

Definition at line 32 of file AddCoupledEqSpeciesAction.h.

Referenced by AddCoupledEqSpeciesAction().

_sto_u

std::vector<std::vector<Real> > AddCoupledEqSpeciesAction::_sto_u

protected

Stoichiometric coefficients of primary variables in each reaction.

Definition at line 46 of file AddCoupledEqSpeciesAction.h.

Referenced by act(), and AddCoupledEqSpeciesAction().

_sto_v

std::vector<std::vector<std::vector<Real> > > AddCoupledEqSpeciesAction::_sto_v

protected

Stoichiometric coefficients of coupled primary variables in each reaction.

Definition at line 48 of file AddCoupledEqSpeciesAction.h.

Referenced by act(), and AddCoupledEqSpeciesAction().

_stos

std::vector<std::vector<Real> > AddCoupledEqSpeciesAction::_stos

protected

Stoichiometric coefficients for each primary species in each reaction.

Definition at line 34 of file AddCoupledEqSpeciesAction.h.

Referenced by act(), and AddCoupledEqSpeciesAction().

_weights

std::vector<std::vector<Real> > AddCoupledEqSpeciesAction::_weights

protected

Weight of each primary species in each reaction.

Definition at line 36 of file AddCoupledEqSpeciesAction.h.

Referenced by act(), and AddCoupledEqSpeciesAction().

---

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

• chemical_reactions/include/actions/AddCoupledEqSpeciesAction.h
• chemical_reactions/src/actions/AddCoupledEqSpeciesAction.C