ler 0.3.9__py3-none-any.whl → 0.4.1__py3-none-any.whl

ler/__init__.py

@@ -2,19 +2,56 @@
 LeR
 """
 
-#import pycbc
+# mypackage/cli.py
+import argparse
+# import subprocess, os, sys, signal, warnings
+
+## import pycbc
+import os
 import multiprocessing as mp
 
-try:
-   mp.set_start_method('spawn', force=True)
-except RuntimeError:
-   pass
-#from . import rates, gw_source_population, lens_galaxy_population, image_properties, utils
+def set_multiprocessing_start_method():
+    if os.name == 'posix':  # posix indicates the program is run on Unix/Linux/Mac
+      print("Setting multiprocessing start method to 'fork'")
+      try:
+         mp.set_start_method('fork', force=True)
+      except RuntimeError:
+         # The start method can only be set once and must be set before any process starts
+         pass
+    else:
+      print("Setting multiprocessing start method to 'spawn'")
+      # For Windows and other operating systems, use 'spawn'
+      try:
+         mp.set_start_method('spawn', force=True)
+      except RuntimeError:
+         pass
+
+set_multiprocessing_start_method()
+
+# try:
+#    mp.set_start_method('fork', force=True)
+# except RuntimeError:
+#    pass
+
+# if sys.platform == 'darwin':
+#     HAVE_OMP = False
+
+#     # MacosX after python3.7 switched to 'spawn', however, this does not
+#     # preserve common state information which we have relied on when using
+#     # multiprocessing based pools.
+#     import multiprocessing
+#     if multiprocessing.get_start_method(allow_none=True) is None:
+#         if hasattr(multiprocessing, 'set_start_method'):
+#             multiprocessing.set_start_method('fork')
+#     elif multiprocessing.get_start_method() != 'fork':
+#         warnings.warn("PyCBC requires the use of the 'fork' start method for multiprocessing, it is currently set to {}".format(multiprocessing.get_start_method()))
+# else:
+#     HAVE_OMP = True
 
 __author__ = 'hemanta_ph <hemantaphurailatpam@gmail.com>'
 
 # The version as used in the setup.py
-__version__ = "0.3.9"
+__version__ = "0.4.1"
 
 # add __file__
 import os

ler/gw_source_population/cbc_source_parameter_distribution.py

@@ -58,8 +58,8 @@ class CBCSourceParameterDistribution(CBCSourceRedshiftDistribution):
         If True, spin parameters are completely ignore in the sampling.
         default: True
     spin_precession : `bool`
-        If spin_zero=True and spin_precession=True, spin parameters are sampled for precessing binaries.
-        if spin_zero=True and spin_precession=False, spin parameters are sampled for aligned/anti-aligned spin binaries.
+        If spin_zero=False and spin_precession=True, spin parameters are sampled for precessing binaries.
+        if spin_zero=False and spin_precession=False, spin parameters are sampled for aligned/anti-aligned spin binaries.
         default: False
     directory : `str`
         Directory to store the interpolator pickle files

ler/image_properties/image_properties.py

@@ -6,6 +6,8 @@ The class inherits from the CompactBinaryPopulation class, which is used to samp
 
 import warnings
 warnings.filterwarnings("ignore")
+import logging
+logging.getLogger('numexpr.utils').setLevel(logging.ERROR)
 # for multiprocessing
 from multiprocessing import Pool
 from tqdm import tqdm

ler/lens_galaxy_population/lens_galaxy_parameter_distribution.py

@@ -374,6 +374,8 @@ class LensGalaxyParameterDistribution(CBCSourceParameterDistribution, ImagePrope
             lens_model_list=["EPL_NUMBA", "SHEAR"],
         )
         input_params_image.update(params)
+
+        print("input_params_image", input_params_image)
         ImageProperties.__init__(
             self,
             npool=self.npool,

ler/rates/ler.py

@@ -6,14 +6,22 @@ This module contains the main class for calculating the rates of detectable grav
 import os
 import warnings
 warnings.filterwarnings("ignore")
+import logging
+logging.getLogger('numexpr.utils').setLevel(logging.ERROR)
 import contextlib
 import numpy as np
 from scipy.stats import norm
 from astropy.cosmology import LambdaCDM
 from ..lens_galaxy_population import LensGalaxyParameterDistribution
-from ..utils import load_json, append_json, get_param_from_json, batch_handler, add_dict_values
+from ..utils import load_json, append_json, get_param_from_json, batch_handler
 
 
+# # multiprocessing guard code
+# def main():
+#     obj = LeR()
+
+# if __name__ == '__main__':
+
 class LeR(LensGalaxyParameterDistribution):
     """Class to sample of lensed and unlensed events and calculate it's rates. Please note that parameters of the simulated events are stored in json file but not as an attribute of the class. This saves RAM memory. 
 
@@ -480,7 +488,7 @@ class LeR(LensGalaxyParameterDistribution):
         Function to print all the parameters.
         """
         # print all relevant functions and sampler priors
-        print("\n LeR set up params:")
+        print("\n # LeR set up params:")
         print(f'npool = {self.npool},')
         print(f'z_min = {self.z_min},')
         print(f'z_max = {self.z_max},')
@@ -493,23 +501,23 @@ class LeR(LensGalaxyParameterDistribution):
         if self.pdet:
             print(f'pdet_finder = {self.pdet},')
         print(f'json_file_names = {self.json_file_names},')
-        print(f'interpolator_directory = {self.interpolator_directory},')
-        print(f'ler_directory = {self.ler_directory},')
+        print(f"interpolator_directory = '{self.interpolator_directory}',")
+        print(f"ler_directory = '{self.ler_directory}',")
 
-        print("\n LeR also takes CBCSourceParameterDistribution class params as kwargs, as follows:")
+        print("\n # LeR also takes CBCSourceParameterDistribution class params as kwargs, as follows:")
         print(f"source_priors = {self.gw_param_sampler_dict['source_priors']},")
         print(f"source_priors_params = {self.gw_param_sampler_dict['source_priors_params']},")
         print(f"spin_zero = {self.gw_param_sampler_dict['spin_zero']},")
         print(f"spin_precession = {self.gw_param_sampler_dict['spin_precession']},")
         print(f"create_new_interpolator = {self.gw_param_sampler_dict['create_new_interpolator']},")
         
-        print("\n LeR also takes LensGalaxyParameterDistribution class params as kwargs, as follows:")
+        print("\n # LeR also takes LensGalaxyParameterDistribution class params as kwargs, as follows:")
         print(f"lens_type = '{self.gw_param_sampler_dict['lens_type']}',")
         print(f"lens_functions = {self.gw_param_sampler_dict['lens_functions']},")
         print(f"lens_priors = {self.gw_param_sampler_dict['lens_priors']},")
         print(f"lens_priors_params = {self.gw_param_sampler_dict['lens_priors_params']},")
         
-        print("\n LeR also takes ImageProperties class params as kwargs, as follows:")
+        print("\n # LeR also takes ImageProperties class params as kwargs, as follows:")
         print(f"n_min_images = {self.n_min_images},")
         print(f"n_max_images = {self.n_max_images},")
         print(f"geocent_time_min = {self.geocent_time_min},")
@@ -517,7 +525,7 @@ class LeR(LensGalaxyParameterDistribution):
         print(f"lens_model_list = {self.lens_model_list},")
         
         if self.gwsnr:
-            print("\n LeR also takes gwsnr.GWSNR params as kwargs, as follows:")
+            print("\n # LeR also takes gwsnr.GWSNR params as kwargs, as follows:")
             print(f"mtot_min = {self.snr_calculator_dict['mtot_min']},")
             print(f"mtot_max = {self.snr_calculator_dict['mtot_max']},")
             print(f"ratio_min = {self.snr_calculator_dict['ratio_min']},")
@@ -531,7 +539,6 @@ class LeR(LensGalaxyParameterDistribution):
             print(f"psds = {self.snr_calculator_dict['psds']},")
             print(f"ifos = {self.snr_calculator_dict['ifos']},")
             print(f"interpolator_dir = '{self.snr_calculator_dict['interpolator_dir']}',")
-            print(f"create_new_interpolator = {self.snr_calculator_dict['create_new_interpolator']},")
             print(f"gwsnr_verbose = {self.snr_calculator_dict['gwsnr_verbose']},")
             print(f"multiprocessing_verbose = {self.snr_calculator_dict['multiprocessing_verbose']},")
             print(f"mtot_cut = {self.snr_calculator_dict['mtot_cut']},")
@@ -712,6 +719,7 @@ class LeR(LensGalaxyParameterDistribution):
         # initialization of LensGalaxyParameterDistribution class
         # it also initializes the CBCSourceParameterDistribution and ImageProperties classes
         input_params = dict(
+            # LensGalaxyParameterDistribution class params
             z_min=self.z_min,
             z_max=self.z_max,
             cosmology=self.cosmo,
@@ -720,8 +728,13 @@ class LeR(LensGalaxyParameterDistribution):
             lens_functions= None,
             lens_priors=None,
             lens_priors_params=None,
+            # ImageProperties class params
+            n_min_images=2, 
+            n_max_images=4,
             geocent_time_min=1126259462.4,
             geocent_time_max=1126259462.4+365*24*3600*20,
+            lens_model_list=['EPL_NUMBA', 'SHEAR'],
+            # CBCSourceParameterDistribution class params
             source_priors=None,
             source_priors_params=None,
             spin_zero=True,
@@ -745,8 +758,11 @@ class LeR(LensGalaxyParameterDistribution):
             lens_functions=input_params["lens_functions"],
             lens_priors=input_params["lens_priors"],
             lens_priors_params=input_params["lens_priors_params"],
+            n_min_images=input_params["n_min_images"],
+            n_max_images=input_params["n_max_images"],
             geocent_time_min=input_params["geocent_time_min"],
             geocent_time_max=input_params["geocent_time_max"],
+            lens_model_list=input_params["lens_model_list"],
             source_priors=input_params["source_priors"],
             source_priors_params=input_params["source_priors_params"],
             spin_zero=input_params["spin_zero"],
@@ -792,6 +808,10 @@ class LeR(LensGalaxyParameterDistribution):
             gwsnr_verbose=False,
             multiprocessing_verbose=True,
             mtot_cut=True,
+            pdet=False,
+            snr_th=8.0,
+            snr_th_net=8.0,
+            ann_path_dict=None,
         )
         # if self.event_type == "BNS":
         #     input_params["mtot_max"]= 18.
@@ -819,6 +839,10 @@ class LeR(LensGalaxyParameterDistribution):
                     gwsnr_verbose=input_params["gwsnr_verbose"],
                     multiprocessing_verbose=input_params["multiprocessing_verbose"],
                     mtot_cut=input_params["mtot_cut"],
+                    pdet=input_params["pdet"],
+                    snr_th=input_params["snr_th"],
+                    snr_th_net=input_params["snr_th_net"],
+                    ann_path_dict=input_params["ann_path_dict"],
                 )
 
         self.snr = gwsnr.snr
@@ -909,36 +933,16 @@ class LeR(LensGalaxyParameterDistribution):
         output_path = os.path.join(self.ler_directory, output_jsonfile)
         print(f"unlensed params will be store in {output_path}")
 
-        # sampling in batches
-        if resume and os.path.exists(output_path):
-            # get sample from json file
-            self.dict_buffer = get_param_from_json(output_path)
-        else:
-            self.dict_buffer = None
-
-        batch_handler(
+        unlensed_param = batch_handler(
             size=size,
             batch_size=self.batch_size,
             sampling_routine=self.unlensed_sampling_routine,
             output_jsonfile=output_path,
             save_batch=save_batch,
             resume=resume,
+            param_name="unlensed parameters",
         )
 
-        if save_batch:
-            unlensed_param = get_param_from_json(output_path)
-        else:
-            # this if condition is required if there is nothing to save
-            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} ")
-                append_json(output_path, unlensed_param, replace=True)
-            else:
-                print("unlensed_params already sampled.")
-                unlensed_param = get_param_from_json(output_path)
-        self.dict_buffer = None  # save memory
-
         return unlensed_param
     
     def unlensed_sampling_routine(self, size, output_jsonfile, resume=False, save_batch=True):
@@ -978,17 +982,6 @@ class LeR(LensGalaxyParameterDistribution):
             pdet = self.pdet(gw_param_dict=unlensed_param)
             unlensed_param.update(pdet)
 
-        # adding batches
-        if not save_batch:
-            if self.dict_buffer is None:
-                self.dict_buffer = unlensed_param
-            else:
-                for key, value in unlensed_param.items():
-                    self.dict_buffer[key] = np.concatenate((self.dict_buffer[key], value))
-        else:
-            # store all params in json file
-            self.dict_buffer = append_json(file_name=output_jsonfile, new_dictionary=unlensed_param,  old_dictionary=self.dict_buffer, replace=not (resume))
-
         return unlensed_param
 
     def unlensed_rate(
@@ -1323,36 +1316,16 @@ class LeR(LensGalaxyParameterDistribution):
         output_path = os.path.join(self.ler_directory, output_jsonfile)
         print(f"lensed params will be store in {output_path}")
 
-        # sampling in batches
-        if resume and os.path.exists(output_path):
-            # get sample from json file
-            self.dict_buffer = get_param_from_json(output_path)
-        else:
-            self.dict_buffer = None
-
-        batch_handler(
+        lensed_param = batch_handler(
             size=size,
             batch_size=self.batch_size,
             sampling_routine=self.lensed_sampling_routine,
             output_jsonfile=output_path,
             save_batch=save_batch,
             resume=resume,
+            param_name="lensed parameters",
         )
 
-        if save_batch:
-            lensed_param = get_param_from_json(output_path)
-        else:
-            # this if condition is required if there is nothing to save
-            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} ")
-                append_json(output_path, lensed_param, replace=True)
-            else:
-                print("lensed_params already sampled.")
-                lensed_param = get_param_from_json(output_path)
-        self.dict_buffer = None  # save memory
-
         return lensed_param
     
     def lensed_sampling_routine(self, size, output_jsonfile, save_batch=True, resume=False):
@@ -1382,6 +1355,8 @@ class LeR(LensGalaxyParameterDistribution):
         print("sampling lensed params...")
         lensed_param = {}
 
+        # Some of the sample lensed events may not satisfy the strong lensing condition
+        # In that case, we will resample those events and replace the values with the corresponding indices
         while True:
             # get lensed params
             lensed_param_ = self.sample_lens_parameters(size=size)
@@ -1425,17 +1400,6 @@ class LeR(LensGalaxyParameterDistribution):
             )
             lensed_param.update(pdet)
 
-        # adding batches
-        if not save_batch:
-            if self.dict_buffer is None:
-                self.dict_buffer = lensed_param
-            else:
-                for key, value in lensed_param.items():
-                    self.dict_buffer[key] = np.concatenate((self.dict_buffer[key], value))
-        else:
-            # store all params in json file
-            self.dict_buffer = append_json(file_name=output_jsonfile, new_dictionary=lensed_param,  old_dictionary=self.dict_buffer, replace=not (resume))
-
         return lensed_param
 
     def lensed_rate(
@@ -1447,6 +1411,8 @@ class LeR(LensGalaxyParameterDistribution):
         output_jsonfile=None,
         nan_to_num=True,
         detectability_condition="step_function",
+        combine_image_snr=False,
+        snr_cut_for_combine_image_snr=4.0,
         snr_recalculation=False,
         snr_threshold_recalculation=[[4,4], [20,20]],
     ):
@@ -1519,7 +1485,8 @@ class LeR(LensGalaxyParameterDistribution):
         if snr_recalculation:
             lensed_param = self._recalculate_snr_lensed(lensed_param, snr_threshold_recalculation, num_img, total_events)
 
-        snr_hit = self._find_detectable_index_lensed(lensed_param, snr_threshold, pdet_threshold, num_img, detectability_condition)
+        # find index of detectable events
+        snr_hit = self._find_detectable_index_lensed(lensed_param, snr_threshold, pdet_threshold, num_img, detectability_condition, combine_image_snr=combine_image_snr, snr_cut_for_combine_image_snr=snr_cut_for_combine_image_snr)
 
         # montecarlo integration
         total_rate = self.rate_function(np.sum(snr_hit), total_events, param_type="lensed")
@@ -1619,7 +1586,7 @@ class LeR(LensGalaxyParameterDistribution):
 
         return lensed_param
 
-    def _find_detectable_index_lensed(self, lensed_param, snr_threshold, pdet_threshold, num_img, detectability_condition):
+    def _find_detectable_index_lensed(self, lensed_param, snr_threshold, pdet_threshold, num_img, detectability_condition, combine_image_snr=False, snr_cut_for_combine_image_snr=4.0):
         """
         Helper function to find the index of detectable events based on SNR or p_det.
 
@@ -1655,18 +1622,24 @@ class LeR(LensGalaxyParameterDistribution):
             snr_param = -np.sort(-snr_param, axis=1)  # sort snr in descending order
             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 
-            # algorithm: 
-            # i) consider snr_threshold=[8,6] and num_img=[2,1] and first row of snr_param[0]=[12,8,6,1]. Note that the snr_param is sorted in descending order.
-            # ii) for loop runs wrt snr_threshold. idx_max = idx_max + num_img[i]
-            # iii) First iteration: snr_threshold=8 and num_img=2. In snr_param, column index 0 and 1 (i.e. 0:num_img[0]) are considered. The sum of snr_param[0, 0:2] > 8 is checked. If True, then snr_hit = True. 
-            # v) Second iteration: snr_threshold=6 and num_img=1. In snr_param, column index 2 (i.e. num_img[0]:num_img[1]) is considered. The sum of snr_param[0, 0:1] > 6 is checked. If True, then snr_hit = True.
-            j = 0
-            idx_max = 0
-            for i, snr_th in enumerate(snr_threshold):
-                idx_max = idx_max + num_img[i]
-                snr_hit = snr_hit & (np.sum((snr_param[:,j:idx_max] > snr_th), axis=1) >= num_img[i])
-                j = idx_max
+            if not combine_image_snr:
+                # 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 
+                # algorithm: 
+                # i) consider snr_threshold=[8,6] and num_img=[2,1] and first row of snr_param[0]=[12,8,6,1]. Note that the snr_param is sorted in descending order.
+                # ii) for loop runs wrt snr_threshold. idx_max = idx_max + num_img[i]
+                # iii) First iteration: snr_threshold=8 and num_img=2. In snr_param, column index 0 and 1 (i.e. 0:num_img[0]) are considered. The sum of snr_param[0, 0:2] > 8 is checked. If True, then snr_hit = True. 
+                # v) Second iteration: snr_threshold=6 and num_img=1. In snr_param, column index 2 (i.e. num_img[0]:num_img[1]) is considered. The sum of snr_param[0, 0:1] > 6 is checked. If True, then snr_hit = True.
+                j = 0
+                idx_max = 0
+                for i, snr_th in enumerate(snr_threshold):
+                    idx_max = idx_max + num_img[i]
+                    snr_hit = snr_hit & (np.sum((snr_param[:,j:idx_max] > snr_th), axis=1) >= num_img[i])
+                    j = idx_max
+            else:
+                # sqrt of the the sum of the squares of the snr of the images
+                snr_param[snr_param<snr_cut_for_combine_image_snr] = 0.0 # images with snr below snr_cut_for_combine_image_snr are not considered 
+                snr_param = np.sqrt(np.sum(snr_param[:,:np.sum(num_img)]**2, axis=1))
+                snr_hit = snr_param >= snr_threshold[0]
                 
         elif detectability_condition == "pdet":
             if "pdet_net" not in lensed_param:
@@ -1705,6 +1678,8 @@ class LeR(LensGalaxyParameterDistribution):
         lensed_param=None,
         snr_threshold_lensed=[8.0,8.0],
         num_img=[1,1],
+        combine_image_snr=False,
+        snr_cut_for_combine_image_snr=4.0,
         output_jsonfile_lensed=None,
         nan_to_num=True,
         detectability_condition="step_function",
@@ -1779,6 +1754,8 @@ class LeR(LensGalaxyParameterDistribution):
             output_jsonfile=output_jsonfile_lensed,
             nan_to_num=nan_to_num,
             detectability_condition=detectability_condition,
+            combine_image_snr=combine_image_snr,
+            snr_cut_for_combine_image_snr=snr_cut_for_combine_image_snr,
         )
         # calculate rate ratio
         rate_ratio = self.rate_ratio()
@@ -1893,7 +1870,7 @@ class LeR(LensGalaxyParameterDistribution):
         """
 
         # initial setup
-        n, events_total, output_path, meta_data_path, buffer_file = self._initial_setup_for_n_event_selection(meta_data_file, output_jsonfile, resume, batch_size)
+        n, events_total, output_path, meta_data_path, buffer_file, batch_size = self._initial_setup_for_n_event_selection(meta_data_file, output_jsonfile, resume, batch_size)
 
         # loop until n samples are collected
         while n < size:
@@ -1953,6 +1930,8 @@ class LeR(LensGalaxyParameterDistribution):
         snr_threshold=[8.0,8.0],
         pdet_threshold=0.5,
         num_img=[1,1],
+        combine_image_snr=False,
+        snr_cut_for_combine_image_snr=4.0,
         resume=False,
         detectability_condition="step_function",
         output_jsonfile="n_lensed_params_detectable.json",
@@ -2021,7 +2000,7 @@ class LeR(LensGalaxyParameterDistribution):
         """
 
         # initial setup
-        n, events_total, output_path, meta_data_path, buffer_file = self._initial_setup_for_n_event_selection(meta_data_file, output_jsonfile, resume, batch_size)
+        n, events_total, output_path, meta_data_path, buffer_file, batch_size = self._initial_setup_for_n_event_selection(meta_data_file, output_jsonfile, resume, batch_size)
 
         # re-analyse the provided snr_threshold and num_img
         snr_threshold, num_img = self._check_snr_threshold_lensed(snr_threshold, num_img)
@@ -2041,7 +2020,7 @@ class LeR(LensGalaxyParameterDistribution):
             if snr_recalculation:
                 lensed_param = self._recalculate_snr_lensed(lensed_param, snr_threshold_recalculation, num_img, total_events_in_this_iteration)
 
-            snr_hit = self._find_detectable_index_lensed(lensed_param, snr_threshold, pdet_threshold, num_img, detectability_condition)
+            snr_hit = self._find_detectable_index_lensed(lensed_param, snr_threshold, pdet_threshold, num_img, detectability_condition, combine_image_snr=combine_image_snr, snr_cut_for_combine_image_snr=snr_cut_for_combine_image_snr)
                     
             # store all params in json file
             self._save_detectable_params(output_jsonfile, lensed_param, snr_hit, key_file_name="n_lensed_detectable_events", nan_to_num=nan_to_num, verbose=False, replace_jsonfile=False)
@@ -2118,6 +2097,8 @@ class LeR(LensGalaxyParameterDistribution):
         if not resume:
             n = 0  # iterator
             events_total = 0
+            # the following file will be removed if it exists
+            print(f"removing {output_path} and {meta_data_path} if they exist")
             if os.path.exists(output_path):
                 os.remove(output_path)
             if os.path.exists(meta_data_path):
@@ -2136,7 +2117,7 @@ class LeR(LensGalaxyParameterDistribution):
         buffer_file = "params_buffer.json"
         print("collected number of detectable events = ", n)
 
-        return n, events_total, output_path, meta_data_path, buffer_file
+        return n, events_total, output_path, meta_data_path, buffer_file, batch_size
 
     def _trim_results_to_size(self, size, output_path, meta_data_path, param_type="unlensed"):
         """

ler/utils/utils.py

@@ -125,7 +125,7 @@ def append_json(file_name, new_dictionary, old_dictionary=None, replace=False):
 
     # start = datetime.datetime.now()
     if not replace:
-        data = add_dict_values(data, new_dictionary)
+        data = add_dictionaries_together(data, new_dictionary)
         # data_key = data.keys()
         # for key, value in new_dictionary.items():
         #     if key in data_key:
@@ -143,25 +143,25 @@ def append_json(file_name, new_dictionary, old_dictionary=None, replace=False):
 
     return data
 
-def add_dict_values(dict1, dict2):
-    """Adds the values of two dictionaries together.
+# def add_dict_values(dict1, dict2):
+#     """Adds the values of two dictionaries together.
     
-    Parameters
-    ----------
-    dict1 : `dict`
-        dictionary to be added.
-    dict2 : `dict`
-        dictionary to be added.
+#     Parameters
+#     ----------
+#     dict1 : `dict`
+#         dictionary to be added.
+#     dict2 : `dict`
+#         dictionary to be added.
 
-    Returns
-    ----------
-    dict1 : `dict`
-        dictionary with added values.
-    """
-    data_key = dict1.keys()
-    for key, value in dict2.items():
-        if key in data_key:
-            dict1[key] = np.concatenate((dict1[key], value))
+#     Returns
+#     ----------
+#     dict1 : `dict`
+#         dictionary with added values.
+#     """
+#     data_key = dict1.keys()
+#     for key, value in dict2.items():
+#         if key in data_key:
+#             dict1[key] = np.concatenate((dict1[key], value))
 
     return dict1
 
@@ -315,13 +315,33 @@ def add_dictionaries_together(dictionary1, dictionary2):
     if dictionary1.keys() != dictionary2.keys():
         raise ValueError("The dictionaries have different keys.")
     for key in dictionary1.keys():
-        # Check if the item is an ndarray
-        if isinstance(dictionary1[key], np.ndarray):
-            dictionary[key] = np.concatenate((dictionary1[key], dictionary2[key]))
-        elif isinstance(dictionary1[key], list):
-            dictionary[key] = dictionary1[key] + dictionary2[key]
-        # Check if the item is a nested dictionary
-        elif isinstance(dictionary1[key], dict):
+        value1 = dictionary1[key]
+        value2 = dictionary2[key]
+
+        # check if the value is empty
+        bool0 = len(value1) == 0 or len(value2) == 0
+        # check if the value is an ndarray or a list
+        bool1 = isinstance(value1, np.ndarray) and isinstance(value2, np.ndarray)
+        bool2 = isinstance(value1, list) and isinstance(value2, list)
+        bool3 = isinstance(value1, np.ndarray) and isinstance(value2, list)
+        bool4 = isinstance(value1, list) and isinstance(value2, np.ndarray)
+        bool4 = bool4 or bool3
+        bool5 = isinstance(value1, dict) and isinstance(value2, dict)
+
+        if bool0:
+            if len(value1) == 0 and len(value2) == 0:
+                dictionary[key] = np.array([])
+            elif len(value1) != 0 and len(value2) == 0:
+                dictionary[key] = np.array(value1)
+            elif len(value1) == 0 and len(value2) != 0:
+                dictionary[key] = np.array(value2)
+        elif bool1:
+            dictionary[key] = np.concatenate((value1, value2))
+        elif bool2:
+            dictionary[key] = value1 + value2
+        elif bool4:
+            dictionary[key] = np.concatenate((np.array(value1), np.array(value2)))
+        elif bool5:
             dictionary[key] = add_dictionaries_together(
                 dictionary1[key], dictionary2[key]
             )
@@ -370,9 +390,9 @@ def create_func_pdf_invcdf(x, y, category="function"):
     Parameters
     ----------
     x : `numpy.ndarray`
-        x values.
+        x values. This has to sorted in ascending order.
     y : `numpy.ndarray`
-        y values.
+        y values. Corresponding to the x values.
     category : `str`, optional
         category of the function. Default is "function". Other options are "function_inverse", "pdf" and "inv_cdf".
 
@@ -853,8 +873,7 @@ def inverse_transform_sampler(size, cdf, x):
     samples = y0 + (y1 - y0) * (u - x0) / (x1 - x0)
     return samples
 
-def batch_handler(size, batch_size, sampling_routine, output_jsonfile, save_batch=True, resume=False,
-    ):
+def batch_handler(size, batch_size, sampling_routine, output_jsonfile, save_batch=True, resume=False, param_name='parameters'):
     """
     Function to run the sampling in batches.
 
@@ -865,14 +884,28 @@ def batch_handler(size, batch_size, sampling_routine, output_jsonfile, save_batc
     batch_size : `int`
         batch size.
     sampling_routine : `function`
-        function to sample the parameters.
-        e.g. unlensed_sampling_routine() or lensed_sampling_routine()
+        sampling function. It should have 'size' as input and return a dictionary.
     output_jsonfile : `str`
-        name of the json file to store the parameters.
-    resume : `bool`
-        if True, it will resume the sampling from the last batch.
-        default resume = False.
+        json file name for storing the parameters.
+    save_batch : `bool`, optional
+        if True, save sampled parameters in each iteration. Default is True.
+    resume : `bool`, optional
+        if True, resume sampling from the last batch. Default is False.
+    param_name : `str`, optional
+        name of the parameter. Default is 'parameters'.
+
+    Returns
+    ----------
+    dict_buffer : `dict`
+        dictionary of parameters.
     """
+
+    # sampling in batches
+    if resume and os.path.exists(output_jsonfile):
+        # get sample from json file
+        dict_buffer = get_param_from_json(output_jsonfile)
+    else:
+        dict_buffer = None
     
     # if size is multiple of batch_size
     if size % batch_size == 0:
@@ -895,69 +928,90 @@ def batch_handler(size, batch_size, sampling_routine, output_jsonfile, save_batc
     track_batches = 0  # to track the number of batches
 
     if not resume:
-        track_batches = track_batches + 1
-        print(f"Batch no. {track_batches}")
-        # new first batch with the frac_batches
-        sampling_routine(size=frac_batches, save_batch=save_batch, output_jsonfile=output_jsonfile);
+        # create new first batch with the frac_batches
+        track_batches, dict_buffer = create_batch_params(sampling_routine, frac_batches, dict_buffer, save_batch, output_jsonfile, track_batches=track_batches)
     else:
         # check where to resume from
+        # identify the last batch and assign current batch number
+        # try-except is added to avoid the error when the file does not exist or if the file is empty or corrupted or does not have the required key.
         try:
             print(f"resuming from {output_jsonfile}")
-            with open(output_jsonfile, "r", encoding="utf-8") as f:
-                data = json.load(f)
-                track_batches = (len(data["zs"]) - frac_batches) // batch_size + 1
+            len_ = len(list(dict_buffer.values())[0])
+            track_batches = (len_ - frac_batches) // batch_size + 1
         except:
-            track_batches = track_batches + 1
-            print(f"Batch no. {track_batches}")
-            # new first batch with the frac_batches
-            sampling_routine(size=frac_batches,  save_batch=save_batch, output_jsonfile=output_jsonfile);
+            # create new first batch with the frac_batches
+            track_batches, dict_buffer = create_batch_params(sampling_routine, frac_batches, dict_buffer, save_batch, output_jsonfile, track_batches=track_batches)
 
-    # ---------------------------------------------------#
+    # loop over the remaining batches
     min_, max_ = track_batches, num_batches
-    for i in range(min_, max_):
-        track_batches = track_batches + 1
-        print(f"Batch no. {track_batches}")
-        sampling_routine(size=batch_size, save_batch=save_batch, output_jsonfile=output_jsonfile, resume=True);
-    # ---------------------------------------------------#
-
-    return None
+    # print(f"min_ = {min_}, max_ = {max_}")
+    save_param = False
+    if min_ == max_:
+        print(f"{param_name} already sampled.")
+    elif min_ > max_:
+        len_ = len(list(dict_buffer.values())[0])
+        print(f"existing {param_name} size is {len_} is more than the required size={size}. It will be trimmed.")
+        dict_buffer = trim_dictionary(dict_buffer, size)
+        save_param = True
+    else:
+        for i in range(min_, max_):
+            _, dict_buffer = create_batch_params(sampling_routine, batch_size, dict_buffer, save_batch, output_jsonfile, track_batches=i, resume=True)
+
+        if save_batch:
+            # if save_batch=True, then dict_buffer is only the last batch
+            dict_buffer = get_param_from_json(output_jsonfile)
+        else:  # dont save in batches
+            # this if condition is required if there is nothing to save
+            save_param = True
+    
+    if save_param:
+        # store all params in json file
+        print(f"saving all {param_name} in {output_jsonfile} ")
+        append_json(output_jsonfile, dict_buffer, replace=True)
 
-# def batch_handler(size, batch_size, sampling_routine, output_jsonfile, save_batch=True, resume=False):
-#     """
-#     Function to run the sampling in batches.
+    return dict_buffer
 
-#     Parameters
-#     ----------
-#     size : `int`
-#         number of samples.
-#     batch_size : `int`
-#         batch size.
-#     sampling_routine : `function`
-#         function to sample the parameters.
-#         e.g. unlensed_sampling_routine() or lensed_sampling_routine()
-#     output_jsonfile : `str`
-#         name of the json file to store the parameters.
-#     resume : `bool`
-#         if True, it will resume the sampling from the last batch.
-#         default resume = False.
-#     """
+def create_batch_params(sampling_routine, frac_batches, dict_buffer, save_batch, output_jsonfile, track_batches, resume=False):
+    """
+    Helper function to batch_handler. It create batch parameters and store in a dictionary.
 
-#     num_batches = (size + batch_size - 1) // batch_size
-#     print(f"Chosen batch size = {batch_size} with total size = {size}")
-#     print(f"There will be {num_batches} batch(es)")
+    Parameters
+    ----------
+    sampling_routine : `function`
+        sampling function. It should have 'size' as input and return a dictionary.
+    frac_batches : `int`
+        batch size.
+    dict_buffer : `dict`
+        dictionary of parameters.
+    save_batch : `bool`
+        if True, save sampled parameters in each iteration.
+    output_jsonfile : `str`
+        json file name for storing the parameters.
+    track_batches : `int`
+        track the number of batches.
+    resume : `bool`, optional
+        if True, resume sampling from the last batch. Default is False.
 
-#     if not resume:
-#         first_batch_size = size % batch_size or batch_size
-#     else:
-#         with open(output_jsonfile, "r", encoding="utf-8") as f:
-#             data = json.load(f)
-#             first_batch_size = len(data["zs"]) % batch_size or batch_size
+    Returns
+    ----------
+    track_batches : `int`
+        track the number of batches.
+    """
 
-#     for batch_num in range(1, num_batches + 1):
-#         print(f"Batch no. {batch_num}")
-#         current_batch_size = first_batch_size if batch_num == 1 else batch_size
-#         sampling_routine(size=current_batch_size, output_jsonfile=output_jsonfile, resume=resume, save_batch=save_batch)
-#         resume = True  # Resume for subsequent batches
+    track_batches = track_batches + 1
+    print(f"Batch no. {track_batches}")
+    param = sampling_routine(size=frac_batches, save_batch=save_batch, output_jsonfile=output_jsonfile, resume=resume)
 
-#     return None
+    # adding batches and hold it in the buffer attribute.
+    if not save_batch:
+        # in the new batch (new sampling run), dict_buffer will be None
+        if dict_buffer is None:
+            dict_buffer = param
+        else:
+            for key, value in param.items():
+                dict_buffer[key] = np.concatenate((dict_buffer[key], value))
+    else:
+        # store all params in json file
+        dict_buffer = append_json(file_name=output_jsonfile, new_dictionary=param,  old_dictionary=dict_buffer, replace=not (resume))
 
+    return track_batches, dict_buffer

{ler-0.3.9.dist-info → ler-0.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ler
-Version: 0.3.9
+Version: 0.4.1
 Summary: Gravitational waves Lensing Rates
 Home-page: https://github.com/hemantaph/ler
 Author: Hemantakumar
@@ -9,20 +9,20 @@ License: MIT
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: setuptools >=65.5.0
-Requires-Dist: matplotlib >=3.4.2
-Requires-Dist: pycbc >=1.18.0
-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.14.0
-Requires-Dist: lenstronomy >=1.10.4
-Requires-Dist: astropy >=5.1
-Requires-Dist: tqdm >=4.64.1
-Requires-Dist: pointpats >=2.3
-Requires-Dist: shapely >=2.0.1
-Requires-Dist: gwcosmo
+Requires-Dist: setuptools>=65.5.0
+Requires-Dist: matplotlib>=3.4.2
+Requires-Dist: pycbc>=2.0.4
+Requires-Dist: numpy>=1.18
+Requires-Dist: numba>=0.57.1
+Requires-Dist: bilby>=1.0.2
+Requires-Dist: gwsnr>=0.3.2
+Requires-Dist: scipy<1.14.0
+Requires-Dist: lenstronomy>=1.10.4
+Requires-Dist: astropy>=5.1
+Requires-Dist: tqdm>=4.64.1
+Requires-Dist: pointpats>=2.3
+Requires-Dist: shapely>=2.0.1
+Requires-Dist: gwcosmo==2.1.0
 
 # LeR
 [![DOI](https://zenodo.org/badge/626733473.svg)](https://zenodo.org/badge/latestdoi/626733473) [![PyPI version](https://badge.fury.io/py/ler.svg)](https://badge.fury.io/py/ler) [![DOCS](https://readthedocs.org/projects/ler/badge/?version=latest)](https://ler.readthedocs.io/en/latest/)

{ler-0.3.9.dist-info → ler-0.4.1.dist-info}/RECORD

@@ -1,25 +1,25 @@
-ler/__init__.py,sha256=qHG43pWB__gD_SrSbq0Ncvt0PwdQC2Dx3MzGgNAn6ls,804
+ler/__init__.py,sha256=aC-PEncn43TwcmsVQdUYivq0I8ylmw8wKclBoEWVQv4,2174
 ler/gw_source_population/__init__.py,sha256=HG0ve5wTpBDN2fNMxHLnoOqTz-S0jXM_DsWEJ5PEHAw,126
-ler/gw_source_population/cbc_source_parameter_distribution.py,sha256=e0-Sqcx7WblWkqX1WQg6sCzrpMbkQ5tUcMu9sbBcp9Y,67455
+ler/gw_source_population/cbc_source_parameter_distribution.py,sha256=6rKmyX6DLawgXsgbrjLHN_Mgd1j5QcaMHFHEIHVLHh0,67457
 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=QmZ27y4CFR-DvzBxJewgaH3kEAXW6UDPxbyI7zwjdP4,25302
+ler/image_properties/image_properties.py,sha256=A6PDoeK28C1zKLgOjLAfPqo8CFROaHK4OdbvI34j_hM,25376
 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=_o_kaIIqps9i-5RYQ8PIaofblAwTBSIokjYPEbo1Rh4,48278
+ler/lens_galaxy_population/lens_galaxy_parameter_distribution.py,sha256=8dj1hoef_cjkb7tbXwR2pyUl_Tyyel_Ze3OAJ4DTUBw,48335
 ler/lens_galaxy_population/mp.py,sha256=TPnFDEzojEqJzE3b0g39emZasHeeaeXN2q7JtMcgihk,6387
 ler/lens_galaxy_population/optical_depth.py,sha256=rZ_Inpw7ChpFdDLp3kJrCmA0PL3RxN6T_W_NTFhj_ko,42542
 ler/rates/__init__.py,sha256=N4li9NouSVjZl5HIhyuiKKRyrpUgQkBZaUeDgL1m4ic,43
 ler/rates/gwrates.py,sha256=akw6rKAkETr_ERmymVJx3APRXs0XqqFccZ-LIzAV4jM,58465
 ler/rates/ler copy.py,sha256=BlnGlRISUwiWUhUNwp32_lvh7tHdT-d1VDhFelwKO_c,101873
-ler/rates/ler.py,sha256=pBFTeYlranu5A81yENC3lUC5ebalUmr-g8neyWJUhgk,106112
+ler/rates/ler.py,sha256=LlpUJKw5KkPacz_mm5voLDLqLkmr8FD4bQ68jcQeSqY,105771
 ler/utils/__init__.py,sha256=JWF9SKoqj1BThpV_ynfoyUeU06NQQ45DHCUGaaMSp_8,42
 ler/utils/plots.py,sha256=uq-usKRnEymtOSAPeHFOfMQW1XX76_WP2aBkT40RvLo,15664
-ler/utils/utils.py,sha256=HzRgpDjxXqaZ0jUjYU79IRzaFFK66rAhNAoqXdUHJJo,28976
-ler-0.3.9.dist-info/LICENSE,sha256=9LeXXC3WaHBpiUGhLVgOVnz0F12olPma1RX5zgpfp8Q,1081
-ler-0.3.9.dist-info/METADATA,sha256=G7PYS2UakhDt_JADHG269abUUsCwV_-afUf6IzlCSQA,6521
-ler-0.3.9.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-ler-0.3.9.dist-info/top_level.txt,sha256=VWeWLF_gNMjzquGmqrLXqp2J5WegY86apTUimMTh68I,4
-ler-0.3.9.dist-info/RECORD,,
+ler/utils/utils.py,sha256=45fdEJ6B125kCp_lXl3IFulY61hKyOX1JewSQ_LLQSU,31464
+ler-0.4.1.dist-info/LICENSE,sha256=9LeXXC3WaHBpiUGhLVgOVnz0F12olPma1RX5zgpfp8Q,1081
+ler-0.4.1.dist-info/METADATA,sha256=nmop_EQhbQPN2M6_ISxap_6LUvSA1i2BFkA0T5ob4Sk,6514
+ler-0.4.1.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+ler-0.4.1.dist-info/top_level.txt,sha256=VWeWLF_gNMjzquGmqrLXqp2J5WegY86apTUimMTh68I,4
+ler-0.4.1.dist-info/RECORD,,

{ler-0.3.9.dist-info → ler-0.4.1.dist-info}/WHEEL

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