GeochemicalDatabaseReader Class Reference

Class for reading geochemical reactions from a MOOSE geochemical database. More...

#include <GeochemicalDatabaseReader.h>

Public Member Functions
	GeochemicalDatabaseReader (const FileName filename, const bool reexpress_free_electron=true, const bool use_piecewise_interpolation=false, const bool remove_all_extrapolated_secondary_species=false)
	Parse the file.
void	read (const FileName filename)
	Parse the thermodynamic database.
void	validate (const FileName filename, const nlohmann::json &db)
	Validate the thermodynamic database.
void	reexpressFreeElectron ()
	Sometimes the free electron's equilibrium reaction is defined in terms of O2(g) which is not a basis species.
std::string	getActivityModel () const
	Get the activity model type.
std::string	getFugacityModel () const
	Get the fugacity model type.
std::string	getLogKModel () const
	Get the equilibrium constant model type.
std::vector< std::string >	getBasisSpeciesNames () const
	Get the list of basis (primary) species read from database.
std::vector< std::string >	getEquilibriumSpeciesNames () const
	Get the list of secondary equilibrium species read from database.
std::vector< std::string >	getMineralSpeciesNames () const
	Get the list of secondary mineral species read from database.
const std::vector< Real > &	getTemperatures () const
	Get the temperature points that the equilibrium constant is defined at.
std::vector< Real >	getPressures ()
	Get the pressure points that the equilibrium constant is defined at.
const GeochemistryDebyeHuckel &	getDebyeHuckel () const
	Get the Debye-Huckel activity coefficients.
std::map< std::string, GeochemistryBasisSpecies >	getBasisSpecies (const std::vector< std::string > &names)
	Get the basis (primary) species information.
std::map< std::string, GeochemistryEquilibriumSpecies >	getEquilibriumSpecies (const std::vector< std::string > &names)
	Get the secondary equilibrium species information.
std::map< std::string, GeochemistryMineralSpecies >	getMineralSpecies (const std::vector< std::string > &names)
	Get the mineral species information.
std::map< std::string, GeochemistryElements >	getElements ()
	Get all the elements.
std::map< std::string, GeochemistryGasSpecies >	getGasSpecies (const std::vector< std::string > &names)
	Get the gas species information.
std::map< std::string, GeochemistryRedoxSpecies >	getRedoxSpecies (const std::vector< std::string > &names)
	Get the redox species (couples) information.
std::map< std::string, GeochemistryOxideSpecies >	getOxideSpecies (const std::vector< std::string > &names)
	Get the oxide species information.
std::map< std::string, GeochemistrySurfaceSpecies >	getSurfaceSpecies (const std::vector< std::string > &names)
	Get the surface sorbing species information.
const std::map< std::string, GeochemistryNeutralSpeciesActivity > &	getNeutralSpeciesActivity () const
	Get the neutral species activity coefficients.
std::vector< std::string >	equilibriumReactions (const std::vector< std::string > &names) const
	Generates a formatted vector of strings representing all aqueous equilibrium reactions.
std::vector< std::string >	mineralReactions (const std::vector< std::string > &names) const
	Generates a formatted vector of strings representing all mineral reactions.
std::vector< std::string >	gasReactions (const std::vector< std::string > &names) const
	Generates a formatted vector of strings representing all gas reactions.
std::vector< std::string >	redoxReactions (const std::vector< std::string > &names) const
	Generates a formatted vector of strings representing all redox reactions.
std::vector< std::string >	oxideReactions (const std::vector< std::string > &names) const
	Generates a formatted vector of strings representing all oxide reactions.
std::string	getSpeciesData (const std::string name) const
	String representation of JSON species object contents.
const FileName &	filename () const
	Filename of database.
bool	isSecondarySpecies (const std::string &name) const
	Returns true if name is a "secondary species" or "free electron" in the database.
bool	isBasisSpecies (const std::string &name) const
	Checks if species is of given type.
bool	isRedoxSpecies (const std::string &name) const
bool	isGasSpecies (const std::string &name) const
bool	isMineralSpecies (const std::string &name) const
bool	isOxideSpecies (const std::string &name) const
bool	isSurfaceSpecies (const std::string &name) const
bool	isSorbingMineral (const std::string &name) const
	returns True iff name is the name of a sorbing mineral
std::vector< std::string >	mineralSpeciesNames () const
	Returns a list of all the names of the "mineral species" in the database.
std::vector< std::string >	secondarySpeciesNames () const
	Returns a list of all the names of the "secondary species" and "free electron" in the database.
std::vector< std::string >	redoxCoupleNames () const
	Returns a list of all the names of the "redox couples" in the database.
std::vector< std::string >	surfaceSpeciesNames () const
	Returns a list of all the names of the "surface species" in the database.

Protected Member Functions
void	removeExtrapolatedSecondarySpecies ()
	After parsing the database file, remove any secondary species that have extrapolated equilibrium constants.
void	setTemperatures ()
	Copy the temperature points (if any) found in the database into _temperature_points.
void	setDebyeHuckel ()
	Copy the Debye-Huckel parameters (if any) found in the database into _debye_huckel.
void	setNeutralSpeciesActivity ()
	Copy the Debye-Huckel parameters for computing neutral species activity (if any) found in the database into _neutral_species_activity.

Static Protected Member Functions
static Real	getReal (const nlohmann::json &node)

Protected Attributes
const FileName	_filename
	Database filename.
nlohmann::json	_root
	JSON data.
std::vector< std::string >	_bs_names
	List of basis (primary) species names read from database.
std::vector< std::string >	_es_names
	List of secondary equilibrium species to read from database.
std::vector< std::string >	_ms_names
	List of secondary mineral species to read from database.
std::vector< Real >	_temperature_points
	Temperature points in database.
std::vector< Real >	_pressure_points
	Pressure points in database.
std::map< std::string, GeochemistryElements >	_elements
	Elements and their molecular weight read from the database.
std::map< std::string, GeochemistryBasisSpecies >	_basis_species
	Basis species data read from the database.
std::map< std::string, GeochemistryEquilibriumSpecies >	_equilibrium_species
	Secondary equilibrium species and free electron data read from the database.
std::map< std::string, GeochemistryMineralSpecies >	_mineral_species
	Mineral species data read from the database.
std::map< std::string, GeochemistryGasSpecies >	_gas_species
	Gas species data read from the database.
std::map< std::string, GeochemistryRedoxSpecies >	_redox_species
	Redox species (couples) data read from the database.
std::map< std::string, GeochemistryOxideSpecies >	_oxide_species
	Oxide species data read from the database.
std::map< std::string, GeochemistrySurfaceSpecies >	_surface_species
	Surface sorbing species data read from the database.
GeochemistryDebyeHuckel	_debye_huckel
	Debye-Huckel activity coefficients.
std::map< std::string, GeochemistryNeutralSpeciesActivity >	_neutral_species_activity
	Neutral species activity coefficients.

Private Member Functions
std::vector< std::string >	printReactions (const std::vector< std::string > &names, const std::vector< std::map< std::string, Real > > &basis_species) const
	Generates a formatted vector of strings representing all reactions.

Detailed Description

Class for reading geochemical reactions from a MOOSE geochemical database.

Definition at line 215 of file GeochemicalDatabaseReader.h.

Constructor & Destructor Documentation

GeochemicalDatabaseReader()

GeochemicalDatabaseReader::GeochemicalDatabaseReader	(	const FileName	filename,
		const bool	reexpress_free_electron = true,
		const bool	use_piecewise_interpolation = false,
		const bool	remove_all_extrapolated_secondary_species = false
	)

Parse the file.

Parameters

filename	Moose geochemical database file
reexpress_free_electron	If true, and if the free electron in the database file has an equilibrium reaction expressed in terms of O2(g), and O2(g) exists as a gas in the database file, and O2(g)'s equilibrium reaction is O2(g)=O2(eq), and O2(aq) exists as a basis species in the database file, then reexpress the free electron's equilibrium reaction in terms of O2(aq)
use_piecewise_interpolation	If true then set the "logk model" to "piecewise-linear" regardless of the value found in the filename. This is designed to make testing easy (because logK and Debye-Huckel parameters will be exactly as set in the filename instead of from a 4-th order least-squares fit) but should rarely be used for real geochemical simulations

Definition at line 18 of file GeochemicalDatabaseReader.C.

  : _filename(filename)
{
  read(_filename);
  validate(_filename, _root);
 
  if (reexpress_free_electron)
    reexpressFreeElectron();
 
  if (use_piecewise_interpolation && _root["Header"].contains("logk model"))
    _root["Header"]["logk model"] = "piecewise-linear";
 
  if (remove_all_extrapolated_secondary_species)
    removeExtrapolatedSecondarySpecies();
 
  setTemperatures();
  setDebyeHuckel();
  setNeutralSpeciesActivity();
}

Member Function Documentation

equilibriumReactions()

std::vector< std::string > GeochemicalDatabaseReader::equilibriumReactions

(

const std::vector< std::string > &

names

)

const

Generates a formatted vector of strings representing all aqueous equilibrium reactions.

Parameters

names

list of equilibrium species return formatted equilibrium reactions

Definition at line 513 of file GeochemicalDatabaseReader.C.

{
  std::vector<std::map<std::string, Real>> basis_species(names.size());
 
  for (unsigned int i = 0; i < names.size(); ++i)
  {
    auto species = names[i];
 
    if (_root["secondary species"].contains(species))
    {
      auto sec_species = _root["secondary species"][species];
 
      // The basis species in this reaction
      std::map<std::string, Real> this_basis_species;
      for (auto & bs : sec_species["species"].items())
        this_basis_species[bs.key()] = getReal(bs.value());
 
      basis_species[i] = this_basis_species;
    }
    else
      mooseError(species + " does not exist in database " + _filename);
  }
 
  auto reactions = printReactions(names, basis_species);
 
  return reactions;
}

Referenced by TEST().

filename()

const FileName & GeochemicalDatabaseReader::filename

(

)

const

Filename of database.

Returns

filename

Definition at line 740 of file GeochemicalDatabaseReader.C.

{
  return _filename;
}

Referenced by PertinentGeochemicalSystem::buildBasis(), read(), TEST(), and validate().

gasReactions()

std::vector< std::string > GeochemicalDatabaseReader::gasReactions

(

const std::vector< std::string > &

names

)

const

Generates a formatted vector of strings representing all gas reactions.

Parameters

names

list of gas species @preturn formatted gas reactions

Definition at line 571 of file GeochemicalDatabaseReader.C.

{
  std::vector<std::map<std::string, Real>> basis_species(names.size());
 
  for (unsigned int i = 0; i < names.size(); ++i)
  {
    const auto species = names[i];
 
    if (_root["gas species"].contains(species))
    {
      auto gas_species = _root["gas species"][species];
 
      // The basis species in this reaction
      std::map<std::string, Real> this_basis_species;
      for (auto & bs : gas_species["species"].items())
        this_basis_species[bs.key()] = getReal(bs.value());
 
      basis_species[i] = this_basis_species;
    }
    else
      mooseError(species + " does not exist in database " + _filename);
  }
 
  auto reactions = printReactions(names, basis_species);
 
  return reactions;
}

Referenced by TEST().

getActivityModel()

std::string GeochemicalDatabaseReader::getActivityModel

(

)

const

Get the activity model type.

Returns

activity model

Definition at line 109 of file GeochemicalDatabaseReader.C.

{
  return _root["Header"]["activity model"];
}

Referenced by getDebyeHuckel(), setDebyeHuckel(), and TEST().

getBasisSpecies()

std::map< std::string, GeochemistryBasisSpecies > GeochemicalDatabaseReader::getBasisSpecies

(

const std::vector< std::string > &

names

)

Get the basis (primary) species information.

Parameters

names

list of basis species

Returns

basis species structure

Definition at line 215 of file GeochemicalDatabaseReader.C.

{
  // Parse the basis species specified in names
  for (const auto & species : names)
    if (_root["basis species"].contains(species))
    {
      GeochemistryBasisSpecies dbs;
 
      auto basis_species = _root["basis species"][species];
      dbs.name = species;
      dbs.radius = getReal(basis_species["radius"]);
      dbs.charge = getReal(basis_species["charge"]);
      dbs.molecular_weight = getReal(basis_species["molecular weight"]);
 
      std::map<std::string, Real> elements;
      for (auto & el : basis_species["elements"].items())
        elements[el.key()] = getReal(el.value());
 
      dbs.elements = elements;
 
      _basis_species[species] = dbs;
    }
    else
      mooseError(species + " does not exist in database " + _filename);
 
  return _basis_species;
}

Referenced by PertinentGeochemicalSystem::buildBasis(), and TEST().

getBasisSpeciesNames()

std::vector< std::string > GeochemicalDatabaseReader::getBasisSpeciesNames ( ) const

inline

Get the list of basis (primary) species read from database.

Returns

list of primary species names

Definition at line 277 of file GeochemicalDatabaseReader.h.

{ return _bs_names; };

getDebyeHuckel()

const GeochemistryDebyeHuckel & GeochemicalDatabaseReader::getDebyeHuckel

(

)

const

Get the Debye-Huckel activity coefficients.

Returns

vectors of adh, bdh and bdot

Definition at line 191 of file GeochemicalDatabaseReader.C.

{
  if (getActivityModel() != "debye-huckel")
    mooseError("Attempted to get Debye-Huckel activity parameters but the activity model is ",
               getActivityModel());
  return _debye_huckel;
}

Referenced by TEST().

getElements()

std::map< std::string, GeochemistryElements > GeochemicalDatabaseReader::getElements

(

)

Get all the elements.

Returns

elements species structure

Definition at line 200 of file GeochemicalDatabaseReader.C.

{
  if (_root.contains("elements"))
  {
    for (auto & el : _root["elements"].items())
    {
      _elements[el.key()].name = el.value()["name"];
      _elements[el.key()].molecular_weight = getReal(el.value()["molecular weight"]);
    }
  }
 
  return _elements;
}

Referenced by TEST().

getEquilibriumSpecies()

std::map< std::string, GeochemistryEquilibriumSpecies > GeochemicalDatabaseReader::getEquilibriumSpecies

(

const std::vector< std::string > &

names

)

Get the secondary equilibrium species information.

Parameters

names

list of equilibrium species

Returns

secondary species structure

Definition at line 244 of file GeochemicalDatabaseReader.C.

{
  // Parse the secondary species specified in names
  for (const auto & species : names)
    if (_root["secondary species"].contains(species) or _root["free electron"].contains(species))
    {
      GeochemistryEquilibriumSpecies dbs;
 
      auto sec_species = _root["secondary species"].contains(species)
                             ? _root["secondary species"][species]
                             : _root["free electron"][species];
      dbs.name = species;
      dbs.radius = getReal(sec_species["radius"]);
      dbs.charge = getReal(sec_species["charge"]);
      dbs.molecular_weight = getReal(sec_species["molecular weight"]);
 
      std::vector<Real> eq_const(sec_species["logk"].size());
      for (unsigned int i = 0; i < sec_species["logk"].size(); ++i)
        eq_const[i] = getReal(sec_species["logk"][i]);
 
      dbs.equilibrium_const = eq_const;
 
      std::map<std::string, Real> basis_species;
      for (auto & bs : sec_species["species"].items())
        basis_species[bs.key()] = getReal(bs.value());
 
      dbs.basis_species = basis_species;
 
      _equilibrium_species[species] = dbs;
    }
    else
      mooseError(species + " does not exist in database " + _filename);
 
  return _equilibrium_species;
}

Referenced by PertinentGeochemicalSystem::buildRedoxeInfo(), PertinentGeochemicalSystem::buildSecondarySpecies(), PertinentGeochemicalSystem::checkRedoxe(), TEST(), TEST(), and TEST().

getEquilibriumSpeciesNames()

std::vector< std::string > GeochemicalDatabaseReader::getEquilibriumSpeciesNames ( ) const

inline

Get the list of secondary equilibrium species read from database.

Returns

list of equilibrium species names

Definition at line 283 of file GeochemicalDatabaseReader.h.

{ return _es_names; };

getFugacityModel()

std::string GeochemicalDatabaseReader::getFugacityModel

(

)

const

Get the fugacity model type.

Returns

fugacity model

Definition at line 115 of file GeochemicalDatabaseReader.C.

{
  return _root["Header"]["fugacity model"];
}

Referenced by TEST().

getGasSpecies()

std::map< std::string, GeochemistryGasSpecies > GeochemicalDatabaseReader::getGasSpecies

(

const std::vector< std::string > &

names

)

Get the gas species information.

Parameters

names

list of gs species

Returns

gas species structure

Definition at line 328 of file GeochemicalDatabaseReader.C.

{
  // Parse the gas species specified in names
  for (const auto & species : names)
    if (_root["gas species"].contains(species))
    {
      GeochemistryGasSpecies dbs;
 
      auto gas_species = _root["gas species"][species];
      dbs.name = species;
      dbs.molecular_weight = getReal(gas_species["molecular weight"]);
 
      std::vector<Real> eq_const(gas_species["logk"].size());
      for (unsigned int i = 0; i < gas_species["logk"].size(); ++i)
        eq_const[i] = getReal(gas_species["logk"][i]);
 
      dbs.equilibrium_const = eq_const;
 
      std::map<std::string, Real> basis_species;
      for (auto & bs : gas_species["species"].items())
        basis_species[bs.key()] = getReal(bs.value());
 
      dbs.basis_species = basis_species;
 
      // Optional fugacity coefficients
      if (gas_species.contains("chi"))
      {
        std::vector<Real> chi(gas_species["chi"].size());
        for (unsigned int i = 0; i < gas_species["chi"].size(); ++i)
          chi[i] = getReal(gas_species["chi"][i]);
 
        dbs.chi = chi;
      }
 
      if (gas_species.contains("Pcrit"))
        dbs.Pcrit = getReal(gas_species["Pcrit"]);
 
      if (gas_species.contains("Tcrit"))
        dbs.Tcrit = getReal(gas_species["Tcrit"]);
 
      if (gas_species.contains("omega"))
        dbs.omega = getReal(gas_species["omega"]);
 
      _gas_species[species] = dbs;
    }
    else
      mooseError(species + " does not exist in database " + _filename);
 
  return _gas_species;
}

Referenced by PertinentGeochemicalSystem::buildGases(), and TEST().

getLogKModel()

std::string GeochemicalDatabaseReader::getLogKModel

(

)

const

Get the equilibrium constant model type.

Returns

equilibrium constant model

Definition at line 121 of file GeochemicalDatabaseReader.C.

{
  return _root["Header"]["logk model"];
}

Referenced by GeochemicalSystem::buildTemperatureDependentQuantities(), GeochemicalModelInterrogator::outputActivity(), GeochemicalModelInterrogator::outputReaction(), GeochemicalModelInterrogator::solveForT(), and TEST().

getMineralSpecies()

std::map< std::string, GeochemistryMineralSpecies > GeochemicalDatabaseReader::getMineralSpecies

(

const std::vector< std::string > &

names

)

Get the mineral species information.

Parameters

names

list of mineral species

Returns

mineral species structure

Definition at line 281 of file GeochemicalDatabaseReader.C.

{
  // Parse the mineral species specified in names
  for (const auto & species : names)
    if (_root["mineral species"].contains(species))
    {
      GeochemistryMineralSpecies dbs;
 
      auto mineral_species = _root["mineral species"][species];
      dbs.name = species;
      dbs.molecular_weight = getReal(mineral_species["molecular weight"]);
      dbs.molecular_volume = getReal(mineral_species["molar volume"]);
 
      std::vector<Real> eq_const(mineral_species["logk"].size());
      for (unsigned int i = 0; i < mineral_species["logk"].size(); ++i)
        eq_const[i] = getReal(mineral_species["logk"][i]);
 
      dbs.equilibrium_const = eq_const;
 
      std::map<std::string, Real> basis_species;
      for (auto & bs : mineral_species["species"].items())
        basis_species[bs.key()] = getReal(bs.value());
 
      dbs.basis_species = basis_species;
 
      // recover sorption information, if any
      std::map<std::string, Real> species_and_sorbing_density;
      dbs.surface_area = 0.0;
      if (_root["sorbing minerals"].contains(species))
      {
        auto sorbing_mineral = _root["sorbing minerals"][species];
        dbs.surface_area = getReal(sorbing_mineral["surface area"]);
 
        for (auto & site : sorbing_mineral["sorbing sites"].items())
          species_and_sorbing_density[site.key()] = getReal(site.value());
      }
      dbs.sorption_sites = species_and_sorbing_density;
 
      _mineral_species[species] = dbs;
    }
    else
      mooseError(species + " does not exist in database " + _filename);
 
  return _mineral_species;
}

Referenced by PertinentGeochemicalSystem::buildAllMinerals(), PertinentGeochemicalSystem::buildKineticMinerals(), PertinentGeochemicalSystem::buildMinerals(), and TEST().

getMineralSpeciesNames()

std::vector< std::string > GeochemicalDatabaseReader::getMineralSpeciesNames ( ) const

inline

Get the list of secondary mineral species read from database.

Returns

list of mineral species names

Definition at line 289 of file GeochemicalDatabaseReader.h.

{ return _ms_names; };

getNeutralSpeciesActivity()

const std::map< std::string, GeochemistryNeutralSpeciesActivity > & GeochemicalDatabaseReader::getNeutralSpeciesActivity

(

)

const

Get the neutral species activity coefficients.

Returns

neutral species activity coefficients

Definition at line 505 of file GeochemicalDatabaseReader.C.

{
  if (!_root["Header"].contains("neutral species"))
    mooseError("No neutral species activity coefficients in database");
  return _neutral_species_activity;
}

Referenced by TEST().

getOxideSpecies()

std::map< std::string, GeochemistryOxideSpecies > GeochemicalDatabaseReader::getOxideSpecies

(

const std::vector< std::string > &

names

)

Get the oxide species information.

Parameters

names

list of gs species

Returns

oxide species structure

Definition at line 415 of file GeochemicalDatabaseReader.C.

{
  // Parse the oxide species specified in names
  for (auto & species : names)
    if (_root["oxides"].contains(species))
    {
      GeochemistryOxideSpecies dbs;
 
      auto oxide_species = _root["oxides"][species];
      dbs.name = species;
      dbs.molecular_weight = getReal(oxide_species["molecular weight"]);
 
      std::map<std::string, Real> basis_species;
      for (auto & bs : oxide_species["species"].items())
        basis_species[bs.key()] = getReal(bs.value());
 
      dbs.basis_species = basis_species;
 
      _oxide_species[species] = dbs;
    }
    else
      mooseError(species + " does not exist in database " + _filename);
 
  return _oxide_species;
}

Referenced by TEST().

getPressures()

std::vector< Real > GeochemicalDatabaseReader::getPressures

(

)

Get the pressure points that the equilibrium constant is defined at.

Returns

vector of pressure points (C)

Definition at line 145 of file GeochemicalDatabaseReader.C.

{
  // Read pressure points
  if (_root["Header"].contains("pressures"))
  {
    auto pressures = _root["Header"]["pressures"];
    _pressure_points.resize(pressures.size());
    for (unsigned int i = 0; i < pressures.size(); ++i)
      _pressure_points[i] = getReal(pressures[i]);
  }
 
  return _pressure_points;
}

Referenced by TEST().

getReal()

Real GeochemicalDatabaseReader::getReal ( const nlohmann::json &  node )

staticprotected

Definition at line 812 of file GeochemicalDatabaseReader.C.

{
  if (node.is_string())
    return MooseUtils::convert<Real>(node);
  return node;
}

Referenced by equilibriumReactions(), gasReactions(), getBasisSpecies(), getElements(), getEquilibriumSpecies(), getGasSpecies(), getMineralSpecies(), getOxideSpecies(), getPressures(), getRedoxSpecies(), getSurfaceSpecies(), mineralReactions(), oxideReactions(), redoxReactions(), reexpressFreeElectron(), setDebyeHuckel(), setNeutralSpeciesActivity(), and setTemperatures().

getRedoxSpecies()

std::map< std::string, GeochemistryRedoxSpecies > GeochemicalDatabaseReader::getRedoxSpecies

(

const std::vector< std::string > &

names

)

Get the redox species (couples) information.

Parameters

names

list of gs species

Returns

redox species structure

Definition at line 380 of file GeochemicalDatabaseReader.C.

{
  // Parse the redox species specified in names
  for (const auto & species : names)
    if (_root["redox couples"].contains(species))
    {
      GeochemistryRedoxSpecies dbs;
 
      auto redox_species = _root["redox couples"][species];
      dbs.name = species;
      dbs.radius = getReal(redox_species["radius"]);
      dbs.charge = getReal(redox_species["charge"]);
      dbs.molecular_weight = getReal(redox_species["molecular weight"]);
 
      std::vector<Real> eq_const(redox_species["logk"].size());
      for (unsigned int i = 0; i < redox_species["logk"].size(); ++i)
        eq_const[i] = getReal(redox_species["logk"][i]);
 
      dbs.equilibrium_const = eq_const;
 
      std::map<std::string, Real> basis_species;
      for (auto & bs : redox_species["species"].items())
        basis_species[bs.key()] = getReal(bs.value());
 
      dbs.basis_species = basis_species;
 
      _redox_species[species] = dbs;
    }
    else
      mooseError(species + " does not exist in database " + _filename);
 
  return _redox_species;
}

Referenced by PertinentGeochemicalSystem::buildBasis(), PertinentGeochemicalSystem::buildKineticRedox(), PertinentGeochemicalSystem::buildSecondarySpecies(), PertinentGeochemicalSystem::createModel(), and TEST().

getSpeciesData()

std::string GeochemicalDatabaseReader::getSpeciesData

(

const std::string

name

)

const

String representation of JSON species object contents.

Parameters

name	name of species

Returns

styled string of species information

Definition at line 794 of file GeochemicalDatabaseReader.C.

{
  std::string output;
  for (auto & item : _root.items())
    if (_root[item.key()].contains(name))
    {
      std::ostringstream os;
      os << item.value()[name].dump(4);
      output = os.str();
    }
 
  if (output.empty())
    mooseError(name + " is not a species in the database");
 
  return name + ":\n" + output;
}

Referenced by TEST().

getSurfaceSpecies()

std::map< std::string, GeochemistrySurfaceSpecies > GeochemicalDatabaseReader::getSurfaceSpecies

(

const std::vector< std::string > &

names

)

Get the surface sorbing species information.

Parameters

names

list of surface sorbing species

Returns

surface sorbing species structure

Definition at line 442 of file GeochemicalDatabaseReader.C.

{
  // Parse the secondary species specified in names
  for (const auto & species : names)
    if (_root["surface species"].contains(species))
    {
      GeochemistrySurfaceSpecies dbs;
 
      auto surface_species = _root["surface species"][species];
      dbs.name = species;
      dbs.charge = getReal(surface_species["charge"]);
      dbs.molecular_weight = getReal(surface_species["molecular weight"]);
      dbs.log10K = getReal(surface_species["log K"]);
      dbs.dlog10KdT = getReal(surface_species["dlogK/dT"]);
 
      std::map<std::string, Real> basis_species;
      for (auto & bs : surface_species["species"].items())
        basis_species[bs.key()] = getReal(bs.value());
 
      dbs.basis_species = basis_species;
 
      _surface_species[species] = dbs;
    }
    else
      mooseError(species + " does not exist in database " + _filename);
 
  return _surface_species;
}

Referenced by PertinentGeochemicalSystem::buildKineticSurface(), PertinentGeochemicalSystem::buildSecondarySpecies(), and TEST().

getTemperatures()

const std::vector< Real > & GeochemicalDatabaseReader::getTemperatures

(

)

const

Get the temperature points that the equilibrium constant is defined at.

Returns

vector of temperature points (C)

Definition at line 139 of file GeochemicalDatabaseReader.C.

{
  return _temperature_points;
}

Referenced by PertinentGeochemicalSystem::buildRedoxeInfo(), PertinentGeochemicalSystem::buildSecondarySpecies(), GeochemicalSystem::buildTemperatureDependentQuantities(), PertinentGeochemicalSystem::createModel(), GeochemicalModelInterrogator::outputActivity(), GeochemicalModelInterrogator::outputReaction(), GeochemicalModelInterrogator::outputTemperature(), GeochemicalModelInterrogator::solveForT(), TEST(), and TEST().

isBasisSpecies()

bool GeochemicalDatabaseReader::isBasisSpecies

(

const std::string &

name

)

const

Checks if species is of given type.

Parameters

name	species name

Returns

true iff species is of given type

Definition at line 746 of file GeochemicalDatabaseReader.C.

{
  return _root["basis species"].contains(name);
}

Referenced by PertinentGeochemicalSystem::buildBasis(), and TEST().

isGasSpecies()

bool GeochemicalDatabaseReader::isGasSpecies

(

const std::string &

name

)

const

Definition at line 770 of file GeochemicalDatabaseReader.C.

{
  return _root["gas species"].contains(name);
}

Referenced by TEST().

isMineralSpecies()

bool GeochemicalDatabaseReader::isMineralSpecies

(

const std::string &

name

)

const

Definition at line 776 of file GeochemicalDatabaseReader.C.

{
  return _root["mineral species"].contains(name);
}

Referenced by TEST().

isOxideSpecies()

bool GeochemicalDatabaseReader::isOxideSpecies

(

const std::string &

name

)

const

Definition at line 782 of file GeochemicalDatabaseReader.C.

{
  return _root["oxides"].contains(name);
}

Referenced by TEST().

isRedoxSpecies()

bool GeochemicalDatabaseReader::isRedoxSpecies

(

const std::string &

name

)

const

Definition at line 752 of file GeochemicalDatabaseReader.C.

{
  return _root["redox couples"].contains(name);
}

Referenced by PertinentGeochemicalSystem::buildBasis(), PertinentGeochemicalSystem::createModel(), and TEST().

isSecondarySpecies()

bool GeochemicalDatabaseReader::isSecondarySpecies

(

const std::string &

name

)

const

Returns true if name is a "secondary species" or "free electron" in the database.

Definition at line 764 of file GeochemicalDatabaseReader.C.

{
  return _root["secondary species"].contains(name) || _root["free electron"].contains(name);
}

Referenced by TEST(), and TEST().

isSorbingMineral()

bool GeochemicalDatabaseReader::isSorbingMineral

(

const std::string &

name

)

const

returns True iff name is the name of a sorbing mineral

Definition at line 758 of file GeochemicalDatabaseReader.C.

{
  return _root["sorbing minerals"].contains(name);
}

Referenced by TEST().

isSurfaceSpecies()

bool GeochemicalDatabaseReader::isSurfaceSpecies

(

const std::string &

name

)

const

Definition at line 788 of file GeochemicalDatabaseReader.C.

{
  return _root["surface species"].contains(name);
}

Referenced by TEST().

mineralReactions()

std::vector< std::string > GeochemicalDatabaseReader::mineralReactions

(

const std::vector< std::string > &

names

)

const

Generates a formatted vector of strings representing all mineral reactions.

Parameters

names

list of mineral species @preturn formatted mineral reactions

Definition at line 542 of file GeochemicalDatabaseReader.C.

{
  std::vector<std::map<std::string, Real>> basis_species(names.size());
 
  for (unsigned int i = 0; i < names.size(); ++i)
  {
    const auto species = names[i];
 
    if (_root["mineral species"].contains(species))
    {
      auto min_species = _root["mineral species"][species];
 
      // The basis species in this reaction
      std::map<std::string, Real> this_basis_species;
      for (auto & bs : min_species["species"].items())
        this_basis_species[bs.key()] = getReal(bs.value());
 
      basis_species[i] = this_basis_species;
    }
    else
      mooseError(species + " does not exist in database " + _filename);
  }
 
  auto reactions = printReactions(names, basis_species);
 
  return reactions;
}

Referenced by TEST().

mineralSpeciesNames()

std::vector< std::string > GeochemicalDatabaseReader::mineralSpeciesNames

(

)

const

Returns a list of all the names of the "mineral species" in the database.

Definition at line 696 of file GeochemicalDatabaseReader.C.

{
  std::vector<std::string> names;
  if (_root.contains("mineral species"))
    for (auto & item : _root["mineral species"].items())
      names.push_back(item.key());
  return names;
}

Referenced by PertinentGeochemicalSystem::buildAllMinerals(), and TEST().

oxideReactions()

std::vector< std::string > GeochemicalDatabaseReader::oxideReactions

(

const std::vector< std::string > &

names

)

const

Generates a formatted vector of strings representing all oxide reactions.

Parameters

names

list of oxide species @preturn formatted oxide reactions

Definition at line 629 of file GeochemicalDatabaseReader.C.

{
  std::vector<std::map<std::string, Real>> basis_species(names.size());
 
  for (unsigned int i = 0; i < names.size(); ++i)
  {
    const auto species = names[i];
 
    if (_root["oxides"].contains(species))
    {
      auto oxide_species = _root["oxides"][species];
 
      // The basis species in this reaction
      std::map<std::string, Real> this_basis_species;
      for (auto & bs : oxide_species["species"].items())
        this_basis_species[bs.key()] = getReal(bs.value());
 
      basis_species[i] = this_basis_species;
    }
    else
      mooseError(species + " does not exist in database " + _filename);
  }
 
  auto reactions = printReactions(names, basis_species);
 
  return reactions;
}

Referenced by TEST().

printReactions()

std::vector< std::string > GeochemicalDatabaseReader::printReactions ( const std::vector< std::string > &  names, const std::vector< std::map< std::string, Real > > &  basis_species  ) const

private

Generates a formatted vector of strings representing all reactions.

Parameters

names	list of reaction species
basis	species list of basis species for each reaction species (this vector must be of same size as names)

Returns

formatted reaction equations

Definition at line 658 of file GeochemicalDatabaseReader.C.

{
  std::vector<std::string> reactions;
 
  for (unsigned int i = 0; i < names.size(); ++i)
  {
    std::string reaction = "";
    for (auto & bs : basis_species[i])
    {
      if (bs.second < 0.0)
      {
        if (bs.second == -1.0)
          reaction += " - " + bs.first;
        else
          reaction += " " + Moose::stringify(bs.second) + bs.first;
      }
      else
      {
        if (bs.second == 1.0)
          reaction += " + " + bs.first;
        else
          reaction += " + " + Moose::stringify(bs.second) + bs.first;
      }
    }
 
    // Trim off leading +
    if (reaction.size() > 1 && reaction[1] == '+')
      reaction.erase(1, 2);
 
    reactions.push_back(names[i] + " =" + reaction);
  }
 
  return reactions;
}

Referenced by equilibriumReactions(), gasReactions(), mineralReactions(), oxideReactions(), and redoxReactions().

read()

void GeochemicalDatabaseReader::read

(

const FileName

filename

)

Parse the thermodynamic database.

Parameters

filename

Name of thermodynamic database file

Definition at line 43 of file GeochemicalDatabaseReader.C.

{
  MooseUtils::checkFileReadable(filename);
 
  // Read the JSON database
  std::ifstream jsondata(filename);
  jsondata >> _root;
}

Referenced by GeochemicalDatabaseReader().

redoxCoupleNames()

std::vector< std::string > GeochemicalDatabaseReader::redoxCoupleNames

(

)

const

Returns a list of all the names of the "redox couples" in the database.

Definition at line 720 of file GeochemicalDatabaseReader.C.

{
  std::vector<std::string> names;
  if (_root.contains("redox couples"))
    for (const auto & item : _root["redox couples"].items())
      names.push_back(item.key());
  return names;
}

Referenced by PertinentGeochemicalSystem::buildSecondarySpecies(), and TEST().

redoxReactions()

std::vector< std::string > GeochemicalDatabaseReader::redoxReactions

(

const std::vector< std::string > &

names

)

const

Generates a formatted vector of strings representing all redox reactions.

Parameters

names

list of redox species @preturn formatted redox reactions

Definition at line 600 of file GeochemicalDatabaseReader.C.

{
  std::vector<std::map<std::string, Real>> basis_species(names.size());
 
  for (unsigned int i = 0; i < names.size(); ++i)
  {
    const auto species = names[i];
 
    if (_root["redox couples"].contains(species))
    {
      auto redox_species = _root["redox couples"][species];
 
      // The basis species in this reaction
      std::map<std::string, Real> this_basis_species;
      for (auto & bs : redox_species["species"].items())
        this_basis_species[bs.key()] = getReal(bs.value());
 
      basis_species[i] = this_basis_species;
    }
    else
      mooseError(species + " does not exist in database " + _filename);
  }
 
  auto reactions = printReactions(names, basis_species);
 
  return reactions;
}

Referenced by TEST().

reexpressFreeElectron()

void GeochemicalDatabaseReader::reexpressFreeElectron

(

)

Sometimes the free electron's equilibrium reaction is defined in terms of O2(g) which is not a basis species.

If this is the case, re-express it in terms of O2(aq), if O2(g) is a gas and O2(aq) is a basis species.

Definition at line 62 of file GeochemicalDatabaseReader.C.

{
  if (!_root.contains("free electron") || !_root["free electron"].contains("e-") ||
      !_root["free electron"]["e-"]["species"].contains("O2(g)"))
    return;
  if (!_root.contains("basis species") || !_root["basis species"].contains("O2(aq)"))
    return;
  if (!_root.contains("gas species") || !_root["gas species"].contains("O2(g)") ||
      !_root["gas species"]["O2(g)"]["species"].contains("O2(aq)") ||
      (_root["gas species"]["O2(g)"]["species"].size() != 1))
    return;
 
  // remove O2(g) in the "e-" and replace with O2(aq)
  const std::string stoi_o2g =
      nlohmann::to_string(_root["free electron"]["e-"]["species"]["O2(g)"]);
  _root["free electron"]["e-"]["species"].erase("O2(g)");
  _root["free electron"]["e-"]["species"]["O2(aq)"] = stoi_o2g;
  const Real stoi = getReal(stoi_o2g);
 
  // alter equilibrium constants
  if (!_root["Header"].contains("temperatures"))
    return;
  for (unsigned i = 0; i < _root["Header"]["temperatures"].size(); ++i)
  {
    const Real logk_e = getReal(_root["free electron"]["e-"]["logk"][i]);
    const Real logk_o2 = getReal(_root["gas species"]["O2(g)"]["logk"][i]);
    const Real newk = logk_e + stoi * logk_o2;
    _root["free electron"]["e-"]["logk"][i] = std::to_string(newk);
  }
}

Referenced by GeochemicalDatabaseReader().

removeExtrapolatedSecondarySpecies()

void GeochemicalDatabaseReader::removeExtrapolatedSecondarySpecies ( )

protected

After parsing the database file, remove any secondary species that have extrapolated equilibrium constants.

This is called in the constructor if the remove_all_extrapolated_secondary_species flag is true

Definition at line 94 of file GeochemicalDatabaseReader.C.

{
  if (_root.contains("secondary species"))
  {
    std::set<std::string> remove; // items to remove
    for (const auto & item : _root["secondary species"].items())
      if (item.value().contains("note"))
        remove.insert(item.key());
 
    for (const auto & name : remove)
      _root["secondary species"].erase(name);
  }
}

Referenced by GeochemicalDatabaseReader().

secondarySpeciesNames()

std::vector< std::string > GeochemicalDatabaseReader::secondarySpeciesNames

(

)

const

Returns a list of all the names of the "secondary species" and "free electron" in the database.

Definition at line 706 of file GeochemicalDatabaseReader.C.

{
  std::vector<std::string> names;
  if (_root.contains("secondary species"))
    for (auto & item : _root["secondary species"].items())
      names.push_back(item.key());
 
  if (_root.contains("free electron"))
    for (const auto & nm : _root["free electron"].items())
      names.push_back(nm.key());
  return names;
}

Referenced by PertinentGeochemicalSystem::buildRedoxeInfo(), PertinentGeochemicalSystem::buildSecondarySpecies(), PertinentGeochemicalSystem::checkRedoxe(), and TEST().

setDebyeHuckel()

void GeochemicalDatabaseReader::setDebyeHuckel ( )

protected

Copy the Debye-Huckel parameters (if any) found in the database into _debye_huckel.

This method is called in the constructor

Definition at line 160 of file GeochemicalDatabaseReader.C.

{
  if (getActivityModel() == "debye-huckel")
  {
    if (_root["Header"].contains("adh"))
    {
      std::vector<Real> adhvals(_root["Header"]["adh"].size());
      for (unsigned int i = 0; i < _root["Header"]["adh"].size(); ++i)
        adhvals[i] = getReal(_root["Header"]["adh"][i]);
      _debye_huckel.adh = adhvals;
    }
 
    if (_root["Header"].contains("bdh"))
    {
      std::vector<Real> bdhvals(_root["Header"]["bdh"].size());
      for (unsigned int i = 0; i < _root["Header"]["bdh"].size(); ++i)
        bdhvals[i] = getReal(_root["Header"]["bdh"][i]);
      _debye_huckel.bdh = bdhvals;
    }
 
    if (_root["Header"].contains("bdot"))
    {
      std::vector<Real> bdotvals(_root["Header"]["bdot"].size());
      for (unsigned int i = 0; i < _root["Header"]["bdot"].size(); ++i)
        bdotvals[i] = getReal(_root["Header"]["bdot"][i]);
      _debye_huckel.bdot = bdotvals;
    }
  }
}

Referenced by GeochemicalDatabaseReader().

setNeutralSpeciesActivity()

void GeochemicalDatabaseReader::setNeutralSpeciesActivity ( )

protected

Copy the Debye-Huckel parameters for computing neutral species activity (if any) found in the database into _neutral_species_activity.

This method is called in the constructor

Definition at line 472 of file GeochemicalDatabaseReader.C.

{
  if (_root["Header"].contains("neutral species"))
  {
    auto neutral_species = _root["Header"]["neutral species"];
    for (auto & ns : neutral_species.items())
    {
      std::vector<std::vector<Real>> coeffs;
 
      for (auto & nsac : ns.value().items())
      {
        if (nsac.key() == "note")
          continue;
        std::vector<Real> coeffvec(nsac.value().size());
 
        for (unsigned int i = 0; i < coeffvec.size(); ++i)
          coeffvec[i] = getReal(nsac.value()[i]);
 
        coeffs.push_back(coeffvec);
      }
 
      // GeochemistryNeutralSpeciesActivity expects four vectos, so
      // add empty vectors if coeffs.size() != 4
      coeffs.resize(4, {});
 
      GeochemistryNeutralSpeciesActivity nsa(coeffs);
 
      _neutral_species_activity[ns.key()] = nsa;
    }
  }
}

Referenced by GeochemicalDatabaseReader().

setTemperatures()

void GeochemicalDatabaseReader::setTemperatures ( )

protected

Copy the temperature points (if any) found in the database into _temperature_points.

This method is called in the constructor

Definition at line 127 of file GeochemicalDatabaseReader.C.

{
  if (_root["Header"].contains("temperatures"))
  {
    auto temperatures = _root["Header"]["temperatures"];
    _temperature_points.resize(temperatures.size());
    for (unsigned int i = 0; i < temperatures.size(); ++i)
      _temperature_points[i] = getReal(temperatures[i]);
  }
}

Referenced by GeochemicalDatabaseReader().

surfaceSpeciesNames()

std::vector< std::string > GeochemicalDatabaseReader::surfaceSpeciesNames

(

)

const

Returns a list of all the names of the "surface species" in the database.

Definition at line 730 of file GeochemicalDatabaseReader.C.

{
  std::vector<std::string> names;
  if (_root.contains("surface species"))
    for (const auto & item : _root["surface species"].items())
      names.push_back(item.key());
  return names;
}

Referenced by PertinentGeochemicalSystem::buildSecondarySpecies(), and TEST().

validate()

void GeochemicalDatabaseReader::validate	(	const FileName	filename,
		const nlohmann::json &	db
	)

Validate the thermodynamic database.

Parameters

filename	Name of thermodynamic database file
db	JSON database read from filename

Definition at line 53 of file GeochemicalDatabaseReader.C.

{
  // Validate the JSON database so that we don't have to check array sizes,
  // check for conversion issues, etc when extracting data using get methods
  GeochemicalDatabaseValidator dbv(filename, db);
  dbv.validate();
}

Referenced by GeochemicalDatabaseReader(), TEST(), and testExceptionMessage().

Member Data Documentation

_basis_species

std::map<std::string, GeochemistryBasisSpecies> GeochemicalDatabaseReader::_basis_species

protected

Basis species data read from the database.

Definition at line 500 of file GeochemicalDatabaseReader.h.

Referenced by getBasisSpecies().

_bs_names

std::vector<std::string> GeochemicalDatabaseReader::_bs_names

protected

List of basis (primary) species names read from database.

Definition at line 488 of file GeochemicalDatabaseReader.h.

Referenced by getBasisSpeciesNames().

_debye_huckel

GeochemistryDebyeHuckel GeochemicalDatabaseReader::_debye_huckel

protected

Debye-Huckel activity coefficients.

Definition at line 514 of file GeochemicalDatabaseReader.h.

Referenced by getDebyeHuckel(), and setDebyeHuckel().

_elements

std::map<std::string, GeochemistryElements> GeochemicalDatabaseReader::_elements

protected

Elements and their molecular weight read from the database.

Definition at line 498 of file GeochemicalDatabaseReader.h.

Referenced by getElements().

_equilibrium_species

std::map<std::string, GeochemistryEquilibriumSpecies> GeochemicalDatabaseReader::_equilibrium_species

protected

Secondary equilibrium species and free electron data read from the database.

Definition at line 502 of file GeochemicalDatabaseReader.h.

Referenced by getEquilibriumSpecies().

_es_names

std::vector<std::string> GeochemicalDatabaseReader::_es_names

protected

List of secondary equilibrium species to read from database.

Definition at line 490 of file GeochemicalDatabaseReader.h.

Referenced by getEquilibriumSpeciesNames().

_filename

const FileName GeochemicalDatabaseReader::_filename

protected

Database filename.

Definition at line 484 of file GeochemicalDatabaseReader.h.

Referenced by equilibriumReactions(), filename(), gasReactions(), GeochemicalDatabaseReader(), getBasisSpecies(), getEquilibriumSpecies(), getGasSpecies(), getMineralSpecies(), getOxideSpecies(), getRedoxSpecies(), getSurfaceSpecies(), mineralReactions(), oxideReactions(), and redoxReactions().

_gas_species

std::map<std::string, GeochemistryGasSpecies> GeochemicalDatabaseReader::_gas_species

protected

Gas species data read from the database.

Definition at line 506 of file GeochemicalDatabaseReader.h.

Referenced by getGasSpecies().

_mineral_species

std::map<std::string, GeochemistryMineralSpecies> GeochemicalDatabaseReader::_mineral_species

protected

Mineral species data read from the database.

Definition at line 504 of file GeochemicalDatabaseReader.h.

Referenced by getMineralSpecies().

_ms_names

std::vector<std::string> GeochemicalDatabaseReader::_ms_names

protected

List of secondary mineral species to read from database.

Definition at line 492 of file GeochemicalDatabaseReader.h.

Referenced by getMineralSpeciesNames().

_neutral_species_activity

std::map<std::string, GeochemistryNeutralSpeciesActivity> GeochemicalDatabaseReader::_neutral_species_activity

protected

Neutral species activity coefficients.

Definition at line 516 of file GeochemicalDatabaseReader.h.

Referenced by getNeutralSpeciesActivity(), and setNeutralSpeciesActivity().

_oxide_species

std::map<std::string, GeochemistryOxideSpecies> GeochemicalDatabaseReader::_oxide_species

protected

Oxide species data read from the database.

Definition at line 510 of file GeochemicalDatabaseReader.h.

Referenced by getOxideSpecies().

_pressure_points

std::vector<Real> GeochemicalDatabaseReader::_pressure_points

protected

Pressure points in database.

Definition at line 496 of file GeochemicalDatabaseReader.h.

Referenced by getPressures().

_redox_species

std::map<std::string, GeochemistryRedoxSpecies> GeochemicalDatabaseReader::_redox_species

protected

Redox species (couples) data read from the database.

Definition at line 508 of file GeochemicalDatabaseReader.h.

Referenced by getRedoxSpecies().

_root

nlohmann::json GeochemicalDatabaseReader::_root

protected

JSON data.

Definition at line 486 of file GeochemicalDatabaseReader.h.

Referenced by equilibriumReactions(), gasReactions(), GeochemicalDatabaseReader(), getActivityModel(), getBasisSpecies(), getElements(), getEquilibriumSpecies(), getFugacityModel(), getGasSpecies(), getLogKModel(), getMineralSpecies(), getNeutralSpeciesActivity(), getOxideSpecies(), getPressures(), getRedoxSpecies(), getSpeciesData(), getSurfaceSpecies(), isBasisSpecies(), isGasSpecies(), isMineralSpecies(), isOxideSpecies(), isRedoxSpecies(), isSecondarySpecies(), isSorbingMineral(), isSurfaceSpecies(), mineralReactions(), mineralSpeciesNames(), oxideReactions(), read(), redoxCoupleNames(), redoxReactions(), reexpressFreeElectron(), removeExtrapolatedSecondarySpecies(), secondarySpeciesNames(), setDebyeHuckel(), setNeutralSpeciesActivity(), setTemperatures(), and surfaceSpeciesNames().

_surface_species

std::map<std::string, GeochemistrySurfaceSpecies> GeochemicalDatabaseReader::_surface_species

protected

Surface sorbing species data read from the database.

Definition at line 512 of file GeochemicalDatabaseReader.h.

Referenced by getSurfaceSpecies().

_temperature_points

std::vector<Real> GeochemicalDatabaseReader::_temperature_points

protected

Temperature points in database.

Definition at line 494 of file GeochemicalDatabaseReader.h.

Referenced by getTemperatures(), and setTemperatures().

---

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

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