GeochemistryKineticRateCalculator.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html

#pragma once

#include "MooseTypes.h"
#include "DenseMatrix.h"
#include "GeochemistryConstants.h"

enum DirectionChoiceEnum
{
  BOTH,
  DISSOLUTION,
  PRECIPITATION,
  RAW,
  DEATH
};

struct KineticRateUserDescription
{
  KineticRateUserDescription(const std::string & kinetic_species_name,
                             Real intrinsic_rate_constant,
                             Real area_quantity,
                             bool multiply_by_mass,
                             Real kinetic_molal_index,
                             Real kinetic_monod_index,
                             Real kinetic_half_saturation,
                             const std::vector<std::string> & promoting_species,
                             const std::vector<Real> & promoting_indices,
                             const std::vector<Real> & promoting_monod_indices,
                             const std::vector<Real> & promoting_half_saturation,
                             Real theta,
                             Real eta,
                             Real activation_energy,
                             Real one_over_T0,
                             DirectionChoiceEnum direction,
                             std::string progeny,
                             Real progeny_efficiency,
                             Real kinetic_bio_efficiency,
                             Real energy_captured)
    : kinetic_species_name(kinetic_species_name),
      intrinsic_rate_constant(intrinsic_rate_constant),
      area_quantity(area_quantity),
      multiply_by_mass(multiply_by_mass),
      kinetic_molal_index(kinetic_molal_index),
      kinetic_monod_index(kinetic_monod_index),
      kinetic_half_saturation(kinetic_half_saturation),
      promoting_species(promoting_species),
      promoting_indices(promoting_indices),
      promoting_monod_indices(promoting_monod_indices),
      promoting_half_saturation(promoting_half_saturation),
      theta(theta),
      eta(eta),
      activation_energy(activation_energy),
      one_over_T0(one_over_T0),
      direction(direction),
      progeny(progeny),
      progeny_efficiency(progeny_efficiency),
      kinetic_bio_efficiency(kinetic_bio_efficiency),
      energy_captured(energy_captured)
  {
    if (promoting_species.size() != promoting_indices.size())
      mooseError("The promoting_species and promoting_indices vectors must be the same size");
    if (promoting_species.size() != promoting_monod_indices.size())
      mooseError("The promoting_species and promoting_monod_indices vectors must be the same size");
    if (promoting_species.size() != promoting_half_saturation.size())
      mooseError(
          "The promoting_species and promoting_half_saturation vectors must be the same size");
    std::unordered_map<std::string, int> check_for_repeats;
    for (const std::string & name : promoting_species)
      if (check_for_repeats.count(name) == 1)
        mooseError("Promoting species ", name, " has already been provided with an exponent");
      else
        check_for_repeats[name] = 1;
  };

  bool operator==(const KineticRateUserDescription & rhs) const
  {
    return (kinetic_species_name == rhs.kinetic_species_name) &&
           (intrinsic_rate_constant == rhs.intrinsic_rate_constant) &&
           (area_quantity == rhs.area_quantity) && (multiply_by_mass == rhs.multiply_by_mass) &&
           (kinetic_molal_index == rhs.kinetic_molal_index) &&
           (kinetic_monod_index == rhs.kinetic_monod_index) &&
           (kinetic_half_saturation == rhs.kinetic_half_saturation) &&
           (promoting_species == rhs.promoting_species) &&
           (promoting_indices == rhs.promoting_indices) &&
           (promoting_monod_indices == rhs.promoting_monod_indices) &&
           (promoting_half_saturation == rhs.promoting_half_saturation) && (theta == rhs.theta) &&
           (eta == rhs.eta) && (activation_energy == rhs.activation_energy) &&
           (one_over_T0 == rhs.one_over_T0) && (direction == rhs.direction) &&
           (progeny == rhs.progeny) && (progeny_efficiency == rhs.progeny_efficiency) &&
           (kinetic_bio_efficiency == rhs.kinetic_bio_efficiency) &&
           (energy_captured == rhs.energy_captured);
  };

  std::string kinetic_species_name;
  Real intrinsic_rate_constant;
  Real area_quantity;
  bool multiply_by_mass;
  Real kinetic_molal_index;
  Real kinetic_monod_index;
  Real kinetic_half_saturation;
  std::vector<std::string> promoting_species;
  std::vector<Real> promoting_indices;
  std::vector<Real> promoting_monod_indices;
  std::vector<Real> promoting_half_saturation;
  Real theta;
  Real eta;
  Real activation_energy;
  Real one_over_T0;
  DirectionChoiceEnum direction;
  std::string progeny;
  Real progeny_efficiency;
  Real kinetic_bio_efficiency;
  Real energy_captured;
};

namespace GeochemistryKineticRateCalculator
{
void calculateRate(const std::vector<Real> & promoting_indices,
                   const std::vector<Real> & promoting_monod_indices,
                   const std::vector<Real> & promoting_half_saturation,
                   const KineticRateUserDescription & description,
                   const std::vector<std::string> & basis_species_name,
                   const std::vector<bool> & basis_species_gas,
                   const std::vector<Real> & basis_molality,
                   const std::vector<Real> & basis_activity,
                   const std::vector<bool> & basis_activity_known,
                   const std::vector<std::string> & eqm_species_name,
                   const std::vector<bool> & eqm_species_gas,
                   const std::vector<Real> & eqm_molality,
                   const std::vector<Real> & eqm_activity,
                   const DenseMatrix<Real> & eqm_stoichiometry,
                   Real kin_moles,
                   Real kin_species_molecular_weight,
                   Real log10K,
                   Real log10_activity_product,
                   const DenseMatrix<Real> & kin_stoichiometry,
                   unsigned kin,
                   Real temp_degC,
                   Real & rate,
                   Real & drate_dkin,
                   std::vector<Real> & drate_dmol);
}