ler 0.3.4__tar.gz → 0.3.6__tar.gz

{ler-0.3.4 → ler-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ler
-Version: 0.3.4
+Version: 0.3.6
 Summary: Gravitational waves Lensing Rates
 Home-page: https://github.com/hemantaph/ler
 Author: Hemantakumar

{ler-0.3.4 → ler-0.3.6}/ler/__init__.py

@@ -13,7 +13,12 @@ except RuntimeError:
 
 __author__ = 'hemanta_ph <hemantaphurailatpam@gmail.com>'
 
-__version__ = "0.3.4"
+# The version as used in the setup.py
+__version__ = "0.3.6"
+
+# add __file__
+import os
+__file__ = os.path.abspath(__file__)
 
 from . import rates, gw_source_population, lens_galaxy_population, image_properties, utils
 

{ler-0.3.4 → ler-0.3.6}/ler/image_properties/image_properties.py

@@ -119,7 +119,7 @@ class ImageProperties():
                  n_min_images=2, 
                  n_max_images=4,
                  geocent_time_min=1126259462.4,
-                 geocent_time_max=1126259462.4+365*24*3600*10,
+                 geocent_time_max=1126259462.4+365*24*3600*20,
                  lens_model_list=['EPL_NUMBA', 'SHEAR'],
                  cosmology=None,
                  spin_zero=True,
@@ -342,7 +342,7 @@ class ImageProperties():
 
         return lens_parameters
 
-    def get_lensed_snrs(self, snr_calculator, list_of_detectors, lensed_param):
+    def get_lensed_snrs(self, lensed_param, list_of_detectors=None, snr_calculator=None, pdet_calculator=None):
         """
         Function to calculate the signal to noise ratio for each image in each event.
 
@@ -403,14 +403,27 @@ class ImageProperties():
                 )
         
         # setting up snr dictionary
-        optimal_snrs = dict()
-        optimal_snrs["optimal_snr_net"] = (
-            np.ones((number_of_lensed_events, n_max_images)) * np.nan
-        )
-        for detector in list_of_detectors:
-            optimal_snrs[detector] = (
+        result_dict = dict()
+        if snr_calculator:
+            result_dict["optimal_snr_net"] = (
+                np.ones((number_of_lensed_events, n_max_images)) * np.nan
+            )
+        # setting up pdet dictionary
+        elif pdet_calculator:
+            result_dict["pdet_net"] = (
                 np.ones((number_of_lensed_events, n_max_images)) * np.nan
             )
+        else:
+            raise ValueError("snr_calculator or pdet_calculator not given")
+        
+        # if detector list are provided for snr or pdet calculation
+        if list_of_detectors:
+            for detector in list_of_detectors:
+                result_dict[detector] = (
+                    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
@@ -435,33 +448,65 @@ class ImageProperties():
             # Each image has their own effective luminosity distance and effective geocent time
             if len(effective_luminosity_distance) != 0:
                 # Returns a dictionary
-                optimal_snr = snr_calculator(
-                    mass_1[idx],
-                    mass_2[idx],
-                    effective_luminosity_distance[idx],
-                    theta_jn[idx],
-                    psi[idx],
-                    phase[idx],
-                    effective_geocent_time[idx],
-                    ra[idx],
-                    dec[idx],
-                    a_1[idx],
-                    a_2[idx],
-                    tilt_1[idx],
-                    tilt_2[idx],
-                    phi_12[idx],
-                    phi_jl[idx],
-                    output_jsonfile=False,
-                )
-
-                optimal_snrs["optimal_snr_net"][idx, i] = optimal_snr["optimal_snr_net"]
-                for detector in list_of_detectors:
-                    optimal_snrs[detector][idx, i] = optimal_snr[detector]
+                if snr_calculator:
+                    optimal_snr = snr_calculator(
+                        gw_param_dict= dict(
+                            mass_1=mass_1[idx],
+                            mass_2=mass_2[idx],
+                            luminosity_distance=effective_luminosity_distance[idx],
+                            theta_jn=theta_jn[idx],
+                            psi=psi[idx],
+                            phase=phase[idx],
+                            geocent_time=effective_geocent_time[idx],
+                            ra=ra[idx],
+                            dec=dec[idx],
+                            a_1=a_1[idx],
+                            a_2=a_2[idx],
+                            tilt_1=tilt_1[idx],
+                            tilt_2=tilt_2[idx],
+                            phi_12=phi_12[idx],
+                            phi_jl=phi_jl[idx],
+                        ),
+                        output_jsonfile=False,
+                    )
+                    result_dict["optimal_snr_net"][idx, i] = optimal_snr["optimal_snr_net"]
+
+                    if list_of_detectors:
+                        for detector in list_of_detectors:
+                            result_dict[detector][idx, i] = optimal_snr[detector]
+
+                elif pdet_calculator:
+                    pdet = pdet_calculator(
+                        gw_param_dict= dict(
+                            mass_1=mass_1[idx],
+                            mass_2=mass_2[idx],
+                            luminosity_distance=effective_luminosity_distance[idx],
+                            theta_jn=theta_jn[idx],
+                            psi=psi[idx],
+                            phase=phase[idx],
+                            geocent_time=effective_geocent_time[idx],
+                            ra=ra[idx],
+                            dec=dec[idx],
+                            a_1=a_1[idx],
+                            a_2=a_2[idx],
+                            tilt_1=tilt_1[idx],
+                            tilt_2=tilt_2[idx],
+                            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]
+                
 
                 lensed_param["effective_luminosity_distance"][:, i] = effective_luminosity_distance
                 lensed_param["effective_geocent_time"][:, i] = effective_geocent_time
 
-        lensed_param["luminosity_distance"]
-        lensed_param["geocent_time"]
+        del lensed_param["luminosity_distance"]
+        del lensed_param["geocent_time"]
 
-        return optimal_snrs, lensed_param
+        return result_dict, lensed_param

{ler-0.3.4 → ler-0.3.6}/ler/image_properties/multiprocessing_routine.py

@@ -159,7 +159,7 @@ def solve_lens_equation(lens_parameters):
             sourcePos_y=y_source,
             kwargs_lens=kwargs_lens,
             solver="analytical",
-            magnification_limit=1.0 / 1000.0,
+            magnification_limit=1.0 / 100.0,
             arrival_time_sort=True,
         )
         nImages = len(x0_image_position)  # shows how many images

{ler-0.3.4 → ler-0.3.6}/ler/rates/gwrates.py

@@ -186,9 +186,11 @@ class GWRATES(CBCSourceParameterDistribution):
         z_max=10.0,
         event_type="BBH",
         size=100000,
-        batch_size=25000,
+        batch_size=50000,
         cosmology=None,
-        snr_finder="gwsnr",
+        snr_finder=None,
+        pdet_finder=None,
+        list_of_detectors=None,
         json_file_names=None,
         interpolator_directory="./interpolator_pickle",
         ler_directory="./ler_data",
@@ -215,12 +217,18 @@ class GWRATES(CBCSourceParameterDistribution):
         def initialization():
             # initialization of parent class
             self.class_initialization(params=kwargs)
-            if snr_finder == "gwsnr":
-                # initialization self.snr and self.pdet from GWSNR class
+            # initialization self.snr and self.pdet from GWSNR class
+            if not snr_finder and not pdet_finder:
                 self.gwsnr_intialization(params=kwargs)
+                self.gwsnr = True
+                self.pdet = pdet_finder
             else:
                 self.snr = snr_finder
+                self.pdet = pdet_finder
+                self.gwsnr = False
+                self.list_of_detectors = list_of_detectors
 
+            # store all the gwrates input parameters
             self.store_gwrates_params(output_jsonfile=self.json_file_names["gwrates_param"])
 
         if verbose:
@@ -229,7 +237,6 @@ class GWRATES(CBCSourceParameterDistribution):
         else:
             with contextlib.redirect_stdout(None):
                 initialization()
-            
 
     def print_all_params(self):
         """
@@ -245,9 +252,13 @@ class GWRATES(CBCSourceParameterDistribution):
         print("size = ", self.size)
         print("batch_size = ", self.batch_size)
         print("cosmology = ", self.cosmo)
-        print("snr_finder = ", self.snr)
+        if self.snr:
+            print("snr_finder = ", self.snr)
+        if self.pdet:
+            print("pdet_finder = ", self.pdet)
         print("json_file_names = ", self.json_file_names)
         print("interpolator_directory = ", self.interpolator_directory)
+        print("ler_directory = ", self.ler_directory)
 
         print("\n GWRATES also takes CBCSourceParameterDistribution params as kwargs, as follows:")
         print("source_priors=", self.gw_param_sampler_dict["source_priors"])
@@ -256,24 +267,26 @@ class GWRATES(CBCSourceParameterDistribution):
         print("spin_precession=", self.gw_param_sampler_dict["spin_precession"])
         print("create_new_interpolator=", self.gw_param_sampler_dict["create_new_interpolator"])
 
-        print("\n GWRATES also takes GWSNR params as kwargs, as follows:")
-        print("mtot_min = ", self.snr_calculator_dict["mtot_min"])
-        print("mtot_max = ", self.snr_calculator_dict["mtot_max"])
-        print("ratio_min = ", self.snr_calculator_dict["ratio_min"])
-        print("ratio_max = ", self.snr_calculator_dict["ratio_max"])
-        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("minimum_frequency = ", self.snr_calculator_dict["minimum_frequency"])
-        print("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"])
-        print("create_new_interpolator = ", self.snr_calculator_dict["create_new_interpolator"])
-        print("gwsnr_verbose = ", self.snr_calculator_dict["gwsnr_verbose"])
-        print("multiprocessing_verbose = ", self.snr_calculator_dict["multiprocessing_verbose"])
-        print("mtot_cut = ", self.snr_calculator_dict["mtot_cut"])
+        if self.gwsnr:
+            print("\n GWRATES also takes GWSNR params as kwargs, as follows:")
+            print("mtot_min = ", self.snr_calculator_dict["mtot_min"])
+            print("mtot_max = ", self.snr_calculator_dict["mtot_max"])
+            print("ratio_min = ", self.snr_calculator_dict["ratio_min"])
+            print("ratio_max = ", self.snr_calculator_dict["ratio_max"])
+            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("minimum_frequency = ", self.snr_calculator_dict["minimum_frequency"])
+            print("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"])
+            print("create_new_interpolator = ", self.snr_calculator_dict["create_new_interpolator"])
+            print("gwsnr_verbose = ", self.snr_calculator_dict["gwsnr_verbose"])
+            print("multiprocessing_verbose = ", self.snr_calculator_dict["multiprocessing_verbose"])
+            print("mtot_cut = ", self.snr_calculator_dict["mtot_cut"])
+        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"])
@@ -416,10 +429,11 @@ class GWRATES(CBCSourceParameterDistribution):
         input_params = dict(
             z_min=self.z_min,
             z_max=self.z_max,
+            cosmology=self.cosmo,
             event_type=self.event_type,
             source_priors=None,
             source_priors_params=None,
-            cosmology=self.cosmo,
+            
             spin_zero=True,
             spin_precession=False,
             interpolator_directory=self.interpolator_directory,
@@ -557,7 +571,7 @@ class GWRATES(CBCSourceParameterDistribution):
             pass
 
     def gw_cbc_statistics(
-        self, size=None, resume=False, save_batch=True, output_jsonfile=None,
+        self, size=None, resume=False, save_batch=False, output_jsonfile=None,
     ):
         """
         Function to generate gw GW source parameters. This function also stores the parameters in json file.
@@ -593,7 +607,7 @@ class GWRATES(CBCSourceParameterDistribution):
         output_jsonfile = output_jsonfile or self.json_file_names["gw_param"]
         self.json_file_names["gw_param"] = output_jsonfile
         output_path = os.path.join(self.ler_directory, output_jsonfile)
-        print(f"Simulated GW params will be stored in {output_jsonfile}")
+        print(f"Simulated GW params will be stored in {output_path}")
 
         # sampling in batches
         if resume and os.path.exists(output_path):
@@ -621,7 +635,7 @@ class GWRATES(CBCSourceParameterDistribution):
                 print(f"saving all gw_params in {output_path}...")
                 append_json(output_path, gw_param, replace=True)
             else:
-                print("unlensed_params already sampled.")
+                print("gw_params already sampled.")
                 gw_param = get_param_from_json(output_path)
         self.dict_buffer = None  # save memory
 
@@ -654,9 +668,14 @@ class GWRATES(CBCSourceParameterDistribution):
         print("sampling gw source params...")
         gw_param = self.sample_gw_parameters(size=size)
         # Get all of the signal to noise ratios
-        print("calculating snrs...")
-        snrs = self.snr(gw_param_dict=gw_param)
-        gw_param.update(snrs)
+        if self.snr:
+            print("calculating snrs...")
+            snrs = self.snr(gw_param_dict=gw_param)
+            gw_param.update(snrs)
+        elif self.pdet:
+            print("calculating pdet...")
+            pdet = self.pdet(gw_param_dict=gw_param)
+            gw_param.update(pdet)
 
         # adding batches
         if not save_batch:
@@ -727,7 +746,8 @@ class GWRATES(CBCSourceParameterDistribution):
             gw_param = self.json_file_names["gw_param"]
         if type(gw_param) == str:
             self.json_file_names["gw_param"] = gw_param
-            print(f"getting gw_params from json file {gw_param}...")
+            path_ = self.ler_directory+"/"+gw_param
+            print(f"getting gw_params from json file {path_}...")
             gw_param = get_param_from_json(self.ler_directory+"/"+gw_param)
         else:
             print("using provided gw_param dict...")
@@ -748,29 +768,30 @@ class GWRATES(CBCSourceParameterDistribution):
             # recalculate more accurate snrs 
             snrs = self.snr_bilby(gw_param_dict=gw_param)
             gw_param.update(snrs)
-            
-        if detectability_condition == "step_function":
-            try:
-                snr_param = gw_param["optimal_snr_net"]
-            except:
-                print("optimal_snr_net not provided in gw_param dict. Exiting...")
-                return None
-            threshold = snr_threshold
-
-        elif detectability_condition == "pdet":
-            # check if pdet is provided in gw_param dict
-            if "pdet_net" in gw_param.keys():
-                snr_param = gw_param["pdet_net"]
+        
+        if self.snr:
+            if "optimal_snr_net" not in gw_param:
+                raise ValueError("'optimal_snr_net' not in gw parm dict provided")
+            if detectability_condition == "step_function":
+                print("given detectability_condition == 'step_function'")
+                param = gw_param["optimal_snr_net"]
+                threshold = snr_threshold
+
+
+            elif detectability_condition == "pdet":
+                print("given detectability_condition == 'pdet'")
+                param = 1 - norm.cdf(snr_threshold - gw_param["optimal_snr_net"])
+                gw_param["pdet_net"] = param
+                threshold = 0.5
+        elif self.pdet:
+            if "pdet_net" in gw_param:
+                print("given detectability_condition == 'pdet'")
+                param = gw_param["pdet_net"]
+                threshold = 0.5
             else:
-                if "optimal_snr_net" in gw_param.keys():
-                    snr_param = 1 - norm.cdf(snr_threshold - gw_param["optimal_snr_net"])
-                    gw_param["pdet_net"] = snr_param
-                else:
-                    print("pdet or optimal_snr_net not provided in gw_param dict. Exiting...")
-                    return None
-            threshold = 0.5
-
-        idx_detectable = snr_param > threshold
+                raise ValueError("'pdet_net' not in gw parm dict provided")
+
+        idx_detectable = param > threshold
         detectable_events = np.sum(idx_detectable)
         # montecarlo integration
         # The total rate R = norm <Theta(rho-rhoc)>
@@ -788,7 +809,8 @@ class GWRATES(CBCSourceParameterDistribution):
             output_jsonfile = self.json_file_names["gw_param_detectable"]
         else:
             self.json_file_names["gw_param_detectable"] = output_jsonfile
-        print(f"storing detectable gw params in {output_jsonfile}")
+            path_ = self.ler_directory+"/"+output_jsonfile
+        print(f"storing detectable gw params in {path_}")
         append_json(self.ler_directory+"/"+output_jsonfile, gw_param, replace=True)
 
         # write the results
@@ -866,7 +888,7 @@ class GWRATES(CBCSourceParameterDistribution):
                 events_total = 0
 
         buffer_file = self.ler_directory+"/"+"gw_params_buffer.json"
-        print("collected number of events = ", n)
+        print("collected number of detectable events = ", n)
         # loop until n samples are collected
         while n < size:
             # disable print statements
@@ -897,7 +919,7 @@ class GWRATES(CBCSourceParameterDistribution):
             else:
                 append_json(file_name=meta_data_path, new_dictionary=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 gw rate (yr^-1): {total_rate}")
 

{ler-0.3.4 → ler-0.3.6}/ler/rates/ler.py

@@ -40,12 +40,12 @@ class LeR(LensGalaxyParameterDistribution):
         recommended batch_size = 50000, if size = 1000000.
     snr_finder : `str`
         default snr_finder = 'gwsnr'.
-        if 'gwsnr', the SNR will be calculated using the gwsnr package.
+        if None, the SNR will be calculated using the gwsnr package.
         if 'custom', the SNR will be calculated using a custom function.
         The custom function should have input and output as given in GWSNR.snr method.
     json_file_names: `dict`
         names of the json files to strore the necessary parameters.
-        default json_file_names = {'ler_param': 'LeR_params.json', 'unlensed_param': 'unlensed_param.json', 'unlensed_param_detectable': 'unlensed_param_detectable.json'}.\n
+        default json_file_names = {'ler_params': 'LeR_params.json', 'unlensed_param': 'unlensed_param.json', 'unlensed_param_detectable': 'unlensed_param_detectable.json'}.\n
     kwargs : `keyword arguments`
         Note : kwargs takes input for initializing the :class:`~ler.lens_galaxy_population.LensGalaxyParameterDistribution`, :meth:`~gwsnr_intialization`.
 
@@ -239,7 +239,9 @@ class LeR(LensGalaxyParameterDistribution):
         size=100000,
         batch_size=50000,
         cosmology=None,
-        snr_finder="gwsnr",
+        snr_finder=None,
+        pdet_finder=None,
+        list_of_detectors=None,
         json_file_names=None,
         interpolator_directory="./interpolator_pickle",
         ler_directory="./ler_data",
@@ -254,7 +256,7 @@ class LeR(LensGalaxyParameterDistribution):
         self.cosmo = cosmology if cosmology else LambdaCDM(H0=70, Om0=0.3, Ode0=0.7)
         self.size = size
         self.batch_size = batch_size
-        self.json_file_names = dict(ler_param="ler_params.json", unlensed_param="unlensed_param.json", unlensed_param_detectable="unlensed_param_detectable.json", lensed_param="lensed_param.json", lensed_param_detectable="lensed_param_detectable.json")
+        self.json_file_names = dict(ler_params="ler_params.json", unlensed_param="unlensed_param.json", unlensed_param_detectable="unlensed_param_detectable.json", lensed_param="lensed_param.json", lensed_param_detectable="lensed_param_detectable.json")
         if json_file_names:
             self.json_file_names.update(json_file_names)
         self.interpolator_directory = interpolator_directory
@@ -266,13 +268,19 @@ class LeR(LensGalaxyParameterDistribution):
         def initialization():
             # initialization of parent class
             self.class_initialization(params=kwargs)
-            if snr_finder == "gwsnr":
-                # initialization self.snr and self.pdet from GWSNR class
+            # initialization self.snr and self.pdet from GWSNR class
+            if not snr_finder and not pdet_finder:
                 self.gwsnr_intialization(params=kwargs)
+                self.gwsnr = True
+                self.pdet = pdet_finder
             else:
                 self.snr = snr_finder
+                self.pdet = pdet_finder
+                self.gwsnr = False
+                self.list_of_detectors = list_of_detectors
+            
             # store all the ler input parameters
-            self.store_ler_params(output_jsonfile=self.json_file_names["ler_param"])
+            self.store_ler_params(output_jsonfile=self.json_file_names["ler_params"])
 
         # if verbose, prevent anything from printing
         if verbose:
@@ -296,7 +304,10 @@ class LeR(LensGalaxyParameterDistribution):
         print("size = ", self.size)
         print("batch_size = ", self.batch_size)
         print("cosmology = ", self.cosmo)
-        print("snr_finder = ", self.snr)
+        if self.snr:
+            print("snr_finder = ", self.snr)
+        if self.pdet:
+            print("pdet_finder = ", self.pdet)
         print("json_file_names = ", self.json_file_names)
         print("interpolator_directory = ", self.interpolator_directory)
         print("ler_directory = ", self.ler_directory)
@@ -321,24 +332,26 @@ class LeR(LensGalaxyParameterDistribution):
         print("geocent_time_max = ", self.geocent_time_max)
         print("lens_model_list = ", self.lens_model_list)
 
-        print("\n LeR also takes gwsnr.GWSNR params as kwargs, as follows:")
-        print("mtot_min = ", self.snr_calculator_dict["mtot_min"])
-        print("mtot_max = ", self.snr_calculator_dict["mtot_max"])
-        print("ratio_min = ", self.snr_calculator_dict["ratio_min"])
-        print("ratio_max = ", self.snr_calculator_dict["ratio_max"])
-        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("minimum_frequency = ", self.snr_calculator_dict["minimum_frequency"])
-        print("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"])
-        print("create_new_interpolator = ", self.snr_calculator_dict["create_new_interpolator"])
-        print("gwsnr_verbose = ", self.snr_calculator_dict["gwsnr_verbose"])
-        print("multiprocessing_verbose = ", self.snr_calculator_dict["multiprocessing_verbose"])
-        print("mtot_cut = ", self.snr_calculator_dict["mtot_cut"])
+        if self.gwsnr:
+            print("\n LeR also takes gwsnr.GWSNR params as kwargs, as follows:")
+            print("mtot_min = ", self.snr_calculator_dict["mtot_min"])
+            print("mtot_max = ", self.snr_calculator_dict["mtot_max"])
+            print("ratio_min = ", self.snr_calculator_dict["ratio_min"])
+            print("ratio_max = ", self.snr_calculator_dict["ratio_max"])
+            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("minimum_frequency = ", self.snr_calculator_dict["minimum_frequency"])
+            print("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"])
+            print("create_new_interpolator = ", self.snr_calculator_dict["create_new_interpolator"])
+            print("gwsnr_verbose = ", self.snr_calculator_dict["gwsnr_verbose"])
+            print("multiprocessing_verbose = ", self.snr_calculator_dict["multiprocessing_verbose"])
+            print("mtot_cut = ", self.snr_calculator_dict["mtot_cut"])
+        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"])
@@ -461,7 +474,7 @@ class LeR(LensGalaxyParameterDistribution):
             dictionary of unlensed GW source parameters.
         """
 
-        return get_param_from_json(self.json_file_names["unlensed_param"])
+        return get_param_from_json(self.ler_directory+"/"+self.json_file_names["unlensed_param"])
     
     @property
     def unlensed_param_detectable(self):
@@ -474,7 +487,7 @@ class LeR(LensGalaxyParameterDistribution):
             dictionary of unlensed GW source parameters.
         """
 
-        return get_param_from_json(self.json_file_names["unlensed_param_detectable"])
+        return get_param_from_json(self.ler_directory+"/"+self.json_file_names["unlensed_param_detectable"])
     
     @property
     def lensed_param(self):
@@ -487,7 +500,7 @@ class LeR(LensGalaxyParameterDistribution):
             dictionary of lensed GW source parameters.
         """
 
-        return get_param_from_json(self.json_file_names["lensed_param"])
+        return get_param_from_json(self.ler_directory+"/"+self.json_file_names["lensed_param"])
     
     @property
     def lensed_param_detectable(self):
@@ -500,7 +513,7 @@ class LeR(LensGalaxyParameterDistribution):
             dictionary of lensed GW source parameters.
         """
 
-        return get_param_from_json(self.json_file_names["lensed_param_detectable"])
+        return get_param_from_json(self.ler_directory+"/"+self.json_file_names["lensed_param_detectable"])
 
     def class_initialization(self, params=None):
         """
@@ -531,7 +544,7 @@ class LeR(LensGalaxyParameterDistribution):
             lens_priors=None,
             lens_priors_params=None,
             geocent_time_min=1126259462.4,
-            geocent_time_max=1126259462.4+365*24*3600*10,
+            geocent_time_max=1126259462.4+365*24*3600*20,
             source_priors=None,
             source_priors_params=None,
             spin_zero=True,
@@ -636,7 +649,7 @@ class LeR(LensGalaxyParameterDistribution):
         self.snr_bilby = gwsnr.compute_bilby_snr
         self.snr_calculator_dict["mtot_max"] = gwsnr.mtot_max
         self.snr_calculator_dict["psds"] = gwsnr.psds_list
-        #self.pdet = gwsnr.pdet
+        # self.pdet = gwsnr.pdet
 
     def store_ler_params(self, output_jsonfile="ler_params.json"):
         """
@@ -659,7 +672,6 @@ class LeR(LensGalaxyParameterDistribution):
             snr_finder=str(self.snr),
             json_file_names=str(self.json_file_names),
             interpolator_directory=str(self.interpolator_directory),
-            ler_directory=str(self.ler_directory),
         )
 
         # cbc params
@@ -719,7 +731,7 @@ class LeR(LensGalaxyParameterDistribution):
         output_jsonfile = output_jsonfile or self.json_file_names["unlensed_param"]
         self.json_file_names["unlensed_param"] = output_jsonfile
         output_path = os.path.join(self.ler_directory, output_jsonfile)
-        print(f"unlensed params will be store in {output_jsonfile}")
+        print(f"unlensed params will be store in {output_path}")
 
         # sampling in batches
         if resume and os.path.exists(output_path):
@@ -780,9 +792,14 @@ class LeR(LensGalaxyParameterDistribution):
         print("sampling gw source params...")
         unlensed_param = self.sample_gw_parameters(size=size)
         # Get all of the signal to noise ratios
-        print("calculating snrs...")
-        snrs = self.snr(gw_param_dict=unlensed_param)
-        unlensed_param.update(snrs)
+        if self.snr:
+            print("calculating snrs...")
+            snrs = self.snr(gw_param_dict=unlensed_param)
+            unlensed_param.update(snrs)
+        elif self.pdet:
+            print("calculating pdet...")
+            pdet = self.pdet(gw_param_dict=unlensed_param)
+            unlensed_param.update(pdet)
 
         # adding batches
         if not save_batch:
@@ -847,14 +864,15 @@ class LeR(LensGalaxyParameterDistribution):
         """
         
         # call self.json_file_names["ler_param"] and for adding the final results
-        data = load_json(self.ler_directory+"/"+self.json_file_names["ler_param"])
+        data = load_json(self.ler_directory+"/"+self.json_file_names["ler_params"])
         
         # get gw params from json file if not provided
         if unlensed_param is None:
             unlensed_param = self.json_file_names["unlensed_param"]
         if type(unlensed_param) == str:
             self.json_file_names["unlensed_param"] = unlensed_param
-            print(f"getting unlensed_params from json file {unlensed_param}...")
+            path_ = self.ler_directory+"/"+unlensed_param
+            print(f"getting unlensed_params from json file {path_}...")
             unlensed_param = get_param_from_json(self.ler_directory+"/"+unlensed_param)
         else:
             print("using provided unlensed_param dict...")
@@ -875,22 +893,25 @@ class LeR(LensGalaxyParameterDistribution):
             snrs = self.snr_bilby(gw_param_dict=unlensed_param)
             unlensed_param.update(snrs)
 
-        if detectability_condition == "step_function":
-            param = unlensed_param["optimal_snr_net"]
-            threshold = snr_threshold
-
-        elif detectability_condition == "pdet":
-            # check if pdet is provided in unlensed_param dict
-            if "pdet_net" in unlensed_param.keys():
+        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:
-                if "optimal_snr_net" in unlensed_param.keys():
-                    param = 1 - norm.cdf(snr_threshold - unlensed_param["optimal_snr_net"])
-                    unlensed_param["pdet_net"] = param
-                else:
-                    print("pdet or optimal_snr_net not provided in unlensed_param dict. Exiting...")
-                    return None
-            threshold = 0.5
+                raise ValueError("'pdet_net' not in unlensed parm dict provided")
 
         idx_detectable = param > threshold
         detectable_events = np.sum(idx_detectable)
@@ -910,18 +931,19 @@ class LeR(LensGalaxyParameterDistribution):
             output_jsonfile = self.json_file_names["unlensed_param_detectable"]
         else:
             self.json_file_names["unlensed_param_detectable"] = output_jsonfile
-        print(f"storing detectable unlensed params in {output_jsonfile}")
+        path_ = self.ler_directory+"/"+output_jsonfile
+        print(f"storing detectable unlensed params in {path_}")
         append_json(self.ler_directory+"/"+output_jsonfile, unlensed_param, replace=True)
 
         # write the results
         data["detectable_unlensed_rate_per_year"] = total_rate
         data["detectability_condition"] = detectability_condition
-        append_json(self.ler_directory+"/"+self.json_file_names["ler_param"], data, replace=True)
+        append_json(self.ler_directory+"/"+self.json_file_names["ler_params"], data, replace=True)
         
         return total_rate, unlensed_param
     
     def lensed_cbc_statistics(
-        self, size=None, save_batch=True, resume=False, output_jsonfile=None,
+        self, size=None, save_batch=False, resume=False, output_jsonfile=None,
     ):
         """
         Function to generate lensed GW source parameters. This function also stores the parameters in json file.
@@ -955,7 +977,7 @@ class LeR(LensGalaxyParameterDistribution):
         output_jsonfile = output_jsonfile or self.json_file_names["lensed_param"]
         self.json_file_names["lensed_param"] = output_jsonfile
         output_path = os.path.join(self.ler_directory, output_jsonfile)
-        print(f"lensed params will be store in {output_jsonfile}")
+        print(f"lensed params will be store in {output_path}")
 
         # sampling in batches
         if resume and os.path.exists(output_path):
@@ -1039,13 +1061,23 @@ class LeR(LensGalaxyParameterDistribution):
                 size = np.sum(idx)
                 
         # Get all of the signal to noise ratios
-        print("calculating snrs...")
-        snrs, lensed_param = self.get_lensed_snrs(
-            snr_calculator=self.snr,
-            list_of_detectors=self.list_of_detectors,
-            lensed_param=lensed_param,
-        )
-        lensed_param.update(snrs)
+        if self.snr:
+            print("calculating snrs...")
+            snrs, lensed_param = self.get_lensed_snrs(
+                lensed_param=lensed_param,
+                list_of_detectors=self.list_of_detectors,
+                snr_calculator=self.snr,
+            )
+            lensed_param.update(snrs)
+
+        elif self.pdet:
+            print("calculating pdet...")
+            pdet, lensed_param = self.get_lensed_snrs(
+                lensed_param=lensed_param,
+                list_of_detectors=self.list_of_detectors,
+                pdet_calculator=self.pdet,
+            )
+            lensed_param.update(pdet)
 
         # adding batches
         if not save_batch:
@@ -1118,14 +1150,15 @@ class LeR(LensGalaxyParameterDistribution):
         """
         
         # call self.json_file_names["ler_param"] and for adding the final results
-        data = load_json(self.ler_directory+"/"+self.json_file_names["ler_param"])
+        data = load_json(self.ler_directory+"/"+self.json_file_names["ler_params"])
 
         # get gw params from json file if not provided
         if lensed_param is None:
             lensed_param = self.json_file_names["lensed_param"]
         if type(lensed_param) == str:
             self.json_file_names["lensed_param"] = lensed_param
-            print(f"getting lensed_params from json file {lensed_param}...")
+            path_ = self.ler_directory+"/"+lensed_param
+            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...")
@@ -1180,55 +1213,66 @@ class LeR(LensGalaxyParameterDistribution):
             )
             lensed_param.update(snrs)
 
-        # from here, we focus on calculating the rate
-        if detectability_condition == "step_function":
-            if "optimal_snr_net" in lensed_param.keys():
+        if self.snr:
+            if "optimal_snr_net" not in lensed_param:
+                raise ValueError("'optimal_snr_net' not in lensed parm dict provided")
+            if detectability_condition == "step_function":
+                print("given detectability_condition == 'step_function'")
+                
+                if "optimal_snr_net" in lensed_param.keys():
+                    snr_param = lensed_param["optimal_snr_net"]
+                    snr_param = -np.sort(-snr_param, axis=1)  # sort snr in descending order
+                else:
+                    print("snr not provided in lensed_param dict. Exiting...")
+                    return None
+                snr_hit = np.full(len(snr_param), True)  # boolean array to store the result of the threshold condition
+                
+                # 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
+                for i in range(len(snr_threshold)):
+                    idx_max = idx_max + num_img[i]
+                    snr_hit = snr_hit & (np.sum((snr_param[:,j:idx_max] > snr_threshold[i]), axis=1) >= num_img[i])
+                    j = idx_max
+
+                # montecarlo integration
+                total_rate = self.normalization_pdf_z_lensed * np.sum(snr_hit)/total_events
+                print("total lensed rate (yr^-1) (with step function): {}".format(total_rate))
+            
+            elif detectability_condition == "pdet":
+                print("given detectability_condition == 'pdet'")
+                # pdet dimension is (size, n_max_images)
                 snr_param = lensed_param["optimal_snr_net"]
                 snr_param = -np.sort(-snr_param, axis=1)  # sort snr in descending order
-            else:
-                print("snr not provided in lensed_param dict. Exiting...")
-                return None
-            snr_hit = np.full(len(snr_param), True)  # boolean array to store the result of the threshold condition
-            
-            # 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
-            for i in range(len(snr_threshold)):
-                idx_max = idx_max + num_img[i]
-                snr_hit = snr_hit & (np.sum((snr_param[:,j:idx_max] > snr_threshold[i]), axis=1) >= num_img[i])
-                j = idx_max
 
-            # montecarlo integration
-            total_rate = self.normalization_pdf_z_lensed * np.sum(snr_hit)/total_events
-            print("total lensed rate (yr^-1) (with step function): {}".format(total_rate))
+                pdet = np.ones(np.shape(snr_param))
+                j = 0
+                idx_max = 0
+                for i in range(len(snr_threshold)):
+                    idx_max = idx_max + num_img[i]
+                    pdet[:,j:idx_max] = 1 - norm.cdf(snr_threshold[i] - snr_param[:,j:idx_max])
+                    j = idx_max
+
+                snr_hit = np.prod(pdet, axis=1)>0.5
+                # montecarlo integration
+                total_rate = self.normalization_pdf_z_lensed * np.sum(snr_hit)/total_events
+                print(f"total lensed rate (yr^-1) (with pdet function): {total_rate}")
 
-        elif detectability_condition == "pdet":
-            # check if pdet is provided in unlensed_param dict
+        elif self.pdet:
+            # check if pdet is provided in lensed_param dict
             if "pdet_net" in lensed_param.keys():
+                print("given detectability_condition == 'pdet'")
                 pdet = lensed_param["pdet_net"]
                 pdet = -np.sort(-pdet, axis=1)  # sort pdet in descending order
                 pdet = pdet[:,:np.sum(num_img)]  # use only num_img images
-            else:
-                if "optimal_snr_net" in lensed_param.keys():
-                    # pdet dimension is (size, n_max_images)
-                    snr_param = lensed_param["optimal_snr_net"]
-                    snr_param = -np.sort(-snr_param, axis=1)  # sort snr in descending order
 
-                    pdet = np.ones(np.shape(snr_param))
-                    j = 0
-                    idx_max = 0
-                    for i in range(len(snr_threshold)):
-                        idx_max = idx_max + num_img[i]
-                        pdet[:,j:idx_max] = 1 - norm.cdf(snr_threshold[i] - snr_param[:,j:idx_max])
-                        j = idx_max
-                else:
-                    print("pdet or optimal_snr_net not provided in lensed_param dict. Exiting...")
-                    return None
-                
-            snr_hit = np.prod(pdet, axis=1)>0.5
-            # montecarlo integration
-            total_rate = self.normalization_pdf_z_lensed * np.sum(snr_hit)/total_events
-            print(f"total lensed rate (yr^-1) (with pdet function): {total_rate}")
+                snr_hit = np.prod(pdet, axis=1)>0.5
+                # montecarlo integration
+                total_rate = self.normalization_pdf_z_lensed * np.sum(snr_hit)/total_events
+                print(f"total lensed rate (yr^-1) (with pdet function): {total_rate}")
+
+            else:
+                raise ValueError("'pdet_net' not in unlensed parm dict provided")
 
         print(f"number of simulated lensed detectable events: {np.sum(snr_hit)}")
         print(f"number of simulated all lensed events: {total_events}")
@@ -1245,13 +1289,14 @@ class LeR(LensGalaxyParameterDistribution):
             output_jsonfile = self.json_file_names["lensed_param_detectable"]
         else:
             self.json_file_names["lensed_param_detectable"] = output_jsonfile
-        print(f"storing detectable lensed params in {output_jsonfile}")
+        path_ = self.ler_directory+"/"+output_jsonfile
+        print(f"storing detectable lensed params in {path_}")
         append_json(self.ler_directory+"/"+output_jsonfile, lensed_param, replace=True)
 
         # write the results
         data["detectable_lensed_rate_per_year"] = total_rate
         data["detectability_condition"] = detectability_condition
-        append_json(self.ler_directory+"/"+self.json_file_names["ler_param"], data, replace=True)
+        append_json(self.ler_directory+"/"+self.json_file_names["ler_params"], data, replace=True)
 
         return total_rate, lensed_param
      
@@ -1277,19 +1322,19 @@ class LeR(LensGalaxyParameterDistribution):
         """
 
         # call json_file_ler_param and add the results
-        data = load_json(self.ler_directory+"/"+self.json_file_names["ler_param"])
+        data = load_json(self.ler_directory+"/"+self.json_file_names["ler_params"])
 
         try:
             unlensed_rate = data['detectable_unlensed_rate_per_year']
             lensed_rate = data['detectable_lensed_rate_per_year']
         except:
-            raise ValueError(f"detectable_unlensed_rate_per_year or 'detectable_lensed_rate_per_year' not found in {self.json_file_names['ler_param']} json file. Exiting...")
+            raise ValueError(f"detectable_unlensed_rate_per_year or 'detectable_lensed_rate_per_year' not found in {self.json_file_names['ler_params']} json file. Exiting...")
         
         rate_ratio = unlensed_rate / lensed_rate
         # append the results
         data['rate_ratio'] = rate_ratio
         # write the results
-        append_json(self.ler_directory+"/"+self.json_file_names["ler_param"], data, replace=True)
+        append_json(self.ler_directory+"/"+self.json_file_names["ler_params"], data, replace=True)
         
         print(f"unlensed_rate: {unlensed_rate}")
         print(f"lensed_rate: {lensed_rate}")
@@ -1356,7 +1401,7 @@ class LeR(LensGalaxyParameterDistribution):
         """
 
         # call json_file_ler_param and add the results
-        data = load_json(self.ler_directory+"/"+self.json_file_names["ler_param"])
+        data = load_json(self.ler_directory+"/"+self.json_file_names["ler_params"])
 
         # get unlensed rate
         unlensed_rate, unlensed_param = self.unlensed_rate(
@@ -1382,7 +1427,7 @@ class LeR(LensGalaxyParameterDistribution):
         data['rate_ratio'] = rate_ratio
         data['detectability_condition'] = detectability_condition
         # write the results
-        append_json(self.ler_directory+"/"+self.json_file_names["ler_param"], data, replace=True)
+        append_json(self.ler_directory+"/"+self.json_file_names["ler_params"], data, replace=True)
         
         print(f"unlensed_rate (per year): {unlensed_rate}")
         print(f"lensed_rate (per year): {lensed_rate}")
@@ -1458,7 +1503,7 @@ class LeR(LensGalaxyParameterDistribution):
                 events_total = 0
 
         buffer_file = self.ler_directory+"/"+"unlensed_params_buffer.json"
-        print("collected number of events = ", n)
+        print("collected number of detectable events = ", n)
         
         while n < size:
             # disable print statements
@@ -1489,7 +1534,7 @@ class LeR(LensGalaxyParameterDistribution):
             else:
                 append_json(file_name=meta_data_path, new_dictionary=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 unlensed rate (yr^-1): {total_rate}")
 
@@ -1594,7 +1639,7 @@ class LeR(LensGalaxyParameterDistribution):
         num_img = num_img[idx]
 
         buffer_file = self.ler_directory+"/"+"lensed_params_buffer.json"
-        print("collected number of events = ", n)
+        print("collected number of detectable events = ", n)
         # loop until n samples are collected
         while n < size:
             # disable print statements

{ler-0.3.4 → ler-0.3.6}/ler.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ler
-Version: 0.3.4
+Version: 0.3.6
 Summary: Gravitational waves Lensing Rates
 Home-page: https://github.com/hemantaph/ler
 Author: Hemantakumar

{ler-0.3.4 → ler-0.3.6}/ler.egg-info/requires.txt

@@ -6,7 +6,7 @@ numba>=0.57.1
 bilby>=1.0.2
 gwsnr>=0.2.0
 scipy>=1.9.0
-lenstronomy==1.10.4
+lenstronomy>=1.10.4
 astropy>=5.1
 tqdm>=4.64.1
 pointpats>=2.3

{ler-0.3.4 → ler-0.3.6}/setup.py

@@ -13,7 +13,7 @@ if python_version < (3, 10):
 
 setup(
     name="ler",
-    version="0.3.4",
+    version="0.3.6",
     description="Gravitational waves Lensing Rates",
     long_description=long_description,
     long_description_content_type='text/markdown',
@@ -32,7 +32,7 @@ setup(
         "bilby>=1.0.2",
         "gwsnr>=0.2.0",
         "scipy>=1.9.0",
-        "lenstronomy==1.10.4",
+        "lenstronomy>=1.10.4",
         "astropy>=5.1",
         "tqdm>=4.64.1",
         "pointpats>=2.3",