classy-szfast 0.0.8__tar.gz → 0.0.10__tar.gz

{classy_szfast-0.0.8/classy_szfast.egg-info → classy_szfast-0.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: classy_szfast
-Version: 0.0.8
+Version: 0.0.10
 Summary: The accelerator of the class_sz code from https://github.com/CLASS-SZ
 Home-page: https://github.com/CLASS-SZ/classy_szfast
 Download-URL: https://github.com/CLASS-SZ/classy_szfast

{classy_szfast-0.0.8 → classy_szfast-0.0.10}/classy_szfast/__init__.py

@@ -6,5 +6,9 @@ from .pks_and_sigmas import *
 
 from pathlib import Path
 import sys
-from .custom_profiles import *
-from .custom_bias import *
+
+
+from .custom_profiles.custom_profiles import *
+
+
+from .custom_bias.custom_bias import *

{classy_szfast-0.0.8 → classy_szfast-0.0.10}/classy_szfast/classy_sz.py

@@ -8,59 +8,69 @@ import numpy as np
 import time
 
 class classy_sz(classy):
-    use_class_sz_fast_mode = 0 # this is passed in the yaml file
+
+    use_class_sz_fast_mode = 1 # this is passed in the yaml file
     use_class_sz_no_cosmo_mode = 0 # this is passed in the yaml file
-    lensing_lkl = "SOLikeT"
-    # skip_background_and_thermo = True
-    # ell_factor = False # True for pyactlite and bplike, False for clik
+    lensing_lkl = 'ACT'
+
+    baos = None 
 
     def initialize(self):
         """Importing CLASS from the correct path, if given, and if not, globally."""
+
         self.classy_module = self.is_installed()
         if not self.classy_module:
             raise NotInstalledError(
                 self.log, "Could not find CLASS_SZ. Check error message above.")
+        
         from classy_sz import Class, CosmoSevereError, CosmoComputationError
+        
         global CosmoComputationError, CosmoSevereError
+
         self.classy = Class()
         super(classy,self).initialize()
+
+
         # Add general CLASS stuff
         self.extra_args["output"] = self.extra_args.get("output", "")
+
         if "sBBN file" in self.extra_args:
             self.extra_args["sBBN file"] = (
                 self.extra_args["sBBN file"].format(classy=self.path))
+            
         # Derived parameters that may not have been requested, but will be necessary later
         self.derived_extra = []
         self.log.info("Initialized!")
 
+
+        ## rename some parameters to avoid conflices
+        classy_sz_renames = {
+
+            'omega_m':'Omega_m',
+            'Omegam':'Omega_m',
+            'Omega_m':'Omega_m'
+        }
+        self.renames.update(classy_sz_renames)
+
+
         if self.use_class_sz_no_cosmo_mode == 1:
+
             self.log.info("Initializing cosmology part!")
+
             initial_parameters = self.extra_args.copy()
-            # print("initial_parameters:",initial_parameters)
+
 
             self.classy.set(initial_parameters)
-            self.classy.compute_class_szfast()
+            self.classy.compute_class_szfast(likelihood_mode=True)
             self.log.info("cosmology part initialized!")
 
 
-        # print(self.lensing_lkl)
-        # exit(0)
-
-        # # class_sz default params for lkl
-        # self.extra_args["output"] = 'tSZ_1h'
-        # self.extra_args["multipoles_sz"] = 'P15'
-        # self.extra_args['nlSZ'] = 18
 
 
-    # # here modify if you want to bypass stuff in the class computation
-    # def calculate(self, state, want_derived=True, **params_values_dict):
-    #     print("Bypassing class_sz")
-
+    def must_provide(self, **requirements):
 
 
 
-    def must_provide(self, **requirements):
-
         if "Cl_sz" in requirements:
             # make sure cobaya still runs as it does for standard classy
             requirements.pop("Cl_sz")
@@ -246,25 +256,25 @@ class classy_sz(classy):
                         args=[])
         super().must_provide(**requirements)
 
+
     # get the required new observable
     def get_Cl(self, ell_factor=False, units="FIRASmuK2"):
+        
         if self.use_class_sz_fast_mode:
+
             return self.get_Clfast(ell_factor=ell_factor)
+        
         else:
+        
             return self._get_Cl(ell_factor=ell_factor, units=units, lensed=True)
 
     def get_Clfast(self,ell_factor = False):
-        # print('ell_factor:',self.ell_factor)
-        # exit(0)
+
         cls = {}
         cls = deepcopy(self._current_state["Cl"])
-        # ell_factor = self.ell_factor
-        # print(cls)
-        # exit(0)
-        # print('in get clfast:',ell_factor)
-        # print(cls)
+
         lcp = np.asarray(cls['ell'])
-        # print(self.lensing_lkl)
+
         if ell_factor==True:
             cls['tt'] *= (2.7255e6)**2.*(lcp*(lcp+1.))/2./np.pi
             cls['te'] *= (2.7255e6)**2.*(lcp*(lcp+1.))/2./np.pi
@@ -274,17 +284,18 @@ class classy_sz(classy):
             cls['tt'] *= (2.7255e6)**2.
             cls['te'] *= (2.7255e6)**2.
             cls['ee'] *= (2.7255e6)**2.
-        # print(cls['tt'][1230])
-        # print(cls['te'][1230])
-        # print(cls['ee'][1230])
-        # exit(0)
+
         if self.lensing_lkl ==  "SOLikeT":
             cls['pp'] *= (lcp*(lcp+1.))**2./4.
+
         elif self.lensing_lkl == "ACT":
-            cls['pp'] *= 1.#(lcp*(lcp+1.))**2./4.
+            cls['pp'] *= 1.
+             
         else: # here for the planck lensing lkl, using lfactor option gives:
             cls['pp'] *= (lcp*(lcp+1.))**2.*1./2./np.pi
+
         return cls
+    
     # get the required new observable
     def get_Cl_sz(self):
         cls = {}
@@ -362,8 +373,9 @@ class classy_sz(classy):
 
     # get the required new observable
     def get_sz_unbinned_cluster_counts(self):
+
         cls = deepcopy(self._current_state["sz_unbinned_cluster_counts"])
-        # print(cls)
+
         return cls['loglike'],cls['ntot'],cls['rates']
 
 
@@ -380,37 +392,53 @@ class classy_sz(classy):
 
     # IMPORTANT: this method is imported from cobaya and modified to accomodate the emulators
     def calculate(self, state, want_derived=True, **params_values_dict):
-        # Set parameters
+
+        
         params_values = params_values_dict.copy()
-        # print('\n\n')
-        # print('>>> class_sz.py: class/class_sz using params:',params_values)
+        # if baos are requested we need to update the relevant flags
+        if self.baos:
+            params_values.update({'skip_chi':0,'skip_hubble':0})
+
         if 'N_ncdm' in self.extra_args.keys():
+
             if self.extra_args['N_ncdm'] ==  3:
+            
                 str_mncdm = str(params_values['m_ncdm'])
                 params_values['m_ncdm'] = str_mncdm+','+str_mncdm+','+str_mncdm
-        # print('>>> class_sz.py: class/class_sz using params:',params_values)
-        # exit(0)
+
         try:
+            
             params_values['ln10^{10}A_s'] = params_values.pop("logA")
+            
             self.set(params_values)
+        
         except KeyError:
+        
             self.set(params_values)
+
         # Compute!
         try:
             if self.use_class_sz_fast_mode == 1:
-                # start = time.perf_counter()
+
+
                 if self.use_class_sz_no_cosmo_mode == 1:
-                    # print(params_values)
+
+                    start_time = time.time()
                     self.classy.compute_class_sz(params_values)
+                    end_time = time.time()
+                    # self.log.info("Execution time of class_sz: {:.5f} seconds".format(end_time - start_time))
+
                 else:
-                    self.classy.compute_class_szfast()
-                # end = time.perf_counter()
-                # print('classy_szfast took:',end-start)
-            # self.classy.compute_class_szfast()
-            # elif self.use_class_sz_no_cosmo_mode == 1:
-            #     self.classy.compute_class_sz(params_values)
+
+                    start_time = time.time()
+                    self.classy.compute_class_szfast(likelihood_mode=True)
+                    end_time = time.time()
+                    # self.log.info("Execution time of class_szfast: {:.5f} seconds".format(end_time - start_time))
+                    # print('pars in classy',self.classy.pars)
             else:
+
                 self.classy.compute()
+
         # "Valid" failure of CLASS: parameters too extreme -> log and report
         except self.classy_module.CosmoComputationError as e:
             if self.stop_at_error:
@@ -492,81 +520,15 @@ class classy_sz(classy):
             if collector.post:
                 state[product] = collector.post(*state[product])
         # Prepare derived parameters
+
         d, d_extra = self._get_derived_all(derived_requested=want_derived)
+
         if want_derived:
+
             state["derived"] = {p: d.get(p) for p in self.output_params}
-            # Prepare necessary extra derived parameters
+
+
         state["derived_extra"] = deepcopy(d_extra)
-        # exit(0)
-
-
-    # # get the required new observable
-    # def get_Cl(self,ell_factor=True,units="FIRASmuK2"):
-    #     ell_factor=self.ell_factor
-    #     # if self.tsz.use_class_sz_fast_mode == 1:
-    #     cls = {}
-    #     cls['ell'] = np.arange(20000)
-    #     # print(cls['ell'])
-    #     cls['tt'] = np.zeros(20000)
-    #     cls['te'] = np.zeros(20000)
-    #     cls['ee'] = np.zeros(20000)
-    #     cls['pp'] = np.zeros(20000)
-    #     # if self.tt_spectra is not None:
-    #     nl = len(self.classy.class_szfast.cp_predicted_tt_spectrum)
-    #     # print('nl:',nl)
-    #     cls['tt'][2:nl+2] = (2.7255e6)**2.*self.classy.class_szfast.cp_predicted_tt_spectrum
-    #     if ell_factor==False:
-    #         lcp = np.asarray(cls['ell'][2:nl+2])
-    #         cls['tt'][2:nl+2] *= 1./(lcp*(lcp+1.)/2./np.pi)
-    #
-    # # if self.te_spectra is not None:
-    #     cls['te'][2:nl+2] = (2.7255e6)**2.*self.classy.class_szfast.cp_predicted_te_spectrum
-    #     if ell_factor==False:
-    #         lcp = np.asarray(cls['ell'][2:nl+2])
-    #         cls['te'][2:nl+2] *= 1./(lcp*(lcp+1.)/2./np.pi)
-    # # if self.ee_spectra is not None:
-    #     cls['ee'][2:nl+2] = (2.7255e6)**2.*self.classy.class_szfast.cp_predicted_ee_spectrum
-    #     if ell_factor==False:
-    #         lcp = np.asarray(cls['ell'][2:nl+2])
-    #         cls['ee'][2:nl+2] *= 1./(lcp*(lcp+1.)/2./np.pi)
-    #     # if self.pp_spectra is not None:
-    #         # nl = len(self.pp_spectra[0])
-    #     if self.lensing_lkl ==  "SOLikeT":
-    #         cls['pp'][2:nl+2] = self.classy.class_szfast.cp_predicted_pp_spectrum/4. ## this is clkk... works for so lensinglite lkl
-    #     else:
-    #         # here for the planck lensing lkl, using lfactor option gives:
-    #         lcp = np.asarray(cls['ell'][2:nl+2])
-    #         cls['pp'][2:nl+2] = self.classy.class_szfast.cp_predicted_pp_spectrum/(lcp*(lcp+1.))**2.
-    #         cls['pp'][2:nl+2] *= (lcp*(lcp+1.))**2./2./np.pi
-    #     return cls
-
-    # def check_ranges(self, z, k):
-    #     return 1
-
-    # IMPORTANT: copied from cobaya and changed.
-    def get_param(self, p):
-        translated = self.translate_param(p)
-        for pool in ["params", "derived", "derived_extra"]:
-            value = (self.current_state[pool] or {}).get(translated, None)
-            if p == 'omegam':
-                print('getting omegam in get_param')
-                # print(translated)
-                # print(self.classy.Omega_m())
-                # exit(0)
-                return self.classy.Omega_m()
-            if value is not None:
-                return value
-
-        raise LoggedError(self.log, "Parameter not known: '%s'", p)
-### ORIGINAL FUNCTION:
-#    def get_param(self, p):
-#        translated = self.translate_param(p)
-#        for pool in ["params", "derived", "derived_extra"]:
-#            value = (self.current_state[pool] or {}).get(translated, None)
-#            if value is not None:
-#                return value
-#
-#        raise LoggedError(self.log, "Parameter not known: '%s'", p)