ler 0.4.0__tar.gz → 0.4.2__tar.gz

{ler-0.4.0 → ler-0.4.2}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: ler
-Version: 0.4.0
-Summary: Gravitational waves Lensing Rates
+Version: 0.4.2
+Summary: LVK (LIGO-Virgo-KAGRA collaboration) Event (compact-binary mergers) Rate calculator and simulator
 Home-page: https://github.com/hemantaph/ler
 Author: Hemantakumar
 Author-email: hemantaphurailatpam@gmail.com

ler-0.4.2/ler/__init__.py

@@ -0,0 +1,68 @@
+"""
+LeR
+"""
+
+# mypackage/cli.py
+import argparse
+# import subprocess, os, sys, signal, warnings
+
+## import pycbc
+import os
+import multiprocessing as mp
+
+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.4.2"
+
+# add __file__
+import os
+__file__ = os.path.abspath(__file__)
+
+from . import rates, gw_source_population, lens_galaxy_population, image_properties, utils
+
+from .rates import ler, gwrates
+from .gw_source_population import cbc_source_parameter_distribution, cbc_source_redshift_distribution
+from .lens_galaxy_population import lens_galaxy_parameter_distribution, optical_depth
+from .image_properties import image_properties
+from .utils import utils, plots
+
+

{ler-0.4.0 → ler-0.4.2}/ler/gw_source_population/cbc_source_parameter_distribution.py

@@ -46,7 +46,7 @@ class CBCSourceParameterDistribution(CBCSourceRedshiftDistribution):
         Dictionary of prior sampler functions and its input parameters.
         Check for available priors and corresponding input parameters by running,
         >>> from ler.gw_source_population import CBCSourceParameterDistribution
-        >>> cbc = CompactBinaryPopulation()
+        >>> cbc = CBCSourceParameterDistribution()
         >>> cbc.available_gw_prior_list_and_its_params()
         # To check the current chosen priors and its parameters, run,
         >>> print("default priors=",cbc.gw_param_samplers)
@@ -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
@@ -77,7 +77,7 @@ class CBCSourceParameterDistribution(CBCSourceRedshiftDistribution):
 
     Instance Attributes
     ----------
-    CompactBinaryPopulation has the following instance attributes:\n
+    CBCSourceParameterDistribution has the following instance attributes:\n
     +-------------------------------------+----------------------------------+
     | Atrributes                          | Type                             |
     +=====================================+==================================+
@@ -114,7 +114,7 @@ class CBCSourceParameterDistribution(CBCSourceRedshiftDistribution):
 
     Instance Methods
     ----------
-    CompactBinaryPopulation has the following instance methods:\n
+    CBCSourceParameterDistribution has the following instance methods:\n
     +-------------------------------------+----------------------------------+
     | Methods                             | Type                             |
     +=====================================+==================================+
@@ -1136,7 +1136,7 @@ class CBCSourceParameterDistribution(CBCSourceRedshiftDistribution):
         Examples
         ----------
         >>> from ler.gw_source_population import CBCSourceParameterDistribution
-        >>> cbc = CompactBinaryPopulation()
+        >>> cbc = CBCSourceParameterDistribution()
         >>> priors = cbc.available_gw_prior_list_and_its_params
         >>> priors.keys()  # type of priors
         dict_keys(['merger_rate_density', 'source_frame_masses', 'spin', 'geocent_time', 'ra', 'phase', 'psi', 'theta_jn'])

{ler-0.4.0 → ler-0.4.2}/ler/gw_source_population/cbc_source_redshift_distribution.py

@@ -25,7 +25,7 @@ from .jit_functions import merger_rate_density_bbh_popI_II_oguri2018, star_forma
 
 class CBCSourceRedshiftDistribution(object):
     """Class to generate a population of source galaxies.
-    This class is inherited by :class:`~ler.ler.CompactBinaryPopulation` and :class:`~ler.ler.LensGalaxyParameterDistribution` class.
+    This class is inherited by :class:`~ler.ler.CBCSourceParameterDistribution` and :class:`~ler.ler.LensGalaxyParameterDistribution` class.
 
     Parameters
     ----------

{ler-0.4.0 → ler-0.4.2}/ler/image_properties/image_properties.py

@@ -1,11 +1,13 @@
 # -*- coding: utf-8 -*-
 """
 This module contains the LensGalaxyPopulation class, which is used to sample lens galaxy parameters, source parameters conditioned on the source being strongly lensed, image properties, and lensed SNRs. \n
-The class inherits from the CompactBinaryPopulation class, which is used to sample source parameters. \n
+The class inherits from the CBCSourceParameterDistribution class, which is used to sample source parameters. \n
 """
 
 import warnings
 warnings.filterwarnings("ignore")
+import logging
+logging.getLogger('numexpr.utils').setLevel(logging.ERROR)
 # for multiprocessing
 from multiprocessing import Pool
 from tqdm import tqdm
@@ -339,6 +341,8 @@ class ImageProperties():
         ####################################
         lens_parameters.update(image_parameters)
         lens_parameters["n_images"] = n_images
+        lens_parameters["x_source"] = x_source
+        lens_parameters["y_source"] = y_source
 
         return lens_parameters
 

{ler-0.4.0 → ler-0.4.2}/ler/lens_galaxy_population/lens_galaxy_parameter_distribution.py

@@ -2,7 +2,7 @@
 """
 This module contains the LensGalaxyPopulation class, which is used to sample lens galaxy parameters, source parameters conditioned on the source being strongly lensed. \n
 The class inherits from the ImageProperties class, which is used calculate image properties (magnification, timedelays, source position, image position, morse phase). \n
-Either the class takes in initialized CompactBinaryPopulation class as input or inherits the CompactBinaryPopulation class with default params (if no input) \n
+Either the class takes in initialized CBCSourceParameterDistribution class as input or inherits the CBCSourceParameterDistribution class with default params (if no input) \n
 """
 
 import warnings
@@ -181,8 +181,8 @@ class LensGalaxyParameterDistribution(CBCSourceParameterDistribution, ImagePrope
 
     # Attributes
     cbc_pop = None
-    """:class:`~CompactBinaryPopulation` class\n
-    This is an already initialized class that contains a function (CompactBinaryPopulation.sample_gw_parameters) that actually samples the source parameters. 
+    """:class:`~CBCSourceParameterDistribution` class\n
+    This is an already initialized class that contains a function (CBCSourceParameterDistribution.sample_gw_parameters) that actually samples the source parameters. 
     """
 
     z_min = None
@@ -313,7 +313,7 @@ class LensGalaxyParameterDistribution(CBCSourceParameterDistribution, ImagePrope
             dictionary of parameters to initialize the parent classes
         """
 
-        # initialization of CompactBinaryPopulation class
+        # initialization of CBCSourceParameterDistribution class
         # it also initializes the CBCSourceRedshiftDistribution class
         # list of relevant initialized instances,
         # 1. self.sample_source_redshift
@@ -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,
@@ -637,7 +639,7 @@ class LensGalaxyParameterDistribution(CBCSourceParameterDistribution, ImagePrope
         def zs_function(zs_sl):
             # get zs
             # self.sample_source_redshifts from CBCSourceRedshiftDistribution class
-            zs = self.sample_zs(size)  # this function is from CompactBinaryPopulation class
+            zs = self.sample_zs(size)  # this function is from CBCSourceParameterDistribution class
             # put strong lensing condition with optical depth
             tau = self.strong_lensing_optical_depth(zs)
             tau_max = self.strong_lensing_optical_depth(np.array([z_max]))[0] # tau increases with z

{ler-0.4.0 → ler-0.4.2}/ler/rates/gwrates.py

@@ -84,7 +84,7 @@ class GWRATES(CBCSourceParameterDistribution):
         
     Instance Attributes
     ----------
-    LeR class has the following attributes, \n
+    LeR class has the following attributes:\n
     +-------------------------------------+----------------------------------+
     | Atrributes                          | Type                             |
     +=====================================+==================================+
@@ -121,7 +121,7 @@ class GWRATES(CBCSourceParameterDistribution):
 
     Instance Methods
     ----------
-    LeR class has the following methods, \n
+    LeR class has the following methods:\n
     +-------------------------------------+----------------------------------+
     | Methods                             | Description                      |
     +=====================================+==================================+
@@ -506,7 +506,7 @@ class GWRATES(CBCSourceParameterDistribution):
             dictionary of parameters to initialize the parent classes
         """
 
-        # initialization of CompactBinaryPopulation class
+        # initialization of CBCSourceParameterDistribution class
         # it also initializes the CBCSourceRedshiftDistribution class
         input_params = dict(
             z_min=self.z_min,

{ler-0.4.0 → ler-0.4.2}/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. 
 
@@ -68,6 +76,23 @@ class LeR(LensGalaxyParameterDistribution):
     interpolator_directory : `str`
         directory to store the interpolators.
         default interpolator_directory = './interpolator_pickle'. This is used for storing the various interpolators related to `ler` and `gwsnr` package.
+    create_new_interpolator : `bool` or `dict`
+        default create_new_interpolator = False.
+        if True, the all interpolators (including `gwsnr`'s)will be created again.
+        if False, the interpolators will be loaded from the interpolator_directory if they exist.
+        if dict, you can specify which interpolators to create new. Complete example (change any of them to True), create_new_interpolator = create_new_interpolator = dict(
+            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),
+            Dl_to_z=dict(create_new=False, resolution=1000),
+            gwsnr=False,
+        )
     ler_directory : `str`
         directory to store the parameters.
         default ler_directory = './ler_data'. This is used for storing the parameters of the simulated events.
@@ -90,7 +115,7 @@ class LeR(LensGalaxyParameterDistribution):
         
     Instance Attributes
     ----------
-    LeR class has the following attributes, \n
+    LeR class has the following attributes: \n
     +-------------------------------------+----------------------------------+
     | Atrributes                          | Type                             |
     +=====================================+==================================+
@@ -133,7 +158,7 @@ class LeR(LensGalaxyParameterDistribution):
 
     Instance Methods
     ----------
-    LeR class has the following methods, \n
+    LeR class has the following methods:\n
     +-------------------------------------+----------------------------------+
     | Methods                             | Description                      |
     +=====================================+==================================+
@@ -186,7 +211,7 @@ class LeR(LensGalaxyParameterDistribution):
     |                                     | ratio between lensed and         |
     |                                     | unlensed events.                 |
     +-------------------------------------+----------------------------------+
-    |:meth:`~rate_comparision_with_rate_calculation                          |
+    |:meth:`~rate_comparison_with_rate_calculation`                          |
     +-------------------------------------+----------------------------------+
     |                                     | Function to calculate rates for  |
     |                                     | unleesed and lensed events and   |
@@ -429,6 +454,7 @@ class LeR(LensGalaxyParameterDistribution):
         list_of_detectors=None,
         json_file_names=None,
         interpolator_directory="./interpolator_pickle",
+        create_new_interpolator=False,
         ler_directory="./ler_data",
         verbose=True,
         **kwargs,
@@ -445,6 +471,7 @@ class LeR(LensGalaxyParameterDistribution):
         if json_file_names:
             self.json_file_names.update(json_file_names)
         self.interpolator_directory = interpolator_directory
+        kwargs["create_new_interpolator"] = create_new_interpolator
         self.ler_directory = ler_directory
         # create directory if not exists
         if not os.path.exists(ler_directory):
@@ -480,7 +507,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 +520,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 +544,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 +558,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 +738,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 +747,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 +777,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 +827,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.
@@ -800,6 +839,21 @@ class LeR(LensGalaxyParameterDistribution):
                 if key in input_params:
                     input_params[key] = value
         self.snr_calculator_dict = input_params
+
+        # dealing with create_new_interpolator param
+        if isinstance(input_params["create_new_interpolator"], bool):
+            pass
+        elif isinstance(input_params["create_new_interpolator"], dict):
+            # check input_params["gwsnr"] exists
+            if "gwsnr" in input_params["create_new_interpolator"]:
+                if isinstance(input_params["create_new_interpolator"]["gwsnr"], bool):
+                    input_params["create_new_interpolator"] = input_params["create_new_interpolator"]["gwsnr"]
+                else:
+                    raise ValueError("create_new_interpolator['gwsnr'] should be a boolean.")
+            else:
+                raise ValueError("create_new_interpolator should be a boolean or a dictionary with 'gwsnr' key.")
+
+        # initialization of GWSNR class
         gwsnr = GWSNR(
                     npool=input_params["npool"],
                     mtot_min=input_params["mtot_min"],
@@ -815,10 +869,14 @@ class LeR(LensGalaxyParameterDistribution):
                     psds=input_params["psds"],
                     ifos=input_params["ifos"],
                     interpolator_dir=input_params["interpolator_dir"],
-                    # create_new_interpolator=input_params["create_new_interpolator"],
+                    create_new_interpolator=input_params["create_new_interpolator"],
                     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
@@ -886,7 +944,7 @@ class LeR(LensGalaxyParameterDistribution):
             resume = False (default) or True.
             if True, the function will resume from the last batch.
         save_batch : `bool`
-            if True, the function will save the parameters in batches. if False, the function will save all the parameters at the end of sampling. save_batch=False is faster.
+            if True, the function will save the parameters in batches. if False (default), the function will save all the parameters at the end of sampling. save_batch=False is faster.
         output_jsonfile : `str`
             json file name for storing the parameters.
             default output_jsonfile = 'unlensed_params.json'. Note that this file will be stored in the self.ler_directory.
@@ -909,36 +967,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 +1016,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 +1350,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 +1389,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 +1434,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 +1445,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 +1519,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 +1620,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 +1656,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:
@@ -1697,7 +1704,7 @@ class LeR(LensGalaxyParameterDistribution):
 
         return snr_hit
 
-    def rate_comparision_with_rate_calculation(
+    def rate_comparison_with_rate_calculation(
         self,
         unlensed_param=None,
         snr_threshold_unlensed=8.0,
@@ -1705,6 +1712,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",
@@ -1758,7 +1767,7 @@ class LeR(LensGalaxyParameterDistribution):
         >>> ler = LeR()
         >>> ler.unlensed_cbc_statistics();
         >>> ler.lensed_cbc_statistics();
-        >>> rate_ratio, unlensed_param, lensed_param = ler.rate_comparision_with_rate_calculation()
+        >>> rate_ratio, unlensed_param, lensed_param = ler.rate_comparison_with_rate_calculation()
         """
 
         # call json_file_ler_param and add the results
@@ -1779,6 +1788,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 +1904,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 +1964,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 +2034,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 +2054,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 +2131,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 +2151,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-0.4.0 → ler-0.4.2}/ler/utils/utils.py

@@ -5,6 +5,7 @@ This module contains helper routines for other modules in the ler package.
 
 import os
 import pickle
+import h5py
 import numpy as np
 import json
 from scipy.interpolate import interp1d
@@ -52,6 +53,66 @@ class NumpyEncoder(json.JSONEncoder):
             return obj.tolist()
         return json.JSONEncoder.default(self, obj)
 
+def load_pickle(file_name):
+    """Load a pickle file.
+
+    Parameters
+    ----------
+    file_name : `str`
+        pickle file name for storing the parameters.
+
+    Returns
+    ----------
+    param : `dict`
+    """
+    with open(file_name, "rb") as handle:
+        param = pickle.load(handle)
+
+    return param
+
+def save_pickle(file_name, param):
+    """Save a dictionary as a pickle file.
+
+    Parameters
+    ----------
+    file_name : `str`
+        pickle file name for storing the parameters.
+    param : `dict`
+        dictionary to be saved as a pickle file.
+    """
+    with open(file_name, "wb") as handle:
+        pickle.dump(param, handle, protocol=pickle.HIGHEST_PROTOCOL)
+
+# hdf5
+def load_hdf5(file_name):
+    """Load a hdf5 file.
+
+    Parameters
+    ----------
+    file_name : `str`
+        hdf5 file name for storing the parameters.
+
+    Returns
+    ----------
+    param : `dict`
+    """
+
+    return h5py.File(file_name, 'r')
+
+def save_hdf5(file_name, param):
+    """Save a dictionary as a hdf5 file.
+
+    Parameters
+    ----------
+    file_name : `str`
+        hdf5 file name for storing the parameters.
+    param : `dict`
+        dictionary to be saved as a hdf5 file.
+    """
+    with h5py.File(file_name, 'w') as f:
+        for key, value in param.items():
+            f.create_dataset(key, data=value)
+
 def load_json(file_name):
     """Load a json file.
 
@@ -125,7 +186,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 +204,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 +376,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 +451,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 +934,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 +945,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 +989,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);
-    # ---------------------------------------------------#
+    # 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)
 
-    return None
+    return dict_buffer
 
-# def batch_handler(size, batch_size, sampling_routine, output_jsonfile, save_batch=True, resume=False):
-#     """
-#     Function to run the sampling in batches.
-
-#     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.4.0 → ler-0.4.2}/ler.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: ler
-Version: 0.4.0
-Summary: Gravitational waves Lensing Rates
+Version: 0.4.2
+Summary: LVK (LIGO-Virgo-KAGRA collaboration) Event (compact-binary mergers) Rate calculator and simulator
 Home-page: https://github.com/hemantaph/ler
 Author: Hemantakumar
 Author-email: hemantaphurailatpam@gmail.com

{ler-0.4.0 → ler-0.4.2}/ler.egg-info/requires.txt

@@ -11,4 +11,4 @@ astropy>=5.1
 tqdm>=4.64.1
 pointpats>=2.3
 shapely>=2.0.1
-gwcosmo
+gwcosmo==2.1.0

{ler-0.4.0 → ler-0.4.2}/setup.py

@@ -13,8 +13,8 @@ if python_version < (3, 10):
 
 setup(
     name="ler",
-    version="0.4.0",
-    description="Gravitational waves Lensing Rates",
+    version="0.4.2",
+    description="LVK (LIGO-Virgo-KAGRA collaboration) Event (compact-binary mergers) Rate calculator and simulator",
     long_description=long_description,
     long_description_content_type='text/markdown',
     author="Hemantakumar",
@@ -37,6 +37,6 @@ setup(
         "tqdm>=4.64.1",
         "pointpats>=2.3",
         "shapely>=2.0.1",
-        "gwcosmo",
+        "gwcosmo==2.1.0",
     ],
 )

ler-0.4.0/ler/__init__.py

@@ -1,31 +0,0 @@
-"""
-LeR
-"""
-
-#import pycbc
-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
-
-__author__ = 'hemanta_ph <hemantaphurailatpam@gmail.com>'
-
-# The version as used in the setup.py
-__version__ = "0.4.0"
-
-# add __file__
-import os
-__file__ = os.path.abspath(__file__)
-
-from . import rates, gw_source_population, lens_galaxy_population, image_properties, utils
-
-from .rates import ler, gwrates
-from .gw_source_population import cbc_source_parameter_distribution, cbc_source_redshift_distribution
-from .lens_galaxy_population import lens_galaxy_parameter_distribution, optical_depth
-from .image_properties import image_properties
-from .utils import utils, plots
-
-