Species.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 "SpeciesBase.h"
#include "PrismConstants.h"
 
#include <vector>
#include <memory>
 
namespace prism
{

struct ReactionData
{
  ReactionId id;
  int stoic_coeff;
};
 
class Reaction;
class SubSpecies;

class Species : public SpeciesBase
{
public:
  Species(const std::string & name, const bool marked_constant = false);
  SpeciesId id() const { return _id; }
  bool markedConstant() const { return _marked_constant; }
  bool isConstant() const
  {
    return _unbalanced_rate_based_data.size() + _unbalanced_xsec_based_data.size() == 0 ||
           _marked_constant;
  }
 
  // /** Comparison operator checks if the sub species have the same member variables */
  bool operator==(const Species & other) const;
  bool operator!=(const Species & other) const;
  const std::vector<std::shared_ptr<const Reaction>> rateBasedReactions() const
  {
    return convertToSharedPtr(_rate_based);
  }

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

  const std::vector<std::shared_ptr<const Reaction>> tabulatedRateBasedReactions() const
  {
    return convertToSharedPtr(_tabulated_rate_based);
  }

  const std::vector<std::shared_ptr<const Reaction>> functionRateBasedReactions() const
  {
    return convertToSharedPtr(_function_rate_based);
  }

  const std::vector<std::shared_ptr<const Reaction>> tabulatedXSecBasedReactions() const
  {
    return convertToSharedPtr(_tabulated_xsec_based);
  }

  const std::vector<std::shared_ptr<const Reaction>> functionXSecBasedReactions() const
  {
    return convertToSharedPtr(_function_xsec_based);
  }

  const std::vector<ReactionData> & rateBasedReactionData() const { return _rate_based_data; }
  const std::vector<ReactionData> & tabulatedRateBasedReactionData() const
  {
    return _tabulated_rate_based_data;
  }

  const std::vector<ReactionData> & functionRateBasedReactionData() const
  {
    return _function_rate_based_data;
  }

  const std::vector<ReactionData> & xsecBasedReactionData() const { return _xsec_based_data; }
  const std::vector<ReactionData> & tabulatedXSecBasedReactionData() const
  {
    return _tabulated_xsec_based_data;
  }

  const std::vector<ReactionData> & functionXSecBasedReactionData() const
  {
    return _function_xsec_based_data;
  }

  const std::vector<ReactionData> & unbalancedRateBasedReactionData() const
  {
    return _unbalanced_rate_based_data;
  }

  const std::vector<ReactionData> & unbalancedTabulatedRateBasedReactionData() const
  {
    return _unbalanced_tabulated_rate_based_data;
  }

  const std::vector<ReactionData> & unbalancedFunctionRateBasedReactionData() const
  {
    return _unbalanced_function_rate_based_data;
  }

  const std::vector<ReactionData> & unbalancedXSecBasedReactionData() const
  {
    return _unbalanced_xsec_based_data;
  }

  const std::vector<ReactionData> & unbalancedTabulatedXSecBasedReactionData() const
  {
    return _unbalanced_tabulated_xsec_based_data;
  }

  const std::vector<ReactionData> & unbalancedFunctionXSecBasedReactionData() const
  {
    return _unbalanced_function_xsec_based_data;
  }

  const std::vector<SubSpecies> & subSpecies() const { return _sub_species; }
 
  virtual std::string to_string() const override;
  friend std::string to_string(const std::shared_ptr<prism::Species> & s);
  friend std::string to_string(const std::shared_ptr<const prism::Species> & s);
  friend std::ostream & operator<<(std::ostream & os, const std::shared_ptr<prism::Species> & s);
  friend std::ostream & operator<<(std::ostream & os,
                                   const std::shared_ptr<const prism::Species> & s);
 
private:
  friend class SpeciesFactory;
  SpeciesId _id;
  const bool _marked_constant;
  const std::vector<SubSpecies> _sub_species;
  std::vector<ReactionData> _rate_based_data;
  std::vector<ReactionData> _tabulated_rate_based_data;
  std::vector<ReactionData> _function_rate_based_data;
  std::vector<ReactionData> _unbalanced_rate_based_data;
  std::vector<ReactionData> _unbalanced_tabulated_rate_based_data;
  std::vector<ReactionData> _unbalanced_function_rate_based_data;
  std::vector<std::weak_ptr<const Reaction>> _rate_based;
  std::vector<std::weak_ptr<const Reaction>> _tabulated_rate_based;
  std::vector<std::weak_ptr<const Reaction>> _function_rate_based;

  std::vector<ReactionData> _xsec_based_data;
  std::vector<ReactionData> _tabulated_xsec_based_data;
  std::vector<ReactionData> _function_xsec_based_data;
  std::vector<ReactionData> _unbalanced_xsec_based_data;
  std::vector<ReactionData> _unbalanced_tabulated_xsec_based_data;
  std::vector<ReactionData> _unbalanced_function_xsec_based_data;
  std::vector<std::weak_ptr<const Reaction>> _xsec_based;
  std::vector<std::weak_ptr<const Reaction>> _tabulated_xsec_based;
  std::vector<std::weak_ptr<const Reaction>> _function_xsec_based;

  void setLatexName() override;
  const std::vector<SubSpecies> decomposeSpecies();
  void setMass() override;
  void setCharge() override;
  virtual void setNeutralGroundState() override;
  const std::vector<std::shared_ptr<const Reaction>>
  convertToSharedPtr(const std::vector<std::weak_ptr<const Reaction>> & vec) const;
 
  void setId(SpeciesId id) { _id = id; }
};
}
 
template <>
struct std::hash<prism::Species>
{
  size_t operator()(const prism::Species & obj) const;
};