tboudreaux/SERiF
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(serif): refactored entire codebase into serif and sub namespaces

Browse Source
This commit is contained in:
Emily Boudreaux
2025-06-11 14:49:11 -04:00
parent f0e1840c91
commit 6e4ff1ece9
56 changed files with 747 additions and 2041 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
src/eos/private/eosIO.cpp
View File

@@ -24,33 +24,36 @@
#include "helm.h"
#include "debug.h"
EosIO::EosIO(const std::string filename) : m_filename(filename) {
load();
}
#include <string>
std::string EosIO::getFormat() const {
return m_format;
}
EOSTable& EosIO::getTable() {
return m_table;
}
void EosIO::load() {
// Load the EOS table from the file
// For now, just set the format to HELM
m_format = "helm";
if (m_format == "helm") {
loadHelm();
namespace serif::eos {
EosIO::EosIO(const std::string filename) : m_filename(filename) {
load();
}
}
void EosIO::loadHelm() {
// Load the HELM table from the file
auto helmTabptr = helmholtz::read_helm_table(m_filename);
m_table = std::move(helmTabptr);
m_loaded = true;
}
std::string EosIO::getFormat() const {
return m_format;
}
EOSTable& EosIO::getTable() {
return m_table;
}
void EosIO::load() {
// Load the EOS table from the file
// For now, just set the format to HELM
m_format = "helm";
if (m_format == "helm") {
loadHelm();
}
}
void EosIO::loadHelm() {
// Load the HELM table from the file
auto helmTabptr = serif::eos::helmholtz::read_helm_table(m_filename);
m_table = std::move(helmTabptr);
m_loaded = true;
}
}

30
src/eos/private/helm.cpp
View File

@@ -43,23 +43,23 @@
using namespace std;
double** heap_allocate_contiguous_2D_memory(int rows, int cols) {
// interpolating polynomila function definitions
namespace serif::eos::helmholtz {
double** heap_allocate_contiguous_2D_memory(int rows, int cols) {
double **array = new double*[rows];
array[0] = new double[rows * cols];
for (int i = 1; i < rows; i++) {
array[i] = array[0] + i * cols;
array[i] = array[0] + i * cols;
}
return array;
}
}
void heap_deallocate_contiguous_2D_memory(double **array) {
void heap_deallocate_contiguous_2D_memory(double **array) {
delete[] array[0];
delete[] array;
}
// interpolating polynomila function definitions
namespace helmholtz {
}
double psi0(double z) { return z*z*z * (z * (-6.0 * z + 15.0) - 10.0) + 1.0; }
double dpsi0(double z) { return z*z * ( z * (-30.0 * z + 60.0) - 30.0); }
@@ -123,14 +123,14 @@ namespace helmholtz {
// this function reads in the HELM table and stores in the above arrays
std::unique_ptr<HELMTable> read_helm_table(const std::string filename) {
Config& config = Config::getInstance();
serif::config::Config& config = serif::config::Config::getInstance();
std::string logFile = config.get<std::string>("EOS:Helm:LogFile", "log");
Probe::LogManager& logManager = Probe::LogManager::getInstance();
serif::probe::LogManager& logManager = serif::probe::LogManager::getInstance();
quill::Logger* logger = logManager.getLogger(logFile);
LOG_INFO(logger, "read_helm_table : Reading HELM table from file {}", filename);
// Make a unique pointer to the HELMTable
std::unique_ptr<HELMTable> table = std::make_unique<HELMTable>();
std::unique_ptr<serif::eos::helmholtz::HELMTable> table = std::make_unique<serif::eos::helmholtz::HELMTable>();
string data;
int i, j;
@@ -233,13 +233,13 @@ namespace helmholtz {
ion, radiation, electron-positron and Coulomb interaction
and returns the calculated quantities in the input
***/
EOS get_helm_EOS(EOSInput &q, const HELMTable &table) {
Config& config = Config::getInstance();
serif::eos::helmholtz::EOS get_helm_EOS(serif::eos::helmholtz::EOSInput &q, const serif::eos::helmholtz::HELMTable &table) {
serif::config::Config& config = serif::config::Config::getInstance();
std::string logFile = config.get<std::string>("EOS:Helm:LogFile", "log");
Probe::LogManager& logManager = Probe::LogManager::getInstance();
serif::probe::LogManager& logManager = serif::probe::LogManager::getInstance();
quill::Logger* logger = logManager.getLogger(logFile);
Constants& constants = Constants::getInstance();
serif::constant::Constants& constants = serif::constant::Constants::getInstance();
const double pi = std::numbers::pi;
const double amu = constants.get("u").value;
const double h = constants.get("h").value;
@@ -822,7 +822,7 @@ namespace helmholtz {
double csound = clight * sqrt(gamma1/z);
// package in q:
EOS eos;
serif::eos::helmholtz::EOS eos;
eos.ptot = ptot; eos.etot = etot; eos.stot = stot;
eos.pgas = pgas; eos.egas = egas; eos.sgas = sgas;
eos.prad = prad; eos.erad = erad; eos.srad = srad;

115
src/eos/public/eosIO.h
View File

@@ -18,73 +18,72 @@
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// *********************************************************************** */
#ifndef EOSIO_H
#define EOSIO_H
#pragma once
#include <string>
#include <variant>
#include <memory>
// EOS table format includes
#include "helm.h"
using EOSTable = std::variant<
std::unique_ptr<helmholtz::HELMTable>
>;
namespace serif::eos {
/**
* @class EosIO
* @brief Handles the input/output operations for EOS tables.
*
* The EosIO class is responsible for loading and managing EOS tables from files.
* It supports different formats, currently only HELM format.
*
* Example usage:
* @code
* EosIO eosIO("path/to/file");
* std::string format = eosIO.getFormat();
* EOSTable& table = eosIO.getTable();
* @endcode
*/
class EosIO {
private:
std::string m_filename; ///< The filename of the EOS table.
bool m_loaded = false; ///< Flag indicating if the table is loaded.
std::string m_format; ///< The format of the EOS table.
EOSTable m_table; ///< The EOS table data.
/**
* @brief Loads the EOS table from the file.
*/
void load();
// EOS table format includes
using EOSTable = std::variant<
std::unique_ptr<serif::eos::helmholtz::HELMTable>
>;
/**
* @brief Loads the HELM format EOS table.
* @class EosIO
* @brief Handles the input/output operations for EOS tables.
*
* The EosIO class is responsible for loading and managing EOS tables from files.
* It supports different formats, currently only HELM format.
*
* Example usage:
* @code
* EosIO eosIO("path/to/file");
* std::string format = eosIO.getFormat();
* EOSTable& table = eosIO.getTable();
* @endcode
*/
void loadHelm();
public:
/**
* @brief Constructs an EosIO object with the given filename.
* @param filename The filename of the EOS table.
*/
EosIO(const std::string filename);
/**
* @brief Default destructor.
*/
~EosIO() = default;
class EosIO {
private:
std::string m_filename; ///< The filename of the EOS table.
bool m_loaded = false; ///< Flag indicating if the table is loaded.
std::string m_format; ///< The format of the EOS table.
EOSTable m_table; ///< The EOS table data.
/**
* @brief Gets the format of the EOS table.
* @return The format of the EOS table as a string.
*/
std::string getFormat() const;
/**
* @brief Loads the EOS table from the file.
*/
void load();
/**
* @brief Gets the EOS table.
* @return A reference to the EOS table.
*/
EOSTable& getTable();
};
/**
* @brief Loads the HELM format EOS table.
*/
void loadHelm();
public:
/**
* @brief Constructs an EosIO object with the given filename.
* @param filename The filename of the EOS table.
*/
EosIO(const std::string filename);
#endif // EOSIO_H
/**
* @brief Default destructor.
*/
~EosIO() = default;
/**
* @brief Gets the format of the EOS table.
* @return The format of the EOS table as a string.
*/
std::string getFormat() const;
/**
* @brief Gets the EOS table.
* @return A reference to the EOS table.
*/
EOSTable& getTable();
};
}

31
src/eos/public/helm.h
View File

@@ -22,11 +22,8 @@
// helmholtz.f90, which implements the Helmholtz Free Energy EOS described
// by Timmes & Swesty (2000) doi:10.1086/313304 -- Aaron Dotter 2025
#ifndef HELM_H
#define HELM_H
#pragma once
#define IMAX 541
#define JMAX 201
#include <array>
#include <iostream>
@@ -37,21 +34,22 @@
#include "debug.h"
/**
* @brief 2D array template alias.
* @tparam T Type of the array elements.
* @tparam J Number of columns.
* @tparam I Number of rows.
*/
template <typename T, std::size_t J, std::size_t I>
using array2D = std::array<std::array<T, J>, I>;
namespace serif::eos::helmholtz {
constexpr int IMAX = 541;
constexpr int JMAX = 201;
/**
* @brief 2D array template alias.
* @tparam T Type of the array elements.
* @tparam J Number of columns.
* @tparam I Number of rows.
*/
template <typename T, std::size_t J, std::size_t I>
using array2D = std::array<std::array<T, J>, I>;
double** heap_allocate_contiguous_2D_memory(int rows, int cols);
double** heap_allocate_contiguous_2D_memory(int rows, int cols);
void heap_deallocate_contiguous_2D_memory(double **array);
void heap_deallocate_contiguous_2D_memory(double **array);
namespace helmholtz
{
const double tlo = 3.0, thi = 13.0;
const double dlo = -12.0, dhi = 15.0;
const double tstp = (thi - tlo) / (JMAX - 1), tstpi = 1 / tstp;
@@ -497,4 +495,3 @@ namespace helmholtz
}
#endif // HELM_H