sxs 2023.1.6__tar.gz → 2023.3.0__tar.gz

{sxs-2023.1.6 → sxs-2023.3.0}/CITATION.cff

@@ -10,5 +10,5 @@ authors:
 title: "The sxs package"
 license: MIT
 doi: 10.5281/zenodo.4034006
-version: 2023.1.6
-date-released: 2024-06-27
+version: 2023.3.0
+date-released: 2024-07-25

{sxs-2023.1.6 → sxs-2023.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sxs
-Version: 2023.1.6
+Version: 2023.3.0
 Summary: Interface to data produced by the Simulating eXtreme Spacetimes collaboration
 Project-URL: Homepage, https://github.com/sxs-collaboration/sxs
 Project-URL: Documentation, https://sxs.readthedocs.io/

sxs-2023.3.0/sxs/__version__.py

@@ -0,0 +1 @@
+__version__ = "2023.3.0"

{sxs-2023.1.6 → sxs-2023.3.0}/sxs/julia/GWFrames.py

@@ -1,3 +1,4 @@
+import numpy as np
 import quaternionic
 from .. import WaveformModes
 from . import PostNewtonian
@@ -46,17 +47,25 @@ def PNWaveform(
         **kwargs
     )
 
+    coorbital_frame = quaternionic.array(w1.frame.to_numpy())
+    frame = np.array([quaternionic.one]) if inertial else coorbital_frame
+    frame_type = "inertial" if inertial else "coorbital"
+
     w = WaveformModes(
-        w1.data,
-        time=w1.t,
+        w1.data.to_numpy(),
+        time=w1.t.to_numpy(),
         modes_axis=1,
-        ell_min=2,
-        ell_max=8,
+        ell_min=ell_min,
+        ell_max=ell_max,
+        spin_weight=-2,
+        frame=frame,
+        frame_type=frame_type,
+        data_type="h",
         M1=w1.M1.to_numpy(),
         M2=w1.M2.to_numpy(),
         chi1=w1.chi1.to_numpy(),
         chi2=w1.chi2.to_numpy(),
-        frame=quaternionic.array(w1.frame.to_numpy()),
+        coorbital_frame=coorbital_frame,
         v=w1.v.to_numpy(),
         orbital_phase=w1.Phi.to_numpy(),
     )
@@ -66,7 +75,7 @@ def PNWaveform(
     w.M2 = w._metadata["M2"]
     w.chi1 = w._metadata["chi1"]
     w.chi2 = w._metadata["chi2"]
-    #w.frame = w._metadata["frame"]  ## Already done
+    w.coorbital_frame = w._metadata["coorbital_frame"]
     w.v = w._metadata["v"]
     w.orbital_phase = w._metadata["orbital_phase"]
 

{sxs-2023.1.6 → sxs-2023.3.0}/sxs/julia/__init__.py

@@ -1,3 +1,4 @@
+import numpy as np
 import quaternionic
 from .. import WaveformModes
 
@@ -6,7 +7,8 @@ import juliacall
 
 PostNewtonian = juliacall.newmodule("PN")
 PostNewtonian.seval("using PostNewtonian")
-GWFrames = PostNewtonian.GWFrames
+
+from . import GWFrames
 
 def pkg_update():
     """Update all installed Julia packages (but not julia itself)."""
@@ -16,6 +18,7 @@ def pkg_update():
 
 def PNWaveform(
         M1, M2, chi1, chi2, Omega_i, *,
+        inertial=True,
         ell_min=2, ell_max=8, waveform_pn_order=None,
         **orbital_evolution_kwargs
 ):
@@ -33,7 +36,7 @@ def PNWaveform(
         - `v` (array): The orbital velocity as a function of time.
         - `orbital_phase` (array): The orbital phase as a function of
           time.
-    
+
     This is a wrapper around the Julia functions
     `PostNewtonian.orbital_evolution` and
     `PostNewtonian.inertial_waveform`.  See [the Julia
@@ -45,7 +48,7 @@ def PNWaveform(
     docs](https://moble.github.io/PostNewtonian.jl/dev/interface/python/)
     for details.  Also, the GWFrames submodule of this module provides
     another interface.
-    
+
     """
     # Integrate the orbital dynamics
     inspiral = PostNewtonian.orbital_evolution(
@@ -55,9 +58,19 @@ def PNWaveform(
 
     # Compute the waveform in the inertial frame
     waveform_pn_order = waveform_pn_order or PostNewtonian.typemax(PostNewtonian.Int)
-    h = PostNewtonian.inertial_waveform(
-        inspiral, ell_min=ell_min, ell_max=ell_max, PNOrder=waveform_pn_order
-    ).to_numpy().T
+    coorbital_frame = quaternionic.array(values[8:12, :].to_numpy().T)
+    if inertial:
+        frame = np.array([quaternionic.one])
+        frame_type = "inertial"
+        h = PostNewtonian.inertial_waveform(
+            inspiral, ell_min=ell_min, ell_max=ell_max, PNOrder=waveform_pn_order
+        ).to_numpy().T
+    else:
+        frame = coorbital_frame
+        frame_type = "coorbital"
+        h = PostNewtonian.coorbital_waveform(
+            inspiral, ell_min=ell_min, ell_max=ell_max, PNOrder=waveform_pn_order
+        ).to_numpy().T
 
     w = WaveformModes(
         h,
@@ -65,11 +78,15 @@ def PNWaveform(
         modes_axis=1,
         ell_min=ell_min,
         ell_max=ell_max,
+        spin_weight=-2,
+        frame=frame,
+        frame_type=frame_type,
+        data_type="h",
         M1=values[0, :].to_numpy(),
         M2=values[1, :].to_numpy(),
         chi1=values[2:5, :].to_numpy().T,
         chi2=values[5:8, :].to_numpy().T,
-        frame=quaternionic.array(values[8:12, :].to_numpy().T),
+        coorbital_frame=coorbital_frame,
         v=values[12, :].to_numpy(),
         orbital_phase=values[13, :].to_numpy(),
     )
@@ -79,7 +96,7 @@ def PNWaveform(
     w.M2 = w._metadata["M2"]
     w.chi1 = w._metadata["chi1"]
     w.chi2 = w._metadata["chi2"]
-    #w.frame = w._metadata["frame"]  ## Already done
+    w.coorbital_frame = w._metadata["coorbital_frame"]
     w.v = w._metadata["v"]
     w.orbital_phase = w._metadata["orbital_phase"]
 

{sxs-2023.1.6 → sxs-2023.3.0}/sxs/juliapkg.json

@@ -3,7 +3,7 @@
     "packages": {
         "PostNewtonian": {
             "uuid": "377afc40-5642-4616-8613-b7ebca523866",
-            "version": "0.7.1"
+            "version": "0.9"
         }
     }
 }

sxs-2023.3.0/tests/test_julia.py

@@ -0,0 +1,61 @@
+import numpy as np
+import sxs
+from sxs import julia
+
+def test_PNWaveform():
+    M1 = 0.3
+    M2 = 0.7
+    chi1 = [0.1, 0.2, 0.3]
+    chi2 = [-0.2, 0.1, -0.3]
+    Omega_i = 0.01
+    PNOrder = 4.0
+    waveform_pn_order = 4.0
+    saves_per_orbit = 32
+    w1 = sxs.julia.PNWaveform(
+        M1, M2, chi1, chi2, Omega_i,
+        PNOrder=PNOrder, waveform_pn_order=waveform_pn_order,
+        saves_per_orbit=saves_per_orbit
+    )
+
+    Approximant = "TaylorT1"
+    delta = sxs.julia.PostNewtonian.mass_difference_ratio(M1, M2)
+    chi1_i = chi1
+    chi2_i = chi2
+    Omega_orb_i = Omega_i
+    inertial = True
+    w2 = sxs.julia.GWFrames.PNWaveform(Approximant, delta, chi1_i, chi2_i, Omega_orb_i, inertial=inertial)
+
+    for w in [w1, w2]:
+        n_times = w.n_times
+        assert w.t[0] == 0.0
+        assert w.data.shape == (n_times, 77)
+        assert w.data_type == "h"
+        assert w.ell_min == 2
+        assert w.ell_max == 8
+        assert w.spin_weight == -2
+        assert w.frame.shape == (1, 4)
+        assert w.frame_type == "inertial"
+        assert w.M1.shape == (n_times,)
+        assert w.M2.shape == (n_times,)
+        assert w.chi1.shape == (n_times, 3)
+        assert w.chi2.shape == (n_times, 3)
+        assert w.coorbital_frame.shape == (n_times, 4)
+        assert w.v.shape == (n_times,)
+        assert w.orbital_phase.shape == (n_times,)
+
+    assert np.allclose(w1.t[:-10], w2.t[:-10])
+    assert np.allclose(w1.data[:-10, :], w2.data[:-10, :], rtol=1e-3, atol=1e-5)
+    assert np.allclose(w1.frame, w2.frame)
+    assert np.allclose(w1.M1[:-10], w2.M1[:-10])
+    assert np.allclose(w1.M2[:-10], w2.M2[:-10])
+    assert np.allclose(w1.chi1[:-10, :], w2.chi1[:-10, :], rtol=1e-3)
+    assert np.allclose(w1.chi2[:-10, :], w2.chi2[:-10, :], rtol=1e-3)
+    assert np.allclose(w1.coorbital_frame[:-10, :], w2.coorbital_frame[:-10, :])
+
+    w1_corot = w1.copy().to_corotating_frame()
+    w2_corot = w2.copy().to_corotating_frame()
+    for (w, w_corot) in [(w1, w1_corot), (w2, w2_corot)]:
+        assert np.array_equal(w.t, w_corot.t)
+        assert w.data.shape == w_corot.data.shape
+        assert w.coorbital_frame.shape == w_corot.frame.shape
+        assert w_corot.frame_type == "corotating"

sxs-2023.1.6/sxs/__version__.py

@@ -1 +0,0 @@
-__version__ = "2023.1.6"