feat(composition): added map overloads

src/composition/include/fourdst/composition/composition.h

@@ -25,6 +25,7 @@
 #include <set>
 
 #include <optional>
+#include <unordered_set>
 
 #include "fourdst/config/config.h"
 #include "fourdst/logging/logging.h"
@@ -218,6 +219,9 @@ namespace fourdst::composition {
          */
         explicit Composition(const std::set<atomic::Species>& species);
 
+        explicit Composition(const std::unordered_set<std::string>& symbols);
+        explicit Composition(const std::unordered_set<atomic::Species>& species);
+
         /**
          * @brief Constructs a Composition from symbols and their corresponding molar abundances.
          * @param symbols The symbols to register.
@@ -268,6 +272,13 @@ namespace fourdst::composition {
          */
         Composition(const std::set<std::string>& symbols, const std::vector<double>& molarAbundances);
 
+        explicit Composition(const std::unordered_map<std::string, double>& symbolMolarAbundances);
+        explicit Composition(const std::map<std::string, double>& symbolMolarAbundances);
+
+        explicit Composition(const std::unordered_map<atomic::Species, double>& speciesMolarAbundances);
+        explicit Composition(const std::map<atomic::Species, double>& speciesMolarAbundances);
+
+
         /**
          * @brief Constructs a Composition from another Composition.
          * @param composition The Composition to copy.

src/composition/include/fourdst/composition/utils.h

@@ -47,4 +47,44 @@ namespace fourdst::composition {
         const std::set<atomic::Species>& species,
         const std::vector<double>& massFractions
     );
+
+    /**
+     * @brief Build a Composition object from a map of species to mass fractions.
+     * @param massFractionsMap The map of species to their corresponding mass fractions.
+     * @return A Composition object constructed from the provided species and mass fractions.
+     * @throws exceptions::InvalidCompositionError if the provided mass fractions do not sum to within one part in 10^10 of 1.0.
+     */
+    Composition buildCompositionFromMassFractions(
+        const std::unordered_map<atomic::Species, double>& massFractionsMap
+    );
+
+    /**
+     * @brief Build a Composition object from a map of species to mass fractions.
+     * @param massFractions The map of species to their corresponding mass fractions.
+     * @return A Composition object constructed from the provided species and mass fractions.
+     * @throws exceptions::InvalidCompositionError if the provided mass fractions do not sum to within one part in 10^10 of 1.0.
+     */
+    Composition buildCompositionFromMassFractions(
+        const std::unordered_map<std::string, double>& massFractions
+    );
+
+    /**
+     * @brief Build a Composition object from a map of species to mass fractions.
+     * @param massFractions The map of species to their corresponding mass fractions.
+     * @return A Composition object constructed from the provided species and mass fractions.
+     * @throws exceptions::InvalidCompositionError if the provided mass fractions do not sum to within one part in 10^10 of 1.0.
+     */
+    Composition buildCompositionFromMassFractions(
+        std::map<atomic::Species, double> massFractions
+    );
+
+    /**
+     * @brief Build a Composition object from a map of species to mass fractions.
+     * @param massFractions The map of species to their corresponding mass fractions.
+     * @return A Composition object constructed from the provided species and mass fractions.
+     * @throws exceptions::InvalidCompositionError if the provided mass fractions do not sum to within one part in 10^10 of 1.0.
+     */
+    Composition buildCompositionFromMassFractions(
+        std::map<std::string, double> massFractions
+    );
 }

src/composition/lib/composition.cpp

@@ -113,6 +113,18 @@ namespace fourdst::composition {
         }
     }
 
+    Composition::Composition(const std::unordered_set<std::string> &symbols) {
+        for (const auto& symbol : symbols) {
+            registerSymbol(symbol);
+        }
+    }
+
+    Composition::Composition(const std::unordered_set<atomic::Species> &species) {
+        for (const auto& s : species) {
+            registerSpecies(s);
+        }
+    }
+
     Composition::Composition(
         const std::vector<std::string>& symbols,
         const std::vector<double>& molarAbundances
@@ -158,6 +170,34 @@ namespace fourdst::composition {
         }
     }
 
+    Composition::Composition(const std::unordered_map<std::string, double> &symbolMolarAbundances) {
+        for (const auto& [symbol, y] : symbolMolarAbundances) {
+            registerSymbol(symbol);
+            setMolarAbundance(symbol, y);
+        }
+    }
+
+    Composition::Composition(const std::map<std::string, double> &symbolMolarAbundances) {
+        for (const auto& [symbol, y] : symbolMolarAbundances) {
+            registerSymbol(symbol);
+            setMolarAbundance(symbol, y);
+        }
+    }
+
+    Composition::Composition(const std::unordered_map<atomic::Species, double> &speciesMolarAbundances) {
+        for (const auto& [species, y] : speciesMolarAbundances) {
+            registerSpecies(species);
+            setMolarAbundance(species, y);
+        }
+    }
+
+    Composition::Composition(const std::map<atomic::Species, double> &speciesMolarAbundances) {
+        for (const auto& [species, y] : speciesMolarAbundances) {
+            registerSpecies(species);
+            setMolarAbundance(species, y);
+        }
+    }
+
     Composition::Composition(
         const Composition &composition
     ) {

src/composition/lib/utils.cpp

@@ -68,7 +68,17 @@ namespace fourdst::composition {
     }
 
     Composition buildCompositionFromMassFractions(const std::vector<atomic::Species> &species, const std::vector<double> &massFractions) {
-        return buildCompositionFromMassFractions(std::set<atomic::Species>(species.begin(), species.end()), massFractions);
+        std::set<atomic::Species> speciesSet(species.begin(), species.end());
+        std::vector<double> sortedMassFractions;
+
+        sortedMassFractions.resize(massFractions.size());
+        for (const auto& [s, xi] : std::views::zip(species, massFractions)) {
+            const size_t index = std::distance(speciesSet.begin(), speciesSet.find(s));
+            assert (index < sortedMassFractions.size());
+            sortedMassFractions[index] = xi;
+        }
+
+        return buildCompositionFromMassFractions(speciesSet, sortedMassFractions);
     }
 
     Composition buildCompositionFromMassFractions(const std::vector<std::string> &symbols, const std::vector<double> &massFractions) {
@@ -80,6 +90,107 @@ namespace fourdst::composition {
             }
             species.insert(result.value());
         }
+
+        std::vector<double> sortedMassFractions(massFractions.size());
+        for (const auto& [symbol, xi] : std::views::zip(symbols, massFractions)) {
+            auto result = getSpecies(symbol);
+            if (!result) {
+                throw_unknown_symbol(symbol);
+            }
+            const size_t index = std::distance(species.begin(), species.find(result.value()));
+            assert (index < sortedMassFractions.size());
+            sortedMassFractions[index] = xi;
+        }
+        return buildCompositionFromMassFractions(species, sortedMassFractions);
+    }
+
+    Composition buildCompositionFromMassFractions(const std::unordered_map<atomic::Species, double>& massFractionsMap) {
+        std::set<atomic::Species> species;
+        std::vector<double> massFractions;
+
+        massFractions.reserve(massFractionsMap.size());
+
+        for (const auto &sp: massFractionsMap | std::views::keys) {
+            species.insert(sp);
+        }
+
+        massFractions.resize(massFractionsMap.size());
+        for (const auto& [sp, xi] : massFractionsMap) {
+            const size_t index = std::distance(species.begin(), species.find(sp));
+            assert (index < massFractions.size());
+            massFractions[index] = xi;
+        }
+
         return buildCompositionFromMassFractions(species, massFractions);
     }
+
+    Composition buildCompositionFromMassFractions(std::map<atomic::Species, double> massFractions) {
+        std::set<atomic::Species> species;
+        std::vector<double> massFractionVector;
+
+        massFractionVector.reserve(massFractions.size());
+
+        for (const auto& [sp, xi] : massFractions) {
+            species.insert(sp);
+            massFractionVector.push_back(xi);
+        }
+
+        return buildCompositionFromMassFractions(species, massFractionVector);
+    }
+
+    Composition buildCompositionFromMassFractions(std::map<std::string, double> massFractions) {
+        std::set<atomic::Species> species;
+        std::vector<double> massFractionVector;
+
+
+        for (const auto &symbol: massFractions | std::views::keys) {
+            auto result = getSpecies(symbol);
+            if (!result) {
+                throw_unknown_symbol(symbol);
+            }
+            species.insert(result.value());
+        }
+
+        massFractionVector.resize(massFractions.size());
+
+        for (const auto& [symbol, xi] : massFractions) {
+            auto result = getSpecies(symbol);
+            if (!result) {
+                throw_unknown_symbol(symbol);
+            }
+            const size_t index = std::distance(species.begin(), species.find(result.value()));
+            assert (index < massFractionVector.size());
+            massFractionVector[index] = xi;
+        }
+
+
+        return buildCompositionFromMassFractions(species, massFractionVector);
+    }
+
+    Composition buildCompositionFromMassFractions(const std::unordered_map<std::string, double>& massFractions) {
+        std::set<atomic::Species> species;
+        std::vector<double> massFractionVector;
+
+        for (const auto &symbol: massFractions | std::views::keys) {
+            auto result = getSpecies(symbol);
+            if (!result) {
+                throw_unknown_symbol(symbol);
+            }
+            species.insert(result.value());
+        }
+
+        massFractionVector.resize(massFractions.size());
+        for (const auto& [sp, xi] : massFractions) {
+            auto result = getSpecies(sp);
+            if (!result) {
+                throw_unknown_symbol(sp);
+            }
+            const size_t index = std::distance(species.begin(), species.find(result.value()));
+            assert (index < massFractionVector.size());
+            massFractionVector[index] = xi;
+        }
+
+        return buildCompositionFromMassFractions(species, massFractionVector);
+    }
+
 }