Reaction.h

#pragma once
 
#include <utility>
#include <string>
#include <vector>
#include <unordered_map>
#include "yaml-cpp/yaml.h"
#include "Species.h"
#include "Constants.h"
 
namespace prism
{
struct TabulatedReactionData
{
  double energy;
  double value;
 
  bool operator<(const TabulatedReactionData & other) const { return energy < other.energy; }
  bool operator<(const double other) const { return energy < other; }
  bool operator==(const TabulatedReactionData & other) const
  {
    return (energy == other.energy) && (value == other.value);
  }
};
 
struct SpeciesData
{
  SpeciesId id;
  unsigned int occurances;
};
 
class Reaction
{
public:
  Reaction(const YAML::Node & rxn_input,
           const int rxn_id = 0,
           const std::string & data_path = "",
           const std::string & bib_file = "",
           const bool check_refs = true,
           const bool read_xsec_files = true,
           const std::string & delimiter = " ");
 
  const std::string & expression() const { return _expression; }
  const std::string & latexRepresentation() const { return _latex_expression; }
  ReactionId id() const { return _id; }
  const std::vector<std::string> & references() const { return _references; }
  const std::vector<std::string> & notes() const { return _notes; }
  bool hasTabulatedData() const { return _has_tabulated_data; }
  double deltaEnergyElectron() const { return _delta_eps_e; }
  double deltaEnergyGas() const { return _delta_eps_g; }
  const std::vector<SpeciesData> & reactantData() const { return _reactant_data; }
  const std::vector<SpeciesData> & productData() const { return _product_data; }
  bool isElastic() const { return _is_elastic; }
  const std::vector<std::shared_ptr<const Species>> species() const;
  const std::string getReferencesAsString() const;
  const std::vector<double> & functionParams() const;
  const std::vector<TabulatedReactionData> & tabulatedData() const;
  int getStoicCoeffByName(const std::string & s_expression) const;
  int getStoicCoeffById(const SpeciesId id) const;
  bool operator==(const Reaction & other) const;
  bool operator!=(const Reaction & other) const;
  double sampleData(const double T_e, const double T_g = 0) const { return _sampler(T_e, T_g); }
 
private:
  friend class SpeciesFactory;
  friend class NetworkParser;
  std::string checkExpression(const YAML::Node & rxn_input);
 
  unsigned int getCoeff(std::string & s);
 
  void setSides();
  void validateReaction();
  void setLatexRepresentation();
  void substituteLumped();
  void checkReferences();
  void collectUniqueSpecies();
  void setSpeciesData();
  double interpolator(const double T_e, const double T_g) const;
  double constantRate(const double T_e, const double T_g) const;
  double partialArrhenius1(const double T_e, const double T_g) const;
  double partialArrhenius2(const double T_e, const double T_g) const;
  double partialArrhenius3(const double T_e, const double T_g) const;
  double fullArrhenius(const double T_e, const double T_g) const;
  std::function<double(double, double)> _sampler;
  const ReactionId _id;
  const std::string _data_path;
  const std::string _expression;
  const double _delta_eps_e;
  const double _delta_eps_g;
  const bool _is_elastic;
  const std::string _bib_file;
  const std::vector<std::string> _references;
  bool _has_tabulated_data;
  std::vector<std::string> _notes;
  std::vector<double> _params;
  std::vector<TabulatedReactionData> _tabulated_data;
  std::vector<std::weak_ptr<Species>> _species;
  std::unordered_map<std::string, int> _stoic_coeffs;
  std::unordered_map<SpeciesId, int> _id_stoic_map;
  std::string _latex_expression;
 
  std::vector<std::weak_ptr<Species>> _reactants;
  std::vector<std::weak_ptr<Species>> _products;
  std::unordered_map<std::string, unsigned int> _reactant_count;
  std::unordered_map<std::string, unsigned int> _product_count;
  std::vector<SpeciesData> _reactant_data;
  std::vector<SpeciesData> _product_data;
};
}
 
template <>
struct std::hash<prism::Reaction>
{
  size_t operator()(const prism::Reaction & obj) const;
};