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

feat(pythonInterface/eos): fast forward

Browse Source
This commit is contained in:
Emily Boudreaux
2025-06-12 14:04:11 -04:00
parent b5980ea57a 353e2072e7
commit 54e408a4af
273 changed files with 42783 additions and 12196 deletions
Download Patch File Download Diff File Expand all files Collapse all files

75
src/eos/private/EOSio.cpp
View File

@@ -1,3 +1,23 @@
/* ***********************************************************************
//
// Copyright (C) 2025 -- The 4D-STAR Collaboration
// File Author: Emily Boudreaux
// Last Modified: March 20, 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
//
// *********************************************************************** */
#include <string>
#include <utility>
@@ -5,33 +25,36 @@
#include "helm.h"
#include "debug.h"
EOSio::EOSio(std::string filename) : m_filename(std::move(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;
}
}

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

@@ -1,8 +1,8 @@
/* ***********************************************************************
//
// Copyright (C) 2025 -- The 4D-STAR Collaboration
// File Author: Emily Boudreaux
// Last Modified: March 17, 2025
// File Authors: Aaron Dotter, Emily Boudreaux
// Last Modified: March 20, 2025
//
// 4DSSE is free software; you can use it and/or modify
// it under the terms and restrictions the GNU General Library Public
@@ -41,56 +41,60 @@
#include "config.h"
#include "quill/LogMacros.h"
namespace serif::constant {
class Constants;
}
using namespace std;
double** heap_allocate_contiguous_2D_memory(const int rows, const int cols) {
// interpolating polynomila function definitions
namespace serif::eos::helmholtz {
double** heap_allocate_contiguous_2D_memory(const int rows, const int cols) {
if (rows <= 0 || cols <= 0) {
throw std::invalid_argument("Rows and columns must be positive integers.");
throw std::invalid_argument("Rows and columns must be positive integers.");
}
auto array = new double*[rows];
const auto 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 psi0(const 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); }
double dpsi0(const double z) { return z*z * ( z * (-30.0 * z + 60.0) - 30.0); }
double ddpsi0(double z) { return z * ( z * (-120.0 * z + 180.0) - 60.0); }
double ddpsi0(const double z) { return z * ( z * (-120.0 * z + 180.0) - 60.0); }
double psi1(double z) { return z * ( z*z * ( z * (-3.0*z + 8.0) - 6.0) + 1.0); }
double psi1(const double z) { return z * ( z*z * ( z * (-3.0*z + 8.0) - 6.0) + 1.0); }
double dpsi1(double z) { return z*z * ( z * (-15.0*z + 32.0) - 18.0) +1.0; }
double dpsi1(const double z) { return z*z * ( z * (-15.0*z + 32.0) - 18.0) +1.0; }
double ddpsi1(double z) { return z * (z * (-60.0*z + 96.0) - 36.0); }
double ddpsi1(const double z) { return z * (z * (-60.0*z + 96.0) - 36.0); }
double psi2(double z) { return 0.5 * z*z * ( z* ( z * (-z + 3.0) - 3.0) + 1.0); }
double psi2(const double z) { return 0.5 * z*z * ( z* ( z * (-z + 3.0) - 3.0) + 1.0); }
double dpsi2(double z) { return 0.5 * z * ( z * (z * (-5.0*z + 12.0) - 9.0) + 2.0); }
double dpsi2(const double z) { return 0.5 * z * ( z * (z * (-5.0*z + 12.0) - 9.0) + 2.0); }
double ddpsi2(double z) { return 0.5*(z*( z * (-20.*z + 36.) - 18.) + 2.); }
double ddpsi2(const double z) { return 0.5*(z*( z * (-20.*z + 36.) - 18.) + 2.); }
double xpsi0(double z) { return z * z * (2.0 * z - 3.0) + 1.0; }
double xpsi0(const double z) { return z * z * (2.0 * z - 3.0) + 1.0; }
double xdpsi0(double z) { return z * (6.0*z - 6.0); }
double xdpsi0(const double z) { return z * (6.0*z - 6.0); }
double xpsi1(double z) { return z * ( z * (z - 2.0) + 1.0); }
double xpsi1(const double z) { return z * ( z * (z - 2.0) + 1.0); }
double xdpsi1(double z) { return z * (3.0 * z - 4.0) + 1.0; }
double xdpsi1(const double z) { return z * (3.0 * z - 4.0) + 1.0; }
double h3(std::array<double, 36> fi, double w0t, double w1t, double w0mt, double w1mt,
double w0d, double w1d, double w0md, double w1md) {
double h3(const std::array<double, 36> &fi, const double w0t, const double w1t, const double w0mt, const double w1mt,
const double w0d, const double w1d, const double w0md, const double w1md) {
return fi[0] * w0d * w0t + fi[1] * w0md * w0t
+ fi[2] * w0d * w0mt + fi[3] * w0md * w0mt
+ fi[4] * w0d * w1t + fi[5] * w0md * w1t
@@ -101,9 +105,9 @@ namespace helmholtz {
+ fi[14] * w1d * w1mt + fi[15] * w1md * w1mt;
}
double h5(std::array<double, 36> fi, double w0t, double w1t, double w2t,double w0mt,
double w1mt, double w2mt, double w0d, double w1d, double w2d,
double w0md, double w1md, double w2md) {
double h5(const std::array<double, 36> &fi, const double w0t, const double w1t, const double w2t, const double w0mt,
const double w1mt, const double w2mt, const double w0d, const double w1d, const double w2d,
const double w0md, const double w1md, const double w2md) {
return fi[0] * w0d * w0t + fi[1] * w0md * w0t
+ fi[2] * w0d * w0mt + fi[3] * w0md * w0mt
+ fi[4] * w0d * w1t + fi[5] * w0md * w1t
@@ -125,15 +129,15 @@ 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();
std::string logFile = config.get<std::string>("EOS:Helm:LogFile", "log");
Probe::LogManager& logManager = Probe::LogManager::getInstance();
std::unique_ptr<HELMTable> read_helm_table(const std::string &filename) {
serif::config::Config& config = serif::config::Config::getInstance();
auto logFile = config.get<std::string>("EOS:Helm:LogFile", "log");
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>();
auto table = std::make_unique<serif::eos::helmholtz::HELMTable>();
string data;
int i, j;
@@ -236,13 +240,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();
std::string logFile = config.get<std::string>("EOS:Helm:LogFile", "log");
Probe::LogManager& logManager = Probe::LogManager::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();
auto logFile = config.get<std::string>("EOS:Helm:LogFile", "log");
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;
@@ -252,13 +256,13 @@ namespace helmholtz {
const double kergavo = kerg*avo;
const double clight2 = clight * clight;
const double ssol = 5.6704e-5;
constexpr double ssol = 5.6704e-5;
const double asol = 4 * ssol / clight;
const double asoli3 = asol / 3;
const double sioncon = (2.0 * pi * amu * kerg)/(h*h);
const double qe = 4.8032042712e-10;
const double esqu = qe * qe;
const double third = 1./3.;
constexpr double qe = 4.8032042712e-10;
constexpr double esqu = qe * qe;
constexpr double third = 1./3.;
std::array<double, 36> fi;
double T, rho, s, free, abar, zbar, ytot1, ye, ptot;
double prad, srad, erad, etot, stot;
@@ -630,14 +634,14 @@ namespace helmholtz {
// coulomb
const double a1 = -0.898004;
const double b1 = 0.96786;
const double c1 = 0.220703;
const double d1 = -0.86097;
const double e1 = 2.5269;
const double a2 = 0.29561;
const double b2 = 1.9885;
const double c2 = 0.288675;
constexpr double a1 = -0.898004;
constexpr double b1 = 0.96786;
constexpr double c1 = 0.220703;
constexpr double d1 = -0.86097;
constexpr double e1 = 2.5269;
constexpr double a2 = 0.29561;
constexpr double b2 = 1.9885;
constexpr double c2 = 0.288675;
z = 4 * pi * third;
s = z * xni;
@@ -825,7 +829,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;

135
src/eos/public/EOSio.h
View File

@@ -1,69 +1,92 @@
/* ***********************************************************************
//
// Copyright (C) 2025 -- The 4D-STAR Collaboration
// File Author: Emily Boudreaux
// Last Modified: March 20, 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 <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.
*/
explicit EOSio(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.
*/
explicit EOSio(const std::string filename);
/**
* @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();
std::string getFilename() const { return m_filename; }
};
}
std::string getFilename() const { return m_filename; }
};

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

@@ -2,7 +2,7 @@
//
// Copyright (C) 2025 -- The 4D-STAR Collaboration
// File Authors: Aaron Dotter, Emily Boudreaux
// Last Modified: March 06, 2025
// Last Modified: March 20, 2025
//
// 4DSSE is free software; you can use it and/or modify
// it under the terms and restrictions the GNU General Library Public
@@ -21,10 +21,9 @@
// this file contains a C++ conversion of Frank Timmes' fortran code
// helmholtz.f90, which implements the Helmholtz Free Energy EOS described
// by Timmes & Swesty (2000) doi:10.1086/313304 -- Aaron Dotter 2025
#pragma once
#define IMAX 541
#define JMAX 201
#include <array>
#include <iostream>
@@ -35,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;