ler 0.2.7__tar.gz → 0.2.9__tar.gz

{ler-0.2.7 → ler-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ler
-Version: 0.2.7
+Version: 0.2.9
 Summary: Gravitational waves Lensing Rates
 Home-page: https://github.com/hemantaph/ler
 Author: Hemantakumar
@@ -9,17 +9,28 @@ License: MIT
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: setuptools>=65.5.0
+Requires-Dist: numpy>=1.18
+Requires-Dist: numba>=0.57.1
+Requires-Dist: bilby>=1.0.2
+Requires-Dist: gwsnr>=0.1
+Requires-Dist: scipy>=1.9.0
+Requires-Dist: lenstronomy>=1.10.4
+Requires-Dist: astropy>=5.1
+Requires-Dist: tqdm>=4.64.1
+Requires-Dist: pointpats>=2.3
+Requires-Dist: shapely>=2.0.1
 
 # LeR
 [![DOI](https://zenodo.org/badge/626733473.svg)](https://zenodo.org/badge/latestdoi/626733473) [![PyPI version](https://badge.fury.io/py/ler.svg)](https://badge.fury.io/py/ler) [![DOCS](https://readthedocs.org/projects/ler/badge/?version=latest)](https://ler.readthedocs.io/en/latest/)
 
-`LeR` is a statistical-based python package whose core function is designed for the computation of detectable rates pertaining to both lensed and unlensed gravitational wave (GW) events. This calculation intricately hinges upon the interplay of various components within the package, which can be categorized into three primary segments: 1. Sampling the properties of compact-binary sources, 2. Sampling characteristics of lens galaxies, and 3. Solving the lens equation to derive image attributes of the source. The holistic functionality of the package is built upon leveraging array operations and linear algebra from the numpy library, interpolation from scipy, and the `multiprocessing` capability inherent to Python. This design optimizes both speed and functionality while upholding user-friendliness. The architecture of the "LeR" API is deliberately organized such that each distinct functionality holds its own significance in scientific research. Simultaneously, these functionalities seamlessly integrate and can be employed collectively based on specific research requirements. Key features of `LeR` and its dependencies can be summarized as follows,
+`LeR` is a statistical-based python package whose core function is designed for the computation of detectable rates pertaining to both lensed and unlensed gravitational wave (GW) events. This calculation intricately hinges upon the interplay of various components within the package, which can be categorized into three primary segments: 1. Sampling the properties of compact-binary sources, 2. Sampling characteristics of lens galaxies, and 3. Solving the lens equation to derive image attributes of the source. The holistic functionality of the package is built upon leveraging array operations and linear algebra from the `numpy` library, interpolation from `scipy`, and the `multiprocessing` capability inherent to Python. This design optimizes both speed and functionality while upholding user-friendliness. The architecture of the "LeR" API is deliberately organized such that each distinct functionality holds its own significance in scientific research. Simultaneously, these functionalities seamlessly integrate and can be employed collectively based on specific research requirements. Key features of `LeR` and its dependencies can be summarized as follows,
 
 - Detectable merger rates: 
     * The calculation depends not only on simulated event properties but also on GW detector detectability. We compute optimal signal-to-noise ratios (SNRs) for simulated events, which can be computationally intensive. `LeR` mitigates this using [`gwsnr`](https://github.com/hemantaph/gwsnr) for efficient  and rapid SNR calculation. `gwsnr` enables rate calculation for current and future detectors with customizable sensitivities.
     * The merger rates of both the simulated unlensed and lensed events can be computed and subsequently compared. 
 - Sampling GW sources:
-    * The distribution of the source's red-shift is based on the merger rate density of compact binaries, including binary black hole (BBH), binary neutron star (BNS) etc. The code is meticulously structured to facilitate straightforward incorporation of future updates or additional distributions of such sources by users.
+    * The distribution of the source's red-shift is based on the merger rate density of compact binaries, including BBHs, BNSs etc. The code is meticulously structured to facilitate straightforward incorporation of future updates or additional distributions of such sources by users.
     * The sampling of intrinsic and extrinsic parameters of gravitational wave sources is conducted employing the prior distributions encompassed within the `gwcosmo` and `bilby` Python packages. Prior to parameterizing the rate calculation, users retain the flexibility to manually substitute any relevant parameters as needed.
 - Sampling of lens galaxies:
     * The Lens distribution follows [(Oguri et al. 2018](https://arxiv.org/abs/1807.02584). It depends on the sampled source red-shifts and also on the optical depth.

{ler-0.2.7 → ler-0.2.9}/README.md

@@ -1,13 +1,13 @@
 # LeR
 [![DOI](https://zenodo.org/badge/626733473.svg)](https://zenodo.org/badge/latestdoi/626733473) [![PyPI version](https://badge.fury.io/py/ler.svg)](https://badge.fury.io/py/ler) [![DOCS](https://readthedocs.org/projects/ler/badge/?version=latest)](https://ler.readthedocs.io/en/latest/)
 
-`LeR` is a statistical-based python package whose core function is designed for the computation of detectable rates pertaining to both lensed and unlensed gravitational wave (GW) events. This calculation intricately hinges upon the interplay of various components within the package, which can be categorized into three primary segments: 1. Sampling the properties of compact-binary sources, 2. Sampling characteristics of lens galaxies, and 3. Solving the lens equation to derive image attributes of the source. The holistic functionality of the package is built upon leveraging array operations and linear algebra from the numpy library, interpolation from scipy, and the `multiprocessing` capability inherent to Python. This design optimizes both speed and functionality while upholding user-friendliness. The architecture of the "LeR" API is deliberately organized such that each distinct functionality holds its own significance in scientific research. Simultaneously, these functionalities seamlessly integrate and can be employed collectively based on specific research requirements. Key features of `LeR` and its dependencies can be summarized as follows,
+`LeR` is a statistical-based python package whose core function is designed for the computation of detectable rates pertaining to both lensed and unlensed gravitational wave (GW) events. This calculation intricately hinges upon the interplay of various components within the package, which can be categorized into three primary segments: 1. Sampling the properties of compact-binary sources, 2. Sampling characteristics of lens galaxies, and 3. Solving the lens equation to derive image attributes of the source. The holistic functionality of the package is built upon leveraging array operations and linear algebra from the `numpy` library, interpolation from `scipy`, and the `multiprocessing` capability inherent to Python. This design optimizes both speed and functionality while upholding user-friendliness. The architecture of the "LeR" API is deliberately organized such that each distinct functionality holds its own significance in scientific research. Simultaneously, these functionalities seamlessly integrate and can be employed collectively based on specific research requirements. Key features of `LeR` and its dependencies can be summarized as follows,
 
 - Detectable merger rates: 
     * The calculation depends not only on simulated event properties but also on GW detector detectability. We compute optimal signal-to-noise ratios (SNRs) for simulated events, which can be computationally intensive. `LeR` mitigates this using [`gwsnr`](https://github.com/hemantaph/gwsnr) for efficient  and rapid SNR calculation. `gwsnr` enables rate calculation for current and future detectors with customizable sensitivities.
     * The merger rates of both the simulated unlensed and lensed events can be computed and subsequently compared. 
 - Sampling GW sources:
-    * The distribution of the source's red-shift is based on the merger rate density of compact binaries, including binary black hole (BBH), binary neutron star (BNS) etc. The code is meticulously structured to facilitate straightforward incorporation of future updates or additional distributions of such sources by users.
+    * The distribution of the source's red-shift is based on the merger rate density of compact binaries, including BBHs, BNSs etc. The code is meticulously structured to facilitate straightforward incorporation of future updates or additional distributions of such sources by users.
     * The sampling of intrinsic and extrinsic parameters of gravitational wave sources is conducted employing the prior distributions encompassed within the `gwcosmo` and `bilby` Python packages. Prior to parameterizing the rate calculation, users retain the flexibility to manually substitute any relevant parameters as needed.
 - Sampling of lens galaxies:
     * The Lens distribution follows [(Oguri et al. 2018](https://arxiv.org/abs/1807.02584). It depends on the sampled source red-shifts and also on the optical depth.

{ler-0.2.7 → ler-0.2.9}/ler/__init__.py

@@ -1,3 +1,15 @@
+"""
+LeR
+"""
+
+import sys
+import warnings
+warnings.filterwarnings("ignore", "Wswiglal-redir-stdio")
+
+__author__ = 'hemanta_ph <hemantaphurailatpam@gmail.com>'
+
+__version__ = "0.2.7"
+
 from .ler import LeR
 from .lens_galaxy_population import LensGalaxyPopulation
 from .source_population import SourceGalaxyPopulationModel, CompactBinaryPopulation

{ler-0.2.7 → ler-0.2.9}/ler/lens_galaxy_population.py

@@ -3,7 +3,9 @@
 This module contains the LensGalaxyPopulation class, which is used to sample lens galaxy parameters, source parameters conditioned on the source being strongly lensed, image properties, and lensed SNRs. \n
 The class inherits from the CompactBinaryPopulation class, which is used to sample source parameters. \n
 """
+import warnings
 
+warnings.filterwarnings("ignore")
 import numpy as np
 from scipy.stats import gengamma, rayleigh, norm
 from scipy.interpolate import interp1d
@@ -188,7 +190,7 @@ class LensGalaxyPopulation:
             # initialization of clasess
             # CompactBinaryPopulation already inherits from Source_Galaxy_Population_Model class form source_population.py
             self.cbc_pop = CompactBinaryPopulation(
-                z_min=0.0,
+                z_min=0.0001,
                 z_max=10.0,
                 m_min=4.59,
                 m_max=86.22,
@@ -216,7 +218,7 @@ class LensGalaxyPopulation:
         pdf_unnormalized = (
             lambda z: merger_rate_density_detector_frame(z)
             * self.differential_comoving_volume(z)
-            * self.strong_lensing_optical_depth(z)
+            * self.strong_lensing_optical_depth_SIS(z)
         )
         # Normalize the pdf
         # this normalization factor is common no matter what you choose for z_min and z_max
@@ -445,8 +447,8 @@ class LensGalaxyPopulation:
             )
 
             # put strong lensing condition with optical depth
-            tau = self.strong_lensing_optical_depth(zs)
-            tau_max = np.max(self.strong_lensing_optical_depth(z_max))
+            tau = self.strong_lensing_optical_depth_SIS(zs)
+            tau_max = np.max(self.strong_lensing_optical_depth_SIS(z_max))
             r = np.random.uniform(0, tau_max, size=len(zs))
             pick_strongly_lensed = r < tau  # pick strongly lensed sources
             # Add the strongly lensed source redshifts to the list
@@ -557,7 +559,7 @@ class LensGalaxyPopulation:
         Returns
         -------
             theta_E : `float`
-                Einstein radii of the lens galaxies
+                Einstein radii of the lens galaxies in radian
 
         """
         # Compute the angular diameter distances
@@ -650,9 +652,9 @@ class LensGalaxyPopulation:
         idx = u < theta_E**2
         return idx
 
-    def strong_lensing_optical_depth(self, zs):
+    def strong_lensing_optical_depth_SIE(self, zs):
         """
-        Function to compute the strong lensing optical depth
+        Function to compute the strong lensing optical depth SIE
 
         Parameters
         ----------
@@ -665,8 +667,41 @@ class LensGalaxyPopulation:
                 strong lensing optical depth
 
         """
+        # for SIE model
+        # dedine a function to calculate the cross section number
+        # here we already assume that we have initialized the crossection spline 
+        def getcrosssect_num(theta_E, q):
+            fid_b_I = 10.0  # constant
+            idx = q > 0.999
+            q[idx] = 0.999
+            idx = q < 0.1
+            q[idx] = 0.1
+            b_I = theta_E * np.sqrt(q)
+            return self.cross_sect_spl(q)*(b_I/fid_b_I)**2
+
+        # theta_E=bsis=einstein_radius_SIS  # refer to compute_einstein_radii
+        
+        return getcrosssect_num(theta_E, q)/(4*np.pi)
+
+    def strong_lensing_optical_depth_SIS(self, zs):
+        """
+        Function to compute the strong lensing optical depth (SIS)
+
+        Parameters
+        ----------
+            zs : `float`
+                source redshifts
+
+        Returns
+        -------
+            tau : `float`
+                strong lensing optical depth
+
+        """
+        # For SIS model
         # z to luminosity_distance (luminosity_distance) conversion
         Dc = self.z_to_Dc(zs) * 1e-3  # 1e-3 converts Mpc to Gpc
+
         return (Dc / 62.2) ** 3
 
     def get_image_properties(

{ler-0.2.7 → ler-0.2.9}/ler/ler.py

@@ -200,7 +200,7 @@ class LeR:
         self,
         nsamples=100000,
         npool=int(4),
-        z_min=0.0,
+        z_min=0.0001,
         z_max=10.0,
         batch_size=25000,
         snr_finder="gwsnr",
@@ -230,11 +230,17 @@ class LeR:
             "m_max": 86.22,
             "z_min": z_min,
             "z_max": z_max,
-            "event_type": "popI_II",
+            "event_type": "BBH",
+            "category": "popI_II",
+            "sub_category": "gwcosmo",
+            "redshift_event_type": None,
+            "redshift_category": None,
             "merger_rate_density_fn": None,
             "merger_rate_density_param": None,
             "src_model_params": None,
-            "spin_zero": False,
+            "mass_constant": False,
+            "redshift_constant": False,
+            "spin_constant": False,
         }
         # for lensed case
         # set 'min_lensed_images' = 2 for double image lensed case
@@ -308,8 +314,9 @@ class LeR:
         if unavailable, the unlensed parameters will be sampled when unlensed_rate() is called \n
         gw_param.keys() = ['m1', 'm2', 'z', 'snr', 'theta_jn', 'ra', 'dec', 'psi', 'phase', 'geocent_time'] \n
         """
-        if self._gw_param == "default":
-            f = open("gw_params.json", "r", encoding="utf-8")
+        # if file name
+        if isinstance(self._gw_param, str):
+            f = open(self._gw_param, "r", encoding="utf-8")
             self._gw_param = json.loads(f.read())
         return self._gw_param
 
@@ -325,8 +332,9 @@ class LeR:
         if unavailable, the unlensed parameters will be sampled when unlensed_rate() is called \n
         gw_param_detectable.keys() = ['m1', 'm2', 'z', 'snr', 'theta_jn', 'ra', 'dec', 'psi', 'phase', 'geocent_time'] \n
         """
-        if self._gw_param_detectable == "default":
-            f = open("gw_params_detectable.json", "r", encoding="utf-8")
+        # if file name
+        if isinstance(self._gw_param_detectable, str):
+            f = open(self._gw_param_detectable, "r", encoding="utf-8")
             self._gw_param_detectable = json.loads(f.read())
         return self._gw_param_detectable
 
@@ -342,8 +350,9 @@ class LeR:
         if unavailable, the lensed parameters will be sampled when lensed_rate() is called \n
         lensed_param.keys() = ['m1', 'm2', 'z', 'snr', 'theta_jn', 'ra', 'dec', 'psi', 'phase', 'geocent_time', 'lensed_images'] \n
         """
-        if self._lensed_param == "default":
-            f = open("lensed_params.json", "r", encoding="utf-8")
+        # if file name
+        if isinstance(self._lensed_param, str):
+            f = open(self._lensed_param, "r", encoding="utf-8")
             self._lensed_param = json.loads(f.read())
         return self._lensed_param
 
@@ -359,8 +368,9 @@ class LeR:
         if unavailable, the lensed parameters will be sampled when lensed_rate() is called \n
         lensed_param_detectable.keys() = ['m1', 'm2', 'z', 'snr', 'theta_jn', 'ra', 'dec', 'psi', 'phase', 'geocent_time', 'lensed_images'] \n
         """
-        if self._lensed_param_detectable == "default":
-            f = open("lensed_params_detectable.json", "r", encoding="utf-8")
+        # if file name
+        if isinstance(self._lensed_param_detectable, str):
+            f = open(self._lensed_param_detectable, "r", encoding="utf-8")
             self._lensed_param_detectable = json.loads(f.read())
         return self._lensed_param_detectable
 
@@ -379,12 +389,18 @@ class LeR:
             m_min=self.gw_param_sampler_dict["m_min"],
             m_max=self.gw_param_sampler_dict["m_max"],
             event_type=self.gw_param_sampler_dict["event_type"],
+            category=self.gw_param_sampler_dict["category"],
+            sub_category=self.gw_param_sampler_dict["sub_category"],
+            redshift_event_type=self.gw_param_sampler_dict["redshift_event_type"],
+            redshift_category=self.gw_param_sampler_dict["redshift_category"],
             merger_rate_density_fn=self.gw_param_sampler_dict[
                 "merger_rate_density_fn"],
             merger_rate_density_param=self.gw_param_sampler_dict[
                 "merger_rate_density_param"],
             src_model_params=self.gw_param_sampler_dict["src_model_params"],
-            spin_zero=self.gw_param_sampler_dict["spin_zero"],
+            mass_constant=self.gw_param_sampler_dict["mass_constant"],
+            redshift_constant=self.gw_param_sampler_dict["redshift_constant"],
+            spin_constant=self.gw_param_sampler_dict["spin_constant"],
         )
         self.lens_galaxy_pop = LensGalaxyPopulation(self.compact_binary_pop)
 
@@ -591,8 +607,10 @@ class LeR:
                     data = json.load(f)
                     track_batches = (len(data["zs"]) - frac_batches) // batch_size + 1
             except:
-                print(f"no json file found with name {json_file}. Set resume=False")
-                return None
+                track_batches = track_batches + 1
+                print(f"Batch no. {track_batches}")
+                # new first batch with the frac_batches
+                sampling_routine(nsamples=frac_batches, file_name=json_file)
 
         # ---------------------------------------------------#
         min_, max_ = track_batches, num_batches
@@ -1010,11 +1028,11 @@ class LeR:
                 snr = lensed_param["opt_snr_net"]
             except:
                 # snr not provided
-                print("snr not provided in gw_param dict. Exiting...")
+                print("snr not provided in lensed_param dict. Exiting...")
                 return None
 
             snr_hit = np.full(size, True)  # boolean array to store the result of the threshold condition
-            # Below can be just one line with 3D numpy operation
+            # for each row: choose a threshold and check if the number of images above threshold. Sum over the images. If sum is greater than num_img, then snr_hit = True 
             for i in range(len(snr_threshold)):
                 snr_hit = snr_hit & (np.sum((snr > snr_threshold[i]), axis=1) >= num_img[i])
             snr_hit = snr_hit & not_rejected
@@ -1234,9 +1252,9 @@ class LeR:
             data = json.load(f)
         # append the results
         if detectability_condition == "step_function":
-            data['unlensed_rate_ratio_step'] = rate_ratio
+            data['rate_ratio_step'] = rate_ratio
         elif detectability_condition == "pdet":
-            data['unlensed_rate_ratio_pdet'] = rate_ratio
+            data['rate_ratio_pdet'] = rate_ratio
         # write the results
         append_json(self.json_file_ler_param, data, replace=True)
 
@@ -1573,6 +1591,11 @@ class LeR:
             extent=np.log10(extent),
         )
 
+        # labels
+        ax.xlabel(r"$log_{10}\Delta t$ (days)")
+        ax.ylabel(r"$\Delta log_{10}\mu$")
+        ax.title(r"relative magnification vs relative time delay")
+
         # save figure
         if savefig:
             ax.savefig("mu_vs_dt.png", dpi=300, bbox_inches="tight")

{ler-0.2.7 → ler-0.2.9}/ler/source_population.py

@@ -132,9 +132,10 @@ class SourceGalaxyPopulationModel:
 
     def __init__(
             self,
-            z_min=0.0,
+            z_min=0.0001,
             z_max=10.0,
             event_type="popI_II",
+            category="Oguri",
             merger_rate_density_fn=None,
             merger_rate_density_param=None):
 
@@ -150,18 +151,22 @@ class SourceGalaxyPopulationModel:
             self.merger_rate_density = merger_rate_density_fn
         else:
             try:
+                if category == None:
+                    category = ""
+                else:
+                    category = "_" + category
                 self.merger_rate_density = getattr(
-                    self, "merger_rate_density_" + event_type
+                    self, "merger_rate_density_" + event_type + category
                 )
             except:
-                self.merger_rate_density = getattr(self, "merger_rate_density_" + "popI_II")
+                self.merger_rate_density = getattr(self, "merger_rate_density_" + "popI_II_Oguri")
 
-        merger_rate_density_detector_frame = lambda z: self.merger_rate_density(z) / (
+        merger_rate_density_source_frame = lambda z: self.merger_rate_density(z) / (
             1 + z
         )
 
         # Define the pdf p(z)
-        pdf_unnormalized = lambda z: merger_rate_density_detector_frame(
+        pdf_unnormalized = lambda z: merger_rate_density_source_frame(
             z
         ) * self.differential_comoving_volume(z)
         # Normalize the pdf
@@ -226,7 +231,7 @@ class SourceGalaxyPopulationModel:
         Examples
         ----------
         >>> from ler import SourceGalaxyPopulationModel
-        >>> pop = SourceGalaxyPopulationModel(z_min=0.0001, z_max=10, event_type = "popI_II")
+        >>> pop = SourceGalaxyPopulationModel(z_min=0.0001, z_max=10, event_type = "popI_II_Oguri")
         >>> zs = pop.sample_source_redshifts(size=1000)
         >>> zs
         array([0.0001, 0.0001, 0.0001, ..., 9.9999, 9.9999, 9.9999])
@@ -234,11 +239,11 @@ class SourceGalaxyPopulationModel:
         """
         # Define the merger-rate density function
         # print(f"z_max = {z_max}")
-        merger_rate_density_detector_frame = lambda z: self.merger_rate_density(z) / (
+        merger_rate_density_source_frame = lambda z: self.merger_rate_density(z) / (
             1 + z
         )
         # Define the pdf p(z)
-        pdf_unnormalized = lambda z: merger_rate_density_detector_frame(
+        pdf_unnormalized = lambda z: merger_rate_density_source_frame(
             z
         ) * self.differential_comoving_volume(z)
         # Normalize the pdf
@@ -248,7 +253,7 @@ class SourceGalaxyPopulationModel:
         zs = rejection_sample(pdf, z_min, z_max, size=size)
         return zs
 
-    def merger_rate_density_popI_II(self, zs, R0=23.9 * 1e-9, b2=1.6, b3=2.0, b4=30):
+    def merger_rate_density_popI_II_Oguri(self, zs, R0=25.0 * 1e-9, b2=1.6, b3=2.0, b4=30):
         """
         Function to compute the merger rate density (PopI/PopII)
 
@@ -277,12 +282,18 @@ class SourceGalaxyPopulationModel:
         Examples
         ----------
         >>> from ler import SourceGalaxyPopulationModel
-        >>> pop = SourceGalaxyPopulationModel(z_min=0.0001, z_max=10, event_type = "popI_II")
-        >>> rate_density = pop.merger_rate_density_popI_II(zs=0.1)
+        >>> pop = SourceGalaxyPopulationModel(z_min=0.0001, z_max=10, event_type = "popI_II_Oguri")
+        >>> rate_density = pop.merger_rate_density_popI_II_Oguri(zs=0.1)
         >>> rate_density
         2.7848018586883885e-08
 
         """
+        # if self.event_type == "BNS":
+        #     R0 = 170.0 * 1e-9
+        # if self.event_type == "NSBH":
+        #     R0 = 27.0 * 1e-9
+
+        #print("\n merger_rate_density_popI_II_Oguri \n")
         # replace values with self.merger_rate_density_param, if given
         param = dict(R0=R0, b2=b2, b3=b3, b4=b4)
         if self.merger_rate_density_param is not None:
@@ -331,6 +342,7 @@ class SourceGalaxyPopulationModel:
         1.2355851838964846
 
         """
+        # print("\n merger_rate_density_popI_II_Madau_Dickinson \n")
         # replace values with self.merger_rate_density_param, if given
         param = dict(af=af, bf=bf, cf=cf)
         if self.merger_rate_density_param is not None:
@@ -339,11 +351,11 @@ class SourceGalaxyPopulationModel:
                 if key in keys_:
                     param[key] = value
 
-        rate_density = (1 + zs) ** param["af"] / (1 + ((1 + zs) / param["cf"]) ** param["bf"])
+        rate_density = 0.015 * (1 + zs) ** param["af"] / (1 + ((1 + zs) / param["cf"]) ** param["bf"])
 
         return rate_density
 
-    def merger_rate_density_popIII(self, zs, aIII=0.66, bIII=0.3, zIII=11.6):
+    def merger_rate_density_popIII_Ken(self, zs, aIII=0.66, bIII=0.3, zIII=11.6):
         """
         Function to compute the unnormalized merger rate density (PopIII)
 
@@ -374,6 +386,7 @@ class SourceGalaxyPopulationModel:
         >>> rate_density
         0.00010000000000000002
         """
+        #print("\n ken \n")
         # replace values with self.merger_rate_density_param, if given
         param = dict(aIII=aIII, bIII=bIII, zIII=zIII)
         if self.merger_rate_density_param is not None:
@@ -387,7 +400,7 @@ class SourceGalaxyPopulationModel:
 
         return rate_density
 
-    def merger_rate_density_primordial(self, zs, t0=13.786885302009708):
+    def merger_rate_density_primordial_Ken(self, zs, t0=13.786885302009708):
         """
         Function to compute the merger rate density (Primordial)
 
@@ -552,63 +565,63 @@ class CompactBinaryPopulation(SourceGalaxyPopulationModel):
         self,
         z_min=0.0001,
         z_max=10,
-        m_min=4.59,
-        m_max=86.22,
-        event_type="popI_II",
+        m_min=None,
+        m_max=None,
+        event_type="BBH",
+        category=None,
+        sub_category=None,
+        redshift_event_type=None,
+        redshift_category=None,
         merger_rate_density_fn=None,
         merger_rate_density_param=None,
         src_model_params=None,
-        spin_zero=False,
+        redshift_constant = False,
+        mass_constant=False,
+        spin_constant=0.,
     ):
         # initialized SourceGalaxyPopulationModel mother class
         # self.z_min and self.z_max will inherit from SourceGalaxyPopulationModel
-        super().__init__(z_min=z_min, z_max=z_max, event_type=event_type, merger_rate_density_fn=merger_rate_density_fn, merger_rate_density_param=merger_rate_density_param)
-
-        # self.z_min already defined in SourceGalaxyPopulationModel
-        # self.z_max already defined in SourceGalaxyPopulationModel
-        self.m_min = m_min
-        self.m_max = m_max
-        try:
-            self.source_binary_masses = getattr(self, "binary_masses_" + event_type)
-        except:
-            pass
-
-        # check spin_zero
-        self.spin_zero = spin_zero
-        if spin_zero:
-            self.binary_spin = None
-        else:
-            try:
-                self.binary_spin = getattr(self, "binary_spin_" + event_type)
-            except:
-                self.binary_spin = getattr(self, "binary_spin_" + event_type)
-
-        # check the src_model_params have required keys
-        # check mass range
-        if event_type == "popI_II":
-            if m_min < 4.59:
-                print("WARNING: m_min is too low for popI/II BBHs")
-            if m_max > 86.22:
-                print("WARNING: m_max is too high for popI/II BBHs")
+        if redshift_event_type is None:
+            redshift_event_type = category
 
-        elif event_type == "popIII":
-            pass
+        super().__init__(z_min=z_min, z_max=z_max, event_type=redshift_event_type, category=redshift_category, merger_rate_density_fn=merger_rate_density_fn, merger_rate_density_param=merger_rate_density_param)
 
-        elif event_type == "BNS":
-            # check the mass is for neutron stars
-            if m_min < 1.4:
-                print("WARNING: m_min is too low for neutron stars")
-            if m_max > 3.0:
-                print("WARNING: m_max is too high for neutron stars")
+        # check redshift
+        self.redshift_constant = redshift_constant
+        if redshift_constant:
+            self.sample_source_redshifts = None
 
-        elif event_type == "popI_II_Madau_Dickinson":
-            self.source_binary_masses = getattr(self, "binary_masses_" + "popI_II")
+        # checking for event-type, category, sub-categoru
+        # in BBH_popI_II_gwcosmo, "BBH": event type, "popI_II": category, "gwcosmo": sub-category
+        if category==None:
+            category = "_popI_II"
+        else:
+            category = "_"+category
+        if sub_category==None:
+            sub_category = "_gwcosmo"
+        else:
+            sub_category = "_"+sub_category
 
-        elif event_type == "primordial":
-            pass
+        # check mass
+        self.mass_constant = mass_constant
+        if mass_constant:
+            self.source_binary_masses = None
+        else:
+            self.m_min = m_min
+            self.m_max = m_max
+            try:
+                self.source_binary_masses = getattr(self, "binary_masses_" + event_type + category + sub_category)
+            except:
+                pass
 
+        # check spin
+        if spin_constant or spin_constant==0.:
+            self.spin_constant = spin_constant
         else:
-            print(f"Event Type: {event_type} is not recognised")
+            try:
+                self.binary_spin = getattr(self, "binary_spin_" + event_type)
+            except:
+                self.binary_spin = getattr(self, "binary_spin_BBH")
 
         # set attribute
         self.src_model_params = src_model_params
@@ -648,10 +661,6 @@ class CompactBinaryPopulation(SourceGalaxyPopulationModel):
                 f"refer to https://arxiv.org/abs/1908.06068 for parameter definitions, priors and sampling methods"
             )
 
-        # inherit attributes from SourceGalaxyPopulationModel
-        z_min = self.z_min
-        z_max = self.z_max
-
         def warning(param_):
             try:
                 len(param_) == nsamples
@@ -660,29 +669,44 @@ class CompactBinaryPopulation(SourceGalaxyPopulationModel):
                 return 0
 
         # sampling redshifts and luminosity distances
-        try:
-            kwargs["zs"]
-        except:
-            zs = self.sample_source_redshifts(size=nsamples, z_min=z_min, z_max=z_max)
+        if self.redshift_constant:
+            if type(self.redshift_constant)==float or type(self.redshift_constant)==int:
+                zs = self.redshift_constant*np.ones(nsamples)
+            else:
+                # warning
+                print("Error: redshift_constant should be a float or false")
         else:
-            zs = kwargs["zs"]
-            warning(zs)
+            try:
+                zs = kwargs["zs"]
+            except:
+                zs = self.sample_source_redshifts(size=nsamples, z_min=self.z_min, z_max=self.z_max)
         luminosity_distance = self.z_to_luminosity_distance(zs)  # Mpc
 
         # sampling mass1 and mass2
-        try:
-            kwargs["mass_1"]
-            kwargs["mass_2"]
-        except:
-            mass_1_source, mass_2_source = self.source_binary_masses(
-                size=nsamples)
+        if self.mass_constant:
+            if type(self.mass_constant)==list:
+                mass_1_source = self.mass_constant[0]*np.ones(nsamples)
+                mass_2_source = self.mass_constant[1]*np.ones(nsamples)
+            elif type(self.mass_constant)==float or type(self.mass_constant)==int:
+                mass_1_source = self.mass_constant*np.ones(nsamples)
+                mass_2_source = self.mass_constant*np.ones(nsamples)
+            else:
+                # warning
+                print("Error: mass_constant should be a float/list or false")
         else:
-            mass_1 = kwargs["mass_1"]
-            warning(mass_1)
-            mass_2 = kwargs["mass_2"]
-            warning(mass_1)
-            mass_1_source, mass_2_source = self.source_binary_masses(
-                size=nsamples)
+            try:
+                kwargs["mass_1"]
+                kwargs["mass_2"]
+            except:
+                mass_1_source, mass_2_source = self.source_binary_masses(
+                    size=nsamples)
+            else:
+                mass_1 = kwargs["mass_1"]
+                warning(mass_1)
+                mass_2 = kwargs["mass_2"]
+                warning(mass_1)
+                mass_1_source, mass_2_source = self.source_binary_masses(
+                    size=nsamples)
 
         # Sample all other parameters
         # use bilby priors
@@ -695,18 +719,25 @@ class CompactBinaryPopulation(SourceGalaxyPopulationModel):
         theta_jn = prior_default["theta_jn"].sample(nsamples)
         phase = prior_default["phase"].sample(nsamples)
         # sampling spin parameters
-        if self.spin_zero:
+        if self.spin_constant==0. or self.spin_constant==True:
             a_1 = np.zeros(nsamples)
             a_2 = np.zeros(nsamples)
             tilt_1 = np.zeros(nsamples)
             tilt_2 = np.zeros(nsamples)
             phi_12 = np.zeros(nsamples)
             phi_jl = np.zeros(nsamples)
+        elif type(self.spin_constant)==list:
+            a_1 = self.spin_constant[0]*np.ones(nsamples)
+            a_2 = self.spin_constant[1]*np.ones(nsamples)
+            tilt_1 = self.spin_constant[2]*np.ones(nsamples)
+            tilt_2 = self.spin_constant[3]*np.ones(nsamples)
+            phi_12 = self.spin_constant[4]*np.ones(nsamples)
+            phi_jl = self.spin_constant[5]*np.ones(nsamples)
         else:
             a_1, a_2, tilt_1, tilt_2, phi_12, phi_jl = self.binary_spin(nsamples)
 
         # compute GPS time
-        geocent_time = randint.rvs(1238166018, 1238166018 + 15811200, size=nsamples)
+        geocent_time = randint.rvs(1238166018, 1238166018 + 31536000, size=nsamples)
         mass_1, mass_2 = mass_1_source * (1 + zs), mass_2_source * (1 + zs)
 
         gw_parameters = {
@@ -732,7 +763,7 @@ class CompactBinaryPopulation(SourceGalaxyPopulationModel):
 
         return gw_parameters
 
-    def binary_masses_popI_II(self, size, alpha=3.63, beta=1.26, delta_m=4.82, mmin=4.59, mmax=86.22, lambda_peak=0.08, mu_g=33.07, sigma_g=5.69):
+    def binary_masses_BBH_popI_II_gwcosmo(self, size, alpha=3.63, beta=1.26, delta_m=4.82, mmin=4.59, mmax=86.22, lambda_peak=0.08, mu_g=33.07, sigma_g=5.69):
         """
         Function to calculate source mass1 and mass2 with PowerLaw+PEAK model
 
@@ -767,6 +798,11 @@ class CompactBinaryPopulation(SourceGalaxyPopulationModel):
                 if key in keys_:
                     param[key] = value
 
+        if self.m_min is not None:
+            param["mmin"] = self.m_min
+        if self.m_max is not None:
+            param["mmax"] = self.m_max
+
         model = p.mass_prior("BBH-powerlaw-gaussian", param)
         mass_1_source, mass_2_source = model.sample(Nsample=size)
         while np.any(mass_2_source > mass_1_source):
@@ -774,7 +810,7 @@ class CompactBinaryPopulation(SourceGalaxyPopulationModel):
 
         return (mass_1_source, mass_2_source)
 
-    def binary_masses_popIII(self, size, Mc=30.0, sigma=0.3, beta=1.1):
+    def binary_masses_BBH_popIII_gwcosmo(self, size, Mc=30.0, sigma=0.3, beta=1.1):
         """
         Function to calculate source mass1 and mass2 with pop III origin
 
@@ -800,8 +836,15 @@ class CompactBinaryPopulation(SourceGalaxyPopulationModel):
         >>> mass_1_source, mass_2_source = pop.binary_masses_popIII(size=1000)
 
         """
-        m_min = self.m_min
-        m_max = self.m_max
+        if self.m_min is not None:
+            m_min = self.m_min
+        else:
+            m_min = 4.59
+        if self.m_max is not None:
+            m_max = self.m_max
+        else:
+            m_max = 86.22
+
         # replace values with self.src_model_params, if given
         param = dict(Mc=Mc, sigma=sigma, beta=beta)
         if self.src_model_params is not None:
@@ -824,7 +867,7 @@ class CompactBinaryPopulation(SourceGalaxyPopulationModel):
         
         return (mass_1_source, mass_2_source)
 
-    def binary_masses_primordial(self, size, Mc=30.0, sigma=0.3, beta=1.1):
+    def binary_masses_BBH_primordial_lognormal(self, size, Mc=30.0, sigma=0.3, beta=1.1):
         """
         Function to calculate source mass1 and mass2 for primordial BBHs
 
@@ -850,8 +893,15 @@ class CompactBinaryPopulation(SourceGalaxyPopulationModel):
         >>> mass_1_source, mass_2_source = pop.binary_masses_primordial(size=1000)
 
         """
-        m_min = self.m_min
-        m_max = self.m_max
+        if self.m_min is not None:
+            m_min = self.m_min
+        else:
+            m_min = 4.59
+        if self.m_max is not None:
+            m_max = self.m_max
+        else:
+            m_max = 86.22
+
         # replace values with self.src_model_params, if given
         param = dict(Mc=Mc, sigma=sigma, beta=beta)
         if self.src_model_params is not None:
@@ -874,17 +924,23 @@ class CompactBinaryPopulation(SourceGalaxyPopulationModel):
         
         return (mass_1_source, mass_2_source)
 
-    def binary_masses_BNS(self, size, muL=1.35, sigmaL=0.08, muR=1.8, sigmaR=0.3):
+    def binary_masses_BNS_popI_II_gwcosmo(self, size, mminns=1.0, mmaxns=3.0, alphans=0.0):
         """
-        Function to calculate source mass1 and mass2 of BNS
+        Function to calculate source mass1 and mass2 of BNS (gwcosmo)
 
         Parameters
         ----------
         size : `int`
             Number of samples to draw
-        muL, sigmaL, muR, sigmaR : `float`
-            Fitting parameters
-            default: muL=1.35, sigmaL=0.08, muR=1.8, sigmaR=0.3
+        mminns : `float`
+            Minimum mass of the BNS
+            default: 1.0
+        mmaxns : `float`
+            Maximum mass of the BNS
+            default: 3.0
+        alphans : `float`
+            Power law index
+            default: 0.0
 
         Returns
         ----------
@@ -892,29 +948,82 @@ class CompactBinaryPopulation(SourceGalaxyPopulationModel):
             Array of mass1 in source frame
         mass_2_source : `array`
             Array of mass2 in source frame
-
-        Examples
-        ----------
-        >>> from ler import CompactBinaryPopulation
-        >>> pop = CompactBinaryPopulation(z_min=0.0001, z_max=10, m_min=1.0, m_max=3.0, event_type = "BNS")
-        >>> mass_1_source, mass_2_source = pop.binary_masses_BNS(size=1000)
-
         """
+
         # replace values with self.src_model_params, if given
-        param = dict(muL=muL, sigmaL=sigmaL, muR=muR, sigmaR=sigmaR)
+        param = dict(mminns=1.0, mmaxns=3.0, alphans=0.0)
         if self.src_model_params is not None:
             keys_ = param.keys()
             for key, value in self.src_model_params.items():
                 if key in keys_:
                     param[key] = value
-    
-        model = p.mass_prior("BNS", None)
+
+        if self.m_min is not None:
+            param["mminns"] = self.m_min
+        if self.m_max is not None:
+            param["mmaxns"] = self.m_max
+
+        model = p.mass_prior("BNS", param)
         mass_1_source, mass_2_source = model.sample(Nsample=size)
         while np.any(mass_2_source > mass_1_source):
             mass_1_source, mass_2_source = model.sample(Nsample=size)
 
         return (mass_1_source, mass_2_source)
+    
+    def binary_masses_BNS_popI_II_Alsing(self, size, w=0.643, muL=1.352, sigmaL=0.08, muR=1.88, sigmaR=0.3, mmin=1., mmax=2.3):
+        """
+        Function to calculate source mass1 and mass2 of BNS (Alsing)
 
+        Parameters
+        ----------
+        size : `int`
+            Number of samples to draw
+        w, muL, sigmaL, muR, sigmaR : `float`
+            Fitting parameters
+            default: w=0.643, muL=1.352, sigmaL=0.08, muR=1.88, sigmaR=0.3
+        mmin : `float`
+            Minimum mass of the BNS
+            default: 1.0
+        mmax : `float`
+            Maximum mass of the BNS
+            default: 3.0
+
+        Returns
+        ----------
+        mass_1_source : `array`
+            Array of mass1 in source frame
+        mass_2_source : `array`
+            Array of mass2 in source frame
+        """
+        # print("\n BNS alsing \n")
+        # replace values with self.src_model_params, if given
+        param = dict(w=0.643, muL=1.352, sigmaL=0.08, muR=1.88, sigmaR=0.3, mmin=1., mmax=2.3)
+        if self.src_model_params is not None:
+            keys_ = param.keys()
+            for key, value in self.src_model_params.items():
+                if key in keys_:
+                    param[key] = value
+
+        if self.m_min is not None:
+            param["mmin"] = self.m_min
+        if self.m_max is not None:
+            param["mmax"] = self.m_max
+
+        pdf_unnormL = lambda m: np.exp(-(m-muL)**2 / (2*sigmaL**2))  
+        normL = quad(pdf_unnormL, mmin, mmax)[0]
+        pdf_unnormR = lambda m: np.exp(-(m-muR)**2 / (2*sigmaR**2))  
+        normR = quad(pdf_unnormR, mmin, mmax)[0]
+
+        pdf = lambda m: w*pdf_unnormL(m) / normL + (1-w)*pdf_unnormR(m) / normR
+
+        mass_1_source = rejection_sample(pdf, mmin, mmax, size=size)
+        mass_2_source = rejection_sample(pdf, mmin, mmax, size=size)
+        # swap mass_1_source and mass_2_source if mass_2_source > mass_1_source
+        idx = mass_2_source>mass_1_source
+        mass_1_source[idx], mass_2_source[idx] = mass_2_source[idx], mass_1_source[idx] 
+
+        return(mass_1_source, mass_2_source)
+        
     def mass_ratio(self, size, beta=1.1):
         """
         Function to calculate mass ratio with power law distribution
@@ -942,7 +1051,7 @@ class CompactBinaryPopulation(SourceGalaxyPopulationModel):
         q = rejection_sample(pdf, 0, 1, size=size)
         return q
     
-    def binary_spin_popI_II(self, size):
+    def binary_spin_BBH(self, size):
         """
         Function to calculate spin parameters with PowerLaw+PEAK model
 
@@ -970,7 +1079,7 @@ class CompactBinaryPopulation(SourceGalaxyPopulationModel):
         ----------
         >>> from ler import CompactBinaryPopulation
         >>> pop = CompactBinaryPopulation(z_min=0.0001, z_max=10, m_min=4.59, m_max=86.22, event_type = "popI_II")
-        >>> a_1, a_2, tilt_1, tilt_2, phi_12, phi_jl = pop.binary_spin_popI_II(size=1000)
+        >>> a_1, a_2, tilt_1, tilt_2, phi_12, phi_jl = pop.binary_spin_BBH(size=1000)
 
         """
         bilby.core.utils.logger.disabled = True

{ler-0.2.7 → ler-0.2.9}/ler.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ler
-Version: 0.2.7
+Version: 0.2.9
 Summary: Gravitational waves Lensing Rates
 Home-page: https://github.com/hemantaph/ler
 Author: Hemantakumar
@@ -9,17 +9,28 @@ License: MIT
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: setuptools>=65.5.0
+Requires-Dist: numpy>=1.18
+Requires-Dist: numba>=0.57.1
+Requires-Dist: bilby>=1.0.2
+Requires-Dist: gwsnr>=0.1
+Requires-Dist: scipy>=1.9.0
+Requires-Dist: lenstronomy>=1.10.4
+Requires-Dist: astropy>=5.1
+Requires-Dist: tqdm>=4.64.1
+Requires-Dist: pointpats>=2.3
+Requires-Dist: shapely>=2.0.1
 
 # LeR
 [![DOI](https://zenodo.org/badge/626733473.svg)](https://zenodo.org/badge/latestdoi/626733473) [![PyPI version](https://badge.fury.io/py/ler.svg)](https://badge.fury.io/py/ler) [![DOCS](https://readthedocs.org/projects/ler/badge/?version=latest)](https://ler.readthedocs.io/en/latest/)
 
-`LeR` is a statistical-based python package whose core function is designed for the computation of detectable rates pertaining to both lensed and unlensed gravitational wave (GW) events. This calculation intricately hinges upon the interplay of various components within the package, which can be categorized into three primary segments: 1. Sampling the properties of compact-binary sources, 2. Sampling characteristics of lens galaxies, and 3. Solving the lens equation to derive image attributes of the source. The holistic functionality of the package is built upon leveraging array operations and linear algebra from the numpy library, interpolation from scipy, and the `multiprocessing` capability inherent to Python. This design optimizes both speed and functionality while upholding user-friendliness. The architecture of the "LeR" API is deliberately organized such that each distinct functionality holds its own significance in scientific research. Simultaneously, these functionalities seamlessly integrate and can be employed collectively based on specific research requirements. Key features of `LeR` and its dependencies can be summarized as follows,
+`LeR` is a statistical-based python package whose core function is designed for the computation of detectable rates pertaining to both lensed and unlensed gravitational wave (GW) events. This calculation intricately hinges upon the interplay of various components within the package, which can be categorized into three primary segments: 1. Sampling the properties of compact-binary sources, 2. Sampling characteristics of lens galaxies, and 3. Solving the lens equation to derive image attributes of the source. The holistic functionality of the package is built upon leveraging array operations and linear algebra from the `numpy` library, interpolation from `scipy`, and the `multiprocessing` capability inherent to Python. This design optimizes both speed and functionality while upholding user-friendliness. The architecture of the "LeR" API is deliberately organized such that each distinct functionality holds its own significance in scientific research. Simultaneously, these functionalities seamlessly integrate and can be employed collectively based on specific research requirements. Key features of `LeR` and its dependencies can be summarized as follows,
 
 - Detectable merger rates: 
     * The calculation depends not only on simulated event properties but also on GW detector detectability. We compute optimal signal-to-noise ratios (SNRs) for simulated events, which can be computationally intensive. `LeR` mitigates this using [`gwsnr`](https://github.com/hemantaph/gwsnr) for efficient  and rapid SNR calculation. `gwsnr` enables rate calculation for current and future detectors with customizable sensitivities.
     * The merger rates of both the simulated unlensed and lensed events can be computed and subsequently compared. 
 - Sampling GW sources:
-    * The distribution of the source's red-shift is based on the merger rate density of compact binaries, including binary black hole (BBH), binary neutron star (BNS) etc. The code is meticulously structured to facilitate straightforward incorporation of future updates or additional distributions of such sources by users.
+    * The distribution of the source's red-shift is based on the merger rate density of compact binaries, including BBHs, BNSs etc. The code is meticulously structured to facilitate straightforward incorporation of future updates or additional distributions of such sources by users.
     * The sampling of intrinsic and extrinsic parameters of gravitational wave sources is conducted employing the prior distributions encompassed within the `gwcosmo` and `bilby` Python packages. Prior to parameterizing the rate calculation, users retain the flexibility to manually substitute any relevant parameters as needed.
 - Sampling of lens galaxies:
     * The Lens distribution follows [(Oguri et al. 2018](https://arxiv.org/abs/1807.02584). It depends on the sampled source red-shifts and also on the optical depth.

{ler-0.2.7 → ler-0.2.9}/ler.egg-info/requires.txt

@@ -1,4 +1,4 @@
-setuptools>=67.8.0
+setuptools>=65.5.0
 numpy>=1.18
 numba>=0.57.1
 bilby>=1.0.2

{ler-0.2.7 → ler-0.2.9}/setup.py

@@ -13,7 +13,7 @@ if python_version < (3, 10):
 
 setup(
     name="ler",
-    version="0.2.7",
+    version="0.2.9",
     description="Gravitational waves Lensing Rates",
     long_description=long_description,
     long_description_content_type='text/markdown',
@@ -24,7 +24,7 @@ setup(
     packages=find_packages(),
     python_requires='>=3.10',
     install_requires=[
-        "setuptools>=67.8.0",
+        "setuptools>=65.5.0",
         "numpy>=1.18",
         "numba>=0.57.1",
         "bilby>=1.0.2",
@@ -35,6 +35,6 @@ setup(
         "tqdm>=4.64.1",
         "pointpats>=2.3",
         "shapely>=2.0.1",
-        #"gwcosmo @ git+https://git.ligo.org/lscsoft/gwcosmo.git@v1.0.0",
+        #"gwcosmo@git+https://git.ligo.org/lscsoft/gwcosmo.git@v1.0.0",
     ],
 )