classy-szfast 0.0.0__py3-none-any.whl

classy_szfast/pks_and_sigmas.py

@@ -0,0 +1,150 @@
+from .utils import *
+from .config import *
+from scipy.interpolate import RectBivariateSpline
+
+
+# this code is adapted from cobaya
+class PowerSpectrumInterpolator(RectBivariateSpline):
+    r"""
+    2D spline interpolation object (scipy.interpolate.RectBivariateSpline)
+    to evaluate matter power spectrum as function of z and k.
+
+    *This class is adapted from CAMB's own P(k) interpolator, by Antony Lewis;
+    it's mostly interface-compatible with the original.*
+
+    :param z: values of z for which the power spectrum was evaluated.
+    :param k: values of k for which the power spectrum was evaluated.
+    :param P_or_logP: Values of the power spectrum (or log-values, if logP=True).
+    :param logP: if True (default: False), log of power spectrum are given and used
+        for the underlying interpolator.
+    :param logsign: if logP is True, P_or_logP is log(logsign*Pk)
+    :param extrap_kmax: if set, use power law extrapolation beyond kmax up to
+        extrap_kmax; useful for tails of integrals.
+    """
+
+    def __init__(self, z, k, P_or_logP, extrap_kmin=1e-5, extrap_kmax=1e2, logP=False,
+                 logsign=1):
+        self.islog = logP
+        #  Check order
+        z, k = (np.atleast_1d(x) for x in [z, k])
+        if len(z) < 4:
+            raise ValueError('Require at least four redshifts for Pk interpolation.'
+                             'Consider using Pk_grid if you just need a small number'
+                             'of specific redshifts (doing 1D splines in k yourself).')
+        z, k, P_or_logP = np.array(z), np.array(k), np.array(P_or_logP)
+        i_z = np.argsort(z)
+        i_k = np.argsort(k)
+        self.logsign = logsign
+        self.z, self.k, P_or_logP = z[i_z], k[i_k], P_or_logP[i_z, :][:, i_k]
+        self.zmin, self.zmax = self.z[0], self.z[-1]
+        self.extrap_kmin, self.extrap_kmax = extrap_kmin, extrap_kmax
+        logk = np.log(self.k)
+        # Start from extrap_kmin using a (log,log)-linear extrapolation
+        if extrap_kmin and extrap_kmin < self.input_kmin:
+            if not logP:
+                raise ValueError('extrap_kmin must use logP')
+            logk = np.hstack(
+                [np.log(extrap_kmin),
+                 np.log(self.input_kmin) * 0.1 + np.log(extrap_kmin) * 0.9, logk])
+            logPnew = np.empty((P_or_logP.shape[0], P_or_logP.shape[1] + 2))
+            logPnew[:, 2:] = P_or_logP
+            diff = (logPnew[:, 3] - logPnew[:, 2]) / (logk[3] - logk[2])
+            delta = diff * (logk[2] - logk[0])
+            logPnew[:, 0] = logPnew[:, 2] - delta
+            logPnew[:, 1] = logPnew[:, 2] - delta * 0.9
+            P_or_logP = logPnew
+        # Continue until extrap_kmax using a (log,log)-linear extrapolation
+        if extrap_kmax and extrap_kmax > self.input_kmax:
+            if not logP:
+                raise ValueError('extrap_kmax must use logP')
+            logk = np.hstack(
+                [logk, np.log(self.input_kmax) * 0.1 + np.log(extrap_kmax) * 0.9,
+                 np.log(extrap_kmax)])
+            logPnew = np.empty((P_or_logP.shape[0], P_or_logP.shape[1] + 2))
+            logPnew[:, :-2] = P_or_logP
+            diff = (logPnew[:, -3] - logPnew[:, -4]) / (logk[-3] - logk[-4])
+            delta = diff * (logk[-1] - logk[-3])
+            logPnew[:, -1] = logPnew[:, -3] + delta
+            logPnew[:, -2] = logPnew[:, -3] + delta * 0.9
+            P_or_logP = logPnew
+        super().__init__(self.z, logk, P_or_logP)
+
+    @property
+    def input_kmin(self):
+        """Minimum k for the interpolation (not incl. extrapolation range)."""
+        return self.k[0]
+
+    @property
+    def input_kmax(self):
+        """Maximum k for the interpolation (not incl. extrapolation range)."""
+        return self.k[-1]
+
+    @property
+    def kmin(self):
+        """Minimum k of the interpolator (incl. extrapolation range)."""
+        if self.extrap_kmin is None:
+            return self.input_kmin
+        return self.extrap_kmin
+
+    @property
+    def kmax(self):
+        """Maximum k of the interpolator (incl. extrapolation range)."""
+        if self.extrap_kmax is None:
+            return self.input_kmax
+        return self.extrap_kmax
+
+    def check_ranges(self, z, k):
+        """Checks that we are not trying to extrapolate beyond the interpolator limits."""
+        z = np.atleast_1d(z).flatten()
+        min_z, max_z = min(z), max(z)
+        if min_z < self.zmin and not np.allclose(min_z, self.zmin):
+            print(
+                              f"Not possible to extrapolate to z={min(z)} "
+                              f"(minimum z computed is {self.zmin}).")
+        if max_z > self.zmax and not np.allclose(max_z, self.zmax):
+            print(
+                              f"Not possible to extrapolate to z={max(z)} "
+                              f"(maximum z computed is {self.zmax}).")
+        k = np.atleast_1d(k).flatten()
+        min_k, max_k = min(k), max(k)
+        if min_k < self.kmin and not np.allclose(min_k, self.kmin):
+            raise print(
+                              f"Not possible to extrapolate to k={min(k)} 1/Mpc "
+                              f"(minimum k possible is {self.kmin} 1/Mpc).")
+        if max_k > self.kmax and not np.allclose(max_k, self.kmax):
+            print(
+                              f"Not possible to extrapolate to k={max(k)} 1/Mpc "
+                              f"(maximum k possible is {self.kmax} 1/Mpc).")
+
+    def P(self, z, k, grid=None):
+        """
+        Get the power spectrum at (z,k).
+        """
+        self.check_ranges(z, k)
+        if grid is None:
+            grid = not np.isscalar(z) and not np.isscalar(k)
+        if self.islog:
+            return self.logsign * np.exp(self(z, np.log(k), grid=grid, warn=False))
+        else:
+            return self(z, np.log(k), grid=grid, warn=False)
+
+    def logP(self, z, k, grid=None):
+        """
+        Get the log power spectrum at (z,k). (or minus log power spectrum if
+        islog and logsign=-1)
+        """
+        self.check_ranges(z, k)
+        if grid is None:
+            grid = not np.isscalar(z) and not np.isscalar(k)
+        if self.islog:
+            return self(z, np.log(k), grid=grid, warn=False)
+        else:
+            return np.log(self(z, np.log(k), grid=grid, warn=False))
+
+    def __call__(self, *args, warn=True, **kwargs):
+        if warn:
+            print(
+                "Do not call the instance directly. Use instead methods P(z, k) or "
+                "logP(z, k) to get the (log)power spectrum. (If you know what you are "
+                "doing, pass warn=False)")
+        return super().__call__(*args, **kwargs)

classy_szfast/restore_nn.py

@@ -0,0 +1,395 @@
+from .utils import *
+from .config import *
+
+
+from .suppress_warnings import suppress_warnings
+
+import warnings
+from contextlib import contextmanager
+import logging
+
+# Suppress absl warnings
+import absl.logging
+absl.logging.set_verbosity('error')
+# Suppress TensorFlow warnings
+import os
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
+with suppress_warnings():
+    import tensorflow as tf
+    tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.ERROR)
+dtype = tf.float32
+import pickle
+
+class Restore_NN(tf.keras.Model):
+
+    def __init__(self, 
+                 parameters=None, 
+                 modes=None, 
+                 parameters_mean=None, 
+                 parameters_std=None, 
+                 features_mean=None, 
+                 features_std=None, 
+                 n_hidden=[512,512,512], 
+                 restore=False, 
+                 restore_filename=None, 
+                 trainable=True,
+                 optimizer=None,
+                 verbose=False, 
+                 ):
+        
+        # super
+        super(Restore_NN, self).__init__()
+
+        # restore
+        
+        self.restore(restore_filename)
+
+
+        # input parameters mean and std
+        self.parameters_mean = tf.constant(self.parameters_mean_, dtype=dtype, name='parameters_mean')
+        self.parameters_std = tf.constant(self.parameters_std_, dtype=dtype, name='parameters_std')
+
+        # (log)-spectra mean and std
+        self.features_mean = tf.constant(self.features_mean_, dtype=dtype, name='features_mean')
+        self.features_std = tf.constant(self.features_std_, dtype=dtype, name='features_std')
+
+        # weights, biases and activation function parameters for each layer of the network
+        self.W = []
+        self.b = []
+        self.alphas = []
+        self.betas = [] 
+        for i in range(self.n_layers):
+            self.W.append(tf.Variable(tf.random.normal([self.architecture[i], self.architecture[i+1]], 0., 1e-3), name="W_" + str(i), trainable=trainable))
+            self.b.append(tf.Variable(tf.zeros([self.architecture[i+1]]), name = "b_" + str(i), trainable=trainable))
+        for i in range(self.n_layers-1):
+            self.alphas.append(tf.Variable(tf.random.normal([self.architecture[i+1]]), name = "alphas_" + str(i), trainable=trainable))
+            self.betas.append(tf.Variable(tf.random.normal([self.architecture[i+1]]), name = "betas_" + str(i), trainable=trainable))
+
+        # restore weights if restore = True
+
+        for i in range(self.n_layers):
+            self.W[i].assign(self.W_[i])
+            self.b[i].assign(self.b_[i])
+        for i in range(self.n_layers-1):
+            self.alphas[i].assign(self.alphas_[i])
+            self.betas[i].assign(self.betas_[i])
+
+        # optimizer
+        self.optimizer = optimizer or tf.keras.optimizers.Adam()
+        self.verbose= verbose
+
+        # print initialization info, if verbose
+        if self.verbose:
+            multiline_str = "\nInitialized cosmopower_NN model, \n" \
+                            f"mapping {self.n_parameters} input parameters to {self.n_modes} output modes, \n" \
+                            f"using {len(self.n_hidden)} hidden layers, \n" \
+                            f"with {list(self.n_hidden)} nodes, respectively. \n"
+            print(multiline_str)
+
+
+    # restore attributes
+    def restore(self, 
+                filename
+                ):
+        r"""
+        Load pre-trained model
+
+        Parameters:
+            filename (str):
+                filename tag (without suffix) where model was saved
+        """
+        # load attributes
+        with open(filename + ".pkl", 'rb') as f:
+            self.W_, self.b_, self.alphas_, self.betas_, \
+            self.parameters_mean_, self.parameters_std_, \
+            self.features_mean_, self.features_std_, \
+            self.n_parameters, self.parameters, \
+            self.n_modes, self.modes, \
+            self.n_hidden, self.n_layers, self.architecture = pickle.load(f)
+
+
+
+    # auxiliary function to sort input parameters
+    def dict_to_ordered_arr_np(self, 
+                               input_dict, 
+                               ):
+        r"""
+        Sort input parameters
+
+        Parameters:
+            input_dict (dict [numpy.ndarray]):
+                input dict of (arrays of) parameters to be sorted
+
+        Returns:
+            numpy.ndarray:
+                parameters sorted according to desired order
+        """
+        if self.parameters is not None:
+            return np.stack([input_dict[k] for k in self.parameters], axis=1)
+        else:
+            return np.stack([input_dict[k] for k in input_dict], axis=1)
+
+
+    # forward prediction given input parameters implemented in Numpy
+    def forward_pass_np(self, 
+                        parameters_arr
+                        ):
+        r"""
+        Forward pass through the network to predict the output, 
+        fully implemented in Numpy
+
+        Parameters:
+            parameters_arr (numpy.ndarray):
+                array of input parameters
+
+        Returns:
+          numpy.ndarray:
+            output predictions
+        """
+        # forward pass through the network
+        act = []
+        layers = [(parameters_arr - self.parameters_mean_)/self.parameters_std_]
+        for i in range(self.n_layers-1):
+
+            # linear network operation
+            act.append(np.dot(layers[-1], self.W_[i]) + self.b_[i])
+
+            # pass through activation function
+            layers.append((self.betas_[i] + (1.-self.betas_[i])*1./(1.+np.exp(-self.alphas_[i]*act[-1])))*act[-1])
+
+        # final (linear) layer -> (standardised) predictions
+        layers.append(np.dot(layers[-1], self.W_[-1]) + self.b_[-1])
+
+        # rescale and output
+        return layers[-1]*self.features_std_ + self.features_mean_
+
+
+    # Numpy array predictions
+    def predictions_np(self, 
+                       parameters_dict
+                       ):
+        r"""
+        Predictions given input parameters collected in a dict.
+        Fully implemented in Numpy. Calls ``forward_pass_np``
+        after ordering the input parameter dict
+
+        Parameters:
+            parameters_dict (dict [numpy.ndarray]):
+                dictionary of (arrays of) parameters
+
+        Returns:
+            numpy.ndarray:
+                output predictions
+        """
+        parameters_arr = self.dict_to_ordered_arr_np(parameters_dict)
+        return self.forward_pass_np(parameters_arr)
+
+
+    # Numpy array 10.**predictions
+    def ten_to_predictions_np(self,
+                            parameters_dict
+                            ):
+        r"""
+        10^predictions given input parameters collected in a dict.
+        Fully implemented in Numpy. It raises 10 to the output
+        from ``forward_pass_np``
+
+        Parameters:
+            parameters_dict (dict [numpy.ndarray]):
+                dictionary of (arrays of) parameters
+
+        Returns:
+            numpy.ndarray:
+                10^output predictions
+        """
+        return 10.**self.predictions_np(parameters_dict)
+
+
+class Restore_PCAplusNN(tf.keras.Model):
+
+    def __init__(self, 
+                 cp_pca=None,
+                 n_hidden=[512,512,512], 
+                 restore=False, 
+                 restore_filename=None, 
+                 trainable=True, 
+                 optimizer=None,
+                 verbose=False,
+                 ):
+        r"""
+        Constructor.
+        """
+        # super
+        super(Restore_PCAplusNN, self).__init__()
+
+
+        self.restore(restore_filename)
+
+        # input parameters mean and std
+        self.parameters_mean = tf.constant(self.parameters_mean_, dtype=dtype, name='parameters_mean')
+        self.parameters_std = tf.constant(self.parameters_std_, dtype=dtype, name='parameters_std')
+
+        # PCA mean and std
+        self.pca_mean = tf.constant(self.pca_mean_, dtype=dtype, name='pca_mean')
+        self.pca_std = tf.constant(self.pca_std_, dtype=dtype, name='pca_std')
+
+        # (log)-spectra mean and std
+        self.features_mean = tf.constant(self.features_mean_, dtype=dtype, name='features_mean')
+        self.features_std = tf.constant(self.features_std_, dtype=dtype, name='features_std')
+
+        # pca transform matrix
+        self.pca_transform_matrix = tf.constant(self.pca_transform_matrix_, dtype=dtype, name='pca_transform_matrix')
+
+        # weights, biases and activation function parameters for each layer of the network
+        self.W = []
+        self.b = []
+        self.alphas = []
+        self.betas = [] 
+        for i in range(self.n_layers):
+            self.W.append(tf.Variable(tf.random.normal([self.architecture[i], self.architecture[i+1]], 0., np.sqrt(2./self.n_parameters)), name="W_" + str(i), trainable=trainable))
+            self.b.append(tf.Variable(tf.zeros([self.architecture[i+1]]), name = "b_" + str(i), trainable=trainable))
+        for i in range(self.n_layers-1):
+            self.alphas.append(tf.Variable(tf.random.normal([self.architecture[i+1]]), name = "alphas_" + str(i), trainable=trainable))
+            self.betas.append(tf.Variable(tf.random.normal([self.architecture[i+1]]), name = "betas_" + str(i), trainable=trainable))
+
+        # restore weights if restore = True
+        for i in range(self.n_layers):
+            self.W[i].assign(self.W_[i])
+            self.b[i].assign(self.b_[i])
+        for i in range(self.n_layers-1):
+            self.alphas[i].assign(self.alphas_[i])
+            self.betas[i].assign(self.betas_[i])
+
+        self.optimizer = optimizer or tf.keras.optimizers.Adam()
+        self.verbose= verbose
+
+        # print initialization info, if verbose
+        if self.verbose:
+            multiline_str = "\nInitialized cosmopower_PCAplusNN model, \n" \
+                            f"mapping {self.n_parameters} input parameters to {self.n_pcas} PCA components \n" \
+                            f"and then inverting the PCA compression to obtain {self.n_modes} modes \n" \
+                            f"The model uses {len(self.n_hidden)} hidden layers, \n" \
+                            f"with {list(self.n_hidden)} nodes, respectively. \n"
+            print(multiline_str)
+
+
+
+    # restore attributes
+    def restore(self, 
+                filename,
+                ):
+        r"""
+        Load pre-trained model
+
+        Parameters:
+            filename (str):
+                filename tag (without suffix) where model was saved
+        """
+        # load attributes
+        f = open(filename + ".pkl", 'rb')
+        self.W_, self.b_, self.alphas_, self.betas_, \
+        self.parameters_mean_, self.parameters_std_, \
+        self.pca_mean_, self.pca_std_, \
+        self.features_mean_, self.features_std_, \
+        self.parameters, self.n_parameters, \
+        self.modes, self.n_modes, \
+        self.n_pcas, self.pca_transform_matrix_, \
+        self.n_hidden, self.n_layers, self.architecture = pickle.load(f)
+        f.close()
+
+
+
+
+    # auxiliary function to sort input parameters
+    def dict_to_ordered_arr_np(self, 
+                               input_dict, 
+                               ):
+        r"""
+        Sort input parameters
+
+        Parameters:
+            input_dict (dict [numpy.ndarray]):
+                input dict of (arrays of) parameters to be sorted
+
+        Returns:
+            numpy.ndarray:
+                parameters sorted according to desired order
+        """
+        if self.parameters is not None:
+            return np.stack([input_dict[k] for k in self.parameters], axis=1)
+        else:
+            return np.stack([input_dict[k] for k in input_dict], axis=1)
+
+
+    # forward prediction given input parameters implemented in Numpy
+    def forward_pass_np(self, 
+                        parameters_arr,
+                        ):
+        r"""
+        Forward pass through the network to predict the output, 
+        fully implemented in Numpy
+
+        Parameters:
+            parameters_arr (numpy.ndarray):
+                array of input parameters
+
+        Returns:
+          numpy.ndarray:
+            output predictions
+        """
+        # forward pass through the network
+        act = []
+        layers = [(parameters_arr - self.parameters_mean_)/self.parameters_std_]
+        for i in range(self.n_layers-1):
+
+            # linear network operation
+            act.append(np.dot(layers[-1], self.W_[i]) + self.b_[i])
+
+            # pass through activation function
+            layers.append((self.betas_[i] + (1.-self.betas_[i])*1./(1.+np.exp(-self.alphas_[i]*act[-1])))*act[-1])
+
+        # final (linear) layer -> (normalized) PCA coefficients
+        layers.append(np.dot(layers[-1], self.W_[-1]) + self.b_[-1])
+
+        # rescale PCA coefficients, multiply out PCA basis -> normalised (log)-spectrum, shift and re-scale (log)-spectrum -> output (log)-spectrum
+        return np.dot(layers[-1]*self.pca_std_ + self.pca_mean_, self.pca_transform_matrix_)*self.features_std_ + self.features_mean_
+
+
+    def predictions_np(self, 
+                       parameters_dict,
+                       ):
+        r"""
+        Predictions given input parameters collected in a dict.
+        Fully implemented in Numpy. Calls ``forward_pass_np``
+        after ordering the input parameter dict
+
+        Parameters:
+            parameters_dict (dict [numpy.ndarray]):
+                dictionary of (arrays of) parameters
+
+        Returns:
+            numpy.ndarray:
+                output predictions
+        """
+        parameters_arr = self.dict_to_ordered_arr_np(parameters_dict)
+        return self.forward_pass_np(parameters_arr)
+
+
+    # 10.**predictions
+    def ten_to_predictions_np(self,
+                              parameters_dict,
+                              ):
+        r"""
+        10^predictions given input parameters collected in a dict.
+        Fully implemented in Numpy. It raises 10 to the output
+        from ``forward_pass_np``
+
+        Parameters:
+            parameters_dict (dict [numpy.ndarray]):
+                dictionary of (arrays of) parameters
+
+        Returns:
+            numpy.ndarray:
+                10^output predictions
+        """
+        return 10.**self.predictions_np(parameters_dict)

classy_szfast/suppress_warnings.py

@@ -0,0 +1,10 @@
+import warnings
+from contextlib import contextmanager
+
+@contextmanager
+def suppress_warnings():
+    warnings.filterwarnings("ignore")
+    try:
+        yield
+    finally:
+        warnings.resetwarnings()

classy_szfast/utils.py

@@ -0,0 +1,62 @@
+import numpy as np
+from datetime import datetime
+import multiprocessing
+import time
+import functools
+import re
+from pkg_resources import resource_filename
+import os
+from scipy import optimize
+from scipy.integrate import quad
+from scipy.interpolate import interp1d
+import math
+from numpy import linalg as LA
+import mcfit
+from mcfit import P2xi
+# import cosmopower
+# import classy_sz as csz
+
+
+
+from scipy.interpolate import LinearNDInterpolator
+from scipy.interpolate import CloughTocher2DInterpolator
+
+kb = 1.38064852e-23 #m2 kg s-2 K-1
+clight = 299792458. #m/s
+hplanck=6.62607004e-34 #m2 kg / s
+firas_T0 = 2.728 #pivot temperature used in the Max Lkl Analysis
+firas_T0_bf = 2.725 #best-fitting temperature
+
+Tcmb_uk = 2.7255e6
+
+G_newton = 6.674e-11
+rho_crit_over_h2_in_GeV_per_cm3 = 1.0537e-5
+
+
+nu_21_cm_in_GHz =  1./21.1*clight*1.e2/1.e9
+x_21_cm = hplanck*nu_21_cm_in_GHz/kb/firas_T0_bf*1.e9
+
+kappa_c = 2.1419 # 4M_2-3M_c see below eq. 9b of https://arxiv.org/pdf/1506.06582.pdf
+
+beta_mu = 2.1923
+
+G1 = np.pi**2./6
+G2 = 2.4041
+G3 = np.pi**4/15.
+a_rho = G2/G3
+alpha_mu = 2.*G1/3./G2 # = 1/beta_mu = π^2/18ζ(3) see eq. 4.15 CUSO lectures.
+
+z_mu_era = 3e5
+z_y_era = 5e4
+z_reio_min = 6
+z_reio_max = 25
+z_recombination_min = 800
+z_recombination_max = 1500
+
+# Physical constants
+# ------------------
+# Light speed
+class Const:
+    c_km_s = 299792.458  # speed of light
+    h_J_s = 6.626070040e-34  # Planck's constant
+    kB_J_K = 1.38064852e-23  # Boltzmann constant

classy_szfast-0.0.0.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: classy_szfast
+Version: 0.0.0
+Summary: The accelerator of the class_sz code from https://github.com/CLASS-SZ
+Maintainer-email: Boris Bolliet <bb667@cam.ac.uk>
+Project-URL: Homepage, https://github.com/CLASS-SZ
+Project-URL: GitHub, https://github.com/CLASS-SZ
+Description-Content-Type: text/markdown
+Requires-Dist: numpy >=1.19.0
+Requires-Dist: Cython >=0.29.21
+Requires-Dist: tensorflow
+Requires-Dist: cosmopower
+Requires-Dist: mcfit
+Requires-Dist: get-cosmopower-emus
+

classy_szfast-0.0.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+classy_szfast/__init__.py,sha256=E2thrL0Z9oXFfdzwcsu-xbOytudLFTlRlPqVFGlPPPg,279
+classy_szfast/classy_sz.py,sha256=QmbwrSXInQLMvCDqsr7KPmtaU0KOiOt1Rb-cTKuulZw,22240
+classy_szfast/classy_szfast.py,sha256=A06tLt_Slxd5TvSQLHaqmX2-Z0aI6p3nWo6jEQ2oWeM,33748
+classy_szfast/config.py,sha256=4CvejtLcFOQR30bJ8tlEeBHhu3Rr7LakeLO6dbFgPSU,210
+classy_szfast/cosmopower.py,sha256=eym72TFAcSJSTUlrwD-sAg8_9e2GdZq0m3lLPQ7uvPU,9858
+classy_szfast/cosmosis_classy_szfast_interface.py,sha256=zAnxvFtn73a5yS7jgs59zpWFEYKCIQyraYPs5hQ4Le8,11483
+classy_szfast/pks_and_sigmas.py,sha256=drtuujE1HhlrYY1hY92DyY5lXlYS1uE15MSuVI4uo6k,6625
+classy_szfast/restore_nn.py,sha256=OyxaRRk9D4hOJTvUSY3c5wAWTPCZJRMxBtin4kq_xd0,14149
+classy_szfast/suppress_warnings.py,sha256=6wIBml2Sj9DyRGZlZWhuA9hqvpxqrNyYjuz6BPK_a6E,202
+classy_szfast/utils.py,sha256=VdaRsJK2ttHI9zkyxVhergxHPC6t99usrlycblyqcP8,1464
+classy_szfast/custom_bias/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+classy_szfast/custom_bias/custom_bias.py,sha256=aR2t5RTIwv7P0m2bsEU0Eq6BTkj4pG10AebH6QpG4qM,486
+classy_szfast/custom_profiles/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+classy_szfast/custom_profiles/custom_profiles.py,sha256=4LZwb2XoqwCyWNmW2s24Z7AJdmgVdaRG7yYaBYe-d9Q,1188
+classy_szfast-0.0.0.dist-info/METADATA,sha256=7upoCRlu-ECxV5fe7aZtRlsDxgwVoi3sOFKcRfNjzzA,497
+classy_szfast-0.0.0.dist-info/WHEEL,sha256=Wyh-_nZ0DJYolHNn1_hMa4lM7uDedD_RGVwbmTjyItk,91
+classy_szfast-0.0.0.dist-info/top_level.txt,sha256=hRgqpilUck4lx2KkaWI2y9aCDKqF6pFfGHfNaoPFxv0,14
+classy_szfast-0.0.0.dist-info/RECORD,,

classy_szfast-0.0.0.dist-info/WHEEL

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

classy_szfast-0.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+classy_szfast