roche 0.2.1__tar.gz

roche-0.2.1/.gitignore

@@ -0,0 +1 @@
+/target

roche-0.2.1/Cargo.lock

@@ -0,0 +1,218 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "bulirsch"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdbb964461d0f1217e0dcfd69c2879c4318524c6650d149b410b962bbf0f7c87"
+dependencies = [
+ "ndarray",
+ "num-traits",
+]
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "libc"
+version = "0.2.183"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d"
+
+[[package]]
+name = "matrixmultiply"
+version = "0.3.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a06de3016e9fae57a36fd14dba131fccf49f74b40b7fbdb472f96e361ec71a08"
+dependencies = [
+ "autocfg",
+ "rawpointer",
+]
+
+[[package]]
+name = "ndarray"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "882ed72dce9365842bf196bdeedf5055305f11fc8c03dee7bb0194a6cad34841"
+dependencies = [
+ "matrixmultiply",
+ "num-complex",
+ "num-integer",
+ "num-traits",
+ "portable-atomic",
+ "portable-atomic-util",
+ "rawpointer",
+]
+
+[[package]]
+name = "num-complex"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "portable-atomic"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
+
+[[package]]
+name = "portable-atomic-util"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "091397be61a01d4be58e7841595bd4bfedb15f1cd54977d79b8271e94ed799a3"
+dependencies = [
+ "portable-atomic",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.28.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf85e27e86080aafd5a22eae58a162e133a589551542b3e5cee4beb27e54f8e1"
+dependencies = [
+ "libc",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.28.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8bf94ee265674bf76c09fa430b0e99c26e319c945d96ca0d5a8215f31bf81cf7"
+dependencies = [
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.28.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "491aa5fc66d8059dd44a75f4580a2962c1862a1c2945359db36f6c2818b748dc"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.28.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f5d671734e9d7a43449f8480f8b38115df67bef8d21f76837fa75ee7aaa5e52e"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.28.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22faaa1ce6c430a1f71658760497291065e6450d7b5dc2bcf254d49f66ee700a"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "pyo3-build-config",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rawpointer"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3"
+
+[[package]]
+name = "rust-roche"
+version = "0.2.1"
+dependencies = [
+ "bulirsch",
+ "ndarray",
+ "pyo3",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"

roche-0.2.1/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "rust-roche"
+version = "0.2.1"
+edition = "2024"
+description = "Rust translation of Tom Marsh's cpp-roche package for modelling Roche distorted stars/binary systems."
+license = "MIT"
+readme = "README.md"
+
+[lib]
+name = "roche"
+# "cdylib" is necessary to produce a shared library for Python to import from.
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+ndarray = "0.16.1"
+bulirsch = "0.1.12"
+
+[dependencies.pyo3]
+version = "0.28.2"
+# "abi3-py38" tells pyo3 (and maturin) to build using the stable ABI with minimum Python version 3.8
+features = ["abi3-py38"]

roche-0.2.1/PKG-INFO

@@ -0,0 +1,4 @@
+Metadata-Version: 2.4
+Name: roche
+Version: 0.2.1
+Requires-Python: >=3.8

roche-0.2.1/README.md

@@ -0,0 +1,3 @@
+rust-roche is a translation of Tom Marsh's C++ [cpp-roche](https://github.com/trmrsh/cpp-roche) package for modelling Roche-distorted binary systems. As of the current version, not all functions from cpp-roche have been translated.
+
+This is very much a first go at it with only a small amount of testing and so expect bugs. 

roche-0.2.1/pyproject.toml

@@ -0,0 +1,12 @@
+[build-system]
+requires = ["maturin>=1.8,<2.0"]
+build-backend = "maturin"
+
+[project]
+name = "roche"
+version = "0.2.1"
+requires-python = ">=3.8"
+
+[tool.maturin]
+features = ["pyo3/extension-module"]
+cargo-extra-args = "--features extension-module"

roche-0.2.1/src/blink.rs

@@ -0,0 +1,211 @@
+use crate::Vec3;
+use crate::errors::RocheError;
+use crate::x_l1;
+
+///
+/// blink tests for the occultation of a point in a semi-detached
+/// binary. blink = true when point is eclipsed, otherwise = false. It works 
+/// by first trying to eliminate as many paths that go nowhere near the 
+/// Roche lobe before getting down to the hard work of stepping
+/// along the path.
+///
+/// NB Note that this version of !!emph{blink} works in units of binary separation
+/// NOT the inner lagrangian point distance.
+///
+/// Arguments:
+/// 
+/// * `q`: the mass ratio = M2/M1.
+/// * `r`: the position vector (in units of binary separation)
+/// * `e`: unit vector pointing towards Earth. Standardly this is (sini(i)*cos(phi),-sin(i)*sin(phi),cos(i))
+/// * `acc`: step size parameter. acc specifies the size of steps taken when trying to see if the 
+/// photon path goes inside the Roche lobe. The step size is roughly acc times the radius of the lobe filling star. 
+/// This means that the photon path could mistakenly not be occulted if it passed less than about (acc**2)/8 of 
+/// the radius below the surface of the Roche lobe. acc of order 0.1 should therefore do the job.
+/// Returns:
+/// 
+/// * false = not eclipsed; true = eclipsed.
+///
+pub fn blink(q: f64, r: &Vec3, e: &Vec3, acc: f64) -> Result<bool, RocheError> {
+
+    let mut x_cofm: f64;
+    let c1: f64;
+    let c2: f64;
+    let step: f64;
+    let pp: f64;
+    let crit: f64;
+    let mut p: f64;
+    let p1: f64;
+    let p2: f64;
+
+
+    let mut r1: f64;
+    let mut r2: f64;
+    // Compute q dependent quantities
+    if q <= 0. {
+        let message = format!("q = {} <= 0", q);
+        return Err(RocheError::ParameterError(message));
+    }
+
+    if acc <= 0.0 {
+        let message = format!("Invalid accuracy parameter. {} <= 0.0.", acc);
+        return Err(RocheError::ParameterError(message));
+    }
+ 
+    x_cofm = 1.0 / (1.0 + q);
+    c1 = 2.0 * x_cofm;
+    x_cofm *= q;
+    c2 = 2.0 * x_cofm;
+
+    // Locate the inner Lagrangian point (L1)
+    let rl1: f64 = x_l1(q)?;
+
+    // Evaluate Roche potential at L1 point.
+    r1 = rl1;
+    r2 = 1.0 - rl1;
+    let xc: f64 = rl1 - x_cofm;
+    crit = c1/r1 + c2/r2 + xc*xc;
+
+    // The red star lies entirely within the sphere centred on its
+    // centre of mass and reaching the inner Lagrangian point.
+
+    let rsphere: f64 = 1.0 - rl1;
+    pp = rsphere*rsphere;
+    step = rsphere*acc;
+
+    // From now on computations are done every call. Main point is
+    // to try to bail out as soon as possible to save time 
+
+    // evaluate closest approach distance to sphere.
+
+    let xt: f64 = r.x - 1.0;
+    let mut b: f64 = e.x*xt + e.y*r.y + e.z*r.z;
+    let mut c: f64 = xt*xt + r.y*r.y + r.z*r.z - pp;
+
+    // Photon path crosses sphere at two points given by quadratic
+    // equation l*l + 2*b*l + c = 0. First check that this has
+    // real roots. If not, there is no eclipse. This test should
+    // eliminate most cases.
+
+    let mut fac: f64 = b*b - c;
+
+    if fac <= 0.0 {
+        return Ok(false);
+    }
+
+    fac = fac.sqrt();
+
+    // If the larger root is negative, the photon starts after the sphere.
+    // This should get rid of another whole stack
+    
+
+    let par2: f64 = -b + fac;
+
+    if par2 <= 0.0 {
+        return Ok(false);
+    }
+
+    //  Now for the hard work. The photon's path does go
+    //  inside the sphere ... groan. First evaluate smaller root 
+    //  but limit to >= 0 to ensure that only photon path
+    //  and not its extrapolation backwards in included.
+
+    let mut par1: f64 = -b - fac;
+    par1 = if par1 > 0.0 {
+        par1
+    } else {
+        0.0
+    };
+
+    // Now follow the photon's path in finite steps to see if 
+    // it intercepts the red star. We start off at closest
+    // approach point to increase chance of only needing one 
+    // computation of the roche potential
+
+    let par: f64 =  if b < 0.0 {
+        -b
+    } else {
+        0.0
+    };
+
+    let mut x1: f64 = r.x + par*e.x;
+    let mut x2: f64 = r.y + par*e.y;
+    let mut x3: f64 = r.z + par*e.z;
+
+    // Test roche potential for an occultation
+    let mut xm: f64 = x1 - 1.0;
+    let mut yy: f64 = x2*x2;
+    let mut rr: f64 = yy + x3*x3;
+    let rs2: f64 = xm*xm + rr;
+
+    // Point at c of m of red star. Definitely eclipsed, avoids
+    // division by 0 later
+
+    if rs2 <= 0.0 {
+        return Ok(true);
+    }
+
+    let rs1: f64 = x1*x1 + rr;
+    r1 = rs1.sqrt();
+    r2 = rs2.sqrt();
+
+    // Deeper in well than inner Lagrangian, therefore eclipsed.
+
+    let mut xc: f64 = x1 - x_cofm;
+    c = c1/r1 + c2/r2 + xc*xc + yy;
+
+    if c > crit {
+        return Ok(true);
+    }
+
+    // Now we need to step. Determine step direction by 
+    // evaluating the first derivative
+
+    let a: f64 = x1*e.x + x2*e.y;
+    b = a + x3*e.z;
+
+    if -c1*b/(rs1*r1) - c2*(b - e.x)/(rs2*r2) + 2.0*(a - x_cofm*e.x) > 0.0 {
+        p1 = par;
+        p2 = par2;
+    } else {
+        p1 = par;
+        p2 = par1;
+    }
+
+    // Loop while the Roche potential increases in depth
+
+    let mut nstep: i32 = ((p2-p1).abs() / step + 0.5).floor() as i32;
+
+    nstep = nstep.max(2);
+    
+    let dp: f64 = (p2-p1)/(nstep as f64);
+    let mut cmax: f64 = c - 1.0;
+    let mut i: i32 = 0;
+    while c > cmax && i < nstep {
+        i += 1;
+        cmax = c;
+        p = p1 + dp*(i as f64);
+        x1 = r.x + p*e.x;
+        x2 = r.y + p*e.y;
+        x3 = r.z + p*e.z;
+
+        // test roche potential for an occultation, again guarding
+        // against division by 0
+
+        xm = x1 - 1.0;
+        yy = x2*x2;
+        rr = yy + x3*x3;
+        r2 = (xm*xm + rr).sqrt();
+        if r2 <= 0.0 {
+            return Ok(true);
+        }
+        r1 = (x1*x1 + rr).sqrt();
+        xc = x1 - x_cofm;
+        c = c1/r1 + c2/r2 + xc*xc + yy;
+        if c > crit {
+            return Ok(true);
+        }
+    }
+
+    return Ok(false)
+
+}