ler 0.3.6__py3-none-any.whl → 0.3.8__py3-none-any.whl

ler/__init__.py

@@ -14,7 +14,7 @@ except RuntimeError:
 __author__ = 'hemanta_ph <hemantaphurailatpam@gmail.com>'
 
 # The version as used in the setup.py
-__version__ = "0.3.6"
+__version__ = "0.3.8"
 
 # add __file__
 import os

ler/gw_source_population/cbc_source_parameter_distribution.py

@@ -827,6 +827,55 @@ class CBCSourceParameterDistribution(CBCSourceRedshiftDistribution):
             mass_1_source, mass_2_source = model.sample(Nsample=size)
 
             return (mass_1_source, mass_2_source)
+        
+    def binary_masses_uniform(
+        self,
+        size,
+        m_min=1.0,
+        m_max=3.0,
+        get_attribute=False,
+        param=None,
+    ):
+        """
+        Function to sample source mass1 and mass2 from uniform distribution.
+
+        Parameters
+        ----------
+        size : `int`
+            Number of samples to draw
+        m_min : `float`
+            Minimum mass of the BNS
+            default: 1.0
+        m_max : `float`
+            Maximum mass of the BNS
+            default: 3.0
+        get_attribute : `bool`
+            If True, return a sampler function with size as the only input where parameters are fixed to the given values.
+        param : `dict`
+            Allows to pass in above parameters as dict.
+            e.g. param = dict(m_min=1.0, m_max=3.0)
+
+        Returns
+        ----------
+        mass_1_source : `numpy.ndarray` (1D array of floats)
+            Array of mass1 in source frame (Msun)
+        mass_2_source : `numpy.ndarray` (1D array of floats)
+            Array of mass2 in source frame (Msun)
+
+        Examples
+        ----------
+        >>> from ler.gw_source_population import CBCSourceParameterDistribution
+        >>> cbc = CBCSourceParameterDistribution()
+        >>> m1_src, m2_src = cbc.binary_masses_uniform(size=1000)
+        """
+
+        if param:
+            m_min = param["m_min"]
+            m_max = param["m_max"]
+
+        if get_attribute:
+            return njit(lambda size: (np.random.uniform(m_min, m_max, size), np.random.uniform(m_min, m_max, size)))
+        return np.random.uniform(m_min, m_max, size), np.random.uniform(m_min, m_max, size)
 
     def binary_masses_BNS_bimodal(
         self,
@@ -918,13 +967,13 @@ class CBCSourceParameterDistribution(CBCSourceRedshiftDistribution):
         # find inverse cdf
         inv_cdf = interpolator_from_pickle(
             param_dict_given=dict(
-                w=0.643,
-                muL=1.352,
-                sigmaL=0.08,
-                muR=1.88,
-                sigmaR=0.3,
-                mmin=1.0,
-                mmax=2.3,
+                w=w,
+                muL=muL,
+                sigmaL=sigmaL,
+                muR=muR,
+                sigmaR=sigmaR,
+                mmin=mmin,
+                mmax=mmax,
                 resolution=500,
             ),
             directory=self.directory,

ler/gw_source_population/cbc_source_redshift_distribution.py

@@ -53,7 +53,7 @@ class CBCSourceRedshiftDistribution(object):
         default: './interpolator_pickle'
     create_new_interpolator : `dict`
         Dictionary of interpolator creation parameters
-        default: None/dict(redshift_distribution=dict(create_new=False, resolution=500), z_to_luminosity_distance=dict(create_new=False, resolution=500), differential_comoving_volume=dict(create_new=False, resolution=500))
+        default: None/dict(redshift_distribution=dict(create_new=False, resolution=1000), z_to_luminosity_distance=dict(create_new=False, resolution=1000), differential_comoving_volume=dict(create_new=False, resolution=1000))
 
     Examples
     ----------
@@ -86,7 +86,7 @@ class CBCSourceRedshiftDistribution(object):
     |                                     | and its parameters               |
     +-------------------------------------+----------------------------------+
     |:attr:`~sample_source_redshift`      | Function to sample source        |
-    |                                     | redshifts (source frame)         |
+    |                                     | redshifts                        |
     +-------------------------------------+----------------------------------+
 
     Instance Methods
@@ -104,10 +104,10 @@ class CBCSourceRedshiftDistribution(object):
     |:meth:`~pdf_z`                       | Function to compute the pdf      |
     |                                     | p(z)                             |
     +-------------------------------------+----------------------------------+
-    |:meth:`~merger_rate_density_src_frame`                                  |
+    |:meth:`~merger_rate_density_detector_frame`                                  |
     +-------------------------------------+----------------------------------+
     |                                     | Function to compute the merger   |
-    |                                     | rate density (source frame)      |
+    |                                     | rate density (detector frame)    |
     +-------------------------------------+----------------------------------+
     |:meth:`~create_lookup_table`         | Function to create a lookup      |
     |                                     | table for the differential       |
@@ -170,7 +170,7 @@ class CBCSourceRedshiftDistribution(object):
     c_n_i = None
     """``dict`` \n
     c_n_i stands for 'create new interpolator'. Dictionary of interpolator creation parameters. \n
-    e.g. dict(redshift_distribution=dict(create_new=False, resolution=500), z_to_luminosity_distance=dict(create_new=False, resolution=500), differential_comoving_volume=dict(create_new=False, resolution=500))
+    e.g. dict(redshift_distribution=dict(create_new=False, resolution=1000), z_to_luminosity_distance=dict(create_new=False, resolution=1000), differential_comoving_volume=dict(create_new=False, resolution=1000))
     """
 
     normalization_pdf_z = None
@@ -207,7 +207,7 @@ class CBCSourceRedshiftDistribution(object):
         self.cosmo = cosmology if cosmology else LambdaCDM(H0=70, Om0=0.3, Ode0=0.7)
         # setting up the interpolator creation parameters
         self.c_n_i = dict(
-            redshift_distribution=dict(create_new=False, resolution=500), z_to_luminosity_distance=dict(create_new=False, resolution=500), differential_comoving_volume=dict(create_new=False, resolution=500))
+            redshift_distribution=dict(create_new=False, resolution=1000), z_to_luminosity_distance=dict(create_new=False, resolution=1000), differential_comoving_volume=dict(create_new=False, resolution=1000))
         if create_new_interpolator:
             self.c_n_i.update(create_new_interpolator)
         # creating of interpolators for redshift dependent quantities
@@ -219,21 +219,23 @@ class CBCSourceRedshiftDistribution(object):
         # if None is passed, use the default merger_rate_density_param
         if merger_rate_density_param is None and merger_rate_density== "merger_rate_density_bbh_popI_II_oguri2018":
             if self.event_type == "BBH":
-                R0 = 25 * 1e-9
+                R0 = 23.9 * 1e-9
             elif self.event_type == "BNS":
-                R0 = 170.0 * 1e-9
+                R0 = 105.5 * 1e-9
             elif self.event_type == "NSBH":
-                R0 = 27.0 * 1e-9
+                R0 = 45.0 * 1e-9
             else:
                 raise ValueError("event_type must be one of 'BBH', 'BNS', 'NSBH'")
-            self.merger_rate_density_param = dict(R0=R0, b2=1.6, b3=2.0, b4=30)
+            merger_rate_density_param = dict(R0=R0, b2=1.6, b3=2.0, b4=30)
+        self.merger_rate_density_param = merger_rate_density_param
+
 
         # To find the normalization constant of the pdf p(z)
-        # merger_rate_density_src_frame is njit function and takes array as input but quad integrand function takes only float as input
-        merger_rate_density_src_frame = lambda z: self.merger_rate_density_src_frame(np.array([z]))[0]
+        # merger_rate_density_detector_frame is njit function and takes array as input but quad integrand function takes only float as input
+        merger_rate_density_detector_frame = lambda z: self.merger_rate_density_detector_frame(zs=np.array([z]), param=merger_rate_density_param)[0]
         # this normalization is important to find the correct pdf p(z)
         self.normalization_pdf_z = quad(
-            merger_rate_density_src_frame,
+            merger_rate_density_detector_frame,
             z_min,
             z_max
         )[0]
@@ -242,18 +244,24 @@ class CBCSourceRedshiftDistribution(object):
         # create sampler using the pdf p(z)
         resolution = self.c_n_i["redshift_distribution"]["resolution"]
         create_new = self.c_n_i["redshift_distribution"]["create_new"]
+
+        # if callable(merger_rate_density):
+        #     merger_rate_density_name = merger_rate_density.__name__
+        # else:
+        #     merger_rate_density_name = merger_rate_density
+
         zs_inv_cdf = interpolator_from_pickle(
-                param_dict_given= dict(z_min=z_min, 
-                                       z_max=z_max, 
+                param_dict_given= dict(z_min=z_min,
+                                       z_max=z_max,
                                        cosmology=self.cosmo,
                                        event_type=event_type,
-                                       merger_rate_density=merger_rate_density,
-                                        merger_rate_density_param=merger_rate_density_param,
+                                       merger_rate_density=str(merger_rate_density),
+                                        merger_rate_density_param=str(merger_rate_density_param),
                                         resolution=resolution,
                                         ),
                 directory=directory,
-                sub_directory=merger_rate_density,
-                name=merger_rate_density,
+                sub_directory="merger_rate_density",
+                name="merger_rate_density",
                 x = np.linspace(z_min, z_max, resolution),
                 pdf_func= lambda z_: self.pdf_z(zs=z_, param=merger_rate_density_param),
                 conditioned_y=None,
@@ -267,7 +275,7 @@ class CBCSourceRedshiftDistribution(object):
 
     def pdf_z(self, zs, param=None):
         """
-        Function to compute the pdf p(z). The output is in source frame and is normalized.
+        Function to compute the pdf p(z). The output is in detector frame and is normalized.
 
         Parameters
         ----------
@@ -291,11 +299,11 @@ class CBCSourceRedshiftDistribution(object):
         >>> pdf = cbc.pdf_z(zs=0.1)
         """
 
-        return self.merger_rate_density_src_frame(zs=zs,param=param)/self.normalization_pdf_z
+        return self.merger_rate_density_detector_frame(zs=zs,param=param)/self.normalization_pdf_z
 
-    def merger_rate_density_src_frame(self, zs, param=None):
+    def merger_rate_density_detector_frame(self, zs, param=None):
         """
-        Function to compute the merger rate density (source frame). The output is in source frame and is unnormalized.
+        Function to compute the merger rate density (detector frame). The output is in detector frame and is unnormalized.
 
         Parameters
         ----------
@@ -310,13 +318,13 @@ class CBCSourceRedshiftDistribution(object):
         ----------
         rate_density : `numpy.ndarray`
             1D array of floats
-            merger rate density (source frame) (Mpc^-3 yr^-1)
+            merger rate density (detector frame) (Mpc^-3 yr^-1)
 
         Examples
         ----------
         >>> from ler.gw_source_population import SourceGalaxyPopulationModel
         >>> cbc = SourceGalaxyPopulationModel()
-        >>> rate_density = cbc.merger_rate_density_src_frame(zs=0.1)
+        >>> rate_density = cbc.merger_rate_density_detector_frame(zs=0.1)
         """
 
         zs = np.array([zs]).reshape(-1)
@@ -333,7 +341,7 @@ class CBCSourceRedshiftDistribution(object):
         zs, R0=23.9 * 1e-9, b2=1.6, b3=2.0, b4=30, param=None
     ):
         """
-        Function to compute the merger rate density (PopI/PopII). Reference: Oguri et al. (2018). The output is in detector frame and is unnormalized.
+        Function to compute the merger rate density (PopI/PopII). Reference: Oguri et al. (2018). The output is in source frame and is unnormalized.
 
         Parameters
         ----------
@@ -374,6 +382,7 @@ class CBCSourceRedshiftDistribution(object):
             b3 = param["b3"]
             b4 = param["b4"]
 
+        #print(f"\nR0: {R0}\n")
         return merger_rate_density_bbh_popI_II_oguri2018(zs=zs, R0=R0, b2=b2, b3=b3, b4=b4)
     
     def star_formation_rate_madau_dickinson2014(self,
@@ -595,7 +604,7 @@ class CBCSourceRedshiftDistribution(object):
     @property
     def sample_source_redshift(self):
         """
-        Function to sample source redshifts (source frame) between z_min and z_max from the source galaxy population
+        Function to sample source redshifts (detector frame) between z_min and z_max from the detector galaxy population
 
         Parameters
         ----------
@@ -641,7 +650,7 @@ class CBCSourceRedshiftDistribution(object):
     
     @merger_rate_density.setter
     def merger_rate_density(self, merger_rate_density):
-        error_msg = ValueError(f"merger_rate_density must be one of {self.merger_rate_density_model_list}")
+        # error_msg = ValueError(f"merger_rate_density must be one of {self.merger_rate_density_model_list}")
         # check if it is a string
         if isinstance(merger_rate_density, str):
             try:

ler/gw_source_population/jit_functions.py

@@ -143,7 +143,7 @@ def star_formation_rate_madau_dickinson2014(
     return 0.015 * (1 + zs) ** af / (1 + ((1 + zs) / cf) ** bf)
 
 
-@jit
+# @jit
 def merger_rate_density_bbh_primordial_ken2022(
         zs, cosmology=cosmo, n0=0.044 * 1e-9, t0=13.786885302009708
     ):

ler/image_properties/image_properties.py

@@ -67,7 +67,7 @@ class ImageProperties():
         default: "./interpolator_pickle"
     create_new_interpolator : `dict`
         dictionary to create new interpolator pickle files
-        default: dict(Dl_to_z=dict(create_new=False, resolution=500))
+        default: dict(Dl_to_z=dict(create_new=False, resolution=1000))
 
     Examples
     --------
@@ -140,13 +140,13 @@ class ImageProperties():
         
         # initialize the interpolator's parameters
         self.create_new_interpolator = dict(
-            Dl_to_z=dict(create_new=False, resolution=500),
+            Dl_to_z=dict(create_new=False, resolution=1000),
         )
         if isinstance(create_new_interpolator, dict):
             self.create_new_interpolator.update(create_new_interpolator)
         elif create_new_interpolator is True:
             self.create_new_interpolator = dict(
-                Dl_to_z=dict(create_new=True, resolution=500)
+                Dl_to_z=dict(create_new=True, resolution=1000)
             )
 
         resolution = self.create_new_interpolator["Dl_to_z"]["resolution"]
@@ -375,15 +375,13 @@ class ImageProperties():
 
         # Get the binary parameters
         number_of_lensed_events = len(magnifications)
-        mass_1, mass_2, luminosity_distance, theta_jn, psi, ra, dec, geocent_time, phase, a_1, a_2, tilt_1, tilt_2, phi_12, phi_jl  = (
+        mass_1, mass_2, theta_jn, psi, ra, dec, phase, a_1, a_2, tilt_1, tilt_2, phi_12, phi_jl  = (
             lensed_param["mass_1"],
             lensed_param["mass_2"],
-            lensed_param["luminosity_distance"],
             lensed_param["theta_jn"],
             lensed_param["psi"],
             lensed_param["ra"],
             lensed_param["dec"],
-            lensed_param["geocent_time"],
             lensed_param["phase"],
             np.zeros(size),
             np.zeros(size),
@@ -423,24 +421,45 @@ class ImageProperties():
                     np.ones((number_of_lensed_events, n_max_images)) * np.nan
                 )
         
-        
-
         # for updating the lensed_param
-        lensed_param["effective_luminosity_distance"] = np.ones((number_of_lensed_events, n_max_images)) * np.nan
-        lensed_param["effective_geocent_time"] = np.ones((number_of_lensed_events, n_max_images)) * np.nan
+        if "luminosity_distance" in lensed_param:
+            luminosity_distance = lensed_param["luminosity_distance"]
+            lensed_param["effective_luminosity_distance"] = np.ones((number_of_lensed_events, n_max_images)) * np.nan
+            dl_eff_present = False
+        elif "effective_luminosity_distance" in lensed_param:
+            dl_eff = lensed_param["effective_luminosity_distance"]
+            dl_eff_present = True
+        else:
+            raise ValueError("luminosity_distance or effective_luminosity_distance not given")
+        
+        if "geocent_time" in lensed_param:
+            geocent_time = lensed_param["geocent_time"]
+            lensed_param["effective_geocent_time"] = np.ones((number_of_lensed_events, n_max_images)) * np.nan
+            time_eff_present = False
+        elif "effective_geocent_time" in lensed_param:
+            time_eff = lensed_param["effective_geocent_time"]
+            time_eff_present = True
+        else:
+            raise ValueError("geocent_time or effective_geocent_time not given")
 
         # Get the optimal signal to noise ratios for each image
         # iterate over the image type (column)
         for i in range(n_max_images):
             
             # get the effective time for each image type
-            effective_geocent_time = geocent_time + time_delays[:, i]
+            if not time_eff_present:
+                effective_geocent_time = geocent_time + time_delays[:, i]
+            else:
+                effective_geocent_time = time_eff[:, i]
             # choose only the events that are within the time range and also not nan
             idx = (effective_geocent_time <= self.geocent_time_max) & (effective_geocent_time >= self.geocent_time_min)
             # get the effective luminosity distance for each image type
-            effective_luminosity_distance = luminosity_distance / np.sqrt(
-                np.abs(magnifications[:, i])
-            )
+            if not dl_eff_present:
+                effective_luminosity_distance = luminosity_distance / np.sqrt(
+                    np.abs(magnifications[:, i])
+                )
+            else:
+                effective_luminosity_distance = dl_eff[:, i]
             
             # check for nan values
             idx = idx & ~np.isnan(effective_luminosity_distance) & ~np.isnan(effective_geocent_time)
@@ -473,7 +492,8 @@ class ImageProperties():
 
                     if list_of_detectors:
                         for detector in list_of_detectors:
-                            result_dict[detector][idx, i] = optimal_snr[detector]
+                            if detector in optimal_snr:
+                                result_dict[detector][idx, i] = optimal_snr[detector]
 
                 elif pdet_calculator:
                     pdet = pdet_calculator(
@@ -494,19 +514,21 @@ class ImageProperties():
                             phi_12=phi_12[idx],
                             phi_jl=phi_jl[idx],
                         ),
-                        output_jsonfile=False,
                     )
                     result_dict["pdet_net"][idx, i] = pdet["pdet_net"]
 
                     if list_of_detectors:
                         for detector in list_of_detectors:
-                            result_dict[detector][idx, i] = pdet[detector]
+                            if detector in pdet:
+                                result_dict[detector][idx, i] = pdet[detector]
                 
 
                 lensed_param["effective_luminosity_distance"][:, i] = effective_luminosity_distance
                 lensed_param["effective_geocent_time"][:, i] = effective_geocent_time
 
-        del lensed_param["luminosity_distance"]
-        del lensed_param["geocent_time"]
+        if dl_eff_present:
+            del lensed_param["effective_luminosity_distance"]
+        if time_eff_present:
+            del lensed_param["effective_geocent_time"]
 
         return result_dict, lensed_param

ler/image_properties/multiprocessing_routine.py

@@ -151,17 +151,32 @@ def solve_lens_equation(lens_parameters):
         # try:
         x_source, y_source = pointpats.random.poisson(caustic_double, size=1)
         # Solve the lens equation
-        (
-            x0_image_position,
-            x1_image_position,
-        ) = lens_eq_solver.image_position_from_source(
-            sourcePos_x=x_source,
-            sourcePos_y=y_source,
-            kwargs_lens=kwargs_lens,
-            solver="analytical",
-            magnification_limit=1.0 / 100.0,
-            arrival_time_sort=True,
-        )
+        try:  # this to catch this error: "ValueError: Signs are not different"
+            (
+                x0_image_position,
+                x1_image_position,
+            ) = lens_eq_solver.image_position_from_source(
+                sourcePos_x=x_source,
+                sourcePos_y=y_source,
+                kwargs_lens=kwargs_lens,
+                solver="analytical",
+                magnification_limit=1.0 / 100.0,
+                arrival_time_sort=True,
+            )
+        except:
+            return (
+                np.nan,
+                np.nan,
+                np.array([np.nan,np.nan]),
+                np.array([np.nan,np.nan]),
+                np.array([np.nan,np.nan]),
+                np.array([np.nan,np.nan]),
+                0,
+                np.array([np.nan,np.nan]),
+                np.array([np.nan,np.nan]),
+                iteration,
+            )
+
         nImages = len(x0_image_position)  # shows how many images
         if nImages >= n_min_images:
             strongly_lensed = True

ler/lens_galaxy_population/jit_functions.py

@@ -228,6 +228,7 @@ def lens_redshift_SDSS_catalogue(zs, splineDc, splineDcInv, u, cdf):
     splineDcInv: `list`
         List of spline coefficients for the inverse of comoving distance and redshifts
     u: `numpy.ndarray` (1D array of float of size=size)
+        corresponding x values wrt to the cdf values
         e.g. u = np.linspace(0, 1, 500)
     cdf: `numpy.ndarray` (1D array of float of size=size)
         Cumulative distribution function of the lens redshift distribution between 0 and 1

ler/lens_galaxy_population/lens_galaxy_parameter_distribution.py

@@ -233,31 +233,31 @@ class LensGalaxyParameterDistribution(CBCSourceParameterDistribution, ImagePrope
         self.directory = directory
         # initialize the interpolator's parameters
         self.create_new_interpolator = dict(
-            redshift_distribution=dict(create_new=False, resolution=500),
-            z_to_luminosity_distance=dict(create_new=False, resolution=500),
-            velocity_dispersion=dict(create_new=False, resolution=500),
-            axis_ratio=dict(create_new=False, resolution=500),
-            optical_depth=dict(create_new=False, resolution=100),
-            z_to_Dc=dict(create_new=False, resolution=500),
-            Dc_to_z=dict(create_new=False, resolution=500),
-            angular_diameter_distance=dict(create_new=False, resolution=500),
-            differential_comoving_volume=dict(create_new=False, resolution=500),
-            Dl_to_z=dict(create_new=False, resolution=500),
+            redshift_distribution=dict(create_new=False, resolution=1000),
+            z_to_luminosity_distance=dict(create_new=False, resolution=1000),
+            velocity_dispersion=dict(create_new=False, resolution=1000),
+            axis_ratio=dict(create_new=False, resolution=1000),
+            optical_depth=dict(create_new=False, resolution=1000),
+            z_to_Dc=dict(create_new=False, resolution=1000),
+            Dc_to_z=dict(create_new=False, resolution=1000),
+            angular_diameter_distance=dict(create_new=False, resolution=1000),
+            differential_comoving_volume=dict(create_new=False, resolution=1000),
+            Dl_to_z=dict(create_new=False, resolution=1000),
         )
         if isinstance(create_new_interpolator, dict):
             self.create_new_interpolator.update(create_new_interpolator)
         elif create_new_interpolator is True:
             self.create_new_interpolator = dict(
-                redshift_distribution=dict(create_new=True, resolution=500),
-                z_to_luminosity_distance=dict(create_new=True, resolution=500),
-                velocity_dispersion=dict(create_new=True, resolution=500),
-                axis_ratio=dict(create_new=True, resolution=500),
-                optical_depth=dict(create_new=True, resolution=100),
-                z_to_Dc=dict(create_new=True, resolution=500),
-                Dc_to_z=dict(create_new=True, resolution=500),
-                angular_diameter_distance=dict(create_new=True, resolution=500),
-                differential_comoving_volume=dict(create_new=True, resolution=500),
-                Dl_to_z=dict(create_new=True, resolution=500),
+                redshift_distribution=dict(create_new=True, resolution=1000),
+                z_to_luminosity_distance=dict(create_new=True, resolution=1000),
+                velocity_dispersion=dict(create_new=True, resolution=1000),
+                axis_ratio=dict(create_new=True, resolution=1000),
+                optical_depth=dict(create_new=True, resolution=1000),
+                z_to_Dc=dict(create_new=True, resolution=1000),
+                Dc_to_z=dict(create_new=True, resolution=1000),
+                angular_diameter_distance=dict(create_new=True, resolution=1000),
+                differential_comoving_volume=dict(create_new=True, resolution=1000),
+                Dl_to_z=dict(create_new=True, resolution=1000),
             )
 
         # dealing with prior functions and categorization
@@ -294,7 +294,7 @@ class LensGalaxyParameterDistribution(CBCSourceParameterDistribution, ImagePrope
         # To find the normalization constant of the pdf p(z)
         # this under the assumption that the event is strongly lensed
         # Define the merger-rate density function
-        pdf_unnormalized_ = lambda z: self.merger_rate_density_src_frame(np.array([z])) * self.strong_lensing_optical_depth(np.array([z]))
+        pdf_unnormalized_ = lambda z: self.merger_rate_density_detector_frame(np.array([z]), param=self.merger_rate_density_param) * self.strong_lensing_optical_depth(np.array([z]))
         pdf_unnormalized = lambda z: pdf_unnormalized_(z)[0]
 
         self.normalization_pdf_z_lensed = quad(
@@ -601,7 +601,7 @@ class LensGalaxyParameterDistribution(CBCSourceParameterDistribution, ImagePrope
                 size=size)
 
             # sample gravitional waves source parameter
-            param = dict(zs=np.array(zs))
+            param = dict(zs=lens_parameters["zs"])
             if samplers_params["source_parameters"]:
                 param.update(self.sample_gw_parameters(size=size))
             gw_param = self.sample_source_parameters(size=size, param=param)
@@ -1173,7 +1173,7 @@ class LensGalaxyParameterDistribution(CBCSourceParameterDistribution, ImagePrope
         """
 
         self._available_lens_functions = dict(
-            strong_lensing_condition=["rjs_with_cross_section_SIE", "rjs_with_cross_section_SIE"],
+            strong_lensing_condition=["rjs_with_cross_section_SIE", "rjs_with_cross_section_SIS"],
             optical_depth=["SIS", "optical_depth_SIS_haris","optical_depth_SIS_hemanta", "SIE", "optical_depth_SIE_hemanta"],
             param_sampler_type=["sample_all_routine"],
         )

ler/lens_galaxy_population/optical_depth.py

@@ -186,25 +186,25 @@ class OpticalDepth():
 
         self.directory = directory
         self.c_n_i = dict(
-            velocity_dispersion=dict(create_new=False, resolution=500),
-            axis_ratio=dict(create_new=False, resolution=500),
-            optical_depth=dict(create_new=False, resolution=100),
-            z_to_Dc=dict(create_new=False, resolution=500),
-            Dc_to_z=dict(create_new=False, resolution=500),
-            angular_diameter_distance=dict(create_new=False, resolution=500),
-            differential_comoving_volume=dict(create_new=False, resolution=500),
+            velocity_dispersion=dict(create_new=False, resolution=1000),
+            axis_ratio=dict(create_new=False, resolution=1000),
+            optical_depth=dict(create_new=False, resolution=1000),
+            z_to_Dc=dict(create_new=False, resolution=1000),
+            Dc_to_z=dict(create_new=False, resolution=1000),
+            angular_diameter_distance=dict(create_new=False, resolution=1000),
+            differential_comoving_volume=dict(create_new=False, resolution=1000),
         )
         if isinstance(create_new_interpolator, dict):
             self.c_n_i.update(create_new_interpolator)
         elif create_new_interpolator is True:
             self.c_n_i = dict(
-                velocity_dispersion=dict(create_new=True, resolution=500),
-                axis_ratio=dict(create_new=True, resolution=500),
-                optical_depth=dict(create_new=True, resolution=100),
-                z_to_Dc=dict(create_new=True, resolution=500),
-                Dc_to_z=dict(create_new=True, resolution=500),
-                angular_diameter_distance=dict(create_new=True, resolution=500),
-                differential_comoving_volume=dict(create_new=True, resolution=500),
+                velocity_dispersion=dict(create_new=True, resolution=1000),
+                axis_ratio=dict(create_new=True, resolution=1000),
+                optical_depth=dict(create_new=True, resolution=1000),
+                z_to_Dc=dict(create_new=True, resolution=1000),
+                Dc_to_z=dict(create_new=True, resolution=1000),
+                angular_diameter_distance=dict(create_new=True, resolution=1000),
+                differential_comoving_volume=dict(create_new=True, resolution=1000),
             )
 
         vd_name = self.sampler_priors["velocity_dispersion"]  # velocity dispersion sampler name
@@ -237,8 +237,8 @@ class OpticalDepth():
             self.vd_min = self.sampler_priors_params['velocity_dispersion']['vd_min']
             self.vd_max = self.sampler_priors_params['velocity_dispersion']['vd_max']
         except:
-            self.vd_min = 0.
-            self.vd_max = 600.
+            self.vd_min = 10.
+            self.vd_max = 350.
 
         # generating inverse cdf interpolator for velocity dispersion
         param_dict_given_ = dict(z_min=self.z_min, z_max=self.z_max, vd_min=self.vd_min, vd_max=self.vd_max, cosmology=self.cosmo, name=vd_name, resolution=self.c_n_i["velocity_dispersion"]["resolution"])
@@ -966,7 +966,8 @@ class OpticalDepth():
         Function to list all available axis ratio sampler.
         """
         self._available_axis_ratio_list_and_its_params = dict(
-            axis_ratio_rayleigh=None,
+            axis_ratio_rayleigh=dict(q_min=0.2, q_max=1.0),
+            axis_ratio_padilla_strauss=dict(q_min=0.2, q_max=1.0),
             axis_ratio_SIS=None,
         )
 

ler/rates/gwrates.py

@@ -915,7 +915,10 @@ class GWRATES(CBCSourceParameterDistribution):
             # save meta data
             meta_data = dict(events_total=[events_total], detectable_events=[float(n)], total_rate=[total_rate])
             if os.path.exists(meta_data_path):
-                append_json(file_name=meta_data_path, new_dictionary=meta_data, replace=False)
+                try:
+                    append_json(file_name=meta_data_path, new_dictionary=meta_data, replace=False)
+                except:
+                    append_json(file_name=meta_data_path, new_dictionary=meta_data, replace=True)
             else:
                 append_json(file_name=meta_data_path, new_dictionary=meta_data, replace=True)
                 

ler/rates/ler.py

@@ -300,7 +300,7 @@ class LeR(LensGalaxyParameterDistribution):
         print("npool = ", self.npool)
         print("z_min = ", self.z_min)
         print("z_max = ", self.z_max)
-        print("event_type = ", self.event_type)
+        print(f"event_type = '{self.event_type}'")
         print("size = ", self.size)
         print("batch_size = ", self.batch_size)
         print("cosmology = ", self.cosmo)
@@ -320,7 +320,7 @@ class LeR(LensGalaxyParameterDistribution):
         print("create_new_interpolator=", self.gw_param_sampler_dict["create_new_interpolator"])
 
         print("\n LeR also takes LensGalaxyParameterDistribution params as kwargs, as follows:")
-        print("lens_type = ", self.gw_param_sampler_dict["lens_type"])
+        print(f"lens_type = '{self.gw_param_sampler_dict['lens_type']}'")
         print("lens_functions = ", self.gw_param_sampler_dict["lens_functions"])
         print("lens_priors = ", self.gw_param_sampler_dict["lens_priors"])
         print("lens_priors_params = ", self.gw_param_sampler_dict["lens_priors_params"])
@@ -341,9 +341,9 @@ class LeR(LensGalaxyParameterDistribution):
             print("mtot_resolution = ", self.snr_calculator_dict["mtot_resolution"])
             print("ratio_resolution = ", self.snr_calculator_dict["ratio_resolution"])
             print("sampling_frequency = ", self.snr_calculator_dict["sampling_frequency"])
-            print("waveform_approximant = ", self.snr_calculator_dict["waveform_approximant"])
+            print(f"waveform_approximant = '{self.snr_calculator_dict['waveform_approximant']}'")
             print("minimum_frequency = ", self.snr_calculator_dict["minimum_frequency"])
-            print("snr_type = ", self.snr_calculator_dict["snr_type"])
+            print(f"snr_type = '{self.snr_calculator_dict['snr_type']}'")
             print("psds = ", self.snr_calculator_dict["psds"])
             print("ifos = ", self.snr_calculator_dict["ifos"])
             print("interpolator_dir = ", self.snr_calculator_dict["interpolator_dir"])
@@ -354,54 +354,54 @@ class LeR(LensGalaxyParameterDistribution):
         del self.gwsnr
 
         print("\n For reference, the chosen source parameters are listed below:")
-        print("merger_rate_density = ", self.gw_param_samplers["merger_rate_density"])
+        print(f"merger_rate_density = '{self.gw_param_samplers['merger_rate_density']}'")
         print("merger_rate_density_params = ", self.gw_param_samplers_params["merger_rate_density"])
-        print("source_frame_masses = ", self.gw_param_samplers["source_frame_masses"])
+        print(f"source_frame_masses = '{self.gw_param_samplers['source_frame_masses']}'")
         print("source_frame_masses_params = ", self.gw_param_samplers_params["source_frame_masses"])
-        print("geocent_time = ", self.gw_param_samplers["geocent_time"])
+        print(f"geocent_time = '{self.gw_param_samplers['geocent_time']}'")
         print("geocent_time_params = ", self.gw_param_samplers_params["geocent_time"])
-        print("ra = ", self.gw_param_samplers["ra"])
+        print(f"ra = '{self.gw_param_samplers['ra']}'")
         print("ra_params = ", self.gw_param_samplers_params["ra"])
-        print("dec = ", self.gw_param_samplers["dec"])
+        print(f"dec = '{self.gw_param_samplers['dec']}'")
         print("dec_params = ", self.gw_param_samplers_params["dec"])
-        print("phase = ", self.gw_param_samplers["phase"])
+        print(f"phase = '{self.gw_param_samplers['phase']}'")
         print("phase_params = ", self.gw_param_samplers_params["phase"])
-        print("psi = ", self.gw_param_samplers["psi"])
+        print(f"psi = '{self.gw_param_samplers['psi']}'")
         print("psi_params = ", self.gw_param_samplers_params["psi"])
-        print("theta_jn = ", self.gw_param_samplers["theta_jn"])
+        print(f"theta_jn = '{self.gw_param_samplers['theta_jn']}'")
         print("theta_jn_params = ", self.gw_param_samplers_params["theta_jn"])
         if self.spin_zero==False:
-            print("a_1 = ", self.gw_param_samplers["a_1"])
+            print(f"a_1 = '{self.gw_param_samplers['a_1']}'")
             print("a_1_params = ", self.gw_param_samplers_params["a_1"])
-            print("a_2 = ", self.gw_param_samplers["a_2"])
+            print(f"a_2 = '{self.gw_param_samplers['a_2']}'")
             print("a_2_params = ", self.gw_param_samplers_params["a_2"])
             if self.spin_precession==True:
-                print("tilt_1 = ", self.gw_param_samplers["tilt_1"])
+                print(f"tilt_1 = '{self.gw_param_samplers['tilt_1']}'")
                 print("tilt_1_params = ", self.gw_param_samplers_params["tilt_1"])
-                print("tilt_2 = ", self.gw_param_samplers["tilt_2"])
+                print(f"tilt_2 = '{self.gw_param_samplers['tilt_2']}'")
                 print("tilt_2_params = ", self.gw_param_samplers_params["tilt_2"])
-                print("phi_12 = ", self.gw_param_samplers["phi_12"])
+                print(f"phi_12 = '{self.gw_param_samplers['phi_12']}'")
                 print("phi_12_params = ", self.gw_param_samplers_params["phi_12"])
-                print("phi_jl = ", self.gw_param_samplers["phi_jl"])
+                print(f"phi_jl = '{self.gw_param_samplers['phi_jl']}'")
                 print("phi_jl_params = ", self.gw_param_samplers_params["phi_jl"])
 
         print("\n For reference, the chosen lens related parameters and functions are listed below:")
-        print("lens_redshift = ", self.lens_param_samplers["lens_redshift"])
+        print(f"lens_redshift = '{self.lens_param_samplers['lens_redshift']}'")
         print("lens_redshift_params = ", self.lens_param_samplers_params["lens_redshift"])
-        print("velocity_dispersion = ", self.lens_param_samplers["velocity_dispersion"])
+        print(f"velocity_dispersion = '{self.lens_param_samplers['velocity_dispersion']}'")
         print("velocity_dispersion_params = ", self.lens_param_samplers_params["velocity_dispersion"])
-        print("axis_ratio = ", self.lens_param_samplers["axis_ratio"])
+        print(f"axis_ratio = '{self.lens_param_samplers['axis_ratio']}'")
         print("axis_ratio_params = ", self.lens_param_samplers_params["axis_ratio"])
-        print("axis_rotation_angle = ", self.lens_param_samplers["axis_rotation_angle"])
+        print(f"axis_rotation_angle = '{self.lens_param_samplers['axis_rotation_angle']}'")
         print("axis_rotation_angle_params = ", self.lens_param_samplers_params["axis_rotation_angle"])
-        print("shear = ", self.lens_param_samplers["shear"])
+        print(f"shear = '{self.lens_param_samplers['shear']}'")
         print("shear_params = ", self.lens_param_samplers_params["shear"])
-        print("mass_density_spectral_index = ", self.lens_param_samplers["mass_density_spectral_index"])
+        print(f"mass_density_spectral_index = '{self.lens_param_samplers['mass_density_spectral_index']}'")
         print("mass_density_spectral_index_params = ", self.lens_param_samplers_params["mass_density_spectral_index"])
         # lens functions
         print("Lens functions:")
-        print("strong_lensing_condition = ", self.lens_functions["strong_lensing_condition"])
-        print("optical_depth = ", self.lens_functions["optical_depth"])
+        print(f"strong_lensing_condition = '{self.lens_functions['strong_lensing_condition']}'")
+        print(f"optical_depth = '{self.lens_functions['optical_depth']}'")
 
     @property
     def snr(self):
@@ -612,7 +612,7 @@ class LeR(LensGalaxyParameterDistribution):
             ifos=None,
             interpolator_dir=self.interpolator_directory,
             create_new_interpolator=False,
-            gwsnr_verbose=True,
+            gwsnr_verbose=False,
             multiprocessing_verbose=True,
             mtot_cut=True,
         )
@@ -756,7 +756,7 @@ class LeR(LensGalaxyParameterDistribution):
             if self.dict_buffer:
                 unlensed_param = self.dict_buffer.copy()
                 # store all params in json file
-                print(f"saving all unlensed_params in {output_path}...")
+                print(f"saving all unlensed_params in {output_path} ")
                 append_json(output_path, unlensed_param, replace=True)
             else:
                 print("unlensed_params already sampled.")
@@ -821,7 +821,7 @@ class LeR(LensGalaxyParameterDistribution):
         output_jsonfile=None,
         detectability_condition="step_function",
         snr_recalculation=False,
-        threshold_snr_recalculation=6.0,
+        snr_threshold_recalculation=5.5,
     ):
         """
         Function to calculate the unlensed rate. This function also stores the parameters of the detectable events in json file.
@@ -842,9 +842,9 @@ class LeR(LensGalaxyParameterDistribution):
             default detectability_condition = 'step_function'.
             other options are 'pdet'.
         snr_recalculation : `bool`
-            if True, the SNR of centain events (snr>threshold_snr_recalculation)will be recalculate with 'inner product'. This is useful when the snr is calculated with 'ann' method.
+            if True, the SNR of centain events (snr>snr_threshold_recalculation)will be recalculate with 'inner product'. This is useful when the snr is calculated with 'ann' method.
             default snr_recalculation = False.
-        threshold_snr_recalculation : `float`
+        snr_threshold_recalculation : `float`
             threshold for recalculation of detection signal to noise ratio.
 
         Returns
@@ -885,7 +885,7 @@ class LeR(LensGalaxyParameterDistribution):
         if snr_recalculation:
             # select only above centain snr threshold
             param = unlensed_param["optimal_snr_net"]
-            idx_detectable = param > threshold_snr_recalculation
+            idx_detectable = param > snr_threshold_recalculation
             # reduce the size of the dict
             for key, value in unlensed_param.items():
                 unlensed_param[key] = value[idx_detectable]
@@ -924,7 +924,7 @@ class LeR(LensGalaxyParameterDistribution):
 
         # store all detectable params in json file
         for key, value in unlensed_param.items():
-            unlensed_param[key] = value[idx_detectable]
+            unlensed_param[key] = np.array(value)[idx_detectable]
 
         # store all detectable params in json file
         if output_jsonfile is None:
@@ -1002,7 +1002,7 @@ class LeR(LensGalaxyParameterDistribution):
             if self.dict_buffer:
                 lensed_param = self.dict_buffer.copy()
                 # store all params in json file
-                print(f"saving all lensed_params in {output_path}...")
+                print(f"saving all lensed_params in {output_path} ")
                 append_json(output_path, lensed_param, replace=True)
             else:
                 print("lensed_params already sampled.")
@@ -1101,7 +1101,7 @@ class LeR(LensGalaxyParameterDistribution):
         nan_to_num=True,
         detectability_condition="step_function",
         snr_recalculation=False,
-        threshold_snr_recalculation=[6.0,6.0],
+        snr_threshold_recalculation=[5.5,5.5],
     ):
         """
         Function to calculate the lensed rate. This function also stores the parameters of the detectable events in json file.
@@ -1128,9 +1128,9 @@ class LeR(LensGalaxyParameterDistribution):
             default detectability_condition = 'step_function'.
             other options are 'pdet'.
         snr_recalculation : `bool`
-            if True, the SNR of centain events (snr>threshold_snr_recalculation)will be recalculate with 'inner product'. This is useful when the snr is calculated with 'ann' method.
+            if True, the SNR of centain events (snr>snr_threshold_recalculation)will be recalculate with 'inner product'. This is useful when the snr is calculated with 'ann' method.
             default snr_recalculation = False.
-        threshold_snr_recalculation : `float`
+        snr_threshold_recalculation : `float`
             threshold for recalculation of detection signal to noise ratio.
 
         Returns
@@ -1158,7 +1158,7 @@ class LeR(LensGalaxyParameterDistribution):
         if type(lensed_param) == str:
             self.json_file_names["lensed_param"] = lensed_param
             path_ = self.ler_directory+"/"+lensed_param
-            print(f"getting lensed_params from json file {path_}...")
+            print(f"getting lensed_params from json file {path_} ")
             lensed_param = get_param_from_json(self.ler_directory+"/"+lensed_param)
         else:
             print("using provided lensed_param dict...")
@@ -1178,11 +1178,14 @@ class LeR(LensGalaxyParameterDistribution):
         # recalculate snr if required
         # this ensures that the snr is recalculated for the detectable events
         # with inner product
+        ############################
+        #       for ANN SNR        #
+        ############################
         if snr_recalculation:
-            # dealing with provided threshold_snr_recalculation
-            threshold_snr_recalculation = np.array([threshold_snr_recalculation]).reshape(-1)
-            idx = np.argsort(-threshold_snr_recalculation)
-            threshold_snr_recalculation = threshold_snr_recalculation[idx]
+            # dealing with provided snr_threshold_recalculation
+            snr_threshold_recalculation = np.array([snr_threshold_recalculation]).reshape(-1)
+            idx = np.argsort(-snr_threshold_recalculation)
+            snr_threshold_recalculation = snr_threshold_recalculation[idx]
             num_img_recalculation = num_img[idx]
 
             # check optimal_snr_net is provided in dict
@@ -1196,9 +1199,9 @@ class LeR(LensGalaxyParameterDistribution):
             j = 0
             idx_max = 0
             snr_hit = np.full(total_events, True)  # boolean array to store the result of the threshold condition
-            for i in range(len(threshold_snr_recalculation)):
+            for i in range(len(snr_threshold_recalculation)):
                 idx_max = idx_max + num_img_recalculation[i]
-                snr_hit = snr_hit & (np.sum((snr_param[:,j:idx_max] > threshold_snr_recalculation[i]), axis=1) >= num_img_recalculation[i])
+                snr_hit = snr_hit & (np.sum((snr_param[:,j:idx_max] > snr_threshold_recalculation[i]), axis=1) >= num_img_recalculation[i])
                 j = idx_max
 
             # reduce the size of the dict
@@ -1212,6 +1215,7 @@ class LeR(LensGalaxyParameterDistribution):
                 lensed_param=lensed_param,
             )
             lensed_param.update(snrs)
+        ############################
 
         if self.snr:
             if "optimal_snr_net" not in lensed_param:
@@ -1443,7 +1447,10 @@ class LeR(LensGalaxyParameterDistribution):
         resume=False,
         output_jsonfile="n_unlensed_param_detectable.json",
         meta_data_file="meta_unlensed.json",
+        detectability_condition="step_function",
         trim_to_size=True,
+        snr_recalculation=False,
+        snr_threshold_recalculation=5.5,
     ):
         """
         Function to select n unlensed detectable events.
@@ -1513,10 +1520,44 @@ class LeR(LensGalaxyParameterDistribution):
                     size=batch_size, output_jsonfile=buffer_file, save_batch=False,resume=False
                 )
 
-            # get snr
-            snr = unlensed_param["optimal_snr_net"]
+            total_events_in_this_iteration = len(unlensed_param["zs"])
+            ############################
+            #       for ANN SNR        #
+            ############################
+            if snr_recalculation:
+                # select only above centain snr threshold
+                param = unlensed_param["optimal_snr_net"]
+                idx_detectable = param > snr_threshold_recalculation
+                # reduce the size of the dict
+                for key, value in unlensed_param.items():
+                    unlensed_param[key] = value[idx_detectable]
+                # recalculate more accurate snrs 
+                snrs = self.snr_bilby(gw_param_dict=unlensed_param)
+                unlensed_param.update(snrs)
+            ############################
+
+            if self.snr:
+                if "optimal_snr_net" not in unlensed_param:
+                    raise ValueError("'optimal_snr_net' not in unlensed parm dict provided")
+                if detectability_condition == "step_function":
+                    #print("given detectability_condition == 'step_function'")
+                    param = unlensed_param["optimal_snr_net"]
+                    threshold = snr_threshold
+                elif detectability_condition == "pdet":
+                    # print("given detectability_condition == 'pdet'")
+                    param = 1 - norm.cdf(snr_threshold - unlensed_param["optimal_snr_net"])
+                    unlensed_param["pdet_net"] = param
+                    threshold = 0.5
+            elif self.pdet:
+                if "pdet_net" in unlensed_param:
+                    #print("given detectability_condition == 'pdet'")
+                    param = unlensed_param["pdet_net"]
+                    threshold = 0.5
+                else:
+                    raise ValueError("'pdet_net' not in unlensed parm dict provided")
+
             # index of detectable events
-            idx = snr > snr_threshold
+            idx = param > threshold
 
             # store all params in json file
             for key, value in unlensed_param.items():
@@ -1524,7 +1565,7 @@ class LeR(LensGalaxyParameterDistribution):
             append_json(file_name=output_path, new_dictionary=unlensed_param, replace=False)
 
             n += np.sum(idx)
-            events_total += len(idx)                
+            events_total += total_events_in_this_iteration              
             total_rate = self.normalization_pdf_z * n / events_total
 
             # save meta data
@@ -1539,17 +1580,43 @@ class LeR(LensGalaxyParameterDistribution):
             print(f"total unlensed rate (yr^-1): {total_rate}")
 
         print(f"storing detectable unlensed params in {output_path}")
+        print(f"storing meta data in {meta_data_path}")
 
         if trim_to_size:
             # trim the final param dictionary
             print(f"\n trmming final result to size={size}")
             param_final = get_param_from_json(output_path)
+            # randomly select size number of samples
+            len_ = len(list(param_final.values())[0])
+            idx = np.random.choice(len_, size, replace=False)
             # trim the final param dictionary, randomly, without repeating
             for key, value in param_final.items():
-                param_final[key] = param_final[key][:size]
+                param_final[key] = value[idx]
+
+            # change meta data
+            meta_data = load_json(meta_data_path)
+            old_events_total = meta_data["events_total"][-1]
+            old_detectable_events = meta_data["detectable_events"][-1]
+
+            # adjust the meta data
+            # following is to keep rate the same
+            new_events_total = np.round(size*old_events_total/old_detectable_events)
+            new_total_rate = self.normalization_pdf_z * size / new_events_total
+            meta_data["events_total"][-1] = new_events_total
+            meta_data["detectable_events"][-1] = size
+            meta_data["total_rate"][-1] = new_total_rate
+
+
+            print("collected number of detectable events = ", size)
+            print("total number of events = ", new_events_total)
+            print(f"total unlensed rate (yr^-1): {new_total_rate}")
 
-        # save the final param dictionary
-        append_json(output_path, param_final, replace=True)
+            # save the meta data
+            append_json(meta_data_path, meta_data, replace=True)
+            # save the final param dictionary
+            append_json(output_path, param_final, replace=True)
+        else:
+            param_final = get_param_from_json(output_path)
 
         return param_final
     
@@ -1557,14 +1624,16 @@ class LeR(LensGalaxyParameterDistribution):
         self,
         size=100,
         batch_size=None,
-        snr_threshold=8.0,
-        num_img=2,
+        snr_threshold=[8.0,8.0],
+        num_img=[1,1],
         resume=False,
         detectability_condition="step_function",
         output_jsonfile="n_lensed_params_detectable.json",
         meta_data_file="meta_lensed.json",
         trim_to_size=True,
         nan_to_num=False,
+        snr_recalculation=False,
+        snr_threshold_recalculation=[5.5,5.5],
     ):
         """
         Function to select n lensed detectable events.
@@ -1605,6 +1674,8 @@ class LeR(LensGalaxyParameterDistribution):
 
         meta_data_path = self.ler_directory+"/"+meta_data_file
         output_path = self.ler_directory+"/"+output_jsonfile
+        if meta_data_path==output_path:
+            raise ValueError("meta_data_file and output_jsonfile cannot be same.")
 
         if batch_size is None:
             batch_size = self.batch_size
@@ -1649,6 +1720,47 @@ class LeR(LensGalaxyParameterDistribution):
                     size=self.batch_size, output_jsonfile=buffer_file, resume=False
                 )  # Dimensions are (size, n_max_images)
 
+            total_events_in_this_iteration = len(lensed_param["zs"])
+            ############################
+            #       for ANN SNR        #
+            ############################
+            if snr_recalculation:
+                # dealing with provided snr_threshold_recalculation
+                snr_threshold_recalculation = np.array([snr_threshold_recalculation]).reshape(-1)
+                idx = np.argsort(-snr_threshold_recalculation)
+                snr_threshold_recalculation = snr_threshold_recalculation[idx]
+                num_img_recalculation = num_img[idx]
+
+                # check optimal_snr_net is provided in dict
+                snr_param = lensed_param["optimal_snr_net"]
+                if "optimal_snr_net" in lensed_param.keys():
+                    snr_param = -np.sort(-snr_param, axis=1)  # sort snr in descending order
+                else:
+                    raise ValueError("optimal_snr_net not provided in lensed_param dict. Exiting...")
+
+                # 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 
+                j = 0
+                idx_max = 0
+                snr_hit = np.full(len(snr_param), True)  # boolean array to store the result of the threshold condition
+                for i, snr_th in enumerate(snr_threshold_recalculation):
+                    idx_max = idx_max + num_img_recalculation[i]
+
+                    snr_hit = snr_hit & (np.sum((snr_param[:,j:idx_max] > snr_th), axis=1) >= num_img_recalculation[i])
+                    j = idx_max
+
+                # reduce the size of the dict
+                for key, value in lensed_param.items():
+                    lensed_param[key] = value[snr_hit]
+                # recalculate more accurate snrs
+                print("calculating snrs...")
+                snrs, lensed_param = self.get_lensed_snrs(
+                    snr_calculator=self.snr_bilby,
+                    list_of_detectors=self.list_of_detectors,
+                    lensed_param=lensed_param,
+                )
+                lensed_param.update(snrs)
+            ############################
+
             if detectability_condition == "step_function":
                 snr_hit = np.full(len(lensed_param["zs"]), True)  # boolean array to store the result of the threshold condition
                 try:
@@ -1699,12 +1811,15 @@ class LeR(LensGalaxyParameterDistribution):
                     lensed_param[key] = value[snr_hit]
 
             if os.path.exists(output_path):
-                append_json(output_path, lensed_param, replace=False)
+                try:
+                    append_json(output_path, lensed_param, replace=False)
+                except:
+                    append_json(output_path, lensed_param, replace=True)
             else:
                 append_json(output_path, lensed_param, replace=True)
 
             n += np.sum(snr_hit)
-            events_total += len(snr_hit)
+            events_total += total_events_in_this_iteration
 
             # save meta data
             total_rate = self.normalization_pdf_z_lensed * n / events_total
@@ -1714,22 +1829,47 @@ class LeR(LensGalaxyParameterDistribution):
             else:
                 append_json(meta_data_path, meta_data, replace=True)
 
-            print("collected number of events = ", n)
+            print("collected number of detectable events = ", n)
             print("total number of events = ", events_total)
             print(f"total lensed rate (yr^-1): {total_rate}")
 
         print(f"storing detectable lensed params in {output_path}")
+        print(f"storing meta data in {meta_data_path}")
 
         if trim_to_size:
             # trim the final param dictionary
             print(f"\n trmming final result to size={size}")
             param_final = get_param_from_json(output_path)
+            # randomly select size number of samples
+            len_ = len(list(param_final.values())[0])
+            idx = np.random.choice(len_, size, replace=False)
             # trim the final param dictionary
             for key, value in param_final.items():
-                param_final[key] = param_final[key][:size]
-
+                param_final[key] = value[idx]
+
+            # change meta data
+            meta_data = load_json(meta_data_path)
+            old_events_total = meta_data["events_total"][-1]
+            old_detectable_events = meta_data["detectable_events"][-1]
+
+            # adjust the meta data
+            # following is to keep rate the same
+            new_events_total = np.round(size * old_events_total/old_detectable_events)
+            new_total_rate = self.normalization_pdf_z_lensed * size / new_events_total
+            meta_data["events_total"][-1] = new_events_total
+            meta_data["detectable_events"][-1] = size
+            meta_data["total_rate"][-1] = new_total_rate
+
+            print("collected number of detectable events = ", size)
+            print("total number of events = ", new_events_total)
+            print(f"total unlensed rate (yr^-1): {new_total_rate}")
+
+            # save the meta data
+            append_json(meta_data_path, meta_data, replace=True)
             # save the final param dictionary
             append_json(output_path, param_final, replace=True)
+        else:
+            param_final = get_param_from_json(output_path)
 
         return param_final
 

ler/utils/utils.py

@@ -139,7 +139,7 @@ def add_dict_values(dict1, dict2):
     data_key = dict1.keys()
     for key, value in dict2.items():
         if key in data_key:
-            dict1[key] = np.concatenate((dict1[key], value)).tolist()
+            dict1[key] = np.concatenate((dict1[key], value))
 
     return dict1
 
@@ -187,15 +187,24 @@ def rejection_sample(pdf, xmin, xmax, size=100, chunk_size=10000):
     """
     x = np.linspace(xmin, xmax, chunk_size)
     y = pdf(x)
+    # Maximum value of the pdf
     ymax = np.max(y)
+
     # Rejection sample in chunks
     x_sample = []
     while len(x_sample) < size:
         x_try = np.random.uniform(xmin, xmax, size=chunk_size)
+        pdf_x_try = pdf(x_try) # Calculate the pdf at the random x values
+        # this is for comparing with the pdf value at x_try, will be used to accept or reject the sample
         y_try = np.random.uniform(0, ymax, size=chunk_size)
-        ymax = max(ymax, np.max(y_try))  # Update the maximum value of the pdf
+        
+        # Update the maximum value of the pdf
+        ymax = max(ymax, np.max(pdf_x_try))  
+        
+        # applying condition to accept the sample
         # Add while retaining 1D shape of the list
-        x_sample += list(x_try[y_try < pdf(x_try)])
+        x_sample += list(x_try[y_try < pdf_x_try])
+
     # Transform the samples to a 1D numpy array
     x_sample = np.array(x_sample).flatten()
     # Return the correct number of samples
@@ -228,11 +237,11 @@ def rejection_sample2d(pdf, xmin, xmax, ymin, ymax, size=100, chunk_size=10000):
     x_sample : `numpy.ndarray`
         samples from the pdf in the x-axis.
     """
-    chunk_size = 10000
 
     x = np.random.uniform(xmin, xmax, chunk_size)
     y = np.random.uniform(ymin, ymax, chunk_size)
     z = pdf(x, y)
+    # Maximum value of the pdf
     zmax = np.max(z)
 
     # Rejection sample in chunks
@@ -241,12 +250,15 @@ def rejection_sample2d(pdf, xmin, xmax, ymin, ymax, size=100, chunk_size=10000):
     while len(x_sample) < size:
         x_try = np.random.uniform(xmin, xmax, size=chunk_size)
         y_try = np.random.uniform(ymin, ymax, size=chunk_size)
-
+        pdf_xy_try = pdf(x_try, y_try)
+        # this is for comparing with the pdf value at x_try, will be used to accept or reject the sample
         z_try = np.random.uniform(0, zmax, size=chunk_size)
-        zmax = max(zmax, np.max(z_try))
+        
+        # Update the maximum value of the pdf
+        zmax = max(zmax, np.max(pdf_xy_try))
 
-        x_sample += list(x_try[z_try < pdf(x_try, y_try)])
-        y_sample += list(y_try[z_try < pdf(x_try, y_try)])
+        x_sample += list(x_try[z_try < pdf_xy_try])
+        y_sample += list(y_try[z_try < pdf_xy_try])
 
     # Transform the samples to a 1D numpy array
     x_sample = np.array(x_sample).flatten()

{ler-0.3.6.dist-info → ler-0.3.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ler
-Version: 0.3.6
+Version: 0.3.8
 Summary: Gravitational waves Lensing Rates
 Home-page: https://github.com/hemantaph/ler
 Author: Hemantakumar
@@ -16,7 +16,7 @@ Requires-Dist: numpy >=1.18
 Requires-Dist: numba >=0.57.1
 Requires-Dist: bilby >=1.0.2
 Requires-Dist: gwsnr >=0.2.0
-Requires-Dist: scipy >=1.9.0
+Requires-Dist: scipy <1.14.0
 Requires-Dist: lenstronomy >=1.10.4
 Requires-Dist: astropy >=5.1
 Requires-Dist: tqdm >=4.64.1

ler-0.3.8.dist-info/RECORD

@@ -0,0 +1,24 @@
+ler/__init__.py,sha256=mTa4tgjjmfWuadm6yhsGqo-92BYy_Ad0lbBcvRZnJn4,804
+ler/gw_source_population/__init__.py,sha256=HG0ve5wTpBDN2fNMxHLnoOqTz-S0jXM_DsWEJ5PEHAw,126
+ler/gw_source_population/cbc_source_parameter_distribution.py,sha256=jSqAE4tm-4ZmQiKRpxZ7-LGAP_uGpEMGX197Eh2Iuyg,67862
+ler/gw_source_population/cbc_source_redshift_distribution.py,sha256=o2qAM_-9SeLxxfGwqXrdVWTCeEAaXVan_OPDd4jrplg,28559
+ler/gw_source_population/jit_functions.py,sha256=aQV9mv3IY5b3OLiPeXmoLWJ_TbFUS9M1OgnIyIY3eX4,8668
+ler/image_properties/__init__.py,sha256=XfJFlyZuOrKODT-z9WxjR9mI8eT399YJV-jzcJKTqGo,71
+ler/image_properties/image_properties.py,sha256=as-6ZKoA7bvOTDNsCE0o9LyoKzfdHip-nRRq86UkjX0,25166
+ler/image_properties/multiprocessing_routine.py,sha256=hYnQTM7PSIj3X-5YNDqMxH9UgeXHUPPdLG70h_r6sEY,18333
+ler/lens_galaxy_population/__init__.py,sha256=TXk1nwiYy0tvTpKs35aYK0-ZK63g2JLPyGG_yfxD0YU,126
+ler/lens_galaxy_population/jit_functions.py,sha256=tCTcr4FWyQXH7SQlHsUWeZBpv4jnG00DsBIljdWFs5M,8472
+ler/lens_galaxy_population/lens_galaxy_parameter_distribution.py,sha256=074RNd1EPilObL0dh7NLW1bxl9xRqv0TqdFkrAx4Ebw,48246
+ler/lens_galaxy_population/mp.py,sha256=TPnFDEzojEqJzE3b0g39emZasHeeaeXN2q7JtMcgihk,6387
+ler/lens_galaxy_population/optical_depth.py,sha256=fcZSXaIjx7v8WDZuiIIMEqR1gtKJc4V4gTnQpVlTpas,42437
+ler/rates/__init__.py,sha256=N4li9NouSVjZl5HIhyuiKKRyrpUgQkBZaUeDgL1m4ic,43
+ler/rates/gwrates.py,sha256=2svyxdEzChiK4YDN4rRVrm0Yhh0TXrRXxobg9d1sF-4,40865
+ler/rates/ler.py,sha256=QySWLxrjP9XJGH423lHlwL006znde-lNvxTTV3O7CFI,84164
+ler/utils/__init__.py,sha256=JWF9SKoqj1BThpV_ynfoyUeU06NQQ45DHCUGaaMSp_8,42
+ler/utils/plots.py,sha256=D8MjTrfyE4cc0D6KBu1Mw4VMllp9Yp73bSi2cqPmNOM,10742
+ler/utils/utils.py,sha256=FI_o6klrkZGzDlKYxSV3S5ovGQFfCNuNoc_m2qBD7pg,27945
+ler-0.3.8.dist-info/LICENSE,sha256=9LeXXC3WaHBpiUGhLVgOVnz0F12olPma1RX5zgpfp8Q,1081
+ler-0.3.8.dist-info/METADATA,sha256=wsmsniEhQ7kv8zjiRqZSXvGiJaVwSkEMMulE9aFkpfQ,6521
+ler-0.3.8.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+ler-0.3.8.dist-info/top_level.txt,sha256=VWeWLF_gNMjzquGmqrLXqp2J5WegY86apTUimMTh68I,4
+ler-0.3.8.dist-info/RECORD,,

{ler-0.3.6.dist-info → ler-0.3.8.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.2)
+Generator: setuptools (70.2.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

ler-0.3.6.dist-info/RECORD

@@ -1,24 +0,0 @@
-ler/__init__.py,sha256=Y1j_RXriJ7OLOdESsyeZkh4W7p438p5-Hgt88zZsQCA,804
-ler/gw_source_population/__init__.py,sha256=HG0ve5wTpBDN2fNMxHLnoOqTz-S0jXM_DsWEJ5PEHAw,126
-ler/gw_source_population/cbc_source_parameter_distribution.py,sha256=jAFBAen3ZsGkJSxSDeBT0WZlVYNTIF-ICRiftVlnlMo,66229
-ler/gw_source_population/cbc_source_redshift_distribution.py,sha256=ajI4L7vkoNNzw2Y_bZTe9T3F9uFcrYt_KaINT9anuvw,28160
-ler/gw_source_population/jit_functions.py,sha256=phUYdbFRvNMRgXJtSwGYSY2HN5h3n3IcLJR9AvHyC6o,8666
-ler/image_properties/__init__.py,sha256=XfJFlyZuOrKODT-z9WxjR9mI8eT399YJV-jzcJKTqGo,71
-ler/image_properties/image_properties.py,sha256=XKOTimOFmSCNlEfUT_oEwPGm7P3tEwEtfsydXeJmhy8,24080
-ler/image_properties/multiprocessing_routine.py,sha256=f5sXcAx01xAx7AvOFE1Q99w7X9WIUwqlsUl7zq--rG4,17805
-ler/lens_galaxy_population/__init__.py,sha256=TXk1nwiYy0tvTpKs35aYK0-ZK63g2JLPyGG_yfxD0YU,126
-ler/lens_galaxy_population/jit_functions.py,sha256=8ZlseC6oaNuiZg5DvOeoonkH1BUE_dZyFMfmAx7_TPw,8419
-ler/lens_galaxy_population/lens_galaxy_parameter_distribution.py,sha256=e_3lgfJi3K_ioZf5VTw4hPgtUHeDThMHUYGmUnuKE9Q,48174
-ler/lens_galaxy_population/mp.py,sha256=TPnFDEzojEqJzE3b0g39emZasHeeaeXN2q7JtMcgihk,6387
-ler/lens_galaxy_population/optical_depth.py,sha256=m4rBkE2-7Gd6z_oHmHOfg4bPHOi0xotCs5VQnFbzz_A,42333
-ler/rates/__init__.py,sha256=N4li9NouSVjZl5HIhyuiKKRyrpUgQkBZaUeDgL1m4ic,43
-ler/rates/gwrates.py,sha256=cAMC57G9D0yiJLN_Q6qV4wyTlnyk_vkrZ3nCbbSb6dw,40718
-ler/rates/ler.py,sha256=Ff1u0sWb_1rHzuUjm7xgZ1q8xBh57TQ3VxJVjgFhjZE,76975
-ler/utils/__init__.py,sha256=JWF9SKoqj1BThpV_ynfoyUeU06NQQ45DHCUGaaMSp_8,42
-ler/utils/plots.py,sha256=D8MjTrfyE4cc0D6KBu1Mw4VMllp9Yp73bSi2cqPmNOM,10742
-ler/utils/utils.py,sha256=BPMUMamJeAW9-LlvW4ao93jAZSG6YBS6Hd3FpTYJgB4,27465
-ler-0.3.6.dist-info/LICENSE,sha256=9LeXXC3WaHBpiUGhLVgOVnz0F12olPma1RX5zgpfp8Q,1081
-ler-0.3.6.dist-info/METADATA,sha256=92RR_37n1guw-A7aebZbeeDqPnosEJ-fee4NQaeiqOY,6521
-ler-0.3.6.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-ler-0.3.6.dist-info/top_level.txt,sha256=VWeWLF_gNMjzquGmqrLXqp2J5WegY86apTUimMTh68I,4
-ler-0.3.6.dist-info/RECORD,,