Merge remote-tracking branch 'upstream/main' into feature/mixedPolytrope

# Conflicts:
#	.gitignore
#	build-config/meson.build
#	meson.build
#	meson_options.txt
#	src/composition/public/composition.h
#	src/config/public/config.h
#	src/constants/public/const.h
#	src/meson.build
#	tests/composition_sandbox/comp.cpp

src/composition/meson.build

@@ -9,13 +9,12 @@ composition_headers = files(
 
 dependencies = [
     probe_dep,
-    config_dep,
     quill_dep,
     species_weight_dep
 ]
 
 # Define the libcomposition library so it can be linked against by other parts of the build system
-libcomposition = static_library('composition',
+libcomposition = library('composition',
     composition_sources, 
     include_directories: include_directories('public'),
     cpp_args: ['-fvisibility=default'],

src/config/meson.build

@@ -8,7 +8,7 @@ config_headers = files(
 )
 
 # Define the libconfig library so it can be linked against by other parts of the build system
-libconfig = static_library('config',
+libconfig = library('config',
     config_sources, 
     include_directories: include_directories('public'),
     cpp_args: ['-fvisibility=default'],

src/config/public/config.h

@@ -18,8 +18,7 @@
 //   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 //
 // *********************************************************************** */
-#ifndef CONFIG_H
-#define CONFIG_H
+#pragma once
 
 #include <string>
 #include <iostream>
@@ -28,7 +27,6 @@
 #include <map>
 #include <algorithm>
 #include <stdexcept>
-#include <stdexcept>
 
 // Required for YAML parsing
 #include "yaml-cpp/yaml.h"
@@ -162,7 +160,12 @@ public:
    template <typename T>
    T get(const std::string &key, T defaultValue) {
       if (!m_loaded) {
-         throw std::runtime_error("Configuration file not loaded! This should be done at the very start of whatever main function you are using (and only done once!)");
+// ONLY THROW ERROR IF HARSH OR WARN CONFIGURATION
+#if defined(CONFIG_HARSH)
+         throw std::runtime_error("Error! Config file not loaded. To disable this error, recompile with CONFIG_HARSH=0");
+#elif defined(CONFIG_WARN)
+         std::cerr << "Warning! Config file not loaded. This instance of 4DSSE was compiled with CONFIG_WARN so the code will continue using only default values" << std::endl;
+#endif
       }
       // --- Check if the key has already been checked for existence 
       if (std::find(unknownKeys.begin(), unknownKeys.end(), key) != unknownKeys.end()) {
@@ -241,5 +244,3 @@ public:
 
 } // namespace config
 } // namespace serif
-
-#endif

src/constants/public/const.h

@@ -20,9 +20,7 @@
 // *********************************************************************** */
 #pragma once
 #include <string>
-#include <fstream>
 #include <iostream>
-#include <vector>
 #include <set>
 #include <map>
 
@@ -95,7 +93,7 @@ private:
 public:
 
   /**
-   * @brief get instance of constants singelton
+   * @brief get instance of constants singleton
    * @return instance of constants
    */
   static Constants& getInstance() {
@@ -107,7 +105,7 @@ public:
    * @brief Check if constants are loaded.
    * @return True if constants are loaded, false otherwise.
    */
-  bool isLoaded() { return loaded_; }
+  bool isLoaded() const { return loaded_; }
 
   /**
    * @brief Get a constant by key.

src/eos/meson.build

@@ -18,7 +18,7 @@ dependencies = [
     macros_dep,
 ]
 # Define the libconst library so it can be linked against by other parts of the build system
-libeos = static_library('eos',
+libeos = library('eos',
     eos_sources, 
     include_directories: include_directories('public'),
     cpp_args: ['-fvisibility=default'],

src/meshIO/meson.build

@@ -10,7 +10,7 @@ dependencies = [
     mfem_dep
 ]
 # Define the libmeshIO library so it can be linked against by other parts of the build system
-libmeshIO = static_library('meshIO',
+libmeshIO = library('meshIO',
     meshIO_sources, 
     include_directories: include_directories('public'),
     cpp_args: ['-fvisibility=default'],

src/meson.build

@@ -22,3 +22,6 @@ subdir('resource')
 # Physics Libraries
 subdir('network')
 subdir('polytrope')
+
+# Python Bindings
+subdir('python')

src/network/meson.build

@@ -19,7 +19,7 @@ dependencies = [
 ]
 
 # Define the libnetwork library so it can be linked against by other parts of the build system
-libnetwork = static_library('network',
+libnetwork = library('network',
     network_sources, 
     include_directories: include_directories('public'),
     dependencies: dependencies,

src/polytrope/utils/meson.build

@@ -34,7 +34,7 @@ dependencies = [
   mfemanalysis_dep,
 ]
 
-libpolyutils = static_library('polyutils',
+libpolyutils = library('polyutils',
   polyutils_sources,
   include_directories : include_directories('./public'),
   cpp_args: ['-fvisibility=default'],

src/probe/meson.build

@@ -35,7 +35,7 @@ dependencies = [
 ]
 
 # Define the liblogger library so it can be linked against by other parts of the build system
-libprobe = static_library('probe',
+libprobe = library('probe',
     probe_sources, 
     include_directories: include_directories('public'),
     cpp_args: ['-fvisibility=default'],

src/python/bindings.cpp

@@ -0,0 +1,20 @@
+#include <pybind11/pybind11.h>
+
+#include <string>
+
+#include "const/bindings.h"
+#include "composition/bindings.h"
+#include "config/bindings.h"
+
+PYBIND11_MODULE(fourdsse_bindings, m) {
+    m.doc() = "Python bindings for the 4DSSE project";
+
+    auto compMod  = m.def_submodule("composition", "Composition-module bindings");
+    register_comp_bindings(compMod);
+
+    auto constMod = m.def_submodule("constants", "Constants-module bindings");
+    register_const_bindings(constMod);
+
+    auto configMod = m.def_submodule("config", "Configuration-module bindings");
+    register_config_bindings(configMod);
+}

src/python/composition/bindings.cpp

@@ -0,0 +1,163 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h> // Needed for vectors, maps, sets, strings
+#include <pybind11/stl_bind.h> // Needed for binding std::vector, std::map etc if needed directly
+
+#include <string>
+
+#include "composition.h"
+#include "atomicSpecies.h"
+
+#include "bindings.h"
+
+namespace py = pybind11;
+
+std::string sv_to_string(std::string_view sv) {
+    return std::string(sv);
+}
+
+std::string get_ostream_str(const composition::Composition& comp) {
+     std::ostringstream oss;
+     oss << comp;
+     return oss.str();
+}
+
+
+void register_comp_bindings(pybind11::module &comp_submodule) {
+    // --- Bindings for composition and species module ---
+    py::class_<composition::GlobalComposition>(comp_submodule, "GlobalComposition")
+        .def_readonly("specificNumberDensity", &composition::GlobalComposition::specificNumberDensity)
+        .def_readonly("meanParticleMass", &composition::GlobalComposition::meanParticleMass)
+        .def("__repr__", // Add a string representation for easy printing in Python
+             [](const composition::GlobalComposition &gc) {
+                 return "<GlobalComposition(specNumDens=" + std::to_string(gc.specificNumberDensity) +
+                        ", meanMass=" + std::to_string(gc.meanParticleMass) + ")>";
+             });
+
+    py::class_<composition::CompositionEntry>(comp_submodule, "CompositionEntry")
+        .def("symbol", &composition::CompositionEntry::symbol)
+        .def("mass_fraction",
+             py::overload_cast<>(&composition::CompositionEntry::mass_fraction, py::const_),
+             "Gets the mass fraction of the species.")
+        .def("mass_fraction",
+             py::overload_cast<double>(&composition::CompositionEntry::mass_fraction, py::const_),
+             py::arg("meanMolarMass"), // Name the argument in Python
+             "Gets the mass fraction of the species given the mean molar mass.")
+        .def("number_fraction",
+              py::overload_cast<>(&composition::CompositionEntry::number_fraction, py::const_),
+              "Gets the number fraction of the species.")
+        .def("number_fraction",
+              py::overload_cast<double>(&composition::CompositionEntry::number_fraction, py::const_),
+              py::arg("totalMoles"),
+              "Gets the number fraction of the species given the total moles.")
+
+        .def("rel_abundance", &composition::CompositionEntry::rel_abundance)
+        .def("isotope", &composition::CompositionEntry::isotope) // Assuming Species is bound or convertible
+        .def("getMassFracMode", &composition::CompositionEntry::getMassFracMode)
+
+        .def("__repr__", // Optional: nice string representation
+            [](const composition::CompositionEntry &ce) {
+                // You might want to include more info here now
+                return "<CompositionEntry(symbol='" + ce.symbol() + "', " +
+                    "mass_frac=" + std::to_string(ce.mass_fraction()) + ", " +
+                    "num_frac=" + std::to_string(ce.number_fraction()) + ")>";
+            });
+
+        // --- Binding for the main Composition class ---
+    py::class_<composition::Composition>(comp_submodule, "Composition")
+        // Constructors
+        .def(py::init<>(), "Default constructor")
+        .def(py::init<const std::vector<std::string>&>(),
+             py::arg("symbols"),
+             "Constructor taking a list of symbols to register (defaults to mass fraction mode)")
+        // .def(py::init<const std::set<std::string>&>(), py::arg("symbols")) // Binding std::set constructor is possible but often less convenient from Python
+        .def(py::init<const std::vector<std::string>&, const std::vector<double>&, bool>(),
+             py::arg("symbols"), py::arg("fractions"), py::arg("massFracMode") = true,
+             "Constructor taking symbols, fractions, and mode (True=Mass, False=Number)")
+
+        // Methods
+        .def("finalize", &composition::Composition::finalize, py::arg("norm") = false,
+             "Finalize the composition, optionally normalizing fractions to sum to 1.")
+
+        .def("registerSymbol", py::overload_cast<const std::string&, bool>(&composition::Composition::registerSymbol),
+             py::arg("symbol"), py::arg("massFracMode") = true, "Register a single symbol.")
+        .def("registerSymbol", py::overload_cast<const std::vector<std::string>&, bool>(&composition::Composition::registerSymbol),
+             py::arg("symbols"), py::arg("massFracMode") = true, "Register multiple symbols.")
+
+        .def("getRegisteredSymbols", &composition::Composition::getRegisteredSymbols,
+             "Get the set of registered symbols.")
+
+        .def("setMassFraction", py::overload_cast<const std::string&, const double&>(&composition::Composition::setMassFraction),
+             py::arg("symbol"), py::arg("mass_fraction"), "Set mass fraction for a single symbol (requires massFracMode). Returns old value.")
+        .def("setMassFraction", py::overload_cast<const std::vector<std::string>&, const std::vector<double>&>(&composition::Composition::setMassFraction),
+             py::arg("symbols"), py::arg("mass_fractions"), "Set mass fractions for multiple symbols (requires massFracMode). Returns list of old values.")
+
+        .def("setNumberFraction", py::overload_cast<const std::string&, const double&>(&composition::Composition::setNumberFraction),
+             py::arg("symbol"), py::arg("number_fraction"), "Set number fraction for a single symbol (requires !massFracMode). Returns old value.")
+        .def("setNumberFraction", py::overload_cast<const std::vector<std::string>&, const std::vector<double>&>(&composition::Composition::setNumberFraction),
+             py::arg("symbols"), py::arg("number_fractions"), "Set number fractions for multiple symbols (requires !massFracMode). Returns list of old values.")
+
+        .def("mix", &composition::Composition::mix, py::arg("other"), py::arg("fraction"),
+             "Mix with another composition. Returns new Composition.")
+
+        .def("getMassFraction", py::overload_cast<const std::string&>(&composition::Composition::getMassFraction, py::const_),
+             py::arg("symbol"), "Get mass fraction for a symbol (calculates if needed). Requires finalization.")
+        .def("getMassFraction", py::overload_cast<>(&composition::Composition::getMassFraction, py::const_),
+             "Get dictionary of all mass fractions. Requires finalization.")
+
+        .def("getNumberFraction", py::overload_cast<const std::string&>(&composition::Composition::getNumberFraction, py::const_),
+             py::arg("symbol"), "Get number fraction for a symbol (calculates if needed). Requires finalization.")
+        .def("getNumberFraction", py::overload_cast<>(&composition::Composition::getNumberFraction, py::const_),
+             "Get dictionary of all number fractions. Requires finalization.")
+
+        // Note: pybind11 automatically converts std::pair to a Python tuple
+        .def("getComposition", py::overload_cast<const std::string&>(&composition::Composition::getComposition, py::const_),
+             py::arg("symbol"), "Returns a tuple (CompositionEntry, GlobalComposition) for the symbol. Requires finalization.")
+        // Binding the version returning map<string, Entry> requires a bit more care or helper function
+        // to convert the map to a Python dict if needed directly. Let's bind the pair version for now.
+         .def("getComposition", py::overload_cast<>(&composition::Composition::getComposition, py::const_),
+             "Returns a tuple (dict[str, CompositionEntry], GlobalComposition) for all symbols. Requires finalization.")
+
+
+        .def("subset", &composition::Composition::subset, py::arg("symbols"), py::arg("method") = "norm",
+             "Create a new Composition containing only the specified symbols.")
+        .def("hasSymbol", &composition::Composition::hasSymbol, py::arg("symbol"),
+             "Check if a symbol is registered.")
+        .def("setCompositionMode", &composition::Composition::setCompositionMode, py::arg("massFracMode"),
+             "Set the mode (True=Mass, False=Number). Requires finalization before switching.")
+
+        // Operator overload
+        .def(py::self + py::self, "Mix equally with another composition.") // Binds operator+
+
+        // Add __repr__ or __str__
+         .def("__repr__", [](const composition::Composition &comp) {
+             return get_ostream_str(comp); // Use helper for C++ operator<<
+         });
+
+
+
+}
+
+void register_species_bindings(pybind11::module &chem_submodule) {
+     // --- Bindings for species module ---
+     py::class_<chemSpecies::Species>(chem_submodule, "Species")
+         .def("mass", &chemSpecies::Species::mass, "Get atomic mass (amu)")
+         .def("massUnc", &chemSpecies::Species::massUnc, "Get atomic mass uncertainty (amu)")
+         .def("bindingEnergy", &chemSpecies::Species::bindingEnergy, "Get binding energy (keV/nucleon?)") // Check units
+         .def("betaDecayEnergy", &chemSpecies::Species::betaDecayEnergy, "Get beta decay energy (keV?)") // Check units
+         .def("betaCode", [](const chemSpecies::Species& s){ return sv_to_string(s.betaCode()); }, "Get beta decay code") // Convert string_view
+         .def("name", [](const chemSpecies::Species& s){ return sv_to_string(s.name()); }, "Get species name (e.g., 'H-1')") // Convert string_view
+         .def("el", [](const chemSpecies::Species& s){ return sv_to_string(s.el()); }, "Get element symbol (e.g., 'H')") // Convert string_view
+         .def("nz", &chemSpecies::Species::nz, "Get NZ value")
+         .def("n", &chemSpecies::Species::n, "Get neutron number N")
+         .def("z", &chemSpecies::Species::z, "Get proton number Z")
+         .def("a", &chemSpecies::Species::a, "Get mass number A")
+
+     .def("__repr__",
+          [](const chemSpecies::Species &s) {
+              std::ostringstream oss;
+              oss << s;
+              return oss.str();
+          });
+
+     chem_submodule.attr("species") = py::cast(chemSpecies::species); // Expose the species map
+}

src/python/composition/bindings.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+void register_comp_bindings(pybind11::module &m);
+void register_species_bindings(pybind11::module &m);

src/python/composition/meson.build

@@ -0,0 +1,18 @@
+# Define the library
+bindings_sources = files('bindings.cpp')
+bindings_headers = files('bindings.h')
+
+dependencies = [
+    composition_dep,
+    species_weight_dep,
+    python3_dep,
+    pybind11_dep,
+]
+
+shared_module('py_composition',
+    bindings_sources,
+    cpp_args: ['-fvisibility=default'],
+    install : true,
+    dependencies: dependencies,
+    include_directories: include_directories('.')
+)

src/python/config/bindings.cpp

@@ -0,0 +1,55 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h> // Needed for vectors, maps, sets, strings
+#include <pybind11/stl_bind.h> // Needed for binding std::vector, std::map etc if needed directly
+
+#include <string>
+#include "bindings.h"
+
+#include "config.h"
+
+namespace py = pybind11;
+
+// Helper function template for binding Config::get
+template <typename T>
+void def_config_get(py::module &m) {
+    m.def("get",
+          [](const std::string &key, T defaultValue) {
+              return Config::getInstance().get<T>(key, defaultValue);
+          },
+          py::arg("key"), py::arg("defaultValue"),
+          "Get configuration value (type inferred from default)");
+}
+
+void register_config_bindings(pybind11::module &config_submodule) {
+    def_config_get<int>(config_submodule);
+    def_config_get<double>(config_submodule);
+    def_config_get<std::string>(config_submodule);
+    def_config_get<bool>(config_submodule);
+
+    config_submodule.def("loadConfig",
+        [](const std::string& configFilePath) {
+            return Config::getInstance().loadConfig(configFilePath);
+        },
+        py::arg("configFilePath"),
+        "Load configuration from a YAML file.");
+
+    config_submodule.def("has",
+        [](const std::string &key) {
+            return Config::getInstance().has(key);
+        },
+        py::arg("key"),
+        "Check if a key exists in the configuration.");
+
+    config_submodule.def("keys",
+        []() {
+            return py::cast(Config::getInstance().keys());
+        },
+        "Get a list of all configuration keys.");
+
+    config_submodule.def("__repr__",
+        []() {
+            std::ostringstream oss;
+            oss << Config::getInstance(); // Use the existing operator<<
+            return std::string("<fourdsse_bindings.config module accessing C++ Singleton>\n") + oss.str();
+        });
+}

src/python/config/bindings.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+void register_config_bindings(pybind11::module &config_submodule);

src/python/config/meson.build

@@ -0,0 +1,17 @@
+# Define the library
+bindings_sources = files('bindings.cpp')
+bindings_headers = files('bindings.h')
+
+dependencies = [
+    config_dep,
+    python3_dep,
+    pybind11_dep,
+]
+
+shared_module('py_config',
+              bindings_sources,
+              include_directories: include_directories('.'),
+              cpp_args: ['-fvisibility=default'],
+              install : true,
+              dependencies: dependencies,
+)

src/python/const/bindings.cpp

@@ -0,0 +1,54 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h> // Needed for vectors, maps, sets, strings
+#include <pybind11/stl_bind.h> // Needed for binding std::vector, std::map etc if needed directly
+
+#include <string>
+#include "const.h"
+#include "bindings.h"
+
+namespace py = pybind11;
+
+
+void register_const_bindings(pybind11::module &const_submodule) {
+    py::class_<Constant>(const_submodule, "Constant")
+        .def_readonly("name", &Constant::name)
+        .def_readonly("value", &Constant::value)
+        .def_readonly("uncertainty", &Constant::uncertainty)
+        .def_readonly("unit", &Constant::unit)
+        .def_readonly("reference", &Constant::reference)
+        .def("__repr__", [](const Constant &c) {
+            return "<Constant(name='" + c.name + "', value=" + std::to_string(c.value) +
+                   ", uncertainty=" + std::to_string(c.uncertainty) +
+                   ", unit='" + c.unit + "')>";
+        });
+
+    py::class_<Constants>(const_submodule, "Constants")
+        .def_property_readonly("loaded", &Constants::isLoaded)
+        .def_static("get",
+            [](const std::string &name) {
+                return py::cast(
+                    Constants::getInstance().get(name)
+                );
+            },
+            "Get a constant by name. Returns None if not found."
+        )
+        .def_static("has",
+            [](const std::string &name) {
+                return Constants::getInstance().has(name);
+            },
+            "Check if a constant exists by name.")
+        .def_static("keys",
+            []() {
+                return py::cast(
+                    Constants::getInstance().keys()
+                );
+            },
+            "Get a list of all constant names.")
+        .def_static("__class_getitem__",
+         [](const std::string &name) {
+             return py::cast(
+                 Constants::getInstance().get(name)
+             );
+         });
+
+}

src/python/const/bindings.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+void register_const_bindings(pybind11::module &const_submodule);

src/python/const/meson.build

@@ -0,0 +1,17 @@
+# Define the library
+bindings_sources = files('bindings.cpp')
+bindings_headers = files('bindings.h')
+
+dependencies = [
+    const_dep,
+    python3_dep,
+    pybind11_dep,
+]
+
+shared_module('py_const',
+    bindings_sources,
+    include_directories: include_directories('.'),
+    cpp_args: ['-fvisibility=default'],
+    install : true,
+    dependencies: dependencies,
+)

src/python/meson.build

@@ -0,0 +1,3 @@
+subdir('composition')
+subdir('const')
+subdir('config')

src/resource/meson.build

@@ -23,7 +23,7 @@ dependencies = [
 
 libResourceHeader_dep = declare_dependency(include_directories: include_directories('public'))
 # Define the libresourceManager library so it can be linked against by other parts of the build system
-libresourceManager = static_library('resourceManager',
+libresourceManager = library('resourceManager',
     resourceManager_sources, 
     include_directories: include_directories('public'),
     cpp_args: ['-fvisibility=default'],