binlite-2 0.0.1__tar.gz

binlite_2-0.0.1/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Thomas Slamecka
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

binlite_2-0.0.1/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: binlite_2
+Version: 0.0.1
+Summary: Rapidly generates accretion templates of eccentric binaries.
+Home-page: https://github.com/tslamecka/binlite_2
+Author: Thomas Slamecka
+Author-email: Thomas Slamecka <thomasslamecka@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/tslamecka/binlite_2
+Project-URL: Issues, https://github.com/tslamecka/binlite_2/issues
+Platform: Any
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: platform
+
+Binlite rapidly generates accretion templates of eccentric binaries.
+
+README to be updated in the soon future.

binlite_2-0.0.1/README.md

@@ -0,0 +1,3 @@
+Binlite rapidly generates accretion templates of eccentric binaries.
+
+README to be updated in the soon future.

binlite_2-0.0.1/binlite/__init__.py

@@ -0,0 +1,5 @@
+"""Rapidly generates accretion templates of eccentric binaries."""
+
+import sys
+if not '-m' in sys.argv:
+	from .accretion import AccretionSeries

binlite_2-0.0.1/binlite/accretion.py

@@ -0,0 +1,222 @@
+import numpy as np
+import os
+
+#=================================================================================================================================
+# Define files
+
+def get_base_dir():
+    return os.path.join(os.path.dirname(__file__), 'data\\')
+
+dfp_1p0 = np.genfromtxt(open(get_base_dir() + 'q1_primary_20F_new.dat'))
+dfs_1p0 = np.genfromtxt(open(get_base_dir() + 'q1_secondary_20F_new.dat'))
+dfT_1p0 = np.genfromtxt(open(get_base_dir() + 'q1_total_20F.dat'))
+
+dfp_0p6 = np.genfromtxt(open(get_base_dir() + 'q0p6_primary_20F.dat'))
+dfs_0p6 = np.genfromtxt(open(get_base_dir() + 'q0p6_secondary_20F.dat'))
+dfT_0p6 = np.genfromtxt(open(get_base_dir() + 'q0p6_total_20F.dat'))
+
+dfp_0p45 = np.genfromtxt(open(get_base_dir() + 'q0p45_primary_20F.dat'))
+dfs_0p45 = np.genfromtxt(open(get_base_dir() + 'q0p45_secondary_20F.dat'))
+dfT_0p45 = np.genfromtxt(open(get_base_dir() + 'q0p45_total_20F.dat'))
+
+dfp_0p3 = np.genfromtxt(open(get_base_dir() + 'q0p3_primary_20F.dat'))
+dfs_0p3 = np.genfromtxt(open(get_base_dir() + 'q0p3_secondary_20F.dat'))
+dfT_0p3 = np.genfromtxt(open(get_base_dir() + 'q0p3_total_20F.dat'))
+
+dfp_0p25 = np.genfromtxt(open(get_base_dir() + 'q0p25_primary_20F.dat'))
+dfs_0p25 = np.genfromtxt(open(get_base_dir() + 'q0p25_secondary_20F.dat'))
+dfT_0p25 = np.genfromtxt(open(get_base_dir() + 'q0p25_total_20F.dat'))
+
+dfp_0p15 = np.genfromtxt(open(get_base_dir() + 'q0p15_primary_20F.dat'))
+dfs_0p15 = np.genfromtxt(open(get_base_dir() + 'q0p15_secondary_20F.dat'))
+dfT_0p15 = np.genfromtxt(open(get_base_dir() + 'q0p15_total_20F.dat'))
+
+dfp_0p1 = np.genfromtxt(open(get_base_dir() + 'q0p1_primary_20F.dat'))
+dfs_0p1 = np.genfromtxt(open(get_base_dir() + 'q0p1_secondary_20F.dat'))
+dfT_0p1 = np.genfromtxt(open(get_base_dir() + 'q0p1_total_20F.dat'))
+
+dfp_0p05 = np.genfromtxt(open(get_base_dir() + 'q0p05_primary_20F.dat'))
+dfs_0p05 = np.genfromtxt(open(get_base_dir() + 'q0p05_secondary_20F.dat'))
+dfT_0p05 = np.genfromtxt(open(get_base_dir() + 'q0p05_total_20F.dat'))
+
+dfp_0p01 = np.genfromtxt(open(get_base_dir() + 'q0p01_primary_20F.dat'))
+dfs_0p01 = np.genfromtxt(open(get_base_dir() + 'q0p01_secondary_20F.dat'))
+dfT_0p01 = np.genfromtxt(open(get_base_dir() + 'q0p01_total_20F.dat'))
+
+dfp = [dfp_0p01, dfp_0p05, dfp_0p1, dfp_0p15, dfp_0p25, dfp_0p3, dfp_0p45, dfp_0p6, dfp_1p0]
+dfs = [dfs_0p01, dfs_0p05, dfs_0p1, dfs_0p15, dfs_0p25, dfs_0p3, dfs_0p45, dfs_0p6, dfs_1p0]
+dfT = [dfT_0p01, dfT_0p05, dfT_0p1, dfT_0p15, dfT_0p25, dfT_0p3, dfT_0p45, dfT_0p6, dfT_1p0]
+
+#=================================================================================================================================
+# MAGIC
+
+class AccretionSeries:
+    """For generating mock timseries of accretion rates onto equal mass binaries of a desired eccentricity
+		- prograde binaries with e < 0.1 will recover additional 5-orbit features if n_orbs > 5
+		- retrograde binaries with e > 0.55 will recover additional 2-orbit features if n_orbs > 2
+
+	Parameters
+	----------
+	eccentricity: 
+		desired binary eccentricity for accretion series (0<e<0.8)
+    mass_ratio:
+        desired binary mass ratio for accretion series (max 1)
+	n_modes (optional, default=20): 
+		number of modes to be used in constructing the series (max 20)
+	n_orbits (optional, default=10):
+		number of periods to generate
+	retrograde (optional, default=False): 
+		whether the binary should be regarded as retrograde to the CBD (otherwise prograde assumed)
+
+	Public attributes
+	-----------------
+	time      : values of the time associated with generated accretion series (in orbits)
+	primary   : periodic accretion series for the primary component (in units of viscous feeding rate)
+	secondary : periodic accretion series for the secondary component (in units of viscous feeding rate)
+	total     : total accretion rate series onto the binary (in units of viscous feeding rate)
+	"""
+    def __init__(self, eccentricity: float, mass_ratio: float, n_modes: int = 10, n_orbits: int = 10):
+        self.ecc = eccentricity
+        self.q = mass_ratio
+        self.modes = n_modes
+        self.orbits = n_orbits
+
+        if n_modes > 20:
+            print("error : exceeded maximum number of prograde Fourier modes (20)")
+            quit()
+        if eccentricity > 0.8 or eccentricity == 0.0:
+            print("error : outside of eccentricity range: 0.0 < e < 0.8")
+            quit()
+		
+        mode = 1
+        self.mode = mode
+
+        self.q_smpls = np.array([0.01,0.05,0.1,0.15,0.25,0.3,0.45,0.6,1.0])
+
+        if self.q != 1.0:
+            i1 = np.where(self.q >= self.q_smpls)[0][-1]
+            i2 = i1 + 1
+        else:
+            i1 = len(self.q_smpls) - 1
+            i2 = len(self.q_smpls) - 1
+
+        self.q1 = self.q_smpls[i1]
+        self.q2 = self.q_smpls[i2]
+
+        self.dataP1 = dfp[i1]
+        self.dataS1 = dfs[i1]
+        self.dataT1 = dfT[i1]
+        
+        self.dataP2 = dfp[i2]
+        self.dataS2 = dfs[i2]
+        self.dataT2 = dfT[i2]
+
+        self.repeats = int(self.orbits)  # Number of orbits
+        self.remainder = self.orbits % 1  # Remainder for non-integer orbits
+        self.e_smpls = np.transpose(self.dataT1)[:][2]
+        self.nx = len(self.dataP1)  # Number of data points
+        self.x = np.linspace(0.0, 2. * np.pi, self.nx)  # Space made for plotting
+
+        i = np.where(self.ecc >= self.e_smpls)[0][-1]
+        a01, a02 = self.dataT1[i][3], self.dataT2[i][3]
+        if self.q != 1.0:
+            self.a0 = ((self.q - self.q2) * a01 + (self.q1 - self.q) * a02) / (self.q1 - self.q2)
+        else:
+            self.a0 = a01
+
+        
+    # Public attributes
+	# -------------------------------------------------------------------------
+    @property
+    def time(self):
+        xlong = []  # Initial array for time
+        for n in range(self.repeats):
+            xlong.append(self.x / 2. / np.pi + n)  # Appends orbit number to array
+        xlong = np.concatenate(xlong)
+        idx = int(len(self.x) * self.remainder)  # Finds fraction of an orbit
+        xtra = self.x[:idx] / 2. / np.pi + self.repeats  # Appends fraction of an orbit
+        xlong = np.concatenate([xlong, xtra])
+        return xlong
+
+    @property
+    def primary(self):
+        """
+		Gives approximate accretion rate timeseries on primary (in units of the viscous feeding rate).
+	
+		: return : (ndarray) periodic accretion rate timeseries
+		"""
+        dm = self.__compute_signal_mode(self.dataP1, self.dataP2, self.mode)
+        dm = dm / self.a0
+        idx = int(len(dm) * self.remainder)
+        base = np.tile(dm, self.repeats)
+        return np.concatenate([base, dm[:idx]])
+
+    @property
+    def secondary(self):
+        """
+		Gives approximate accretion rate timeseries on secondary (in units of the viscous feeding rate).
+	
+		: return : (ndarray) periodic accretion rate timeseries
+		"""
+        dm = self.__compute_signal_mode(self.dataS1, self.dataS2, self.mode)
+        dm = dm / self.a0
+        idx = int(len(dm) * self.remainder)
+        base = np.tile(dm, self.repeats)
+        return np.concatenate([base, dm[:idx]])
+
+    @property
+    def total(self):
+        """
+		Gives approximate total accretion rate timeseries onto the binary (in units of the viscous feeding rate).
+	
+		: return : (ndarray) periodic accretion rate timeseries
+		"""
+        dm = self.__compute_signal_mode(self.dataT1, self.dataT2, self.mode)
+        dm = dm / self.a0
+        idx = int(len(dm) * self.remainder)
+        base = np.tile(dm, self.repeats)
+        return np.concatenate([base, dm[:idx]])
+
+    # Internal methods
+	# -------------------------------------------------------------------------
+    def __compute_signal_mode(self, data1, data2, m):
+        fs = []
+        i1 = np.where(self.ecc >= self.e_smpls)[0][-1]
+        i0 = i1 + 1
+        n = self.modes
+        e1 = self.e_smpls[i1]
+        e0 = self.e_smpls[i0]
+        a01 = data1[i1][3]
+        f11 = data1[i1][5:5+2*n]
+        f01 = data1[i0][5:5+2*n]
+        a02 = data2[i1][3]
+        f12 = data2[i1][5:5+2*n]
+        f02 = data2[i0][5:5+2*n]
+        fe1 = ((self.ecc - e0) * f11 + (e1 - self.ecc) * f01) / (e1 - e0) # interpolated coefficients
+        fe2 = ((self.ecc - e0) * f12 + (e1 - self.ecc) * f02) / (e1 - e0)
+        if self.q != 1.0:
+            fq = ((self.q - self.q2) * fe1 + (self.q1 - self.q) * fe2) / (self.q1 - self.q2)
+            a0 = ((self.q - self.q2) * a01 + (self.q1 - self.q) * a02) / (self.q1 - self.q2)
+        else:
+            fq = fe1
+            a0 = a01
+        for i in range(self.nx):
+            f = a0
+            for jj in range(n):
+                f += fq[2*jj] * np.cos((jj+1) * self.x[i] / m) + fq[2*jj+1] * np.sin((jj+1) * self.x[i] / m)
+            fs.append(f)
+        return np.array(fs)
+
+# Direct user callable functions
+# =============================================================================
+def orbits(eccentricity: float, n_modes: int = 20, n_orbits: int = 10, retrograde: bool = False):
+    return AccretionSeries(eccentricity, n_modes=n_modes, n_orbits=n_orbits).time
+
+def primary(eccentricity: float, n_modes: int = 20, n_orbits: int = 10, retrograde: bool = False):
+    return AccretionSeries(eccentricity, n_modes=n_modes, n_orbits=n_orbits).primary
+
+def secondary(eccentricity: float, n_modes: int = 20, n_orbits: int = 10, retrograde: bool = False):
+    return AccretionSeries(eccentricity, n_modes=n_modes, n_orbits=n_orbits).secondary
+
+def total(eccentricity: float, n_modes: int = 20, n_orbits: int = 10, retrograde: bool = False):
+    return AccretionSeries(eccentricity, n_modes=n_modes, n_orbits=n_orbits).total