Loading [MathJax]/extensions/tex2jax.js
OGS
ChemistryLib Namespace Reference

Detailed Description

Namespaces

 PhreeqcIOData
 
 PhreeqcKernelData
 

Classes

class  ChemicalSolverInterface
 

Enumerations

enum class  ChemicalSolver { Phreeqc , PhreeqcKernel }
 
enum class  ChargeBalance { pH , pe , Unspecified }
 

Functions

ChargeBalance createChargeBalance (BaseLib::ConfigTree const &config)
 
template<typename ReactionRate >
std::vector< ReactionRate > createReactionRates (std::optional< BaseLib::ConfigTree > const &config)
 
template std::vector< PhreeqcIOData::ReactionRatecreateReactionRates< PhreeqcIOData::ReactionRate > (std::optional< BaseLib::ConfigTree > const &config)
 
template std::vector< PhreeqcKernelData::ReactionRatecreateReactionRates< PhreeqcKernelData::ReactionRate > (std::optional< BaseLib::ConfigTree > const &config)
 
template<>
std::unique_ptr< ChemicalSolverInterfacecreateChemicalSolverInterface< ChemicalSolver::Phreeqc > (std::vector< std::unique_ptr< MeshLib::Mesh >> const &meshes, std::map< std::string, std::unique_ptr< GlobalLinearSolver >> const &linear_solvers, BaseLib::ConfigTree const &config, std::string const &output_directory)
 
template<>
std::unique_ptr< ChemicalSolverInterfacecreateChemicalSolverInterface< ChemicalSolver::PhreeqcKernel > (std::vector< std::unique_ptr< MeshLib::Mesh >> const &meshes, std::map< std::string, std::unique_ptr< GlobalLinearSolver >> const &linear_solvers, BaseLib::ConfigTree const &config, std::string const &)
 
template<ChemicalSolver chemical_solver>
std::unique_ptr< ChemicalSolverInterfacecreateChemicalSolverInterface (std::vector< std::unique_ptr< MeshLib::Mesh >> const &meshes, std::map< std::string, std::unique_ptr< GlobalLinearSolver >> const &linear_solvers, BaseLib::ConfigTree const &config, std::string const &output_directory)
 

Enumeration Type Documentation

◆ ChargeBalance

Enumerator
pH 
pe 
Unspecified 

Definition at line 15 of file ChargeBalance.h.

◆ ChemicalSolver

Enumerator
Phreeqc 
PhreeqcKernel 

Definition at line 15 of file ChemicalSolverType.h.

Function Documentation

◆ createChargeBalance()

ChargeBalance ChemistryLib::createChargeBalance ( BaseLib::ConfigTree const &  config)
Input File Parameter:
prj__chemical_system__solution__charge_balance

Definition at line 19 of file CreateChargeBalance.cpp.

20 {
21  auto const charge_balance =
23  config.getConfigParameterOptional<std::string>("charge_balance");
24 
25  if (!charge_balance)
26  {
27  return ChargeBalance::Unspecified;
28  }
29  if (*charge_balance == "pH")
30  {
31  return ChargeBalance::pH;
32  }
33  if (*charge_balance == "pe")
34  {
35  return ChargeBalance::pe;
36  }
37 
38  OGS_FATAL(
39  "Error in specifying the way in which charge balance is achieved. "
40  "Adjusting pH value or pe value are supported at this moment.");
41 }
#define OGS_FATAL(...)
Definition: Error.h:26

References BaseLib::ConfigTree::getConfigParameterOptional(), OGS_FATAL, pe, pH, and Unspecified.

Referenced by ChemistryLib::PhreeqcIOData::createAqueousSolution(), and ChemistryLib::PhreeqcKernelData::createInitialAqueousSolution().

◆ createChemicalSolverInterface()

template<ChemicalSolver chemical_solver>
std::unique_ptr<ChemicalSolverInterface> ChemistryLib::createChemicalSolverInterface ( std::vector< std::unique_ptr< MeshLib::Mesh >> const &  meshes,
std::map< std::string, std::unique_ptr< GlobalLinearSolver >> const &  linear_solvers,
BaseLib::ConfigTree const &  config,
std::string const &  output_directory 
)

◆ createChemicalSolverInterface< ChemicalSolver::Phreeqc >()

template<>
std::unique_ptr<ChemicalSolverInterface> ChemistryLib::createChemicalSolverInterface< ChemicalSolver::Phreeqc > ( std::vector< std::unique_ptr< MeshLib::Mesh >> const &  meshes,
std::map< std::string, std::unique_ptr< GlobalLinearSolver >> const &  linear_solvers,
BaseLib::ConfigTree const &  config,
std::string const &  output_directory 
)
Input File Parameter:
prj__chemical_system__mesh
Input File Parameter:
prj__chemical_system__linear_solver
Input File Parameter:
prj__chemical_system__rates
Input File Parameter:
prj__chemical_system__surface
Input File Parameter:
prj__chemical_system__knobs
Input File Parameter:
prj__chemical_system__user_punch
Input File Parameter:
prj__chemical_system__use_high_precision

Definition at line 41 of file CreateChemicalSolverInterface.cpp.

70 {
71  auto mesh_name =
73  config.getConfigParameter<std::string>("mesh");
74 
75  // Find and extract mesh from the list of meshes.
76  auto const& mesh = *BaseLib::findElementOrError(
77  std::begin(meshes), std::end(meshes),
78  [&mesh_name](auto const& mesh)
79  {
80  assert(mesh != nullptr);
81  return mesh->getName() == mesh_name;
82  },
83  "Required mesh with name '" + mesh_name + "' not found.");
84 
85  assert(mesh.getID() != 0);
86  DBUG("Found mesh '{:s}' with id {:d}.", mesh.getName(), mesh.getID());
87 
88  auto const ls_name =
90  config.getConfigParameter<std::string>("linear_solver");
91  auto& linear_solver = BaseLib::getOrError(
92  linear_solvers, ls_name,
93  "A linear solver with the given name does not exist.");
94 
95  auto path_to_database = parseDatabasePath(config);
96 
97  // chemical system
98  auto chemical_system =
99  PhreeqcIOData::createChemicalSystem(config, *meshes[0]);
100 
101  // rates
102  auto reaction_rates = createReactionRates<PhreeqcIOData::ReactionRate>(
104  config.getConfigSubtreeOptional("rates"));
105 
106  // surface
107  auto surface = PhreeqcIOData::createSurface(
109  config.getConfigSubtreeOptional("surface"));
110 
111  // exchange
112  auto const& exchangers = chemical_system->exchangers;
113 
114  // dump
115  auto const project_file_name = BaseLib::joinPaths(
116  output_directory,
117  BaseLib::extractBaseNameWithoutExtension(config.getProjectFileName()));
118 
119  if (!surface.empty() && !exchangers.empty())
120  {
121  OGS_FATAL(
122  "Using surface and exchange reactions simultaneously is not "
123  "supported at the moment");
124  }
125 
126  auto dump = surface.empty() && exchangers.empty()
127  ? nullptr
128  : std::make_unique<PhreeqcIOData::Dump>(project_file_name);
129 
130  // knobs
131  auto knobs = PhreeqcIOData::createKnobs(
133  config.getConfigSubtree("knobs"));
134 
135  // user punch
136  auto user_punch = PhreeqcIOData::createUserPunch(
138  config.getConfigSubtreeOptional("user_punch"), *meshes[0]);
139 
140  // output
141  auto const use_high_precision =
143  config.getConfigParameter<bool>("use_high_precision", true);
144  auto output = PhreeqcIOData::createOutput(
145  *chemical_system, user_punch, use_high_precision, project_file_name);
146 
147  return std::make_unique<PhreeqcIOData::PhreeqcIO>(
148  *linear_solver, std::move(project_file_name),
149  std::move(path_to_database), std::move(chemical_system),
150  std::move(reaction_rates), std::move(surface), std::move(user_punch),
151  std::move(output), std::move(dump), std::move(knobs));
152 }
void DBUG(char const *fmt, Args const &... args)
Definition: Logging.h:27
Map::mapped_type & getOrError(Map &map, Key const &key, std::string const &error_message)
Definition: Algorithm.h:147
std::string extractBaseNameWithoutExtension(std::string const &pathname)
Definition: FileTools.cpp:180
std::string joinPaths(std::string const &pathA, std::string const &pathB)
Definition: FileTools.cpp:212
std::iterator_traits< InputIt >::reference findElementOrError(InputIt begin, InputIt end, Predicate predicate, std::string const &error="")
Definition: Algorithm.h:69
std::unique_ptr< UserPunch > createUserPunch(std::optional< BaseLib::ConfigTree > const &config, MeshLib::Mesh const &mesh)
std::unique_ptr< Output > createOutput(ChemicalSystem const &chemical_system, std::unique_ptr< UserPunch > const &user_punch, bool const use_high_precision, std::string const &project_file_name)
std::unique_ptr< ChemicalSystem > createChemicalSystem(BaseLib::ConfigTree const &config, MeshLib::Mesh &mesh)
Knobs createKnobs(BaseLib::ConfigTree const &config)
Definition: CreateKnobs.cpp:20
bool createSurface(GeoLib::Polyline const &ply, GeoLib::GEOObjects &geometries, std::string const &geometry_name, std::string const &gmsh_binary)
std::string parseDatabasePath(BaseLib::ConfigTree const &config)

References BaseLib::ConfigTree::getConfigParameter(), BaseLib::getProjectDirectory(), INFO(), BaseLib::IsFileExisting(), BaseLib::joinPaths(), and OGS_FATAL.

◆ createChemicalSolverInterface< ChemicalSolver::PhreeqcKernel >()

template<>
std::unique_ptr<ChemicalSolverInterface> ChemistryLib::createChemicalSolverInterface< ChemicalSolver::PhreeqcKernel > ( std::vector< std::unique_ptr< MeshLib::Mesh >> const &  meshes,
std::map< std::string, std::unique_ptr< GlobalLinearSolver >> const &  linear_solvers,
BaseLib::ConfigTree const &  config,
std::string const &   
)
Input File Parameter:
prj__chemical_system__linear_solver
Input File Parameter:
prj__chemical_system__solution
Input File Parameter:
prj__chemical_system__kinetic_reactants
Input File Parameter:
prj__chemical_system__rates
Input File Parameter:
prj__chemical_system__equilibrium_reactants

Definition at line 41 of file CreateChemicalSolverInterface.cpp.

161 {
162  auto mesh = *meshes[0];
163 
164  auto const ls_name =
166  config.getConfigParameter<std::string>("linear_solver");
167  auto& linear_solver = BaseLib::getOrError(
168  linear_solvers, ls_name,
169  "A linear solver with the given name does not exist.");
170 
171  auto path_to_database = parseDatabasePath(config);
172 
173  // TODO (renchao): remove mapping process id to component name.
174  std::vector<std::pair<int, std::string>> process_id_to_component_name_map;
175  // solution
176  auto aqueous_solution = PhreeqcKernelData::createAqueousSolution(
178  config.getConfigSubtree("solution"),
179  process_id_to_component_name_map);
180 
181  // kinetic reactants
182  auto kinetic_reactants = PhreeqcKernelData::createKineticReactants(
184  config.getConfigSubtreeOptional("kinetic_reactants"), mesh);
185 
186  // rates
187  auto reaction_rates = createReactionRates<PhreeqcKernelData::ReactionRate>(
189  config.getConfigSubtreeOptional("rates"));
190 
191  // equilibrium reactants
192  auto equilibrium_reactants = PhreeqcKernelData::createEquilibriumReactants(
194  config.getConfigSubtreeOptional("equilibrium_reactants"), mesh);
195 
196  return std::make_unique<PhreeqcKernelData::PhreeqcKernel>(
197  *linear_solver, mesh.getNumberOfBaseNodes(),
198  process_id_to_component_name_map, std::move(path_to_database),
199  std::move(aqueous_solution), std::move(equilibrium_reactants),
200  std::move(kinetic_reactants), std::move(reaction_rates));
201 }
std::unique_ptr< AqueousSolution > createAqueousSolution(BaseLib::ConfigTree const &config, MeshLib::Mesh &mesh)
std::vector< EquilibriumReactant > createEquilibriumReactants(std::optional< BaseLib::ConfigTree > const &config, MeshLib::Mesh &mesh)
std::vector< KineticReactant > createKineticReactants(std::optional< BaseLib::ConfigTree > const &config, MeshLib::Mesh &mesh)

◆ createReactionRates()

template<typename ReactionRate >
std::vector< ReactionRate > ChemistryLib::createReactionRates ( std::optional< BaseLib::ConfigTree > const &  config)
Input File Parameter:
prj__chemical_system__rates__rate
Input File Parameter:
prj__chemical_system__rates__rate__kinetic_reactant
Input File Parameter:
prj__chemical_system__rates__rate__expression
Input File Parameter:
prj__chemical_system__rates__rate__expression__statement

Definition at line 20 of file CreateReactionRate.cpp.

22 {
23  if (!config)
24  {
25  return {};
26  }
27 
28  std::vector<ReactionRate> reaction_rates;
29  for (auto const& rate_config :
31  config->getConfigSubtreeList("rate"))
32  {
33  auto kinetic_reactant =
35  rate_config.getConfigParameter<std::string>("kinetic_reactant");
36 
37  auto const expression_config =
39  rate_config.getConfigSubtree("expression");
40  auto const& statements =
42  expression_config.getConfigParameterList<std::string>("statement");
43 
44  std::vector<std::string> expression_statements;
45  expression_statements.reserve(statements.size());
46  std::copy(begin(statements),
47  end(statements),
48  back_inserter(expression_statements));
49 
50  reaction_rates.emplace_back(std::move(kinetic_reactant),
51  std::move(expression_statements));
52  }
53 
54  return reaction_rates;
55 }
void copy(PETScVector const &x, PETScVector &y)
Definition: LinAlg.cpp:37

References MathLib::LinAlg::copy().

◆ createReactionRates< PhreeqcIOData::ReactionRate >()

◆ createReactionRates< PhreeqcKernelData::ReactionRate >()