ler 0.3.7__py3-none-any.whl → 0.3.9__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.7"
+__version__ = "0.3.9"
 
 # add __file__
 import os

ler/gw_source_population/cbc_source_parameter_distribution.py

@@ -269,9 +269,9 @@ class CBCSourceParameterDistribution(CBCSourceRedshiftDistribution):
         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),
-            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 isinstance(create_new_interpolator, dict):
             self.create_new_interpolator.update(create_new_interpolator)
@@ -291,27 +291,21 @@ class CBCSourceParameterDistribution(CBCSourceRedshiftDistribution):
             event_type, source_priors, source_priors_params
         )
 
-        if self.gw_param_samplers["zs"] == "sample_source_redshift":
-            # initialize the SourceGalaxyPopulationModel mother class
-            # for redshift distribution
-            # instance attribute sample_source_redshift is initialized here
-            super().__init__(
-                z_min=z_min,
-                z_max=z_max,
-                event_type=event_type,
-                merger_rate_density=self.gw_param_samplers["merger_rate_density"],
-                merger_rate_density_param=self.gw_param_samplers_params[
-                    "merger_rate_density"
-                ],
-                cosmology=cosmology,
-                directory=directory,
-                create_new_interpolator=self.create_new_interpolator,
-            )
-        else:
-            # if you already have the redshift distribution function, you can pass it in.
-            # super class will not be initialized anymore,
-            # get z_to_luminosity_distance
-            self.lookup_table_luminosity_distance(z_min, z_max, directory)
+        # initialize the SourceGalaxyPopulationModel mother class
+        # for redshift distribution
+        # instance attribute sample_source_redshift is initialized here
+        super().__init__(
+            z_min=z_min,
+            z_max=z_max,
+            event_type=event_type,
+            merger_rate_density=self.gw_param_samplers["merger_rate_density"],
+            merger_rate_density_param=self.gw_param_samplers_params[
+                "merger_rate_density"
+            ],
+            cosmology=cosmology,
+            directory=directory,
+            create_new_interpolator=self.create_new_interpolator,
+        )
 
         # initializing samplers
         # it goes through the setter functions and assign the sampler functions
@@ -827,6 +821,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 +961,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(luminosity_distance_to_z=dict(create_new=False, resolution=1000))
 
     Examples
     --------
@@ -140,22 +140,22 @@ class ImageProperties():
         
         # initialize the interpolator's parameters
         self.create_new_interpolator = dict(
-            Dl_to_z=dict(create_new=False, resolution=500),
+            luminosity_distance_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)
+                luminosity_distance_to_z=dict(create_new=True, resolution=1000)
             )
 
-        resolution = self.create_new_interpolator["Dl_to_z"]["resolution"]
-        create_new = self.create_new_interpolator["Dl_to_z"]["create_new"]
+        resolution = self.create_new_interpolator["luminosity_distance_to_z"]["resolution"]
+        create_new = self.create_new_interpolator["luminosity_distance_to_z"]["create_new"]
         spline1 = interpolator_from_pickle(
             param_dict_given= dict(z_min=z_min, z_max=z_max, cosmology=self.cosmo, resolution=resolution),
             directory=directory,
-            sub_directory="Dl_to_z",
-            name="Dl_to_z",
+            sub_directory="luminosity_distance_to_z",
+            name="luminosity_distance_to_z",
             x = np.linspace(z_min, z_max, resolution),
             pdf_func= lambda z_: cosmo.luminosity_distance(z_).value, 
             conditioned_y=None, 
@@ -163,7 +163,7 @@ class ImageProperties():
             category="function_inverse",
             create_new=create_new,
         )
-        self.Dl_to_z = njit(lambda z_: cubic_spline_interpolator(z_, spline1[0], spline1[1]))
+        self.luminosity_distance_to_z = njit(lambda z_: cubic_spline_interpolator(z_, spline1[0], spline1[1]))
 
     def image_properties(
             self,
@@ -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(
@@ -499,13 +519,16 @@ class ImageProperties():
 
                     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=200),
+            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),
+            luminosity_distance_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=200),
+                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),
+                luminosity_distance_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"],
         )