composition.h

Go to the documentation of this file.

/* ***********************************************************************
//
//   Copyright (C) 2025 -- The 4D-STAR Collaboration
//   File Author: Emily Boudreaux
//   Last Modified: March 26, 2025
//
//   4DSSE is free software; you can use it and/or modify
//   it under the terms and restrictions the GNU General Library Public
//   License version 3 (GPLv3) as published by the Free Software Foundation.
//
//   4DSSE is distributed in the hope that it will be useful,
//   but WITHOUT ANY WARRANTY; without even the implied warranty of
//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
//   See the GNU Library General Public License for more details.
//
//   You should have received a copy of the GNU Library General Public License
//   along with this software; if not, write to the Free Software
//   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// *********************************************************************** */
#pragma once
 
#include <string>
#include <unordered_map>
#include <set>
 
#include <utility>
 
#include "fourdst/config/config.h"
#include "fourdst/logging/logging.h"
#include "fourdst/composition/composition_abstract.h"
#include "fourdst/composition/atomicSpecies.h"
 
namespace fourdst::composition {
    struct CanonicalComposition {
        double X = 0.0; 
        double Y = 0.0; 
        double Z = 0.0; 

        friend std::ostream& operator<<(std::ostream& os, const CanonicalComposition& composition) {
            os << "<CanonicalComposition: "
               << "X = " << composition.X << ", "
               << "Y = " << composition.Y << ", "
               << "Z = " << composition.Z << ">";
            return os;
        }
    };

    struct GlobalComposition {
        double specificNumberDensity; 
        double meanParticleMass; 
 
        // Overload the output stream operator for GlobalComposition
        friend std::ostream& operator<<(std::ostream& os, const GlobalComposition& comp);
    };

    struct CompositionEntry {
        std::string m_symbol; 
        atomic::Species m_isotope; 
        bool m_massFracMode = true; 
 
        double m_massFraction = 0.0; 
        double m_numberFraction = 0.0; 
        double m_relAbundance = 0.0; 
        double m_molesPerMass = 0.0;
        double m_cachedNumberFraction = 0.0; 
 
 
        bool m_initialized = false; 

        CompositionEntry();

        explicit CompositionEntry(const std::string& symbol, bool massFracMode=true);

        CompositionEntry(const CompositionEntry& entry);

        void setSpecies(const std::string& symbol);

        [[nodiscard]] std::string symbol() const;

        [[nodiscard]] double mass_fraction() const;

        [[nodiscard]] double number_fraction() const;

        [[nodiscard]] double number_fraction(double totalMolesPerMass) const;

        [[nodiscard]] double rel_abundance() const;

        [[nodiscard]] atomic::Species isotope() const;

        [[nodiscard]] bool getMassFracMode() const;

        void setMassFraction(double mass_fraction);

        void setNumberFraction(double number_fraction);

        bool setMassFracMode(double meanMolarMass);

        bool setNumberFracMode(double totalMolesPerMass);

        friend std::ostream& operator<<(std::ostream& os, const CompositionEntry& entry);
    };

    class Composition : public CompositionAbstract {
    private:
        struct CompositionCache {
            std::optional<GlobalComposition> globalComp; 
            std::optional<CanonicalComposition> canonicalComp; 
            std::optional<std::vector<double>> massFractions; 
            std::optional<std::vector<double>> numberFractions; 
            std::optional<std::vector<double>> molarAbundances; 
            std::optional<std::vector<atomic::Species>> sortedSpecies; 
            std::optional<std::vector<std::string>> sortedSymbols; 
            std::optional<double> Ye; 
 
            void clear() {
                globalComp = std::nullopt;
                canonicalComp = std::nullopt;
                massFractions = std::nullopt;
                numberFractions = std::nullopt;
                molarAbundances = std::nullopt;
                sortedSymbols = std::nullopt;
                sortedSpecies = std::nullopt;
                Ye = std::nullopt;
            }
 
            [[nodiscard]] bool is_clear() const {
                return !globalComp.has_value() && !canonicalComp.has_value() && !massFractions.has_value() &&
                       !numberFractions.has_value() && !molarAbundances.has_value() && !sortedSymbols.has_value() &&
                       !Ye.has_value() && !sortedSpecies.has_value();
            }
        };
    private:
        config::Config& m_config = config::Config::getInstance();
        logging::LogManager& m_logManager = logging::LogManager::getInstance();
        quill::Logger* m_logger = m_logManager.getLogger("log");
 
        bool m_finalized = false; 
        double m_specificNumberDensity = 0.0; 
        double m_meanParticleMass = 0.0; 
        bool m_massFracMode = true; 
 
        std::set<std::string> m_registeredSymbols; 
        std::unordered_map<std::string, CompositionEntry> m_compositions; 
 
        mutable CompositionCache m_cache; 
 

        static bool isValidSymbol(const std::string& symbol);

        [[nodiscard]] bool isValidComposition(const std::vector<double>& fractions) const;

        void validateComposition(const std::vector<double>& fractions) const;

        bool finalizeMassFracMode(bool norm);

        bool finalizeNumberFracMode(bool norm);
 
    public:
        Composition() = default;

        ~Composition() override = default;

        [[nodiscard]] bool finalize(bool norm=false);

        explicit Composition(const std::vector<std::string>& symbols);

        explicit Composition(const std::set<std::string>& symbols);

        Composition(const std::vector<std::string>& symbols, const std::vector<double>& fractions, bool massFracMode=true);

        Composition(const Composition& composition);

        Composition& operator=(Composition const& other);

        void registerSymbol(const std::string& symbol, bool massFracMode=true);

        void registerSymbol(const std::vector<std::string>& symbols, bool massFracMode=true);

        void registerSpecies(const fourdst::atomic::Species& species, bool massFracMode=true);
 

        void registerSpecies(const std::vector<fourdst::atomic::Species>& species, bool massFracMode=true);
 

        [[nodiscard]] std::set<std::string> getRegisteredSymbols() const override;

        [[nodiscard]] std::set<fourdst::atomic::Species> getRegisteredSpecies() const override;

        double setMassFraction(const std::string& symbol, const double& mass_fraction);

        std::vector<double> setMassFraction(const std::vector<std::string>& symbols, const std::vector<double>& mass_fractions);

        double setMassFraction(const fourdst::atomic::Species& species, const double& mass_fraction);

        std::vector<double> setMassFraction(const std::vector<fourdst::atomic::Species>& species, const std::vector<double>& mass_fractions);

        double setNumberFraction(const std::string& symbol, const double& number_fraction);

        std::vector<double> setNumberFraction(const std::vector<std::string>& symbols, const std::vector<double>& number_fractions);

        double setNumberFraction(const fourdst::atomic::Species& species, const double& number_fraction);

        std::vector<double> setNumberFraction(const std::vector<fourdst::atomic::Species>& species, const std::vector<double>& number_fractions);

        [[nodiscard]] Composition mix(const Composition& other, double fraction) const;

        [[nodiscard]] std::unordered_map<std::string, double> getMassFraction() const override;

        [[nodiscard]] double getMassFraction(const std::string& symbol) const override;

        [[nodiscard]] double getMassFraction(const fourdst::atomic::Species& species) const override;

        [[nodiscard]] double getNumberFraction(const std::string& symbol) const override;

        [[nodiscard]] double getNumberFraction(const fourdst::atomic::Species& species) const override;

        [[nodiscard]] std::unordered_map<std::string, double> getNumberFraction() const override;

        [[nodiscard]] double getMolarAbundance(const std::string& symbol) const override;

        [[nodiscard]] double getMolarAbundance(const fourdst::atomic::Species& species) const override;

        [[nodiscard]] std::pair<CompositionEntry, GlobalComposition> getComposition(const std::string& symbol) const;

        [[nodiscard]] std::pair<CompositionEntry, GlobalComposition> getComposition(const fourdst::atomic::Species& species) const;

        [[nodiscard]] std::pair<std::unordered_map<std::string, CompositionEntry>, GlobalComposition> getComposition() const;

        [[nodiscard]] double getMeanParticleMass() const override;

        [[nodiscard]] double getMeanAtomicNumber() const override;

        [[nodiscard]] double getElectronAbundance() const override;

        [[nodiscard]] Composition subset(const std::vector<std::string>& symbols, const std::string& method="norm") const;

        [[nodiscard]] bool hasSymbol(const std::string& symbol) const override;

        [[nodiscard]] bool hasSpecies(const fourdst::atomic::Species &species) const override;

        [[nodiscard]] bool contains(const atomic::Species& isotope) const override;

        void setCompositionMode(bool massFracMode);

        [[nodiscard]] CanonicalComposition getCanonicalComposition(bool harsh=false) const;

        [[nodiscard]] std::vector<double> getMassFractionVector() const override;

        [[nodiscard]] std::vector<double> getNumberFractionVector() const override;

        [[nodiscard]] std::vector<double> getMolarAbundanceVector() const override;

        [[nodiscard]] size_t getSpeciesIndex(const std::string& symbol) const override;

        [[nodiscard]] size_t getSpeciesIndex(const atomic::Species& species) const override;

        [[nodiscard]] atomic::Species getSpeciesAtIndex(size_t index) const override;

        friend std::ostream& operator<<(std::ostream& os, const Composition& composition);

        Composition operator+(const Composition& other) const;

        auto begin() {
            return m_compositions.begin();
        }

        [[nodiscard]] auto begin() const {
            return m_compositions.cbegin();
        }

        auto end() {
            return m_compositions.end();
        }

        [[nodiscard]] auto end() const {
            return m_compositions.cend();
        }
 
    };
}; // namespace fourdst::composition