PertinentGeochemicalSystem Class Reference

Constructs and stores a minimal amount of information that is pertinent to the user-defined geochemical system. More...

#include <PertinentGeochemicalSystem.h>

Public Member Functions
	PertinentGeochemicalSystem (const GeochemicalDatabaseReader &db, const std::vector< std::string > &basis_species, const std::vector< std::string > &minerals, const std::vector< std::string > &gases, const std::vector< std::string > &kinetic_minerals, const std::vector< std::string > &kinetic_redox, const std::vector< std::string > &kinetic_surface_species, const std::string &redox_ox, const std::string &redox_e)
const ModelGeochemicalDatabase &	modelGeochemicalDatabase () const
	Return a reference to the ModelGeochemicalDatabase structure.
void	addKineticRate (const KineticRateUserDescription &description)
	Adds a rate description for kinetic_species.
unsigned	getIndexOfOriginalBasisSpecies (const std::string &name) const
std::vector< std::string >	originalBasisNames () const

Private Member Functions
void	buildBasis (const std::vector< std::string > &basis_species)
	using the basis_species list, this method builds _basis_index and _basis_info
void	buildMinerals (const std::vector< std::string > &minerals)
	using the minerals list, this method builds _mineral_index and _mineral_info, unless minerals = {"*"}, in which case buildAllMinerals is used instead
void	buildAllMinerals (const std::vector< std::string > &minerals)
	If minerals = {"*"} then populate _mineral_index and _mineral_info with all relevant minerals This is called in the constructor after buildSecondarySpecies and buildKineticMinerals because it adds to _mineral_index and _mineral_info all minerals that:
void	buildGases (const std::vector< std::string > &gases)
	using the gas list, this method builds _gas_index and _gas_info
void	buildKineticMinerals (const std::vector< std::string > &kinetic_minerals)
	using the kinetic_minerals list, this method builds _kinetic_mineral_index and _kinetic_mineral_info
void	buildKineticRedox (const std::vector< std::string > &kinetic_redox)
	using the kinetic_redox list, this method builds _kinetic_redox_index and _kinetic_redox_info
void	buildKineticSurface (const std::vector< std::string > &kinetic_surface)
	using the kinetic_surface list, this method builds _kinetic_surface_index and _kinetic_surface_info
void	buildSecondarySpecies ()
	Extract all relevant "redox couples" and "secondary species" and "surface species" from the database.
bool	checkRedoxe ()
void	checkMinerals (const std::vector< GeochemistryMineralSpecies > &mineral_info) const
	Check that all minerals in mineral_info have reactions that involve only the basis_species or secondary_species.
void	checkGases () const
	Check that all gases in the "gases" list have reactions that involve only the basis_species or secondary_species.
void	checkKineticRedox () const
	Check that all kinetic redox species in the _kinetic_redox list have reactions that involve only the basis_species or secondary_species.
void	checkKineticSurfaceSpecies () const
	Check that all kinetic surface species in the _kinetic_surface_species list have reactions that involve only the basis_species or secondary_species.
void	createModel ()
	Fully populate the ModelGeochemicalDatabase.
void	buildRedoxeInfo (std::vector< Real > &redox_e_stoichiometry, std::vector< Real > &redox_e_log10K)
	Extract the stoichiometry and log10K for the _redox_e species.

Private Attributes
GeochemicalDatabaseReader	_db
	The database.
std::unordered_map< std::string, unsigned >	_basis_index
	given a species name, return its index in the corresponding "info" std::vector
std::vector< GeochemistryBasisSpecies >	_basis_info
	a vector of all relevant species
std::unordered_map< std::string, unsigned >	_mineral_index
	given a species name, return its index in the corresponding "info" std::vector
std::vector< GeochemistryMineralSpecies >	_mineral_info
	a vector of all relevant species
std::unordered_map< std::string, unsigned >	_gas_index
	given a species name, return its index in the corresponding "info" std::vector
std::vector< GeochemistryGasSpecies >	_gas_info
	a vector of all relevant species
std::unordered_map< std::string, unsigned >	_kinetic_mineral_index
	given a species name, return its index in the corresponding "info" std::vector
std::vector< GeochemistryMineralSpecies >	_kinetic_mineral_info
	a vector of all relevant species
std::unordered_map< std::string, unsigned >	_kinetic_redox_index
	given a species name, return its index in the corresponding "info" std::vector
std::vector< GeochemistryRedoxSpecies >	_kinetic_redox_info
	a vector of all relevant species
std::unordered_map< std::string, unsigned >	_kinetic_surface_index
	given a species name, return its index in the corresponding "info" std::vector
std::vector< GeochemistrySurfaceSpecies >	_kinetic_surface_info
	a vector of all relevant species
std::unordered_map< std::string, unsigned >	_secondary_index
	given a species name, return its index in the corresponding "info" std::vector
std::vector< GeochemistryEquilibriumSpecies >	_secondary_info
	a vector of all relevant species
const std::string	_redox_ox
	The name of the oxygen in all disequilibrium-redox equations, eg O2(aq), which must be a basis species if disequilibrium redox reactions are to be recorded.
const std::string	_redox_e
	The name of the free electron involved in redox reactions.
ModelGeochemicalDatabase	_model
	The important datastructure built by this class.

Detailed Description

Constructs and stores a minimal amount of information that is pertinent to the user-defined geochemical system.

Most importantly, all basis species, secondary species, mineral species, etc, that are defined in the geochemical database but are irrelevant to the user-defined system are eliminated from further consideration. This reduces the amount of information considerably. The final result is stored in a ModelGeochemicalDatabase structure. This structure is designed to be computationally efficient. A "getter" that copies this structure is provided as a public method. It is intended that a MOOSE simulation will construct one PertinentGeochemicalSystem object, and then copy the information to the nodes during the initial setup. If different nodes are allowed different swaps (likely to be the case) each node will need a different copy of the ModelGeochemicalDatabase structure.

Definition at line 386 of file PertinentGeochemicalSystem.h.

Constructor & Destructor Documentation

PertinentGeochemicalSystem()

PertinentGeochemicalSystem::PertinentGeochemicalSystem	(	const GeochemicalDatabaseReader &	db,
		const std::vector< std::string > &	basis_species,
		const std::vector< std::string > &	minerals,
		const std::vector< std::string > &	gases,
		const std::vector< std::string > &	kinetic_minerals,
		const std::vector< std::string > &	kinetic_redox,
		const std::vector< std::string > &	kinetic_surface_species,
		const std::string &	redox_ox,
		const std::string &	redox_e
	)

Parameters

db	the database reader, which will have parsed the database file
basis_species	A list of basis components relevant to the aqueous-equilibrium problem. "H2O" must appear first in this list. No element must appear more than once in this list. These components must be chosen from the "basis species" in the database, the sorbing sites (if any) and the decoupled redox states that are in disequilibrium (if any). Any redox pair that is not in this list or the kinetic_redox list, will be assumed to be at equilibrium with the aqueous solution and will be considered a secondary species. All these species, except H2O, may be later swapped out of this list, either by a manual user-prescribed swap (and replaced by a mineral or a gas of fixed fugacity, for instance), or during the numerical solve.
minerals	A list of minerals that are in equilibrium with the aqueous solution. This can only include the "minerals" in the database file. No element can appear more than once in this list. Their equilibrium reaction must consist of only the basis_species, and secondary species and non-kinetically-controlled redox couples that can be expressed in terms of the basis_species. If they are also "sorbing minerals" in the database then their sorption sites must consist of the basis_species only. During simulation, the user can compute the saturation index of these minerals, and these minerals can be "swapped" into the basis if desired (or required during the numerical solve). If the user performs a manual "swap" then an initial condition must be provided for the mineral. The user choose whether these minerals are allowed to precipitate or not - that is, they can be "supressed". This list, along with the kinetic_minerals list, comprises the entire list of minerals in the problem: all others are eliminated from consideration.
gases	A list of gases that are in equilibrium with the aqueous solution and can have their fugacities fixed, at least at some time and spatial location. All members of this list must be a "gas" in the database file. No gas must appear more than once in this list. The equilibrium reaction of each gas must involve only the basis_species, or secondary species or non-kinetically-controlled redox couples that can be expressed in terms of the basis_species.
kinetic_minerals	A list of minerals that whose dynamics are governed by a rate law. These are not in equilibrium with the aqueous solution. This can only include the "minerals" in the database file. No element can appear more than once in this list. Their equilibrium reaction must involve only the basis_species, or secondary species or non-kinetically-controlled redox couples that can be expressed in terms of the basis_species. If they are also "sorbing minerals" in the database then their sorption sites must consist of the basis_speices only. No members of this list must be in the minerals list. They can never be "swapped" into the basis, nor can they be "supressed".
kinetic_redox	A list of redox pairs whose dynamics are governed by a rate law. These are not in equilibrium with the aqueous solution. Each element of this list must appear in the "redox couples" section of the database. No element can appear more than once in this list. Their reaction must involve only the basis_species, or secondary species or non-kinetically-controlled redox couples that can be expressed in terms of the basis_species. No members of this list must be in the basis_species list. They can never be "swapped" into the basis.
kinetic_surface_species	A list of surface sorbing species whose dynamics are governed by a rate law. These are not in equilibrium with the aqueous solution. All elements of this list must appear as a "surface species" in the database. No member must appear more than twice in this list. Their reaction must involve only the basis_species, or secondary species or non-kinetically-controlled redox couples that can be expressed in terms of the basis_species. They can never be "swapped" into the basis.
redox_ox	The name of the oxygen species, eg O2(aq), that appears in redox reactions. For redox pairs that are in disequilibrium to be correctly recorded, and hence their Nernst potentials to be computed easily, redox_ox must be a basis_species and it must appear in the reaction for each redox pair.
redox_e	The name of the free electron, eg e-. For redox pairs that are in disequilibrium to be correctly recorded, and hence their Nernst potentials to be computed easily, the equilibrium reaction for redox_e must involve redox_ox, and the basis species must be chosen so that redox_e is an equilibrium species according to the database reader

Definition at line 12 of file PertinentGeochemicalSystem.C.

  : _db(db),
    _basis_index(),
    _basis_info(),
    _mineral_index(),
    _mineral_info(),
    _gas_index(),
    _gas_info(),
    _kinetic_mineral_index(),
    _kinetic_mineral_info(),
    _kinetic_redox_index(),
    _kinetic_redox_info(),
    _kinetic_surface_index(),
    _kinetic_surface_info(),
    _secondary_index(),
    _secondary_info(),
    _redox_ox(redox_ox),
    _redox_e(redox_e),
    _model(_db)
{
  // Use the constructor info to build the "index" and "info" structures
  buildBasis(basis_species);
  buildMinerals(minerals);
  buildGases(gases);
  buildKineticMinerals(kinetic_minerals);
  buildKineticRedox(kinetic_redox);
  buildKineticSurface(kinetic_surface_species);
 
  // Pull out all secondary equilibrium species: these are all relevant "redox couples" and
  // "secondary species" and "surface species"
  buildSecondarySpecies();
 
  // Build minerals in the case that minerals = {"*"}
  buildAllMinerals(minerals);
 
  // Check that everything can be expressed in terms of the basis, possibly via redox and secondary
  // species
  checkMinerals(_mineral_info);
  checkGases();
  checkMinerals(_kinetic_mineral_info);
  checkKineticRedox();
  checkKineticSurfaceSpecies();
 
  // Populate _model
  createModel();
}

Member Function Documentation

addKineticRate()

void PertinentGeochemicalSystem::addKineticRate

(

const KineticRateUserDescription &

description

)

Adds a rate description for kinetic_species.

Note that a single kinetic species can have multiple rates prescribed to it (by calling this method multiple times): they are added together to give an overall rate.

Definition at line 856 of file PertinentGeochemicalSystem.C.

{
  const std::string kinetic_species = description.kinetic_species_name;
  if (_model.kin_species_index.count(kinetic_species) == 0)
    mooseError("Cannot prescribe a kinetic rate to species ",
               kinetic_species,
               " since it is not a kinetic species");
  const unsigned kinetic_species_index = _model.kin_species_index.at(kinetic_species);
 
  // build the promoting index list
  const unsigned num_pro = description.promoting_species.size();
  const unsigned num_basis = _model.basis_species_name.size();
  const unsigned num_eqm = _model.eqm_species_name.size();
  std::vector<Real> promoting_ind(num_basis + num_eqm, 0.0);
  std::vector<Real> promoting_m_ind(num_basis + num_eqm, 0.0);
  std::vector<Real> promoting_k(num_basis + num_eqm, 0.0);
  for (unsigned i = 0; i < num_pro; ++i)
  {
    unsigned index = 0;
    const std::string promoting_species = description.promoting_species[i];
    if (_model.basis_species_index.count(promoting_species) == 1)
      index = _model.basis_species_index.at(promoting_species);
    else if (_model.eqm_species_index.count(promoting_species) == 1)
      index = num_basis + _model.eqm_species_index.at(promoting_species);
    else
      mooseError(
          "Promoting species ", promoting_species, " must be a basis or a secondary species");
    promoting_ind[index] = description.promoting_indices[i];
    promoting_m_ind[index] = description.promoting_monod_indices[i];
    promoting_k[index] = description.promoting_half_saturation[i];
  }
  unsigned progeny_num = 0;
  if (_model.basis_species_index.count(description.progeny) == 1)
    progeny_num = _model.basis_species_index.at(description.progeny);
  else if (_model.eqm_species_index.count(description.progeny) == 1)
    progeny_num = num_basis + _model.eqm_species_index.at(description.progeny);
  else
    mooseError("Progeny ", description.progeny, " must be a basis or a secondary species");
 
  // append the result to kin_rate
  _model.kin_rate.push_back(KineticRateDefinition(kinetic_species_index,
                                                  promoting_ind,
                                                  promoting_m_ind,
                                                  promoting_k,
                                                  progeny_num,
                                                  description));
}

Referenced by GeochemicalModelDefinition::GeochemicalModelDefinition(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

buildAllMinerals()

void PertinentGeochemicalSystem::buildAllMinerals ( const std::vector< std::string > &  minerals )

private

If minerals = {"*"} then populate _mineral_index and _mineral_info with all relevant minerals This is called in the constructor after buildSecondarySpecies and buildKineticMinerals because it adds to _mineral_index and _mineral_info all minerals that:

• are not kinetic minerals (these have been identified by buildKineticMinerals) and
• whose stoichiometry depends on the basis species specified in the constructor or on secondary species (which are redox couples, secondary species and surface species) that depend on these basis species. These secondary species have already been identified by buildSecondarySpecies.

Definition at line 300 of file PertinentGeochemicalSystem.C.

{
  if (!(minerals.size() == 1 && minerals[0] == "*"))
    return; // buildMinerals has done its job of building _mineral_info and _mineral_index
  unsigned ind = 0;
  for (const auto & name_ms : _db.getMineralSpecies(_db.mineralSpeciesNames()))
  {
    if (_kinetic_mineral_index.count(name_ms.first) == 1)
      continue;
    bool known_basis_only = true;
    for (const auto & basis_stoi : name_ms.second.basis_species)
    {
      if (_basis_index.count(basis_stoi.first) == 0 &&
          _secondary_index.count(basis_stoi.first) == 0)
      {
        known_basis_only = false;
        break;
      }
    }
    if (known_basis_only)
    {
      _mineral_index.emplace(name_ms.first, ind);
      ind += 1;
      _mineral_info.push_back(name_ms.second);
    }
  }
}

Referenced by PertinentGeochemicalSystem().

buildBasis()

void PertinentGeochemicalSystem::buildBasis ( const std::vector< std::string > &  basis_species )

private

using the basis_species list, this method builds _basis_index and _basis_info

Definition at line 95 of file PertinentGeochemicalSystem.C.

{
  unsigned ind = 0;
  for (const auto & name : basis_species)
  {
    if (ind == 0 and name != "H2O")
      mooseError("First member of basis species list must be H2O");
    if (_basis_index.count(name) == 1)
      mooseError(name, " exists more than once in the basis species list");
    _basis_index.emplace(name, ind);
    ind += 1;
    if (_db.isBasisSpecies(name))
      _basis_info.push_back(_db.getBasisSpecies({name})[name]);
    else if (_db.isRedoxSpecies(name))
    {
      const GeochemistryRedoxSpecies rs = _db.getRedoxSpecies({name})[name];
      GeochemistryBasisSpecies bs;
      bs.name = rs.name;
      bs.radius = rs.radius;
      bs.charge = rs.charge;
      bs.molecular_weight = rs.molecular_weight;
      _basis_info.push_back(bs);
    }
    else
      mooseError(name + " does not exist in the basis species or redox species in " +
                 _db.filename());
  }
}

Referenced by PertinentGeochemicalSystem().

buildGases()

void PertinentGeochemicalSystem::buildGases ( const std::vector< std::string > &  gases )

private

using the gas list, this method builds _gas_index and _gas_info

Definition at line 141 of file PertinentGeochemicalSystem.C.

{
  unsigned ind = 0;
  for (const auto & name : gases)
  {
    if (_gas_index.count(name) == 1)
      mooseError(name + " exists more than once in the gases list");
    _gas_index.emplace(name, ind);
    ind += 1;
    const GeochemistryGasSpecies gas = _db.getGasSpecies({name})[name];
    _gas_info.push_back(gas);
  }
}

Referenced by PertinentGeochemicalSystem().

buildKineticMinerals()

void PertinentGeochemicalSystem::buildKineticMinerals ( const std::vector< std::string > &  kinetic_minerals )

private

using the kinetic_minerals list, this method builds _kinetic_mineral_index and _kinetic_mineral_info

Definition at line 156 of file PertinentGeochemicalSystem.C.

{
  unsigned ind = 0;
  for (const auto & name : kinetic_minerals)
  {
    if (_kinetic_mineral_index.count(name) == 1)
      mooseError(name + " exists more than once in the kinetic_minerals list");
    if (_mineral_index.count(name) == 1)
      mooseError(name + " exists in both the minerals and kinetic_minerals lists");
    _kinetic_mineral_index.emplace(name, ind);
    ind += 1;
    _kinetic_mineral_info.push_back(_db.getMineralSpecies({name})[name]);
  }
}

Referenced by PertinentGeochemicalSystem().

buildKineticRedox()

void PertinentGeochemicalSystem::buildKineticRedox ( const std::vector< std::string > &  kinetic_redox )

private

using the kinetic_redox list, this method builds _kinetic_redox_index and _kinetic_redox_info

Definition at line 172 of file PertinentGeochemicalSystem.C.

{
  unsigned ind = 0;
  for (const auto & name : kinetic_redox)
  {
    if (_kinetic_redox_index.count(name) == 1)
      mooseError(name + " exists more than once in the kinetic_redox list");
    if (_basis_index.count(name) == 1)
      mooseError(name + " exists in both the basis_species and kinetic_redox lists");
    _kinetic_redox_index.emplace(name, ind);
    ind += 1;
    _kinetic_redox_info.push_back(_db.getRedoxSpecies({name})[name]);
  }
}

Referenced by PertinentGeochemicalSystem().

buildKineticSurface()

void PertinentGeochemicalSystem::buildKineticSurface ( const std::vector< std::string > &  kinetic_surface )

private

using the kinetic_surface list, this method builds _kinetic_surface_index and _kinetic_surface_info

Definition at line 188 of file PertinentGeochemicalSystem.C.

{
  unsigned ind = 0;
  for (const auto & name : kinetic_surface_species)
  {
    if (_kinetic_surface_index.count(name) == 1)
      mooseError(name + " exists more than once in the kinetic_surface_species list");
    _kinetic_surface_index.emplace(name, ind);
    ind += 1;
    _kinetic_surface_info.push_back(_db.getSurfaceSpecies({name})[name]);
  }
}

Referenced by PertinentGeochemicalSystem().

buildMinerals()

void PertinentGeochemicalSystem::buildMinerals ( const std::vector< std::string > &  minerals )

private

using the minerals list, this method builds _mineral_index and _mineral_info, unless minerals = {"*"}, in which case buildAllMinerals is used instead

Definition at line 125 of file PertinentGeochemicalSystem.C.

{
  unsigned ind = 0;
  if (minerals.size() == 1 && minerals[0] == "*")
    return; // buildAllMinerals is called later
  for (const auto & name : minerals)
  {
    if (_mineral_index.count(name) == 1)
      mooseError(name + " exists more than once in the minerals list");
    _mineral_index.emplace(name, ind);
    ind += 1;
    _mineral_info.push_back(_db.getMineralSpecies({name})[name]);
  }
}

Referenced by PertinentGeochemicalSystem().

buildRedoxeInfo()

void PertinentGeochemicalSystem::buildRedoxeInfo ( std::vector< Real > &  redox_e_stoichiometry, std::vector< Real > &  redox_e_log10K  )

private

Extract the stoichiometry and log10K for the _redox_e species.

This is called during createModel()

Parameters

redox_e_stoichiometry	upon exit will contain the stoichiometry for the _redox_e species
redox_e_log10K	upon exit will contain the log10K info for the _redox_e species

Definition at line 345 of file PertinentGeochemicalSystem.C.

{
  const unsigned num_basis = _basis_info.size();
  const unsigned numT = _db.getTemperatures().size();
  redox_e_stoichiometry.assign(num_basis, 0.0);
  redox_e_log10K.assign(numT, 0.0);
  for (const auto & name : _db.secondarySpeciesNames())
    if (name == _redox_e)
    {
      const GeochemistryEquilibriumSpecies ss = _db.getEquilibriumSpecies({name})[name];
      for (unsigned i = 0; i < numT; ++i)
        redox_e_log10K[i] = ss.equilibrium_const[i];
      for (const auto & react : ss.basis_species)
      {
        const Real stoi_coeff = react.second;
        if (_model.basis_species_index.count(react.first) == 1)
        {
          const unsigned col = _model.basis_species_index[react.first];
          redox_e_stoichiometry[col] += react.second;
        }
        else if (_secondary_index.count(react.first) == 1)
        {
          // reaction species is not a basis component, but a secondary component.
          // So express stoichiometry in terms of the secondary component's reaction
          const unsigned sec_row = _model.eqm_species_index[react.first];
          for (unsigned i = 0; i < numT; ++i)
            redox_e_log10K[i] += stoi_coeff * _model.eqm_log10K(sec_row, i);
          for (unsigned col = 0; col < num_basis; ++col)
            redox_e_stoichiometry[col] += stoi_coeff * _model.eqm_stoichiometry(sec_row, col);
        }
      }
    }
}

Referenced by createModel().

buildSecondarySpecies()

void PertinentGeochemicalSystem::buildSecondarySpecies ( )

private

Extract all relevant "redox couples" and "secondary species" and "surface species" from the database.

These are all species whose reaction involves only the basis_species and are not kinetically controlled or already in the basis_species list.

Definition at line 203 of file PertinentGeochemicalSystem.C.

{
  // run through all redox couples, including them if:
  // - they are not part of the kinetic_redox list
  // - they are not part of the basis_species list
  // - their reaction involves only basis_species or secondary species already encountered
  unsigned ind = 0;
  for (const auto & name : _db.redoxCoupleNames())
  {
    if (_kinetic_redox_index.count(name) == 0 && _basis_index.count(name) == 0)
    {
      const GeochemistryRedoxSpecies rs = _db.getRedoxSpecies({name})[name];
      // check all reaction species are in the basis
      bool all_species_in_basis_or_sec = true;
      for (const auto & element : rs.basis_species)
        if (_basis_index.count(element.first) == 0 && _secondary_index.count(element.first) == 0)
        {
          all_species_in_basis_or_sec = false;
          break;
        }
      if (all_species_in_basis_or_sec)
      {
        _secondary_index.emplace(name, ind);
        ind += 1;
        GeochemistryEquilibriumSpecies ss;
        ss.name = rs.name;
        ss.basis_species = rs.basis_species;
        ss.equilibrium_const = rs.equilibrium_const;
        ss.radius = rs.radius;
        ss.charge = rs.charge;
        ss.molecular_weight = rs.molecular_weight;
        _secondary_info.push_back(ss);
      }
    }
  }
 
  // run through all secondary species, including them if:
  // - their reaction involves only basis_species, or secondary species already encountered
  // - the name is not _redox_e (which is usually "e-" the free electron)
  for (const auto & name : _db.secondarySpeciesNames())
  {
    if (name == _redox_e)
      continue;
    const GeochemistryEquilibriumSpecies ss = _db.getEquilibriumSpecies({name})[name];
    // check all reaction species are in the basis
    bool all_species_in_basis_or_sec = true;
    for (const auto & element : ss.basis_species)
      if (_basis_index.count(element.first) == 0 && _secondary_index.count(element.first) == 0)
      {
        all_species_in_basis_or_sec = false;
        break;
      }
    if (all_species_in_basis_or_sec)
    {
      _secondary_index.emplace(name, ind);
      ind += 1;
      _secondary_info.push_back(ss);
    }
  }
 
  // run through all surface species, including them if:
  // - their reaction involves only basis_species or secondary species encountered so far
  // - they are not in the kinetic_surface_species list
  for (const auto & name : _db.surfaceSpeciesNames())
  {
    if (_kinetic_surface_index.count(name) == 0)
    {
      const GeochemistrySurfaceSpecies ss = _db.getSurfaceSpecies({name})[name];
      // check all reaction species are in the basis
      bool all_species_in_basis_or_sec = true;
      for (const auto & element : ss.basis_species)
        if (_basis_index.count(element.first) == 0 && _secondary_index.count(element.first) == 0)
        {
          all_species_in_basis_or_sec = false;
          break;
        }
      if (all_species_in_basis_or_sec)
      {
        GeochemistryEquilibriumSpecies to_sec;
        to_sec.name = ss.name;
        to_sec.basis_species = ss.basis_species;
        to_sec.radius = -1.5; // flag to activity calculators that activity coefficient = 1
        to_sec.charge = ss.charge;
        to_sec.molecular_weight = ss.molecular_weight;
        const Real T0 = _db.getTemperatures()[0];
        for (const auto & temp : _db.getTemperatures())
          to_sec.equilibrium_const.push_back(ss.log10K + ss.dlog10KdT * (temp - T0));
 
        _secondary_index.emplace(name, ind);
        ind += 1;
        _secondary_info.push_back(to_sec);
      }
    }
  }
}

Referenced by PertinentGeochemicalSystem().

checkGases()

void PertinentGeochemicalSystem::checkGases ( ) const

private

Check that all gases in the "gases" list have reactions that involve only the basis_species or secondary_species.

Definition at line 398 of file PertinentGeochemicalSystem.C.

{
  for (const auto & gas : _gas_info)
    for (const auto & element : gas.basis_species)
      if (_basis_index.count(element.first) == 0 && _secondary_index.count(element.first) == 0)
        mooseError("The reaction for " + gas.name + " depends on " + element.first +
                   " which is not reducable to a set of basis species");
}

Referenced by PertinentGeochemicalSystem().

checkKineticRedox()

void PertinentGeochemicalSystem::checkKineticRedox ( ) const

private

Check that all kinetic redox species in the _kinetic_redox list have reactions that involve only the basis_species or secondary_species.

Definition at line 408 of file PertinentGeochemicalSystem.C.

{
  for (const auto & kr : _kinetic_redox_info)
    for (const auto & element : kr.basis_species)
      if (_basis_index.count(element.first) == 0 && _secondary_index.count(element.first) == 0)
        mooseError("The reaction for " + kr.name + " depends on " + element.first +
                   " which is not reducable to a set of basis species");
}

Referenced by PertinentGeochemicalSystem().

checkKineticSurfaceSpecies()

void PertinentGeochemicalSystem::checkKineticSurfaceSpecies ( ) const

private

Check that all kinetic surface species in the _kinetic_surface_species list have reactions that involve only the basis_species or secondary_species.

Definition at line 418 of file PertinentGeochemicalSystem.C.

{
  for (const auto & kr : _kinetic_surface_info)
    for (const auto & element : kr.basis_species)
      if (_basis_index.count(element.first) == 0 && _secondary_index.count(element.first) == 0)
        mooseError("The reaction for " + kr.name + " depends on " + element.first +
                   " which is not reducable to a set of basis species");
}

Referenced by PertinentGeochemicalSystem().

checkMinerals()

void PertinentGeochemicalSystem::checkMinerals ( const std::vector< GeochemistryMineralSpecies > &  mineral_info ) const

private

Check that all minerals in mineral_info have reactions that involve only the basis_species or secondary_species.

Check that if a mineral in this list is also a "sorbing mineral", its sorbing sites are present in the basis_species list

Definition at line 381 of file PertinentGeochemicalSystem.C.

{
  for (const auto & mineral : mineral_info)
  {
    for (const auto & element : mineral.basis_species)
      if (_basis_index.count(element.first) == 0 && _secondary_index.count(element.first) == 0)
        mooseError("The reaction for " + mineral.name + " depends on " + element.first +
                   " which is not reducable to a set of basis species");
    for (const auto & element : mineral.sorption_sites)
      if (_basis_index.count(element.first) == 0)
        mooseError("The sorbing sites for " + mineral.name + " include " + element.first +
                   " which is not in the basis_species list");
  }
}

Referenced by PertinentGeochemicalSystem().

checkRedoxe()

bool PertinentGeochemicalSystem::checkRedoxe ( )

private

Returns

true if _redox_e appears as a secondary species in the database and that its stoichiometry can be expressed in terms of basis species

Definition at line 329 of file PertinentGeochemicalSystem.C.

{
  bool found = false;
  for (const auto & name : _db.secondarySpeciesNames())
    if (name == _redox_e)
    {
      found = true;
      const GeochemistryEquilibriumSpecies ss = _db.getEquilibriumSpecies({name})[name];
      for (const auto & element : ss.basis_species)
        if (_basis_index.count(element.first) == 0 && _secondary_index.count(element.first) == 0)
          return false;
    }
  return found;
}

Referenced by createModel().

createModel()

void PertinentGeochemicalSystem::createModel ( )

private

Fully populate the ModelGeochemicalDatabase.

Definition at line 428 of file PertinentGeochemicalSystem.C.

{
  const unsigned num_rows = _secondary_info.size() + _mineral_info.size() + _gas_info.size();
  const unsigned num_cols = _basis_info.size();
  const unsigned num_temperatures = _db.getTemperatures().size();
  unsigned ind = 0;
 
  // create basis_species_index map
  _model.basis_species_index = _basis_index;
 
  // extract the names
  _model.basis_species_name = std::vector<std::string>(num_cols);
  for (const auto & species : _basis_info)
    _model.basis_species_name[_model.basis_species_index[species.name]] = species.name;
 
  // initially no basis species are minerals
  _model.basis_species_mineral = std::vector<bool>(num_cols, false);
 
  // initially no basis species are gases
  _model.basis_species_gas = std::vector<bool>(num_cols, false);
 
  // initially all basis species are involved in transport (this gets modified for surface species
  // below)
  _model.basis_species_transported = std::vector<bool>(num_cols, true);
 
  // record the charge
  _model.basis_species_charge = std::vector<Real>(num_cols, 0.0);
  for (const auto & species : _basis_info)
    _model.basis_species_charge[_model.basis_species_index[species.name]] = species.charge;
 
  // record the ionic radius
  _model.basis_species_radius = std::vector<Real>(num_cols, 0.0);
  for (const auto & species : _basis_info)
    _model.basis_species_radius[_model.basis_species_index[species.name]] = species.radius;
 
  // record the molecular weight
  _model.basis_species_molecular_weight = std::vector<Real>(num_cols, 0.0);
  for (const auto & species : _basis_info)
    _model.basis_species_molecular_weight[_model.basis_species_index[species.name]] =
        species.molecular_weight;
 
  // record the molecular weight (zero for all species except minerals)
  _model.basis_species_molecular_volume = std::vector<Real>(num_cols, 0.0);
 
  // the "eqm_species" stuff is rather long-winded because of the different data structures used
  // to hold secondary, mineral and gas info.  There is a bit of an overlap, however, so let's
  // create a new data structure that contains that overlapping info
 
  std::vector<GeochemistryEquilibriumSpecies> overlap(_secondary_info);
  for (const auto & species : _mineral_info)
  {
    GeochemistryEquilibriumSpecies es;
    es.name = species.name;
    es.molecular_weight = species.molecular_weight;
    es.equilibrium_const = species.equilibrium_const;
    es.basis_species = species.basis_species;
    overlap.push_back(es);
  }
  for (const auto & species : _gas_info)
  {
    GeochemistryEquilibriumSpecies es;
    es.name = species.name;
    es.molecular_weight = species.molecular_weight;
    es.equilibrium_const = species.equilibrium_const;
    es.basis_species = species.basis_species;
    overlap.push_back(es);
  }
 
  // create the eqm_species_index map
  ind = 0;
  for (const auto & species : overlap)
    _model.eqm_species_index[species.name] = ind++;
 
  // extract the names
  _model.eqm_species_name = std::vector<std::string>(num_rows);
  for (const auto & species : _model.eqm_species_index)
    _model.eqm_species_name[species.second] = species.first;
 
  // create the eqm_species_mineral vector
  _model.eqm_species_mineral = std::vector<bool>(num_rows, false);
  for (const auto & species : _mineral_info)
    _model.eqm_species_mineral[_model.eqm_species_index[species.name]] = true;
  for (const auto & species : _gas_info)
    _model.eqm_species_mineral[_model.eqm_species_index[species.name]] = false;
 
  // create the eqm_species_gas vector
  _model.eqm_species_gas = std::vector<bool>(num_rows, false);
  for (const auto & species : _mineral_info)
    _model.eqm_species_gas[_model.eqm_species_index[species.name]] = false;
  for (const auto & species : _gas_info)
    _model.eqm_species_gas[_model.eqm_species_index[species.name]] = true;
 
  // create the eqm_species_transported vector (true for non-minerals) - gets modified below for
  // surface species
  _model.eqm_species_transported = std::vector<bool>(num_rows, true);
  for (const auto & species : _mineral_info)
    _model.eqm_species_transported[_model.eqm_species_index.at(species.name)] = false;
 
  // record the charge
  _model.eqm_species_charge =
      std::vector<Real>(num_rows, 0.0); // charge of gases and minerals is zero
  for (const auto & species : _secondary_info)
    _model.eqm_species_charge[_model.eqm_species_index[species.name]] = species.charge;
 
  // record the radius
  _model.eqm_species_radius =
      std::vector<Real>(num_rows, 0.0); // ionic radius of gases and minerals is zero
  for (const auto & species : _secondary_info)
    _model.eqm_species_radius[_model.eqm_species_index[species.name]] = species.radius;
 
  // record the molecular weight
  _model.eqm_species_molecular_weight = std::vector<Real>(num_rows, 0.0);
  for (const auto & species : overlap)
    _model.eqm_species_molecular_weight[_model.eqm_species_index[species.name]] =
        species.molecular_weight;
 
  // record the molecular volume (zero for all species except minerals)
  _model.eqm_species_molecular_volume = std::vector<Real>(num_rows, 0.0);
  for (const auto & species : _mineral_info)
    _model.eqm_species_molecular_volume[_model.eqm_species_index[species.name]] =
        species.molecular_volume;
 
  // record surface-complexation info
  for (const auto & species : _mineral_info)
    if (species.surface_area != 0.0)
    {
      SurfaceComplexationInfo sci;
      sci.surface_area = species.surface_area;
      sci.sorption_sites = species.sorption_sites;
      _model.surface_complexation_info[species.name] = sci;
    }
  for (const auto & species : _kinetic_mineral_info)
    if (species.surface_area != 0.0)
    {
      SurfaceComplexationInfo sci;
      sci.surface_area = species.surface_area;
      sci.sorption_sites = species.sorption_sites;
      _model.surface_complexation_info[species.name] = sci;
    }
 
  // record gas fugacity info
  for (const auto & species : _gas_info)
    _model.gas_chi[species.name] = species.chi;
 
  // create the stoichiometry matrix
  _model.eqm_stoichiometry.resize(num_rows, num_cols);
  _model.eqm_log10K.resize(num_rows, num_temperatures);
 
  // populate the stoichiometry
  for (const auto & species : overlap)
  {
    const unsigned row = _model.eqm_species_index[species.name];
    for (unsigned i = 0; i < num_temperatures; ++i)
      _model.eqm_log10K(row, i) = species.equilibrium_const[i];
    for (const auto & react : species.basis_species)
    {
      const Real stoi_coeff = react.second;
      if (_model.basis_species_index.count(react.first) == 1)
      {
        const unsigned col = _model.basis_species_index[react.first];
        _model.eqm_stoichiometry(row, col) += react.second;
      }
      else if (_secondary_index.count(react.first) == 1)
      {
        // reaction species is not a basis component, but a secondary component.
        // So express stoichiometry in terms of the secondary component's reaction
        const unsigned sec_row = _model.eqm_species_index[react.first];
        for (unsigned i = 0; i < num_temperatures; ++i)
          _model.eqm_log10K(row, i) += stoi_coeff * _model.eqm_log10K(sec_row, i);
        for (unsigned col = 0; col < num_cols; ++col)
          _model.eqm_stoichiometry(row, col) += stoi_coeff * _model.eqm_stoichiometry(sec_row, col);
      }
      else
        mooseError("Species " + species.name + " includes " + react.first +
                   ", which cannot be expressed in terms of the basis.  Previous checks must be "
                   "erroneous!");
    }
  }
 
  // Build the redox information, if any.  Here we express any O2(aq) in the redox equations in
  // terms of redox_e (which is usually e-)
  _model.redox_lhs = _redox_e;
  std::vector<Real> redox_e_stoichiometry(num_cols, 0.0);
  std::vector<Real> redox_e_log10K(num_temperatures, 0.0);
  std::vector<Real> redox_stoi;
  std::vector<Real> redox_log10K;
  if ((_model.basis_species_index.count(_redox_ox) == 1) && checkRedoxe())
  {
    // construct the stoichiometry and log10K for _redox_e and put it
    buildRedoxeInfo(redox_e_stoichiometry, redox_e_log10K);
    redox_stoi.insert(redox_stoi.end(), redox_e_stoichiometry.begin(), redox_e_stoichiometry.end());
    redox_log10K.insert(redox_log10K.end(), redox_e_log10K.begin(), redox_e_log10K.end());
    // the electron reaction is
    // e- = nuw_i * basis_i + beta * O2(aq), where we've pulled out the O2(aq) because it's
    // special
    const unsigned o2_index = _model.basis_species_index.at(_redox_ox);
    const Real beta = redox_e_stoichiometry[o2_index];
    if (beta != 0.0)
    {
      for (const auto & bs : _model.basis_species_index)
        if (_db.isRedoxSpecies(bs.first))
        {
          // this basis species is a redox couple in disequilibrium
          const GeochemistryRedoxSpecies rs = _db.getRedoxSpecies({bs.first})[bs.first];
          // check that its reaction involves only basis species, and record the stoichiometry in
          // the current basis
          std::vector<Real> stoi(num_cols, 0.0);
          bool only_involves_basis_species = true;
          for (const auto & name_stoi : rs.basis_species)
          {
            if (_model.basis_species_index.count(name_stoi.first) == 1)
              stoi[_model.basis_species_index.at(name_stoi.first)] = name_stoi.second;
            else
            {
              only_involves_basis_species = false;
              break;
            }
          }
          if (!only_involves_basis_species)
            continue;
          // Reaction is now
          // redox = nu_i * basis_i + alpha * O2(aq), where we've pulled the O2(aq) out because
          // it's special. Now pull the redox couple to the RHS of the reaction, so we have 0 =
          // -redox + nu_i * basis_i + alpha * O2(aq)
          stoi[bs.second] = -1.0;
          // check that the stoichiometry involves O2(aq)
          const Real alpha = stoi[o2_index];
          if (alpha == 0.0)
            continue;
          // multiply equation -beta/alpha so it reads
          // 0 = -beta/alpha * (-redox + nu_i * basis_i) - beta * O2(aq)
          for (unsigned basis_i = 0; basis_i < num_cols; ++basis_i)
            stoi[basis_i] *= -beta / alpha;
          // add the equation to e- = nuw_i * basis_i + beta * O2(aq)
          for (unsigned basis_i = 0; basis_i < num_cols; ++basis_i)
            stoi[basis_i] += redox_e_stoichiometry[basis_i];
          // now the reation is e- = nuw_i * basis_i - beta/alpha * (-redox + nu_i * basis_i)
          redox_stoi.insert(redox_stoi.end(), stoi.begin(), stoi.end());
 
          // record the equilibrium constants
          for (unsigned temp = 0; temp < num_temperatures; ++temp)
            redox_log10K.push_back((-beta / alpha) * rs.equilibrium_const[temp] +
                                   redox_e_log10K[temp]);
        }
    }
  }
  // record the above in the model.redox_stoichiometry and model.redox_log10K DenseMatrices
  const unsigned num_redox = redox_stoi.size() / num_cols;
  _model.redox_stoichiometry.resize(num_redox, num_cols);
  for (unsigned red = 0; red < num_redox; ++red)
    for (unsigned basis_i = 0; basis_i < num_cols; ++basis_i)
      _model.redox_stoichiometry(red, basis_i) = redox_stoi[red * num_cols + basis_i];
  _model.redox_log10K.resize(num_redox, num_temperatures);
  for (unsigned red = 0; red < num_redox; ++red)
    for (unsigned temp = 0; temp < num_temperatures; ++temp)
      _model.redox_log10K(red, temp) = redox_log10K[red * num_temperatures + temp];
 
  // To build the kin_species_index, kin_species_name, etc, let's build an "overlap", similar to
  // above
  std::vector<GeochemistryMineralSpecies> overlap_kin(_kinetic_mineral_info);
  for (const auto & species : _kinetic_redox_info)
  {
    GeochemistryMineralSpecies ms;
    ms.name = species.name;
    ms.molecular_volume = 0.0;
    ms.basis_species = species.basis_species;
    ms.molecular_weight = species.molecular_weight;
    ms.equilibrium_const = species.equilibrium_const;
    overlap_kin.push_back(ms);
  }
  for (const auto & species : _kinetic_surface_info)
  {
    GeochemistryMineralSpecies ms;
    ms.name = species.name;
    ms.molecular_volume = 0.0;
    ms.basis_species = species.basis_species;
    ms.molecular_weight = species.molecular_weight;
    const Real T0 = _db.getTemperatures()[0];
    for (const auto & temp : _db.getTemperatures())
      ms.equilibrium_const.push_back(species.log10K + species.dlog10KdT * (temp - T0));
    overlap_kin.push_back(ms);
  }
  const unsigned num_kin = overlap_kin.size();
 
  // create the kin_species_index map
  ind = 0;
  for (const auto & species : overlap_kin)
    _model.kin_species_index[species.name] = ind++;
 
  // extract the names
  _model.kin_species_name = std::vector<std::string>(num_kin);
  for (const auto & species : _model.kin_species_index)
    _model.kin_species_name[species.second] = species.first;
 
  // build the kin_species_mineral info
  _model.kin_species_mineral = std::vector<bool>(num_kin, true);
  for (const auto & species : _kinetic_redox_info)
    _model.kin_species_mineral[_model.kin_species_index[species.name]] = false;
  for (const auto & species : _kinetic_surface_info)
    _model.kin_species_mineral[_model.kin_species_index[species.name]] = false;
 
  // create the kin_species_transported vector (false for minerals and surface species)
  _model.kin_species_transported = std::vector<bool>(num_kin, true);
  for (const auto & species : _kinetic_mineral_info)
    _model.kin_species_transported[_model.kin_species_index.at(species.name)] = false;
  for (const auto & species : _kinetic_surface_info)
    _model.kin_species_transported[_model.kin_species_index.at(species.name)] = false;
 
  // build the kin_species_charge info
  _model.kin_species_charge = std::vector<Real>(num_kin, 0.0);
  for (const auto & species : _kinetic_redox_info)
    _model.kin_species_charge[_model.kin_species_index[species.name]] = species.charge;
  for (const auto & species : _kinetic_surface_info)
    _model.kin_species_charge[_model.kin_species_index[species.name]] = species.charge;
 
  // extract the molecular weight
  _model.kin_species_molecular_weight = std::vector<Real>(num_kin, 0.0);
  for (const auto & species : overlap_kin)
    _model.kin_species_molecular_weight[_model.kin_species_index[species.name]] =
        species.molecular_weight;
 
  // extract the molecular volume
  _model.kin_species_molecular_volume = std::vector<Real>(num_kin, 0.0);
  for (const auto & species : overlap_kin)
    _model.kin_species_molecular_volume[_model.kin_species_index[species.name]] =
        species.molecular_volume;
 
  // extract the stoichiometry
  _model.kin_stoichiometry.resize(num_kin, num_cols);
  _model.kin_log10K.resize(num_kin, num_temperatures);
 
  // populate the stoichiometry
  for (const auto & species : overlap_kin)
  {
    const unsigned row = _model.kin_species_index[species.name];
    for (unsigned i = 0; i < num_temperatures; ++i)
      _model.kin_log10K(row, i) = species.equilibrium_const[i];
    for (const auto & react : species.basis_species)
    {
      const Real stoi_coeff = react.second;
      if (_model.basis_species_index.count(react.first) == 1)
      {
        const unsigned col = _model.basis_species_index[react.first];
        _model.kin_stoichiometry(row, col) += react.second;
      }
      else if (_model.eqm_species_index.count(react.first) == 1)
      {
        // reaction species is not a basis component, but a secondary component.
        // So express stoichiometry in terms of the secondary component's reaction
        const unsigned sec_row = _model.eqm_species_index[react.first];
        for (unsigned i = 0; i < num_temperatures; ++i)
          _model.kin_log10K(row, i) += stoi_coeff * _model.eqm_log10K(sec_row, i);
        for (unsigned col = 0; col < num_cols; ++col)
          _model.kin_stoichiometry(row, col) += stoi_coeff * _model.eqm_stoichiometry(sec_row, col);
      }
      else
        mooseError("Kinetic species " + species.name + " includes " + react.first +
                   ", which cannot be expressed in terms of the basis.  Previous checks must be "
                   "erroneous!");
    }
  }
 
  // check that there are no repeated sorbing sites in the SurfaceComplexationInfo
  std::vector<std::string> all_sorbing_sites;
  for (const auto & name_info : _model.surface_complexation_info)
    for (const auto & name_frac : name_info.second.sorption_sites)
      if (std::find(all_sorbing_sites.begin(), all_sorbing_sites.end(), name_frac.first) !=
          all_sorbing_sites.end())
        mooseError(
            "The sorbing site ", name_frac.first, " appears in more than one sorbing mineral");
      else
        all_sorbing_sites.push_back(name_frac.first);
 
  // build the information related to surface sorption, and modify the species_transported vectors
  _model.surface_sorption_related.assign(num_rows, false);
  _model.surface_sorption_number.assign(num_rows, 99);
  for (const auto & name_info :
       _model.surface_complexation_info) // all minerals involved in surface complexation
  {
    for (const auto & name_frac :
         name_info.second.sorption_sites) // all sorption sites on the given mineral
    {
      const unsigned basis_index_of_sorption_site = _model.basis_species_index.at(name_frac.first);
      _model.basis_species_transported[basis_index_of_sorption_site] = false;
    }
    bool mineral_involved_in_eqm = false;
    for (const auto & name_frac :
         name_info.second.sorption_sites) // all sorption sites on the given mineral
    {
      const unsigned basis_index_of_sorption_site = _model.basis_species_index.at(name_frac.first);
      for (unsigned j = 0; j < num_rows; ++j) // all equilibrium species
        if (_model.eqm_stoichiometry(j, basis_index_of_sorption_site) != 0.0)
        {
          mineral_involved_in_eqm = true;
          break;
        }
    }
    if (!mineral_involved_in_eqm)
      continue;
    const unsigned num_surface_sorption = _model.surface_sorption_name.size();
    _model.surface_sorption_name.push_back(name_info.first);
    _model.surface_sorption_area.push_back(name_info.second.surface_area);
    for (const auto & name_frac :
         name_info.second.sorption_sites) // all sorption sites on the given mineral
    {
      const unsigned basis_index_of_sorption_site = _model.basis_species_index.at(name_frac.first);
      for (unsigned j = 0; j < num_rows; ++j) // all equilibrium species
        if (_model.eqm_stoichiometry(j, basis_index_of_sorption_site) != 0.0)
        {
          if (_model.surface_sorption_related[j])
            mooseError("It is an error for any equilibrium species (such as ",
                       _model.eqm_species_name[j],
                       ") to have a reaction involving more than one sorbing site");
          _model.surface_sorption_related[j] = true;
          _model.surface_sorption_number[j] = num_surface_sorption;
          _model.eqm_species_transported[j] = false;
        }
    }
  }
}

Referenced by PertinentGeochemicalSystem().

getIndexOfOriginalBasisSpecies()

unsigned PertinentGeochemicalSystem::getIndexOfOriginalBasisSpecies

(

const std::string &

name

)

const

Parameters

name	species name

Returns

the index of the species in the original basis

Definition at line 69 of file PertinentGeochemicalSystem.C.

{
  try
  {
    return _basis_index.at(name);
  }
  catch (const std::out_of_range &)
  {
    mooseError("species ", name, " is not in the original basis");
  }
  catch (...)
  {
    throw;
  }
}

Referenced by GeochemistryQuantityAux::computeValue(), GeochemistryQuantityAux::GeochemistryQuantityAux(), and TEST().

modelGeochemicalDatabase()

const ModelGeochemicalDatabase & PertinentGeochemicalSystem::modelGeochemicalDatabase

(

)

const

Return a reference to the ModelGeochemicalDatabase structure.

Definition at line 850 of file PertinentGeochemicalSystem.C.

{
  return _model;
}

Referenced by GeochemistryQuantityAux::GeochemistryQuantityAux(), GeochemicalModelDefinition::getDatabase(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

originalBasisNames()

std::vector< std::string > PertinentGeochemicalSystem::originalBasisNames

(

)

const

Returns

a vector of names of the original basis species

Definition at line 86 of file PertinentGeochemicalSystem.C.

{
  std::vector<std::string> names(_basis_info.size());
  for (const auto & name_ind : _basis_index)
    names[name_ind.second] = name_ind.first;
  return names;
}

Referenced by GeochemistryConsoleOutput::output(), TEST(), and TEST_F().

Member Data Documentation

_basis_index

std::unordered_map<std::string, unsigned> PertinentGeochemicalSystem::_basis_index

private

given a species name, return its index in the corresponding "info" std::vector

Definition at line 490 of file PertinentGeochemicalSystem.h.

Referenced by buildAllMinerals(), buildBasis(), buildKineticRedox(), buildSecondarySpecies(), checkGases(), checkKineticRedox(), checkKineticSurfaceSpecies(), checkMinerals(), checkRedoxe(), createModel(), getIndexOfOriginalBasisSpecies(), and originalBasisNames().

_basis_info

std::vector<GeochemistryBasisSpecies> PertinentGeochemicalSystem::_basis_info

private

a vector of all relevant species

Definition at line 493 of file PertinentGeochemicalSystem.h.

Referenced by buildBasis(), buildRedoxeInfo(), createModel(), and originalBasisNames().

_db

GeochemicalDatabaseReader PertinentGeochemicalSystem::_db

private

The database.

Definition at line 487 of file PertinentGeochemicalSystem.h.

Referenced by buildAllMinerals(), buildBasis(), buildGases(), buildKineticMinerals(), buildKineticRedox(), buildKineticSurface(), buildMinerals(), buildRedoxeInfo(), buildSecondarySpecies(), checkRedoxe(), and createModel().

_gas_index

std::unordered_map<std::string, unsigned> PertinentGeochemicalSystem::_gas_index

private

given a species name, return its index in the corresponding "info" std::vector

Definition at line 502 of file PertinentGeochemicalSystem.h.

Referenced by buildGases().

_gas_info

std::vector<GeochemistryGasSpecies> PertinentGeochemicalSystem::_gas_info

private

a vector of all relevant species

Definition at line 505 of file PertinentGeochemicalSystem.h.

Referenced by buildGases(), checkGases(), and createModel().

_kinetic_mineral_index

std::unordered_map<std::string, unsigned> PertinentGeochemicalSystem::_kinetic_mineral_index

private

given a species name, return its index in the corresponding "info" std::vector

Definition at line 508 of file PertinentGeochemicalSystem.h.

Referenced by buildAllMinerals(), and buildKineticMinerals().

_kinetic_mineral_info

std::vector<GeochemistryMineralSpecies> PertinentGeochemicalSystem::_kinetic_mineral_info

private

a vector of all relevant species

Definition at line 511 of file PertinentGeochemicalSystem.h.

Referenced by buildKineticMinerals(), createModel(), and PertinentGeochemicalSystem().

_kinetic_redox_index

std::unordered_map<std::string, unsigned> PertinentGeochemicalSystem::_kinetic_redox_index

private

given a species name, return its index in the corresponding "info" std::vector

Definition at line 514 of file PertinentGeochemicalSystem.h.

Referenced by buildKineticRedox(), and buildSecondarySpecies().

_kinetic_redox_info

std::vector<GeochemistryRedoxSpecies> PertinentGeochemicalSystem::_kinetic_redox_info

private

a vector of all relevant species

Definition at line 517 of file PertinentGeochemicalSystem.h.

Referenced by buildKineticRedox(), checkKineticRedox(), and createModel().

_kinetic_surface_index

std::unordered_map<std::string, unsigned> PertinentGeochemicalSystem::_kinetic_surface_index

private

given a species name, return its index in the corresponding "info" std::vector

Definition at line 520 of file PertinentGeochemicalSystem.h.

Referenced by buildKineticSurface(), and buildSecondarySpecies().

_kinetic_surface_info

std::vector<GeochemistrySurfaceSpecies> PertinentGeochemicalSystem::_kinetic_surface_info

private

a vector of all relevant species

Definition at line 523 of file PertinentGeochemicalSystem.h.

Referenced by buildKineticSurface(), checkKineticSurfaceSpecies(), and createModel().

_mineral_index

std::unordered_map<std::string, unsigned> PertinentGeochemicalSystem::_mineral_index

private

given a species name, return its index in the corresponding "info" std::vector

Definition at line 496 of file PertinentGeochemicalSystem.h.

Referenced by buildAllMinerals(), buildKineticMinerals(), and buildMinerals().

_mineral_info

std::vector<GeochemistryMineralSpecies> PertinentGeochemicalSystem::_mineral_info

private

a vector of all relevant species

Definition at line 499 of file PertinentGeochemicalSystem.h.

Referenced by buildAllMinerals(), buildMinerals(), createModel(), and PertinentGeochemicalSystem().

_model

ModelGeochemicalDatabase PertinentGeochemicalSystem::_model

private

The important datastructure built by this class.

Definition at line 541 of file PertinentGeochemicalSystem.h.

Referenced by addKineticRate(), buildRedoxeInfo(), createModel(), and modelGeochemicalDatabase().

_redox_e

const std::string PertinentGeochemicalSystem::_redox_e

private

The name of the free electron involved in redox reactions.

Definition at line 538 of file PertinentGeochemicalSystem.h.

Referenced by buildRedoxeInfo(), buildSecondarySpecies(), checkRedoxe(), and createModel().

_redox_ox

const std::string PertinentGeochemicalSystem::_redox_ox

private

The name of the oxygen in all disequilibrium-redox equations, eg O2(aq), which must be a basis species if disequilibrium redox reactions are to be recorded.

Definition at line 535 of file PertinentGeochemicalSystem.h.

Referenced by createModel().

_secondary_index

std::unordered_map<std::string, unsigned> PertinentGeochemicalSystem::_secondary_index

private

given a species name, return its index in the corresponding "info" std::vector

Definition at line 526 of file PertinentGeochemicalSystem.h.

Referenced by buildAllMinerals(), buildRedoxeInfo(), buildSecondarySpecies(), checkGases(), checkKineticRedox(), checkKineticSurfaceSpecies(), checkMinerals(), checkRedoxe(), and createModel().

_secondary_info

std::vector<GeochemistryEquilibriumSpecies> PertinentGeochemicalSystem::_secondary_info

private

a vector of all relevant species

Definition at line 529 of file PertinentGeochemicalSystem.h.

Referenced by buildSecondarySpecies(), and createModel().

---

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

• geochemistry/include/utils/PertinentGeochemicalSystem.h
• geochemistry/src/utils/PertinentGeochemicalSystem.C