sxs 2023.1.4__tar.gz → 2023.1.6__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sxs
-Version: 2023.1.4
+Version: 2023.1.6
 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/
@@ -62,7 +62,8 @@ Requires-Dist: jupyterlab>=2.2.8; extra == 'ecosystem'
 Requires-Dist: line-profiler>=3.0.2; extra == 'ecosystem'
 Requires-Dist: matplotlib>=2.1.1; extra == 'ecosystem'
 Requires-Dist: memory-profiler>=0.57.0; extra == 'ecosystem'
-Requires-Dist: numpy-quaternion>=0.3.1; extra == 'ecosystem'
+Requires-Dist: numpy-quaternion>=2023.0.4; extra == 'ecosystem'
+Requires-Dist: numpy<2.0,>=1.20; extra == 'ecosystem'
 Requires-Dist: qgrid>=1.3.1; extra == 'ecosystem'
 Requires-Dist: rise>=5.6.1; extra == 'ecosystem'
 Requires-Dist: scri>=2020.8.18; (sys_platform != 'win32') and extra == 'ecosystem'

sxs-2023.1.6/docs/julia.md

@@ -0,0 +1,60 @@
+# Calling `sxs` from Julia
+
+Julia makes it extraordinarily simple to call Python packages from within Julia.
+
+!!! note
+
+    This page describes calling the `sxs` Python package from Julia.  Instructions
+    for calling Julia components from Python are found elsewhere.
+
+## Optional preliminary step: A new environment
+
+Julia also makes it much easier to work with "environments" than
+Python does.  If you want to create one from working with `sxs` in
+Julia, just create a new directory, `cd` into it, and run
+```bash
+julia --project=.
+```
+This will create a file named `Project.toml` in that directory
+containing this new environment.  Every time you need to work with
+this environment, you can tell Julia to use it by adding `--project=`
+followed by the path to that directory.  Alternatively, if Julia is already running,
+just hit `]` to enter the package manager, and run
+```julia
+activate /path/to/new/directory
+```
+
+## Getting Julia working with Python
+
+Once Julia is running (with the project you want), just run
+```julia
+import Pkg
+Pkg.add(["PythonCall", "CondaPkg"])
+using PythonCall
+import CondaPkg
+CondaPkg.add("numba", channel="numba")
+CondaPkg.add("llvmlite", channel="numba")
+CondaPkg.add("sxs", channel="conda-forge")
+```
+Once everything is installed, the main difference from Python is that
+you have to import the module as
+```julia
+sxs = pyimport("sxs")
+```
+Now, you can call functions from the `sxs` package nearly identically
+to how they are called in Python.  For example, the simple call to
+load a waveform from the README of this package is
+```julia
+waveform = sxs.load("SXS:BBH:0123/Lev/rhOverM", extrapolation_order=2)
+```
+That exact line works just in Julia like it does in Python.  (Note
+that strings must use double quotes in Julia, and Python's `True` and
+`False` are lowercased in Julia.)  And accessing members and methods
+of Python objects is just as natural.  For example, `waveform.t` and
+`waveform.data` return the same data as in Python.
+
+See the [PythonCall
+documentation](https://juliapy.github.io/PythonCall.jl/stable/pythoncall/)
+for more details on how to call Python from Julia, and any conversions
+that may need to be done.  Note that `pyconvert(Any, x)` will usually
+convert `x` to its most natural Julia equivalent.

{sxs-2023.1.4 → sxs-2023.1.6}/mkdocs.yml

@@ -30,6 +30,7 @@ nav:
     - "Horizons": "api/horizons.md"
     - "Waveforms": "api/waveforms.md"
   - "Calling from Mathematica": "mathematica.md"
+  - "Calling from Julia": "julia.md"
 
 theme:
   name: "material" # "readthedocs", "mkdocs", "material"
@@ -63,6 +64,7 @@ extra_javascript:
   - https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-svg.js
 
 markdown_extensions:
+  - admonition
   - toc:
       permalink: "#"
   - pymdownx.arithmatex:

{sxs-2023.1.4 → sxs-2023.1.6}/pyproject.toml

@@ -48,11 +48,12 @@ ecosystem = [
   "line_profiler >=3.0.2",
   "memory_profiler >=0.57.0",
   "matplotlib >=2.1.1",
+  "numpy >=1.20, <2.0",
   "sympy >=1.6.2",
   "corner >=2.1.0",
   "qgrid >=1.3.1",
   "rise >=5.6.1",
-  "numpy-quaternion >=0.3.1",
+  "numpy-quaternion >=2023.0.4",
   "spinsfast >=2022; sys_platform != 'win32'",
   "scri >=2020.8.18; sys_platform != 'win32'"
 ]
@@ -75,7 +76,8 @@ dependencies = [
   "pytest",
   "pytest-cov",
   "pytest-forked >=1.3.0",
-  "juliapkg >=0.1.13"
+  "juliapkg >=0.1.13",
+  "numpy >=1.20, <2.0"
 ]
 [tool.hatch.envs.default.scripts]
 # Run these as `hatch run test`

sxs-2023.1.6/sxs/__version__.py

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

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

@@ -14,7 +14,11 @@ def pkg_update():
     return PostNewtonian.seval("Pkg.update()")
 
 
-def PNWaveform(M1, M2, chi1, chi2, Omega_i, **kwargs):
+def PNWaveform(
+        M1, M2, chi1, chi2, Omega_i, *,
+        ell_min=2, ell_max=8, waveform_pn_order=None,
+        **orbital_evolution_kwargs
+):
     """Generate a PN waveform.
 
     The return value is an `sxs.WaveformModes` object with the
@@ -24,7 +28,8 @@ def PNWaveform(M1, M2, chi1, chi2, Omega_i, **kwargs):
         - `M2` (array): The secondary mass as a function of time.
         - `chi1` (array): The primary spin as a function of time.
         - `chi2` (array): The secondary spin as a function of time.
-        - `frame` (array): The quaternionic frame as a function of time.
+        - `frame` (array): The quaternionic frame as a function of
+          time.
         - `v` (array): The orbital velocity as a function of time.
         - `orbital_phase` (array): The orbital phase as a function of
           time.
@@ -34,21 +39,32 @@ def PNWaveform(M1, M2, chi1, chi2, Omega_i, **kwargs):
     `PostNewtonian.inertial_waveform`.  See [the Julia
     documentation](https://moble.github.io/PostNewtonian.jl/dev/internals/dynamics/#PostNewtonian.orbital_evolution)
     for details on the optional keyword arguments.
+
+    Note that the full Julia interface is also accessible from this
+    Python module.  See [the Julia
+    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(M1, M2, chi1, chi2, Omega_i, **kwargs)
+    inspiral = PostNewtonian.orbital_evolution(
+        M1, M2, chi1, chi2, Omega_i, **orbital_evolution_kwargs
+    )
     values = PostNewtonian.stack(inspiral.u)
 
     # Compute the waveform in the inertial frame
-    h = PostNewtonian.inertial_waveform(inspiral).to_numpy().T
+    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
 
     w = WaveformModes(
         h,
         time=inspiral.t,
         modes_axis=1,
-        ell_min=2,
-        ell_max=8,
+        ell_min=ell_min,
+        ell_max=ell_max,
         M1=values[0, :].to_numpy(),
         M2=values[1, :].to_numpy(),
         chi1=values[2:5, :].to_numpy().T,

sxs-2023.1.4/sxs/__version__.py

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