NetworkParser.h

//* This file is a part of PRISM: Plasma Reaction Input SysteM,
//* A library for parcing chemical reaction networks for plasma chemistry
//* https://github.com/NCSU-ComPS-Group/prism
//*
//* Licensed under MIT, please see LICENSE for details
//* https://opensource.org/license/mit
//*
//* Copyright 2024, North Carolina State University
//* ALL RIGHTS RESERVED
//*
#pragma once
 
#include "PrismConstants.h"
 
#include <vector>
#include <string>
#include <unordered_map>
#include "yaml-cpp/yaml.h"
namespace prism
{
 
class Reaction;
class Species;
class SpeciesFactory;
class BibTexHelper;
class TableWriterBase;
class SpeciesSummaryWriterBase;

class NetworkParser
{
public:
  static NetworkParser & instance();
  void clear();
  void parseNetwork(const std::string & file);
 
// These methods are only available in testing mode
// this allows for easier unit testing and should never
// be made available for end users
#ifdef TESTING
  void setCheckRefs(const bool check_refs) { _check_refs = check_refs; }
  void setReadXsecFiles(const bool read_xsec_files) { _read_xsec_files = read_xsec_files; }
#endif
 
  // Various getter methods for the different categories of reactions
  // note these methods will exit the program if you have any errors in your reaction network
  // we do not let users to perform a simulation with errors in the network or with lack of
  // documentation
  const std::vector<std::shared_ptr<Reaction>> & rateBasedReactions() const
  {
    preventInvalidDataFetch();
    return _rate_based;
  }

  const std::vector<std::shared_ptr<Reaction>> & xsecBasedReactions() const
  {
    preventInvalidDataFetch();
    return _xsec_based;
  }

  const std::vector<std::shared_ptr<const Reaction>> & tabulatedXSecReactions() const
  {
    preventInvalidDataFetch();
    return _tabulated_xsec_based;
  }

  const std::vector<std::shared_ptr<const Reaction>> & functionXSecReactions() const
  {
    preventInvalidDataFetch();
    return _function_xsec_based;
  }

  const std::vector<std::shared_ptr<const Reaction>> & tabulatedRateReactions() const
  {
    preventInvalidDataFetch();
    return _tabulated_rate_based;
  }

  const std::vector<std::shared_ptr<const Reaction>> & functionRateReactions() const
  {
    preventInvalidDataFetch();
    return _function_rate_based;
  }

  const std::vector<std::shared_ptr<const Species>> & transientSpecies() const;
  const std::vector<std::string> & speciesNames() const;

  const std::vector<std::shared_ptr<Species>> & species() const;

  void writeReactionTable(const std::string & file) const;
  void writeReactionTable(const std::string & file, TableWriterBase & writer) const;
  void writeSpeciesSummary(const std::string & file);
  void writeSpeciesSummary(const std::string & file, SpeciesSummaryWriterBase & writer) const;
 
private:
  NetworkParser();
  NetworkParser(const NetworkParser &) = delete;
  NetworkParser & operator=(const NetworkParser &) = delete;
  SpeciesFactory & _factory;
  BibTexHelper & _bib_helper;
  static NetworkParser * _instance;
  bool _network_has_errors;
  bool _network_has_bib_errors;
  bool _check_refs;
  bool _read_xsec_files;
  std::unordered_map<std::string, YAML::Node> _networks;
  std::unordered_map<std::string, std::string> _bibs;
  std::unordered_map<std::string, std::string> _data_paths;
  std::unordered_map<std::string, std::string> _delimiters;
  ReactionId _rate_id;
  ReactionId _xsec_id;
  void checkFile(const std::string & file) const;
  void checkBibFile(const YAML::Node & network, const std::string & file) const;

  void parseReactions(const YAML::Node & inputs,
                      ReactionId * rxn_id,
                      std::vector<std::shared_ptr<Reaction>> * rxn_list,
                      std::vector<std::shared_ptr<const Reaction>> * tabulated_rxn_list,
                      std::vector<std::shared_ptr<const Reaction>> * function_rxn_list,
                      const std::string & type,
                      const std::string & data_path,
                      const std::string & bib_file,
                      const std::string & _delimiter);
 
  void tableHelper(TableWriterBase & writer,
                   void (TableWriterBase::*beginTable)(),
                   void (TableWriterBase::*endTable)(),
                   void (TableWriterBase::*addReaction)(const std::shared_ptr<const Reaction> & r),
                   const std::vector<std::shared_ptr<const Reaction>> & rxn_list) const;
  void preventInvalidDataFetch() const;

  std::vector<std::shared_ptr<Reaction>> _rate_based;
  std::vector<std::shared_ptr<const Reaction>> _tabulated_rate_based;
  std::vector<std::shared_ptr<const Reaction>> _function_rate_based;
  std::vector<std::shared_ptr<Reaction>> _xsec_based;
  std::vector<std::shared_ptr<const Reaction>> _tabulated_xsec_based;
  std::vector<std::shared_ptr<const Reaction>> _function_xsec_based;
};
}