Release version 1.5

-Various fixes of 1.5beta
-Improved docstrings of Python interface
-Improved HTML documentation
-Spline EOS creation does not need pseudo-enthalpy anymore,
 can be computed via numerical integration. Similarly, specific
 energy is not required for creating isentropic spline EOS.
-EOS interface offers description string for logging etc
-Tabulated EOS (linear interpolation EOS) is now deprecated in favour
 of new spline EOS. Loading (and direct creation) still supported for
 reproducability, but there is no saving functionality.
-Added some more example EOS files for testing

Author: Wolfgang Kastaun

ET_interface/thorns/RePrimAnd/dist/RePrimAnd.tar

@@ -10,8 +10,11 @@ The full documentation can be found [here](https://wokast.github.io/RePrimAnd/in
 
 The main target and devolpment platform is Linux, although the
 library code is not platform-specific and should also work on Macs.
-Windows and AIX are not supported. Binary packages are currently not available, but a conda
-package is planned.
+Windows and AIX are not supported. For use in HPC, users need to build 
+the library from source. For use in postprocessing, the Python intferface
+can also be installed via pip (binary wheel of the library available for 
+Linux). Conda packages for the C++ library and Python intface are planned 
+but not available yet.
 
 ## Requirements
 
@@ -192,7 +195,7 @@ This requires Python+matplotlib.
 ### Visualizing Master Function
 
 In addition, there is code to sample the primitive recovery master
-function (the central ingredient of the scheme) for various cases,
+function (the central ingredient of the con2prim scheme) for various cases,
 as shown in the paper.
 
 ```bash

README.md

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
   name = "RePrimAnd"
-  version = "1.5beta"
+  version = "1.5"
   authors = [
     { name = "Wolfgang Kastaun", email = "physik@fangwolg.de" }
   ]  

bindings/python/pyproject.toml

@@ -12,7 +12,7 @@ INST_DIR=/usr
 
 mkdir -p $BUILD_DIR
 cd /project
-meson setup --prefix=$INST_DIR -Dbuild_python_api=false -Dbuild_tests=false -Dbuild_benchmarks=false -Dbuild_documentation=false $BUILD_DIR
+meson setup --prefix=$INST_DIR -Dbuild_tests=false -Dbuild_benchmarks=false -Dbuild_documentation=false $BUILD_DIR
 cd $BUILD_DIR
 ninja 
 ninja install

bindings/python/pyreprimand.cpp

@@ -113,7 +113,7 @@ In terms of the pseudo-enthalpy, the segments are given by
 .. warning::
    The intended use case for this EOS contains just few (<10) segments.
    It would be very inefficient to approximate arbitrary EOS using 
-   hundreds of segments. For this, use the tabulated EOS below.
+   hundreds of segments. For this, use the spline EOS below.
 
 
 
@@ -127,8 +127,9 @@ interpolation. The EOS is therefore differentiable in principle.
 Of course, there can still be steep gradients.
 
 Internally, most properties are represented in terms of the 
-pseudo enthalpy. This has the advantage of avoiding jumps at phase 
-transitions. Only the density has a jump.
+pseudo enthalpy. This has some advantages for computing hydrostatic
+equilibrium models and also with regard to phase 
+transitions (although the density has a jump at those).
 When calling the EOS using density as independent variable, another 
 interpolation spline is used to first compute the pseudo enthalpy
 (in presence of phase transitions, it has a plateau as function of 

docker/cibw_prepare.sh

@@ -2,43 +2,73 @@ Reference
 ---------
 
 
-Generic Interface
-^^^^^^^^^^^^^^^^^
-.. doxygenclass:: EOS_Toolkit::eos_barotr
-   :project: RePrimAnd
-   :members:
-
 Loading from File
 ^^^^^^^^^^^^^^^^^
 
 .. doxygenfunction:: EOS_Toolkit::load_eos_barotr
    :project: RePrimAnd
 
 
-Creating Specific EOS
-^^^^^^^^^^^^^^^^^^^^^
+Creating EOS from sampled data
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+To create a EOS based on spline interpolation from given sample points, 
+there are three options.
+Depending on whether the pseudo-enthalpy and/or specific energy are 
+known accurately, one should use one of the following.
+
+.. doxygenfunction:: EOS_Toolkit::make_eos_barotr_spline(const std::vector<real_t>& gm1, const std::vector<real_t>& rho, const std::vector<real_t>& eps, const std::vector<real_t>& press, const std::vector<real_t>& csnd, const std::vector<real_t>& temp, const std::vector<real_t>& efrac, bool isentropic, interval<real_t> rg_rho, real_t n_poly, units u, std::size_t pts_per_mag)
+   :project: RePrimAnd
+
+|
+
+.. doxygenfunction:: EOS_Toolkit::make_eos_barotr_spline(const std::vector<real_t>& rho, const std::vector<real_t>& eps, const std::vector<real_t>& press, const std::vector<real_t>& csnd, const std::vector<real_t>& temp, const std::vector<real_t>& efrac, bool isentropic, interval<real_t> rg_rho, real_t n_poly, units u, std::size_t pts_per_mag)
+   :project: RePrimAnd
+
+|
 
-.. doxygenfunction:: EOS_Toolkit::make_eos_barotr_spline(const std::vector<real_t>& gm1, const std::vector<real_t>& rho, const std::vector<real_t>& eps, const std::vector<real_t>& press, const std::vector<real_t>& csnd, const std::vector<real_t>& temp, const std::vector<real_t>& efrac, bool isentropic_, interval<real_t> rg_rho, real_t n_poly_, units units_, std::size_t pts_per_mag)
+.. doxygenfunction:: EOS_Toolkit::make_eos_barotr_spline(const std::vector<real_t>& rho, const std::vector<real_t>& press, const std::vector<real_t>& csnd, const std::vector<real_t>& temp, const std::vector<real_t>& efrac, interval<real_t> rg_rho, real_t n_poly, real_t eps0, units u, std::size_t pts_per_mag)
    :project: RePrimAnd
 
 |
 
+It is also possible to sample an existing EOS:
+
 .. doxygenfunction:: EOS_Toolkit::make_eos_barotr_spline(const eos_barotr& eos, interval<real_t> rg_rho, real_t n_poly, std::size_t pts_per_mag=200)
    :project: RePrimAnd
 
 |
 
+Creating Polytropic EOS
+^^^^^^^^^^^^^^^^^^^^^^^
+
 .. doxygenfunction:: EOS_Toolkit::make_eos_barotr_poly
    :project: RePrimAnd
 
 |
 
+Creating Piecewise Polytropic EOS
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 .. doxygenfunction:: EOS_Toolkit::make_eos_barotr_pwpoly
    :project: RePrimAnd
 
-|
 
 
+Generic Interface
+^^^^^^^^^^^^^^^^^
+.. doxygenclass:: EOS_Toolkit::eos_barotr
+   :project: RePrimAnd
+   :members:|
+
+
+Deprecated EOS 
+^^^^^^^^^^^^^^
+
+In older versions, there was no spline based EOS. Instead 
+there was eos_barotr_table based on linear interpolation. This type 
+can still be used for sake of reproducing old results, but for new
+EOS its use is discouraged.
+
 .. deprecated:: 1.5
    Use make_eos_barotr_spline instead make_eos_barotr_table
 

docsrc/sphinx/eos_barotr_available.rst

@@ -3,8 +3,11 @@ Installation
 
 The main target and devolpment platform is Linux, although the
 library code is not platform-specific and should also work on Macs.
-Windows and AIX are not supported. Binary packages are currently not available, but a conda
-package is planned.
+Windows and AIX are not supported. For use in HPC, users need to build 
+the library from source. For use in postprocessing, the Python intferface
+can also be installed via pip (binary wheel of the library available for 
+Linux). Conda packages for the C++ library and Python intface are planned 
+but not available yet.
 
 Requirements
 ------------
@@ -84,7 +87,7 @@ it is easiest to install from pypi
 
 .. code::
 
-   pip install reprimand
+   pip install pyreprimand
 
 
 Otherwise, one first has to buid and install the C++ library as shown above.

docsrc/sphinx/eos_barotr_ref.rst

@@ -42,7 +42,7 @@ valid range.
    import pyreprimand as pyr
    import numpy as np
    
-   u   = pyr.units.geom_solar
+   u   = pyr.units.geom_solar()
    eos = pyr.load_eos_barotr("EOS/MS1_PP.eos.h5", units=u)
    
    rho = np.linspace(eos.range_rho.min, eos.range_rho.max, 1000)
@@ -52,15 +52,15 @@ Creating EOS Files
 ^^^^^^^^^^^^^^^^^^
 
 One prime use for the Python interface is the creation of EOS files based on
-data from other sources. Polytropic, piecewise polytropic, and tabulated EOS
-are supported directly. Other EOS types can be represented by first sampling
-them.
+data from other sources. Polytropic, piecewise polytropic, and spline-based 
+EOS for tabulated data are supported directly. Other EOS types can be represented 
+by first sampling them.
 
 Creating a piecewise polytropic EOS file is as simple as
 
 .. code-block:: python
 
-   u   = pyr.units.geom_solar
+   u   = pyr.units.geom_solar()
 
    eos = pyr.make_eos_barotr_pwpoly(rho_poly, 
                  rho_bounds, gammas, rho_max, uc)
@@ -78,15 +78,15 @@ EOS as follows
 
 .. code-block:: python
 
-   u   = pyr.units.geom_solar
+   u   = pyr.units.geom_solar()
 
-   eos = pyr.make_eos_barotr_spline(gm1, rho, eps, press, csnd, 
+   eos = pyr.make_eos_barotr_spline(rho, eps, press, csnd, 
                 temp, efrac, is_isentropic, range_rho, n_poly, 
                 eos_units, pts_per_mag)
 
    pyr.save_eos_barotr("example_spline.eos.h5", eos)
 
-where `gm1`, `rho`, `eps`, `press`, `csnd`, `temp`, and `efrac` are numpy 
+where `rho`, `eps`, `press`, `csnd`, `temp`, and `efrac` are numpy 
 arrays with the arbitrarily-spaced tabulated sample points. If temperature 
 and/or electron fraction are not available, pass an empty list instead.
 Any dimensionful arguments have to be specified in the unit system desired 
@@ -123,10 +123,8 @@ Methods related to stellar profiles, such as
 :cpp:func:`~EOS_Toolkit::spherical_star::press_from_rc`  
 are vectorized and accept a numpy array as argument for the radius.
 Note that computing TOV solutions is not vectorized, so passing a numpy array as central density
-will not work. Future versions may contain dedicated functions for TOV sequences.
+will not work. See below for working with TOV sequences.
 
-An example Python script plotting TOV sequences can be found under
-`examples/pwpoly_TOV.py`.
 
 NS Sequences
 ^^^^^^^^^^^^
@@ -143,6 +141,9 @@ branches) are vectorized, i.e., they accept `numpy` arrays. If the input is outs
 the valid range, the result is NAN. The same holds for :cpp:class:`~EOS_Toolkit::star_seq` 
 objects representing a general NS sequence.
 
+An example Python script plotting TOV sequences can be found under
+`examples/pwpoly_TOV.py`.
+
 Units
 ^^^^^
 
@@ -151,7 +152,10 @@ objects, which are used throughout the interface to specify unit systems
 in a unified consistent way. The unit objects should also be very
 useful on their own, for example in quick interactive calculations.
 The very popular system defined by :math:`G=c=M_\odot=1` is predefined as
-`pyr.units.geom_solar` and provides units as data members such as 
+`pyr.units.geom_solar()`. Note this is a function; when setting up
+geometric units, the default values for :math:`G` and/or :math:`M_\odot` 
+can be overridden by parameters msun_si, g_si. 
+Unit objects provide specific units via data members such as 
 `u.density` (try Tab-completion for the complete list!).
 Note that temperatures in the EOS framework are always in `MeV` and the unit
-conversion objects do not define a temperature unit.
+conversion objects do not define a temperature unit. 

docsrc/sphinx/installing.rst

@@ -9,39 +9,38 @@
 matplotlib.use("AGG")
 from matplotlib import pyplot as plt
 
-def get_seq(eos, rho_min, rho_max,   
-            nsamp=400, acc_tov=1.e-6, acc_def=1.e-3, acc_mres=500):
+
+
+def get_seq(eos, mgmin=0.5, acc_tov=1.e-6, acc_def=1.e-3, 
+            acc_mres=500, seq_res=500):
+    """Compute stable TOV branch 
     """
-    Compute mass, radius, and tidal deformability for a sequence
-    of TOV solution with given EOS and within given range of central
-    density.
-    """    
-    rho_max = min(rho_max, eos.range_rho.max*0.99999)
-    
-    rhoc = np.exp(np.linspace(np.log(rho_min), np.log(rho_max), nsamp))
-    
-    accs = pyr.tov_acc_simple(acc_tov, acc_def, acc_mres)
-    
-    @np.vectorize
-    def props(rho_cent):
-        tov  = pyr.get_tov_star_properties(eos, rho_cent, accs)
-        return (tov.grav_mass, tov.circ_radius, 
-                  tov.deformability.lambda_tidal)
-        
-    return props(rhoc)
 
+    acc = pyr.tov_acc_simple(acc_tov, acc_def, acc_mres)
 
+    return pyr.make_tov_branch_stable(eos, acc, mgrav_min=mgmin, 
+                                      num_samp=seq_res)
+#
+
 def plot_seqs(seqs):
     """
     Plot mass-radius and compactness-deformability diagrams for 
     a list of TOV sequences.
     """
-    u   = pyr.units.geom_solar
 
     fig,(ax1,ax2) = plt.subplots(2,1)
     cm = plt.get_cmap("viridis")
-    for oga,mg,rc,lt in seqs:
+    for oga,seq in seqs:
         clr = cm(oga) 
+        
+        u = seq.units_to_SI     
+        rggm1 = seq.range_center_gm1
+        gm1 = np.linspace(rggm1.min, rggm1.max, 800)
+        
+        mg  = seq.grav_mass_from_center_gm1(gm1)
+        rc  = seq.circ_radius_from_center_gm1(gm1)
+        lt  = seq.lambda_tidal_from_center_gm1(gm1)
+        
         c = mg/rc
         ax2.semilogy(c, lt, ls='-', color=clr)
         ax2.set_xlabel(r"$M/R$")
@@ -60,7 +59,7 @@ def main():
     of the segment's adiabatic exponent. Compute TOV sequence
     for each EOS, plot them, save plot in current directory.
     """
-    u   = pyr.units.geom_solar
+    u   = pyr.units.geom_solar()
 
     seg_bounds_si = [0.0, 2.44034e+10, 3.78358e+14, 2.6278e+15,
                      9.417030181375906e+16, 5.011872336272714e+17, 
@@ -77,16 +76,16 @@ def main():
     rho_max     = rho_max_si / u.density
     rho_min     = rho_min_si / u.density
 
-    
-    seqs = []
-    for oga in np.linspace(0, 1, 10):
+
+    def mkeos(oga):  
       ga = 2.9 + (oga-0.5)*0.5
       gammas = seg_gammas[:4] + [ga] + seg_gammas[5:]
-      eos = pyr.make_eos_barotr_pwpoly(rho_poly, seg_bounds, gammas,
-                                     rho_max*2)
+      return pyr.make_eos_barotr_pwpoly(rho_poly, seg_bounds, gammas,
+                                        rho_max*2)
+    #
 
-      seq = get_seq(eos, rho_min, rho_max)
-      seqs.append([oga]+list(seq))
+    seqs = [( oga, get_seq(mkeos(oga)) ) 
+              for oga in np.linspace(0, 1, 10)]
 
     plot_seqs(seqs)