From 6589f932595e4418106fcd2214bd3edd8c583ed9 Mon Sep 17 00:00:00 2001 From: eduardojsbarroso Date: Thu, 21 Jul 2022 07:28:51 -0700 Subject: [PATCH 01/38] Merged into main --- clmm/utils.py.orig | 693 +++++++++++++++++++++++++++++++++++++++ examples/term2h_nc.txt | 100 ++++++ tests/test_utils.py.orig | 413 +++++++++++++++++++++++ 3 files changed, 1206 insertions(+) create mode 100644 clmm/utils.py.orig create mode 100644 examples/term2h_nc.txt create mode 100644 tests/test_utils.py.orig diff --git a/clmm/utils.py.orig b/clmm/utils.py.orig new file mode 100644 index 000000000..5e003905c --- /dev/null +++ b/clmm/utils.py.orig @@ -0,0 +1,693 @@ +"""General utility functions that are used in multiple modules""" +import numpy as np +from scipy.stats import binned_statistic +from scipy.special import gamma, gammainc +from astropy import units as u +from .constants import Constants as const +from scipy.integrate import quad + +def compute_radial_averages(xvals, yvals, xbins, yerr=None, error_model='ste', weights=None): + """ Given a list of xvals, yvals and bins, sort into bins. If xvals or yvals + contain non-finite values, these are filtered. + + Parameters + ---------- + xvals : array_like + Values to be binned + yvals : array_like + Values to compute statistics on + xbins: array_like + Bin edges to sort into + yerr : array_like, None + Errors of component y + error_model : str, optional + Statistical error model to use for y uncertainties. (letter case independent) + + * `ste` - Standard error [=std/sqrt(n) in unweighted computation] (Default). + * `std` - Standard deviation. + + weights: array_like, None + Weights for averages. + + + Returns + ------- + mean_x : array_like + Mean x value in each bin + mean_y : array_like + Mean y value in each bin + err_y: array_like + Error on the mean y value in each bin. Specified by error_model + num_objects : array_like + Number of objects in each bin + binnumber: 1-D ndarray of ints + Indices of the bins (corresponding to `xbins`) in which each value + of `xvals` belongs. Same length as `yvals`. A binnumber of `i` means the + corresponding value is between (xbins[i-1], xbins[i]). + """ + # make case independent + error_model = error_model.lower() + # binned_statics throus an error in case of non-finite values, so filtering those out + filt = np.isfinite(xvals)*np.isfinite(yvals) + x, y = np.array(xvals)[filt], np.array(yvals)[filt] + # normalize weights (and computers binnumber) + wts = np.ones(x.size) if weights is None else np.array(weights, dtype=float)[filt] + wts_sum, binnumber = binned_statistic(x, wts, statistic='sum', bins=xbins)[:3:2] + objs_in_bins = (binnumber>0)*(binnumber<=wts_sum.size) # mask for binnumber in range + wts[objs_in_bins] *= 1./wts_sum[binnumber[objs_in_bins]-1] # norm weights in each bin + weighted_bin_stat = lambda vals: binned_statistic(x, vals*wts, statistic='sum', bins=xbins)[0] + # means + mean_x = weighted_bin_stat(x) + mean_y = weighted_bin_stat(y) + # errors + data_yerr2 = 0 if yerr is None else weighted_bin_stat(np.array(yerr)[filt]**2*wts) + stat_yerr2 = weighted_bin_stat(y**2)-mean_y**2 + if error_model == 'ste': + stat_yerr2 *= weighted_bin_stat(wts) # sum(wts^2)=1/n for not weighted + elif error_model != 'std': + raise ValueError(f"{error_model} not supported err model for binned stats") + err_y = np.sqrt(stat_yerr2+data_yerr2) + # number of objects + num_objects = np.histogram(x, xbins)[0] + return mean_x, mean_y, err_y, num_objects, binnumber + + +def make_bins(rmin, rmax, nbins=10, method='evenwidth', source_seps=None): + """ Define bin edges + + Parameters + ---------- + rmin : float + Minimum bin edges wanted + rmax : float + Maximum bin edges wanted + nbins : float + Number of bins you want to create, default to 10. + method : str, optional + Binning method to use (letter case independent): + + * `evenwidth` - Default, evenly spaced bins between rmin and rmax + * `evenlog10width` - Logspaced bins with even width in log10 between rmin and rmax + * `equaloccupation` - Bins with equal occupation numbers + + source_seps : array_like + Radial distance of source separations + + Returns + ------- + binedges: array_like, float + n_bins+1 dimensional array that defines bin edges + """ + # make case independent + method = method.lower() + # Check consistency + if (rmin > rmax) or (rmin < 0.0) or (rmax < 0.0): + raise ValueError(f"Invalid bin endpoints in make_bins, {rmin} {rmax}") + if (nbins <= 0) or not isinstance(nbins, int): + raise ValueError( + f"Invalid nbins={nbins}. Must be integer greater than 0.") + + if method == 'evenwidth': + binedges = np.linspace(rmin, rmax, nbins+1, endpoint=True) + elif method == 'evenlog10width': + binedges = np.logspace(np.log10(rmin), np.log10( + rmax), nbins+1, endpoint=True) + elif method == 'equaloccupation': + if source_seps is None: + raise ValueError( + f"Binning method '{method}' requires source separations array") + # by default, keep all galaxies + seps = np.array(source_seps) + mask = np.full(seps.size, True) + if rmin is not None or rmax is not None: + # Need to filter source_seps to only keep galaxies in the [rmin, rmax] + rmin = seps.min() if rmin is None else rmin + rmax = seps.max() if rmax is None else rmax + mask = (seps >= rmin)*(seps <= rmax) + binedges = np.percentile(seps[mask], tuple( + np.linspace(0, 100, nbins+1, endpoint=True))) + else: + raise ValueError( + f"Binning method '{method}' is not currently supported") + + return binedges + + +def convert_units(dist1, unit1, unit2, redshift=None, cosmo=None): + """ Convenience wrapper to convert between a combination of angular and physical units. + + Supported units: radians, degrees, arcmin, arcsec, Mpc, kpc, pc + (letter case independent) + + To convert between angular and physical units you must provide both + a redshift and a cosmology object. + + Parameters + ---------- + dist1 : array_like + Input distances + unit1 : str + Unit for the input distances + unit2 : str + Unit for the output distances + redshift : float + Redshift used to convert between angular and physical units + cosmo : CLMM.Cosmology + CLMM Cosmology object to compute angular diameter distance to + convert between physical and angular units + + Returns + ------- + dist2: array_like + Input distances converted to unit2 + """ + # make case independent + unit1, unit2 = unit1.lower(), unit2.lower() + # Available units + angular_bank = {"radians": u.rad, "degrees": u.deg, + "arcmin": u.arcmin, "arcsec": u.arcsec} + physical_bank = {"pc": u.pc, "kpc": u.kpc, "mpc": u.Mpc} + units_bank = {**angular_bank, **physical_bank} + # Some error checking + if unit1 not in units_bank: + raise ValueError(f"Input units ({unit1}) not supported") + if unit2 not in units_bank: + raise ValueError(f"Output units ({unit2}) not supported") + # Try automated astropy unit conversion + try: + dist2 = (dist1*units_bank[unit1]).to(units_bank[unit2]).value + # Otherwise do manual conversion + except u.UnitConversionError: + # Make sure that we were passed a redshift and cosmology + if redshift is None or cosmo is None: + raise TypeError( + "Redshift and cosmology must be specified to convert units") \ + from u.UnitConversionError + # Redshift must be greater than zero for this approx + if not redshift > 0.0: + raise ValueError("Redshift must be greater than 0.") from u.UnitConversionError + # Convert angular to physical + if (unit1 in angular_bank) and (unit2 in physical_bank): + dist1_rad = (dist1*units_bank[unit1]).to(u.rad).value + dist1_mpc = cosmo.rad2mpc(dist1_rad, redshift) + dist2 = (dist1_mpc*u.Mpc).to(units_bank[unit2]).value + # Otherwise physical to angular + else: + dist1_mpc = (dist1*units_bank[unit1]).to(u.Mpc).value + dist1_rad = cosmo.mpc2rad(dist1_mpc, redshift) + dist2 = (dist1_rad*u.rad).to(units_bank[unit2]).value + return dist2 + + +def convert_shapes_to_epsilon(shape_1, shape_2, shape_definition='epsilon', kappa=0): + r""" Convert shape components 1 and 2 appropriately to make them estimators of the reduced shear + once averaged. The shape 1 and 2 components may correspond to ellipticities according the + :math:`\epsilon`- or :math:`\chi`-definition, but also to the 1 and 2 components of the shear. + See Bartelmann & Schneider 2001 for details (https://arxiv.org/pdf/astro-ph/9912508.pdf). + + The :math:`\epsilon`-ellipticity is a direct estimator of + the reduced shear. The shear :math:`\gamma` may be converted to reduced shear :math:`g` if the + convergence :math:`\kappa` is known. The conversions are given below. + + .. math:: + \epsilon = \frac{\chi}{1+(1-|\chi|^2)^{1/2}} + + .. math:: + g=\frac{\gamma}{1-\kappa} + + - If `shape_definition = 'chi'`, this function returns the corresponding `epsilon` ellipticities + + - If `shape_definition = 'shear'`, it returns the corresponding reduced shear, given the + convergence `kappa` + + - If `shape_definition = 'epsilon'` or `'reduced_shear'`, it returns them as is as no conversion + is needed. + + Parameters + ---------- + shape_1 : array_like + Input shapes or shears along principal axis (g1 or e1) + shape_2 : array_like + Input shapes or shears along secondary axis (g2 or e2) + shape_definition : str + Definition of the input shapes, can be ellipticities 'epsilon' or 'chi' or shears 'shear' or + 'reduced_shear' + kappa : array_like + Convergence for transforming to a reduced shear. Default is 0 + + Returns + ------- + epsilon_1 : array_like + Epsilon ellipticity (or reduced shear) along principal axis (epsilon1) + epsilon_2 : array_like + Epsilon ellipticity (or reduced shear) along secondary axis (epsilon2) + """ + + if shape_definition in ('epsilon', 'reduced_shear'): + epsilon_1, epsilon_2 = shape_1, shape_2 + elif shape_definition == 'chi': + chi_to_eps_conversion = 1./(1.+(1-(shape_1**2+shape_2**2))**0.5) + epsilon_1, epsilon_2 = shape_1*chi_to_eps_conversion, shape_2*chi_to_eps_conversion + elif shape_definition == 'shear': + epsilon_1, epsilon_2 = shape_1/(1.-kappa), shape_2/(1.-kappa) + else: + raise TypeError("Please choose epsilon, chi, shear, reduced_shear") + return epsilon_1, epsilon_2 + + +def build_ellipticities(q11, q22, q12): + """ Build ellipticties from second moments. See, e.g., Schneider et al. (2006) + + Parameters + ---------- + q11 : float or array + Second brightness moment tensor, component (1,1) + q22 : float or array + Second brightness moment tensor, component (2,2) + q12 : float or array + Second brightness moment tensor, component (1,2) + + Returns + ------- + chi1, chi2 : float or array + Ellipticities using the "chi definition" + epsilon1, epsilon2 : float or array + Ellipticities using the "epsilon definition" + """ + norm_x, norm_e = q11+q22, q11+q22+2*np.sqrt(q11*q22-q12*q12) + chi1, chi2 = (q11-q22)/norm_x, 2*q12/norm_x + epsilon1, epsilon2 = (q11-q22)/norm_e, 2*q12/norm_e + return chi1, chi2, epsilon1, epsilon2 + + +def compute_lensed_ellipticity(ellipticity1_true, ellipticity2_true, shear1, shear2, convergence): + r""" Compute lensed ellipticities from the intrinsic ellipticities, shear and convergence. + Following Schneider et al. (2006) + + .. math:: + \epsilon^{\rm lensed}=\epsilon^{\rm lensed}_1+i\epsilon^{\rm lensed}_2= + \frac{\epsilon^{\rm true}+g}{1+g^\ast\epsilon^{\rm true}}, + + where, the complex reduced shear :math:`g` is obtained from the shear + :math:`\gamma=\gamma_1+i\gamma_2` and convergence :math:`\kappa` as :math:`g = + \gamma/(1-\kappa)`, and the complex intrinsic ellipticity is :math:`\epsilon^{\rm + true}=\epsilon^{\rm true}_1+i\epsilon^{\rm true}_2` + + Parameters + ---------- + ellipticity1_true : float or array + Intrinsic ellipticity of the sources along the principal axis + ellipticity2_true : float or array + Intrinsic ellipticity of the sources along the second axis + shear1 : float or array + Shear component (not reduced shear) along the principal axis at the source location + shear2 : float or array + Shear component (not reduced shear) along the 45-degree axis at the source location + convergence : float or array + Convergence at the source location + Returns + ------- + e1, e2 : float or array + Lensed ellipicity along both reference axes. + """ + # shear (as a complex number) + shear = shear1+shear2*1j + # intrinsic ellipticity (as a complex number) + ellipticity_true = ellipticity1_true+ellipticity2_true*1j + # reduced shear + reduced_shear = shear/(1.0-convergence) + # lensed ellipticity + lensed_ellipticity = (ellipticity_true+reduced_shear) / \ + (1.0+reduced_shear.conjugate()*ellipticity_true) + return np.real(lensed_ellipticity), np.imag(lensed_ellipticity) + + +def arguments_consistency(arguments, names=None, prefix=''): + r"""Make sure all arguments have the same length (or are scalars) + + Parameters + ---------- + arguments: list, arrays, tuple + Group of arguments to be checked + names: list, tuple + Names for each array, optional + prefix: str + Customized prefix for error message + + Returns + ------- + list, arrays, tuple + Group of arguments, converted to numpy arrays if they have length + """ + sizes = [len(arg) if hasattr(arg, '__len__') + else None for arg in arguments] + # check there is a name for each argument + if names: + if len(names) != len(arguments): + raise TypeError( + f'names (len={len(names)}) must have same length ' + f'as arguments (len={len(arguments)})') + msg = ', '.join([f'{n}({s})' for n, s in zip(names, sizes)]) + else: + msg = ', '.join([f'{s}' for s in sizes]) + # check consistency + if any(sizes): + # Check that all of the inputs have length and they match + if not all(sizes) or any([s != sizes[0] for s in sizes[1:]]): + # make error message + raise TypeError(f'{prefix} inconsistent sizes: {msg}') + return tuple(np.array(arg) for arg in arguments) + return arguments + + +def _patch_rho_crit_to_cd2018(rho_crit_external): + r""" Convertion factor for rho_crit of any external modult to + CODATA 2018+IAU 2015 + + rho_crit_external: float + Critical density of the Universe in units of :math:`M_\odot\ Mpc^{-3}` + """ + + rhocrit_mks = 3.0*100.0*100.0/(8.0*np.pi*const.GNEWT.value) + rhocrit_cd2018 = (rhocrit_mks*1000.0*1000.0* + const.PC_TO_METER.value*1.0e6/const.SOLAR_MASS.value) + + return rhocrit_cd2018/rho_crit_external + +_valid_types = { + float: (float, int, np.floating, np.integer), + int: (int, np.integer), + 'float_array': (float, int, np.floating, np.integer), + 'int_array': (int, np.integer) + } + +def _is_valid(arg, valid_type): + r"""Check if argument is of valid type, supports arrays. + + Parameters + ---------- + arg: any + Argument to be tested. + valid_type: str, type + Valid types for argument, options are object types, list/tuple of types, or: + + * `int_array` - interger, interger array + * `float_array` - float, float array + + Returns + ------- + valid: bool + Is argument valid + """ + return (isinstance(arg[0], _valid_types[valid_type]) + if (valid_type in ('int_array', 'float_array') and np.iterable(arg)) + else isinstance(arg, _valid_types.get(valid_type, valid_type))) + + +def validate_argument(loc, argname, valid_type, none_ok=False, argmin=None, argmax=None, + eqmin=False, eqmax=False): + r"""Validate argument type and raise errors. + + Parameters + ---------- + loc: dict + Dictionaty with all input arguments. Should be locals(). + argname: str + Name of argument to be tested. + valid_type: str, type + Valid types for argument, options are object types, list/tuple of types, or: + + * `int_array` - interger, interger array + * `float_array` - float, float array + + none_ok: True + Accepts None as a valid type. + argmin (optional) : int, float, None + Minimum value allowed. + argmax (optional) : int, float, None + Maximum value allowed. + eqmin: bool + Accepts min(arg)==argmin. + eqmax: bool + Accepts max(arg)==argmax. + """ + var = loc[argname] + # Check for None + if none_ok and (var is None): + return + # Check for type + valid = (any(_is_valid(var, types) for types in valid_type) + if isinstance(valid_type, (list, tuple)) + else _is_valid(var, valid_type)) + if not valid: + err = f'{argname} must be {valid_type}, received {type(var).__name__}' + raise TypeError(err) + # Check min/max + if any(t is not None for t in (argmin, argmax)): + try: + var_array = np.array(var, dtype=float) + except: + err = f'{argname} ({type(var).__name__}) cannot be converted to number' \ + ' for min/max validation.' + raise TypeError(err) + if argmin is not None: + if (var_array.min()argmax if eqmax else var_array.max()>=argmax): + err = f'{argname} must be lesser than {argmax},' \ + f' received {"vec_max:"*(var_array.size-1)}{var}' + raise ValueError(err) + +def compute_beta(z_s, z_cl, cosmo): + r"""Geometric lensing efficicency + + .. math:: + beta = max(0, Dang_ls/Dang_s) + + Eq.2 in https://arxiv.org/pdf/1611.03866.pdf + + Parameters + ---------- + z_cl: float + Galaxy cluster redshift + z_s: float + Source galaxy redshift + cosmo: Cosmology + Cosmology object + + Returns + ------- + float + Geometric lensing efficicency + """ + beta = np.heaviside(z_s-z_cl, 0) * cosmo.eval_da_z1z2(z_cl, z_s) / cosmo.eval_da(z_cl) + return beta + +def compute_beta_s(z_s, z_cl, z_inf, cosmo): + r"""Geometric lensing efficicency ratio + + .. math:: + beta_s =beta(z_s)/beta(z_inf) + + Parameters + ---------- + z_cl: float + Galaxy cluster redshift + z_s: float + Source galaxy redshift + z_inf: float + Redshift at infinity + cosmo: Cosmology + Cosmology object + + Returns + ------- + float + Geometric lensing efficicency ratio + """ + beta_s = compute_beta(z_s, z_cl, cosmo) / compute_beta(z_inf, z_cl, cosmo) + return beta_s + +def compute_beta_mean(z_cl, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, pdz=None): + r"""Mean value of the geometric lensing efficicency + + .. math:: + \left\ =\frac{\sum_{z = z_{min}}^{z = z_{max}}\beta(z)p(z)}{\sum_{z = z_{min}}^{z = z_{max}}p(z)} + + Parameters + ---------- + z_cl: float + Galaxy cluster redshift + z_inf: float + Redshift at infinity + pdz: argument function + Redshift probability density function. Default is\ + Chang et al (2013) unnormalized galaxy redshift distribution\ + function. + zmin: float + Minimum redshift to be set as the source of the galaxy\ + when performing the sum. + zmax: float + Maximum redshift to be set as the source of the galaxy\ + when performing the sum. + delta_z_cut: float + Redshift interval to be summed with $z_cl$ to return\ + a $zmin$. This feature is not used if $zmin$ is provided. + cosmo: Cosmology + Cosmology object + + Returns + ------- + float + Mean value of the geometric lensing efficicency + """ + if pdz == None: + pdz = _chang_z_distrib + def integrand(z_i, z_cl=z_cl, cosmo=cosmo): + return compute_beta(z_i, z_cl, cosmo) * pdz(z_i) + + if zmin==None: + zmin = z_cl + delta_z_cut + + B_mean = quad(integrand, zmin, zmax)[0] / quad(pdz, zmin, zmax)[0] + return B_mean + +def compute_beta_s_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, pdz=None): + r"""Mean value of the geometric lensing efficicency ratio + + .. math:: + \left\ =\frac{\sum_{z = z_{min}}^{z = z_{max}}\beta_s(z)p(z)}{\sum_{z = z_{min}}^{z = z_{max}}p(z)} + + Parameters + ---------- + z_cl: float + Galaxy cluster redshift + z_inf: float + Redshift at infinity + pdz: argument function + Redshift probability density function. Default is\ + Chang et al (2013) unnormalized galaxy redshift distribution\ + function. + zmin: float + Minimum redshift to be set as the source of the galaxy\ + when performing the sum. + zmax: float + Minimum redshift to be set as the source of the galaxy\ + when performing the sum. + delta_z_cut: float + Redshift interval to be summed with $z_cl$ to return\ + a $zmin$. This feature is not used if $zmin$ is provided. + cosmo: Cosmology + Cosmology object + + Returns + ------- + float + Mean value of the geometric lensing efficicency ratio + """ + if pdz == None: + pdz = _chang_z_distrib + + def integrand(z_i, z_cl=z_cl, z_inf=z_inf, cosmo=cosmo): + return compute_beta_s(z_i, z_cl, z_inf, cosmo) * pdz(z_i) + + if zmin==None: + zmin = z_cl + delta_z_cut + Bs_mean = quad(integrand, zmin, zmax)[0] / quad(pdz, zmin, zmax)[0] + return Bs_mean + +def compute_beta_s_square_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, pdz=None): + r"""Mean square value of the geometric lensing efficicency ratio + + .. math:: + \left\2 =\frac{\sum_{z = z_{min}}^{z = z_{max}}\beta_s^2(z)p(z)}{\sum_{z = z_{min}}^{z = z_{max}}p(z)} + + Parameters + ---------- + z_cl: float + Galaxy cluster redshift + z_inf: float + Redshift at infinity + pdz: argument function + Redshift probability density function. Default is\ + Chang et al (2013) unnormalized galaxy redshift distribution\ + function. + zmin: float + Minimum redshift to be set as the source of the galaxy\ + when performing the sum. + zmax: float + Minimum redshift to be set as the source of the galaxy\ + when performing the sum. + delta_z_cut: float + Redshift interval to be summed with $z_cl$ to return\ + a $zmin$. This feature is not used if $zmin$ is provided. + cosmo: Cosmology + Cosmology object + + Returns + ------- + float + Mean square value of the geometric lensing efficicency ratio. + """ + if pdz == None: + pdz = _chang_z_distrib + + def integrand(z_i, z_cl=z_cl, z_inf=z_inf, cosmo=cosmo): + return compute_beta_s(z_i, z_cl, z_inf, cosmo)**2 * pdz(z_i) + + if zmin==None: + zmin = z_cl + delta_z_cut +<<<<<<< HEAD + Bs_s_mean = quad(integrand, zmin, zmax)[0] / quad(pdz, zmin, zmax)[0] + return Bs_s_mean +======= + Bs_mean = quad(integrand, zmin, zmax)[0] / quad(pdz, zmin, zmax)[0] + return Bs_mean + +def _chang_z_distrib(redshift, is_cdf=False): + """ + A private function that returns the Chang et al (2013) unnormalized galaxy redshift distribution + function, with the fiducial set of parameters. + + Parameters + ---------- + redshift : float + Galaxy redshift + is_cdf : bool + If True, returns cumulative distribution function. + + Returns + ------- + The value of the distribution at z + """ + alpha, beta, redshift0 = 1.24, 1.01, 0.51 + if is_cdf: + return redshift0**(alpha+1)*gammainc((alpha+1)/beta, (redshift/redshift0)**beta)/beta*gamma((alpha+1)/beta) + else: + return (redshift**alpha)*np.exp(-(redshift/redshift0)**beta) + +def _srd_z_distrib(redshift, is_cdf=False): + """ + A private function that returns the unnormalized galaxy redshift distribution function used in + the LSST/DESC Science Requirement Document (arxiv:1809.01669). + + Parameters + ---------- + redshift : float + Galaxy redshift + is_cdf : bool + If True, returns cumulative distribution function. + + Returns + ------- + The value of the distribution at z + """ + alpha, beta, redshift0 = 2., 0.9, 0.28 + if is_cdf: + return redshift0**(alpha+1)*gammainc((alpha+1)/beta, (redshift/redshift0)**beta)/beta*gamma((alpha+1)/beta) + else: + return (redshift**alpha)*np.exp(-(redshift/redshift0)**beta) +>>>>>>> 22eda2796c3d436b3c6dfaca05046adb9a646874 diff --git a/examples/term2h_nc.txt b/examples/term2h_nc.txt new file mode 100644 index 000000000..cc2f7f48d --- /dev/null +++ b/examples/term2h_nc.txt @@ -0,0 +1,100 @@ +1.000000000000000021e-02 2.450321215942639542e+10 +1.097498765493056146e-02 2.582364849782210922e+10 +1.204503540258782326e-02 2.717986641351715469e+10 +1.321941148466028795e-02 2.875505951695832443e+10 +1.450828778495939428e-02 3.072292569362144089e+10 +1.592282793341092198e-02 3.314568384264012527e+10 +1.747528400007683849e-02 3.589019518063602448e+10 +1.917910261672488639e-02 3.866510386589351654e+10 +2.104904144512020903e-02 4.124642492877477264e+10 +2.310129700083160542e-02 4.375949119816561890e+10 +2.535364493970111363e-02 4.663945700533943939e+10 +2.782559402207124277e-02 5.007795312893126678e+10 +3.053855508833415444e-02 5.364302065496985626e+10 +3.351602650938842465e-02 5.702479777682296753e+10 +3.678379771828634015e-02 6.077313394732890320e+10 +4.037017258596553582e-02 6.502378972815399170e+10 +4.430621457583882455e-02 6.914267117891433716e+10 +4.862601580065353118e-02 7.367832082273686218e+10 +5.336699231206309957e-02 7.849099949712435913e+10 +5.857020818056667133e-02 8.344389834407061768e+10 +6.428073117284321958e-02 8.879009839267294312e+10 +7.054802310718645553e-02 9.436155627241120911e+10 +7.742636826811269413e-02 1.001730588849221191e+11 +8.497534359086446332e-02 1.063974460165665131e+11 +9.326033468832199691e-02 1.128747383454654999e+11 +1.023531021899026366e-01 1.196363307049693756e+11 +1.123324032978027659e-01 1.267320510040680084e+11 +1.232846739442066547e-01 1.341688570392554474e+11 +1.353047774579807516e-01 1.419454959612069092e+11 +1.484968262254464932e-01 1.500484800730760193e+11 +1.629750834620644351e-01 1.584733909994166870e+11 +1.788649529057435017e-01 1.672710560533544006e+11 +1.963040650040271395e-01 1.763854633189150085e+11 +2.154434690031884481e-01 1.858598252718684692e+11 +2.364489412645408295e-01 1.956639196399551392e+11 +2.595024211399737379e-01 2.057852114509843140e+11 +2.848035868435802032e-01 2.162214395589595032e+11 +3.125715849688237014e-01 2.269960181723335571e+11 +3.430469286314919430e-01 2.380772026773450012e+11 +3.764935806792469308e-01 2.494060497311617126e+11 +4.132012400115338546e-01 2.608117676747231140e+11 +4.534878508128584174e-01 2.729142770443499451e+11 +4.977023564332111460e-01 2.848286240289870605e+11 +5.462277217684342601e-01 2.968217913506503296e+11 +5.994842503189411476e-01 3.095263003383236694e+11 +6.579332246575682053e-01 3.216722843219785156e+11 +7.220809018385467848e-01 3.341219960756307373e+11 +7.924828983539177196e-01 3.469056480416076050e+11 +8.697490026177834288e-01 3.589080179125376587e+11 +9.545484566618341882e-01 3.715064833301427612e+11 +1.047615752789665233e+00 3.837582142192907104e+11 +1.149756995397736903e+00 3.949933687838672485e+11 +1.261856883066021062e+00 4.072353933249326172e+11 +1.384886371393873050e+00 4.183155997483372192e+11 +1.519911082952934755e+00 4.282539736912182617e+11 +1.668100537200059241e+00 4.394270609114318237e+11 +1.830738280295369780e+00 4.485853924575095825e+11 +2.009233002565047776e+00 4.568394253247011108e+11 +2.205130739903045534e+00 4.657253947823126831e+11 +2.420128264794383366e+00 4.720264871379987793e+11 +2.656087782946686904e+00 4.783374304151119385e+11 +2.915053062825178731e+00 4.835202033891856689e+11 +3.199267137797384475e+00 4.861481485057972412e+11 +3.511191734215134641e+00 4.897071519766116333e+11 +3.853528593710531247e+00 4.909615239880612183e+11 +4.229242874389498752e+00 4.887889937525338745e+11 +4.641588833612781961e+00 4.890118723536967163e+11 +5.094138014816380178e+00 4.852691040884033813e+11 +5.590810182512228721e+00 4.788424516505772095e+11 +6.135907273413176100e+00 4.749955659364075317e+11 +6.734150657750828550e+00 4.656489189290159302e+11 +7.390722033525782386e+00 4.556975134323302612e+11 +8.111308307896871739e+00 4.457718625114807739e+11 +8.902150854450392004e+00 4.307686450427430420e+11 +9.770099572992256398e+00 4.181127966914452515e+11 +1.072267222010324339e+01 4.029579234428847656e+11 +1.176811952434999142e+01 3.824960964864786377e+11 +1.291549665014884063e+01 3.676805133867901001e+11 +1.417474162926806258e+01 3.483574896556759033e+11 +1.555676143930472222e+01 3.245351796807640991e+11 +1.707352647470692020e+01 3.093679167254439087e+11 +1.873817422860384951e+01 2.865114091601412354e+11 +2.056512308348653661e+01 2.628138242063374023e+11 +2.257019719633921540e+01 2.458918336387040710e+11 +2.477076355991711409e+01 2.210363407311755676e+11 +2.718588242732942817e+01 2.025139727240394287e+11 +2.983647240283340452e+01 1.828613941084895935e+11 +3.274549162877731590e+01 1.585754621992243958e+11 +3.593813663804629499e+01 1.457694431423413086e+11 +3.944206059437659917e+01 1.287957930683296661e+11 +4.328761281083061618e+01 1.040817541542567749e+11 +4.750810162102798273e+01 9.876485313003871155e+10 +5.214008287999689628e+01 8.314542821097509766e+10 +5.722367659350220492e+01 6.477508455225241089e+10 +6.280291441834259558e+01 6.486439088418131256e+10 +6.892612104349701951e+01 5.040400910539440918e+10 +7.564633275546290747e+01 4.205551185695338440e+10 +8.302175681319752698e+01 3.857194131048378754e+10 +9.111627561154895716e+01 2.457745561368053818e+10 +1.000000000000000000e+02 2.591326326844504166e+10 diff --git a/tests/test_utils.py.orig b/tests/test_utils.py.orig new file mode 100644 index 000000000..e49af704b --- /dev/null +++ b/tests/test_utils.py.orig @@ -0,0 +1,413 @@ +# pylint: disable=no-member, protected-access +""" Tests for utils.py """ +import numpy as np +from numpy.testing import assert_raises, assert_allclose +from scipy.integrate import quad +import clmm.utils as utils +import clmm.theory as md +from clmm.utils import ( + compute_radial_averages, make_bins, convert_shapes_to_epsilon, arguments_consistency, + validate_argument) + + +TOLERANCE = {'rtol': 1.0e-6, 'atol': 0} + + +def test_compute_radial_averages(): + """ Tests compute_radial_averages, a function that computes several binned statistics """ + # Make some test data + binvals = np.array([2., 3., 6., 8., 4., 9.]) + xbins1 = [0., 10.] + xbins2 = [0., 5., 10.] + + # Test requesting an unsupported error model + assert_raises(ValueError, compute_radial_averages, binvals, binvals, [0., 10.], error_model='glue') + + # Check the default error model + assert_allclose(compute_radial_averages(binvals, binvals, xbins1)[:4], + [[np.mean(binvals)], [np.mean(binvals)], [np.std(binvals)/np.sqrt(len(binvals))], + [6]], + **TOLERANCE) + # Test weights + # Normalized + assert_allclose(compute_radial_averages([1, 1], [2, 3], [1, 2], weights=[.5, .5])[:3], + ([1], [2.5], [1/np.sqrt(8)]), + **TOLERANCE) + # Not normalized + assert_allclose(compute_radial_averages([1, 1], [2, 3], [1, 2], weights=[5, 5])[:3], + ([1], [2.5], [1/np.sqrt(8)]), + **TOLERANCE) + # Values outside bins + assert_allclose(compute_radial_averages([1, 1, 3], [2, 3, 1000], [1, 2], weights=[.5, .5, 100])[:3], + ([1], [2.5], [1/np.sqrt(8)]), + **TOLERANCE) + # Weighted values == Repeated values (std only) + assert_allclose(compute_radial_averages([1, 1], [2, 3], [1, 2], weights=[1, 2], error_model='std')[:3], + compute_radial_averages([1, 1, 1], [2, 3, 3], [1, 2], error_model='std')[:3], + **TOLERANCE) + # Zero yerr + assert_allclose(compute_radial_averages([1, 1], [2, 3], [1, 2], weights=[.5, .5], yerr=[0, 0])[:3], + ([1], [2.5], [1/np.sqrt(8)]), + **TOLERANCE) + # With yerr + assert_allclose(compute_radial_averages([1, 1], [2, 3], [1, 2], weights=[.5, .5], yerr=[1, 1])[:3], + ([1], [2.5], [np.sqrt(5/8)]), + **TOLERANCE) + + # Test 3 objects in one bin with various error models + assert_allclose(compute_radial_averages(binvals, binvals, xbins1, error_model='ste')[:4], + [[np.mean(binvals)], [np.mean(binvals)], [np.std(binvals)/np.sqrt(len(binvals))], [6]], + **TOLERANCE) + assert_allclose(compute_radial_averages(binvals, binvals, xbins1, error_model='std')[:4], + [[np.mean(binvals)], [np.mean(binvals)], [np.std(binvals)], + [6]], **TOLERANCE) + + # Repeat test with different error_model case + assert_allclose(compute_radial_averages(binvals, binvals, xbins1, error_model='STE')[:4], + [[np.mean(binvals)], [np.mean(binvals)], [np.std(binvals)/np.sqrt(len(binvals))], [6]], + **TOLERANCE) + assert_allclose(compute_radial_averages(binvals, binvals, xbins1, error_model='STD')[:4], + [[np.mean(binvals)], [np.mean(binvals)], [np.std(binvals)], + [6]], **TOLERANCE) + + + # A slightly more complicated case with two bins + inbin1 = binvals[(binvals > xbins2[0]) & (binvals < xbins2[1])] + inbin2 = binvals[(binvals > xbins2[1]) & (binvals < xbins2[2])] + assert_allclose(compute_radial_averages(binvals, binvals, xbins2, error_model='ste')[:4], + [[np.mean(inbin1), np.mean(inbin2)], [np.mean(inbin1), np.mean(inbin2)], + [np.std(inbin1)/np.sqrt(len(inbin1)), np.std(inbin2)/np.sqrt(len(inbin2))], + [3,3]], **TOLERANCE) + assert_allclose(compute_radial_averages(binvals, binvals, xbins2, error_model='std')[:4], + [[np.mean(inbin1), np.mean(inbin2)], [np.mean(inbin1), np.mean(inbin2)], + [np.std(inbin1), np.std(inbin2)], + [3,3]], **TOLERANCE) + + # Test a much larger, random sample with unevenly spaced bins + binvals = np.loadtxt('tests/data/radial_average_test_array.txt') + xbins2 = [0.0, 3.33, 6.66, 10.0] + inbin1 = binvals[(binvals > xbins2[0]) & (binvals < xbins2[1])] + inbin2 = binvals[(binvals > xbins2[1]) & (binvals < xbins2[2])] + inbin3 = binvals[(binvals > xbins2[2]) & (binvals < xbins2[3])] + assert_allclose(compute_radial_averages(binvals, binvals, xbins2, error_model='ste')[:4], + [[np.mean(inbin1), np.mean(inbin2), np.mean(inbin3)], + [np.mean(inbin1), np.mean(inbin2), np.mean(inbin3)], + [np.std(inbin1)/np.sqrt(len(inbin1)), np.std(inbin2)/np.sqrt(len(inbin2)), + np.std(inbin3)/np.sqrt(len(inbin3))], + [inbin1.size, inbin2.size, inbin3.size]], **TOLERANCE) + assert_allclose(compute_radial_averages(binvals, binvals, xbins2, error_model='std')[:4], + [[np.mean(inbin1), np.mean(inbin2), np.mean(inbin3)], + [np.mean(inbin1), np.mean(inbin2), np.mean(inbin3)], + [np.std(inbin1), np.std(inbin2), np.std(inbin3)], + [inbin1.size, inbin2.size, inbin3.size]], **TOLERANCE) + +def test_make_bins(): + """ Test the make_bins function. Right now this function is pretty simplistic and the + tests are pretty circular. As more functionality is added here the tests will + become more substantial. + """ + # Test various combinations of rmin and rmax with default values + assert_allclose(make_bins(0.0, 10.), np.linspace( + 0.0, 10., 11), **TOLERANCE) + assert_raises(ValueError, make_bins, 0.0, -10.) + assert_raises(ValueError, make_bins, -10., 10.) + assert_raises(ValueError, make_bins, -10., -5.) + assert_raises(ValueError, make_bins, 10., 0.0) + + # Test various nbins + assert_allclose(make_bins(0.0, 10., nbins=3), + np.linspace(0.0, 10., 4), **TOLERANCE) + assert_allclose(make_bins(0.0, 10., nbins=13), + np.linspace(0.0, 10., 14), **TOLERANCE) + assert_raises(ValueError, make_bins, 0.0, 10., -10) + assert_raises(ValueError, make_bins, 0.0, 10., 0) + + # Test default method + assert_allclose(make_bins(0.0, 10., nbins=10), + make_bins(0.0, 10., nbins=10, method='evenwidth'), + **TOLERANCE) + + # Test the different binning methods + assert_allclose(make_bins(0.0, 10., nbins=10, method='evenwidth'), + np.linspace(0.0, 10., 11), **TOLERANCE) + assert_allclose(make_bins(1.0, 10., nbins=10, method='evenlog10width'), + np.logspace(np.log10(1.0), np.log10(10.), 11), **TOLERANCE) + + # Repeat test with different error_model case + assert_allclose(make_bins(0.0, 10., nbins=10, method='EVENWIDTH'), + np.linspace(0.0, 10., 11), **TOLERANCE) + assert_allclose(make_bins(1.0, 10., nbins=10, method='EVENLOG10WIDTH'), + np.logspace(np.log10(1.0), np.log10(10.), 11), **TOLERANCE) + + # Test equaloccupation method. It needs a source_seps array, so create one + test_array = np.sqrt(np.random.uniform(-10, 10, 1361) + ** 2+np.random.uniform(-10, 10, 1361)**2) + test_bins = make_bins(1.0, 10., nbins=10, + method='equaloccupation', source_seps=test_array) + # Check that all bins have roughly equal occupation. + # Assert needs atol=2, because len(source_seps)/nbins may not be an integer, + # and for some random arrays atol=1 is not enough. + assert_allclose(np.diff(np.histogram(test_array, bins=test_bins)[0]), + np.zeros(9), atol=2) + test_bins = make_bins(0.51396, 6.78, nbins=23, + method='equaloccupation', source_seps=test_array) + assert_allclose(np.diff(np.histogram(test_array, bins=test_bins)[0]), + np.zeros(22), atol=2) + assert_raises(ValueError, make_bins, 0, 10, 10, 'equaloccupation', None) + assert_raises(ValueError, make_bins, 0, 10, 10, 'undefinedmethod') + + +def test_convert_units(): + """ Test the wrapper function to convert units. Corner cases should be tested in the + individual functions. This function should test one case for all supported conversions + and the error handling. + """ + # Make an astropy cosmology object for testing + # cosmo = FlatLambdaCDM(H0=70., Om0=0.3) + cosmo = md.Cosmology(H0=70.0, Omega_dm0=0.3-0.045, Omega_b0=0.045) + + # Test that each unit is supported + utils.convert_units(1.0, 'radians', 'degrees') + utils.convert_units(1.0, 'arcmin', 'arcsec') + utils.convert_units(1.0, 'Mpc', 'kpc') + utils.convert_units(1.0, 'Mpc', 'kpc') + + # Error checking + assert_raises(ValueError, utils.convert_units, 1.0, 'radians', 'CRAZY') + assert_raises(ValueError, utils.convert_units, 1.0, 'CRAZY', 'radians') + assert_raises(TypeError, utils.convert_units, 1.0, 'arcsec', 'Mpc') + assert_raises(TypeError, utils.convert_units, + 1.0, 'arcsec', 'Mpc', None, cosmo) + assert_raises(TypeError, utils.convert_units, + 1.0, 'arcsec', 'Mpc', 0.5, None) + assert_raises(ValueError, utils.convert_units, + 1.0, 'arcsec', 'Mpc', -0.5, cosmo) + + # Test cases to make sure angular -> angular is fitting together + assert_allclose(utils.convert_units( + np.pi, 'radians', 'degrees'), 180., **TOLERANCE) + assert_allclose(utils.convert_units( + 180.0, 'degrees', 'radians'), np.pi, **TOLERANCE) + assert_allclose(utils.convert_units( + 1.0, 'degrees', 'arcmin'), 60., **TOLERANCE) + assert_allclose(utils.convert_units( + 1.0, 'degrees', 'arcsec'), 3600., **TOLERANCE) + + # Test cases to make sure physical -> physical is fitting together + assert_allclose(utils.convert_units(1.0, 'Mpc', 'kpc'), 1.0e3, **TOLERANCE) + assert_allclose(utils.convert_units(1000., 'kpc', 'Mpc'), 1.0, **TOLERANCE) + assert_allclose(utils.convert_units(1.0, 'Mpc', 'pc'), 1.0e6, **TOLERANCE) + + # Test conversion from angular to physical + # Using astropy, circular now but this will be fine since we are going to be + # swapping to CCL soon and then its kosher + r_arcmin, redshift = 20.0, 0.5 + d_a = cosmo.eval_da(redshift)*1.e3 # kpc + truth = r_arcmin*(1.0/60.0)*(np.pi/180.0)*d_a + assert_allclose(utils.convert_units(r_arcmin, 'arcmin', 'kpc', redshift, cosmo), + truth, **TOLERANCE) + + # Test conversion both ways between angular and physical units + # Using astropy, circular now but this will be fine since we are going to be + # swapping to CCL soon and then its kosher + r_kpc, redshift = 20.0, 0.5 +# d_a = cosmo.angular_diameter_distance(redshift).to('kpc').value + d_a = cosmo.eval_da(redshift)*1.e3 # kpc + truth = r_kpc*(1.0/d_a)*(180./np.pi)*60. + assert_allclose(utils.convert_units(r_kpc, 'kpc', 'arcmin', redshift, cosmo), + truth, **TOLERANCE) + + +def test_build_ellipticities(): + """test build ellipticities""" + + # second moments are floats + q11 = 0.5 + q22 = 0.3 + q12 = 0.02 + + assert_allclose( + utils.build_ellipticities(q11, q22, q12), + (0.25, 0.05, 0.12710007580505459, 0.025420015161010917), **TOLERANCE) + + # second moments are numpy array + q11 = np.array([0.5, 0.3]) + q22 = np.array([0.8, 0.2]) + q12 = np.array([0.01, 0.01]) + + assert_allclose( + utils.build_ellipticities(q11, q22, q12), + ([-0.23076923, 0.2], [0.01538462, 0.04], [-0.11697033, 0.10106221], + [0.00779802, 0.02021244]), + **TOLERANCE) + + +def test_shape_conversion(): + """ Test the helper function that convert user defined shapes into + epsilon ellipticities or reduced shear. Both can be used for the galcat in + the GalaxyCluster object""" + + # Number of random ellipticities to check + niter = 25 + + # Create random second moments and from that random ellipticities + q11, q22 = np.random.randint(0, 20, (2, niter)) + # Q11 seperate to avoid a whole bunch of nans + q12 = np.random.uniform(-1, 1, niter)*np.sqrt(q11*q22) + chi1, chi2, ellips1, ellips2 = utils.build_ellipticities(q11, q22, q12) + + # Test conversion from 'chi' to epsilon + ellips1_2, ellips2_2 = convert_shapes_to_epsilon(chi1, chi2, shape_definition='chi') + assert_allclose(ellips1, ellips1_2, **TOLERANCE) + assert_allclose(ellips2, ellips2_2, **TOLERANCE) + + # Test that 'epsilon' just returns the same values + ellips1_2, ellips2_2 = convert_shapes_to_epsilon(ellips1, ellips2, shape_definition='epsilon') + assert_allclose(ellips1, ellips1_2, **TOLERANCE) + assert_allclose(ellips2, ellips2_2, **TOLERANCE) + + # Test that 'reduced_shear' just returns the same values + ellips1_2, ellips2_2 = convert_shapes_to_epsilon( + ellips1, ellips2, shape_definition='reduced_shear') + assert_allclose(ellips1, ellips1_2, **TOLERANCE) + assert_allclose(ellips2, ellips2_2, **TOLERANCE) + + # Test that 'shear' just returns the right values for reduced shear + ellips1_2, ellips2_2 = convert_shapes_to_epsilon( + ellips1, ellips2, shape_definition='shear', kappa=0.2) + assert_allclose(ellips1/0.8, ellips1_2, **TOLERANCE) + assert_allclose(ellips2/0.8, ellips2_2, **TOLERANCE) + # Test known shape_definition + assert_raises(TypeError, convert_shapes_to_epsilon, + ellips1, ellips2, shape_definition='undefinedSD') + + +def test_compute_lensed_ellipticities(): + """test compute lensed ellipticities""" + + # Validation test with floats + es1 = 0 + es2 = 0 + gamma1 = 0.2 + gamma2 = 0.2 + kappa = 0.5 + assert_allclose(utils.compute_lensed_ellipticity( + es1, es2, gamma1, gamma2, kappa), (0.4, 0.4), **TOLERANCE) + + # Validation test with array + es1 = np.array([0, 0.5]) + es2 = np.array([0, 0.1]) + gamma1 = np.array([0.2, 0.]) + gamma2 = np.array([0.2, 0.3]) + kappa = np.array([0.5, 0.2]) + + assert_allclose(utils.compute_lensed_ellipticity(es1, es2, gamma1, gamma2, kappa), + ([0.4, 0.38656171], [0.4, 0.52769188]), **TOLERANCE) + + +def test_arguments_consistency(): + """test arguments consistency""" + assert_allclose(arguments_consistency([1, 2]), [1, 2], **TOLERANCE) + assert_allclose(arguments_consistency( [1, 2], names=['a', 'b']), [1, 2], **TOLERANCE) + assert_allclose(arguments_consistency( [1, 2], names='ab'), [1, 2], **TOLERANCE) + assert_allclose(arguments_consistency( [1, 2], names=['a', 'b'], prefix='x'), [1, 2], + **TOLERANCE) + + assert_allclose(arguments_consistency([[1], [2]]), [[1], [2]], **TOLERANCE) + assert_allclose(arguments_consistency( [[1], [2]], names=['a', 'b']), [[1], [2]], **TOLERANCE) + assert_allclose(arguments_consistency( [[1], [2]], names='ab'), [[1], [2]], **TOLERANCE) + assert_allclose(arguments_consistency([[1], [2]], names=[ 'a', 'b'], prefix='x'), [[1], [2]], + **TOLERANCE) + # test error + assert_raises(TypeError, arguments_consistency, [1, [1, 2]]) + assert_raises(TypeError, arguments_consistency, [[1], [1, 2]]) + assert_raises(TypeError, arguments_consistency, [1, 2], names=['a']) + + +def test_validate_argument(): + """test validate argument""" + loc = {'float': 1.1, 'int':3, 'str': 'test', 'int_array': [1, 2], 'float_array': [1.1, 1.2], + 'float_str': '1.1', 'none':None,} + # Validate type + for type_ in (int, float, 'int_array', 'float_array', (str, int)): + assert validate_argument(loc, 'int', type_) is None + for type_ in (float, 'float_array', (str, float)): + assert validate_argument(loc, 'float', type_) is None + for type_ in ('int_array', 'float_array', (str, 'int_array')): + assert validate_argument(loc, 'int_array', type_) is None + for type_ in ('float_array', (str, 'float_array')): + assert validate_argument(loc, 'float_array', type_) is None + for type_ in (str, ('float_array', str, float)): + assert validate_argument(loc, 'str', type_) is None + assert validate_argument(loc, 'none', 'float', none_ok=True) is None # test none_ok + + for type_ in (bool, (bool, tuple)): + for argname in loc: + assert_raises(TypeError, validate_argument, loc, argname, type_) + + for type_ in (int, (str, 'int_array')): + assert_raises(TypeError, validate_argument, loc, 'float', type_) + + for type_ in (int, float, (str, float)): + for argname in ('int_array', 'float_array'): + assert_raises(TypeError, validate_argument, loc, argname, type_) + + for argname in ('float', 'int', 'int_array', 'float_array', 'float_str'): + assert validate_argument(loc, argname, ('float_array', str), argmin=0, argmax=4, + eqmin=False, eqmax=False) is None + assert validate_argument(loc, argname, ('float_array', str), argmin=0, argmax=4, + eqmin=True, eqmax=True) is None + + assert_raises(TypeError, validate_argument, loc, 'str', ('float_array', str), argmin=0) + + + for argname in ('float', 'float_array', 'float_str'): + assert_raises(ValueError, validate_argument, loc, argname, ('float_array', str), argmin=1.1) + assert validate_argument(loc, argname, ('float_array', str), argmin=1.1, eqmin=True) is None + assert_raises(ValueError, validate_argument, loc, argname, ('float_array', str), argmax=1.1) + + assert validate_argument(loc, 'float_array', ('float_array', str), argmax=1.2, eqmax=True) is None + +def test_beta_functions(): + z_cl = 1.0 + z_s = 2.4 + z_inf =1000. + zmax = 15.0 + nsteps = 1000 + zmin = z_cl + 0.1 + z_int = np.linspace(zmin, zmax, nsteps) + cosmo = md.Cosmology(H0=70.0, Omega_dm0=0.27 - 0.045, + Omega_b0=0.045, Omega_k0=0.0) + beta_test = np.heaviside(z_s-z_cl, 0) * cosmo.eval_da_z1z2(z_cl, z_s) / cosmo.eval_da(z_cl) + beta_s_test = utils.compute_beta(z_s, z_cl, cosmo) / utils.compute_beta(z_inf, z_cl, cosmo) + + def pdz(z): + return (z**1.24)*np.exp(-(z/0.51)**1.01) + + def integrand1(z_i, z_cl=z_cl, cosmo=cosmo): + return utils.compute_beta(z_i, z_cl, cosmo) * pdz(z_i) + + def integrand2(z_i, z_inf=z_inf, z_cl=z_cl, cosmo=cosmo): + return utils.compute_beta_s(z_i, z_cl, z_inf, cosmo) * pdz(z_i) + + def integrand3(z_i, z_inf=z_inf, z_cl=z_cl, cosmo=cosmo): + return utils.compute_beta_s(z_i, z_cl, z_inf, cosmo)**2 * pdz(z_i) + + test1 = utils.compute_beta(z_s, z_cl, cosmo) +<<<<<<< HEAD + test2 = utils.compute_beta_s(z_s, z_cl, z_inf, cosmo) + test3 = utils.compute_beta_mean(z_cl, cosmo, zmax) + test4 = utils.compute_beta_s_mean(z_cl, z_inf,cosmo, zmax) + test5 = utils.compute_beta_s_square_mean(z_cl,z_inf,cosmo, zmax) +======= + test2 = utils.compute_beta_s(z_s, z_cl, z_inf, cosmo) + test3 = utils.compute_B_mean(z_cl, cosmo, zmax) + test4 = utils.compute_Bs_mean(z_cl, z_inf,cosmo, zmax) + test5 = utils.compute_Bs_square_mean(z_cl, z_inf,cosmo, zmax) +>>>>>>> 22eda2796c3d436b3c6dfaca05046adb9a646874 + + assert_allclose(test1, beta_test, **TOLERANCE) + assert_allclose(test2, beta_s_test, **TOLERANCE) + assert_allclose(test3, quad(integrand1, zmin, zmax)[0] / quad(pdz, zmin, zmax)[0], **TOLERANCE) + assert_allclose(test4, quad(integrand2, zmin, zmax)[0] / quad(pdz, zmin, zmax)[0], **TOLERANCE) + assert_allclose(test5, quad(integrand3, zmin, zmax)[0] / quad(pdz, zmin, zmax)[0], **TOLERANCE) From b36ed4b02dd9ea7a8fdd6afedf34841beeea46a4 Mon Sep 17 00:00:00 2001 From: eduardojsbarroso Date: Thu, 21 Jul 2022 08:14:02 -0700 Subject: [PATCH 02/38] Added weights option --- clmm/utils.py | 79 +++++++++++++++++++++++++++++++-------------- tests/test_utils.py | 4 +++ 2 files changed, 59 insertions(+), 24 deletions(-) diff --git a/clmm/utils.py b/clmm/utils.py index 6f9b71cea..5d9fc4847 100644 --- a/clmm/utils.py +++ b/clmm/utils.py @@ -732,7 +732,7 @@ def integrand(z_i, z_cl=z_cl, cosmo=cosmo): B_mean = quad(integrand, zmin, zmax)[0] / quad(z_distrib_func, zmin, zmax)[0] return B_mean -def compute_beta_s_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, z_distrib_func=None): +def compute_beta_s_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, z_distrib_func=None, weights_option=False, z_src = None): r"""Mean value of the geometric lensing efficicency ratio .. math:: @@ -758,25 +758,40 @@ def compute_beta_s_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=Non Redshift interval to be summed with $z_cl$ to return\ $zmin$. This feature is not used if $z_min$ is provided by the user. cosmo: Cosmology - Cosmology object - + Cosmology object + weights_option: boolean + If set to true, the function uses Eq.(13) from\ + https://arxiv.org/pdf/1611.03866.pdf with evenly distributed\ + weights summing to one. + z_src: array_like, float + Invididual source galaxies redshift. + Returns ------- float Mean value of the geometric lensing efficicency ratio """ - if z_distrib_func == None: - z_distrib_func = _chang_z_distrib - - def integrand(z_i, z_cl=z_cl, z_inf=z_inf, cosmo=cosmo): - return compute_beta_s(z_i, z_cl, z_inf, cosmo) * z_distrib_func(z_i) - - if zmin==None: - zmin = z_cl + delta_z_cut - Bs_mean = quad(integrand, zmin, zmax)[0] / quad(z_distrib_func, zmin, zmax)[0] + if weights_option == False: + if z_distrib_func == None: + z_distrib_func = _chang_z_distrib + + def integrand(z_i, z_cl=z_cl, z_inf=z_inf, cosmo=cosmo): + return compute_beta_s(z_i, z_cl, z_inf, cosmo) * z_distrib_func(z_i) + + if zmin==None: + zmin = z_cl + delta_z_cut + Bs_mean = quad(integrand, zmin, zmax)[0] / quad(z_distrib_func, zmin, zmax)[0] + elif weights_option == True: + if z_src == None: + raise ValueError(f"Inividual source galaxies redshift needed") + else: + n_galaxies = len(z_src) + weight = 1/n_galaxies + Bsw_i = [weight * compute_beta_s(z, z_cl, z_inf, cosmo) for z in z_src] + Bs_mean = np.sum(Bsw_i) return Bs_mean -def compute_beta_s_square_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, z_distrib_func=None): +def compute_beta_s_square_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, z_distrib_func=None, weights_option=False, z_src = None): r"""Mean square value of the geometric lensing efficicency ratio .. math:: @@ -802,22 +817,38 @@ def compute_beta_s_square_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, z Redshift interval to be summed with $z_cl$ to return\ $zmin$. This feature is not used if $z_min$ is provided by the user. cosmo: Cosmology - Cosmology object - + Cosmology object + weights_option: boolean + If set to true, the function uses Eq.(13) from\ + https://arxiv.org/pdf/1611.03866.pdf with evenly distributed\ + weights summing to one. + z_src: array_like, float + Invididual source galaxies redshift. Returns ------- float Mean square value of the geometric lensing efficicency ratio. """ - if z_distrib_func == None: - z_distrib_func = _chang_z_distrib - - def integrand(z_i, z_cl=z_cl, z_inf=z_inf, cosmo=cosmo): - return compute_beta_s(z_i, z_cl, z_inf, cosmo)**2 * z_distrib_func(z_i) - - if zmin==None: - zmin = z_cl + delta_z_cut - Bs_square_mean = quad(integrand, zmin, zmax)[0] / quad(z_distrib_func, zmin, zmax)[0] + if weights_option == False: + if z_distrib_func == None: + z_distrib_func = _chang_z_distrib + + def integrand(z_i, z_cl=z_cl, z_inf=z_inf, cosmo=cosmo): + return compute_beta_s(z_i, z_cl, z_inf, cosmo)**2 * z_distrib_func(z_i) + + if zmin==None: + zmin = z_cl + delta_z_cut + Bs_square_mean = quad(integrand, zmin, zmax)[0] / quad(z_distrib_func, zmin, zmax)[0] + + elif weights_option == True: + if z_src == None: + raise ValueError(f"Inividual source galaxies redshift needed") + else: + n_galaxies = len(z_src) + weight = 1/n_galaxies + Bsw_i = [weight * compute_beta_s(z, z_cl, z_inf, cosmo)**2 for z in z_src] + Bs_square_mean = np.sum(Bsw_i) + return Bs_square_mean def _chang_z_distrib(redshift, is_cdf=False): diff --git a/tests/test_utils.py b/tests/test_utils.py index 7e0c7c339..b6c3bb268 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -456,9 +456,13 @@ def integrand3(z_i, z_inf=z_inf, z_cl=z_cl, cosmo=cosmo): test3 = utils.compute_beta_mean(z_cl, cosmo, zmax) test4 = utils.compute_beta_s_mean(z_cl, z_inf,cosmo, zmax) test5 = utils.compute_beta_s_square_mean(z_cl, z_inf,cosmo, zmax) + test6 = utils.compute_beta_s_mean(z_cl, z_inf,cosmo, zmax, weights_option=True, z_src=[2.1,2.3]) + test7 = utils.compute_beta_s_square_mean(z_cl, z_inf,cosmo, zmax, weights_option=True, z_src=[2.1, 2.3]) assert_allclose(test1, beta_test, **TOLERANCE) assert_allclose(test2, beta_s_test, **TOLERANCE) assert_allclose(test3, quad(integrand1, zmin, zmax)[0] / quad(pdz, zmin, zmax)[0], **TOLERANCE) assert_allclose(test4, quad(integrand2, zmin, zmax)[0] / quad(pdz, zmin, zmax)[0], **TOLERANCE) assert_allclose(test5, quad(integrand3, zmin, zmax)[0] / quad(pdz, zmin, zmax)[0], **TOLERANCE) + assert_allclose(test6, 0.5*utils.compute_beta_s(2.1, z_cl, z_inf, cosmo) + 0.5*utils.compute_beta_s(2.3, z_cl, z_inf, cosmo), **TOLERANCE) + assert_allclose(test7, 0.5*utils.compute_beta_s(2.1, z_cl, z_inf, cosmo)**2 + 0.5*utils.compute_beta_s(2.3, z_cl, z_inf, cosmo)**2, **TOLERANCE) \ No newline at end of file From 2fd4ad81ce6391ff3f65e5198d125407a29c5c78 Mon Sep 17 00:00:00 2001 From: eduardojsbarroso Date: Wed, 1 Mar 2023 16:01:16 +0100 Subject: [PATCH 03/38] Fixed old code to match new features --- clmm/utils.py | 13 ++++--------- tests/test_utils.py | 46 +++++++++++++++++++++++++++++++-------------- 2 files changed, 36 insertions(+), 23 deletions(-) diff --git a/clmm/utils.py b/clmm/utils.py index f94567465..e507d2c7a 100644 --- a/clmm/utils.py +++ b/clmm/utils.py @@ -797,14 +797,12 @@ def compute_beta_s_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=Non Redshift at infinity cosmo: clmm.Cosmology CLMM Cosmology object - zmin: float + zmax: float Minimum redshift to be set as the source of the galaxy\ when performing the sum. delta_z_cut: float Redshift interval to be summed with $z_cl$ to return\ $zmin$. This feature is not used if $z_min$ is provided by the user. - cosmo: Cosmology - Cosmology object weights_option: boolean If set to true, the function uses Eq.(13) from\ https://arxiv.org/pdf/1611.03866.pdf with evenly distributed\ @@ -819,7 +817,7 @@ def compute_beta_s_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=Non """ if weights_option == False: if z_distrib_func == None: - z_distrib_func = _chang_z_distrib + z_distrib_func = zdist.chang2013 def integrand(z_i, z_cl=z_cl, z_inf=z_inf, cosmo=cosmo): return compute_beta_s(z_i, z_cl, z_inf, cosmo) * z_distrib_func(z_i) @@ -837,7 +835,6 @@ def integrand(z_i, z_cl=z_cl, z_inf=z_inf, cosmo=cosmo): Bs_mean = np.sum(Bsw_i) return Bs_mean -<<<<<<< HEAD def compute_beta_s_square_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, z_distrib_func=None, weights_option=False, z_src = None): r"""Mean square value of the geometric lensing efficicency ratio @@ -853,14 +850,12 @@ def compute_beta_s_square_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, z Redshift at infinity cosmo: clmm.Cosmology CLMM Cosmology object - zmin: float + zmax: float Minimum redshift to be set as the source of the galaxy\ when performing the sum. delta_z_cut: float Redshift interval to be summed with $z_cl$ to return\ $zmin$. This feature is not used if $z_min$ is provided by the user. - cosmo: Cosmology - Cosmology object weights_option: boolean If set to true, the function uses Eq.(13) from\ https://arxiv.org/pdf/1611.03866.pdf with evenly distributed\ @@ -874,7 +869,7 @@ def compute_beta_s_square_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, z """ if weights_option == False: if z_distrib_func == None: - z_distrib_func = _chang_z_distrib + z_distrib_func = zdist.chang2013 def integrand(z_i, z_cl=z_cl, z_inf=z_inf, cosmo=cosmo): return compute_beta_s(z_i, z_cl, z_inf, cosmo)**2 * z_distrib_func(z_i) diff --git a/tests/test_utils.py b/tests/test_utils.py index 55cee1943..09e7bd5d1 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -452,18 +452,36 @@ def test_beta_functions(): assert_allclose(utils.compute_beta(z_s, z_cl, cosmo), beta_test, **TOLERANCE) assert_allclose(utils.compute_beta_s(z_s, z_cl, z_inf, cosmo), beta_s_test, **TOLERANCE) - test1 = utils.compute_beta(z_s, z_cl, cosmo) - test2 = utils.compute_beta_s(z_s, z_cl, z_inf, cosmo) - test3 = utils.compute_beta_mean(z_cl, cosmo, zmax) - test4 = utils.compute_beta_s_mean(z_cl, z_inf,cosmo, zmax) - test5 = utils.compute_beta_s_square_mean(z_cl, z_inf,cosmo, zmax) - test6 = utils.compute_beta_s_mean(z_cl, z_inf,cosmo, zmax, weights_option=True, z_src=[2.1,2.3]) - test7 = utils.compute_beta_s_square_mean(z_cl, z_inf,cosmo, zmax, weights_option=True, z_src=[2.1, 2.3]) - assert_allclose(test1, beta_test, **TOLERANCE) - assert_allclose(test2, beta_s_test, **TOLERANCE) - assert_allclose(test3, quad(integrand1, zmin, zmax)[0] / quad(pdz, zmin, zmax)[0], **TOLERANCE) - assert_allclose(test4, quad(integrand2, zmin, zmax)[0] / quad(pdz, zmin, zmax)[0], **TOLERANCE) - assert_allclose(test5, quad(integrand3, zmin, zmax)[0] / quad(pdz, zmin, zmax)[0], **TOLERANCE) - assert_allclose(test6, 0.5*utils.compute_beta_s(2.1, z_cl, z_inf, cosmo) + 0.5*utils.compute_beta_s(2.3, z_cl, z_inf, cosmo), **TOLERANCE) - assert_allclose(test7, 0.5*utils.compute_beta_s(2.1, z_cl, z_inf, cosmo)**2 + 0.5*utils.compute_beta_s(2.3, z_cl, z_inf, cosmo)**2, **TOLERANCE) + for model in (None, zdist.chang2013, zdist.desc_srd): + + # None defaults to chang2013 for compute_beta* functions + + test1 = utils.compute_beta_mean(z_cl, cosmo, zmax, z_distrib_func=model) + test2 = utils.compute_beta_s_mean(z_cl, z_inf, cosmo, zmax, z_distrib_func=model) + test3 = utils.compute_beta_s_square_mean(z_cl, z_inf, cosmo, zmax, + z_distrib_func=model) + + if model is None: + model = zdist.chang2013 + + def integrand1(z_i, z_cl=z_cl, cosmo=cosmo): + return utils.compute_beta(z_i, z_cl, cosmo) * model(z_i) + + def integrand2(z_i, z_inf=z_inf, z_cl=z_cl, cosmo=cosmo): + return utils.compute_beta_s(z_i, z_cl, z_inf, cosmo) * model(z_i) + + def integrand3(z_i, z_inf=z_inf, z_cl=z_cl, cosmo=cosmo): + return utils.compute_beta_s(z_i, z_cl, z_inf, cosmo)**2 * model(z_i) + + assert_allclose(test1, quad(integrand1, zmin, zmax)[0] / quad(model, zmin, zmax)[0], + **TOLERANCE) + assert_allclose(test2, quad(integrand2, zmin, zmax)[0] / quad(model, zmin, zmax)[0], + **TOLERANCE) + assert_allclose(test3, quad(integrand3, zmin, zmax)[0] / quad(model, zmin, zmax)[0], + **TOLERANCE) + test4 = utils.compute_beta_s_mean(z_cl, z_inf,cosmo, zmax, weights_option=True, z_src=[2.1,2.3]) + test5 = utils.compute_beta_s_square_mean(z_cl, z_inf,cosmo, zmax, weights_option=True, z_src=[2.1, 2.3]) + + assert_allclose(test4, 0.5*utils.compute_beta_s(2.1, z_cl, z_inf, cosmo) + 0.5*utils.compute_beta_s(2.3, z_cl, z_inf, cosmo), **TOLERANCE) + assert_allclose(test5, 0.5*utils.compute_beta_s(2.1, z_cl, z_inf, cosmo)**2 + 0.5*utils.compute_beta_s(2.3, z_cl, z_inf, cosmo)**2, **TOLERANCE) From 23a0c58c62cca8f899610de75603748f8297c639 Mon Sep 17 00:00:00 2001 From: eduardojsbarroso Date: Wed, 1 Mar 2023 16:32:38 +0100 Subject: [PATCH 04/38] Deleting Unwanted commited files --- clmm/utils.py.orig | 693 --------------------------------------- examples/term2h_nc.txt | 100 ------ tests/test_utils.py.orig | 413 ----------------------- 3 files changed, 1206 deletions(-) delete mode 100644 clmm/utils.py.orig delete mode 100644 examples/term2h_nc.txt delete mode 100644 tests/test_utils.py.orig diff --git a/clmm/utils.py.orig b/clmm/utils.py.orig deleted file mode 100644 index 5e003905c..000000000 --- a/clmm/utils.py.orig +++ /dev/null @@ -1,693 +0,0 @@ -"""General utility functions that are used in multiple modules""" -import numpy as np -from scipy.stats import binned_statistic -from scipy.special import gamma, gammainc -from astropy import units as u -from .constants import Constants as const -from scipy.integrate import quad - -def compute_radial_averages(xvals, yvals, xbins, yerr=None, error_model='ste', weights=None): - """ Given a list of xvals, yvals and bins, sort into bins. If xvals or yvals - contain non-finite values, these are filtered. - - Parameters - ---------- - xvals : array_like - Values to be binned - yvals : array_like - Values to compute statistics on - xbins: array_like - Bin edges to sort into - yerr : array_like, None - Errors of component y - error_model : str, optional - Statistical error model to use for y uncertainties. (letter case independent) - - * `ste` - Standard error [=std/sqrt(n) in unweighted computation] (Default). - * `std` - Standard deviation. - - weights: array_like, None - Weights for averages. - - - Returns - ------- - mean_x : array_like - Mean x value in each bin - mean_y : array_like - Mean y value in each bin - err_y: array_like - Error on the mean y value in each bin. Specified by error_model - num_objects : array_like - Number of objects in each bin - binnumber: 1-D ndarray of ints - Indices of the bins (corresponding to `xbins`) in which each value - of `xvals` belongs. Same length as `yvals`. A binnumber of `i` means the - corresponding value is between (xbins[i-1], xbins[i]). - """ - # make case independent - error_model = error_model.lower() - # binned_statics throus an error in case of non-finite values, so filtering those out - filt = np.isfinite(xvals)*np.isfinite(yvals) - x, y = np.array(xvals)[filt], np.array(yvals)[filt] - # normalize weights (and computers binnumber) - wts = np.ones(x.size) if weights is None else np.array(weights, dtype=float)[filt] - wts_sum, binnumber = binned_statistic(x, wts, statistic='sum', bins=xbins)[:3:2] - objs_in_bins = (binnumber>0)*(binnumber<=wts_sum.size) # mask for binnumber in range - wts[objs_in_bins] *= 1./wts_sum[binnumber[objs_in_bins]-1] # norm weights in each bin - weighted_bin_stat = lambda vals: binned_statistic(x, vals*wts, statistic='sum', bins=xbins)[0] - # means - mean_x = weighted_bin_stat(x) - mean_y = weighted_bin_stat(y) - # errors - data_yerr2 = 0 if yerr is None else weighted_bin_stat(np.array(yerr)[filt]**2*wts) - stat_yerr2 = weighted_bin_stat(y**2)-mean_y**2 - if error_model == 'ste': - stat_yerr2 *= weighted_bin_stat(wts) # sum(wts^2)=1/n for not weighted - elif error_model != 'std': - raise ValueError(f"{error_model} not supported err model for binned stats") - err_y = np.sqrt(stat_yerr2+data_yerr2) - # number of objects - num_objects = np.histogram(x, xbins)[0] - return mean_x, mean_y, err_y, num_objects, binnumber - - -def make_bins(rmin, rmax, nbins=10, method='evenwidth', source_seps=None): - """ Define bin edges - - Parameters - ---------- - rmin : float - Minimum bin edges wanted - rmax : float - Maximum bin edges wanted - nbins : float - Number of bins you want to create, default to 10. - method : str, optional - Binning method to use (letter case independent): - - * `evenwidth` - Default, evenly spaced bins between rmin and rmax - * `evenlog10width` - Logspaced bins with even width in log10 between rmin and rmax - * `equaloccupation` - Bins with equal occupation numbers - - source_seps : array_like - Radial distance of source separations - - Returns - ------- - binedges: array_like, float - n_bins+1 dimensional array that defines bin edges - """ - # make case independent - method = method.lower() - # Check consistency - if (rmin > rmax) or (rmin < 0.0) or (rmax < 0.0): - raise ValueError(f"Invalid bin endpoints in make_bins, {rmin} {rmax}") - if (nbins <= 0) or not isinstance(nbins, int): - raise ValueError( - f"Invalid nbins={nbins}. Must be integer greater than 0.") - - if method == 'evenwidth': - binedges = np.linspace(rmin, rmax, nbins+1, endpoint=True) - elif method == 'evenlog10width': - binedges = np.logspace(np.log10(rmin), np.log10( - rmax), nbins+1, endpoint=True) - elif method == 'equaloccupation': - if source_seps is None: - raise ValueError( - f"Binning method '{method}' requires source separations array") - # by default, keep all galaxies - seps = np.array(source_seps) - mask = np.full(seps.size, True) - if rmin is not None or rmax is not None: - # Need to filter source_seps to only keep galaxies in the [rmin, rmax] - rmin = seps.min() if rmin is None else rmin - rmax = seps.max() if rmax is None else rmax - mask = (seps >= rmin)*(seps <= rmax) - binedges = np.percentile(seps[mask], tuple( - np.linspace(0, 100, nbins+1, endpoint=True))) - else: - raise ValueError( - f"Binning method '{method}' is not currently supported") - - return binedges - - -def convert_units(dist1, unit1, unit2, redshift=None, cosmo=None): - """ Convenience wrapper to convert between a combination of angular and physical units. - - Supported units: radians, degrees, arcmin, arcsec, Mpc, kpc, pc - (letter case independent) - - To convert between angular and physical units you must provide both - a redshift and a cosmology object. - - Parameters - ---------- - dist1 : array_like - Input distances - unit1 : str - Unit for the input distances - unit2 : str - Unit for the output distances - redshift : float - Redshift used to convert between angular and physical units - cosmo : CLMM.Cosmology - CLMM Cosmology object to compute angular diameter distance to - convert between physical and angular units - - Returns - ------- - dist2: array_like - Input distances converted to unit2 - """ - # make case independent - unit1, unit2 = unit1.lower(), unit2.lower() - # Available units - angular_bank = {"radians": u.rad, "degrees": u.deg, - "arcmin": u.arcmin, "arcsec": u.arcsec} - physical_bank = {"pc": u.pc, "kpc": u.kpc, "mpc": u.Mpc} - units_bank = {**angular_bank, **physical_bank} - # Some error checking - if unit1 not in units_bank: - raise ValueError(f"Input units ({unit1}) not supported") - if unit2 not in units_bank: - raise ValueError(f"Output units ({unit2}) not supported") - # Try automated astropy unit conversion - try: - dist2 = (dist1*units_bank[unit1]).to(units_bank[unit2]).value - # Otherwise do manual conversion - except u.UnitConversionError: - # Make sure that we were passed a redshift and cosmology - if redshift is None or cosmo is None: - raise TypeError( - "Redshift and cosmology must be specified to convert units") \ - from u.UnitConversionError - # Redshift must be greater than zero for this approx - if not redshift > 0.0: - raise ValueError("Redshift must be greater than 0.") from u.UnitConversionError - # Convert angular to physical - if (unit1 in angular_bank) and (unit2 in physical_bank): - dist1_rad = (dist1*units_bank[unit1]).to(u.rad).value - dist1_mpc = cosmo.rad2mpc(dist1_rad, redshift) - dist2 = (dist1_mpc*u.Mpc).to(units_bank[unit2]).value - # Otherwise physical to angular - else: - dist1_mpc = (dist1*units_bank[unit1]).to(u.Mpc).value - dist1_rad = cosmo.mpc2rad(dist1_mpc, redshift) - dist2 = (dist1_rad*u.rad).to(units_bank[unit2]).value - return dist2 - - -def convert_shapes_to_epsilon(shape_1, shape_2, shape_definition='epsilon', kappa=0): - r""" Convert shape components 1 and 2 appropriately to make them estimators of the reduced shear - once averaged. The shape 1 and 2 components may correspond to ellipticities according the - :math:`\epsilon`- or :math:`\chi`-definition, but also to the 1 and 2 components of the shear. - See Bartelmann & Schneider 2001 for details (https://arxiv.org/pdf/astro-ph/9912508.pdf). - - The :math:`\epsilon`-ellipticity is a direct estimator of - the reduced shear. The shear :math:`\gamma` may be converted to reduced shear :math:`g` if the - convergence :math:`\kappa` is known. The conversions are given below. - - .. math:: - \epsilon = \frac{\chi}{1+(1-|\chi|^2)^{1/2}} - - .. math:: - g=\frac{\gamma}{1-\kappa} - - - If `shape_definition = 'chi'`, this function returns the corresponding `epsilon` ellipticities - - - If `shape_definition = 'shear'`, it returns the corresponding reduced shear, given the - convergence `kappa` - - - If `shape_definition = 'epsilon'` or `'reduced_shear'`, it returns them as is as no conversion - is needed. - - Parameters - ---------- - shape_1 : array_like - Input shapes or shears along principal axis (g1 or e1) - shape_2 : array_like - Input shapes or shears along secondary axis (g2 or e2) - shape_definition : str - Definition of the input shapes, can be ellipticities 'epsilon' or 'chi' or shears 'shear' or - 'reduced_shear' - kappa : array_like - Convergence for transforming to a reduced shear. Default is 0 - - Returns - ------- - epsilon_1 : array_like - Epsilon ellipticity (or reduced shear) along principal axis (epsilon1) - epsilon_2 : array_like - Epsilon ellipticity (or reduced shear) along secondary axis (epsilon2) - """ - - if shape_definition in ('epsilon', 'reduced_shear'): - epsilon_1, epsilon_2 = shape_1, shape_2 - elif shape_definition == 'chi': - chi_to_eps_conversion = 1./(1.+(1-(shape_1**2+shape_2**2))**0.5) - epsilon_1, epsilon_2 = shape_1*chi_to_eps_conversion, shape_2*chi_to_eps_conversion - elif shape_definition == 'shear': - epsilon_1, epsilon_2 = shape_1/(1.-kappa), shape_2/(1.-kappa) - else: - raise TypeError("Please choose epsilon, chi, shear, reduced_shear") - return epsilon_1, epsilon_2 - - -def build_ellipticities(q11, q22, q12): - """ Build ellipticties from second moments. See, e.g., Schneider et al. (2006) - - Parameters - ---------- - q11 : float or array - Second brightness moment tensor, component (1,1) - q22 : float or array - Second brightness moment tensor, component (2,2) - q12 : float or array - Second brightness moment tensor, component (1,2) - - Returns - ------- - chi1, chi2 : float or array - Ellipticities using the "chi definition" - epsilon1, epsilon2 : float or array - Ellipticities using the "epsilon definition" - """ - norm_x, norm_e = q11+q22, q11+q22+2*np.sqrt(q11*q22-q12*q12) - chi1, chi2 = (q11-q22)/norm_x, 2*q12/norm_x - epsilon1, epsilon2 = (q11-q22)/norm_e, 2*q12/norm_e - return chi1, chi2, epsilon1, epsilon2 - - -def compute_lensed_ellipticity(ellipticity1_true, ellipticity2_true, shear1, shear2, convergence): - r""" Compute lensed ellipticities from the intrinsic ellipticities, shear and convergence. - Following Schneider et al. (2006) - - .. math:: - \epsilon^{\rm lensed}=\epsilon^{\rm lensed}_1+i\epsilon^{\rm lensed}_2= - \frac{\epsilon^{\rm true}+g}{1+g^\ast\epsilon^{\rm true}}, - - where, the complex reduced shear :math:`g` is obtained from the shear - :math:`\gamma=\gamma_1+i\gamma_2` and convergence :math:`\kappa` as :math:`g = - \gamma/(1-\kappa)`, and the complex intrinsic ellipticity is :math:`\epsilon^{\rm - true}=\epsilon^{\rm true}_1+i\epsilon^{\rm true}_2` - - Parameters - ---------- - ellipticity1_true : float or array - Intrinsic ellipticity of the sources along the principal axis - ellipticity2_true : float or array - Intrinsic ellipticity of the sources along the second axis - shear1 : float or array - Shear component (not reduced shear) along the principal axis at the source location - shear2 : float or array - Shear component (not reduced shear) along the 45-degree axis at the source location - convergence : float or array - Convergence at the source location - Returns - ------- - e1, e2 : float or array - Lensed ellipicity along both reference axes. - """ - # shear (as a complex number) - shear = shear1+shear2*1j - # intrinsic ellipticity (as a complex number) - ellipticity_true = ellipticity1_true+ellipticity2_true*1j - # reduced shear - reduced_shear = shear/(1.0-convergence) - # lensed ellipticity - lensed_ellipticity = (ellipticity_true+reduced_shear) / \ - (1.0+reduced_shear.conjugate()*ellipticity_true) - return np.real(lensed_ellipticity), np.imag(lensed_ellipticity) - - -def arguments_consistency(arguments, names=None, prefix=''): - r"""Make sure all arguments have the same length (or are scalars) - - Parameters - ---------- - arguments: list, arrays, tuple - Group of arguments to be checked - names: list, tuple - Names for each array, optional - prefix: str - Customized prefix for error message - - Returns - ------- - list, arrays, tuple - Group of arguments, converted to numpy arrays if they have length - """ - sizes = [len(arg) if hasattr(arg, '__len__') - else None for arg in arguments] - # check there is a name for each argument - if names: - if len(names) != len(arguments): - raise TypeError( - f'names (len={len(names)}) must have same length ' - f'as arguments (len={len(arguments)})') - msg = ', '.join([f'{n}({s})' for n, s in zip(names, sizes)]) - else: - msg = ', '.join([f'{s}' for s in sizes]) - # check consistency - if any(sizes): - # Check that all of the inputs have length and they match - if not all(sizes) or any([s != sizes[0] for s in sizes[1:]]): - # make error message - raise TypeError(f'{prefix} inconsistent sizes: {msg}') - return tuple(np.array(arg) for arg in arguments) - return arguments - - -def _patch_rho_crit_to_cd2018(rho_crit_external): - r""" Convertion factor for rho_crit of any external modult to - CODATA 2018+IAU 2015 - - rho_crit_external: float - Critical density of the Universe in units of :math:`M_\odot\ Mpc^{-3}` - """ - - rhocrit_mks = 3.0*100.0*100.0/(8.0*np.pi*const.GNEWT.value) - rhocrit_cd2018 = (rhocrit_mks*1000.0*1000.0* - const.PC_TO_METER.value*1.0e6/const.SOLAR_MASS.value) - - return rhocrit_cd2018/rho_crit_external - -_valid_types = { - float: (float, int, np.floating, np.integer), - int: (int, np.integer), - 'float_array': (float, int, np.floating, np.integer), - 'int_array': (int, np.integer) - } - -def _is_valid(arg, valid_type): - r"""Check if argument is of valid type, supports arrays. - - Parameters - ---------- - arg: any - Argument to be tested. - valid_type: str, type - Valid types for argument, options are object types, list/tuple of types, or: - - * `int_array` - interger, interger array - * `float_array` - float, float array - - Returns - ------- - valid: bool - Is argument valid - """ - return (isinstance(arg[0], _valid_types[valid_type]) - if (valid_type in ('int_array', 'float_array') and np.iterable(arg)) - else isinstance(arg, _valid_types.get(valid_type, valid_type))) - - -def validate_argument(loc, argname, valid_type, none_ok=False, argmin=None, argmax=None, - eqmin=False, eqmax=False): - r"""Validate argument type and raise errors. - - Parameters - ---------- - loc: dict - Dictionaty with all input arguments. Should be locals(). - argname: str - Name of argument to be tested. - valid_type: str, type - Valid types for argument, options are object types, list/tuple of types, or: - - * `int_array` - interger, interger array - * `float_array` - float, float array - - none_ok: True - Accepts None as a valid type. - argmin (optional) : int, float, None - Minimum value allowed. - argmax (optional) : int, float, None - Maximum value allowed. - eqmin: bool - Accepts min(arg)==argmin. - eqmax: bool - Accepts max(arg)==argmax. - """ - var = loc[argname] - # Check for None - if none_ok and (var is None): - return - # Check for type - valid = (any(_is_valid(var, types) for types in valid_type) - if isinstance(valid_type, (list, tuple)) - else _is_valid(var, valid_type)) - if not valid: - err = f'{argname} must be {valid_type}, received {type(var).__name__}' - raise TypeError(err) - # Check min/max - if any(t is not None for t in (argmin, argmax)): - try: - var_array = np.array(var, dtype=float) - except: - err = f'{argname} ({type(var).__name__}) cannot be converted to number' \ - ' for min/max validation.' - raise TypeError(err) - if argmin is not None: - if (var_array.min()argmax if eqmax else var_array.max()>=argmax): - err = f'{argname} must be lesser than {argmax},' \ - f' received {"vec_max:"*(var_array.size-1)}{var}' - raise ValueError(err) - -def compute_beta(z_s, z_cl, cosmo): - r"""Geometric lensing efficicency - - .. math:: - beta = max(0, Dang_ls/Dang_s) - - Eq.2 in https://arxiv.org/pdf/1611.03866.pdf - - Parameters - ---------- - z_cl: float - Galaxy cluster redshift - z_s: float - Source galaxy redshift - cosmo: Cosmology - Cosmology object - - Returns - ------- - float - Geometric lensing efficicency - """ - beta = np.heaviside(z_s-z_cl, 0) * cosmo.eval_da_z1z2(z_cl, z_s) / cosmo.eval_da(z_cl) - return beta - -def compute_beta_s(z_s, z_cl, z_inf, cosmo): - r"""Geometric lensing efficicency ratio - - .. math:: - beta_s =beta(z_s)/beta(z_inf) - - Parameters - ---------- - z_cl: float - Galaxy cluster redshift - z_s: float - Source galaxy redshift - z_inf: float - Redshift at infinity - cosmo: Cosmology - Cosmology object - - Returns - ------- - float - Geometric lensing efficicency ratio - """ - beta_s = compute_beta(z_s, z_cl, cosmo) / compute_beta(z_inf, z_cl, cosmo) - return beta_s - -def compute_beta_mean(z_cl, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, pdz=None): - r"""Mean value of the geometric lensing efficicency - - .. math:: - \left\ =\frac{\sum_{z = z_{min}}^{z = z_{max}}\beta(z)p(z)}{\sum_{z = z_{min}}^{z = z_{max}}p(z)} - - Parameters - ---------- - z_cl: float - Galaxy cluster redshift - z_inf: float - Redshift at infinity - pdz: argument function - Redshift probability density function. Default is\ - Chang et al (2013) unnormalized galaxy redshift distribution\ - function. - zmin: float - Minimum redshift to be set as the source of the galaxy\ - when performing the sum. - zmax: float - Maximum redshift to be set as the source of the galaxy\ - when performing the sum. - delta_z_cut: float - Redshift interval to be summed with $z_cl$ to return\ - a $zmin$. This feature is not used if $zmin$ is provided. - cosmo: Cosmology - Cosmology object - - Returns - ------- - float - Mean value of the geometric lensing efficicency - """ - if pdz == None: - pdz = _chang_z_distrib - def integrand(z_i, z_cl=z_cl, cosmo=cosmo): - return compute_beta(z_i, z_cl, cosmo) * pdz(z_i) - - if zmin==None: - zmin = z_cl + delta_z_cut - - B_mean = quad(integrand, zmin, zmax)[0] / quad(pdz, zmin, zmax)[0] - return B_mean - -def compute_beta_s_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, pdz=None): - r"""Mean value of the geometric lensing efficicency ratio - - .. math:: - \left\ =\frac{\sum_{z = z_{min}}^{z = z_{max}}\beta_s(z)p(z)}{\sum_{z = z_{min}}^{z = z_{max}}p(z)} - - Parameters - ---------- - z_cl: float - Galaxy cluster redshift - z_inf: float - Redshift at infinity - pdz: argument function - Redshift probability density function. Default is\ - Chang et al (2013) unnormalized galaxy redshift distribution\ - function. - zmin: float - Minimum redshift to be set as the source of the galaxy\ - when performing the sum. - zmax: float - Minimum redshift to be set as the source of the galaxy\ - when performing the sum. - delta_z_cut: float - Redshift interval to be summed with $z_cl$ to return\ - a $zmin$. This feature is not used if $zmin$ is provided. - cosmo: Cosmology - Cosmology object - - Returns - ------- - float - Mean value of the geometric lensing efficicency ratio - """ - if pdz == None: - pdz = _chang_z_distrib - - def integrand(z_i, z_cl=z_cl, z_inf=z_inf, cosmo=cosmo): - return compute_beta_s(z_i, z_cl, z_inf, cosmo) * pdz(z_i) - - if zmin==None: - zmin = z_cl + delta_z_cut - Bs_mean = quad(integrand, zmin, zmax)[0] / quad(pdz, zmin, zmax)[0] - return Bs_mean - -def compute_beta_s_square_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, pdz=None): - r"""Mean square value of the geometric lensing efficicency ratio - - .. math:: - \left\2 =\frac{\sum_{z = z_{min}}^{z = z_{max}}\beta_s^2(z)p(z)}{\sum_{z = z_{min}}^{z = z_{max}}p(z)} - - Parameters - ---------- - z_cl: float - Galaxy cluster redshift - z_inf: float - Redshift at infinity - pdz: argument function - Redshift probability density function. Default is\ - Chang et al (2013) unnormalized galaxy redshift distribution\ - function. - zmin: float - Minimum redshift to be set as the source of the galaxy\ - when performing the sum. - zmax: float - Minimum redshift to be set as the source of the galaxy\ - when performing the sum. - delta_z_cut: float - Redshift interval to be summed with $z_cl$ to return\ - a $zmin$. This feature is not used if $zmin$ is provided. - cosmo: Cosmology - Cosmology object - - Returns - ------- - float - Mean square value of the geometric lensing efficicency ratio. - """ - if pdz == None: - pdz = _chang_z_distrib - - def integrand(z_i, z_cl=z_cl, z_inf=z_inf, cosmo=cosmo): - return compute_beta_s(z_i, z_cl, z_inf, cosmo)**2 * pdz(z_i) - - if zmin==None: - zmin = z_cl + delta_z_cut -<<<<<<< HEAD - Bs_s_mean = quad(integrand, zmin, zmax)[0] / quad(pdz, zmin, zmax)[0] - return Bs_s_mean -======= - Bs_mean = quad(integrand, zmin, zmax)[0] / quad(pdz, zmin, zmax)[0] - return Bs_mean - -def _chang_z_distrib(redshift, is_cdf=False): - """ - A private function that returns the Chang et al (2013) unnormalized galaxy redshift distribution - function, with the fiducial set of parameters. - - Parameters - ---------- - redshift : float - Galaxy redshift - is_cdf : bool - If True, returns cumulative distribution function. - - Returns - ------- - The value of the distribution at z - """ - alpha, beta, redshift0 = 1.24, 1.01, 0.51 - if is_cdf: - return redshift0**(alpha+1)*gammainc((alpha+1)/beta, (redshift/redshift0)**beta)/beta*gamma((alpha+1)/beta) - else: - return (redshift**alpha)*np.exp(-(redshift/redshift0)**beta) - -def _srd_z_distrib(redshift, is_cdf=False): - """ - A private function that returns the unnormalized galaxy redshift distribution function used in - the LSST/DESC Science Requirement Document (arxiv:1809.01669). - - Parameters - ---------- - redshift : float - Galaxy redshift - is_cdf : bool - If True, returns cumulative distribution function. - - Returns - ------- - The value of the distribution at z - """ - alpha, beta, redshift0 = 2., 0.9, 0.28 - if is_cdf: - return redshift0**(alpha+1)*gammainc((alpha+1)/beta, (redshift/redshift0)**beta)/beta*gamma((alpha+1)/beta) - else: - return (redshift**alpha)*np.exp(-(redshift/redshift0)**beta) ->>>>>>> 22eda2796c3d436b3c6dfaca05046adb9a646874 diff --git a/examples/term2h_nc.txt b/examples/term2h_nc.txt deleted file mode 100644 index cc2f7f48d..000000000 --- a/examples/term2h_nc.txt +++ /dev/null @@ -1,100 +0,0 @@ -1.000000000000000021e-02 2.450321215942639542e+10 -1.097498765493056146e-02 2.582364849782210922e+10 -1.204503540258782326e-02 2.717986641351715469e+10 -1.321941148466028795e-02 2.875505951695832443e+10 -1.450828778495939428e-02 3.072292569362144089e+10 -1.592282793341092198e-02 3.314568384264012527e+10 -1.747528400007683849e-02 3.589019518063602448e+10 -1.917910261672488639e-02 3.866510386589351654e+10 -2.104904144512020903e-02 4.124642492877477264e+10 -2.310129700083160542e-02 4.375949119816561890e+10 -2.535364493970111363e-02 4.663945700533943939e+10 -2.782559402207124277e-02 5.007795312893126678e+10 -3.053855508833415444e-02 5.364302065496985626e+10 -3.351602650938842465e-02 5.702479777682296753e+10 -3.678379771828634015e-02 6.077313394732890320e+10 -4.037017258596553582e-02 6.502378972815399170e+10 -4.430621457583882455e-02 6.914267117891433716e+10 -4.862601580065353118e-02 7.367832082273686218e+10 -5.336699231206309957e-02 7.849099949712435913e+10 -5.857020818056667133e-02 8.344389834407061768e+10 -6.428073117284321958e-02 8.879009839267294312e+10 -7.054802310718645553e-02 9.436155627241120911e+10 -7.742636826811269413e-02 1.001730588849221191e+11 -8.497534359086446332e-02 1.063974460165665131e+11 -9.326033468832199691e-02 1.128747383454654999e+11 -1.023531021899026366e-01 1.196363307049693756e+11 -1.123324032978027659e-01 1.267320510040680084e+11 -1.232846739442066547e-01 1.341688570392554474e+11 -1.353047774579807516e-01 1.419454959612069092e+11 -1.484968262254464932e-01 1.500484800730760193e+11 -1.629750834620644351e-01 1.584733909994166870e+11 -1.788649529057435017e-01 1.672710560533544006e+11 -1.963040650040271395e-01 1.763854633189150085e+11 -2.154434690031884481e-01 1.858598252718684692e+11 -2.364489412645408295e-01 1.956639196399551392e+11 -2.595024211399737379e-01 2.057852114509843140e+11 -2.848035868435802032e-01 2.162214395589595032e+11 -3.125715849688237014e-01 2.269960181723335571e+11 -3.430469286314919430e-01 2.380772026773450012e+11 -3.764935806792469308e-01 2.494060497311617126e+11 -4.132012400115338546e-01 2.608117676747231140e+11 -4.534878508128584174e-01 2.729142770443499451e+11 -4.977023564332111460e-01 2.848286240289870605e+11 -5.462277217684342601e-01 2.968217913506503296e+11 -5.994842503189411476e-01 3.095263003383236694e+11 -6.579332246575682053e-01 3.216722843219785156e+11 -7.220809018385467848e-01 3.341219960756307373e+11 -7.924828983539177196e-01 3.469056480416076050e+11 -8.697490026177834288e-01 3.589080179125376587e+11 -9.545484566618341882e-01 3.715064833301427612e+11 -1.047615752789665233e+00 3.837582142192907104e+11 -1.149756995397736903e+00 3.949933687838672485e+11 -1.261856883066021062e+00 4.072353933249326172e+11 -1.384886371393873050e+00 4.183155997483372192e+11 -1.519911082952934755e+00 4.282539736912182617e+11 -1.668100537200059241e+00 4.394270609114318237e+11 -1.830738280295369780e+00 4.485853924575095825e+11 -2.009233002565047776e+00 4.568394253247011108e+11 -2.205130739903045534e+00 4.657253947823126831e+11 -2.420128264794383366e+00 4.720264871379987793e+11 -2.656087782946686904e+00 4.783374304151119385e+11 -2.915053062825178731e+00 4.835202033891856689e+11 -3.199267137797384475e+00 4.861481485057972412e+11 -3.511191734215134641e+00 4.897071519766116333e+11 -3.853528593710531247e+00 4.909615239880612183e+11 -4.229242874389498752e+00 4.887889937525338745e+11 -4.641588833612781961e+00 4.890118723536967163e+11 -5.094138014816380178e+00 4.852691040884033813e+11 -5.590810182512228721e+00 4.788424516505772095e+11 -6.135907273413176100e+00 4.749955659364075317e+11 -6.734150657750828550e+00 4.656489189290159302e+11 -7.390722033525782386e+00 4.556975134323302612e+11 -8.111308307896871739e+00 4.457718625114807739e+11 -8.902150854450392004e+00 4.307686450427430420e+11 -9.770099572992256398e+00 4.181127966914452515e+11 -1.072267222010324339e+01 4.029579234428847656e+11 -1.176811952434999142e+01 3.824960964864786377e+11 -1.291549665014884063e+01 3.676805133867901001e+11 -1.417474162926806258e+01 3.483574896556759033e+11 -1.555676143930472222e+01 3.245351796807640991e+11 -1.707352647470692020e+01 3.093679167254439087e+11 -1.873817422860384951e+01 2.865114091601412354e+11 -2.056512308348653661e+01 2.628138242063374023e+11 -2.257019719633921540e+01 2.458918336387040710e+11 -2.477076355991711409e+01 2.210363407311755676e+11 -2.718588242732942817e+01 2.025139727240394287e+11 -2.983647240283340452e+01 1.828613941084895935e+11 -3.274549162877731590e+01 1.585754621992243958e+11 -3.593813663804629499e+01 1.457694431423413086e+11 -3.944206059437659917e+01 1.287957930683296661e+11 -4.328761281083061618e+01 1.040817541542567749e+11 -4.750810162102798273e+01 9.876485313003871155e+10 -5.214008287999689628e+01 8.314542821097509766e+10 -5.722367659350220492e+01 6.477508455225241089e+10 -6.280291441834259558e+01 6.486439088418131256e+10 -6.892612104349701951e+01 5.040400910539440918e+10 -7.564633275546290747e+01 4.205551185695338440e+10 -8.302175681319752698e+01 3.857194131048378754e+10 -9.111627561154895716e+01 2.457745561368053818e+10 -1.000000000000000000e+02 2.591326326844504166e+10 diff --git a/tests/test_utils.py.orig b/tests/test_utils.py.orig deleted file mode 100644 index e49af704b..000000000 --- a/tests/test_utils.py.orig +++ /dev/null @@ -1,413 +0,0 @@ -# pylint: disable=no-member, protected-access -""" Tests for utils.py """ -import numpy as np -from numpy.testing import assert_raises, assert_allclose -from scipy.integrate import quad -import clmm.utils as utils -import clmm.theory as md -from clmm.utils import ( - compute_radial_averages, make_bins, convert_shapes_to_epsilon, arguments_consistency, - validate_argument) - - -TOLERANCE = {'rtol': 1.0e-6, 'atol': 0} - - -def test_compute_radial_averages(): - """ Tests compute_radial_averages, a function that computes several binned statistics """ - # Make some test data - binvals = np.array([2., 3., 6., 8., 4., 9.]) - xbins1 = [0., 10.] - xbins2 = [0., 5., 10.] - - # Test requesting an unsupported error model - assert_raises(ValueError, compute_radial_averages, binvals, binvals, [0., 10.], error_model='glue') - - # Check the default error model - assert_allclose(compute_radial_averages(binvals, binvals, xbins1)[:4], - [[np.mean(binvals)], [np.mean(binvals)], [np.std(binvals)/np.sqrt(len(binvals))], - [6]], - **TOLERANCE) - # Test weights - # Normalized - assert_allclose(compute_radial_averages([1, 1], [2, 3], [1, 2], weights=[.5, .5])[:3], - ([1], [2.5], [1/np.sqrt(8)]), - **TOLERANCE) - # Not normalized - assert_allclose(compute_radial_averages([1, 1], [2, 3], [1, 2], weights=[5, 5])[:3], - ([1], [2.5], [1/np.sqrt(8)]), - **TOLERANCE) - # Values outside bins - assert_allclose(compute_radial_averages([1, 1, 3], [2, 3, 1000], [1, 2], weights=[.5, .5, 100])[:3], - ([1], [2.5], [1/np.sqrt(8)]), - **TOLERANCE) - # Weighted values == Repeated values (std only) - assert_allclose(compute_radial_averages([1, 1], [2, 3], [1, 2], weights=[1, 2], error_model='std')[:3], - compute_radial_averages([1, 1, 1], [2, 3, 3], [1, 2], error_model='std')[:3], - **TOLERANCE) - # Zero yerr - assert_allclose(compute_radial_averages([1, 1], [2, 3], [1, 2], weights=[.5, .5], yerr=[0, 0])[:3], - ([1], [2.5], [1/np.sqrt(8)]), - **TOLERANCE) - # With yerr - assert_allclose(compute_radial_averages([1, 1], [2, 3], [1, 2], weights=[.5, .5], yerr=[1, 1])[:3], - ([1], [2.5], [np.sqrt(5/8)]), - **TOLERANCE) - - # Test 3 objects in one bin with various error models - assert_allclose(compute_radial_averages(binvals, binvals, xbins1, error_model='ste')[:4], - [[np.mean(binvals)], [np.mean(binvals)], [np.std(binvals)/np.sqrt(len(binvals))], [6]], - **TOLERANCE) - assert_allclose(compute_radial_averages(binvals, binvals, xbins1, error_model='std')[:4], - [[np.mean(binvals)], [np.mean(binvals)], [np.std(binvals)], - [6]], **TOLERANCE) - - # Repeat test with different error_model case - assert_allclose(compute_radial_averages(binvals, binvals, xbins1, error_model='STE')[:4], - [[np.mean(binvals)], [np.mean(binvals)], [np.std(binvals)/np.sqrt(len(binvals))], [6]], - **TOLERANCE) - assert_allclose(compute_radial_averages(binvals, binvals, xbins1, error_model='STD')[:4], - [[np.mean(binvals)], [np.mean(binvals)], [np.std(binvals)], - [6]], **TOLERANCE) - - - # A slightly more complicated case with two bins - inbin1 = binvals[(binvals > xbins2[0]) & (binvals < xbins2[1])] - inbin2 = binvals[(binvals > xbins2[1]) & (binvals < xbins2[2])] - assert_allclose(compute_radial_averages(binvals, binvals, xbins2, error_model='ste')[:4], - [[np.mean(inbin1), np.mean(inbin2)], [np.mean(inbin1), np.mean(inbin2)], - [np.std(inbin1)/np.sqrt(len(inbin1)), np.std(inbin2)/np.sqrt(len(inbin2))], - [3,3]], **TOLERANCE) - assert_allclose(compute_radial_averages(binvals, binvals, xbins2, error_model='std')[:4], - [[np.mean(inbin1), np.mean(inbin2)], [np.mean(inbin1), np.mean(inbin2)], - [np.std(inbin1), np.std(inbin2)], - [3,3]], **TOLERANCE) - - # Test a much larger, random sample with unevenly spaced bins - binvals = np.loadtxt('tests/data/radial_average_test_array.txt') - xbins2 = [0.0, 3.33, 6.66, 10.0] - inbin1 = binvals[(binvals > xbins2[0]) & (binvals < xbins2[1])] - inbin2 = binvals[(binvals > xbins2[1]) & (binvals < xbins2[2])] - inbin3 = binvals[(binvals > xbins2[2]) & (binvals < xbins2[3])] - assert_allclose(compute_radial_averages(binvals, binvals, xbins2, error_model='ste')[:4], - [[np.mean(inbin1), np.mean(inbin2), np.mean(inbin3)], - [np.mean(inbin1), np.mean(inbin2), np.mean(inbin3)], - [np.std(inbin1)/np.sqrt(len(inbin1)), np.std(inbin2)/np.sqrt(len(inbin2)), - np.std(inbin3)/np.sqrt(len(inbin3))], - [inbin1.size, inbin2.size, inbin3.size]], **TOLERANCE) - assert_allclose(compute_radial_averages(binvals, binvals, xbins2, error_model='std')[:4], - [[np.mean(inbin1), np.mean(inbin2), np.mean(inbin3)], - [np.mean(inbin1), np.mean(inbin2), np.mean(inbin3)], - [np.std(inbin1), np.std(inbin2), np.std(inbin3)], - [inbin1.size, inbin2.size, inbin3.size]], **TOLERANCE) - -def test_make_bins(): - """ Test the make_bins function. Right now this function is pretty simplistic and the - tests are pretty circular. As more functionality is added here the tests will - become more substantial. - """ - # Test various combinations of rmin and rmax with default values - assert_allclose(make_bins(0.0, 10.), np.linspace( - 0.0, 10., 11), **TOLERANCE) - assert_raises(ValueError, make_bins, 0.0, -10.) - assert_raises(ValueError, make_bins, -10., 10.) - assert_raises(ValueError, make_bins, -10., -5.) - assert_raises(ValueError, make_bins, 10., 0.0) - - # Test various nbins - assert_allclose(make_bins(0.0, 10., nbins=3), - np.linspace(0.0, 10., 4), **TOLERANCE) - assert_allclose(make_bins(0.0, 10., nbins=13), - np.linspace(0.0, 10., 14), **TOLERANCE) - assert_raises(ValueError, make_bins, 0.0, 10., -10) - assert_raises(ValueError, make_bins, 0.0, 10., 0) - - # Test default method - assert_allclose(make_bins(0.0, 10., nbins=10), - make_bins(0.0, 10., nbins=10, method='evenwidth'), - **TOLERANCE) - - # Test the different binning methods - assert_allclose(make_bins(0.0, 10., nbins=10, method='evenwidth'), - np.linspace(0.0, 10., 11), **TOLERANCE) - assert_allclose(make_bins(1.0, 10., nbins=10, method='evenlog10width'), - np.logspace(np.log10(1.0), np.log10(10.), 11), **TOLERANCE) - - # Repeat test with different error_model case - assert_allclose(make_bins(0.0, 10., nbins=10, method='EVENWIDTH'), - np.linspace(0.0, 10., 11), **TOLERANCE) - assert_allclose(make_bins(1.0, 10., nbins=10, method='EVENLOG10WIDTH'), - np.logspace(np.log10(1.0), np.log10(10.), 11), **TOLERANCE) - - # Test equaloccupation method. It needs a source_seps array, so create one - test_array = np.sqrt(np.random.uniform(-10, 10, 1361) - ** 2+np.random.uniform(-10, 10, 1361)**2) - test_bins = make_bins(1.0, 10., nbins=10, - method='equaloccupation', source_seps=test_array) - # Check that all bins have roughly equal occupation. - # Assert needs atol=2, because len(source_seps)/nbins may not be an integer, - # and for some random arrays atol=1 is not enough. - assert_allclose(np.diff(np.histogram(test_array, bins=test_bins)[0]), - np.zeros(9), atol=2) - test_bins = make_bins(0.51396, 6.78, nbins=23, - method='equaloccupation', source_seps=test_array) - assert_allclose(np.diff(np.histogram(test_array, bins=test_bins)[0]), - np.zeros(22), atol=2) - assert_raises(ValueError, make_bins, 0, 10, 10, 'equaloccupation', None) - assert_raises(ValueError, make_bins, 0, 10, 10, 'undefinedmethod') - - -def test_convert_units(): - """ Test the wrapper function to convert units. Corner cases should be tested in the - individual functions. This function should test one case for all supported conversions - and the error handling. - """ - # Make an astropy cosmology object for testing - # cosmo = FlatLambdaCDM(H0=70., Om0=0.3) - cosmo = md.Cosmology(H0=70.0, Omega_dm0=0.3-0.045, Omega_b0=0.045) - - # Test that each unit is supported - utils.convert_units(1.0, 'radians', 'degrees') - utils.convert_units(1.0, 'arcmin', 'arcsec') - utils.convert_units(1.0, 'Mpc', 'kpc') - utils.convert_units(1.0, 'Mpc', 'kpc') - - # Error checking - assert_raises(ValueError, utils.convert_units, 1.0, 'radians', 'CRAZY') - assert_raises(ValueError, utils.convert_units, 1.0, 'CRAZY', 'radians') - assert_raises(TypeError, utils.convert_units, 1.0, 'arcsec', 'Mpc') - assert_raises(TypeError, utils.convert_units, - 1.0, 'arcsec', 'Mpc', None, cosmo) - assert_raises(TypeError, utils.convert_units, - 1.0, 'arcsec', 'Mpc', 0.5, None) - assert_raises(ValueError, utils.convert_units, - 1.0, 'arcsec', 'Mpc', -0.5, cosmo) - - # Test cases to make sure angular -> angular is fitting together - assert_allclose(utils.convert_units( - np.pi, 'radians', 'degrees'), 180., **TOLERANCE) - assert_allclose(utils.convert_units( - 180.0, 'degrees', 'radians'), np.pi, **TOLERANCE) - assert_allclose(utils.convert_units( - 1.0, 'degrees', 'arcmin'), 60., **TOLERANCE) - assert_allclose(utils.convert_units( - 1.0, 'degrees', 'arcsec'), 3600., **TOLERANCE) - - # Test cases to make sure physical -> physical is fitting together - assert_allclose(utils.convert_units(1.0, 'Mpc', 'kpc'), 1.0e3, **TOLERANCE) - assert_allclose(utils.convert_units(1000., 'kpc', 'Mpc'), 1.0, **TOLERANCE) - assert_allclose(utils.convert_units(1.0, 'Mpc', 'pc'), 1.0e6, **TOLERANCE) - - # Test conversion from angular to physical - # Using astropy, circular now but this will be fine since we are going to be - # swapping to CCL soon and then its kosher - r_arcmin, redshift = 20.0, 0.5 - d_a = cosmo.eval_da(redshift)*1.e3 # kpc - truth = r_arcmin*(1.0/60.0)*(np.pi/180.0)*d_a - assert_allclose(utils.convert_units(r_arcmin, 'arcmin', 'kpc', redshift, cosmo), - truth, **TOLERANCE) - - # Test conversion both ways between angular and physical units - # Using astropy, circular now but this will be fine since we are going to be - # swapping to CCL soon and then its kosher - r_kpc, redshift = 20.0, 0.5 -# d_a = cosmo.angular_diameter_distance(redshift).to('kpc').value - d_a = cosmo.eval_da(redshift)*1.e3 # kpc - truth = r_kpc*(1.0/d_a)*(180./np.pi)*60. - assert_allclose(utils.convert_units(r_kpc, 'kpc', 'arcmin', redshift, cosmo), - truth, **TOLERANCE) - - -def test_build_ellipticities(): - """test build ellipticities""" - - # second moments are floats - q11 = 0.5 - q22 = 0.3 - q12 = 0.02 - - assert_allclose( - utils.build_ellipticities(q11, q22, q12), - (0.25, 0.05, 0.12710007580505459, 0.025420015161010917), **TOLERANCE) - - # second moments are numpy array - q11 = np.array([0.5, 0.3]) - q22 = np.array([0.8, 0.2]) - q12 = np.array([0.01, 0.01]) - - assert_allclose( - utils.build_ellipticities(q11, q22, q12), - ([-0.23076923, 0.2], [0.01538462, 0.04], [-0.11697033, 0.10106221], - [0.00779802, 0.02021244]), - **TOLERANCE) - - -def test_shape_conversion(): - """ Test the helper function that convert user defined shapes into - epsilon ellipticities or reduced shear. Both can be used for the galcat in - the GalaxyCluster object""" - - # Number of random ellipticities to check - niter = 25 - - # Create random second moments and from that random ellipticities - q11, q22 = np.random.randint(0, 20, (2, niter)) - # Q11 seperate to avoid a whole bunch of nans - q12 = np.random.uniform(-1, 1, niter)*np.sqrt(q11*q22) - chi1, chi2, ellips1, ellips2 = utils.build_ellipticities(q11, q22, q12) - - # Test conversion from 'chi' to epsilon - ellips1_2, ellips2_2 = convert_shapes_to_epsilon(chi1, chi2, shape_definition='chi') - assert_allclose(ellips1, ellips1_2, **TOLERANCE) - assert_allclose(ellips2, ellips2_2, **TOLERANCE) - - # Test that 'epsilon' just returns the same values - ellips1_2, ellips2_2 = convert_shapes_to_epsilon(ellips1, ellips2, shape_definition='epsilon') - assert_allclose(ellips1, ellips1_2, **TOLERANCE) - assert_allclose(ellips2, ellips2_2, **TOLERANCE) - - # Test that 'reduced_shear' just returns the same values - ellips1_2, ellips2_2 = convert_shapes_to_epsilon( - ellips1, ellips2, shape_definition='reduced_shear') - assert_allclose(ellips1, ellips1_2, **TOLERANCE) - assert_allclose(ellips2, ellips2_2, **TOLERANCE) - - # Test that 'shear' just returns the right values for reduced shear - ellips1_2, ellips2_2 = convert_shapes_to_epsilon( - ellips1, ellips2, shape_definition='shear', kappa=0.2) - assert_allclose(ellips1/0.8, ellips1_2, **TOLERANCE) - assert_allclose(ellips2/0.8, ellips2_2, **TOLERANCE) - # Test known shape_definition - assert_raises(TypeError, convert_shapes_to_epsilon, - ellips1, ellips2, shape_definition='undefinedSD') - - -def test_compute_lensed_ellipticities(): - """test compute lensed ellipticities""" - - # Validation test with floats - es1 = 0 - es2 = 0 - gamma1 = 0.2 - gamma2 = 0.2 - kappa = 0.5 - assert_allclose(utils.compute_lensed_ellipticity( - es1, es2, gamma1, gamma2, kappa), (0.4, 0.4), **TOLERANCE) - - # Validation test with array - es1 = np.array([0, 0.5]) - es2 = np.array([0, 0.1]) - gamma1 = np.array([0.2, 0.]) - gamma2 = np.array([0.2, 0.3]) - kappa = np.array([0.5, 0.2]) - - assert_allclose(utils.compute_lensed_ellipticity(es1, es2, gamma1, gamma2, kappa), - ([0.4, 0.38656171], [0.4, 0.52769188]), **TOLERANCE) - - -def test_arguments_consistency(): - """test arguments consistency""" - assert_allclose(arguments_consistency([1, 2]), [1, 2], **TOLERANCE) - assert_allclose(arguments_consistency( [1, 2], names=['a', 'b']), [1, 2], **TOLERANCE) - assert_allclose(arguments_consistency( [1, 2], names='ab'), [1, 2], **TOLERANCE) - assert_allclose(arguments_consistency( [1, 2], names=['a', 'b'], prefix='x'), [1, 2], - **TOLERANCE) - - assert_allclose(arguments_consistency([[1], [2]]), [[1], [2]], **TOLERANCE) - assert_allclose(arguments_consistency( [[1], [2]], names=['a', 'b']), [[1], [2]], **TOLERANCE) - assert_allclose(arguments_consistency( [[1], [2]], names='ab'), [[1], [2]], **TOLERANCE) - assert_allclose(arguments_consistency([[1], [2]], names=[ 'a', 'b'], prefix='x'), [[1], [2]], - **TOLERANCE) - # test error - assert_raises(TypeError, arguments_consistency, [1, [1, 2]]) - assert_raises(TypeError, arguments_consistency, [[1], [1, 2]]) - assert_raises(TypeError, arguments_consistency, [1, 2], names=['a']) - - -def test_validate_argument(): - """test validate argument""" - loc = {'float': 1.1, 'int':3, 'str': 'test', 'int_array': [1, 2], 'float_array': [1.1, 1.2], - 'float_str': '1.1', 'none':None,} - # Validate type - for type_ in (int, float, 'int_array', 'float_array', (str, int)): - assert validate_argument(loc, 'int', type_) is None - for type_ in (float, 'float_array', (str, float)): - assert validate_argument(loc, 'float', type_) is None - for type_ in ('int_array', 'float_array', (str, 'int_array')): - assert validate_argument(loc, 'int_array', type_) is None - for type_ in ('float_array', (str, 'float_array')): - assert validate_argument(loc, 'float_array', type_) is None - for type_ in (str, ('float_array', str, float)): - assert validate_argument(loc, 'str', type_) is None - assert validate_argument(loc, 'none', 'float', none_ok=True) is None # test none_ok - - for type_ in (bool, (bool, tuple)): - for argname in loc: - assert_raises(TypeError, validate_argument, loc, argname, type_) - - for type_ in (int, (str, 'int_array')): - assert_raises(TypeError, validate_argument, loc, 'float', type_) - - for type_ in (int, float, (str, float)): - for argname in ('int_array', 'float_array'): - assert_raises(TypeError, validate_argument, loc, argname, type_) - - for argname in ('float', 'int', 'int_array', 'float_array', 'float_str'): - assert validate_argument(loc, argname, ('float_array', str), argmin=0, argmax=4, - eqmin=False, eqmax=False) is None - assert validate_argument(loc, argname, ('float_array', str), argmin=0, argmax=4, - eqmin=True, eqmax=True) is None - - assert_raises(TypeError, validate_argument, loc, 'str', ('float_array', str), argmin=0) - - - for argname in ('float', 'float_array', 'float_str'): - assert_raises(ValueError, validate_argument, loc, argname, ('float_array', str), argmin=1.1) - assert validate_argument(loc, argname, ('float_array', str), argmin=1.1, eqmin=True) is None - assert_raises(ValueError, validate_argument, loc, argname, ('float_array', str), argmax=1.1) - - assert validate_argument(loc, 'float_array', ('float_array', str), argmax=1.2, eqmax=True) is None - -def test_beta_functions(): - z_cl = 1.0 - z_s = 2.4 - z_inf =1000. - zmax = 15.0 - nsteps = 1000 - zmin = z_cl + 0.1 - z_int = np.linspace(zmin, zmax, nsteps) - cosmo = md.Cosmology(H0=70.0, Omega_dm0=0.27 - 0.045, - Omega_b0=0.045, Omega_k0=0.0) - beta_test = np.heaviside(z_s-z_cl, 0) * cosmo.eval_da_z1z2(z_cl, z_s) / cosmo.eval_da(z_cl) - beta_s_test = utils.compute_beta(z_s, z_cl, cosmo) / utils.compute_beta(z_inf, z_cl, cosmo) - - def pdz(z): - return (z**1.24)*np.exp(-(z/0.51)**1.01) - - def integrand1(z_i, z_cl=z_cl, cosmo=cosmo): - return utils.compute_beta(z_i, z_cl, cosmo) * pdz(z_i) - - def integrand2(z_i, z_inf=z_inf, z_cl=z_cl, cosmo=cosmo): - return utils.compute_beta_s(z_i, z_cl, z_inf, cosmo) * pdz(z_i) - - def integrand3(z_i, z_inf=z_inf, z_cl=z_cl, cosmo=cosmo): - return utils.compute_beta_s(z_i, z_cl, z_inf, cosmo)**2 * pdz(z_i) - - test1 = utils.compute_beta(z_s, z_cl, cosmo) -<<<<<<< HEAD - test2 = utils.compute_beta_s(z_s, z_cl, z_inf, cosmo) - test3 = utils.compute_beta_mean(z_cl, cosmo, zmax) - test4 = utils.compute_beta_s_mean(z_cl, z_inf,cosmo, zmax) - test5 = utils.compute_beta_s_square_mean(z_cl,z_inf,cosmo, zmax) -======= - test2 = utils.compute_beta_s(z_s, z_cl, z_inf, cosmo) - test3 = utils.compute_B_mean(z_cl, cosmo, zmax) - test4 = utils.compute_Bs_mean(z_cl, z_inf,cosmo, zmax) - test5 = utils.compute_Bs_square_mean(z_cl, z_inf,cosmo, zmax) ->>>>>>> 22eda2796c3d436b3c6dfaca05046adb9a646874 - - assert_allclose(test1, beta_test, **TOLERANCE) - assert_allclose(test2, beta_s_test, **TOLERANCE) - assert_allclose(test3, quad(integrand1, zmin, zmax)[0] / quad(pdz, zmin, zmax)[0], **TOLERANCE) - assert_allclose(test4, quad(integrand2, zmin, zmax)[0] / quad(pdz, zmin, zmax)[0], **TOLERANCE) - assert_allclose(test5, quad(integrand3, zmin, zmax)[0] / quad(pdz, zmin, zmax)[0], **TOLERANCE) From 8605658f020ed040ebb560c8b0f429391fee8be9 Mon Sep 17 00:00:00 2001 From: eduardojsbarroso Date: Thu, 2 Mar 2023 15:02:42 +0100 Subject: [PATCH 05/38] Implemented Weights option --- clmm/utils.py | 55 +++++++++++++++++++++++++-------------------- tests/test_utils.py | 9 ++++---- 2 files changed, 35 insertions(+), 29 deletions(-) diff --git a/clmm/utils.py b/clmm/utils.py index e507d2c7a..93811815c 100644 --- a/clmm/utils.py +++ b/clmm/utils.py @@ -782,7 +782,7 @@ def integrand(z_i, z_cl=z_cl, cosmo=cosmo): B_mean = quad(integrand, zmin, zmax)[0] / quad(z_distrib_func, zmin, zmax)[0] return B_mean -def compute_beta_s_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, z_distrib_func=None, weights_option=False, z_src = None): +def compute_beta_s_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, z_distrib_func=None, weights_option=False, z_src = None, shape_weights = None): r"""Mean value of the geometric lensing efficicency ratio .. math:: @@ -798,18 +798,20 @@ def compute_beta_s_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=Non cosmo: clmm.Cosmology CLMM Cosmology object zmax: float - Minimum redshift to be set as the source of the galaxy\ - when performing the sum. + Minimum redshift to be set as the source of the galaxy\ + when performing the sum. delta_z_cut: float - Redshift interval to be summed with $z_cl$ to return\ - $zmin$. This feature is not used if $z_min$ is provided by the user. + Redshift interval to be summed with $z_cl$ to return\ + $zmin$. This feature is not used if $z_min$ is provided by the user. weights_option: boolean - If set to true, the function uses Eq.(13) from\ - https://arxiv.org/pdf/1611.03866.pdf with evenly distributed\ - weights summing to one. + If set to true, the function uses Eq.(13) from\ + https://arxiv.org/pdf/1611.03866.pdf with evenly distributed\ + weights summing to one. z_src: array_like, float - Invididual source galaxies redshift. - + Individual source galaxies redshift. + shape_weights: array-life, float, + Individual source galaxies shape weights. + Defalut: None Returns ------- float @@ -827,15 +829,17 @@ def integrand(z_i, z_cl=z_cl, z_inf=z_inf, cosmo=cosmo): Bs_mean = quad(integrand, zmin, zmax)[0] / quad(z_distrib_func, zmin, zmax)[0] elif weights_option == True: if z_src == None: - raise ValueError(f"Inividual source galaxies redshift needed") + raise ValueError(f"Individual source galaxies redshift needed") + elif shape_weights == None: + raise ValueError(f"Individual source galaxies shape weights needed") else: n_galaxies = len(z_src) weight = 1/n_galaxies - Bsw_i = [weight * compute_beta_s(z, z_cl, z_inf, cosmo) for z in z_src] + Bsw_i = [shape_weights[i] * compute_beta_s(z_src[i], z_cl, z_inf, cosmo) for i in range(0,len(z_src))] Bs_mean = np.sum(Bsw_i) return Bs_mean -def compute_beta_s_square_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, z_distrib_func=None, weights_option=False, z_src = None): +def compute_beta_s_square_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, z_distrib_func=None, weights_option=False, z_src = None, shape_weights = None): r"""Mean square value of the geometric lensing efficicency ratio .. math:: @@ -851,17 +855,20 @@ def compute_beta_s_square_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, z cosmo: clmm.Cosmology CLMM Cosmology object zmax: float - Minimum redshift to be set as the source of the galaxy\ - when performing the sum. + Minimum redshift to be set as the source of the galaxy\ + when performing the sum. delta_z_cut: float - Redshift interval to be summed with $z_cl$ to return\ - $zmin$. This feature is not used if $z_min$ is provided by the user. + Redshift interval to be summed with $z_cl$ to return\ + $zmin$. This feature is not used if $z_min$ is provided by the user. weights_option: boolean - If set to true, the function uses Eq.(13) from\ - https://arxiv.org/pdf/1611.03866.pdf with evenly distributed\ - weights summing to one. + If set to true, the function uses Eq.(13) from\ + https://arxiv.org/pdf/1611.03866.pdf with evenly distributed\ + weights summing to one. z_src: array_like, float - Invididual source galaxies redshift. + Invididual source galaxies redshift. + shape_weights: array-life, float, + Individual source galaxies shape weights. + Defalut: None Returns ------- float @@ -881,10 +888,10 @@ def integrand(z_i, z_cl=z_cl, z_inf=z_inf, cosmo=cosmo): elif weights_option == True: if z_src == None: raise ValueError(f"Inividual source galaxies redshift needed") + elif shape_weights == None: + raise ValueError(f"Individual source galaxies shape weights needed") else: - n_galaxies = len(z_src) - weight = 1/n_galaxies - Bsw_i = [weight * compute_beta_s(z, z_cl, z_inf, cosmo)**2 for z in z_src] + Bsw_i = [shape_weights[i] * compute_beta_s(z_src[i], z_cl, z_inf, cosmo)**2 for i in range(0,len(z_src))] Bs_square_mean = np.sum(Bsw_i) return Bs_square_mean diff --git a/tests/test_utils.py b/tests/test_utils.py index 09e7bd5d1..25a720271 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -480,8 +480,7 @@ def integrand3(z_i, z_inf=z_inf, z_cl=z_cl, cosmo=cosmo): **TOLERANCE) assert_allclose(test3, quad(integrand3, zmin, zmax)[0] / quad(model, zmin, zmax)[0], **TOLERANCE) - test4 = utils.compute_beta_s_mean(z_cl, z_inf,cosmo, zmax, weights_option=True, z_src=[2.1,2.3]) - test5 = utils.compute_beta_s_square_mean(z_cl, z_inf,cosmo, zmax, weights_option=True, z_src=[2.1, 2.3]) - - assert_allclose(test4, 0.5*utils.compute_beta_s(2.1, z_cl, z_inf, cosmo) + 0.5*utils.compute_beta_s(2.3, z_cl, z_inf, cosmo), **TOLERANCE) - assert_allclose(test5, 0.5*utils.compute_beta_s(2.1, z_cl, z_inf, cosmo)**2 + 0.5*utils.compute_beta_s(2.3, z_cl, z_inf, cosmo)**2, **TOLERANCE) + test4 = utils.compute_beta_s_mean(z_cl, z_inf,cosmo, zmax, weights_option=True, z_src=[2.1,2.3], shape_weights = [3.3,5.1]) + test5 = utils.compute_beta_s_square_mean(z_cl, z_inf,cosmo, zmax, weights_option=True, z_src=[2.1, 2.3], shape_weights = [3.3,5.1]) + assert_allclose(test4, 3.3*utils.compute_beta_s(2.1, z_cl, z_inf, cosmo) + 5.1*utils.compute_beta_s(2.3, z_cl, z_inf, cosmo), **TOLERANCE) + assert_allclose(test5, 3.3*utils.compute_beta_s(2.1, z_cl, z_inf, cosmo)**2 + 5.1*utils.compute_beta_s(2.3, z_cl, z_inf, cosmo)**2, **TOLERANCE) From 5766cfaa88fb1c88e2e49233742e3a34329122db Mon Sep 17 00:00:00 2001 From: eduardojsbarroso Date: Mon, 20 Mar 2023 11:29:52 +0100 Subject: [PATCH 06/38] Implemented resquested changes --- clmm/utils.py | 92 ++++++++++++++++++++++----------------------- tests/test_utils.py | 4 +- 2 files changed, 46 insertions(+), 50 deletions(-) diff --git a/clmm/utils.py b/clmm/utils.py index 93811815c..69e2ca1aa 100644 --- a/clmm/utils.py +++ b/clmm/utils.py @@ -668,8 +668,8 @@ def compute_beta(z_src, z_cl, cosmo): Parameters ---------- - z_src: float - Source galaxy redshift + z_src: float, array_like + Source galaxies redshift z_cl: float Galaxy cluster redshift cosmo: clmm.Cosmology @@ -677,11 +677,13 @@ def compute_beta(z_src, z_cl, cosmo): Returns ------- - float - Geometric lensing efficicency + numpy array + Geometric lensing efficicency for each source """ - beta = np.heaviside(z_src-z_cl, 0) * cosmo.eval_da_z1z2(z_cl, z_src) / cosmo.eval_da(z_src) - return beta + if type(z_src) is not list: + z_src = [z_src] + beta = [np.heaviside(z_src_i-z_cl, 0) * cosmo.eval_da_z1z2(z_cl, z_src_i) / cosmo.eval_da(z_src_i) for z_src_i in z_src] + return np.array(beta) def compute_beta_s(z_src, z_cl, z_inf, cosmo): r"""Geometric lensing efficicency ratio @@ -691,8 +693,8 @@ def compute_beta_s(z_src, z_cl, z_inf, cosmo): Parameters ---------- - z_src: float - Source galaxy redshift + z_src: float, array_like + Source galaxies redshift z_cl: float Galaxy cluster redshift z_inf: float @@ -702,8 +704,8 @@ def compute_beta_s(z_src, z_cl, z_inf, cosmo): Returns ------- - float - Geometric lensing efficicency ratio + numpy array + Geometric lensing efficicency ratio for each source """ beta_s = compute_beta(z_src, z_cl, cosmo) / compute_beta(z_inf, z_cl, cosmo) return beta_s @@ -717,8 +719,8 @@ def compute_beta_s_func(z_src, z_cl, z_inf, cosmo, func, *args, **kwargs): Parameters ---------- - z_src: float - Source galaxy redshift + z_src: float, array_like + Source galaxies redshift z_cl: float Galaxy cluster redshift z_inf: float @@ -734,8 +736,8 @@ def compute_beta_s_func(z_src, z_cl, z_inf, cosmo, func, *args, **kwargs): Returns ------- - float - Geometric lensing efficicency ratio + numpy array + Geometric lensing efficicency ratio for each source """ beta_s = compute_beta(z_src, z_cl, cosmo) / compute_beta(z_inf, z_cl, cosmo) beta_s_func = beta_s * func(*args, **kwargs) @@ -776,13 +778,13 @@ def compute_beta_mean(z_cl, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, z_dist def integrand(z_i, z_cl=z_cl, cosmo=cosmo): return compute_beta(z_i, z_cl, cosmo) * z_distrib_func(z_i) - if zmin==None: + if zmin is None: zmin = z_cl + delta_z_cut B_mean = quad(integrand, zmin, zmax)[0] / quad(z_distrib_func, zmin, zmax)[0] return B_mean -def compute_beta_s_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, z_distrib_func=None, weights_option=False, z_src = None, shape_weights = None): +def compute_beta_s_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, z_distrib_func=None, z_src = None, shape_weights = None): r"""Mean value of the geometric lensing efficicency ratio .. math:: @@ -803,43 +805,40 @@ def compute_beta_s_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=Non delta_z_cut: float Redshift interval to be summed with $z_cl$ to return\ $zmin$. This feature is not used if $z_min$ is provided by the user. - weights_option: boolean - If set to true, the function uses Eq.(13) from\ + z_src: float, array_like + Individual source galaxies redshift. + shape_weights: float, array_like + Individual source galaxies shape weights.\ + If not None, the function uses Eq.(13) from\ https://arxiv.org/pdf/1611.03866.pdf with evenly distributed\ weights summing to one. - z_src: array_like, float - Individual source galaxies redshift. - shape_weights: array-life, float, - Individual source galaxies shape weights. Defalut: None Returns ------- float Mean value of the geometric lensing efficicency ratio """ - if weights_option == False: - if z_distrib_func == None: + if shape_weights is None: + if z_distrib_func is None: z_distrib_func = zdist.chang2013 def integrand(z_i, z_cl=z_cl, z_inf=z_inf, cosmo=cosmo): return compute_beta_s(z_i, z_cl, z_inf, cosmo) * z_distrib_func(z_i) - if zmin==None: + if zmin is None: zmin = z_cl + delta_z_cut Bs_mean = quad(integrand, zmin, zmax)[0] / quad(z_distrib_func, zmin, zmax)[0] - elif weights_option == True: - if z_src == None: + else: + if z_src is None: raise ValueError(f"Individual source galaxies redshift needed") - elif shape_weights == None: - raise ValueError(f"Individual source galaxies shape weights needed") + else: n_galaxies = len(z_src) - weight = 1/n_galaxies - Bsw_i = [shape_weights[i] * compute_beta_s(z_src[i], z_cl, z_inf, cosmo) for i in range(0,len(z_src))] - Bs_mean = np.sum(Bsw_i) + Bsw = shape_weights * compute_beta_s(z_src, z_cl, z_inf, cosmo) + Bs_mean = np.sum(Bsw) return Bs_mean -def compute_beta_s_square_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, z_distrib_func=None, weights_option=False, z_src = None, shape_weights = None): +def compute_beta_s_square_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, z_distrib_func=None, z_src = None, shape_weights = None): r"""Mean square value of the geometric lensing efficicency ratio .. math:: @@ -860,39 +859,36 @@ def compute_beta_s_square_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, z delta_z_cut: float Redshift interval to be summed with $z_cl$ to return\ $zmin$. This feature is not used if $z_min$ is provided by the user. - weights_option: boolean - If set to true, the function uses Eq.(13) from\ + z_src: float, array_like + Invididual source galaxies redshift. + shape_weights: float, array_like + Individual source galaxies shape weights.\ + If not None, the function uses Eq.(13) from\ https://arxiv.org/pdf/1611.03866.pdf with evenly distributed\ weights summing to one. - z_src: array_like, float - Invididual source galaxies redshift. - shape_weights: array-life, float, - Individual source galaxies shape weights. Defalut: None Returns ------- float Mean square value of the geometric lensing efficicency ratio. """ - if weights_option == False: - if z_distrib_func == None: + if shape_weights is None: + if z_distrib_func is None: z_distrib_func = zdist.chang2013 def integrand(z_i, z_cl=z_cl, z_inf=z_inf, cosmo=cosmo): return compute_beta_s(z_i, z_cl, z_inf, cosmo)**2 * z_distrib_func(z_i) - if zmin==None: + if zmin is None: zmin = z_cl + delta_z_cut Bs_square_mean = quad(integrand, zmin, zmax)[0] / quad(z_distrib_func, zmin, zmax)[0] - elif weights_option == True: - if z_src == None: + else: + if z_src is None: raise ValueError(f"Inividual source galaxies redshift needed") - elif shape_weights == None: - raise ValueError(f"Individual source galaxies shape weights needed") else: - Bsw_i = [shape_weights[i] * compute_beta_s(z_src[i], z_cl, z_inf, cosmo)**2 for i in range(0,len(z_src))] - Bs_square_mean = np.sum(Bsw_i) + Bsw = shape_weights * np.square(compute_beta_s(z_src, z_cl, z_inf, cosmo)) + Bs_square_mean = np.sum(Bsw) return Bs_square_mean diff --git a/tests/test_utils.py b/tests/test_utils.py index 25a720271..99fea41ba 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -480,7 +480,7 @@ def integrand3(z_i, z_inf=z_inf, z_cl=z_cl, cosmo=cosmo): **TOLERANCE) assert_allclose(test3, quad(integrand3, zmin, zmax)[0] / quad(model, zmin, zmax)[0], **TOLERANCE) - test4 = utils.compute_beta_s_mean(z_cl, z_inf,cosmo, zmax, weights_option=True, z_src=[2.1,2.3], shape_weights = [3.3,5.1]) - test5 = utils.compute_beta_s_square_mean(z_cl, z_inf,cosmo, zmax, weights_option=True, z_src=[2.1, 2.3], shape_weights = [3.3,5.1]) + test4 = utils.compute_beta_s_mean(z_cl, z_inf,cosmo, zmax, z_src=[2.1,2.3], shape_weights = [3.3,5.1]) + test5 = utils.compute_beta_s_square_mean(z_cl, z_inf,cosmo, zmax, z_src=[2.1, 2.3], shape_weights = [3.3,5.1]) assert_allclose(test4, 3.3*utils.compute_beta_s(2.1, z_cl, z_inf, cosmo) + 5.1*utils.compute_beta_s(2.3, z_cl, z_inf, cosmo), **TOLERANCE) assert_allclose(test5, 3.3*utils.compute_beta_s(2.1, z_cl, z_inf, cosmo)**2 + 5.1*utils.compute_beta_s(2.3, z_cl, z_inf, cosmo)**2, **TOLERANCE) From 37a3e760c0b6c9901e143994791e6b15b777ccc8 Mon Sep 17 00:00:00 2001 From: eduardojsbarroso Date: Fri, 5 May 2023 17:25:55 +0200 Subject: [PATCH 07/38] Finished implementation of functions --- clmm/theory/parent_class.py | 18 ++- clmm/utils.py | 208 +++++++++++++++++++----------- examples/demo_boost_factors.ipynb | 190 +++++++++++++++++++++++---- tests/test_theory.py | 6 +- tests/test_utils.py | 34 +++-- 5 files changed, 328 insertions(+), 128 deletions(-) diff --git a/clmm/theory/parent_class.py b/clmm/theory/parent_class.py index 0964be65d..503065a11 100644 --- a/clmm/theory/parent_class.py +++ b/clmm/theory/parent_class.py @@ -12,8 +12,11 @@ compute_magnification_bias_from_magnification, compute_rdelta, compute_profile_mass_in_radius, convert_profile_mass_concentration) -from ..utils import (validate_argument, _integ_pzfuncs, compute_beta_s_mean, - compute_beta_s_square_mean, compute_beta_s_func) +from ..utils import (validate_argument, _integ_pzfuncs, compute_beta_s_func, + compute_beta_s_mean_from_weights, + compute_beta_s_mean_from_distribution, + compute_beta_s_square_mean_from_weights, + compute_beta_s_square_mean_from_distribution) class CLMModeling: @@ -665,7 +668,7 @@ def _get_beta_s_mean(self, z_cl, z_src, z_src_info='discrete', beta_kwargs=None) elif z_src_info=='distribution': # z_src (function) if PDZ beta_kwargs = {} if beta_kwargs is None else beta_kwargs - beta_s_mean = compute_beta_s_mean( + beta_s_mean = compute_beta_s_mean_from_distribution( z_cl, self.z_inf, self.cosmo, z_distrib_func=z_src, **beta_kwargs) return beta_s_mean @@ -726,9 +729,9 @@ def _get_beta_s_square_mean(self, z_cl, z_src, z_src_info='discrete', # z_src (tuple) is (beta_s_mean, beta_s_square_mean) beta_s_square_mean = z_src[1] elif z_src_info=='distribution': - # z_src (function) if PDZ + # z_src (function) is PDZ beta_kwargs = {} if beta_kwargs is None else beta_kwargs - beta_s_square_mean = compute_beta_s_square_mean( + beta_s_square_mean = compute_beta_s_square_mean_from_distribution( z_cl, self.z_inf, self.cosmo, z_distrib_func=z_src, **beta_kwargs) return beta_s_square_mean @@ -931,10 +934,11 @@ def _pdz_weighted_avg(self, core, pdz_func, r_proj, z_cl, integ_kwargs=None): array_like Function averaged by pdz, with r_proj dimention. """ + z_src_info_beta = 'discrete' tfunc = lambda z, r: compute_beta_s_func( - z, z_cl, self.z_inf, self.cosmo, self._eval_tangential_shear, r, z_cl, self.z_inf) + z, z_cl, self.z_inf, self.cosmo, z_src_info_beta, self._eval_tangential_shear, r, z_cl, self.z_inf) kfunc = lambda z, r: compute_beta_s_func( - z, z_cl, self.z_inf, self.cosmo, self._eval_convergence, r, z_cl, self.z_inf) + z, z_cl, self.z_inf, self.cosmo, z_src_info_beta, self._eval_convergence, r, z_cl, self.z_inf) __integrand__ = lambda z, r: pdz_func(z)*core(tfunc(z, r), kfunc(z, r)) _integ_kwargs = {'zmax': 10.0, 'delta_z_cut': 0.1} diff --git a/clmm/utils.py b/clmm/utils.py index 69e2ca1aa..e7fe57677 100644 --- a/clmm/utils.py +++ b/clmm/utils.py @@ -658,7 +658,7 @@ def compute_for_good_redshifts(function, z1, z2, bad_value, error_message): res = function(z1, z2) return res -def compute_beta(z_src, z_cl, cosmo): +def compute_beta(z_src, z_cl, cosmo, z_src_info='discrete'): r"""Geometric lensing efficicency .. math:: @@ -668,24 +668,33 @@ def compute_beta(z_src, z_cl, cosmo): Parameters ---------- - z_src: float, array_like - Source galaxies redshift + z_src : array_like, float, function + Information on the background source galaxy redshift(s). Value required depends on + `z_src_info` (see below). z_cl: float Galaxy cluster redshift cosmo: clmm.Cosmology CLMM Cosmology object + z_src_info : str, optional + Type of redshift information provided by the `z_src` argument. + In this function, the only supported option is: + * 'discrete' (default) : The redshift of sources is provided by `z_src`. + It can be individual redshifts for each source galaxy when `z_src` is an + array or all sources are at the same redshift when `z_src` is a float. Returns ------- numpy array - Geometric lensing efficicency for each source + Geometric lensing efficicency """ - if type(z_src) is not list: + try: + len(z_src) + except TypeError: z_src = [z_src] beta = [np.heaviside(z_src_i-z_cl, 0) * cosmo.eval_da_z1z2(z_cl, z_src_i) / cosmo.eval_da(z_src_i) for z_src_i in z_src] return np.array(beta) -def compute_beta_s(z_src, z_cl, z_inf, cosmo): +def compute_beta_s(z_src, z_cl, z_inf, cosmo, z_src_info='discrete'): r"""Geometric lensing efficicency ratio .. math:: @@ -693,24 +702,31 @@ def compute_beta_s(z_src, z_cl, z_inf, cosmo): Parameters ---------- - z_src: float, array_like - Source galaxies redshift + z_src : array_like, float, function + Information on the background source galaxy redshift(s). Value required depends on + `z_src_info` (see below). z_cl: float Galaxy cluster redshift z_inf: float Redshift at infinity cosmo: clmm.Cosmology CLMM Cosmology object + z_src_info : str, optional + Type of redshift information provided by the `z_src` argument. + In this function, the only supported option is: + * 'discrete' (default) : The redshift of sources is provided by `z_src`. + It can be individual redshifts for each source galaxy when `z_src` is an + array or all sources are at the same redshift when `z_src` is a float. Returns ------- numpy array - Geometric lensing efficicency ratio for each source + Geometric lensing efficicency ratio """ beta_s = compute_beta(z_src, z_cl, cosmo) / compute_beta(z_inf, z_cl, cosmo) return beta_s -def compute_beta_s_func(z_src, z_cl, z_inf, cosmo, func, *args, **kwargs): +def compute_beta_s_func(z_src, z_cl, z_inf, cosmo, z_src_info, func, *args, **kwargs): r"""Geometric lensing efficicency ratio times a value of a function .. math:: @@ -719,8 +735,9 @@ def compute_beta_s_func(z_src, z_cl, z_inf, cosmo, func, *args, **kwargs): Parameters ---------- - z_src: float, array_like - Source galaxies redshift + z_src : array_like, float, function + Information on the background source galaxy redshift(s). Value required depends on + `z_src_info` (see below). z_cl: float Galaxy cluster redshift z_inf: float @@ -729,6 +746,13 @@ def compute_beta_s_func(z_src, z_cl, z_inf, cosmo, func, *args, **kwargs): CLMM Cosmology object func: callable A scalar function + z_src_info : str, optional + Type of redshift information provided by the `z_src` argument. + In this function, the only supported option is: + + * 'discrete' (default) : The redshift of sources is provided by `z_src`. + It can be individual redshifts for each source galaxy when `z_src` is an + array or all sources are at the same redshift when `z_src` is a float. *args: positional arguments args to be passed to `func` **kwargs: keyword arguments @@ -743,17 +767,19 @@ def compute_beta_s_func(z_src, z_cl, z_inf, cosmo, func, *args, **kwargs): beta_s_func = beta_s * func(*args, **kwargs) return beta_s_func -def compute_beta_mean(z_cl, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, z_distrib_func=None): +def compute_beta_s_mean_from_distribution(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, z_distrib_func=None): r"""Mean value of the geometric lensing efficicency .. math:: - \left<\beta\right> = \frac{\int_{z = z_{min}}^{z_{max}}\beta(z)N(z)} + \left<\beta_s\right> = \frac{\int_{z = z_{min}}^{z_{max}}\beta_s(z)N(z)} {\int_{z = z_{min}}^{z_{max}}N(z)} Parameters ---------- z_cl: float Galaxy cluster redshift + z_inf: float + Redshift at infinity cosmo: clmm.Cosmology CLMM Cosmology object zmax: float, optional @@ -775,20 +801,20 @@ def compute_beta_mean(z_cl, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, z_dist """ if z_distrib_func is None: z_distrib_func = zdist.chang2013 - def integrand(z_i, z_cl=z_cl, cosmo=cosmo): - return compute_beta(z_i, z_cl, cosmo) * z_distrib_func(z_i) + def integrand(z_i): + return compute_beta_s(z_i, z_cl, z_inf, cosmo) * z_distrib_func(z_i) if zmin is None: zmin = z_cl + delta_z_cut - B_mean = quad(integrand, zmin, zmax)[0] / quad(z_distrib_func, zmin, zmax)[0] - return B_mean + Bs_mean = quad(integrand, zmin, zmax)[0] / quad(z_distrib_func, zmin, zmax)[0] + return Bs_mean -def compute_beta_s_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, z_distrib_func=None, z_src = None, shape_weights = None): - r"""Mean value of the geometric lensing efficicency ratio +def compute_beta_s_square_mean_from_distribution(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, z_distrib_func=None): + r"""Mean square value of the geometric lensing efficicency ratio .. math:: - \left<\beta_s\right> =\frac{\int_{z = z_{min}}^{z_{max}}\beta_s(z)N(z)} + \left<\beta_s^2\right> =\frac{\int_{z = z_{min}}^{z_{max}}\beta_s^2(z)N(z)} {\int_{z = z_{min}}^{z_{max}}N(z)} Parameters @@ -805,90 +831,120 @@ def compute_beta_s_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=Non delta_z_cut: float Redshift interval to be summed with $z_cl$ to return\ $zmin$. This feature is not used if $z_min$ is provided by the user. - z_src: float, array_like - Individual source galaxies redshift. - shape_weights: float, array_like - Individual source galaxies shape weights.\ - If not None, the function uses Eq.(13) from\ - https://arxiv.org/pdf/1611.03866.pdf with evenly distributed\ - weights summing to one. - Defalut: None + zmin: float, None, optional + Minimum redshift to be set as the source of the galaxy when performing the sum. + Default: None + z_distrib_func: one-parameter function, optional + Redshift distribution function. Default is Chang et al (2013) distribution function. Returns ------- float - Mean value of the geometric lensing efficicency ratio + Mean square value of the geometric lensing efficicency ratio. """ - if shape_weights is None: - if z_distrib_func is None: - z_distrib_func = zdist.chang2013 + if z_distrib_func is None: + z_distrib_func = zdist.chang2013 - def integrand(z_i, z_cl=z_cl, z_inf=z_inf, cosmo=cosmo): - return compute_beta_s(z_i, z_cl, z_inf, cosmo) * z_distrib_func(z_i) + def integrand(z_i): + return compute_beta_s(z_i, z_cl, z_inf, cosmo)**2 * z_distrib_func(z_i) - if zmin is None: - zmin = z_cl + delta_z_cut - Bs_mean = quad(integrand, zmin, zmax)[0] / quad(z_distrib_func, zmin, zmax)[0] - else: - if z_src is None: - raise ValueError(f"Individual source galaxies redshift needed") + if zmin is None: + zmin = z_cl + delta_z_cut + + Bs_square_mean = quad(integrand, zmin, zmax)[0] / quad(z_distrib_func, zmin, zmax)[0] + + return Bs_square_mean - else: - n_galaxies = len(z_src) - Bsw = shape_weights * compute_beta_s(z_src, z_cl, z_inf, cosmo) - Bs_mean = np.sum(Bsw) - return Bs_mean -def compute_beta_s_square_mean(z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, z_distrib_func=None, z_src = None, shape_weights = None): +def compute_beta_s_mean_from_weights(z_src, z_cl, z_inf, cosmo, shape_weights, z_src_info='discrete'): r"""Mean square value of the geometric lensing efficicency ratio .. math:: - \left<\beta_s^2\right> =\frac{\int_{z = z_{min}}^{z_{max}}\beta_s^2(z)N(z)} - {\int_{z = z_{min}}^{z_{max}}N(z)} + \left<\beta_s\right> =\frac{\sum_i \beta_s(z_i)w_i} + {\sum_i w_i} Parameters ---------- + z_src: float, array_like + Invididual source galaxies redshift. z_cl: float - Galaxy cluster redshift + Galaxy cluster redshift. z_inf: float - Redshift at infinity + Redshift at infinity. cosmo: clmm.Cosmology CLMM Cosmology object - zmax: float - Minimum redshift to be set as the source of the galaxy\ - when performing the sum. - delta_z_cut: float - Redshift interval to be summed with $z_cl$ to return\ - $zmin$. This feature is not used if $z_min$ is provided by the user. - z_src: float, array_like - Invididual source galaxies redshift. shape_weights: float, array_like Individual source galaxies shape weights.\ If not None, the function uses Eq.(13) from\ https://arxiv.org/pdf/1611.03866.pdf with evenly distributed\ weights summing to one. - Defalut: None + z_src_info : str, optional + Type of redshift information provided by the `z_src` argument. + In this function, the only supported option is: + + * 'discrete' (default) : The redshift of sources is provided by `z_src`. + It can be individual redshifts for each source galaxy when `z_src` is an + array or all sources are at the same redshift when `z_src` is a float. Returns ------- float - Mean square value of the geometric lensing efficicency ratio. + Mean value of the geometric lensing efficicency ratio. """ - if shape_weights is None: - if z_distrib_func is None: - z_distrib_func = zdist.chang2013 + try: + if len(z_src) != len(shape_weights): + raise ValueError("The source redshifts and the weights array must be the same size.") + except TypeError: + z_src = [z_src] + shape_weights = [shape_weights] + + weights_sum = np.sum(shape_weights) + shape_weights = np.array(shape_weights) + Bsw = shape_weights * compute_beta_s(z_src, z_cl, z_inf, cosmo) + Bs_square_mean = np.sum(Bsw) / weights_sum - def integrand(z_i, z_cl=z_cl, z_inf=z_inf, cosmo=cosmo): - return compute_beta_s(z_i, z_cl, z_inf, cosmo)**2 * z_distrib_func(z_i) + return Bs_square_mean - if zmin is None: - zmin = z_cl + delta_z_cut - Bs_square_mean = quad(integrand, zmin, zmax)[0] / quad(z_distrib_func, zmin, zmax)[0] - - else: - if z_src is None: - raise ValueError(f"Inividual source galaxies redshift needed") - else: - Bsw = shape_weights * np.square(compute_beta_s(z_src, z_cl, z_inf, cosmo)) - Bs_square_mean = np.sum(Bsw) +def compute_beta_s_square_mean_from_weights(z_src, z_cl, z_inf, cosmo, shape_weights, z_src_info='discrete'): + r"""Mean square value of the geometric lensing efficicency ratio + + .. math:: + \left<\beta_s^2\right> =\frac{\sum_i \beta_s^2(z_i)w_i} + {\sum_i w_i} + + Parameters + ---------- + z_src: float, array_like + Invididual source galaxies redshift. + z_cl: float + Galaxy cluster redshift. + z_inf: float + Redshift at infinity. + cosmo: clmm.Cosmology + CLMM Cosmology object + shape_weights: float, array_like + Individual source galaxies shape weights. + z_src_info : str, optional + Type of redshift information provided by the `z_src` argument. + In this function, the only supported option is: + + * 'discrete' (default) : The redshift of sources is provided by `z_src`. + It can be individual redshifts for each source galaxy when `z_src` is an + array or all sources are at the same redshift when `z_src` is a float. + Returns + ------- + float + Mean square value of the geometric lensing efficicency ratio. + """ + try: + if len(z_src) != len(shape_weights): + raise ValueError("The source redshifts and the weights array must be the same size.") + except TypeError: + z_src = [z_src] + shape_weights = [shape_weights] + + weights_sum = np.sum(shape_weights) + shape_weights = np.array(shape_weights) + Bsw = shape_weights * np.square(compute_beta_s(z_src, z_cl, z_inf, cosmo)) + Bs_square_mean = np.sum(Bsw) / weights_sum return Bs_square_mean diff --git a/examples/demo_boost_factors.ipynb b/examples/demo_boost_factors.ipynb index f3f37a6b1..2fb0d7fd8 100644 --- a/examples/demo_boost_factors.ipynb +++ b/examples/demo_boost_factors.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "7180b199", "metadata": {}, "outputs": [], @@ -34,10 +34,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "389d5ab7", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "'1.4.8'" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "clmm.__version__" ] @@ -52,7 +63,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "74bcb35c", "metadata": {}, "outputs": [], @@ -78,7 +89,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "6cec7b64", "metadata": {}, "outputs": [], @@ -112,7 +123,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "a564b1c9", "metadata": {}, "outputs": [], @@ -133,10 +144,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "bc5b051d", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/pbs/home/e/ebarroso/.local/lib/python3.11/site-packages/clmm-1.4.8-py3.11.egg/clmm/utils.py:641: UserWarning: Some source redshifts are lower than the cluster redshift. Returning Sigma_crit = np.inf for those galaxies.\n" + ] + } + ], "source": [ "_ = cl.compute_tangential_and_cross_components(\n", " geometry=\"flat\", shape_component1='e1', shape_component2='e2', \n", @@ -154,10 +173,75 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "eaadac01", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "GCData length=10\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
idxradius_minradiusradius_maxDeltaSigma_tanDeltaSigma_tan_errDeltaSigma_crossDeltaSigma_cross_errzz_errn_src
0115.98427.41664.302.07e+141.79e+135.36e+123.78e+120.960.0823
1664.30921.981212.621.22e+143.81e+125.37e+112.18e+121.250.1060
21212.621469.851760.957.85e+132.04e+12-7.46e+111.79e+121.360.0971
31760.952049.592309.275.78e+131.95e+12-3.03e+111.45e+121.160.06119
42309.272594.932857.594.40e+131.32e+126.37e+111.40e+121.340.07139
52857.593160.793405.923.54e+131.96e+12-1.90e+122.10e+121.220.06149
63405.923680.883954.242.75e+131.47e+12-2.41e+122.04e+121.280.06197
73954.244205.064502.562.47e+131.63e+12-9.21e+111.50e+121.330.07143
84502.564760.195050.891.76e+132.17e+12-5.49e+122.22e+121.320.1269
95050.895198.695599.211.90e+132.00e+12-4.19e+123.87e+121.490.1430
\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "cl.make_radial_profile(\"kpc\", cosmo=cosmo, \n", " tan_component_in='DeltaSigma_tan', cross_component_in='DeltaSigma_cross',\n", @@ -185,10 +269,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "0aeb2f52", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.errorbar(cl.DeltaSigma_profile['radius'], cl.DeltaSigma_profile['DeltaSigma_tan'],\n", " cl.DeltaSigma_profile['DeltaSigma_tan_err'], marker = 'o')\n", @@ -224,7 +319,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "e6b6ee3d", "metadata": {}, "outputs": [], @@ -244,10 +339,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "1c1de291", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.plot(cl.DeltaSigma_profile['radius'],nfw_boost,label='NFW boost factor')\n", "plt.plot(cl.DeltaSigma_profile['radius'],powerlaw_boost,label='Powerlaw boost factor')\n", @@ -298,7 +404,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "d7b5f71d", "metadata": {}, "outputs": [], @@ -319,10 +425,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "e2d90e0c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.errorbar(cl.DeltaSigma_profile['radius'], Sigma_corrected_nfw_boost,\n", " cl.DeltaSigma_profile['DeltaSigma_tan_err'], marker = 'o',label='$\\Delta \\Sigma$ / NFW boost factor')\n", @@ -351,10 +468,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "b4b3f953", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "Sigma_corrected_powerlaw_boost = u.correct_sigma_with_boost_model(cl.DeltaSigma_profile['radius'],\n", " cl.DeltaSigma_profile['DeltaSigma_tan'],\n", @@ -379,13 +507,29 @@ "plt.legend()\n", "plt.show()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "089d39af-9ca0-4d28-baa0-ba7b76fb40dd", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cb5021c2-9b96-43a0-ab23-b28c7508e38a", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python (firecrown2.0)", "language": "python", - "name": "python3" + "name": "firecrown" }, "language_info": { "codemirror_mode": { @@ -397,7 +541,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.9" + "version": "3.11.0" } }, "nbformat": 4, diff --git a/tests/test_theory.py b/tests/test_theory.py index 7964c1afe..80997b58f 100644 --- a/tests/test_theory.py +++ b/tests/test_theory.py @@ -7,7 +7,7 @@ from clmm.constants import Constants as clc from clmm.galaxycluster import GalaxyCluster from clmm import GCData -from clmm.utils import compute_beta_s_square_mean, compute_beta_s_mean +from clmm.utils import compute_beta_s_square_mean_from_distribution, compute_beta_s_mean_from_distribution, compute_beta_s_func from clmm.z_distributions import chang2013, desc_srd TOLERANCE = {'rtol': 1.0e-8} @@ -521,9 +521,9 @@ def test_shear_convergence_unittests(modeling_data, profile_init): # compute some values cfg_inf['GAMMA_PARAMS']['z_source'] = 1000. - beta_s_mean = compute_beta_s_mean( + beta_s_mean = compute_beta_s_mean_from_distribution( cfg_inf['GAMMA_PARAMS']['z_cluster'], cfg_inf['GAMMA_PARAMS']['z_source'], cosmo) - beta_s_square_mean = compute_beta_s_square_mean( + beta_s_square_mean = compute_beta_s_square_mean_from_distribution( cfg_inf['GAMMA_PARAMS']['z_cluster'], cfg_inf['GAMMA_PARAMS']['z_source'], cosmo) gammat_inf = theo.compute_tangential_shear(cosmo=cosmo, **cfg_inf['GAMMA_PARAMS']) diff --git a/tests/test_utils.py b/tests/test_utils.py index 99fea41ba..6acee7b3e 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -438,7 +438,8 @@ def test_validate_argument(): def test_beta_functions(): z_cl = 1.0 - z_s = 2.4 + z_src= [2.4, 2.1] + shape_weights = [4.6, 6.4] z_inf =1000. zmax = 15.0 nsteps = 1000 @@ -446,41 +447,36 @@ def test_beta_functions(): z_int = np.linspace(zmin, zmax, nsteps) cosmo = clmm.Cosmology(H0=70.0, Omega_dm0=0.27 - 0.045, Omega_b0=0.045, Omega_k0=0.0) - beta_test = np.heaviside(z_s-z_cl, 0) * cosmo.eval_da_z1z2(z_cl, z_s) / cosmo.eval_da(z_s) - beta_s_test = utils.compute_beta(z_s, z_cl, cosmo) / utils.compute_beta(z_inf, z_cl, cosmo) + beta_test = [np.heaviside(z_s-z_cl, 0) * cosmo.eval_da_z1z2(z_cl, z_s) / cosmo.eval_da(z_s) for z_s in z_src] + beta_s_test = utils.compute_beta(z_src, z_cl, cosmo) / utils.compute_beta(z_inf, z_cl, cosmo) - assert_allclose(utils.compute_beta(z_s, z_cl, cosmo), beta_test, **TOLERANCE) - assert_allclose(utils.compute_beta_s(z_s, z_cl, z_inf, cosmo), beta_s_test, **TOLERANCE) + assert_allclose(utils.compute_beta(z_src, z_cl, cosmo), beta_test, **TOLERANCE) + assert_allclose(utils.compute_beta_s(z_src, z_cl, z_inf, cosmo), beta_s_test, **TOLERANCE) for model in (None, zdist.chang2013, zdist.desc_srd): # None defaults to chang2013 for compute_beta* functions - test1 = utils.compute_beta_mean(z_cl, cosmo, zmax, z_distrib_func=model) - test2 = utils.compute_beta_s_mean(z_cl, z_inf, cosmo, zmax, z_distrib_func=model) - test3 = utils.compute_beta_s_square_mean(z_cl, z_inf, cosmo, zmax, + test1 = utils.compute_beta_s_mean_from_distribution(z_cl, z_inf, cosmo, zmax, z_distrib_func=model) + test2 = utils.compute_beta_s_square_mean_from_distribution(z_cl, z_inf, cosmo, zmax, z_distrib_func=model) if model is None: model = zdist.chang2013 - def integrand1(z_i, z_cl=z_cl, cosmo=cosmo): - return utils.compute_beta(z_i, z_cl, cosmo) * model(z_i) - - def integrand2(z_i, z_inf=z_inf, z_cl=z_cl, cosmo=cosmo): + def integrand1(z_i, z_inf=z_inf, z_cl=z_cl, cosmo=cosmo): return utils.compute_beta_s(z_i, z_cl, z_inf, cosmo) * model(z_i) - def integrand3(z_i, z_inf=z_inf, z_cl=z_cl, cosmo=cosmo): + def integrand2(z_i, z_inf=z_inf, z_cl=z_cl, cosmo=cosmo): return utils.compute_beta_s(z_i, z_cl, z_inf, cosmo)**2 * model(z_i) assert_allclose(test1, quad(integrand1, zmin, zmax)[0] / quad(model, zmin, zmax)[0], **TOLERANCE) assert_allclose(test2, quad(integrand2, zmin, zmax)[0] / quad(model, zmin, zmax)[0], **TOLERANCE) - assert_allclose(test3, quad(integrand3, zmin, zmax)[0] / quad(model, zmin, zmax)[0], - **TOLERANCE) - test4 = utils.compute_beta_s_mean(z_cl, z_inf,cosmo, zmax, z_src=[2.1,2.3], shape_weights = [3.3,5.1]) - test5 = utils.compute_beta_s_square_mean(z_cl, z_inf,cosmo, zmax, z_src=[2.1, 2.3], shape_weights = [3.3,5.1]) - assert_allclose(test4, 3.3*utils.compute_beta_s(2.1, z_cl, z_inf, cosmo) + 5.1*utils.compute_beta_s(2.3, z_cl, z_inf, cosmo), **TOLERANCE) - assert_allclose(test5, 3.3*utils.compute_beta_s(2.1, z_cl, z_inf, cosmo)**2 + 5.1*utils.compute_beta_s(2.3, z_cl, z_inf, cosmo)**2, **TOLERANCE) + + test3 = utils.compute_beta_s_mean_from_weights(z_src, z_cl, z_inf,cosmo, shape_weights) + test4 = utils.compute_beta_s_square_mean_from_weights(z_src, z_cl, z_inf,cosmo, shape_weights) + assert_allclose(test3, np.sum(shape_weights * utils.compute_beta_s(z_src, z_cl, z_inf, cosmo) / np.sum(shape_weights)), **TOLERANCE) + assert_allclose(test4, np.sum(shape_weights * utils.compute_beta_s(z_src, z_cl, z_inf, cosmo)**2 / np.sum(shape_weights)), **TOLERANCE) From b990d0e987a882acb18d09a9eabcc4b10ac822bf Mon Sep 17 00:00:00 2001 From: eduardojsbarroso Date: Tue, 9 May 2023 09:32:14 +0200 Subject: [PATCH 08/38] Fixed failling tests --- clmm/theory/parent_class.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/clmm/theory/parent_class.py b/clmm/theory/parent_class.py index 29e2555aa..9557ff9e5 100644 --- a/clmm/theory/parent_class.py +++ b/clmm/theory/parent_class.py @@ -952,9 +952,9 @@ def _pdz_weighted_avg(self, core, pdz_func, r_proj, z_cl, integ_kwargs=None): """ z_src_info_beta = 'discrete' tfunc = lambda z, r: compute_beta_s_func( - z, z_cl, self.z_inf, self.cosmo, z_src_info_beta, self._eval_tangential_shear, r, z_cl, self.z_inf) + z, z_cl, self.z_inf, self.cosmo, z_src_info_beta, self._eval_tangential_shear_core, r, z_cl, self.z_inf) kfunc = lambda z, r: compute_beta_s_func( - z, z_cl, self.z_inf, self.cosmo, z_src_info_beta, self._eval_convergence, r, z_cl, self.z_inf) + z, z_cl, self.z_inf, self.cosmo, z_src_info_beta, self._eval_convergence_core, r, z_cl, self.z_inf) __integrand__ = lambda z, r: pdz_func(z)*core(tfunc(z, r), kfunc(z, r)) _integ_kwargs = {'zmax': 10.0, 'delta_z_cut': 0.1} From 6335ed9933e8979065edbc5a0fa54acf5df4e20e Mon Sep 17 00:00:00 2001 From: m-aguena Date: Tue, 9 May 2023 14:15:47 +0200 Subject: [PATCH 09/38] rm compute_beta from theory.parent --- clmm/theory/parent_class.py | 284 ++++++++---------------------------- 1 file changed, 61 insertions(+), 223 deletions(-) diff --git a/clmm/theory/parent_class.py b/clmm/theory/parent_class.py index 9557ff9e5..f2c3b32e8 100644 --- a/clmm/theory/parent_class.py +++ b/clmm/theory/parent_class.py @@ -14,14 +14,10 @@ compute_magnification_bias_from_magnification, compute_rdelta, compute_profile_mass_in_radius, convert_profile_mass_concentration) - + from ..utils import (validate_argument, _integ_pzfuncs, compute_beta_s_func, - compute_beta_s_mean_from_weights, - compute_beta_s_mean_from_distribution, - compute_beta_s_square_mean_from_weights, - compute_beta_s_square_mean_from_distribution, compute_for_good_redshifts) - + class CLMModeling: r"""Object with functions for halo mass modeling @@ -425,7 +421,7 @@ def eval_critical_surface_density_eff(self, z_len, pzbins, pzpdf, validate_input This comes from the maximum likelihood estimator for evaluating a :math:`\Delta\Sigma` profile. - For the standard :math:`\Sigma_{\rm crit}(z)` definition, use the `eval_sigma_crit` method of + For the standard :math:`\Sigma_{\rm crit}(z)` definition, use the `eval_sigma_crit` method of the CLMM cosmology object. Parameters @@ -449,7 +445,7 @@ def eval_critical_surface_density_eff(self, z_len, pzbins, pzpdf, validate_input if self.validate_input: validate_argument(locals(), 'z_len', float, argmin=0) - + def inv_sigmac(redshift): return 1./self.cosmo.eval_sigma_crit(z_len, redshift) @@ -618,132 +614,8 @@ def eval_surface_density_2h(self, r_proj, z_cl, halobias=1., logkbounds=(-5,5), logkbounds=logkbounds, ksteps=ksteps, loglbounds=loglbounds, lsteps=lsteps) - def _get_beta_s_mean(self, z_cl, z_src, z_src_info='discrete', beta_kwargs=None): - r"""Get mean value of the geometric lensing efficicency ratio from typical class function. - - Parameters - ---------- - z_cl : float - Galaxy cluster redshift - z_src : array_like, float, function - Information on the background source galaxy redshift(s). Value required depends on - `z_src_info` (see below). - z_src_info : str, optional - Type of redshift information provided by the `z_src` argument. - The following supported options are: - - * 'discrete' (default) : The redshift of sources is provided by `z_src`. - It can be individual redshifts for each source galaxy when `z_src` is an - arrayor all sources are at the same redshift when `z_src` is a float. - - * 'distribution' : A redshift distribution function is provided by `z_src`. - `z_src` must be a one dimentional function. - - * 'beta' : The averaged lensing efficiency is provided by `z_src`. - `z_src` must be a tuple containing - ( :math:`\langle \beta_s \rangle, \langle \beta_s^2 \rangle`), - the lensing efficiency and square of the lensing efficiency averaged over - the galaxy redshift distribution repectively. - - .. math:: - \langle \beta_s \rangle = \left\langle \frac{D_{LS}}{D_S}\frac{D_\infty} - {D_{L,\infty}}\right\rangle - - .. math:: - \langle \beta_s^2 \rangle = \left\langle \left(\frac{D_{LS}} - {D_S}\frac{D_\infty}{D_{L,\infty}}\right)^2 \right\rangle - - beta_kwargs: None, dict - Extra arguments for the `compute_beta_s_mean, compute_beta_s_square_mean` functions. - Only used if `z_src_info='distribution'`. Possible keys are: - - * 'zmin' (None, float) : Minimum redshift to be set as the source of the galaxy - when performing the sum. (default=None) - * 'zmax' (float) : Maximum redshift to be set as the source of the galaxy - when performing the sum. (default=10.0) - * 'delta_z_cut' (float) : Redshift cut so that `zmin` = `z_cl` + `delta_z_cut`. - `delta_z_cut` is ignored if `z_min` is already provided. (default=0.1) - - Returns - ------- - array_like, float - The averaged lensing efficiency. - """ - if z_src_info=='beta': - # z_src (tuple) is (beta_s_mean, beta_s_square_mean) - beta_s_mean = z_src[0] - elif z_src_info=='distribution': - # z_src (function) if PDZ - beta_kwargs = {} if beta_kwargs is None else beta_kwargs - beta_s_mean = compute_beta_s_mean_from_distribution( - z_cl, self.z_inf, self.cosmo, z_distrib_func=z_src, **beta_kwargs) - return beta_s_mean - - def _get_beta_s_square_mean(self, z_cl, z_src, z_src_info='discrete', - beta_kwargs=None): - r"""Get mean value of the square geometric lensing efficicency ratio from typical class - function. - - Parameters - ---------- - z_cl : float - Galaxy cluster redshift - z_src : array_like, float, function - Information on the background source galaxy redshift(s). Value required depends on - `z_src_info` (see below). - z_src_info : str, optional - Type of redshift information provided by the `z_src` argument. - The following supported options are: - - * 'discrete' (default) : The redshift of sources is provided by `z_src`. - It can be individual redshifts for each source galaxy when `z_src` is an - arrayor all sources are at the same redshift when `z_src` is a float. - - * 'distribution' : A redshift distribution function is provided by `z_src`. - `z_src` must be a one dimentional function. - - * 'beta' : The averaged lensing efficiency is provided by `z_src`. - `z_src` must be a tuple containing - ( :math:`\langle \beta_s \rangle, \langle \beta_s^2 \rangle`), - the lensing efficiency and square of the lensing efficiency averaged over - the galaxy redshift distribution repectively. - - .. math:: - \langle \beta_s \rangle = \left\langle \frac{D_{LS}}{D_S}\frac{D_\infty} - {D_{L,\infty}}\right\rangle - - .. math:: - \langle \beta_s^2 \rangle = \left\langle \left(\frac{D_{LS}} - {D_S}\frac{D_\infty}{D_{L,\infty}}\right)^2 \right\rangle - - beta_kwargs: None, dict - Extra arguments for the `compute_beta_s_mean, compute_beta_s_square_mean` functions. - Only used if `z_src_info='distribution'`. Possible keys are: - - * 'zmin' (None, float) : Minimum redshift to be set as the source of the galaxy - when performing the sum. (default=None) - * 'zmax' (float) : Maximum redshift to be set as the source of the galaxy - when performing the sum. (default=10.0) - * 'delta_z_cut' (float) : Redshift cut so that `zmin` = `z_cl` + `delta_z_cut`. - `delta_z_cut` is ignored if `z_min` is already provided. (default=0.1) - - Returns - ------- - array_like, float - The square averaged lensing efficiency. - """ - if z_src_info=='beta': - # z_src (tuple) is (beta_s_mean, beta_s_square_mean) - beta_s_square_mean = z_src[1] - elif z_src_info=='distribution': - # z_src (function) is PDZ - beta_kwargs = {} if beta_kwargs is None else beta_kwargs - beta_s_square_mean = compute_beta_s_square_mean_from_distribution( - z_cl, self.z_inf, self.cosmo, z_distrib_func=z_src, **beta_kwargs) - return beta_s_square_mean - def eval_tangential_shear(self, r_proj, z_cl, z_src, z_src_info='discrete', - beta_kwargs=None, verbose=False): + verbose=False): r"""Computes the tangential shear Parameters @@ -761,10 +633,7 @@ def eval_tangential_shear(self, r_proj, z_cl, z_src, z_src_info='discrete', * 'discrete' (default) : The redshift of sources is provided by `z_src`. It can be individual redshifts for each source galaxy when `z_src` is an - arrayor all sources are at the same redshift when `z_src` is a float. - - * 'distribution' : A redshift distribution function is provided by `z_src`. - `z_src` must be a one dimentional function. + array or all sources are at the same redshift when `z_src` is a float. * 'beta' : The averaged lensing efficiency is provided by `z_src`. `z_src` must be a tuple containing @@ -780,17 +649,6 @@ def eval_tangential_shear(self, r_proj, z_cl, z_src, z_src_info='discrete', \langle \beta_s^2 \rangle = \left\langle \left(\frac{D_{LS}} {D_S}\frac{D_\infty}{D_{L,\infty}}\right)^2 \right\rangle - beta_kwargs: None, dict - Extra arguments for the `compute_beta_s_mean, compute_beta_s_square_mean` functions. - Only used if `z_src_info='distribution'`. Possible keys are: - - * 'zmin' (None, float) : Minimum redshift to be set as the source of the galaxy - when performing the sum. (default=None) - * 'zmax' (float) : Maximum redshift to be set as the source of the galaxy - when performing the sum. (default=10.0) - * 'delta_z_cut' (float) : Redshift cut so that `zmin` = `z_cl` + `delta_z_cut`. - `delta_z_cut` is ignored if `z_min` is already provided. (default=0.1) - verbose : bool, optional If True, the Einasto slope (alpha_ein) is printed out. Only availble for the NC and CCL backends. @@ -815,10 +673,8 @@ def eval_tangential_shear(self, r_proj, z_cl, z_src, z_src_info='discrete', gammat = compute_for_good_redshifts(self._eval_tangential_shear_core, z_cl, z_src, 0., warning_msg, 'z_cl', 'z_src', r_proj) - elif z_src_info in ('distribution', 'beta'): - beta_s_mean = self._get_beta_s_mean( - z_cl, z_src, z_src_info=z_src_info, beta_kwargs=beta_kwargs) - + elif z_src_info=='beta': + beta_s_mean = z_src[0] gammat_inf = self._eval_tangential_shear_core(r_proj=r_proj, z_cl=z_cl, z_src=self.z_inf) @@ -829,7 +685,7 @@ def eval_tangential_shear(self, r_proj, z_cl, z_src, z_src_info='discrete', return gammat def eval_convergence(self, r_proj, z_cl, z_src, z_src_info='discrete', - beta_kwargs=None, verbose=False): + verbose=False): r"""Computes the mass convergence @@ -858,9 +714,6 @@ def eval_convergence(self, r_proj, z_cl, z_src, z_src_info='discrete', It can be individual redshifts for each source galaxy when `z_src` is an array or all sources are at the same redshift when `z_src` is a float. - * 'distribution' : A redshift distribution function is provided by `z_src`. - `z_src` must be a one dimentional function. - * 'beta' : The averaged lensing efficiency is provided by `z_src`. `z_src` must be a tuple containing ( :math:`\langle \beta_s \rangle, \langle \beta_s^2 \rangle`), @@ -875,17 +728,6 @@ def eval_convergence(self, r_proj, z_cl, z_src, z_src_info='discrete', \langle \beta_s^2 \rangle = \left\langle \left(\frac{D_{LS}} {D_S}\frac{D_\infty}{D_{L,\infty}}\right)^2 \right\rangle - beta_kwargs: None, dict - Extra arguments for the `compute_beta_s_mean, compute_beta_s_square_mean` functions. - Only used if `z_src_info='distribution'`. Possible keys are: - - * 'zmin' (None, float) : Minimum redshift to be set as the source of the galaxy - when performing the sum. (default=None) - * 'zmax' (float) : Maximum redshift to be set as the source of the galaxy - when performing the sum. (default=10.0) - * 'delta_z_cut' (float) : Redshift cut so that `zmin` = `z_cl` + `delta_z_cut`. - `delta_z_cut` is ignored if `z_min` is already provided. (default=0.1) - verbose : bool, optional If True, the Einasto slope (alpha_ein) is printed out. Only availble for the NC and CCL backends. @@ -910,9 +752,8 @@ def eval_convergence(self, r_proj, z_cl, z_src, z_src_info='discrete', kappa = compute_for_good_redshifts(self._eval_convergence_core, z_cl, z_src, 0., warning_msg, 'z_cl', 'z_src', r_proj) - elif z_src_info in ('distribution', 'beta'): - beta_s_mean = self._get_beta_s_mean( - z_cl, z_src, z_src_info=z_src_info, beta_kwargs=beta_kwargs) + elif z_src_info=='beta': + beta_s_mean = z_src[0] kappa_inf = self._eval_convergence_core(r_proj=r_proj, z_cl=z_cl, z_src=self.z_inf) @@ -968,7 +809,7 @@ def _pdz_weighted_avg(self, core, pdz_func, r_proj, z_cl, integ_kwargs=None): return out/quad(pdz_func, zmin, zmax)[0] def eval_reduced_tangential_shear(self, r_proj, z_cl, z_src, z_src_info='discrete', - approx=None, beta_kwargs=None, verbose=False): + approx=None, integ_kwargs=None, verbose=False): r"""Computes the reduced tangential shear .. math:: @@ -989,10 +830,11 @@ def eval_reduced_tangential_shear(self, r_proj, z_cl, z_src, z_src_info='discret * 'discrete' (default) : The redshift of sources is provided by `z_src`. It can be individual redshifts for each source galaxy when `z_src` is an - array or all sources are at the same redshift when `z_src` is a float. + array or all sources are at the same redshift when `z_src` is a float + (Used for `approx=None`). * 'distribution' : A redshift distribution function is provided by `z_src`. - `z_src` must be a one dimentional function. + `z_src` must be a one dimentional function (Used when `approx=None`). * 'beta' : The averaged lensing efficiency is provided by `z_src`. `z_src` must be a tuple containing @@ -1025,8 +867,7 @@ def eval_reduced_tangential_shear(self, r_proj, z_cl, z_src, z_src_info='discret * 'order1' : Same approach as in Weighing the Giants - III (equation 6 in Applegate et al. 2014; https://arxiv.org/abs/1208.0605). `z_src_info` must be - either 'beta', or 'distribution' (that will be used to compute - :math:`\langle \beta_s \rangle`) + 'beta': .. math:: g_t\approx\frac{\left<\beta_s\right>\gamma_{\infty}} @@ -1035,8 +876,7 @@ def eval_reduced_tangential_shear(self, r_proj, z_cl, z_src, z_src_info='discret * 'order2' : Same approach as in Cluster Mass Calibration at High Redshift (equation 12 in Schrabback et al. 2017; https://arxiv.org/abs/1611.03866). - `z_src_info` must be either 'beta', or 'distribution' (that will be used - to compute :math:`\langle \beta_s \rangle, \langle \beta_s^2 \rangle`) + `z_src_info` must be 'beta': .. math:: g_t\approx\frac{\left<\beta_s\right>\gamma_{\infty}} @@ -1044,9 +884,9 @@ def eval_reduced_tangential_shear(self, r_proj, z_cl, z_src, z_src_info='discret \left(1+\left(\frac{\left<\beta_s^2\right>} {\left<\beta_s\right>^2}-1\right)\left<\beta_s\right>\kappa_{\infty}\right) - beta_kwargs: None, dict - Extra arguments for the `compute_beta_s_mean, compute_beta_s_square_mean` functions. - Only used if `z_src_info='distribution'`. Possible keys are: + integ_kwargs: None, dict + Extra arguments for the when `approx=None, z_src_info='distribution'`. + Possible keys are: * 'zmin' (None, float) : Minimum redshift to be set as the source of the galaxy when performing the sum. (default=None) @@ -1082,7 +922,7 @@ def eval_reduced_tangential_shear(self, r_proj, z_cl, z_src, z_src_info='discret if z_src_info=='distribution': core = lambda gammat, kappa: gammat/(1-kappa) gt = self._pdz_weighted_avg(core, z_src, r_proj, z_cl, - integ_kwargs=beta_kwargs) + integ_kwargs=integ_kwargs) elif z_src_info=='discrete': warning_msg = '\nSome source redshifts are lower than the cluster redshift.'+\ '\nReduced_shear = 0 for those galaxies.' @@ -1095,8 +935,9 @@ def eval_reduced_tangential_shear(self, r_proj, z_cl, z_src, z_src_info='discret f"z_src_info='{z_src_info}' was provided.") elif approx in ('order1', 'order2'): - beta_s_mean = self._get_beta_s_mean( - z_cl, z_src, z_src_info=z_src_info, beta_kwargs=beta_kwargs) + if z_src_info !='beta': + raise ValueError('z_src_info must be beta if approx!=None.') + beta_s_mean = z_src[0] gammat_inf = self._eval_tangential_shear_core(r_proj, z_cl, z_src=self.z_inf) kappa_inf = self._eval_convergence_core(r_proj, z_cl, z_src=self.z_inf) @@ -1104,8 +945,7 @@ def eval_reduced_tangential_shear(self, r_proj, z_cl, z_src, z_src_info='discret gt = beta_s_mean * gammat_inf / (1. - beta_s_mean * kappa_inf) if approx == 'order2': - beta_s_square_mean = self._get_beta_s_square_mean( - z_cl, z_src, z_src_info=z_src_info, beta_kwargs=beta_kwargs) + beta_s_square_mean = z_src[1] gt *= (1. + (beta_s_square_mean / (beta_s_mean * beta_s_mean) - 1.) \ * beta_s_mean * kappa_inf ) @@ -1115,7 +955,7 @@ def eval_reduced_tangential_shear(self, r_proj, z_cl, z_src, z_src_info='discret return gt def eval_magnification(self, r_proj, z_cl, z_src, z_src_info='discrete', - approx=None, beta_kwargs=None, verbose=False): + approx=None, integ_kwargs=None, verbose=False): r"""Computes the magnification .. math:: @@ -1136,10 +976,11 @@ def eval_magnification(self, r_proj, z_cl, z_src, z_src_info='discrete', * 'discrete' (default) : The redshift of sources is provided by `z_src`. It can be individual redshifts for each source galaxy when `z_src` is an - array or all sources are at the same redshift when `z_src` is a float. + array or all sources are at the same redshift when `z_src` is a float + (Used for `approx=None`). * 'distribution' : A redshift distribution function is provided by `z_src`. - `z_src` must be a one dimentional function. + `z_src` must be a one dimentional function (Used when `approx=None`). * 'beta' : The averaged lensing efficiency is provided by `z_src`. `z_src` must be a tuple containing @@ -1173,26 +1014,24 @@ def eval_magnification(self, r_proj, z_cl, z_src, z_src_info='discrete', {\int_{z_{min}}^{z_{max}} N(z)\text{d}z} * 'order1' : Uses the weak lensing approximation of the magnification with up to - first-order terms in :math:`\kappa_{\infty}` or :math:`\gamma_{\infty}`. - `z_src_info` must be either 'beta', or 'distribution' (that will be used to - compute :math:`\langle \beta_s \rangle`) + first-order terms in :math:`\kappa_{\infty}` or :math:`\gamma_{\infty}` + (`z_src_info` must be 'beta'): .. math:: \mu \approx 1 + 2 \left<\beta_s\right>\kappa_{\infty} * 'order2' : Uses the weak lensing approximation of the magnification with up to - second-order terms in :math:`\kappa_{\infty}` or :math:`\gamma_{\infty}`. - `z_src_info` must be either 'beta', or 'distribution' (that will be used to - compute :math:`\langle \beta_s \rangle`) + second-order terms in :math:`\kappa_{\infty}` or :math:`\gamma_{\infty}` + (`z_src_info` must be 'beta'): .. math:: \mu \approx 1 + 2 \left<\beta_s\right>\kappa_{\infty} + 3 \left<\beta_s^2\right>\kappa_{\infty}^2 + \left<\beta_s^2\right>\gamma_{\infty}^2 - beta_kwargs: None, dict - Extra arguments for the `compute_beta_s_mean, compute_beta_s_square_mean` functions. - Only used if `z_src_info='distribution'`. Possible keys are: + integ_kwargs: None, dict + Extra arguments for the when `approx=None, z_src_info='distribution'`. + Possible keys are: * 'zmin' (None, float) : Minimum redshift to be set as the source of the galaxy when performing the sum. (default=None) @@ -1225,7 +1064,7 @@ def eval_magnification(self, r_proj, z_cl, z_src, z_src_info='discrete', if z_src_info=='distribution': core = lambda gammat, kappa: 1/((1-kappa)**2-gammat**2) mu = self._pdz_weighted_avg(core, z_src, r_proj, z_cl, - integ_kwargs=beta_kwargs) + integ_kwargs=integ_kwargs) elif z_src_info=='discrete': warning_msg = '\nSome source redshifts are lower than the cluster redshift.'+\ '\nMagnification = 1 for those galaxies.' @@ -1238,8 +1077,9 @@ def eval_magnification(self, r_proj, z_cl, z_src, z_src_info='discrete', f"z_src_info='{z_src_info}' was provided.") elif approx in ('order1', 'order2'): - beta_s_mean = self._get_beta_s_mean( - z_cl, z_src, z_src_info=z_src_info, beta_kwargs=beta_kwargs) + if z_src_info !='beta': + raise ValueError('z_src_info must be beta if approx!=None.') + beta_s_mean = z_src[0] kappa_inf = self._eval_convergence_core(r_proj, z_cl, z_src=self.z_inf) gammat_inf = self._eval_tangential_shear_core(r_proj, z_cl, z_src=self.z_inf) @@ -1247,8 +1087,7 @@ def eval_magnification(self, r_proj, z_cl, z_src, z_src_info='discrete', mu = 1 + 2*beta_s_mean*kappa_inf if approx == 'order2': - beta_s_square_mean = self._get_beta_s_square_mean( - z_cl, z_src, z_src_info=z_src_info, beta_kwargs=beta_kwargs) + beta_s_square_mean = z_src[1] # Taylor expansion with up to second-order terms mu += 3*beta_s_square_mean*kappa_inf**2 + beta_s_square_mean*gammat_inf**2 @@ -1257,7 +1096,7 @@ def eval_magnification(self, r_proj, z_cl, z_src, z_src_info='discrete', return mu def eval_magnification_bias(self, r_proj, z_cl, z_src, alpha, z_src_info='discrete', - approx=None, beta_kwargs=None, verbose=False): + approx=None, integ_kwargs=None, verbose=False): r"""Computes the magnification bias .. math:: @@ -1280,10 +1119,11 @@ def eval_magnification_bias(self, r_proj, z_cl, z_src, alpha, z_src_info='discre * 'discrete' (default) : The redshift of sources is provided by `z_src`. It can be individual redshifts for each source galaxy when `z_src` is an - array or all sources are at the same redshift when `z_src` is a float. + array or all sources are at the same redshift when `z_src` is a float + (Used for `approx=None`). * 'distribution' : A redshift distribution function is provided by `z_src`. - `z_src` must be a one dimentional function. + `z_src` must be a one dimentional function (Used when `approx=None`). * 'beta' : The averaged lensing efficiency is provided by `z_src`. `z_src` must be a tuple containing @@ -1318,18 +1158,16 @@ def eval_magnification_bias(self, r_proj, z_cl, z_src, alpha, z_src_info='discre {\int_{z_{min}}^{z_{max}} N(z)\text{d}z} * 'order1' : Uses the weak lensing approximation of the magnification bias with up - to first-order terms in :math:`\kappa_{\infty}` or :math:`\gamma_{\infty}`. - `z_src_info` must be either 'beta', or 'distribution' (that will be used to - compute :math:`\langle \beta_s \rangle`) + to first-order terms in :math:`\kappa_{\infty}` or :math:`\gamma_{\infty}` + (`z_src_info` must be 'beta'): .. math:: \mu^{\alpha-1} \approx 1 + \left(\alpha-1\right)\left(2 \left<\beta_s\right>\kappa_{\infty}\right) * 'order2' : Uses the weak lensing approximation of the magnification bias with up - to second-order terms in :math:`\kappa_{\infty}` or :math:`\gamma_{\infty}`. - `z_src_info` must be either 'beta', or 'distribution' (that will be used to - compute :math:`\langle \beta_s \rangle`) + to second-order terms in :math:`\kappa_{\infty}` or :math:`\gamma_{\infty}` + (`z_src_info` must be 'beta'): .. math:: \mu^{\alpha-1} \approx @@ -1340,9 +1178,9 @@ def eval_magnification_bias(self, r_proj, z_cl, z_src, alpha, z_src_info='discre &+ \left(2\alpha-1\right)\left(\alpha-1\right) \left(\left<\beta_s^2\right>\kappa_{\infty}^2\right) - beta_kwargs: None, dict - Extra arguments for the `compute_beta_s_mean, compute_beta_s_square_mean` functions. - Only used if `z_src_info='distribution'`. Possible keys are: + integ_kwargs: None, dict + Extra arguments for the when `approx=None, z_src_info='distribution'`. + Possible keys are: * 'zmin' (None, float) : Minimum redshift to be set as the source of the galaxy when performing the sum. (default=None) @@ -1377,7 +1215,7 @@ def eval_magnification_bias(self, r_proj, z_cl, z_src, alpha, z_src_info='discre if z_src_info=='distribution': core = lambda gammat, kappa: 1/((1-kappa)**2-gammat**2)**(alpha-1) mu_bias = self._pdz_weighted_avg(core, z_src, r_proj, z_cl, - integ_kwargs=beta_kwargs) + integ_kwargs=integ_kwargs) elif z_src_info=='discrete': warning_msg = '\nSome source redshifts are lower than the cluster redshift.'+\ '\nMagnification bias = 1 for those galaxies.' @@ -1390,8 +1228,9 @@ def eval_magnification_bias(self, r_proj, z_cl, z_src, alpha, z_src_info='discre f"z_src_info='{z_src_info}' was provided.") elif approx in ('order1', 'order2'): - beta_s_mean = self._get_beta_s_mean( - z_cl, z_src, z_src_info=z_src_info, beta_kwargs=beta_kwargs) + if z_src_info !='beta': + raise ValueError('z_src_info must be beta if approx!=None.') + beta_s_mean = z_src[0] kappa_inf = self._eval_convergence_core(r_proj, z_cl, z_src=self.z_inf) gammat_inf = self._eval_tangential_shear_core(r_proj, z_cl, z_src=self.z_inf) @@ -1399,8 +1238,7 @@ def eval_magnification_bias(self, r_proj, z_cl, z_src, alpha, z_src_info='discre mu_bias = 1 + (alpha-1)*(2*beta_s_mean*kappa_inf) if approx == 'order2': - beta_s_square_mean = self._get_beta_s_square_mean( - z_cl, z_src, z_src_info=z_src_info, beta_kwargs=beta_kwargs) + beta_s_square_mean = z_src[1] # Taylor expansion with up to second-order terms mu_bias += (alpha-1)*(beta_s_square_mean*gammat_inf**2)\ +(2*alpha-1)*(alpha-1)*beta_s_square_mean*kappa_inf**2 @@ -1542,11 +1380,11 @@ def _validate_z_src(self, loc_dict): validate_argument(loc_dict, 'z_src', 'float_array', argmin=0) elif loc_dict['z_src_info']=='distribution': validate_argument(loc_dict, 'z_src', 'function', none_ok=False) - beta_kwargs = {} if loc_dict['beta_kwargs'] is None else loc_dict['beta_kwargs'] + integ_kwargs = {} if loc_dict['integ_kwargs'] is None else loc_dict['integ_kwargs'] _def_keys = ['zmin', 'zmax', 'delta_z_cut'] - if any(key not in _def_keys for key in beta_kwargs): - raise KeyError(f'beta_kwargs must contain only {_def_keys} keys, ' - f' {beta_kwargs.keys()} provided.') + if any(key not in _def_keys for key in integ_kwargs): + raise KeyError(f'integ_kwargs must contain only {_def_keys} keys, ' + f' {integ_kwargs.keys()} provided.') elif loc_dict['z_src_info']=='beta': validate_argument(loc_dict, 'z_src', 'array') beta_info = {'beta_s_mean':loc_dict['z_src'][0], From 744a8ae1834483e93727c45b8d984349e2e1aa4f Mon Sep 17 00:00:00 2001 From: m-aguena Date: Tue, 9 May 2023 21:03:28 +0200 Subject: [PATCH 10/38] revert beta functions --- clmm/theory/parent_class.py | 5 ++--- clmm/utils.py | 35 +++++++---------------------------- 2 files changed, 9 insertions(+), 31 deletions(-) diff --git a/clmm/theory/parent_class.py b/clmm/theory/parent_class.py index f2c3b32e8..eb03aa887 100644 --- a/clmm/theory/parent_class.py +++ b/clmm/theory/parent_class.py @@ -791,11 +791,10 @@ def _pdz_weighted_avg(self, core, pdz_func, r_proj, z_cl, integ_kwargs=None): array_like Function averaged by pdz, with r_proj dimention. """ - z_src_info_beta = 'discrete' tfunc = lambda z, r: compute_beta_s_func( - z, z_cl, self.z_inf, self.cosmo, z_src_info_beta, self._eval_tangential_shear_core, r, z_cl, self.z_inf) + z, z_cl, self.z_inf, self.cosmo, self._eval_tangential_shear, r, z_cl, self.z_inf) kfunc = lambda z, r: compute_beta_s_func( - z, z_cl, self.z_inf, self.cosmo, z_src_info_beta, self._eval_convergence_core, r, z_cl, self.z_inf) + z, z_cl, self.z_inf, self.cosmo, self._eval_convergence, r, z_cl, self.z_inf) __integrand__ = lambda z, r: pdz_func(z)*core(tfunc(z, r), kfunc(z, r)) _integ_kwargs = {'zmax': 10.0, 'delta_z_cut': 0.1} diff --git a/clmm/utils.py b/clmm/utils.py index d8abff840..63b0f0b57 100644 --- a/clmm/utils.py +++ b/clmm/utils.py @@ -686,7 +686,7 @@ def compute_for_good_redshifts(function, z1, z2, bad_value, warning_message, res = function(**kwargs) return res -def compute_beta(z_src, z_cl, cosmo, z_src_info='discrete'): +def compute_beta(z_src, z_cl, cosmo): r"""Geometric lensing efficicency .. math:: @@ -696,20 +696,13 @@ def compute_beta(z_src, z_cl, cosmo, z_src_info='discrete'): Parameters ---------- - z_src : array_like, float, function - Information on the background source galaxy redshift(s). Value required depends on - `z_src_info` (see below). + z_src : float, array_like + Source galaxy redshift z_cl: float Galaxy cluster redshift cosmo: clmm.Cosmology CLMM Cosmology object - z_src_info : str, optional - Type of redshift information provided by the `z_src` argument. - In this function, the only supported option is: - * 'discrete' (default) : The redshift of sources is provided by `z_src`. - It can be individual redshifts for each source galaxy when `z_src` is an - array or all sources are at the same redshift when `z_src` is a float. Returns ------- numpy array @@ -722,7 +715,7 @@ def compute_beta(z_src, z_cl, cosmo, z_src_info='discrete'): beta = [np.heaviside(z_src_i-z_cl, 0) * cosmo.eval_da_z1z2(z_cl, z_src_i) / cosmo.eval_da(z_src_i) for z_src_i in z_src] return np.array(beta) -def compute_beta_s(z_src, z_cl, z_inf, cosmo, z_src_info='discrete'): +def compute_beta_s(z_src, z_cl, z_inf, cosmo): r"""Geometric lensing efficicency ratio .. math:: @@ -730,22 +723,15 @@ def compute_beta_s(z_src, z_cl, z_inf, cosmo, z_src_info='discrete'): Parameters ---------- - z_src : array_like, float, function - Information on the background source galaxy redshift(s). Value required depends on - `z_src_info` (see below). + z_src : float, array_like + Source galaxy redshift z_cl: float Galaxy cluster redshift z_inf: float Redshift at infinity cosmo: clmm.Cosmology CLMM Cosmology object - z_src_info : str, optional - Type of redshift information provided by the `z_src` argument. - In this function, the only supported option is: - * 'discrete' (default) : The redshift of sources is provided by `z_src`. - It can be individual redshifts for each source galaxy when `z_src` is an - array or all sources are at the same redshift when `z_src` is a float. Returns ------- numpy array @@ -754,7 +740,7 @@ def compute_beta_s(z_src, z_cl, z_inf, cosmo, z_src_info='discrete'): beta_s = compute_beta(z_src, z_cl, cosmo) / compute_beta(z_inf, z_cl, cosmo) return beta_s -def compute_beta_s_func(z_src, z_cl, z_inf, cosmo, z_src_info, func, *args, **kwargs): +def compute_beta_s_func(z_src, z_cl, z_inf, cosmo, func, *args, **kwargs): r"""Geometric lensing efficicency ratio times a value of a function .. math:: @@ -774,13 +760,6 @@ def compute_beta_s_func(z_src, z_cl, z_inf, cosmo, z_src_info, func, *args, **kw CLMM Cosmology object func: callable A scalar function - z_src_info : str, optional - Type of redshift information provided by the `z_src` argument. - In this function, the only supported option is: - - * 'discrete' (default) : The redshift of sources is provided by `z_src`. - It can be individual redshifts for each source galaxy when `z_src` is an - array or all sources are at the same redshift when `z_src` is a float. *args: positional arguments args to be passed to `func` **kwargs: keyword arguments From 88765f38cf200a136e91d6d9dfe1f143b64a1d5c Mon Sep 17 00:00:00 2001 From: m-aguena Date: Tue, 9 May 2023 21:13:42 +0200 Subject: [PATCH 11/38] improve compute_beta --- clmm/utils.py | 38 +++++++++++++++++++++++++++++++------- 1 file changed, 31 insertions(+), 7 deletions(-) diff --git a/clmm/utils.py b/clmm/utils.py index 63b0f0b57..f9bc8e311 100644 --- a/clmm/utils.py +++ b/clmm/utils.py @@ -686,6 +686,30 @@ def compute_for_good_redshifts(function, z1, z2, bad_value, warning_message, res = function(**kwargs) return res +def _compute_beta(z_src, z_cl, cosmo): + r"""Geometric lensing efficicency + + .. math:: + \beta = max(0, D_{a,\ ls}/D_{a,\ s}) + + Eq.2 in https://arxiv.org/pdf/1611.03866.pdf + + Parameters + ---------- + z_src : float + Source galaxy redshift + z_cl: float + Galaxy cluster redshift + cosmo: clmm.Cosmology + CLMM Cosmology object + + Returns + ------- + float + Geometric lensing efficicency + """ + return np.heaviside(z_src-z_cl, 0) * cosmo.eval_da_z1z2(z_cl, z_src) / cosmo.eval_da(z_src) + def compute_beta(z_src, z_cl, cosmo): r"""Geometric lensing efficicency @@ -705,15 +729,15 @@ def compute_beta(z_src, z_cl, cosmo): Returns ------- - numpy array + float, array Geometric lensing efficicency """ - try: - len(z_src) - except TypeError: - z_src = [z_src] - beta = [np.heaviside(z_src_i-z_cl, 0) * cosmo.eval_da_z1z2(z_cl, z_src_i) / cosmo.eval_da(z_src_i) for z_src_i in z_src] - return np.array(beta) + if hasattr(z_src, '__len__'): + return np.array([ + _compute_beta(z_src_i, z_cl, cosmo) + for z_src_i in z_src]) + else: + return _compute_beta(z_src, z_cl, cosmo) def compute_beta_s(z_src, z_cl, z_inf, cosmo): r"""Geometric lensing efficicency ratio From d1aa4633d14c805e90942c1259affefe81c7f37a Mon Sep 17 00:00:00 2001 From: m-aguena Date: Tue, 16 May 2023 12:15:11 +0200 Subject: [PATCH 12/38] update changes --- clmm/theory/func_layer.py | 103 ++++++++++---------- clmm/utils/__init__.py | 7 +- clmm/utils/beta_lens.py | 197 +++++++++++++++++++++++++++----------- 3 files changed, 197 insertions(+), 110 deletions(-) diff --git a/clmm/theory/func_layer.py b/clmm/theory/func_layer.py index c3695453b..9b91f7776 100644 --- a/clmm/theory/func_layer.py +++ b/clmm/theory/func_layer.py @@ -532,7 +532,7 @@ def compute_tangential_shear( massdef="mean", alpha_ein=None, z_src_info="discrete", - beta_kwargs=None, + integ_kwargs=None, verbose=False, validate_input=True, ): @@ -588,10 +588,11 @@ def compute_tangential_shear( * 'discrete' (default) : The redshift of sources is provided by `z_source`. It can be individual redshifts for each source galaxy when `z_source` is an array - or all sources are at the same redshift when `z_source` is a float. + or all sources are at the same redshift when `z_source` is a float + (Used for `approx=None`). * 'distribution' : A redshift distribution function is provided by `z_source`. - `z_source` must be a one dimensional function. + `z_source` must be a one dimensional function (Used when `approx=None`). * 'beta' : The averaged lensing efficiency is provided by `z_source`. `z_source` must be a tuple containing @@ -607,9 +608,9 @@ def compute_tangential_shear( \langle \beta_s^2 \rangle = \left\langle \left(\frac{D_{LS}} {D_S}\frac{D_\infty}{D_{L,\infty}}\right)^2 \right\rangle - beta_kwargs: None, dict - Extra arguments for the `compute_beta_s_mean, compute_beta_s_square_mean` functions. - Only used if `z_src_info='distribution'`. Possible keys are: + integ_kwargs: None, dict + Extra arguments for the redshift integration (when + `approx=None, z_src_info='distribution'`). Possible keys are: * 'zmin' (None, float) : Minimum redshift to be set as the source of the galaxy when performing the sum. (default=None) @@ -650,7 +651,7 @@ def compute_tangential_shear( z_cluster, z_source, z_src_info=z_src_info, - beta_kwargs=beta_kwargs, + integ_kwargs=integ_kwargs, verbose=verbose, ) @@ -670,7 +671,7 @@ def compute_convergence( massdef="mean", alpha_ein=None, z_src_info="discrete", - beta_kwargs=None, + integ_kwargs=None, verbose=False, validate_input=True, ): @@ -726,10 +727,11 @@ def compute_convergence( * 'discrete' (default) : The redshift of sources is provided by `z_source`. It can be individual redshifts for each source galaxy when `z_source` is an array - or all sources are at the same redshift when `z_source` is a float. + or all sources are at the same redshift when `z_source` is a float + (Used for `approx=None`). * 'distribution' : A redshift distribution function is provided by `z_source`. - `z_source` must be a one dimensional function. + `z_source` must be a one dimensional function (Used when `approx=None`). * 'beta' : The averaged lensing efficiency is provided by `z_source`. `z_source` must be a tuple containing @@ -745,9 +747,9 @@ def compute_convergence( \langle \beta_s^2 \rangle = \left\langle \left(\frac{D_{LS}} {D_S}\frac{D_\infty}{D_{L,\infty}}\right)^2 \right\rangle - beta_kwargs: None, dict - Extra arguments for the `compute_beta_s_mean, compute_beta_s_square_mean` functions. - Only used if `z_src_info='distribution'`. Possible keys are: + integ_kwargs: None, dict + Extra arguments for the redshift integration (when + `approx=None, z_src_info='distribution'`). Possible keys are: * 'zmin' (None, float) : Minimum redshift to be set as the source of the galaxy when performing the sum. (default=None) @@ -784,7 +786,7 @@ def compute_convergence( z_cluster, z_source, z_src_info=z_src_info, - beta_kwargs=beta_kwargs, + integ_kwargs=integ_kwargs, verbose=verbose, ) @@ -804,7 +806,7 @@ def compute_reduced_tangential_shear( massdef="mean", z_src_info="discrete", approx=None, - beta_kwargs=None, + integ_kwargs=None, alpha_ein=None, validate_input=True, verbose=False, @@ -856,10 +858,11 @@ def compute_reduced_tangential_shear( * 'discrete' (default) : The redshift of sources is provided by `z_source`. It can be individual redshifts for each source galaxy when `z_source` is an array - or all sources are at the same redshift when `z_source` is a float. + or all sources are at the same redshift when `z_source` is a float + (Used for `approx=None`). * 'distribution' : A redshift distribution function is provided by `z_source`. - `z_source` must be a one dimensional function. + `z_source` must be a one dimensional function (Used when `approx=None`). * 'beta' : The averaged lensing efficiency is provided by `z_source`. `z_source` must be a tuple containing @@ -891,9 +894,8 @@ def compute_reduced_tangential_shear( {\int_{z_{min}}^{z_{max}} N(z)\text{d}z} * 'order1' : Same approach as in Weighing the Giants - III (equation 6 in - Applegate et al. 2014; https://arxiv.org/abs/1208.0605). `z_src_info` must be - either 'beta', or 'distribution' (that will be used to compute - :math:`\langle \beta_s \rangle`) + Applegate et al. 2014; https://arxiv.org/abs/1208.0605). + `z_src_info` must be 'beta': .. math:: g_t\approx\frac{\left<\beta_s\right>\gamma_{\infty}} @@ -902,8 +904,7 @@ def compute_reduced_tangential_shear( * 'order2' : Same approach as in Cluster Mass Calibration at High Redshift (equation 12 in Schrabback et al. 2017; https://arxiv.org/abs/1611.03866). - `z_src_info` must be either 'beta', or 'distribution' (that will be used - to compute :math:`\langle \beta_s \rangle` and :math:`\langle \beta_s^2 \rangle`) + `z_src_info` must be 'beta': .. math:: g_t\approx\frac{\left<\beta_s\right>\gamma_{\infty}} @@ -911,9 +912,9 @@ def compute_reduced_tangential_shear( \left(1+\left(\frac{\left<\beta_s^2\right>} {\left<\beta_s\right>^2}-1\right)\left<\beta_s\right>\kappa_{\infty}\right) - beta_kwargs: None, dict - Extra arguments for the `compute_beta_s_mean, compute_beta_s_square_mean` functions. - Only used if `z_src_info='distribution'`. Possible keys are: + integ_kwargs: None, dict + Extra arguments for the redshift integration (when + `approx=None, z_src_info='distribution'`). Possible keys are: * 'zmin' (None, float) : Minimum redshift to be set as the source of the galaxy when performing the sum. (default=None) @@ -955,7 +956,7 @@ def compute_reduced_tangential_shear( z_source, z_src_info=z_src_info, approx=approx, - beta_kwargs=beta_kwargs, + integ_kwargs=integ_kwargs, verbose=verbose, ) @@ -976,7 +977,7 @@ def compute_magnification( alpha_ein=None, z_src_info="discrete", approx=None, - beta_kwargs=None, + integ_kwargs=None, verbose=False, validate_input=True, ): @@ -1027,10 +1028,11 @@ def compute_magnification( * 'discrete' (default) : The redshift of sources is provided by `z_source`. It can be individual redshifts for each source galaxy when `z_source` is an array - or all sources are at the same redshift when `z_source` is a float. + or all sources are at the same redshift when `z_source` is a float + (Used for `approx=None`). * 'distribution' : A redshift distribution function is provided by `z_source`. - `z_source` must be a one dimensional function. + `z_source` must be a one dimensional function (Used when `approx=None`). * 'beta' : The averaged lensing efficiency is provided by `z_source`. `z_source` must be a tuple containing @@ -1064,26 +1066,24 @@ def compute_magnification( {\int_{z_{min}}^{z_{max}} N(z)\text{d}z} * 'order1' : Uses the weak lensing approximation of the magnification with up to - first-order terms in :math:`\kappa_{\infty}` or :math:`\gamma_{\infty}`. - `z_src_info` must be either 'beta', or 'distribution' (that will be used to - compute :math:`\langle \beta_s \rangle`) + first-order terms in :math:`\kappa_{\infty}` or :math:`\gamma_{\infty}` + (`z_src_info` must be 'beta'): .. math:: \mu \approx 1 + 2 \left<\beta_s\right>\kappa_{\infty} * 'order2' : Uses the weak lensing approximation of the magnification with up to - second-order terms in :math:`\kappa_{\infty}` or :math:`\gamma_{\infty}`. - `z_src_info` must be either 'beta', or 'distribution' (that will be used to - compute :math:`\langle \beta_s \rangle` and :math:`\langle \beta_s^2 \rangle`) + second-order terms in :math:`\kappa_{\infty}` or :math:`\gamma_{\infty}` + (`z_src_info` must be 'beta'): .. math:: \mu \approx 1 + 2 \left<\beta_s\right>\kappa_{\infty} + 3 \left<\beta_s^2\right>\kappa_{\infty}^2 + \left<\beta_s^2\right>\gamma_{\infty}^2 - beta_kwargs: None, dict - Extra arguments for the `compute_beta_s_mean, compute_beta_s_square_mean` functions. - Only used if `z_src_info='distribution'`. Possible keys are: + integ_kwargs: None, dict + Extra arguments for the redshift integration (when + `approx=None, z_src_info='distribution'`). Possible keys are: * 'zmin' (None, float) : Minimum redshift to be set as the source of the galaxy when performing the sum. (default=None) @@ -1121,7 +1121,7 @@ def compute_magnification( z_source, z_src_info=z_src_info, approx=approx, - beta_kwargs=beta_kwargs, + integ_kwargs=integ_kwargs, verbose=verbose, ) @@ -1143,7 +1143,7 @@ def compute_magnification_bias( alpha_ein=None, z_src_info="discrete", approx=None, - beta_kwargs=None, + integ_kwargs=None, verbose=False, validate_input=True, ): @@ -1210,10 +1210,11 @@ def compute_magnification_bias( * 'discrete' (default) : The redshift of sources is provided by `z_source`. It can be individual redshifts for each source galaxy when `z_source` is an array - or all sources are at the same redshift when `z_source` is a float. + or all sources are at the same redshift when `z_source` is a float + (Used for `approx=None`). * 'distribution' : A redshift distribution function is provided by `z_source`. - `z_source` must be a one dimensional function. + `z_source` must be a one dimensional function (Used when `approx=None`). * 'beta' : The averaged lensing efficiency is provided by `z_source`. `z_source` must be a tuple containing @@ -1248,18 +1249,16 @@ def compute_magnification_bias( {\int_{z_{min}}^{z_{max}} N(z)\text{d}z} * 'order1' : Uses the weak lensing approximation of the magnification bias with up - to first-order terms in :math:`\kappa_{\infty}` or :math:`\gamma_{\infty}`. - `z_src_info` must be either 'beta', or 'distribution' (that will be used to - compute :math:`\langle \beta_s \rangle`) + to first-order terms in :math:`\kappa_{\infty}` or :math:`\gamma_{\infty}` + (`z_src_info` must be 'beta'): .. math:: \mu^{\alpha-1} \approx 1 + \left(\alpha-1\right)\left(2 \left<\beta_s\right>\kappa_{\infty}\right) * 'order2' : Uses the weak lensing approximation of the magnification bias with up - to second-order terms in :math:`\kappa_{\infty}` or :math:`\gamma_{\infty}`. - `z_src_info` must be either 'beta', or 'distribution' (that will be used to - compute :math:`\langle \beta_s \rangle` and :math:`\langle \beta_s^2 \rangle`) + to second-order terms in :math:`\kappa_{\infty}` or :math:`\gamma_{\infty}` + `z_src_info` must be 'beta': .. math:: \mu^{\alpha-1} \approx @@ -1270,9 +1269,9 @@ def compute_magnification_bias( &+ \left(2\alpha-1\right)\left(\alpha-1\right) \left(\left<\beta_s^2\right>\kappa_{\infty}^2\right) - beta_kwargs: None, dict - Extra arguments for the `compute_beta_s_mean, compute_beta_s_square_mean` functions. - Only used if `z_src_info='distribution'`. Possible keys are: + integ_kwargs: None, dict + Extra arguments for the redshift integration (when + `approx=None, z_src_info='distribution'`). Possible keys are: * 'zmin' (None, float) : Minimum redshift to be set as the source of the galaxy when performing the sum. (default=None) @@ -1307,7 +1306,7 @@ def compute_magnification_bias( alpha, z_src_info=z_src_info, approx=approx, - beta_kwargs=beta_kwargs, + integ_kwargs=integ_kwargs, verbose=verbose, ) diff --git a/clmm/utils/__init__.py b/clmm/utils/__init__.py index 9f8d1197c..f8b27c350 100644 --- a/clmm/utils/__init__.py +++ b/clmm/utils/__init__.py @@ -4,9 +4,10 @@ compute_beta, compute_beta_s, compute_beta_s_func, - compute_beta_mean, - compute_beta_s_mean, - compute_beta_s_square_mean, + compute_beta_s_mean_from_distribution, + compute_beta_s_square_mean_from_distribution, + compute_beta_s_mean_from_weights, + compute_beta_s_square_mean_from_weights, ) from .boost import ( diff --git a/clmm/utils/beta_lens.py b/clmm/utils/beta_lens.py index d61f1dce8..ac6b8d476 100644 --- a/clmm/utils/beta_lens.py +++ b/clmm/utils/beta_lens.py @@ -5,7 +5,7 @@ from ..redshift import distributions as zdist -def compute_beta(z_src, z_cl, cosmo): +def _compute_beta(z_src, z_cl, cosmo): r"""Geometric lensing efficicency .. math:: @@ -15,7 +15,7 @@ def compute_beta(z_src, z_cl, cosmo): Parameters ---------- - z_src: float + z_src : float Source galaxy redshift z_cl: float Galaxy cluster redshift @@ -27,8 +27,35 @@ def compute_beta(z_src, z_cl, cosmo): float Geometric lensing efficicency """ - beta = np.heaviside(z_src - z_cl, 0) * cosmo.eval_da_z1z2(z_cl, z_src) / cosmo.eval_da(z_src) - return beta + return np.heaviside(z_src - z_cl, 0) * cosmo.eval_da_z1z2(z_cl, z_src) / cosmo.eval_da(z_src) + + +def compute_beta(z_src, z_cl, cosmo): + r"""Geometric lensing efficicency + + .. math:: + \beta = max(0, D_{a,\ ls}/D_{a,\ s}) + + Eq.2 in https://arxiv.org/pdf/1611.03866.pdf + + Parameters + ---------- + z_src : float, array_like + Source galaxy redshift + z_cl: float + Galaxy cluster redshift + cosmo: clmm.Cosmology + CLMM Cosmology object + + Returns + ------- + float, array + Geometric lensing efficicency + """ + if hasattr(z_src, "__len__"): + return np.array([_compute_beta(z_src_i, z_cl, cosmo) for z_src_i in z_src]) + else: + return _compute_beta(z_src, z_cl, cosmo) def compute_beta_s(z_src, z_cl, z_inf, cosmo): @@ -39,7 +66,7 @@ def compute_beta_s(z_src, z_cl, z_inf, cosmo): Parameters ---------- - z_src: float + z_src : float, array_like Source galaxy redshift z_cl: float Galaxy cluster redshift @@ -50,7 +77,7 @@ def compute_beta_s(z_src, z_cl, z_inf, cosmo): Returns ------- - float + numpy array Geometric lensing efficicency ratio """ beta_s = compute_beta(z_src, z_cl, cosmo) / compute_beta(z_inf, z_cl, cosmo) @@ -66,8 +93,9 @@ def compute_beta_s_func(z_src, z_cl, z_inf, cosmo, func, *args, **kwargs): Parameters ---------- - z_src: float - Source galaxy redshift + z_src : array_like, float, function + Information on the background source galaxy redshift(s). Value required depends on + `z_src_info` (see below). z_cl: float Galaxy cluster redshift z_inf: float @@ -83,25 +111,29 @@ def compute_beta_s_func(z_src, z_cl, z_inf, cosmo, func, *args, **kwargs): Returns ------- - float - Geometric lensing efficicency ratio + numpy array + Geometric lensing efficicency ratio for each source """ beta_s = compute_beta(z_src, z_cl, cosmo) / compute_beta(z_inf, z_cl, cosmo) beta_s_func = beta_s * func(*args, **kwargs) return beta_s_func -def compute_beta_mean(z_cl, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, z_distrib_func=None): +def compute_beta_s_mean_from_distribution( + z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, z_distrib_func=None +): r"""Mean value of the geometric lensing efficicency .. math:: - \left<\beta\right> = \frac{\int_{z = z_{min}}^{z_{max}}\beta(z)N(z)} + \left<\beta_s\right> = \frac{\int_{z = z_{min}}^{z_{max}}\beta_s(z)N(z)} {\int_{z = z_{min}}^{z_{max}}N(z)} Parameters ---------- z_cl: float Galaxy cluster redshift + z_inf: float + Redshift at infinity cosmo: clmm.Cosmology CLMM Cosmology object zmax: float, optional @@ -124,22 +156,23 @@ def compute_beta_mean(z_cl, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, z_dist if z_distrib_func is None: z_distrib_func = zdist.chang2013 - def integrand(z_i, z_cl=z_cl, cosmo=cosmo): - return compute_beta(z_i, z_cl, cosmo) * z_distrib_func(z_i) + def integrand(z_i): + return compute_beta_s(z_i, z_cl, z_inf, cosmo) * z_distrib_func(z_i) if zmin is None: zmin = z_cl + delta_z_cut - return quad(integrand, zmin, zmax)[0] / quad(z_distrib_func, zmin, zmax)[0] + Bs_mean = quad(integrand, zmin, zmax)[0] / quad(z_distrib_func, zmin, zmax)[0] + return Bs_mean -def compute_beta_s_mean( +def compute_beta_s_square_mean_from_distribution( z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, z_distrib_func=None ): - r"""Mean value of the geometric lensing efficicency ratio + r"""Mean square value of the geometric lensing efficicency ratio .. math:: - \left<\beta_s\right> =\frac{\int_{z = z_{min}}^{z_{max}}\beta_s(z)N(z)} + \left<\beta_s^2\right> =\frac{\int_{z = z_{min}}^{z_{max}}\beta_s^2(z)N(z)} {\int_{z = z_{min}}^{z_{max}}N(z)} Parameters @@ -151,75 +184,129 @@ def compute_beta_s_mean( cosmo: clmm.Cosmology CLMM Cosmology object zmax: float - Maximum redshift to be set as the source of the galaxy when performing the sum. - Default: 10 - delta_z_cut: float, optional - Redshift interval to be summed with :math:`z_{cl}` to return :math:`z_{min}`. - This feature is not used if :math:`z_{min}` is provided by the user. Default: 0.1 + Minimum redshift to be set as the source of the galaxy\ + when performing the sum. + delta_z_cut: float + Redshift interval to be summed with $z_cl$ to return\ + $zmin$. This feature is not used if $z_min$ is provided by the user. zmin: float, None, optional Minimum redshift to be set as the source of the galaxy when performing the sum. Default: None z_distrib_func: one-parameter function, optional Redshift distribution function. Default is Chang et al (2013) distribution function. - Returns ------- float - Mean value of the geometric lensing efficicency ratio + Mean square value of the geometric lensing efficicency ratio. """ if z_distrib_func is None: z_distrib_func = zdist.chang2013 - def integrand(z_i, z_cl=z_cl, z_inf=z_inf, cosmo=cosmo): - return compute_beta_s(z_i, z_cl, z_inf, cosmo) * z_distrib_func(z_i) + def integrand(z_i): + return compute_beta_s(z_i, z_cl, z_inf, cosmo) ** 2 * z_distrib_func(z_i) if zmin is None: zmin = z_cl + delta_z_cut - return quad(integrand, zmin, zmax)[0] / quad(z_distrib_func, zmin, zmax)[0] + Bs_square_mean = quad(integrand, zmin, zmax)[0] / quad(z_distrib_func, zmin, zmax)[0] + return Bs_square_mean -def compute_beta_s_square_mean( - z_cl, z_inf, cosmo, zmax=10.0, delta_z_cut=0.1, zmin=None, z_distrib_func=None + +def compute_beta_s_mean_from_weights( + z_src, z_cl, z_inf, cosmo, shape_weights, z_src_info="discrete" ): - r"""Mean square value of the geometric lensing efficiency ratio + r"""Mean square value of the geometric lensing efficicency ratio .. math:: - \left<\beta_s^2\right> =\frac{\int_{z = z_{min}}^{z_{max}}\beta_s^2(z)N(z)} - {\int_{z = z_{min}}^{z_{max}}N(z)} + \left<\beta_s\right> =\frac{\sum_i \beta_s(z_i)w_i} + {\sum_i w_i} Parameters ---------- + z_src: float, array_like + Invididual source galaxies redshift. z_cl: float - Galaxy cluster redshift + Galaxy cluster redshift. z_inf: float - Redshift at infinity + Redshift at infinity. cosmo: clmm.Cosmology CLMM Cosmology object - zmax: float - Maximum redshift to be set as the source of the galaxy when performing the sum. - Default: 10 - delta_z_cut: float, optional - Redshift interval to be summed with :math:`z_{cl}` to return :math:`z_{min}`. - This feature is not used if :math:`z_{min}` is provided by the user. Default: 0.1 - zmin: float, None, optional - Minimum redshift to be set as the source of the galaxy when performing the sum. - Default: None - z_distrib_func: one-parameter function, optional - Redshift distribution function. Default is Chang et al (2013) distribution function. - + shape_weights: float, array_like + Individual source galaxies shape weights.\ + If not None, the function uses Eq.(13) from\ + https://arxiv.org/pdf/1611.03866.pdf with evenly distributed\ + weights summing to one. + z_src_info : str, optional + Type of redshift information provided by the `z_src` argument. + In this function, the only supported option is: + + * 'discrete' (default) : The redshift of sources is provided by `z_src`. + It can be individual redshifts for each source galaxy when `z_src` is an + array or all sources are at the same redshift when `z_src` is a float. Returns ------- float - Mean square value of the geometric lensing efficicency ratio. + Mean value of the geometric lensing efficicency ratio. """ - if z_distrib_func is None: - z_distrib_func = zdist.chang2013 + try: + if len(z_src) != len(shape_weights): + raise ValueError("The source redshifts and the weights array must be the same size.") + except TypeError: + z_src = [z_src] + shape_weights = [shape_weights] - def integrand(z_i, z_cl=z_cl, z_inf=z_inf, cosmo=cosmo): - return compute_beta_s(z_i, z_cl, z_inf, cosmo) ** 2 * z_distrib_func(z_i) + weights_sum = np.sum(shape_weights) + shape_weights = np.array(shape_weights) + Bsw = shape_weights * compute_beta_s(z_src, z_cl, z_inf, cosmo) + Bs_square_mean = np.sum(Bsw) / weights_sum + + return Bs_square_mean - if zmin is None: - zmin = z_cl + delta_z_cut - return quad(integrand, zmin, zmax)[0] / quad(z_distrib_func, zmin, zmax)[0] +def compute_beta_s_square_mean_from_weights( + z_src, z_cl, z_inf, cosmo, shape_weights, z_src_info="discrete" +): + r"""Mean square value of the geometric lensing efficicency ratio + + .. math:: + \left<\beta_s^2\right> =\frac{\sum_i \beta_s^2(z_i)w_i} + {\sum_i w_i} + + Parameters + ---------- + z_src: float, array_like + Invididual source galaxies redshift. + z_cl: float + Galaxy cluster redshift. + z_inf: float + Redshift at infinity. + cosmo: clmm.Cosmology + CLMM Cosmology object + shape_weights: float, array_like + Individual source galaxies shape weights. + z_src_info : str, optional + Type of redshift information provided by the `z_src` argument. + In this function, the only supported option is: + + * 'discrete' (default) : The redshift of sources is provided by `z_src`. + It can be individual redshifts for each source galaxy when `z_src` is an + array or all sources are at the same redshift when `z_src` is a float. + Returns + ------- + float + Mean square value of the geometric lensing efficicency ratio. + """ + try: + if len(z_src) != len(shape_weights): + raise ValueError("The source redshifts and the weights array must be the same size.") + except TypeError: + z_src = [z_src] + shape_weights = [shape_weights] + + weights_sum = np.sum(shape_weights) + shape_weights = np.array(shape_weights) + Bsw = shape_weights * np.square(compute_beta_s(z_src, z_cl, z_inf, cosmo)) + Bs_square_mean = np.sum(Bsw) / weights_sum + + return Bs_square_mean From 37d41fb18ae11c6ac65a53faa3111b12cac2da92 Mon Sep 17 00:00:00 2001 From: m-aguena Date: Tue, 16 May 2023 04:11:15 -0700 Subject: [PATCH 13/38] rm unused instances of integ_kwargs --- clmm/theory/func_layer.py | 26 -------------------------- clmm/theory/parent_class.py | 18 +++++++++--------- 2 files changed, 9 insertions(+), 35 deletions(-) diff --git a/clmm/theory/func_layer.py b/clmm/theory/func_layer.py index 9b91f7776..2df920393 100644 --- a/clmm/theory/func_layer.py +++ b/clmm/theory/func_layer.py @@ -532,7 +532,6 @@ def compute_tangential_shear( massdef="mean", alpha_ein=None, z_src_info="discrete", - integ_kwargs=None, verbose=False, validate_input=True, ): @@ -608,17 +607,6 @@ def compute_tangential_shear( \langle \beta_s^2 \rangle = \left\langle \left(\frac{D_{LS}} {D_S}\frac{D_\infty}{D_{L,\infty}}\right)^2 \right\rangle - integ_kwargs: None, dict - Extra arguments for the redshift integration (when - `approx=None, z_src_info='distribution'`). Possible keys are: - - * 'zmin' (None, float) : Minimum redshift to be set as the source of the galaxy - when performing the sum. (default=None) - * 'zmax' (float) : Maximum redshift to be set as the source of the galaxy - when performing the sum. (default=10.0) - * 'delta_z_cut' (float) : Redshift cut so that `zmin` = `z_cl` + `delta_z_cut`. - `delta_z_cut` is ignored if `z_min` is already provided. (default=0.1) - verbose : bool, optional If True, the Einasto slope (alpha_ein) is printed out. Only availble for the NC and CCL backends. @@ -651,7 +639,6 @@ def compute_tangential_shear( z_cluster, z_source, z_src_info=z_src_info, - integ_kwargs=integ_kwargs, verbose=verbose, ) @@ -671,7 +658,6 @@ def compute_convergence( massdef="mean", alpha_ein=None, z_src_info="discrete", - integ_kwargs=None, verbose=False, validate_input=True, ): @@ -747,17 +733,6 @@ def compute_convergence( \langle \beta_s^2 \rangle = \left\langle \left(\frac{D_{LS}} {D_S}\frac{D_\infty}{D_{L,\infty}}\right)^2 \right\rangle - integ_kwargs: None, dict - Extra arguments for the redshift integration (when - `approx=None, z_src_info='distribution'`). Possible keys are: - - * 'zmin' (None, float) : Minimum redshift to be set as the source of the galaxy - when performing the sum. (default=None) - * 'zmax' (float) : Maximum redshift to be set as the source of the galaxy - when performing the sum. (default=10.0) - * 'delta_z_cut' (float) : Redshift cut so that `zmin` = `z_cl` + `delta_z_cut`. - `delta_z_cut` is ignored if `z_min` is already provided. (default=0.1) - verbose : bool, optional If True, the Einasto slope (alpha_ein) is printed out. Only availble for the NC and CCL backends. @@ -786,7 +761,6 @@ def compute_convergence( z_cluster, z_source, z_src_info=z_src_info, - integ_kwargs=integ_kwargs, verbose=verbose, ) diff --git a/clmm/theory/parent_class.py b/clmm/theory/parent_class.py index f3289d85d..7fb982345 100644 --- a/clmm/theory/parent_class.py +++ b/clmm/theory/parent_class.py @@ -1055,7 +1055,7 @@ def eval_reduced_tangential_shear( else: raise ValueError( "approx=None requires z_src_info='discrete' or 'distribution'," - f"z_src_info='{z_src_info}' was provided." + f" z_src_info='{z_src_info}' was provided." ) elif approx in ("order1", "order2"): if z_src_info != "beta": @@ -1221,7 +1221,7 @@ def eval_magnification( else: raise ValueError( "approx=None requires z_src_info='discrete' or 'distribution'," - f"z_src_info='{z_src_info}' was provided." + f" z_src_info='{z_src_info}' was provided." ) elif approx in ("order1", "order2"): if z_src_info != "beta": @@ -1395,7 +1395,7 @@ def eval_magnification_bias( else: raise ValueError( "approx=None requires z_src_info='discrete' or 'distribution'," - f"z_src_info='{z_src_info}' was provided." + f" z_src_info='{z_src_info}' was provided." ) elif approx in ("order1", "order2"): @@ -1559,6 +1559,12 @@ def _validate_z_src(self, loc_dict): locals_dict: dict Should be the call locals() """ + if loc_dict.get("approx") and loc_dict["z_src_info"]!="beta": + approx, z_src_info = loc_dict["approx"], loc_dict["z_src_info"] + raise ValueError( + f"approx='{approx}' requires z_src_info='beta', " + f"z_src_info='{z_src_info}' was provided." + ) if loc_dict["z_src_info"] == "discrete": validate_argument(loc_dict, "z_src", "float_array", argmin=0) elif loc_dict["z_src_info"] == "distribution": @@ -1578,9 +1584,3 @@ def _validate_z_src(self, loc_dict): } validate_argument(beta_info, "beta_s_mean", "float_array") validate_argument(beta_info, "beta_s_square_mean", "float_array") - if loc_dict.get("approx") and loc_dict["z_src_info"] not in ("distribution", "beta"): - approx, z_src_info = loc_dict["approx"], loc_dict["z_src_info"] - raise ValueError( - f"approx='{approx}' requires z_src_info='distribution' or 'beta', " - f"z_src_info='{z_src_info}' was provided." - ) From 76a567a7cb6bd79de80966919a5c8fbe1c141c0d Mon Sep 17 00:00:00 2001 From: m-aguena Date: Tue, 16 May 2023 04:11:43 -0700 Subject: [PATCH 14/38] update tests --- tests/test_theory.py | 34 +++++++++++++++------------------- 1 file changed, 15 insertions(+), 19 deletions(-) diff --git a/tests/test_theory.py b/tests/test_theory.py index b9fe7a9fd..7b5434f9b 100644 --- a/tests/test_theory.py +++ b/tests/test_theory.py @@ -534,14 +534,21 @@ def test_shear_convergence_unittests(modeling_data, profile_init): kappa_inf = theo.compute_convergence(cosmo=cosmo, **cfg_inf["GAMMA_PARAMS"]) # test z_src = chang2013 distribution - cfg_inf["GAMMA_PARAMS"]["z_source"] = chang2013 - cfg_inf["GAMMA_PARAMS"]["z_src_info"] = "distribution" + cfg_inf["GAMMA_PARAMS"]["z_source"] = ( + compute_beta_s_mean_from_distribution( + cfg_inf['GAMMA_PARAMS']['z_cluster'], cfg_inf['GAMMA_PARAMS']['z_source'], cosmo), + compute_beta_s_square_mean_from_distribution( + cfg_inf['GAMMA_PARAMS']['z_cluster'], cfg_inf['GAMMA_PARAMS']['z_source'], cosmo), + ) + cfg_inf["GAMMA_PARAMS"]["z_src_info"] = "beta" + # store original values r_proj = cfg_inf["GAMMA_PARAMS"]["r_proj"] # use only 5 largest radii cfg_inf["GAMMA_PARAMS"]["r_proj"] = cfg_inf["GAMMA_PARAMS"]["r_proj"][-5:] # calculate some true values + cfg_inf["GAMMA_PARAMS"]["approx"] = "order1" gt = theo.compute_reduced_tangential_shear(cosmo=cosmo, **cfg_inf["GAMMA_PARAMS"]) mu = theo.compute_magnification(cosmo=cosmo, **cfg_inf["GAMMA_PARAMS"]) mu_bias = theo.compute_magnification_bias( @@ -549,6 +556,7 @@ def test_shear_convergence_unittests(modeling_data, profile_init): ) cfg_inf["GAMMA_PARAMS"]["r_proj"] = r_proj # tangential shear + cfg_inf["GAMMA_PARAMS"].pop("approx") assert_allclose( theo.compute_tangential_shear(cosmo=cosmo, **cfg_inf["GAMMA_PARAMS"]), beta_s_mean * gammat_inf, @@ -588,7 +596,7 @@ def test_shear_convergence_unittests(modeling_data, profile_init): assert_allclose( theo.compute_reduced_tangential_shear(cosmo=cosmo, **cfg_inf["GAMMA_PARAMS"])[-5:], gt, - 2.0e-6, + 3.0e-6, ) # magnification @@ -611,7 +619,7 @@ def test_shear_convergence_unittests(modeling_data, profile_init): 1.0e-10, ) assert_allclose( - theo.compute_magnification(cosmo=cosmo, **cfg_inf["GAMMA_PARAMS"])[-5:], mu, 1.0e-10 + theo.compute_magnification(cosmo=cosmo, **cfg_inf["GAMMA_PARAMS"])[-5:], mu, 2.0e-8 ) # magnification bias @@ -641,7 +649,7 @@ def test_shear_convergence_unittests(modeling_data, profile_init): -5: ], mu_bias, - 1.0e-10, + 4.0e-8, ) # test errors and also prepare for the next round of tests @@ -670,20 +678,8 @@ def test_shear_convergence_unittests(modeling_data, profile_init): approx="notvalid" ) # test KeyError from invalid key in integ_kwargs - assert_raises( - KeyError, - theo.compute_tangential_shear, - cosmo=cosmo, - **cfg_inf["GAMMA_PARAMS"], - integ_kwargs={"notavalidkey": 0.0} - ) - assert_raises( - KeyError, - theo.compute_convergence, - cosmo=cosmo, - **cfg_inf["GAMMA_PARAMS"], - integ_kwargs={"notavalidkey": 0.0} - ) + cfg_inf["GAMMA_PARAMS"]["z_src_info"] = "distribution" + cfg_inf["GAMMA_PARAMS"]["z_source"] = chang2013 assert_raises( KeyError, theo.compute_reduced_tangential_shear, From 9c1ea828f164aff5fe3d89b550b7f90efb8c7cf3 Mon Sep 17 00:00:00 2001 From: m-aguena Date: Tue, 16 May 2023 04:22:10 -0700 Subject: [PATCH 15/38] pylint beta_lens.py --- clmm/__init__.py | 2 +- clmm/theory/parent_class.py | 2 +- clmm/utils/beta_lens.py | 47 ++++++++++--------------------------- 3 files changed, 15 insertions(+), 36 deletions(-) diff --git a/clmm/__init__.py b/clmm/__init__.py index 6855e28e7..f558499ac 100644 --- a/clmm/__init__.py +++ b/clmm/__init__.py @@ -26,4 +26,4 @@ ) from . import support -__version__ = '1.8.0' +__version__ = "1.8.0" diff --git a/clmm/theory/parent_class.py b/clmm/theory/parent_class.py index 7fb982345..aa9e8adeb 100644 --- a/clmm/theory/parent_class.py +++ b/clmm/theory/parent_class.py @@ -1559,7 +1559,7 @@ def _validate_z_src(self, loc_dict): locals_dict: dict Should be the call locals() """ - if loc_dict.get("approx") and loc_dict["z_src_info"]!="beta": + if loc_dict.get("approx") and loc_dict["z_src_info"] != "beta": approx, z_src_info = loc_dict["approx"], loc_dict["z_src_info"] raise ValueError( f"approx='{approx}' requires z_src_info='beta', " diff --git a/clmm/utils/beta_lens.py b/clmm/utils/beta_lens.py index ac6b8d476..8447491c0 100644 --- a/clmm/utils/beta_lens.py +++ b/clmm/utils/beta_lens.py @@ -54,8 +54,7 @@ def compute_beta(z_src, z_cl, cosmo): """ if hasattr(z_src, "__len__"): return np.array([_compute_beta(z_src_i, z_cl, cosmo) for z_src_i in z_src]) - else: - return _compute_beta(z_src, z_cl, cosmo) + return _compute_beta(z_src, z_cl, cosmo) def compute_beta_s(z_src, z_cl, z_inf, cosmo): @@ -162,8 +161,7 @@ def integrand(z_i): if zmin is None: zmin = z_cl + delta_z_cut - Bs_mean = quad(integrand, zmin, zmax)[0] / quad(z_distrib_func, zmin, zmax)[0] - return Bs_mean + return quad(integrand, zmin, zmax)[0] / quad(z_distrib_func, zmin, zmax)[0] def compute_beta_s_square_mean_from_distribution( @@ -208,14 +206,10 @@ def integrand(z_i): if zmin is None: zmin = z_cl + delta_z_cut - Bs_square_mean = quad(integrand, zmin, zmax)[0] / quad(z_distrib_func, zmin, zmax)[0] + return quad(integrand, zmin, zmax)[0] / quad(z_distrib_func, zmin, zmax)[0] - return Bs_square_mean - -def compute_beta_s_mean_from_weights( - z_src, z_cl, z_inf, cosmo, shape_weights, z_src_info="discrete" -): +def compute_beta_s_mean_from_weights(z_src, z_cl, z_inf, cosmo, shape_weights): r"""Mean square value of the geometric lensing efficicency ratio .. math:: @@ -237,13 +231,7 @@ def compute_beta_s_mean_from_weights( If not None, the function uses Eq.(13) from\ https://arxiv.org/pdf/1611.03866.pdf with evenly distributed\ weights summing to one. - z_src_info : str, optional - Type of redshift information provided by the `z_src` argument. - In this function, the only supported option is: - * 'discrete' (default) : The redshift of sources is provided by `z_src`. - It can be individual redshifts for each source galaxy when `z_src` is an - array or all sources are at the same redshift when `z_src` is a float. Returns ------- float @@ -256,16 +244,17 @@ def compute_beta_s_mean_from_weights( z_src = [z_src] shape_weights = [shape_weights] - weights_sum = np.sum(shape_weights) shape_weights = np.array(shape_weights) - Bsw = shape_weights * compute_beta_s(z_src, z_cl, z_inf, cosmo) - Bs_square_mean = np.sum(Bsw) / weights_sum - - return Bs_square_mean + beta_s = compute_beta_s(z_src, z_cl, z_inf, cosmo) + return (shape_weights * beta_s).sum() / shape_weights.sum() def compute_beta_s_square_mean_from_weights( - z_src, z_cl, z_inf, cosmo, shape_weights, z_src_info="discrete" + z_src, + z_cl, + z_inf, + cosmo, + shape_weights, ): r"""Mean square value of the geometric lensing efficicency ratio @@ -285,13 +274,6 @@ def compute_beta_s_square_mean_from_weights( CLMM Cosmology object shape_weights: float, array_like Individual source galaxies shape weights. - z_src_info : str, optional - Type of redshift information provided by the `z_src` argument. - In this function, the only supported option is: - - * 'discrete' (default) : The redshift of sources is provided by `z_src`. - It can be individual redshifts for each source galaxy when `z_src` is an - array or all sources are at the same redshift when `z_src` is a float. Returns ------- float @@ -304,9 +286,6 @@ def compute_beta_s_square_mean_from_weights( z_src = [z_src] shape_weights = [shape_weights] - weights_sum = np.sum(shape_weights) shape_weights = np.array(shape_weights) - Bsw = shape_weights * np.square(compute_beta_s(z_src, z_cl, z_inf, cosmo)) - Bs_square_mean = np.sum(Bsw) / weights_sum - - return Bs_square_mean + beta_s = compute_beta_s(z_src, z_cl, z_inf, cosmo) + return (shape_weights * beta_s**2).sum() / shape_weights.sum() From c0b0f7ae491461c3d742621fa29f63b9b67e128a Mon Sep 17 00:00:00 2001 From: m-aguena Date: Tue, 16 May 2023 13:34:31 +0200 Subject: [PATCH 16/38] restore examples/demo_boost_factors.ipynb --- examples/demo_boost_factors.ipynb | 192 ++++-------------------------- 1 file changed, 22 insertions(+), 170 deletions(-) diff --git a/examples/demo_boost_factors.ipynb b/examples/demo_boost_factors.ipynb index 9742efab1..11a763a67 100644 --- a/examples/demo_boost_factors.ipynb +++ b/examples/demo_boost_factors.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "7180b199", "metadata": {}, "outputs": [], @@ -34,21 +34,10 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "389d5ab7", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'1.4.8'" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "clmm.__version__" ] @@ -63,7 +52,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "74bcb35c", "metadata": {}, "outputs": [], @@ -89,7 +78,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "6cec7b64", "metadata": {}, "outputs": [], @@ -126,7 +115,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "a564b1c9", "metadata": {}, "outputs": [], @@ -146,18 +135,10 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "bc5b051d", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/pbs/home/e/ebarroso/.local/lib/python3.11/site-packages/clmm-1.4.8-py3.11.egg/clmm/utils.py:641: UserWarning: Some source redshifts are lower than the cluster redshift. Returning Sigma_crit = np.inf for those galaxies.\n" - ] - } - ], + "outputs": [], "source": [ "_ = cl.compute_tangential_and_cross_components(\n", " geometry=\"flat\",\n", @@ -181,75 +162,10 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "eaadac01", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "GCData length=10\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
idxradius_minradiusradius_maxDeltaSigma_tanDeltaSigma_tan_errDeltaSigma_crossDeltaSigma_cross_errzz_errn_src
0115.98427.41664.302.07e+141.79e+135.36e+123.78e+120.960.0823
1664.30921.981212.621.22e+143.81e+125.37e+112.18e+121.250.1060
21212.621469.851760.957.85e+132.04e+12-7.46e+111.79e+121.360.0971
31760.952049.592309.275.78e+131.95e+12-3.03e+111.45e+121.160.06119
42309.272594.932857.594.40e+131.32e+126.37e+111.40e+121.340.07139
52857.593160.793405.923.54e+131.96e+12-1.90e+122.10e+121.220.06149
63405.923680.883954.242.75e+131.47e+12-2.41e+122.04e+121.280.06197
73954.244205.064502.562.47e+131.63e+12-9.21e+111.50e+121.330.07143
84502.564760.195050.891.76e+132.17e+12-5.49e+122.22e+121.320.1269
95050.895198.695599.211.90e+132.00e+12-4.19e+123.87e+121.490.1430
\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "cl.make_radial_profile(\n", " \"kpc\",\n", @@ -282,21 +198,10 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "0aeb2f52", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.errorbar(\n", " cl.DeltaSigma_profile[\"radius\"],\n", @@ -336,7 +241,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "e6b6ee3d", "metadata": {}, "outputs": [], @@ -358,21 +263,10 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "1c1de291", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAGwCAYAAABFFQqPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAABeX0lEQVR4nO3dd3hUVf7H8fdMMpn00ElCAoSqdASkNxtYEGygWMC66oIgtsV1F11dkd/KriCuuqyKrAriUpa1gi6hSC8BBKQm1ISeBulzf39MMmRICAQmuZPM5/U882Tm3jN3vnMF8+Hcc8+xGIZhICIiIuKDrGYXICIiImIWBSERERHxWQpCIiIi4rMUhERERMRnKQiJiIiIz1IQEhEREZ+lICQiIiI+y9/sAryZw+HgyJEjhIWFYbFYzC5HRERELoFhGGRkZBAdHY3VWnafj4JQGY4cOUJsbKzZZYiIiMhlOHjwIDExMWW2URAqQ1hYGOA8keHh4SZXIyIiIpciPT2d2NhY1+/xsigIlaHoclh4eLiCkIiISBVzKcNaNFhaREREfJaCkIiIiPgsBSERERHxWRojJCLihQoKCsjLyzO7DBGvFRAQcNFb4y+FgpCIiBcxDIOUlBRSU1PNLkXEq1mtVuLi4ggICLii4ygIiYh4kaIQVK9ePYKDgzWZq0gpiiY8Tk5OpmHDhlf090RBSETESxQUFLhCUO3atc0uR8Sr1a1blyNHjpCfn4/NZrvs42iwtIiIlygaExQcHGxyJSLer+iSWEFBwRUdR0FIRMTL6HKYyMV56u+JgpCIiIj4LAUhERER8VkKQiIiUu3Ex8djsViqzDQECxYsoFmzZvj5+TF27Fizy/EpCkJmOXMSjm43uwoREY8YOXIkFouFt956y237ggUL3MZyFAWU8x+vvPIKmZmZ2Gw2vvzyS7djDBs2DIvFwt69e922N23alJdffrnivtQVKk8Y+81vfsPdd9/NwYMHef3116/4s5OSkrBYLCQkJFzxsao7BSEz/PoN/KUJ/Oe3ZlciIuIxgYGBTJo0idOnT1+07c6dO0lOTnY9fve73xEaGkrnzp1ZsmSJW9ulS5cSGxvrtv3QoUPs27eP/v37e/x7VLbMzEyOHTvGgAEDiI6OJiwszOyS3FT3Gc4VhMwQ1cH5MzkBstPMrEREvJxhGJzNza/0h2EY5a71hhtuIDIykokTJ160bb169YiMjHQ9QkNDAejfvz/x8fGudjt27CArK4unn37abfuSJUuw2Wz07NmzzM/5+eefad++PYGBgXTt2pWtW7e67Z87dy6tW7fGbrfTuHFjJk+e7Lb/9OnTPPTQQ9SsWZPg4GBuvvlmdu/e7dq/f/9+Bg0aRM2aNQkJCaF169Z8++23JCUluUJazZo1sVgsjBw5skR98fHxruBz3XXXYbFYiI+P5+TJk9x3333ExMQQHBxM27ZtmTVrltt7HQ4HkyZNolmzZtjtdho2bMif//xnAOLi4gDo2LEjFouFfv36ud7zpz/9iZiYGOx2Ox06dOD77793HbOoJ2nOnDn069ePwMBAPvvsszLPcVWnCRXNENEAajWFU3th/0poebPZFYmIl8rKK6DVH3+o9M/d/qcBBAeU71eEn58fb775JsOHD+eZZ54hJiam3J/bv39/Jk6cSHJyMlFRUSxZsoTevXtz3XXXMW3aNFe7JUuW0LVr14vOufTCCy8wZcoUIiMjefnll7n99tvZtWsXNpuNDRs2MHToUF599VWGDRvGypUrefrpp6ldu7YrtIwcOZLdu3ezcOFCwsPDeemll7jlllvYvn07NpuN3/72t+Tm5rJs2TJCQkLYvn07oaGhxMbGMnfuXO666y527txJeHg4QUFBJerr0aMHO3fupGXLlsydO5cePXpQq1Ytjh8/TqdOnXjppZcIDw/nm2++4cEHH6RJkyZ07doVgPHjxzN9+nT+9re/0atXL5KTk/n1118BWLt2Lddeey0//vgjrVu3ds25M2XKFCZPnsyHH35Ix44d+fjjj7n99tvZtm0bzZs3d9X10ksvMXnyZD755BPsdnu5/ztWJeoRMktcH+fPxGXm1iEi4kF33HEHHTp0YMKECWW2i4mJITQ01PU4efIkAD179sRms7l6f+Lj4+nbty/XXHMNaWlprt6Y+Pj4S7osNmHCBG688Ubatm3Lp59+ytGjR5k/fz4Af/3rX7n++uv5wx/+QIsWLRg5ciSjRo3iL3/5C4ArAP3zn/+kd+/etG/fns8//5zDhw+zYMECAA4cOEDPnj1p27YtTZo04bbbbqNPnz74+flRq1Yt4FzvV0RERIn6AgICqFevHgC1atUiMjKSgIAAGjRowPPPP0+HDh1o0qQJo0ePZsCAAXz11VcAZGRkMGXKFP7v//6PESNG0LRpU3r16sVjjz0GOGddBqhduzaRkZGuWt5++21eeukl7r33Xlq2bMmkSZPo0KED77zzjltdY8eO5c477yQuLo7o6OiLnueqTD1CZonrDRs+gcTlZlciIl4syObH9j8NMOVzL9ekSZO47rrreO655y7YZvny5W5jYWrWrAk4Z9W+9tpriY+P57777mPp0qW88MIL+Pv707NnT+Lj47Hb7SQmJnLdddddtJbu3bu7nteqVYuWLVuyY8cOwHnZbfDgwW7te/bsyTvvvENBQQE7duzA39/f1QMDzmBR/BjPPPMMTz31FIsWLeKGG27grrvuol27dpdwlspWUFDAW2+9xZdffsnhw4fJyckhJyeHkJAQV+05OTlcf/31l3zM9PR0jhw5UuJyYs+ePdm8ebPbts6dO1/xd6gqFITM0ri38+fRrc47yEK0rpCIlGSxWMp9icpsffr0YcCAAbz88suljosB5xiWGjVqlLqvf//+fPnll2zbto2srCyuueYaAPr27cuSJUsICAggMDCQbt26XVZ9RXexGYZRYnbi4mOjLjROqvj7HnvsMQYMGMA333zDokWLmDhxIpMnT2b06NGXVVuRyZMn87e//Y133nmHtm3bEhISwtixY8nNzQUo9TLbpSrtO5+/rShw+QJdGjNLaD2oe7XzeZJ6hUSkennrrbf473//y8qVK8v93v79+7N7926++OILevXqhZ+fs3eqb9++xMfHEx8fT/fu3QkMDLzosVavXu16fvr0aXbt2sVVV10FQKtWrVixYoVb+5UrV9KiRQv8/Pxo1aoV+fn5rFmzxrX/5MmT7Nq1i6uvvtq1LTY2lieffJJ58+bx3HPPMX36dODK1sJavnw5gwcP5oEHHqB9+/Y0adLEbZB28+bNCQoK4qeffir1/aV9dnh4ONHR0aV+5+Lfx9coCJmpaJyQgpCIVDNt27bl/vvv59133y33e3v06IHdbufdd9+lb9++ru1dunQhLS2NuXPnXvJt83/605/46aef+OWXXxg5ciR16tRhyJAhADz33HP89NNPvP766+zatYtPP/2UadOm8fzzzwPOsDF48GAef/xxVqxYwebNm3nggQdo0KCB65La2LFj+eGHH0hMTGTjxo3873//c4WKRo0aYbFY+Prrrzl+/DiZmZmXfA6aNWvG4sWLWblyJTt27OA3v/kNKSkprv2BgYG89NJLvPjii8ycOZO9e/eyevVqPvroI8A5LikoKIjvv/+eo0ePkpbmvEP5hRdeYNKkSXz55Zfs3LmT3/3udyQkJDBmzJhLrq3aMeSC0tLSDMBIS0urmA/Y/l/DmBBuGO92rpjji0iVkpWVZWzfvt3Iysoyu5RyGzFihDF48GC3bUlJSYbdbjeK/6pZsmSJARinT58u83h9+/Y1AGP16tVu26+//noDMJYvX17m+4s+57///a/RunVrIyAgwOjSpYuRkJDg1u7f//630apVK8NmsxkNGzY0/vKXv7jtP3XqlPHggw8aERERRlBQkDFgwABj165drv2jRo0ymjZtatjtdqNu3brGgw8+aJw4ccK1/09/+pMRGRlpWCwWY8SIEaXWevr0aQMwlixZ4tp28uRJY/DgwUZoaKhRr14945VXXjEeeught3NcUFBgvPHGG0ajRo1c9b/55puu/dOnTzdiY2MNq9Vq9O3b1/We1157zWjQoIFhs9mM9u3bG999953rPYmJiQZgbNq0qczz6w3K+vtSnt/fFsO4jMkifER6ejoRERGkpaURHh7u+Q/IOg2T4gADntsJYZGe/wwRqTKys7NJTEwkLi7uki77iPiysv6+lOf3ty6NmSmoJkQV3l2gu8dEREQqnYKQ2YruHktcam4dIiIiPkhByGxxhQMBNWBaRESk0ikIma1Rd7D4wekkSD1gdjUiIiI+RUHIbPYwaOCcLEzjhERERCqXgpA30LpjIiIiplAQ8gauAdPLQLMZiIiIVBoFIW8Q2xX8AiDjCJzaZ3Y1IiIiPkNByBsEBENMF+dz3UYvIlJhRo4c6VpiozLMmDHjgovLeqN//OMfxMbGYrVaeeedd8wup1IoCHkL1zghDZgWkapn5MiRWCwWLBYLNpuNJk2a8Pzzz3PmzBmzS/N5lxrG0tPTGTVqFC+99BKHDx/miSeeuOLPjo+Px2KxkJqaesXHqigKQt6i+AKsGickIlXQwIEDSU5OZt++fbzxxhv8/e9/dy1garaCggIcDofZZXi1AwcOkJeXx6233kpUVBTBwcFml+RiGAb5+fkVcmwFIW/RoBP4B8GZ43D8V7OrEREpN7vdTmRkJLGxsQwfPpz777+fBQsWAJCTk8MzzzxDvXr1CAwMpFevXqxbt8713k6dOjF58mTX6yFDhuDv7096ejoAKSkpWCwWdu7cCUBubi4vvvgiDRo0ICQkhK5duxIfH+96f1EvyNdff02rVq2w2+3s37+/RM3ff/89vXr1okaNGtSuXZvbbruNvXv3uvbfddddjB492vV67NixWCwWtm3bBkB+fj5hYWH88MMPZZ6bBQsW0KJFCwIDA7nxxhs5ePCg2/7333+fpk2bEhAQQMuWLfnXv/7ltv/AgQMMHjyY0NBQwsPDGTp0KEePHnXt37x5M/379ycsLIzw8HA6derE+vXriY+P5+GHHyYtLc3VY/fqq6+WqG/GjBm0bdsWgCZNmmCxWEhKSmLv3r0MHjyY+vXrExoaSpcuXfjxxx/d3puTk8OLL75IbGwsdrud5s2b89FHH5GUlET//v0BqFmzJhaLhZEjR7reU9afh6KepB9++IHOnTtjt9tZvrxirpgoCHkLfzs07OZ8rtvoRaSIYUDumcp/eKBnOigoiLy8PABefPFF5s6dy6effsrGjRtp1qwZAwYM4NSpUwD069fPFWQMw2D58uXUrFmTFStWALBkyRIiIyNp2bIlAA8//DA///wzs2fPZsuWLdxzzz0MHDiQ3bt3uz7/7NmzTJw4kX/+859s27aNevXqlajxzJkzjBs3jnXr1vHTTz9htVq54447XL1HxesCWLp0KXXq1GHpUud4znXr1pGdnU3Pnj0veB7Onj3Ln//8Zz799FN+/vln0tPTuffee13758+fz5gxY3juuef45Zdf+M1vfsPDDz/MkiVLXOdjyJAhnDp1iqVLl7J48WL27t3LsGHDXMe4//77iYmJYd26dWzYsIHf/e532Gw2evTowTvvvEN4eDjJyckkJyeX2ks3bNgwV8BZu3YtycnJxMbGkpmZyS233MKPP/7Ipk2bGDBgAIMGDeLAgXMTAD/00EPMnj2bqVOnsmPHDj744ANCQ0OJjY1l7ty5AOzcuZPk5GSmTJlySX8eirz44otMnDiRHTt20K5duwue4ytS/oXvfUdaWpoBGGlpaZXzgcveNowJ4YYxa3jlfJ6IeJWsrCxj+/btRlZW1rmNOZnO/y9U9iMns1y1jxgxwhg8eLDr9Zo1a4zatWsbQ4cONTIzMw2bzWZ8/vnnrv25ublGdHS08X//93+GYRjGwoULjYiICKOgoMBISEgw6tatazz77LPGCy+8YBiGYTzxxBPGsGHDDMMwjD179hgWi8U4fPiwWw3XX3+9MX78eMMwDOOTTz4xACMhIaHMOs937NgxAzC2bt1qGIZhbNmyxbBYLMbx48eNU6dOGTabzXjjjTeMe+65xzAMw3jzzTeNrl27XvB4RXWsXr3atW3Hjh0GYKxZs8YwDMPo0aOH8fjjj7u975577jFuueUWwzAMY9GiRYafn59x4MAB1/5t27YZgLF27VrDMAwjLCzMmDFjxgVriIiIuGCNRTZt2mQARmJiYpntWrVqZbz77ruGYRjGzp07DcBYvHhxqW2XLFliAMbp06dd2y7lz0PR+xYsWHDBOkr9+1KoPL+/1SPkTVzrjq0AR4G5tYiIlNPXX39NaGgogYGBdO/enT59+vDuu++yd+9e8vLy3HpNbDYb1157LTt27ACgT58+ZGRksGnTJpYuXUrfvn3p37+/q+clPj6evn2d/4/cuHEjhmHQokULQkNDXY+lS5e6XdYKCAi4aC/C3r17GT58OE2aNCE8PJy4uDgAV49HmzZtqF27NkuXLmX58uW0b9+e22+/vdS6LsTf35/OnTu7Xl911VXUqFHD9d137NhRokepZ8+ebvtjY2OJjY117W/VqpXbMcaNG8djjz3GDTfcwFtvveV2Hq7EmTNnePHFF12fFxoayq+//uo6PwkJCfj5+V30HBR3KX8eihQ/bxXFv8I/QS5dVAcICIPsVEjZCtEdTC5IRExnC4aXj5jzueXUv39/3n//fWw2G9HR0dhsNgCSk5MBsFgsbu0Nw3Bti4iIoEOHDsTHx7Ny5Uquu+46evfuTUJCArt372bXrl3069cPAIfDgZ+fHxs2bMDPz8/tmKGhoa7nQUFBJT7zfIMGDSI2Npbp06cTHR2Nw+GgTZs25Obmumru06cP8fHxBAQE0K9fP9q0aUNBQQFbt25l5cqVjB079qLnprQ6im8r69wUf36hNq+++irDhw/nm2++4bvvvmPChAnMnj2bO+6446K1leWFF17ghx9+4O2336ZZs2YEBQVx9913u85PUFBQuY9pFF52Les7FwkJCbnMyi+deoS8iZ8/NOrhfK7V6EUEwGKBgJDKf1wkQJQmJCSEZs2a0ahRI1cIAmjWrBkBAQGu8T4AeXl5rF+/nquvvtq1rV+/fixZsoRly5bRr18/atSoQatWrXjjjTeoV6+eq23Hjh0pKCjg2LFjNGvWzO0RGRl5yfWePHmSHTt28Morr3D99ddz9dVXc/r06RLtisYJxcfH069fPywWC7179+btt98mKyurzPFB4BxQvX79etfrnTt3kpqaylVXXQXA1Vdf7XZuAFauXOn6vq1ateLAgQNuA6y3b99OWlqa2/lr0aIFzz77LIsWLeLOO+/kk08+AZw9YwUFl3eVYfny5YwcOZI77riDtm3bEhkZSVJSkmt/27ZtcTgcrh6y8wUEBAC4ff6l/nmoLApC3kbrjolINRMSEsJTTz3FCy+8wPfff8/27dt5/PHHOXv2LI8++qirXb9+/fj++++xWCy0atXKte3zzz93u/TSokUL7r//fh566CHmzZtHYmIi69atY9KkSXz77beXXFfNmjWpXbs2//jHP9izZw//+9//GDduXIl2/fr1Y9u2bWzdupXevXu71XXNNdcQHh5e5ufYbDZGjx7NmjVr2LhxIw8//DDdunXj2muvBZy9LjNmzOCDDz5g9+7d/PWvf2XevHmuQc033HAD7dq14/7772fjxo2sXbuWhx56iL59+9K5c2eysrIYNWoU8fHx7N+/n59//pl169a5QkXjxo3JzMzkp59+4sSJE5w9e/aSz1GzZs2YN28eCQkJbN68meHDh7tNQ9C4cWNGjBjBI488woIFC0hMTCQ+Pp45c+YA0KhRIywWC19//TXHjx8nMzPzkv88VJqLjiLyYZU+WNowDONIgnOg4p+jDSM/t/I+V0RMV9bgT293sUHIWVlZxujRo406deoYdrvd6Nmzp2ugb5HU1FTDz8/PuPvuu13b5s+fbwDGtGnT3Nrm5uYaf/zjH43GjRsbNpvNiIyMNO644w5jy5YthmFceIDw+XUuXrzYuPrqqw273W60a9fOiI+PNwBj/vz5rjYOh8OoW7eu0blzZ9e2ooHFzz//fJnnpaiOuXPnGk2aNDECAgKM6667zkhKSnJr9/e//91o0qSJYbPZjBYtWhgzZ850279//37j9ttvN0JCQoywsDDjnnvuMVJSUgzDMIycnBzj3nvvNWJjY42AgAAjOjraGDVqlNufoyeffNKoXbu2ARgTJkwotdbSBksnJiYa/fv3N4KCgozY2Fhj2rRpRt++fY0xY8a42mRlZRnPPvusERUVZQQEBBjNmjUzPv74Y9f+P/3pT0ZkZKRhsViMESNGuN5T1p+H0gZZn89Tg6UthqHZ+y4kPT2diIgI0tLSLpr4PcbhgP+Lc44TevRHiO1SOZ8rIqbLzs4mMTGRuLg4AgMDzS5HxKuV9felPL+/dWnM21itEFe0Gr3WHRMREalICkLeqHGx5TZERESkwigIeaOiAdMHVkN+jrm1iIiIVGMKQt6obksIqQf52XBo3cXbi4iIyGVREPJGFkuxcUK6PCbia3QPi8jFeerviYKQt9J8QiI+p2gSwvLM8yLiq4pmtz5/dvHy0hIb3qpxYY/QoXWQexYCyj/dvYhULX5+ftSoUYNjx44BEBwcfNElIkR8kcPh4Pjx4wQHB+Pvf2VRRkHIW9VqAuExkH4IDq6GpteZXZGIVIKiJSKKwpCIlM5qtdKwYcMr/seCgpC3KhontHmW8/KYgpCIT7BYLERFRVGvXj3y8vLMLkfEawUEBGC1XvkIHwUhbxbXpzAIacC0iK/x8/O74rEPInJxGiztzYrGCR3ZBNnp5tYiIiJSDSkIebMasVAzDowCOLDK7GpERESqHQUhb6fb6EVERCqMgpC3cwUhLcAqIiLiaQpC3q5onFDKL3D2lLm1iIiIVDMKQt4urD7UvQowIGmF2dWIiIhUKwpCVUFRr1CSbqMXERHxJK8IQsuWLWPQoEFER0djsVhYsGBBme3nzZvHjTfeSN26dQkPD6d79+788MMPJdrNnTuXVq1aYbfbadWqFfPnz6+gb1DBNGBaRESkQnhFEDpz5gzt27dn2rRpl9R+2bJl3HjjjXz77bds2LCB/v37M2jQIDZt2uRqs2rVKoYNG8aDDz7I5s2befDBBxk6dChr1qypqK9RcRr3Aixw/FfI1LT7IiIinmIxPLWOvYdYLBbmz5/PkCFDyvW+1q1bM2zYMP74xz8CMGzYMNLT0/nuu+9cbQYOHEjNmjWZNWtWqcfIyckhJyfH9To9PZ3Y2FjS0tIIDw8v/5fxpA96QcpWuOsjaHu3ubWIiIh4sfT0dCIiIi7p97dX9AhdKYfDQUZGBrVq1XJtW7VqFTfddJNbuwEDBrBy5coLHmfixIlERES4HrGxsRVWc7k11uUxERERT6sWQWjy5MmcOXOGoUOHuralpKRQv359t3b169cnJSXlgscZP348aWlprsfBgwcrrOZyKxonpAHTIiIiHlPlF12dNWsWr776Kv/5z3+oV6+e2z6LxeL22jCMEtuKs9vt2O32CqnzijXqARY/OLUP0g5BRIzZFYmIiFR5VbpH6Msvv+TRRx9lzpw53HDDDW77IiMjS/T+HDt2rEQvUZURGA7RHZzPtRq9iIiIR1TZIDRr1ixGjhzJF198wa233lpif/fu3Vm8eLHbtkWLFtGjR4/KKtHzdBu9iIiIR3nFpbHMzEz27Nnjep2YmEhCQgK1atWiYcOGjB8/nsOHDzNz5kzAGYIeeughpkyZQrdu3Vw9P0FBQURERAAwZswY+vTpw6RJkxg8eDD/+c9/+PHHH1mxogrPzty4N6z4mzMIGQaUcZlPRERELs4reoTWr19Px44d6dixIwDjxo2jY8eOrlvhk5OTOXDggKv9hx9+SH5+Pr/97W+JiopyPcaMGeNq06NHD2bPns0nn3xCu3btmDFjBl9++SVdu3at3C/nSQ27gdUG6YfgdKLZ1YiIiFR5XjePkDcpzzwElebjm+HAShg0BTqNNLsaERERr+Nz8wj5lLjCdcc0YFpEROSKKQhVNcUHTKszT0RE5IooCFU1MV3APxDOHIPjO82uRkREpEpTEKpq/O0QWzjgW7NMi4iIXBEFoarIdXlsqbl1iIiIVHEKQlWRa92xFeBwmFuLiIhIFaYgVBVFd4SAUMg6DUd/MbsaERGRKktBqCrys0HD7s7nWm5DRETksikIVVWuy2MaMC0iInK5FISqKlcQ+hkK8s2tRUREpIpSEKqqIttCYATkZkDyZrOrERERqZIUhKoqq59zNXrQbfQiIiKXSUGoKnMFIQ2YFhERuRwKQlVZ0TihA6shP9fcWkRERKogBaGqrN7VEFwH8rPg8HqzqxEREalyFISqMosF4oouj+k2ehERkfJSEKrqXOuOaZyQiIhIeSkIVXWNC4PQobWQl2VuLSIiIlWMglBVV7sphEVDQS4cXGN2NSIiIlWKglBV5zZOSJfHREREykNBqDpwjRPSgGkREZHyUBCqDoqC0OENkJNhbi0iIiJViIJQdVCjIdRoBEaBc3JFERERuSQKQtWF6/KY1h0TERG5VApC1YXmExIRESk3BaHqomgB1uQtkHXa3FpERESqCAWh6iI8Cuq0AAxI+tnsakRERKoEBaHqpKhXKEm30YuIiFwKBaHqROOEREREykVBqDop6hE6th0yj5tbi4iISBWgIFSdhNSG+m2cz3V5TERE5KIUhKobXR4TERG5ZApC1Y0GTIuIiFwyBaHqplEPsFjh5B5IO2x2NSIiIl5NQai6CaoBUe2dz9UrJCIiUiYFoerINU5IQUhERKQsCkLVkQZMi4iIXBIFoeoothtY/SHtAJxOMrsaERERr6UgVB3ZQ6FBZ+dz9QqJiIhckIJQdRVXeBu9gpCIiMgFKQhVV8UHTBuGubWIiIh4KQWh6irmWvCzQ2YKnNhtdjUiIiJeSUGourIFQuy1zudJujwmIiJSGgWh6iyur/OnxgmJiIiUSkGoOisaMJ20AhwOc2sRERHxQgpC1Vn0NWALgbMn4dh2s6sRERHxOgpC1Zl/ADTq7nyuy2MiIiIlKAhVd42LLo9p3TEREZHzKQhVd0XzCSX9DI4Cc2sRERHxMgpC1V1Ue7BHQE4aJG82uxoRERGvoiBU3Vn9oHFP53ONExIREXGjIOQLGmvdMRERkdIoCPmConFCB1ZDfq65tYiIiHgRBSFfUK8VBNeGvDNwZKPZ1YiIiHgNBSFfYLVC417O54m6jV5ERKSIgpCvKLo8lrjU3DpERES8iIKQr2hcGIQOroW8bHNrERER8RIKQr6iTnMIjYSCHDi01uxqREREvIKCkK+wWIpdHtNt9CIiIqAg5FviiuYT0oBpERERUBDyLUU9QofXQ06mubWIiIh4Aa8IQsuWLWPQoEFER0djsVhYsGBBme2Tk5MZPnw4LVu2xGq1Mnbs2BJtZsyYgcViKfHIzvbhgcI1G0NEQ3DkOydXFBER8XFeEYTOnDlD+/btmTZt2iW1z8nJoW7duvz+97+nffv2F2wXHh5OcnKy2yMwMNBTZVdNrtXoNU5IRETE3+wCAG6++WZuvvnmS27fuHFjpkyZAsDHH398wXYWi4XIyMgrrq9aiesDCZ9pwLSIiAhe0iNUUTIzM2nUqBExMTHcdtttbNq0qcz2OTk5pKenuz2qnaIB08mbISvV1FJERETMVm2D0FVXXcWMGTNYuHAhs2bNIjAwkJ49e7J79+4LvmfixIlERES4HrGxsZVYcSUJj4bazcBwwP6VZlcjIiJiqmobhLp168YDDzxA+/bt6d27N3PmzKFFixa8++67F3zP+PHjSUtLcz0OHjxYiRVXosZFt9Hr8piIiPi2ahuEzme1WunSpUuZPUJ2u53w8HC3R7XkGjCt+YRERMS3+UwQMgyDhIQEoqKizC7FfEU9Qkd/gTMnzK1FRETERF5x11hmZiZ79uxxvU5MTCQhIYFatWrRsGFDxo8fz+HDh5k5c6arTUJCguu9x48fJyEhgYCAAFq1agXAa6+9Rrdu3WjevDnp6elMnTqVhIQE3nvvvUr9bl4ptC7UawXHtkPSCmg9xOyKRERETOEVQWj9+vX079/f9XrcuHEAjBgxghkzZpCcnMyBAwfc3tOxY0fX8w0bNvDFF1/QqFEjkpKSAEhNTeWJJ54gJSWFiIgIOnbsyLJly7j22msr/gtVBXF9nEEocZmCkIiI+CyLYRiG2UV4q/T0dCIiIkhLS6t+44V2fA1f3g91WsCodWZXIyIi4jHl+f3tM2OE5DyNewIWOLEL0pPNrkZERMQUCkK+KqgmRBUuT6K7x0RExEcpCPmyOM0nJCIivk1ByJfF9XX+VBASEREfpSDkyxp2A4sfpO6H0/vNrkZERKTSKQj5MnsYNOjkfK5xQiIi4oMUhHydxgmJiIgPUxDydUXrjiUuB00pJSIiPkZByNfFdgW/AMg4Aif3ml2NiIhIpVIQ8nW2IIgpXHYkSZfHRETEtygISbHLYwpCIiLiWxSEpNiAaY0TEhER36IgJNCgM/gHwdkTcGyH2dWIiIhUGgUhAf8AaNTd+VyXx0RExIcoCIlT48LLY5pYUUREfIiCkDgVrTuWtBwcBebWIiIiUkkUhMQpqj0EhEF2GqRsMbsaERGRSqEgJE5+/tC4p/N5oi6PiYiIb1AQknM0n5CIiPgYBSE5p2jA9IFVUJBnbi0iIiKVQEFIzqnfBoJqQm4mHNlkdjUiIiIVTkFIzrFaoXEv5/PEpebWIiIiUgkUhMRd0W30GjAtIiI+QEFI3BUNmD64BvJzzK1FRESkgikIibs6LSC0PuRnw6F1ZlcjIiJSoRSExJ3Fcu7uMd1GLyIi1dwVBaG8vDwOHjzIzp07OXXqlKdqErPFFQUhjRMSEZHqrdxBKDMzkw8//JB+/foRERFB48aNadWqFXXr1qVRo0Y8/vjjrFunSypVWtE4oUPrIPeMubWIiIhUoHIFob/97W80btyY6dOnc9111zFv3jwSEhLYuXMnq1atYsKECeTn53PjjTcycOBAdu/eXVF1S0WqGQcRseDIgwOrza5GRESkwviXp/HKlStZsmQJbdu2LXX/tddeyyOPPMIHH3zARx99xNKlS2nevLlHCpVKVDROaPMXztXom11vdkUiIiIVwmIYhmF2Ed4qPT2diIgI0tLSCA8PN7ucypUwCxY8CQ06weP/M7saERGRS1ae39+6a0xKVzRg+sgmyE4ztxYREZEKcllBaP/+/SxatIjk5ORS9x85cuSKihIvEBEDtZqA4YD9q8yuRkREpEKUOwjNmjWLZs2aMXDgQJo2bcq//vUvwBmO3nrrLbp27UrDhg09XqiYoOjuMc0nJCIi1VS5g9Drr7/O6NGj2bp1KzfeeCNPPfUUv//972natCkzZszg2muvZd68eRVRq1S2ookVkxSERESkeirXXWMAe/fuZcyYMTRq1Ij33nuPhg0bsmrVKrZu3crVV19dETWKWYp6hFK2wtlTEFzL3HpEREQ8rNw9Qnl5eQQFBQEQExNDUFAQb7/9tkJQdRRaD+pe5XyetMLcWkRERCrAZQ2W/uKLL/j111+dB7BaqVmzpkeLEi+icUIiIlKNlTsI9erViwkTJtC6dWvq1KlDdnY2U6ZMYc6cOWzfvp38/PyKqFPMogVYRUSkGiv3GKFly5y/EHfv3s2GDRvYuHEjGzZsYObMmaSmpmKz2WjZsiVbtmzxeLFigsa9AAuc2AkZRyGsvtkViYiIeEy5g1CR5s2b07x5c+69917XtsTERNavX8+mTZs8Upx4geBaENkWUrY4l9toe7fZFYmIiHhMuS6NHThwoMz9cXFx3HPPPbz55psAHD58+PIrE++hcUIiIlJNlSsIdenShccff5y1a9desE1aWhrTp0+nTZs2mk+oulAQEhGRaqpcl8Z27NjBm2++ycCBA7HZbHTu3Jno6GgCAwM5ffo027dvZ9u2bXTu3Jm//OUv3HzzzRVVt1Smht3B4genEyH1INSINbsiERERj7is1eezs7P59ttvWb58OUlJSWRlZVGnTh06duzIgAEDaNOmTUXUWul8evX5802/Hg6vhyHvQ4fhZlcjIiJyQeX5/X1Zg6UDAwO58847ufPOOy+rQKmC4vo4g1DiMgUhERGpNso9j9DJkyd59tlneeKJJ1x3hxmGQVJSEunp6R4vULxEXNF8Qsuh/J2IIiIiXqncQeixxx7j448/Zv369fTt25dVq1bRrl07mjZtSp06dRgzZkxF1Clmi+0GVhukH4JT+8yuRkRExCPKHYSWLVvGv//9bzZu3MjkyZO56667qFOnDgsXLuTtt9/mX//6FzNnzqyIWsVMAcEQ08X5XHePiYhINVHuMUKnT5+mbdu2AIwYMYInn3yS+fPn07VrVwDCw8N5//33eeihhzxbqZgvrg8cWOmcWLHzw2ZXIyIicsUua9FVq9X5toCAAIKDg6lbt65rX58+fdi9e7dnqhPv4ppPSOOERESkerjs1ecTEhJKXWA1JCSE06dPX3Fh4oViOoN/IJw5Bsd3ml2NiIjIFSv3pbGi1eczMjKw2+3k5ubyyiuv0KtXLzp16uTWOyTVjL8dGnaDffHOR72rzK5IRETkinhs9flXXnmF1NRU12UzqaaaXu8MQfEToWl/qNvS7IpEREQum1afl/K59nHYsRAOrYPP7obHfoSw+mZXJSIiclkua4kNX6ElNi7gzEn46EY4tRei2sPIb8AeZnZVIiIiQPl+f+s6lpRfSG144N8QXAeSN8NXI6Egz+yqREREyk1BSC5PrSYwfA74B8GeH+HrZ3VLvYiIVDkKQnL5YjrBPZ+AxQqb/gVL/8/sikRERMpFQUiuTMub4Za3nc/j34RNn5tbj4iISDkoCMmV6/Io9BrnfP7fZ2DPT+bWIyIicokUhMQzrv8jtB0KjnyY8xAkbzG7IhERkYvyiiC0bNkyBg0aRHR0NBaLhQULFpTZPjk5meHDh9OyZUusVitjx44ttd3cuXNp1aoVdrudVq1aMX/+fM8XL04WCwx+z7keWW4mfH4PpB40uyoREZEyeUUQOnPmDO3bt2fatGmX1D4nJ4e6devy+9//nvbt25faZtWqVQwbNowHH3yQzZs38+CDDzJ06FDWrFnjydKlOP8AGPYZ1GsFmSnw+d2QpXXnRETEe3ndhIoWi4X58+czZMiQS2rfr18/OnTowDvvvOO2fdiwYaSnp/Pdd9+5tg0cOJCaNWsya9asSzq2JlS8TGmH4J83QsYRaNQLHpznXKdMRESkEmhCRZw9QjfddJPbtgEDBrBy5coLvicnJ4f09HS3h1yGiBi4/yuwh8P+FbDgKXA4zK5KRESkhGobhFJSUqhf330NrPr165OSknLB90ycOJGIiAjXIzY2tqLLrL4i28Cwf4HVH36ZCz9OMLsiERGREqptEALnZbbiDMMosa248ePHk5aW5nocPKjBvlekST/nAGqAlVNhzT9MLUdEROR8l736vLeLjIws0ftz7NixEr1Exdntdux2jWXxqPb3OscM/e91+O5FCI+CqweZXZWIiAhQjXuEunfvzuLFi922LVq0iB49ephUkQ/r/Rx0ehgwYO5jcHCt2RWJiIgAXtIjlJmZyZ49e1yvExMTSUhIoFatWjRs2JDx48dz+PBhZs6c6WqTkJDgeu/x48dJSEggICCAVq1aATBmzBj69OnDpEmTGDx4MP/5z3/48ccfWbFiRaV+N8E5x9Atb0NGMuz6Hr4YBo8uhjrNzK5MRER8nFfcPh8fH0///v1LbB8xYgQzZsxg5MiRJCUlER8f79pX2lifRo0akZSU5Hr973//m1deeYV9+/bRtGlT/vznP3PnnXdecl26fd7Dcs/AjFvhyCao2Rge/RFC65pdlYiIVDPl+f3tFUHIWykIVYDMY/DPGyB1P0RfAyO/hoAQs6sSEZFqRPMIifcKrQcPzIOgWnBkI/z7USjIN7sqERHxUQpCUvnqNIP7ZoN/IOz6znk3mTomRUTEBApCYo6GXeGufwIWWP8RrPib2RWJiIgPUhAS81w9CG6e5Hz+02uwZY659YiIiM9REBJzdf0NdB/lfL7gadi31Nx6RETEpygIiflufB1a3wGOPPjyATi6zeyKRETERygIifmsVhjyATTqCTnp8Pk9kHbY7KpERMQHKAiJd7AFwrDPoE5LSD/sDEPZaWZXJSIi1ZyCkHiP4FrwwL8htD4c2wZfPgj5uWZXJSIi1ZiCkHiXGg3h/q8gIBQSl8LC0ZpjSEREKoyCkHifqPYw9FOw+MGW2fC/N8yuSEREqikFIfFOzW6A26c6ny9/G9Z/Ym49IiJSLSkIiffq+AD0G+98/s042Pm9ufWIiEi1oyAk3q3vS85AZDjg3w/D4Q1mVyQiItWIgpB4N4sFbnsHml4PeWfhi2FwKtHsqkREpJpQEBLv52dzDp6ObAdnjsNnd8GZk2ZXJSIi1YCCkFQN9jDnbfURDeHUXph1L+RlmV2ViIhUcQpCUnWERTonXAyMgENrYe5j4CgwuyoREanCFISkaqnbEu6bDX4B8OvX8MPLmnBRREQum4KQVD2NesAdHzqfr/kAVr1nbj0iIlJlKQiZZM+xDI6kaozLZWtzJ9xUOOP0ot/DL/PMrUdERKokBSET/O/Xowx692dGz9pEXoHD7HKqru6joOuTzufzfwNJP5tbj4iIVDkKQiZoVjcMf6uFDftPM3nRLrPLqbosFhjwJlw9CApyYfZ9cOxXs6sSEZEqREHIBA1rB/N/d7cD4IOle1my85jJFVVhVj+4czrEdoXsNPj8bshIMbsqERGpIhSETHJz2yge6t4IgOfmbCYlLdvkiqowWxDcOwtqN4O0g/D5PZCTYXZVIiJSBSgImejlW66mdXQ4p87k8sysTeRrvNDlC6kN9/8bQupCyhaYMwIK8syuSkREvJyCkIkCbX68N/waQu3+rE06xZSfdptdUtVWKw6Gfwm2YNj7E3w9VnMMiYhImRSETNa4Tghv3tkWgGlL9rBi9wmTK6riGnSCuz8BixU2fQZLJ5ldkYiIeDEFIS9we/to7ru2IYYBY7/cxLF0jRe6Ii0Hwq2Tnc/jJzoDkYiISCkUhLzEhEGtuCoyjBOZuYyZnUCBQ5d0rkjnR6D3887nC5+BPT+aW4+IiHglBSEvEWjz4737ryE4wI9V+04y7X97zC6p6rvuFWh3LxgFzsHTyZvNrkhERLyMgpAXaVo3lD/f0QaAKT/tYtXekyZXVMVZLHD7uxDXF3IznbfVpx4wuyoREfEiCkJe5o6OMdzTKQaHAWNmb+JEZo7ZJVVt/gEw7F9QrzVkHoXP7oas02ZXJSIiXkJByAu9Nrg1zeuFciwjh2e/TMCh8UJXJjAC7v8KwhvAiZ0w+37I04B0ERFREPJKwQH+vHf/NQTarCzffYL3l+41u6SqL6KBMwzZw2H/z7DgSXBoAksREV+nIOSlWtQP40+DneOFJi/aydrEUyZXVA3Ubw3DPgOrDbbNhx//aHZFIiJiMgUhL3ZPpxju7NgAhwHPzNrEqTO5ZpdU9TXpC0Pedz5f+S6s+dDcekRExFQKQl7MYrHw+pA2NKkbQkp6Ns/N0Xghj2h3D1w/wfn8u5dgx3/NrUdEREyjIOTlQuz+vDf8Guz+VpbsPM705fvMLql66PUsdH4UMGDuY7D8r5CTaXZVIiJSyRSEqoCro8KZMKg1AP/3w0427Nft31fMYoFb/gJX3Qb52fDTazClPaycBnlZZlcnIiKVREGoirjv2lgGtY+mwGHwzKxNpJ7VeKErZvWDoTPhjg+hZhycPQGLfu8MRGs+1C32IiI+QEGoirBYLLx5Rxsa1w7mcGoWz3+1BcPQeKErZvWD9vfCqHXOWagjGjonXvzuRXj3Glj3EeQrdIqIVFcKQlVIWKCNacOvIcDPyo87jvLxz0lml1R9+Nngmodg9Aa49a8QFg3ph+GbcTCtE2z8FxTkmV2liIh4mIJQFdOmQQSv3HY1AG99t4PNB1PNLai68Q+ALo/CM5vg5v+D0PrO9ckWjoJpXWDzbHAUmF2liIh4iIJQFfRgt0bc0jaSvAKD336xkbQs9VR4nC0Quv4GnkmAm96A4NpwOhHm/wb+3g1+mauZqUVEqgEFoSrIYrHw1l3tiK0VxKHTWfxursYLVZiAYOgxGsZscc49FFQTTuyCfz8CH/SE7QtB515EpMpSEKqiwgNtTLvvGmx+Fr77JYV/rd5vdknVmz0Ueo9zBqJ+L4M9Ao5thzkPwod9YOd3CkQiIlWQglAV1j62Br+72Tle6I2vd/DL4TSTK/IBgeHQ7yUYuxn6vAABoZCyBWbdC/+8Hvb8qEAkIlKFKAhVcY/0bMyNreqTW+Dgt19sJCNb44UqRVBNuO4VZw9Rz7FgC4bDG+Czu+DjgbBvqdkViojIJVAQquIsFgt/ubsdDWoEsf/kWcbP26rxQpUppDbc+BqM2Qzdfgv+gXBwNcy8HWbcBvtXmV2hiIiUQUGoGqgRHMC7wzvib7Xw9ZZkvlh7wOySfE9oPRj4pvMus2ufAL8ASFoOnwyEmUPg0HqzKxQRkVIoCFUT1zSsyYsDWwLw2n+3syM53eSKfFR4lHMNs9EbodPDYPWHfUuc44c+HwpHNpldoYiIFKMgVI081qsJ/VvWJTffOV7oTE6+2SX5rhqxMOgd50zVHR4Aix/s/gH+0Q9m3w8pv5hdoYiIoCBUrVitFiYP7UBkeCD7jp/hlQW/aLyQ2Wo2hiHvOdcyazcMsMCvXzvnIJozAo79anaFIiI+TUGomqkV4hwv5Ge1MH/TYb5af8jskgSgdlO48x/w2zXQ+g7ntu0LnLNUz30cTu41tTwREV+lIFQNdWlci3E3tgDgjwt/YdfRDJMrEpe6LeGeGfDUSrjqNsCArXOc65gteBpOJ5lcoIiIb1EQqqae6tuU3s3rkJ3n4Lefb+RsrsYLeZX6reHez+GJpdBiIBgFkPA5vNsJ/jsGUg+aXaGIiE9QEKqmrFYLfxvWgXphdnYfy2TCf7aZXZKUJroDDP8SHvsJml4PjnzYMAPevQa+eR7Sk82uUESkWlMQqsbqhNqZcm9HrBb4asMh5m3UeCGvFdMZHpwHD38PjXtDQS6smw5TO8D34yHzmNkViohUSwpC1Vz3prUZc71zvNArC35hz7FMkyuSMjXqDiO/hhH/hdhukJ8Nq/8OU9rD4j/CmZNmVygiUq0oCPmAUdc1o0fT2pzNLWDUFxvJziswuyS5mLg+8Mj38MA8aNAJ8s7Cz1NgSjv46XXIOm12hSIi1YKCkA/ws1p4594O1AkN4NeUDF7773azS5JLYbFAs+ud44eGz4Go9pCbCcvfhnfaQ/wkyE4zu0oRkSrNK4LQsmXLGDRoENHR0VgsFhYsWHDR9yxdupROnToRGBhIkyZN+OCDD9z2z5gxA4vFUuKRnZ1dQd/Cu9ULC+SdYR2xWGDW2gMs3HzE7JLkUlks0GKA8w6zYZ9BvdaQkwbxb8I77WD5ZMjRJU8RkcvhFUHozJkztG/fnmnTpl1S+8TERG655RZ69+7Npk2bePnll3nmmWeYO3euW7vw8HCSk5PdHoGBgRXxFaqEXs3rMKp/MwDGz91C4okzJlck5WKxwNWD4MkVcPcnUKclZKfCT39yXjL7eSrknjW7ShGRKsVieNkaDBaLhfnz5zNkyJALtnnppZdYuHAhO3bscG178skn2bx5M6tWrQKcPUJjx44lNTX1kj87JyeHnJwc1+v09HRiY2NJS0sjPDy83N/FG+UXOBj+zzWsTTxFq6hw5j3dg0Cbn9llyeVwFMAvcyF+Ipza59wWWh96jYNOI8Hmu6FfRHxbeno6ERERl/T72yt6hMpr1apV3HTTTW7bBgwYwPr168nLy3Nty8zMpFGjRsTExHDbbbexaVPZK39PnDiRiIgI1yM2NrZC6jeTv5+Vqfd2pFZIANuT0/nzNzsu/ibxTlY/aDcUfrsOBr8HNRpC5lH4/iWY2hHW/RPyc82uUkTEq1XJIJSSkkL9+vXdttWvX5/8/HxOnDgBwFVXXcWMGTNYuHAhs2bNIjAwkJ49e7J79+4LHnf8+PGkpaW5HgcPVs/ZfSMjAvnr0PYA/Gv1fr7dqkn7qjQ/f+j4AIzaALe9A+ExkHEEvnkO3mkDC0fDjv9CjpZaERE5n7/ZBVwui8Xi9rroCl/R9m7dutGtWzfX/p49e3LNNdfw7rvvMnXq1FKPabfbsdvtFVSxd+nXsh5P9m3KB0v38tK/t9AmOoKGtYPNLkuuhH8AdH4YOgyHjTNh2duQmeJ8vnEmWG3OeYqa3+R81GnhHHckIuLDqmSPUGRkJCkpKW7bjh07hr+/P7Vr1y71PVarlS5dupTZI+RrnrupBZ0a1SQjJ59RszaSk6/5haoFfztc+ziM3eKch6jrU1CrKTjyIHEZLHoF3rvWOcD6m+dg1w8aZC0iPqtKBqHu3buzePFit22LFi2ic+fO2Gy2Ut9jGAYJCQlERUVVRolVgs3Pyrv3daRGsI0th9J467tfzS5JPMnf7pyH6Oa34JmNMHojDJzkXNPMzw6pB5zjiL4YCpMaw2d3wZoPzw28FhHxAV5xaSwzM5M9e/a4XicmJpKQkECtWrVo2LAh48eP5/Dhw8ycORNw3iE2bdo0xo0bx+OPP86qVav46KOPmDVrlusYr732Gt26daN58+akp6czdepUEhISeO+99yr9+3mz6BpBTL6nPY9+up5Pfk6iW5PaDGgdaXZZUhFqN3U+uj0JuWcgcTnsXuR8pB2EPT86H98BtZsVXkK7ERr1dIYqEZFqyCuC0Pr16+nfv7/r9bhx4wAYMWIEM2bMIDk5mQMHDrj2x8XF8e233/Lss8/y3nvvER0dzdSpU7nrrrtcbVJTU3niiSdISUkhIiKCjh07smzZMq699trK+2JVxPVX1+fx3nFMX57IC19tpnV0ODE1NV6oWgsIgZYDnQ/DgOM7z4WiA6vg5B7nY/XfwRYCTfo6Q1GzG6FG9bubUkR8l9fNI+RNyjMPQVWXm+/gng9XsflgKh0b1mDOb7pj86uSV07lSmWnw774wmC02Dngurh6rZyhqPlNENsV/Eq/HC0iYpby/P5WECqDLwUhgIOnznLr1OWkZ+fzRJ8mvHzL1WaXJGYzDEjZei4UHVoLhuPcfns4NO3vDEXNboAwXVYVEfMpCHmIrwUhgB+2pfCbf20A4OORnbnuqvoXeYf4lLOnYO//nKFoz2I4e9J9f1T7c7fnN+jknPRRRKSSKQh5iC8GIYBXF25jxsokagTb+PaZ3kTXCDK7JPFGjgI4knBubNGRje77g2o6e4ma3+S8Uy2k9KktREQ8TUHIQ3w1COXkF3D3+6vYejiNzo1qMvuJbvhrvJBcTOYx2POTMxTt/Qmy04rttEBM53N3okW2B6v+TIlIxVAQ8hBfDUIA+0+e4bapK8jIyefpfk15ceBVZpckVUlBPhxad25s0dGt7vtD6hUOuL4RmvSHoBqmlCki1ZOCkIf4chAC+GZLMr/9wnm549NHrqVvi7omVyRVVtph5xxFuxc570jLzTy3z+IHDbsVBqMBUO9qLf0hIldEQchDfD0IAbyyYCufrT5A7ZAAvh3Tm/rhgWaXJFVdfo5zrqLdi53B6MQu9/3hMed6i+L6gj3UnDpFpMpSEPIQBSHIzivgzr+vZHtyOl3javH5Y101Xkg861Tiud6ixGWQn31un18ANOpx7k602s3UWyQiF6Ug5CEKQk77jmcy6N0VnMkt4JnrmzPuxhZmlyTVVV4WJK1whqJdP0Dqfvf9QbUgsm3ho53zZ53mmtRRRNwoCHmIgtA5/0k4zJjZCVgs8NmjXenZrI7ZJUl1ZxjOZT6Kbs9P+hkceSXb+dmd44qKh6P6rSHQt//OivgyBSEPURBy97u5W5i97iB1Qu38Z1RPGmh+IalMedlwfIdzpmvX4xfIzSi9fc0493AU2RbCo3VpTcQHKAh5iIKQu6zcAoa89zM7j2YQ4G/lrmsa8FjvJjStq8GsYhKHA1KTzgtHWyH9cOntS7201gL8vGL9aRHxEAUhD1EQKinpxBmenZPApgOpgPMf1zdeXZ/f9G1Cp0a1zC1OpMiZk865i4qHo+M7wSgo2fb8S2tR7ZyX1uxhlV+3iHiEgpCHKAiVzjAM1iWd5h/L9vLjjmOu7Z0b1eSJPk244er6WK26/CBeptRLa1vd5zQqrlaTkr1HYVG6tCZSBSgIeYiC0MXtPprB9OX7WLDpCLkFzlXJm9QN4YneTRjSsQGBNi26KV6svJfWgmuXDEe1m+vSmoiXURDyEAWhS3csPZtPVibx2er9ZGTnA1An1M7DPRvzQNdGRATr9mapQsp7aa1+q5J3renSmohpFIQ8REGo/DJz8pm99gAfrUgkOc05MV5wgB/3dmnII70aE1Mz2OQKRS6TLq2JVBkKQh6iIHT58goc/HfzEf6xbB+/pjhvb/azWritXRRP9GlC6+gIkysU8QCHA04nlgxHGUdKb69LayKVQkHIQxSErpxhGCzbfYIPl+5l5d6Tru29m9fhiT5N6NWsDhb9C1mqmzMnSoajE7tKv7Rm9YeIWKjZuPDRqNjzxhBUs1JLF6kOFIQ8REHIs345nMaHy/bxzZYjOAr/1LWKCuc3fZtwa9sorWEm1VteFhw779La0V8ufGmtSGDEuVBU47yQFBEL/gEVXrpIVaMg5CEKQhXj4KmzfLQikS/XHSQrz/kv5AY1gni0VxzDusQSYtdlAvERDgdkJMPppJKP1P2QebTs91usEB5T2ItUFJLizgWl4NoakyQ+SUHIQxSEKtbpM7l8tno/M1YmcfJMLgARQTYe6NaQET0aUy8s0OQKRUyWewZSD5wXkvafe56fVfb7A0JL9iK5epcagk1/x6R6UhDyEAWhypGdV8DcjYf45/JEEk+cAdASHiIXYxiQeaxkL1LR8/QjwEX+9x4WdYGQ1AhC64NVl6ulalIQ8hAFocpV4DBYvD2FD5ft0xIeIlcqLxvSDpZy2a0wLF1osdoi/oGl9CY1OheU7PoHingvBSEPURAyh2EYrN9/mg+Xui/h0alwCY8btYSHyJUxDDh7qrAXKalkWEo7BIaj7GOE1HW/zBYW5exFCouCsPrO5/72iv0eIhegIOQhCkLm23Msg+nLEpm/6bDbEh6P927CHVrCQ6RiFOQ5w9CFBnFnnb604wTVKhaMIiGs2KPodWh9jVUSj1MQ8hAFIe+hJTxEvEhWqvt4pNQDkJHivMst46jzTjhH3qUfL7DGucBUomepWHiyBVXM95FqR0HIQxSEvE/REh4fr0jkiJbwEPFOhuHsNcpIdgakjBTITCn2vDAsZRyFgpxLP25ghHswKh6YXAEqEgJCKu67SZWgIOQhCkLeK6/AwddbjvDhUi3hIVJlFQWm4sEoI7nw9XkBKj/70o9rDz8Xis6/FFf8uQZ8V1sKQh6iIOT9ipbw+Meyvfy8R0t4iFRLhgHZaWX3LBUFqLyzl37cgNBiwag+hNSD4FqFj9rOMU7BtQsftTT4uwpREPIQBaGqpWgJj2+3JlNQuIZH0RIet7SNwqYlPESqN8OAnHRnMCoemM4PUBkpkHem/McPCL1wSFJ48ioKQh6iIFQ1XWgJj0d6xXGvlvAQEYCcjPMuxSU7F8vNOuWcWuDsyXM/s05dfDqBCykKTyWCU+1Stis8eYqCkIcoCFVtRUt4fLoqiROZWsJDRC6TwwE5aSUDUlFIcm0rvv00GAWX93nlCk+FrzUFgRsFIQ9REKoesvMKmLfxMNOX7zu3hIeflbs6aQkPEakgbuGptOB0Xngq6om6kvAUVKtkYAqq4Rw8Hhhx4Ye1+s3HpiDkIQpC1YtzCY+jfLhsr9sSHv1b1qNH09q0i6lB6+hwXToTEXOUFp5KBKfCn8V7oi43PBUJCDsvHF0kOLkeNZwhy8/7/p+pIOQhCkLV07klPPbx446jbvssFmhWN5S2MRG0axBB25gatIoKJyig+v2LSUSqAYfDOUC8REAqfJ2T7rzjrsQj/fIGjJcmIPTivU4lglaNc6/9PD8hroKQhygIVX97jmXy/S/JbDmUxtbDaSSnlZyrxM9qoXm9UNrFOINRuwYRXBUVht1f4UhEqrCCPGcgyk69QFgqfFwoTOVmeqaOmC7w2I+eOVYhBSEPURDyPccysvnlcJozGB1KY/OhNE5klpz51uZn4arI8GI9RxG0qB+mW/RFxHcU5BeGpFT3nqayQpVbkHJOhkvj3jDya4+WpiDkIQpCYhgGR9Nz2HIola2FAWnLoVROny25jlKAv5VWUeHOnqMGEbSLqUHTuiH4KxyJiJTkKHAGqYI8CK3n0UMrCHmIgpCUxjAMDqdmsfVQGlsOO3uOthxKJb1wMdjigmx+tI4u7DmKiaBtgxo0qROC1arZrkVEKoqCkIcoCMmlMgyDA6fOusYabT6Yyi+H0ziTW/JujlC7P62jw93GHDWqHaylQEREPERByEMUhORKOBwG+06cYevhVNeYo21H0l2zXRcXHuhP28Ieo6JLazE1gxSOREQug4KQhygIiaflFzjYe/yM25ij7cnp5OaXnL6/ZrDN1WNUdGktMjxQ4UhE5CIUhDxEQUgqQ16Bg11HM9zGHP2akk5eQcm/mnVC7cUGYzsDkpYKERFxpyDkIQpCYpac/AJ2pmS4LqltOZzGrqMZFDhK/nWNDA90u42/XUwNaoUEmFC1iIh3UBDyEAUh8SbZeQVsT05ny8FUV8/RnuOZlPY3uEGNINrFRHBVZDhRNQKJDA8kKiKQyIhAwgI9P4uriIg3URDyEAUh8XZncvLZdiTdNeZo66E09p0oe9r8kAA/IiMCiYoIon6xgBQZHli4PZBaIQEaiyQiVZaCkIcoCElVlJ6d55ode9/xTFLSczialk1yWlapcx2VJsDPSv0IO1HhQdQvDEdFQakoNNULs2uySBHxSgpCHqIgJNXN2dx8UtKySUnLJjktm5T0c8+Ppjt/lrakSGmsFqgbZi/Wk1R6D1OgTWuyiUjlKs/vb/9KqklEvEBwgD9N6obSpG7oBdvk5js4llEyIKUUC05H07PJdziXHzmansPmQ2kXPF7NYFuxgBTkNl6p6BFm99elOBExhYKQiLgJ8LcSUzOYmJrBF2zjcBicOJNTelgqDEzJaVlk5zk4fTaP02fz+DUl44LHCwnwc12Cu1BoqhUcoKVJRMTjFIREpNysVgv1wgKpFxZIu5jS2xiGQXpWPsnpWW6X487vYUrLyuNMbgH7jp9h3/ELD/S2+VmoERxAeKA/EUE2IoJshBf+jAiyER5YtM3ftT080EZEsI3QAH+FKBEplYKQiFQIi8VCRLAziFwVeeFr9K5xS6WMVyrafiIzh7wCg+MZORzPuLQxTMVZLRAWWCw0Bfm7BajwUoOVv2ubTYPCRaotBSERMdWljls6nplD6tlc0rLySM/KJz0rz/k82/nTub3Y8+x80rLyyM134DBwbb+8Gv0uEJz83XqjSoSpIH+CbH4a/yTixRSERMTrBfhbaVAjiAY1gsr93uy8gguEpvwSAcq53xmy0rPyyMhxTjdwNreAs7kFJKdll/vzbX6WC/Q8OUNUqN1GcIAfQQF+BBc+gmz+rm1BtqLt/gTarApVIh6mICQi1VqgzY9Amx/1wsu/Jlt+gYOM7HxXgHILT6X0RKUX64lKy8qjwGGQV2BwIjOXE5m5V/xdLBZcwagoJAUF+BNcbFtRaCoeooLOC1jBAc5zUrxtcICfLgGKT1IQEhG5AH8/KzVDAqh5GWu3GYbB2dyCc6HprPslu6LwlJGdT3ZeAWdz8zmbW0BWnrP3KSv33LacfEfhMc/1TlUEm5+lMDyVHqRK3V7YPsDfit3fWvjTD7vNSoCftdhPv2L7ndvUuyXeQEFIRKQCWCwWQuz+hNj9iab8l/SKczgM94CUl18sLDnDU1ZhaHLffq5d0fudr4u9P6/AtZhvXoFBXkH+Jc9AfqUC/K3YC8OS3d/vvDB1qdvOC1jFgpjdFcTcg1nxY/hbLQpkPk5BSETEy1mt50KVpxmGQW6Bg+xcR4mAdTY3/7ywVbg9r9j2wn25+Q5y8ot+Oh9F24q/Li63cNtl3AjoMRYLroBl87Ni87Ng87Pi72choPCnzc+KzWrF5m/B32otu13hPn+rM5T5Wy3ntT/33O39Vgv+ftbzjnX+ZxRus1o1HYQHKQiJiPgwi8VS2KviRwS2Cv2sotB1LiQ5yMkrcG7Lcw9P5wKVe7g6f1tpx3F+RsG553nu78l3GMVqguw8B9l5jjIq9z5+Vgv+1guEsGLP/azO4ORnteBf+NrfWvizMICd21YUyNxfF+13a1/sWP5W63nHPnccv8L9xT/X5uf+OtDmR90wu2nnUkFIREQqRfHQZaYCh3GBwGWQ73CQV+Agr8Agv8AofF742uEMXvkOw7Utr8BBfoGD3AKD/GJtndsN8hxFxyq5L7fA4fy8/KJ2jmKfWfQeZ7vSvkOBw3CNH6vKOjaswfyne5r2+V4RhJYtW8Zf/vIXNmzYQHJyMvPnz2fIkCFlvmfp0qWMGzeObdu2ER0dzYsvvsiTTz7p1mbu3Ln84Q9/YO/evTRt2pQ///nP3HHHHRX4TURExNv5WS3OQd8BVWNBYMNwhp58R2F4Oj+gFTjO214YthzObUXvLfqZX+Bwe13gcBRud39dUPg63+Fwtj3vWHkFjvOO7XDdKXn+sQtcxy/2nsLj2/3NvVvRK4LQmTNnaN++PQ8//DB33XXXRdsnJiZyyy238Pjjj/PZZ5/x888/8/TTT1O3bl3X+1etWsWwYcN4/fXXueOOO5g/fz5Dhw5lxYoVdO3ataK/koiIiEdYLIWXq/yc00GIZ1kMwzAu3qzyWCyWi/YIvfTSSyxcuJAdO3a4tj355JNs3ryZVatWATBs2DDS09P57rvvXG0GDhxIzZo1mTVr1iXVkp6eTkREBGlpaYSHX3iJABEREfEe5fn9XSVnz1q1ahU33XST27YBAwawfv168vLyymyzcuXKCx43JyeH9PR0t4eIiIhUX1UyCKWkpFC/fn23bfXr1yc/P58TJ06U2SYlJeWCx504cSIRERGuR2xsrOeLFxEREa9RJYMQUGICrKIrfMW3l9amrImzxo8fT1pamutx8OBBD1YsIiIi3sYrBkuXV2RkZImenWPHjuHv70/t2rXLbHN+L1Fxdrsdu928uQxERESkclXJHqHu3buzePFit22LFi2ic+fO2Gy2Mtv06NGj0uoUERER7+YVPUKZmZns2bPH9ToxMZGEhARq1apFw4YNGT9+PIcPH2bmzJmA8w6xadOmMW7cOB5//HFWrVrFRx995HY32JgxY+jTpw+TJk1i8ODB/Oc//+HHH39kxYoVlf79RERExDt5RY/Q+vXr6dixIx07dgRg3LhxdOzYkT/+8Y8AJCcnc+DAAVf7uLg4vv32W+Lj4+nQoQOvv/46U6dOdZuDqEePHsyePZtPPvmEdu3aMWPGDL788kvNISQiIiIuXjePkDfRPEIiIiJVT7WfR0hERETEExSERERExGcpCImIiIjPUhASERERn6UgJCIiIj7LK+YR8lZFN9Rp8VUREZGqo+j39qXcGK8gVIaMjAwALb4qIiJSBWVkZBAREVFmG80jVAaHw8GRI0cICwsrc7FWOSc9PZ3Y2FgOHjyouZcqkc67eXTuzaHzbp6qcO4NwyAjI4Po6Gis1rJHAalHqAxWq5WYmBizy6iSwsPDvfYvSHWm824enXtz6Lybx9vP/cV6goposLSIiIj4LAUhERER8VkKQuJRdrudCRMmYLfbzS7Fp+i8m0fn3hw67+apbudeg6VFRETEZ6lHSERERHyWgpCIiIj4LAUhERER8VkKQiIiIuKzFISkhGXLljFo0CCio6OxWCwsWLDAbb9hGLz66qtER0cTFBREv3792LZtm1ubnJwcRo8eTZ06dQgJCeH222/n0KFDbm1Onz7Ngw8+SEREBBERETz44IOkpqZW8LfzXhMnTqRLly6EhYVRr149hgwZws6dO93a6Nx73vvvv0+7du1ck8N1796d7777zrVf57xyTJw4EYvFwtixY13bdO4rxquvvorFYnF7REZGuvb73Hk3RM7z7bffGr///e+NuXPnGoAxf/58t/1vvfWWERYWZsydO9fYunWrMWzYMCMqKspIT093tXnyySeNBg0aGIsXLzY2btxo9O/f32jfvr2Rn5/vajNw4ECjTZs2xsqVK42VK1cabdq0MW677bbK+ppeZ8CAAcYnn3xi/PLLL0ZCQoJx6623Gg0bNjQyMzNdbXTuPW/hwoXGN998Y+zcudPYuXOn8fLLLxs2m8345ZdfDMPQOa8Ma9euNRo3bmy0a9fOGDNmjGu7zn3FmDBhgtG6dWsjOTnZ9Th27Jhrv6+ddwUhKdP5QcjhcBiRkZHGW2+95dqWnZ1tREREGB988IFhGIaRmppq2Gw2Y/bs2a42hw8fNqxWq/H9998bhmEY27dvNwBj9erVrjarVq0yAOPXX3+t4G9VNRw7dswAjKVLlxqGoXNfmWrWrGn885//1DmvBBkZGUbz5s2NxYsXG3379nUFIZ37ijNhwgSjffv2pe7zxfOuS2NSLomJiaSkpHDTTTe5ttntdvr27cvKlSsB2LBhA3l5eW5toqOjadOmjavNqlWriIiIoGvXrq423bp1IyIiwtXG16WlpQFQq1YtQOe+MhQUFDB79mzOnDlD9+7ddc4rwW9/+1tuvfVWbrjhBrftOvcVa/fu3URHRxMXF8e9997Lvn37AN8871p0VcolJSUFgPr167ttr1+/Pvv373e1CQgIoGbNmiXaFL0/JSWFevXqlTh+vXr1XG18mWEYjBs3jl69etGmTRtA574ibd26le7du5OdnU1oaCjz58+nVatWrv9h65xXjNmzZ7Nx40bWrVtXYp/+vFecrl27MnPmTFq0aMHRo0d544036NGjB9u2bfPJ864gJJfFYrG4vTYMo8S2853fprT2l3IcXzBq1Ci2bNnCihUrSuzTufe8li1bkpCQQGpqKnPnzmXEiBEsXbrUtV/n3PMOHjzImDFjWLRoEYGBgRdsp3PveTfffLPredu2benevTtNmzbl008/pVu3boBvnXddGpNyKbqz4PxEf+zYMde/ICIjI8nNzeX06dNltjl69GiJ4x8/frzEv0R8zejRo1m4cCFLliwhJibGtV3nvuIEBATQrFkzOnfuzMSJE2nfvj1TpkzROa9AGzZs4NixY3Tq1Al/f3/8/f1ZunQpU6dOxd/f33VedO4rXkhICG3btmX37t0++WdeQUjKJS4ujsjISBYvXuzalpuby9KlS+nRowcAnTp1wmazubVJTk7ml19+cbXp3r07aWlprF271tVmzZo1pKWludr4GsMwGDVqFPPmzeN///sfcXFxbvt17iuPYRjk5OTonFeg66+/nq1bt5KQkOB6dO7cmfvvv5+EhASaNGmic19JcnJy2LFjB1FRUb75Z76yR2eL98vIyDA2bdpkbNq0yQCMv/71r8amTZuM/fv3G4bhvLUyIiLCmDdvnrF161bjvvvuK/XWypiYGOPHH380Nm7caFx33XWl3lrZrl07Y9WqVcaqVauMtm3beuWtlZXlqaeeMiIiIoz4+Hi321rPnj3raqNz73njx483li1bZiQmJhpbtmwxXn75ZcNqtRqLFi0yDEPnvDIVv2vMMHTuK8pzzz1nxMfHG/v27TNWr15t3HbbbUZYWJiRlJRkGIbvnXcFISlhyZIlBlDiMWLECMMwnLdXTpgwwYiMjDTsdrvRp08fY+vWrW7HyMrKMkaNGmXUqlXLCAoKMm677TbjwIEDbm1Onjxp3H///UZYWJgRFhZm3H///cbp06cr6Vt6n9LOOWB88sknrjY69573yCOPGI0aNTICAgKMunXrGtdff70rBBmGznllOj8I6dxXjKJ5gWw2mxEdHW3ceeedxrZt21z7fe28WwzDMMzpixIRERExl8YIiYiIiM9SEBIRERGfpSAkIiIiPktBSERERHyWgpCIiIj4LAUhERER8VkKQiIiIuKzFIRERETEZykIiUiVMnLkSIYMGeJ63a9fP8aOHVuhn2exWLBYLCxYsACApKQkLBYLCQkJFfa5M2bMcH1uRX4/EV+nICQiHlc8PPj7+9OwYUOeeuqpEqtVe8K8efN4/fXXPX7c4gYOHEhycjI333xzhX5OccOGDSM5OZnu3btX2meK+CJ/swsQkepp4MCBfPLJJ+Tn57N9+3YeeeQRUlNTmTVrlkc/p1atWh49XmnsdjuRkZEV/jnFBQUFERQUREBAQKV+roivUY+QiFSIovAQExPDTTfdxLBhw1i0aJFrf0FBAY8++ihxcXEEBQXRsmVLpkyZ4naMgoICxo0bR40aNahduzYvvvgi5y+PeP6lseKXsIrUqFGDGTNmAJCbm8uoUaOIiooiMDCQxo0bM3HixCv6rg6Hg8cff5wWLVqwf/9+Vx3vv/8+N998M0FBQcTFxfHVV1+5ve/QoUPce++91KpVi5CQEDp37syaNWuuqBYRKR8FIRGpcPv27eP777/HZrO5tjkcDmJiYpgzZw7bt2/nj3/8Iy+//DJz5sxxtZk8eTIff/wxH330EStWrODUqVPMnz//imqZOnUqCxcuZM6cOezcuZPPPvuMxo0bX/bxcnNzGTp0KOvXr2fFihU0atTIte8Pf/gDd911F5s3b+aBBx7gvvvuY8eOHQBkZmbSt29fjhw5wsKFC9m8eTMvvvgiDofjir6fiJSPLo2JSIX4+uuvCQ0NpaCggOzsbAD++te/uvbbbDZee+011+u4uDhWrlzJnDlzGDp0KADvvPMO48eP56677gLggw8+4Icffriiug4cOEDz5s3p1asXFovFLbiUV2ZmJrfeeitZWVnEx8cTERHhtv+ee+7hscceA+D1119n8eLFvPvuu/z973/niy++4Pjx46xbt851ea9Zs2aX/8VE5LKoR0hEKkT//v1JSEhgzZo1jB49mgEDBjB69Gi3Nh988AGdO3embt26hIaGMn36dA4cOABAWlpaicHC/v7+dO7c+YrqGjlyJAkJCbRs2ZJnnnnG7XJded13331kZmayaNGiEiEIKDHQuXv37q4eoYSEBDp27FgpY5xE5MIUhESkQoSEhNCsWTPatWvH1KlTycnJcesBmjNnDs8++yyPPPIIixYtIiEhgYcffpjc3Nwr+lyLxVJiHFFeXp7r+TXXXENiYiKvv/46WVlZDB06lLvvvvuyPuuWW25hy5YtrF69ulz1gXMwtIiYT0FIRCrFhAkTePvttzly5AgAy5cvp0ePHjz99NN07NiRZs2asXfvXlf7iIgIoqKi3EJGfn4+GzZsKPNz6tatS3Jysuv17t27OXv2rFub8PBwhg0bxvTp0/nyyy+ZO3cup06dKvd3euqpp3jrrbe4/fbbWbp0aYn95wek1atXc9VVVwHQrl07EhISLutzRcRzFIREpFL069eP1q1b8+abbwLO8TDr16/nhx9+YNeuXfzhD39g3bp1bu8ZM2YMb731FvPnz+fXX3/l6aefJjU1tczPue6665g2bRobN25k/fr1PPnkk26DtP/2t78xe/Zsfv31V3bt2sVXX31FZGQkNWrUuKzvNXr0aN544w1uu+02VqxY4bbvq6++4uOPP2bXrl1MmDCBtWvXMmrUKMB5WS0yMpIhQ4bw888/s2/fPubOncuqVasuqw4RuTwKQiJSacaNG8f06dM5ePAgTz75JHfeeSfDhg2ja9eunDx5kqefftqt/XPPPcdDDz3EyJEj6d69O2FhYdxxxx1lfsbkyZOJjY2lT58+DB8+nOeff57g4GDX/tDQUCZNmkTnzp3p0qULSUlJfPvtt1itl/+/w7Fjx/Laa69xyy23sHLlStf21157jdmzZ9OuXTs+/fRTPv/8c1q1agVAQEAAixYtol69etxyyy20bduWt956Cz8/v8uuQ0TKz2KcfzFdRERcRo4cSWpqaom5iS7GYrEwf/58t+VALke/fv3o0KED77zzzhUdR0RKpx4hEZGLKJoK4Ouvv660z/z8888JDQ1l+fLllfaZIr5IPUIiImU4duwY6enpAERFRRESEnJJ77vSHqGMjAyOHj0KOGfGrlOnzmUdR0TKpiAkIiIiPkuXxkRERMRnKQiJiIiIz1IQEhEREZ+lICQiIiI+S0FIREREfJaCkIiIiPgsBSERERHxWQpCIiIi4rP+H16SUM9eVD36AAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.plot(cl.DeltaSigma_profile[\"radius\"], nfw_boost, label=\"NFW boost factor\")\n", "plt.plot(cl.DeltaSigma_profile[\"radius\"], powerlaw_boost, label=\"Powerlaw boost factor\")\n", @@ -423,7 +317,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "d7b5f71d", "metadata": {}, "outputs": [], @@ -446,21 +340,10 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "e2d90e0c", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.errorbar(\n", " cl.DeltaSigma_profile[\"radius\"],\n", @@ -505,21 +388,10 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "b4b3f953", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "Sigma_corrected_powerlaw_boost = u.correct_sigma_with_boost_model(\n", " cl.DeltaSigma_profile[\"radius\"],\n", @@ -564,29 +436,13 @@ "plt.legend()\n", "plt.show()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "089d39af-9ca0-4d28-baa0-ba7b76fb40dd", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "cb5021c2-9b96-43a0-ab23-b28c7508e38a", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python (firecrown2.0)", + "display_name": "Python 3 (ipykernel)", "language": "python", - "name": "firecrown" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -598,11 +454,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", -<<<<<<< HEAD - "version": "3.11.0" -======= "version": "3.10.8" ->>>>>>> main } }, "nbformat": 4, From e43bb6ed768adce54a4b62ca6317dc7a2a85e2ca Mon Sep 17 00:00:00 2001 From: m-aguena Date: Wed, 17 May 2023 11:46:06 +0200 Subject: [PATCH 17/38] update tests --- tests/test_theory.py | 110 ++----------------------------------------- 1 file changed, 3 insertions(+), 107 deletions(-) diff --git a/tests/test_theory.py b/tests/test_theory.py index 7b5434f9b..7372cfcce 100644 --- a/tests/test_theory.py +++ b/tests/test_theory.py @@ -534,126 +534,24 @@ def test_shear_convergence_unittests(modeling_data, profile_init): kappa_inf = theo.compute_convergence(cosmo=cosmo, **cfg_inf["GAMMA_PARAMS"]) # test z_src = chang2013 distribution - cfg_inf["GAMMA_PARAMS"]["z_source"] = ( - compute_beta_s_mean_from_distribution( - cfg_inf['GAMMA_PARAMS']['z_cluster'], cfg_inf['GAMMA_PARAMS']['z_source'], cosmo), - compute_beta_s_square_mean_from_distribution( - cfg_inf['GAMMA_PARAMS']['z_cluster'], cfg_inf['GAMMA_PARAMS']['z_source'], cosmo), - ) - cfg_inf["GAMMA_PARAMS"]["z_src_info"] = "beta" - + cfg_inf["GAMMA_PARAMS"]["z_source"] = chang2013 + cfg_inf["GAMMA_PARAMS"]["z_src_info"] = "distribution" # store original values r_proj = cfg_inf["GAMMA_PARAMS"]["r_proj"] # use only 5 largest radii cfg_inf["GAMMA_PARAMS"]["r_proj"] = cfg_inf["GAMMA_PARAMS"]["r_proj"][-5:] # calculate some true values - cfg_inf["GAMMA_PARAMS"]["approx"] = "order1" gt = theo.compute_reduced_tangential_shear(cosmo=cosmo, **cfg_inf["GAMMA_PARAMS"]) mu = theo.compute_magnification(cosmo=cosmo, **cfg_inf["GAMMA_PARAMS"]) mu_bias = theo.compute_magnification_bias( cosmo=cosmo, **cfg_inf["GAMMA_PARAMS"], alpha=alpha ) cfg_inf["GAMMA_PARAMS"]["r_proj"] = r_proj - # tangential shear - cfg_inf["GAMMA_PARAMS"].pop("approx") - assert_allclose( - theo.compute_tangential_shear(cosmo=cosmo, **cfg_inf["GAMMA_PARAMS"]), - beta_s_mean * gammat_inf, - 1.0e-10, - ) - - # convergence - assert_allclose( - theo.compute_convergence(cosmo=cosmo, **cfg_inf["GAMMA_PARAMS"]), - beta_s_mean * kappa_inf, - 1.0e-10, - ) - + # tangential shear and convergence cannot use z_src_info="distribution" # reduced tangential shear - cfg_inf["GAMMA_PARAMS"]["approx"] = "order1" - assert_allclose( - theo.compute_reduced_tangential_shear(cosmo=cosmo, **cfg_inf["GAMMA_PARAMS"]), - beta_s_mean * gammat_inf / (1.0 - beta_s_mean * kappa_inf), - 1.0e-10, - ) - assert_allclose( - theo.compute_reduced_tangential_shear(cosmo=cosmo, **cfg_inf["GAMMA_PARAMS"])[-5:], - gt, - 3.0e-6, - ) - - cfg_inf["GAMMA_PARAMS"]["approx"] = "order2" - assert_allclose( - theo.compute_reduced_tangential_shear(cosmo=cosmo, **cfg_inf["GAMMA_PARAMS"]), - ( - 1.0 - + (beta_s_square_mean / (beta_s_mean * beta_s_mean) - 1.0) * beta_s_mean * kappa_inf - ) - * (beta_s_mean * gammat_inf / (1.0 - beta_s_mean * kappa_inf)), - 1.0e-10, - ) - assert_allclose( - theo.compute_reduced_tangential_shear(cosmo=cosmo, **cfg_inf["GAMMA_PARAMS"])[-5:], - gt, - 3.0e-6, - ) - - # magnification - cfg_inf["GAMMA_PARAMS"]["approx"] = "order1" - assert_allclose( - theo.compute_magnification(cosmo=cosmo, **cfg_inf["GAMMA_PARAMS"]), - 1 + 2 * beta_s_mean * kappa_inf, - 1.0e-10, - ) - assert_allclose( - theo.compute_magnification(cosmo=cosmo, **cfg_inf["GAMMA_PARAMS"])[-5:], mu, 2.0e-8 - ) - cfg_inf["GAMMA_PARAMS"]["approx"] = "order2" - assert_allclose( - theo.compute_magnification(cosmo=cosmo, **cfg_inf["GAMMA_PARAMS"]), - 1 - + 2 * beta_s_mean * kappa_inf - + beta_s_square_mean * gammat_inf**2 - + 3 * beta_s_square_mean * kappa_inf**2, - 1.0e-10, - ) - assert_allclose( - theo.compute_magnification(cosmo=cosmo, **cfg_inf["GAMMA_PARAMS"])[-5:], mu, 2.0e-8 - ) - - # magnification bias - cfg_inf["GAMMA_PARAMS"]["approx"] = "order1" - assert_allclose( - theo.compute_magnification_bias(cosmo=cosmo, **cfg_inf["GAMMA_PARAMS"], alpha=alpha), - 1 + (alpha - 1) * (2 * beta_s_mean * kappa_inf), - 1.0e-10, - ) - assert_allclose( - theo.compute_magnification_bias(cosmo=cosmo, **cfg_inf["GAMMA_PARAMS"], alpha=alpha)[ - -5: - ], - mu_bias, - 4.0e-8, - ) - cfg_inf["GAMMA_PARAMS"]["approx"] = "order2" - assert_allclose( - theo.compute_magnification_bias(cosmo=cosmo, **cfg_inf["GAMMA_PARAMS"], alpha=alpha), - 1 - + (alpha - 1) * (2 * beta_s_mean * kappa_inf + beta_s_square_mean * gammat_inf**2) - + (2 * alpha - 1) * (alpha - 1) * beta_s_square_mean * kappa_inf**2, - 1.0e-10, - ) - assert_allclose( - theo.compute_magnification_bias(cosmo=cosmo, **cfg_inf["GAMMA_PARAMS"], alpha=alpha)[ - -5: - ], - mu_bias, - 4.0e-8, - ) # test errors and also prepare for the next round of tests - del cfg_inf["GAMMA_PARAMS"]["approx"] # test ValueError from unsupported approx assert_raises( ValueError, @@ -678,8 +576,6 @@ def test_shear_convergence_unittests(modeling_data, profile_init): approx="notvalid" ) # test KeyError from invalid key in integ_kwargs - cfg_inf["GAMMA_PARAMS"]["z_src_info"] = "distribution" - cfg_inf["GAMMA_PARAMS"]["z_source"] = chang2013 assert_raises( KeyError, theo.compute_reduced_tangential_shear, From f2585e43916d1a3ccae90d4a10edb14215baff7a Mon Sep 17 00:00:00 2001 From: m-aguena Date: Wed, 17 May 2023 11:48:25 +0200 Subject: [PATCH 18/38] rm unnecessary checks --- clmm/theory/parent_class.py | 6 ------ 1 file changed, 6 deletions(-) diff --git a/clmm/theory/parent_class.py b/clmm/theory/parent_class.py index aa9e8adeb..86b8a5c1c 100644 --- a/clmm/theory/parent_class.py +++ b/clmm/theory/parent_class.py @@ -1058,8 +1058,6 @@ def eval_reduced_tangential_shear( f" z_src_info='{z_src_info}' was provided." ) elif approx in ("order1", "order2"): - if z_src_info != "beta": - raise ValueError("z_src_info must be beta if approx!=None.") beta_s_mean = z_src[0] gammat_inf = self._eval_tangential_shear_core(r_proj, z_cl, z_src=self.z_inf) @@ -1224,8 +1222,6 @@ def eval_magnification( f" z_src_info='{z_src_info}' was provided." ) elif approx in ("order1", "order2"): - if z_src_info != "beta": - raise ValueError("z_src_info must be beta if approx!=None.") beta_s_mean = z_src[0] kappa_inf = self._eval_convergence_core(r_proj, z_cl, z_src=self.z_inf) @@ -1399,8 +1395,6 @@ def eval_magnification_bias( ) elif approx in ("order1", "order2"): - if z_src_info != "beta": - raise ValueError("z_src_info must be beta if approx!=None.") beta_s_mean = z_src[0] kappa_inf = self._eval_convergence_core(r_proj, z_cl, z_src=self.z_inf) From a03040890519bfb5db97e35b6d7f0076ea8d13f6 Mon Sep 17 00:00:00 2001 From: m-aguena Date: Wed, 17 May 2023 12:05:53 +0200 Subject: [PATCH 19/38] move all validation of theory cases to _validate_z_src --- clmm/theory/parent_class.py | 49 ++++++++++++++----------------------- 1 file changed, 19 insertions(+), 30 deletions(-) diff --git a/clmm/theory/parent_class.py b/clmm/theory/parent_class.py index 86b8a5c1c..a823fb5ed 100644 --- a/clmm/theory/parent_class.py +++ b/clmm/theory/parent_class.py @@ -753,8 +753,6 @@ def eval_tangential_shear(self, r_proj, z_cl, z_src, z_src_info="discrete", verb r_proj=r_proj, z_cl=z_cl, z_src=self.z_inf ) gammat = beta_s_mean * gammat_inf - else: - raise ValueError(f"Unsupported z_src_info (='{z_src_info}')") return gammat @@ -837,8 +835,6 @@ def eval_convergence(self, r_proj, z_cl, z_src, z_src_info="discrete", verbose=F beta_s_mean = z_src[0] kappa_inf = self._eval_convergence_core(r_proj=r_proj, z_cl=z_cl, z_src=self.z_inf) kappa = beta_s_mean * kappa_inf - else: - raise ValueError(f"Unsupported z_src_info (='{z_src_info}')") return kappa @@ -1052,11 +1048,6 @@ def eval_reduced_tangential_shear( "z_src", r_proj, ) - else: - raise ValueError( - "approx=None requires z_src_info='discrete' or 'distribution'," - f" z_src_info='{z_src_info}' was provided." - ) elif approx in ("order1", "order2"): beta_s_mean = z_src[0] @@ -1073,8 +1064,6 @@ def eval_reduced_tangential_shear( * beta_s_mean * kappa_inf ) - else: - raise ValueError(f"Unsupported approx (='{approx}')") return gt @@ -1216,11 +1205,6 @@ def eval_magnification( "z_src", r_proj, ) - else: - raise ValueError( - "approx=None requires z_src_info='discrete' or 'distribution'," - f" z_src_info='{z_src_info}' was provided." - ) elif approx in ("order1", "order2"): beta_s_mean = z_src[0] @@ -1234,8 +1218,6 @@ def eval_magnification( # Taylor expansion with up to second-order terms mu += 3 * beta_s_square_mean * kappa_inf**2 + beta_s_square_mean * gammat_inf**2 - else: - raise ValueError(f"Unsupported approx (='{approx}')") return mu def eval_magnification_bias( @@ -1388,11 +1370,6 @@ def eval_magnification_bias( r_proj, alpha=alpha, ) - else: - raise ValueError( - "approx=None requires z_src_info='discrete' or 'distribution'," - f" z_src_info='{z_src_info}' was provided." - ) elif approx in ("order1", "order2"): beta_s_mean = z_src[0] @@ -1409,8 +1386,6 @@ def eval_magnification_bias( 2 * alpha - 1 ) * (alpha - 1) * beta_s_square_mean * kappa_inf**2 - else: - raise ValueError(f"Unsupported approx (='{approx}')") return mu_bias @@ -1553,12 +1528,24 @@ def _validate_z_src(self, loc_dict): locals_dict: dict Should be the call locals() """ - if loc_dict.get("approx") and loc_dict["z_src_info"] != "beta": + # check compatility between approx and z_src_info + if "approx" in loc_dict: # if func has approx keyword approx, z_src_info = loc_dict["approx"], loc_dict["z_src_info"] - raise ValueError( - f"approx='{approx}' requires z_src_info='beta', " - f"z_src_info='{z_src_info}' was provided." - ) + if approx is None: + if z_src_info not in ("discrete", "distribution"): + raise ValueError( + "approx=None requires z_src_info='discrete' or 'distribution'," + f" z_src_info='{z_src_info}' was provided." + ) + elif approx in ("order1", "order2"): + if z_src_info != "beta": + raise ValueError( + f"approx='{approx}' requires z_src_info='beta', " + f"z_src_info='{z_src_info}' was provided." + ) + else: + raise ValueError(f"Unsupported approx (='{approx}')") + # check z_src_info type if loc_dict["z_src_info"] == "discrete": validate_argument(loc_dict, "z_src", "float_array", argmin=0) elif loc_dict["z_src_info"] == "distribution": @@ -1578,3 +1565,5 @@ def _validate_z_src(self, loc_dict): } validate_argument(beta_info, "beta_s_mean", "float_array") validate_argument(beta_info, "beta_s_square_mean", "float_array") + else: + raise ValueError(f"Unsupported z_src_info (='{loc_dict['z_src_info']}')") From e07a2266ad915796c4abd9b2775b0d92a4800999 Mon Sep 17 00:00:00 2001 From: m-aguena Date: Wed, 17 May 2023 15:43:10 +0200 Subject: [PATCH 20/38] create _validate_approx_z_src_info func --- clmm/theory/parent_class.py | 53 ++++++++++++++++++++++--------------- 1 file changed, 32 insertions(+), 21 deletions(-) diff --git a/clmm/theory/parent_class.py b/clmm/theory/parent_class.py index a823fb5ed..f3828fdca 100644 --- a/clmm/theory/parent_class.py +++ b/clmm/theory/parent_class.py @@ -1019,6 +1019,7 @@ def eval_reduced_tangential_shear( validate_argument(locals(), "z_cl", float, argmin=0) validate_argument(locals(), "z_src_info", str) validate_argument(locals(), "approx", str, none_ok=True) + self._validate_approx_z_src_info(locals()) self._validate_z_src(locals()) if self.halo_profile_model == "einasto" and verbose: @@ -1176,6 +1177,7 @@ def eval_magnification( validate_argument(locals(), "z_cl", float, argmin=0) validate_argument(locals(), "z_src_info", str) validate_argument(locals(), "approx", str, none_ok=True) + self._validate_approx_z_src_info(locals()) self._validate_z_src(locals()) if self.halo_profile_model == "einasto" and verbose: @@ -1339,6 +1341,7 @@ def eval_magnification_bias( validate_argument(locals(), "z_src_info", str) validate_argument(locals(), "alpha", "float_array") validate_argument(locals(), "approx", str, none_ok=True) + self._validate_approx_z_src_info(locals()) self._validate_z_src(locals()) if self.halo_profile_model == "einasto" and verbose: @@ -1386,7 +1389,6 @@ def eval_magnification_bias( 2 * alpha - 1 ) * (alpha - 1) * beta_s_square_mean * kappa_inf**2 - return mu_bias def eval_rdelta(self, z_cl): @@ -1521,31 +1523,11 @@ def _validate_z_src(self, loc_dict): * z_src_info='beta' : z_src must be a tuple containing ( :math:`\langle \beta_s \rangle, \langle \beta_s^2 \rangle`). - Also, if approx is provided and not None, z_src_info must be 'distribution' or 'beta'. - Parameters ---------- locals_dict: dict Should be the call locals() """ - # check compatility between approx and z_src_info - if "approx" in loc_dict: # if func has approx keyword - approx, z_src_info = loc_dict["approx"], loc_dict["z_src_info"] - if approx is None: - if z_src_info not in ("discrete", "distribution"): - raise ValueError( - "approx=None requires z_src_info='discrete' or 'distribution'," - f" z_src_info='{z_src_info}' was provided." - ) - elif approx in ("order1", "order2"): - if z_src_info != "beta": - raise ValueError( - f"approx='{approx}' requires z_src_info='beta', " - f"z_src_info='{z_src_info}' was provided." - ) - else: - raise ValueError(f"Unsupported approx (='{approx}')") - # check z_src_info type if loc_dict["z_src_info"] == "discrete": validate_argument(loc_dict, "z_src", "float_array", argmin=0) elif loc_dict["z_src_info"] == "distribution": @@ -1567,3 +1549,32 @@ def _validate_z_src(self, loc_dict): validate_argument(beta_info, "beta_s_square_mean", "float_array") else: raise ValueError(f"Unsupported z_src_info (='{loc_dict['z_src_info']}')") + + def _validate_approx_z_src_info(self, loc_dict): + r"""Validation for compatility between approx and z_src_info. The conditions are: + + * approx=None: z_src_info must be 'discrete' or 'distribution' + * approx='order1' or 'order2': z_src_info must be 'beta' + * approx=other: raises error + + Parameters + ---------- + locals_dict: dict + Should be the call locals() + """ + # check compatility between approx and z_src_info + z_src_info, approx = loc_dict["z_src_info"], loc_dict["approx"] + if approx is None: + if z_src_info not in ("discrete", "distribution"): + raise ValueError( + "approx=None requires z_src_info='discrete' or 'distribution'," + f" z_src_info='{z_src_info}' was provided." + ) + elif approx in ("order1", "order2"): + if z_src_info != "beta": + raise ValueError( + f"approx='{approx}' requires z_src_info='beta', " + f"z_src_info='{z_src_info}' was provided." + ) + else: + raise ValueError(f"Unsupported approx (='{approx}')") From 0a88ad215b3fb67e5f6030d35871fa62b5febac4 Mon Sep 17 00:00:00 2001 From: eduardojsbarroso Date: Mon, 26 Jun 2023 11:54:51 +0200 Subject: [PATCH 21/38] Updating notebook --- clmm/theory/parent_class.py | 5 +- ...mo_theory_functionality_diff_z_types.ipynb | 360 ++++++++++++------ 2 files changed, 254 insertions(+), 111 deletions(-) diff --git a/clmm/theory/parent_class.py b/clmm/theory/parent_class.py index f3828fdca..e5515f611 100644 --- a/clmm/theory/parent_class.py +++ b/clmm/theory/parent_class.py @@ -723,6 +723,7 @@ def eval_tangential_shear(self, r_proj, z_cl, z_src, z_src_info="discrete", verb numpy.ndarray, float tangential shear """ + if self.validate_input: validate_argument(locals(), "r_proj", "float_array", argmin=0) validate_argument(locals(), "z_cl", float, argmin=0) @@ -731,7 +732,7 @@ def eval_tangential_shear(self, r_proj, z_cl, z_src, z_src_info="discrete", verb if self.halo_profile_model == "einasto" and verbose: print(f"Einasto alpha = {self._get_einasto_alpha(z_cl=z_cl)}") - + gammat = None if z_src_info == "discrete": warning_msg = ( "\nSome source redshifts are lower than the cluster redshift." @@ -754,6 +755,8 @@ def eval_tangential_shear(self, r_proj, z_cl, z_src, z_src_info="discrete", verb ) gammat = beta_s_mean * gammat_inf + print("test") + gammat = 0 return gammat def eval_convergence(self, r_proj, z_cl, z_src, z_src_info="discrete", verbose=False): diff --git a/examples/demo_theory_functionality_diff_z_types.ipynb b/examples/demo_theory_functionality_diff_z_types.ipynb index fd50854f8..1e383048b 100644 --- a/examples/demo_theory_functionality_diff_z_types.ipynb +++ b/examples/demo_theory_functionality_diff_z_types.ipynb @@ -24,7 +24,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -34,12 +34,12 @@ "import os\n", "\n", "## Uncomment the following line if you want to use a specific modeling backend among 'ct' (cluster-toolkit), 'ccl' (CCL) or 'nc' (Numcosmo). Default is 'ccl'\n", - "# os.environ['CLMM_MODELING_BACKEND'] = 'nc'" + "#os.environ['CLMM_MODELING_BACKEND'] = 'nc'" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ @@ -53,7 +53,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ @@ -71,9 +71,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "'1.8.1'" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "clmm.__version__" ] @@ -87,7 +98,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ @@ -105,7 +116,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ @@ -121,7 +132,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [ @@ -172,7 +183,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ @@ -203,7 +214,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ @@ -213,13 +224,38 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\langle\\beta_s\\rangle = 0.440$" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/latex": [ + "$\\displaystyle \\langle\\beta_s^2\\rangle = 0.220$" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "z_inf = 1000\n", "\n", - "beta_s_mean = clmm.utils.compute_beta_s_mean(\n", + "beta_s_mean = clmm.utils.beta_lens.compute_beta_s_mean_from_distribution(\n", " cluster_z,\n", " z_inf,\n", " cosmo,\n", @@ -228,7 +264,7 @@ " zmin=None,\n", " z_distrib_func=model_z_distrib_dict[\"func\"],\n", ")\n", - "beta_s_square_mean = clmm.utils.compute_beta_s_square_mean(\n", + "beta_s_square_mean = clmm.utils.beta_lens.compute_beta_s_square_mean_from_distribution(\n", " cluster_z,\n", " z_inf,\n", " cosmo,\n", @@ -251,9 +287,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "z = np.linspace(0, zsrc_max, 1000)\n", "\n", @@ -311,7 +368,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "metadata": {}, "outputs": [], "source": [ @@ -320,16 +377,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 36, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(array([0.00218744, 0.00176588, 0.00042673, ..., 0.00224765, 0.00186142,\n", + " 0.00032859]),\n", + " array([0.00898515, 0.01455188, 0.086497 , ..., 0.00915508, 0.0164856 ,\n", + " 0.13692621]),\n", + " array([-4.77048956e-18, -7.80625564e-18, -3.46944695e-17, ...,\n", + " -5.20417043e-18, -1.12757026e-17, -6.93889390e-17]))" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "gc_object.compute_tangential_and_cross_components()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 37, "metadata": {}, "outputs": [], "source": [ @@ -346,7 +419,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 38, "metadata": {}, "outputs": [], "source": [ @@ -372,9 +445,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 39, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 2.16 s, sys: 169 ms, total: 2.33 s\n", + "Wall time: 2.33 s\n" + ] + } + ], "source": [ "%%time\n", "# in case we know the discrete source redshift, we can compute the reduced shear for each source galaxy\n", @@ -418,9 +500,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 40, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 553 ms, sys: 6.02 ms, total: 559 ms\n", + "Wall time: 558 ms\n" + ] + } + ], "source": [ "%%time\n", "gt_distribution_no_approx = clmm.theory.compute_reduced_tangential_shear(\n", @@ -433,7 +524,6 @@ " delta_mdef=500,\n", " massdef=\"critical\",\n", " z_src_info=\"distribution\",\n", - " beta_kwargs={\"zmax\": zsrc_max},\n", " approx=None,\n", ")" ] @@ -442,65 +532,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Cases 3 : Redshift distribution and approximation" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If we want a faster approach we can use an approximation for the reduced shear, using 1 or 2 order of Taylor expansion for the expression of the reduced shear." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "%%time\n", - "gt_distribution_order1 = clmm.theory.compute_reduced_tangential_shear(\n", - " rr,\n", - " cluster_m,\n", - " concentration,\n", - " cluster_z,\n", - " model_z_distrib_dict[\"func\"],\n", - " cosmo,\n", - " delta_mdef=500,\n", - " massdef=\"critical\",\n", - " z_src_info=\"distribution\",\n", - " beta_kwargs={\"zmax\": zsrc_max},\n", - " approx=\"order1\",\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "%%time\n", - "gt_distribution_order2 = clmm.theory.compute_reduced_tangential_shear(\n", - " rr,\n", - " cluster_m,\n", - " concentration,\n", - " cluster_z,\n", - " model_z_distrib_dict[\"func\"],\n", - " cosmo,\n", - " delta_mdef=500,\n", - " massdef=\"critical\",\n", - " z_src_info=\"distribution\",\n", - " beta_kwargs={\"zmax\": zsrc_max},\n", - " approx=\"order2\",\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Cases 4 : Mean lensing efficiencies and approximation" + "#### Cases 3 : Mean lensing efficiencies and approximation" ] }, { @@ -513,9 +545,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 41, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 1.26 ms, sys: 905 µs, total: 2.16 ms\n", + "Wall time: 1.73 ms\n" + ] + } + ], "source": [ "%%time\n", "gt_beta_1 = clmm.theory.compute_reduced_tangential_shear(\n", @@ -528,16 +569,24 @@ " delta_mdef=500,\n", " massdef=\"critical\",\n", " z_src_info=\"beta\",\n", - " beta_kwargs={\"zmax\": zsrc_max},\n", - " approx=\"order1\",\n", + " approx=\"order1\"\n", ")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 42, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 1.17 ms, sys: 21 µs, total: 1.19 ms\n", + "Wall time: 1.12 ms\n" + ] + } + ], "source": [ "%%time\n", "gt_beta_2 = clmm.theory.compute_reduced_tangential_shear(\n", @@ -550,8 +599,7 @@ " delta_mdef=500,\n", " massdef=\"critical\",\n", " z_src_info=\"beta\",\n", - " beta_kwargs={\"zmax\": zsrc_max},\n", - " approx=\"order2\",\n", + " approx=\"order2\"\n", ")" ] }, @@ -559,12 +607,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 3 - Comparison of the four cases for the reduced tangnetial shear" + "## 3 - Comparison of the three cases for the reduced tangnetial shear" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 43, "metadata": {}, "outputs": [], "source": [ @@ -594,17 +642,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 44, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plot_cases(\n", " rr,\n", " base=(gt_discrete, \"k.-\", dict(label=\"discrete\")),\n", " others=(\n", " (gt_distribution_no_approx, \"r.-\", dict(label=\"distribution, no approx\")),\n", - " (gt_distribution_order1, \"ro-\", dict(label=\"distribution, order 1 approx\")),\n", - " (gt_distribution_order2, \"rd-\", dict(label=\"distribution, order 2 approx\")),\n", " (gt_beta_1, \"b--\", dict(label=\"beta, order 1 approx\")),\n", " (gt_beta_2, \"bx-\", dict(label=\"beta, order 2 approx\")),\n", " ),\n", @@ -633,14 +690,28 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Here we will just compute models for cases 1, 2 and 4. For the shear and convergence there is no need for an approximated formula. " + "Here we will just compute models for cases 1, 2 and 3. For the shear and convergence there is no need for an approximated formula. " ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 45, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "UnboundLocalError", + "evalue": "cannot access local variable 'gammat' where it is not associated with a value", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mUnboundLocalError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[45], line 20\u001b[0m\n\u001b[1;32m 1\u001b[0m gammat_discrete \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marray(\n\u001b[1;32m 2\u001b[0m [\n\u001b[1;32m 3\u001b[0m np\u001b[38;5;241m.\u001b[39mmean(\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 17\u001b[0m ]\n\u001b[1;32m 18\u001b[0m )\n\u001b[0;32m---> 20\u001b[0m gammat_distribution \u001b[38;5;241m=\u001b[39m \u001b[43mclmm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtheory\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcompute_tangential_shear\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 21\u001b[0m \u001b[43m \u001b[49m\u001b[43mrr\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 22\u001b[0m \u001b[43m \u001b[49m\u001b[43mcluster_m\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 23\u001b[0m \u001b[43m \u001b[49m\u001b[43mconcentration\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 24\u001b[0m \u001b[43m \u001b[49m\u001b[43mcluster_z\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 25\u001b[0m \u001b[43m \u001b[49m\u001b[43mmodel_z_distrib_dict\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mfunc\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 26\u001b[0m \u001b[43m \u001b[49m\u001b[43mcosmo\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 27\u001b[0m \u001b[43m \u001b[49m\u001b[43mdelta_mdef\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m500\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 28\u001b[0m \u001b[43m \u001b[49m\u001b[43mmassdef\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mcritical\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 29\u001b[0m \u001b[43m \u001b[49m\u001b[43mz_src_info\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mdistribution\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 30\u001b[0m \u001b[43m \u001b[49m\u001b[43mvalidate_input\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\n\u001b[1;32m 31\u001b[0m \u001b[43m)\u001b[49m\n\u001b[1;32m 33\u001b[0m gammat_beta \u001b[38;5;241m=\u001b[39m clmm\u001b[38;5;241m.\u001b[39mtheory\u001b[38;5;241m.\u001b[39mcompute_tangential_shear(\n\u001b[1;32m 34\u001b[0m rr,\n\u001b[1;32m 35\u001b[0m cluster_m,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 42\u001b[0m z_src_info\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbeta\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 43\u001b[0m )\n", + "File \u001b[0;32m~/.local/lib/python3.11/site-packages/clmm/theory/func_layer.py:637\u001b[0m, in \u001b[0;36mcompute_tangential_shear\u001b[0;34m(r_proj, mdelta, cdelta, z_cluster, z_source, cosmo, delta_mdef, halo_profile_model, massdef, alpha_ein, z_src_info, verbose, validate_input)\u001b[0m\n\u001b[1;32m 631\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m np\u001b[38;5;241m.\u001b[39mmin(r_proj) \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m1.0e-11\u001b[39m:\n\u001b[1;32m 632\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 633\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mRmin = \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mnp\u001b[38;5;241m.\u001b[39mmin(r_proj)\u001b[38;5;132;01m:\u001b[39;00m\u001b[38;5;124m.2e\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m Mpc/h! This value is too small \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 634\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mand may cause computational issues.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 635\u001b[0m )\n\u001b[0;32m--> 637\u001b[0m tangential_shear \u001b[38;5;241m=\u001b[39m \u001b[43m_modeling_object\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43meval_tangential_shear\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 638\u001b[0m \u001b[43m \u001b[49m\u001b[43mr_proj\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 639\u001b[0m \u001b[43m \u001b[49m\u001b[43mz_cluster\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 640\u001b[0m \u001b[43m \u001b[49m\u001b[43mz_source\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 641\u001b[0m \u001b[43m \u001b[49m\u001b[43mz_src_info\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mz_src_info\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 642\u001b[0m \u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 643\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 645\u001b[0m _modeling_object\u001b[38;5;241m.\u001b[39mvalidate_input \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[1;32m 646\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m tangential_shear\n", + "File \u001b[0;32m~/.local/lib/python3.11/site-packages/clmm/theory/parent_class.py:757\u001b[0m, in \u001b[0;36mCLMModeling.eval_tangential_shear\u001b[0;34m(self, r_proj, z_cl, z_src, z_src_info, verbose)\u001b[0m\n\u001b[1;32m 752\u001b[0m gammat_inf \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_eval_tangential_shear_core(\n\u001b[1;32m 753\u001b[0m r_proj\u001b[38;5;241m=\u001b[39mr_proj, z_cl\u001b[38;5;241m=\u001b[39mz_cl, z_src\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mz_inf\n\u001b[1;32m 754\u001b[0m )\n\u001b[1;32m 755\u001b[0m gammat \u001b[38;5;241m=\u001b[39m beta_s_mean \u001b[38;5;241m*\u001b[39m gammat_inf\n\u001b[0;32m--> 757\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mgammat\u001b[49m\n", + "\u001b[0;31mUnboundLocalError\u001b[0m: cannot access local variable 'gammat' where it is not associated with a value" + ] + } + ], "source": [ "gammat_discrete = np.array(\n", " [\n", @@ -654,7 +725,7 @@ " cosmo,\n", " delta_mdef=500,\n", " massdef=\"critical\",\n", - " z_src_info=\"discrete\",\n", + " z_src_info=\"discrete\"\n", " )\n", " )\n", " for _r in rr\n", @@ -671,7 +742,7 @@ " delta_mdef=500,\n", " massdef=\"critical\",\n", " z_src_info=\"distribution\",\n", - " beta_kwargs={\"zmax\": zsrc_max},\n", + " validate_input=False\n", ")\n", "\n", "gammat_beta = clmm.theory.compute_tangential_shear(\n", @@ -683,8 +754,7 @@ " cosmo,\n", " delta_mdef=500,\n", " massdef=\"critical\",\n", - " z_src_info=\"beta\",\n", - " beta_kwargs={\"zmax\": zsrc_max},\n", + " z_src_info=\"beta\"\n", ")" ] }, @@ -958,14 +1028,84 @@ "source": [ "When making approximation, there may be large differences (~few 10% level) in the inner regions (compare to when using the exact redshift of the sources), especially for magnification and magnification bias. However, these approaches are very fast to compute. The user as to chose the appropriate method depending on the use case." ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "anaconda-cloud": {}, "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python (firecrown2.0)", "language": "python", - "name": "python3" + "name": "firecrown" }, "language_info": { "codemirror_mode": { @@ -977,7 +1117,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.6" + "version": "3.11.0" } }, "nbformat": 4, From 34dd89f8633ed2764a1e0fe3aa5bbfb6f0b82277 Mon Sep 17 00:00:00 2001 From: eduardojsbarroso Date: Mon, 26 Jun 2023 13:44:22 +0200 Subject: [PATCH 22/38] Finished updating notebook --- clmm/theory/parent_class.py | 2 - ...mo_theory_functionality_diff_z_types.ipynb | 338 ++---------------- 2 files changed, 37 insertions(+), 303 deletions(-) diff --git a/clmm/theory/parent_class.py b/clmm/theory/parent_class.py index e5515f611..6c7a9196a 100644 --- a/clmm/theory/parent_class.py +++ b/clmm/theory/parent_class.py @@ -755,8 +755,6 @@ def eval_tangential_shear(self, r_proj, z_cl, z_src, z_src_info="discrete", verb ) gammat = beta_s_mean * gammat_inf - print("test") - gammat = 0 return gammat def eval_convergence(self, r_proj, z_cl, z_src, z_src_info="discrete", verbose=False): diff --git a/examples/demo_theory_functionality_diff_z_types.ipynb b/examples/demo_theory_functionality_diff_z_types.ipynb index 1e383048b..e4c48128a 100644 --- a/examples/demo_theory_functionality_diff_z_types.ipynb +++ b/examples/demo_theory_functionality_diff_z_types.ipynb @@ -24,7 +24,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -39,7 +39,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -53,7 +53,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -71,20 +71,9 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'1.8.1'" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "clmm.__version__" ] @@ -98,7 +87,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -116,7 +105,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -132,7 +121,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -183,7 +172,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -214,7 +203,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -224,34 +213,9 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/latex": [ - "$\\displaystyle \\langle\\beta_s\\rangle = 0.440$" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/latex": [ - "$\\displaystyle \\langle\\beta_s^2\\rangle = 0.220$" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "z_inf = 1000\n", "\n", @@ -287,30 +251,9 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "z = np.linspace(0, zsrc_max, 1000)\n", "\n", @@ -368,7 +311,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -377,32 +320,16 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(array([0.00218744, 0.00176588, 0.00042673, ..., 0.00224765, 0.00186142,\n", - " 0.00032859]),\n", - " array([0.00898515, 0.01455188, 0.086497 , ..., 0.00915508, 0.0164856 ,\n", - " 0.13692621]),\n", - " array([-4.77048956e-18, -7.80625564e-18, -3.46944695e-17, ...,\n", - " -5.20417043e-18, -1.12757026e-17, -6.93889390e-17]))" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "gc_object.compute_tangential_and_cross_components()" ] }, { "cell_type": "code", - "execution_count": 37, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -419,7 +346,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -445,18 +372,9 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 2.16 s, sys: 169 ms, total: 2.33 s\n", - "Wall time: 2.33 s\n" - ] - } - ], + "outputs": [], "source": [ "%%time\n", "# in case we know the discrete source redshift, we can compute the reduced shear for each source galaxy\n", @@ -500,18 +418,9 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 553 ms, sys: 6.02 ms, total: 559 ms\n", - "Wall time: 558 ms\n" - ] - } - ], + "outputs": [], "source": [ "%%time\n", "gt_distribution_no_approx = clmm.theory.compute_reduced_tangential_shear(\n", @@ -545,18 +454,9 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 1.26 ms, sys: 905 µs, total: 2.16 ms\n", - "Wall time: 1.73 ms\n" - ] - } - ], + "outputs": [], "source": [ "%%time\n", "gt_beta_1 = clmm.theory.compute_reduced_tangential_shear(\n", @@ -575,18 +475,9 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 1.17 ms, sys: 21 µs, total: 1.19 ms\n", - "Wall time: 1.12 ms\n" - ] - } - ], + "outputs": [], "source": [ "%%time\n", "gt_beta_2 = clmm.theory.compute_reduced_tangential_shear(\n", @@ -612,7 +503,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -642,20 +533,9 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plot_cases(\n", " rr,\n", @@ -695,23 +575,9 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "ename": "UnboundLocalError", - "evalue": "cannot access local variable 'gammat' where it is not associated with a value", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mUnboundLocalError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[45], line 20\u001b[0m\n\u001b[1;32m 1\u001b[0m gammat_discrete \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marray(\n\u001b[1;32m 2\u001b[0m [\n\u001b[1;32m 3\u001b[0m np\u001b[38;5;241m.\u001b[39mmean(\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 17\u001b[0m ]\n\u001b[1;32m 18\u001b[0m )\n\u001b[0;32m---> 20\u001b[0m gammat_distribution \u001b[38;5;241m=\u001b[39m \u001b[43mclmm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtheory\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcompute_tangential_shear\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 21\u001b[0m \u001b[43m \u001b[49m\u001b[43mrr\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 22\u001b[0m \u001b[43m \u001b[49m\u001b[43mcluster_m\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 23\u001b[0m \u001b[43m \u001b[49m\u001b[43mconcentration\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 24\u001b[0m \u001b[43m \u001b[49m\u001b[43mcluster_z\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 25\u001b[0m \u001b[43m \u001b[49m\u001b[43mmodel_z_distrib_dict\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mfunc\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 26\u001b[0m \u001b[43m \u001b[49m\u001b[43mcosmo\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 27\u001b[0m \u001b[43m \u001b[49m\u001b[43mdelta_mdef\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m500\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 28\u001b[0m \u001b[43m \u001b[49m\u001b[43mmassdef\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mcritical\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 29\u001b[0m \u001b[43m \u001b[49m\u001b[43mz_src_info\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mdistribution\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 30\u001b[0m \u001b[43m \u001b[49m\u001b[43mvalidate_input\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\n\u001b[1;32m 31\u001b[0m \u001b[43m)\u001b[49m\n\u001b[1;32m 33\u001b[0m gammat_beta \u001b[38;5;241m=\u001b[39m clmm\u001b[38;5;241m.\u001b[39mtheory\u001b[38;5;241m.\u001b[39mcompute_tangential_shear(\n\u001b[1;32m 34\u001b[0m rr,\n\u001b[1;32m 35\u001b[0m cluster_m,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 42\u001b[0m z_src_info\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbeta\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 43\u001b[0m )\n", - "File \u001b[0;32m~/.local/lib/python3.11/site-packages/clmm/theory/func_layer.py:637\u001b[0m, in \u001b[0;36mcompute_tangential_shear\u001b[0;34m(r_proj, mdelta, cdelta, z_cluster, z_source, cosmo, delta_mdef, halo_profile_model, massdef, alpha_ein, z_src_info, verbose, validate_input)\u001b[0m\n\u001b[1;32m 631\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m np\u001b[38;5;241m.\u001b[39mmin(r_proj) \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m1.0e-11\u001b[39m:\n\u001b[1;32m 632\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 633\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mRmin = \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mnp\u001b[38;5;241m.\u001b[39mmin(r_proj)\u001b[38;5;132;01m:\u001b[39;00m\u001b[38;5;124m.2e\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m Mpc/h! This value is too small \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 634\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mand may cause computational issues.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 635\u001b[0m )\n\u001b[0;32m--> 637\u001b[0m tangential_shear \u001b[38;5;241m=\u001b[39m \u001b[43m_modeling_object\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43meval_tangential_shear\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 638\u001b[0m \u001b[43m \u001b[49m\u001b[43mr_proj\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 639\u001b[0m \u001b[43m \u001b[49m\u001b[43mz_cluster\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 640\u001b[0m \u001b[43m \u001b[49m\u001b[43mz_source\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 641\u001b[0m \u001b[43m \u001b[49m\u001b[43mz_src_info\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mz_src_info\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 642\u001b[0m \u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 643\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 645\u001b[0m _modeling_object\u001b[38;5;241m.\u001b[39mvalidate_input \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[1;32m 646\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m tangential_shear\n", - "File \u001b[0;32m~/.local/lib/python3.11/site-packages/clmm/theory/parent_class.py:757\u001b[0m, in \u001b[0;36mCLMModeling.eval_tangential_shear\u001b[0;34m(self, r_proj, z_cl, z_src, z_src_info, verbose)\u001b[0m\n\u001b[1;32m 752\u001b[0m gammat_inf \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_eval_tangential_shear_core(\n\u001b[1;32m 753\u001b[0m r_proj\u001b[38;5;241m=\u001b[39mr_proj, z_cl\u001b[38;5;241m=\u001b[39mz_cl, z_src\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mz_inf\n\u001b[1;32m 754\u001b[0m )\n\u001b[1;32m 755\u001b[0m gammat \u001b[38;5;241m=\u001b[39m beta_s_mean \u001b[38;5;241m*\u001b[39m gammat_inf\n\u001b[0;32m--> 757\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mgammat\u001b[49m\n", - "\u001b[0;31mUnboundLocalError\u001b[0m: cannot access local variable 'gammat' where it is not associated with a value" - ] - } - ], + "outputs": [], "source": [ "gammat_discrete = np.array(\n", " [\n", @@ -732,18 +598,6 @@ " ]\n", ")\n", "\n", - "gammat_distribution = clmm.theory.compute_tangential_shear(\n", - " rr,\n", - " cluster_m,\n", - " concentration,\n", - " cluster_z,\n", - " model_z_distrib_dict[\"func\"],\n", - " cosmo,\n", - " delta_mdef=500,\n", - " massdef=\"critical\",\n", - " z_src_info=\"distribution\",\n", - " validate_input=False\n", - ")\n", "\n", "gammat_beta = clmm.theory.compute_tangential_shear(\n", " rr,\n", @@ -768,7 +622,6 @@ " rr,\n", " base=(gammat_discrete, \"k.-\", dict(label=\"discrete\")),\n", " others=(\n", - " (gammat_distribution, \"rx-\", dict(label=\"distribution, no approx\")),\n", " (gammat_beta, \"b--\", dict(label=\"beta, no approx\")),\n", " ),\n", " ylabel=\"$\\gamma_t$\",\n", @@ -800,18 +653,6 @@ " ]\n", ")\n", "\n", - "kappa_distribution = clmm.theory.compute_convergence(\n", - " rr,\n", - " cluster_m,\n", - " concentration,\n", - " cluster_z,\n", - " model_z_distrib_dict[\"func\"],\n", - " cosmo,\n", - " delta_mdef=500,\n", - " massdef=\"critical\",\n", - " z_src_info=\"distribution\",\n", - " beta_kwargs={\"zmax\": zsrc_max},\n", - ")\n", "\n", "kappa_beta = clmm.theory.compute_convergence(\n", " rr,\n", @@ -822,8 +663,7 @@ " cosmo,\n", " delta_mdef=500,\n", " massdef=\"critical\",\n", - " z_src_info=\"beta\",\n", - " beta_kwargs={\"zmax\": zsrc_max},\n", + " z_src_info=\"beta\"\n", ")" ] }, @@ -837,7 +677,6 @@ " rr,\n", " base=(kappa_discrete, \"k.-\", dict(label=\"discrete\")),\n", " others=(\n", - " (kappa_distribution, \"rx-\", dict(label=\"distribution, no approx\")),\n", " (kappa_beta, \"b--\", dict(label=\"beta, no approx\")),\n", " ),\n", " ylabel=\"$\\kappa_t$\",\n", @@ -869,19 +708,6 @@ " ]\n", ")\n", "\n", - "mu_distribution = clmm.theory.compute_magnification(\n", - " rr,\n", - " cluster_m,\n", - " concentration,\n", - " cluster_z,\n", - " model_z_distrib_dict[\"func\"],\n", - " cosmo,\n", - " delta_mdef=500,\n", - " massdef=\"critical\",\n", - " z_src_info=\"distribution\",\n", - " approx=None,\n", - " beta_kwargs={\"zmax\": zsrc_max},\n", - ")\n", "\n", "mu_beta_1 = clmm.theory.compute_magnification(\n", " rr,\n", @@ -893,8 +719,7 @@ " delta_mdef=500,\n", " massdef=\"critical\",\n", " z_src_info=\"beta\",\n", - " approx=\"order1\",\n", - " beta_kwargs={\"zmax\": zsrc_max},\n", + " approx=\"order1\"\n", ")\n", "\n", "mu_beta_2 = clmm.theory.compute_magnification(\n", @@ -907,8 +732,7 @@ " delta_mdef=500,\n", " massdef=\"critical\",\n", " z_src_info=\"beta\",\n", - " approx=\"order2\",\n", - " beta_kwargs={\"zmax\": zsrc_max},\n", + " approx=\"order2\"\n", ")" ] }, @@ -922,7 +746,6 @@ " rr,\n", " base=(mu_discrete, \"k.-\", dict(label=\"discrete\")),\n", " others=(\n", - " (mu_distribution, \"rs-\", dict(label=\"distribution, no approx\")),\n", " (mu_beta_1, \"bx-\", dict(label=\"beta, order 1 approx\")),\n", " (mu_beta_2, \"b--\", dict(label=\"beta, order 2 approx\")),\n", " ),\n", @@ -958,20 +781,6 @@ " ]\n", ")\n", "\n", - "mu_bias_distribution = clmm.theory.compute_magnification_bias(\n", - " rr,\n", - " alpha,\n", - " cluster_m,\n", - " concentration,\n", - " cluster_z,\n", - " model_z_distrib_dict[\"func\"],\n", - " cosmo,\n", - " delta_mdef=500,\n", - " massdef=\"critical\",\n", - " z_src_info=\"distribution\",\n", - " approx=None,\n", - " beta_kwargs={\"zmax\": zsrc_max},\n", - ")\n", "\n", "mu_bias_beta_1 = clmm.theory.compute_magnification_bias(\n", " rr,\n", @@ -984,8 +793,7 @@ " delta_mdef=500,\n", " massdef=\"critical\",\n", " z_src_info=\"beta\",\n", - " approx=\"order1\",\n", - " beta_kwargs={\"zmax\": zsrc_max},\n", + " approx=\"order1\"\n", ")\n", "\n", "mu_bias_beta_2 = clmm.theory.compute_magnification_bias(\n", @@ -999,8 +807,7 @@ " delta_mdef=500,\n", " massdef=\"critical\",\n", " z_src_info=\"beta\",\n", - " approx=\"order2\",\n", - " beta_kwargs={\"zmax\": zsrc_max},\n", + " approx=\"order2\"\n", ")" ] }, @@ -1014,7 +821,6 @@ " rr,\n", " base=(mu_bias_discrete, \"k.-\", dict(label=\"discrete\")),\n", " others=(\n", - " (mu_bias_distribution, \"rs-\", dict(label=\"distribution, no approx\")),\n", " (mu_bias_beta_1, \"bx-\", dict(label=\"beta, order 1 approx\")),\n", " (mu_bias_beta_2, \"b--\", dict(label=\"beta, order 2 approx\")),\n", " ),\n", @@ -1028,76 +834,6 @@ "source": [ "When making approximation, there may be large differences (~few 10% level) in the inner regions (compare to when using the exact redshift of the sources), especially for magnification and magnification bias. However, these approaches are very fast to compute. The user as to chose the appropriate method depending on the use case." ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From 01a0e9095e32b0b63d7d8d74158aca6e27d56d0d Mon Sep 17 00:00:00 2001 From: eduardojsbarroso Date: Tue, 27 Jun 2023 15:52:21 +0200 Subject: [PATCH 23/38] Added description in notebook --- examples/demo_theory_functionality_diff_z_types.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/examples/demo_theory_functionality_diff_z_types.ipynb b/examples/demo_theory_functionality_diff_z_types.ipynb index e4c48128a..afc536658 100644 --- a/examples/demo_theory_functionality_diff_z_types.ipynb +++ b/examples/demo_theory_functionality_diff_z_types.ipynb @@ -449,7 +449,7 @@ "metadata": {}, "source": [ "Finally, we can also model the reduced shear if the only information we have about the source redshift distribution is through the mean lensing efficiency parameters $\\langle\\beta_s\\rangle$ and $\\langle\\beta_s^2\\rangle$. \\\n", - "In this case, we need to use an approximation for the formula. This is the fastest approach." + "In this case, we need to use an approximation for the formula. This is the fastest approach. Bear in mind that the user has to pre compute the beta parameters and pass them as an argument of the function." ] }, { @@ -556,7 +556,7 @@ "source": [ "All modeled profiles give similar results. They do not correspond to the profile computed from the data in the inner part, because of different ways of constructing the profiles (taking the average radial point and reduced shear value in a bin or computing the average expected reduced shear at a given radius).\n", "\n", - "The profiles computed using an approximation for the reduced shear formula are lower by a few percents, especially in the inner region. The profiles computed from a redshift distribution or a known source redshift differ at the subpercent level." + "The profiles computed using an approximation for the reduced shear formula are lower by a few percents, especially in the inner region. The profile computed from a redshift distribution differs at the subpercent level." ] }, { From 835fdcc444216418bc4f2cd9b46d426bb27c7112 Mon Sep 17 00:00:00 2001 From: m-aguena Date: Wed, 12 Jul 2023 16:50:05 +0200 Subject: [PATCH 24/38] make compute_beta more efficient and fix shape_weights=None in compute_beta_s_mean*_from_weights --- clmm/utils/beta_lens.py | 33 +++++---------------------------- 1 file changed, 5 insertions(+), 28 deletions(-) diff --git a/clmm/utils/beta_lens.py b/clmm/utils/beta_lens.py index 8447491c0..a144460ee 100644 --- a/clmm/utils/beta_lens.py +++ b/clmm/utils/beta_lens.py @@ -5,31 +5,6 @@ from ..redshift import distributions as zdist -def _compute_beta(z_src, z_cl, cosmo): - r"""Geometric lensing efficicency - - .. math:: - \beta = max(0, D_{a,\ ls}/D_{a,\ s}) - - Eq.2 in https://arxiv.org/pdf/1611.03866.pdf - - Parameters - ---------- - z_src : float - Source galaxy redshift - z_cl: float - Galaxy cluster redshift - cosmo: clmm.Cosmology - CLMM Cosmology object - - Returns - ------- - float - Geometric lensing efficicency - """ - return np.heaviside(z_src - z_cl, 0) * cosmo.eval_da_z1z2(z_cl, z_src) / cosmo.eval_da(z_src) - - def compute_beta(z_src, z_cl, cosmo): r"""Geometric lensing efficicency @@ -52,9 +27,7 @@ def compute_beta(z_src, z_cl, cosmo): float, array Geometric lensing efficicency """ - if hasattr(z_src, "__len__"): - return np.array([_compute_beta(z_src_i, z_cl, cosmo) for z_src_i in z_src]) - return _compute_beta(z_src, z_cl, cosmo) + return np.heaviside(z_src - z_cl, 0) * cosmo.eval_da_z1z2(z_cl, z_src) / cosmo.eval_da(z_src) def compute_beta_s(z_src, z_cl, z_inf, cosmo): @@ -237,6 +210,8 @@ def compute_beta_s_mean_from_weights(z_src, z_cl, z_inf, cosmo, shape_weights): float Mean value of the geometric lensing efficicency ratio. """ + if shape_weights is None: + shape_weights = z_src * 0 + 1 try: if len(z_src) != len(shape_weights): raise ValueError("The source redshifts and the weights array must be the same size.") @@ -279,6 +254,8 @@ def compute_beta_s_square_mean_from_weights( float Mean square value of the geometric lensing efficicency ratio. """ + if shape_weights is None: + shape_weights = z_src * 0 + 1 try: if len(z_src) != len(shape_weights): raise ValueError("The source redshifts and the weights array must be the same size.") From ef1168185e8060df5b529e4e5cdba9becb0d1d32 Mon Sep 17 00:00:00 2001 From: m-aguena Date: Wed, 12 Jul 2023 17:34:55 +0200 Subject: [PATCH 25/38] improve compute_beta_s*_mean_from_weights --- clmm/utils/beta_lens.py | 39 ++++++++++++++++----------------------- 1 file changed, 16 insertions(+), 23 deletions(-) diff --git a/clmm/utils/beta_lens.py b/clmm/utils/beta_lens.py index a144460ee..8d00d6c26 100644 --- a/clmm/utils/beta_lens.py +++ b/clmm/utils/beta_lens.py @@ -27,7 +27,10 @@ def compute_beta(z_src, z_cl, cosmo): float, array Geometric lensing efficicency """ - return np.heaviside(z_src - z_cl, 0) * cosmo.eval_da_z1z2(z_cl, z_src) / cosmo.eval_da(z_src) + _z_src = np.array(z_src) + return ( + np.heaviside(_z_src - z_cl, 0) * cosmo._eval_da_z1z2(z_cl, _z_src) / cosmo._eval_da(_z_src) + ) def compute_beta_s(z_src, z_cl, z_inf, cosmo): @@ -210,18 +213,13 @@ def compute_beta_s_mean_from_weights(z_src, z_cl, z_inf, cosmo, shape_weights): float Mean value of the geometric lensing efficicency ratio. """ + _z_src = np.array(z_src) if shape_weights is None: - shape_weights = z_src * 0 + 1 - try: - if len(z_src) != len(shape_weights): - raise ValueError("The source redshifts and the weights array must be the same size.") - except TypeError: - z_src = [z_src] - shape_weights = [shape_weights] - - shape_weights = np.array(shape_weights) - beta_s = compute_beta_s(z_src, z_cl, z_inf, cosmo) - return (shape_weights * beta_s).sum() / shape_weights.sum() + _shape_weights = np.ones_like(_z_src) + else: + _shape_weights = np.array(shape_weights) + beta_s = compute_beta_s(_z_src, z_cl, z_inf, cosmo) + return (_shape_weights * beta_s).sum() / _shape_weights.sum() def compute_beta_s_square_mean_from_weights( @@ -254,15 +252,10 @@ def compute_beta_s_square_mean_from_weights( float Mean square value of the geometric lensing efficicency ratio. """ + _z_src = np.array(z_src) if shape_weights is None: - shape_weights = z_src * 0 + 1 - try: - if len(z_src) != len(shape_weights): - raise ValueError("The source redshifts and the weights array must be the same size.") - except TypeError: - z_src = [z_src] - shape_weights = [shape_weights] - - shape_weights = np.array(shape_weights) - beta_s = compute_beta_s(z_src, z_cl, z_inf, cosmo) - return (shape_weights * beta_s**2).sum() / shape_weights.sum() + _shape_weights = np.ones_like(_z_src) + else: + _shape_weights = np.array(shape_weights) + beta_s = compute_beta_s(_z_src, z_cl, z_inf, cosmo) + return (_shape_weights * beta_s**2).sum() / _shape_weights.sum() From d04f6e37adb840640c3e382bc9aa1c806539d04c Mon Sep 17 00:00:00 2001 From: m-aguena Date: Wed, 12 Jul 2023 17:40:25 +0200 Subject: [PATCH 26/38] add _eval_da, _eval_da_z1z2, _get_z_from_a, _get_a_from_z to cosm --- clmm/cosmology/ccl.py | 20 ++++++------ clmm/cosmology/parent_class.py | 56 ++++++++++++++++++++++++++++++---- 2 files changed, 60 insertions(+), 16 deletions(-) diff --git a/clmm/cosmology/ccl.py b/clmm/cosmology/ccl.py index 1998bcd13..50f2af29f 100644 --- a/clmm/cosmology/ccl.py +++ b/clmm/cosmology/ccl.py @@ -76,29 +76,29 @@ def _get_param(self, key): return value def _get_Omega_m(self, z): - a = self.get_a_from_z(z) + a = self._get_a_from_z(z) return ccl.omega_x(self.be_cosmo, a, "matter") def _get_E2(self, z): - a = self.get_a_from_z(z) + a = self._get_a_from_z(z) return (ccl.h_over_h0(self.be_cosmo, a)) ** 2 def _get_E2Omega_m(self, z): - a = self.get_a_from_z(z) + a = self._get_a_from_z(z) return ccl.omega_x(self.be_cosmo, a, "matter") * (ccl.h_over_h0(self.be_cosmo, a)) ** 2 def _get_rho_m(self, z): # total matter density in physical units [Msun/Mpc3] - a = self.get_a_from_z(z) + a = self._get_a_from_z(z) return ccl.rho_x(self.be_cosmo, a, "matter", is_comoving=False) def _get_rho_c(self, z): - a = self.get_a_from_z(z) + a = self._get_a_from_z(z) return ccl.rho_x(self.be_cosmo, a, "critical", is_comoving=False) def _eval_da_z1z2_core(self, z1, z2): - a1 = np.atleast_1d(self.get_a_from_z(z1)) - a2 = np.atleast_1d(self.get_a_from_z(z2)) + a1 = np.atleast_1d(self._get_a_from_z(z1)) + a2 = np.atleast_1d(self._get_a_from_z(z2)) if len(a1) == 1 and len(a2) != 1: a1 = np.full_like(a2, a1) elif len(a2) == 1 and len(a1) != 1: @@ -110,10 +110,10 @@ def _eval_da_z1z2_core(self, z1, z2): return res def _eval_sigma_crit_core(self, z_len, z_src): - a_len = self.get_a_from_z(z_len) - a_src = self.get_a_from_z(z_src) + a_len = self._get_a_from_z(z_len) + a_src = self._get_a_from_z(z_src) return self.be_cosmo.sigma_critical(a_len, a_src) * self.cor_factor def _eval_linear_matter_powerspectrum(self, k_vals, redshift): - return ccl.linear_matter_power(self.be_cosmo, k_vals, self.get_a_from_z(redshift)) + return ccl.linear_matter_power(self.be_cosmo, k_vals, self._get_a_from_z(redshift)) diff --git a/clmm/cosmology/parent_class.py b/clmm/cosmology/parent_class.py index 7bbef4d9f..215981aee 100644 --- a/clmm/cosmology/parent_class.py +++ b/clmm/cosmology/parent_class.py @@ -284,14 +284,28 @@ def eval_da(self, z): ------- float, numpy.ndarray Angular diameter distance in units :math:`M\!pc` - - Notes - ----- - Describe the vectorization. """ if self.validate_input: validate_argument(locals(), "z", "float_array", argmin=0, eqmin=True) - return self.eval_da_z1z2(0.0, z) + return self._eval_da(z) + + def _eval_da(self, z): + r"""Computes the angular diameter distance between 0.0 and z + + .. math:: + d_a(z) = \frac{c}{H_0}\frac{1}{1+z}\int_{0}^{z}\frac{dz'}{E(z')}. + + Parameters + ---------- + z : float, array_like + Redshift + + Returns + ------- + float, numpy.ndarray + Angular diameter distance in units :math:`M\!pc` + """ + return self._eval_da_z1z2(0.0, z) def eval_da_a1a2(self, a1, a2=1.0): r"""This is a function to calculate the angular diameter distance @@ -340,7 +354,7 @@ def eval_da_a1a2(self, a1, a2=1.0): ) z1 = self.get_z_from_a(a2) z2 = self.get_z_from_a(a1) - return self.eval_da_z1z2(z1, z2) + return self._eval_da_z1z2(z1, z2) def get_a_from_z(self, z): """Convert redshift to scale factor @@ -357,6 +371,21 @@ def get_a_from_z(self, z): """ if self.validate_input: validate_argument(locals(), "z", "float_array", argmin=0, eqmin=True) + return self._get_a_from_z(z) + + def _get_a_from_z(self, z): + """Convert redshift to scale factor + + Parameters + ---------- + z : float, array_like + Redshift + + Returns + ------- + a : float, numpy.ndarray + Scale factor + """ z = np.array(z) return 1.0 / (1.0 + z) @@ -377,6 +406,21 @@ def get_z_from_a(self, a): validate_argument( locals(), "a", "float_array", argmin=0, eqmin=True, argmax=1, eqmax=True ) + return self._get_z_from_a(a) + + def _get_z_from_a(self, a): + """Convert scale factor to redshift + + Parameters + ---------- + a : float, array_like + Scale factor + + Returns + ------- + z : float, numpy.ndarray + Redshift + """ a = np.array(a) return (1.0 / a) - 1.0 From 00d6e026f6ff5998217f9426062a48c179659678 Mon Sep 17 00:00:00 2001 From: m-aguena Date: Wed, 12 Jul 2023 17:48:23 +0200 Subject: [PATCH 27/38] reorder funcs in cosmo parent --- clmm/cosmology/parent_class.py | 203 +++++++++++++-------------------- 1 file changed, 78 insertions(+), 125 deletions(-) diff --git a/clmm/cosmology/parent_class.py b/clmm/cosmology/parent_class.py index 215981aee..5f562a41e 100644 --- a/clmm/cosmology/parent_class.py +++ b/clmm/cosmology/parent_class.py @@ -41,11 +41,16 @@ def __setitem__(self, key, val): else: raise TypeError(f"key input must be str, not {type(key)}") - def _init_from_cosmo(self, be_cosmo): + # Public functions + + def get_desc(self): """ - To be filled in child classes + Returns the Cosmology description. """ - raise NotImplementedError + return ( + f"{type(self).__name__}(H0={self['H0']}, Omega_dm0={self['Omega_dm0']}, " + f"Omega_b0={self['Omega_b0']}, Omega_k0={self['Omega_k0']})" + ) def init_from_params(self, H0=67.66, Omega_b0=0.049, Omega_dm0=0.262, Omega_k0=0.0): """Set the cosmology from parameters @@ -68,33 +73,6 @@ def init_from_params(self, H0=67.66, Omega_b0=0.049, Omega_dm0=0.262, Omega_k0=0 validate_argument(locals(), "Omega_k0", float, argmin=0, eqmin=True) self._init_from_params(H0=H0, Omega_b0=Omega_b0, Omega_dm0=Omega_dm0, Omega_k0=Omega_k0) - def _init_from_params(self, **kwargs): - """ - To be filled in child classes - """ - raise NotImplementedError - - def _set_param(self, key, value): - """ - To be filled in child classes - """ - raise NotImplementedError - - def _get_param(self, key): - """ - To be filled in child classes - """ - raise NotImplementedError - - def get_desc(self): - """ - Returns the Cosmology description. - """ - return ( - f"{type(self).__name__}(H0={self['H0']}, Omega_dm0={self['Omega_dm0']}, " - f"Omega_b0={self['Omega_b0']}, Omega_k0={self['Omega_k0']})" - ) - def set_be_cosmo(self, be_cosmo=None, H0=67.66, Omega_b0=0.049, Omega_dm0=0.262, Omega_k0=0.0): """Set the cosmology @@ -134,9 +112,6 @@ def get_Omega_m(self, z): validate_argument(locals(), "z", "float_array", argmin=0, eqmin=True) return self._get_Omega_m(z=z) - def _get_Omega_m(self, z): - raise NotImplementedError - def get_E2(self, z): r"""Gets the value of the hubble parameter (normalized at 0) @@ -159,9 +134,6 @@ def get_E2(self, z): validate_argument(locals(), "z", "float_array", argmin=0, eqmin=True) return self._get_E2(z=z) - def _get_E2(self, z): - raise NotImplementedError - def get_E2Omega_m(self, z): r"""Gets the value of the dimensionless matter density times the Hubble parameter squared (normalized at 0) @@ -187,9 +159,6 @@ def get_E2Omega_m(self, z): validate_argument(locals(), "z", "float_array", argmin=0, eqmin=True) return self._get_E2Omega_m(z=z) - def _get_E2Omega_m(self, z): - raise NotImplementedError - def get_rho_m(self, z): r"""Gets physical matter density at a given redshift. @@ -207,12 +176,6 @@ def get_rho_m(self, z): validate_argument(locals(), "z", "float_array", argmin=0, eqmin=True) return self._get_rho_m(z=z) - def _get_rho_m(self, z): - rhocrit_cd2018 = (3.0e16 * const.PC_TO_METER.value) / ( - 8.0 * np.pi * const.GNEWT.value * const.SOLAR_MASS.value - ) - return rhocrit_cd2018 * (z + 1) ** 3 * self["Omega_m0"] * self["h"] ** 2 - def get_rho_c(self, z): r"""Gets physical critical density at a given redshift. @@ -230,9 +193,6 @@ def get_rho_c(self, z): validate_argument(locals(), "z", "float_array", argmin=0, eqmin=True) return self._get_rho_c(z=z) - def _get_rho_c(self, z): - raise NotImplementedError - def eval_da_z1z2(self, z1, z2): r"""Computes the angular diameter distance between z1 and z2 @@ -260,15 +220,6 @@ def eval_da_z1z2(self, z1, z2): validate_argument(locals(), "z2", "float_array", argmin=0, eqmin=True) return self._eval_da_z1z2(z1=z1, z2=z2) - def _eval_da_z1z2(self, z1, z2): - warning_msg = "\nSome values of z2 are lower than z1." + "\nda = np.nan for those." - return compute_for_good_redshifts( - self._eval_da_z1z2_core, z1, z2, np.nan, warning_message=warning_msg - ) - - def _eval_da_z1z2_core(self, z1, z2): - raise NotImplementedError - def eval_da(self, z): r"""Computes the angular diameter distance between 0.0 and z @@ -289,24 +240,6 @@ def eval_da(self, z): validate_argument(locals(), "z", "float_array", argmin=0, eqmin=True) return self._eval_da(z) - def _eval_da(self, z): - r"""Computes the angular diameter distance between 0.0 and z - - .. math:: - d_a(z) = \frac{c}{H_0}\frac{1}{1+z}\int_{0}^{z}\frac{dz'}{E(z')}. - - Parameters - ---------- - z : float, array_like - Redshift - - Returns - ------- - float, numpy.ndarray - Angular diameter distance in units :math:`M\!pc` - """ - return self._eval_da_z1z2(0.0, z) - def eval_da_a1a2(self, a1, a2=1.0): r"""This is a function to calculate the angular diameter distance between two scale factors. @@ -373,22 +306,6 @@ def get_a_from_z(self, z): validate_argument(locals(), "z", "float_array", argmin=0, eqmin=True) return self._get_a_from_z(z) - def _get_a_from_z(self, z): - """Convert redshift to scale factor - - Parameters - ---------- - z : float, array_like - Redshift - - Returns - ------- - a : float, numpy.ndarray - Scale factor - """ - z = np.array(z) - return 1.0 / (1.0 + z) - def get_z_from_a(self, a): """Convert scale factor to redshift @@ -408,22 +325,6 @@ def get_z_from_a(self, a): ) return self._get_z_from_a(a) - def _get_z_from_a(self, a): - """Convert scale factor to redshift - - Parameters - ---------- - a : float, array_like - Scale factor - - Returns - ------- - z : float, numpy.ndarray - Redshift - """ - a = np.array(a) - return (1.0 / a) - 1.0 - def rad2mpc(self, dist1, redshift): r"""Convert between radians and Mpc using the small angle approximation and :math:`d = D_A \theta`. @@ -490,24 +391,6 @@ def eval_sigma_crit(self, z_len, z_src): validate_argument(locals(), "z_src", "float_array", argmin=0, eqmin=True) return self._eval_sigma_crit(z_len=z_len, z_src=z_src) - def _eval_sigma_crit(self, z_len, z_src): - warning_msg = ( - "\nSome source redshifts are lower than the cluster redshift." - + "\nSigma_crit = np.inf for those galaxies." - ) - return compute_for_good_redshifts( - self._eval_sigma_crit_core, - z_len, - z_src, - np.inf, - z1_arg_name="z_len", - z2_arg_name="z_src", - warning_message=warning_msg, - ) - - def _eval_sigma_crit_core(self, z_len, z_src): - raise NotImplementedError - def eval_linear_matter_powerspectrum(self, k_vals, redshift): r"""Computes the linear matter power spectrum @@ -528,5 +411,75 @@ def eval_linear_matter_powerspectrum(self, k_vals, redshift): validate_argument(locals(), "redshift", float, argmin=0, eqmin=True) return self._eval_linear_matter_powerspectrum(k_vals, redshift) + # Private functions + + def _init_from_cosmo(self, be_cosmo): + raise NotImplementedError + + def _init_from_params(self, **kwargs): + raise NotImplementedError + + def _set_param(self, key, value): + raise NotImplementedError + + def _get_param(self, key): + raise NotImplementedError + + def _get_Omega_m(self, z): + raise NotImplementedError + + def _get_E2(self, z): + raise NotImplementedError + + def _get_E2Omega_m(self, z): + raise NotImplementedError + + def _get_rho_m(self, z): + rhocrit_cd2018 = (3.0e16 * const.PC_TO_METER.value) / ( + 8.0 * np.pi * const.GNEWT.value * const.SOLAR_MASS.value + ) + return rhocrit_cd2018 * (z + 1) ** 3 * self["Omega_m0"] * self["h"] ** 2 + + def _get_rho_c(self, z): + raise NotImplementedError + + def _eval_da_z1z2(self, z1, z2): + warning_msg = "\nSome values of z2 are lower than z1." + "\nda = np.nan for those." + return compute_for_good_redshifts( + self._eval_da_z1z2_core, z1, z2, np.nan, warning_message=warning_msg + ) + + def _eval_da_z1z2_core(self, z1, z2): + raise NotImplementedError + + def _eval_da(self, z): + return self._eval_da_z1z2(0.0, z) + + def _get_a_from_z(self, z): + z = np.array(z) + return 1.0 / (1.0 + z) + + def _get_z_from_a(self, a): + a = np.array(a) + return (1.0 / a) - 1.0 + + def _eval_sigma_crit(self, z_len, z_src): + warning_msg = ( + "\nSome source redshifts are lower than the cluster redshift." + + "\nSigma_crit = np.inf for those galaxies." + ) + return compute_for_good_redshifts( + self._eval_sigma_crit_core, + z_len, + z_src, + np.inf, + z1_arg_name="z_len", + z2_arg_name="z_src", + warning_message=warning_msg, + ) + + def _eval_sigma_crit_core(self, z_len, z_src): + raise NotImplementedError + def _eval_linear_matter_powerspectrum(self, k_vals, redshift): raise NotImplementedError From 4fc845e1cb80abf31dbb4536c47e30bf6232d2d1 Mon Sep 17 00:00:00 2001 From: m-aguena Date: Wed, 12 Jul 2023 17:52:53 +0200 Subject: [PATCH 28/38] update tests --- tests/test_utils.py | 77 +++++++++++++++++++++++++++++++++------------ 1 file changed, 57 insertions(+), 20 deletions(-) diff --git a/tests/test_utils.py b/tests/test_utils.py index b6a801ad9..0b2db3591 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -535,31 +535,30 @@ def test_validate_argument(): ) -def test_beta_functions(): +def test_beta_functions(modeling_data): z_cl = 1.0 - z_src= [2.4, 2.1] + z_src = [2.4, 2.1] shape_weights = [4.6, 6.4] - z_inf =1000. + z_inf = 1000.0 zmax = 15.0 nsteps = 1000 zmin = z_cl + 0.1 z_int = np.linspace(zmin, zmax, nsteps) - cosmo = clmm.Cosmology(H0=70.0, Omega_dm0=0.27 - 0.045, - Omega_b0=0.045, Omega_k0=0.0) - beta_test = [np.heaviside(z_s-z_cl, 0) * cosmo.eval_da_z1z2(z_cl, z_s) / cosmo.eval_da(z_s) for z_s in z_src] + cosmo = clmm.Cosmology(H0=70.0, Omega_dm0=0.27 - 0.045, Omega_b0=0.045, Omega_k0=0.0) + beta_test = [ + np.heaviside(z_s - z_cl, 0) * cosmo.eval_da_z1z2(z_cl, z_s) / cosmo.eval_da(z_s) + for z_s in z_src + ] beta_s_test = utils.compute_beta(z_src, z_cl, cosmo) / utils.compute_beta(z_inf, z_cl, cosmo) assert_allclose(utils.compute_beta(z_src, z_cl, cosmo), beta_test, **TOLERANCE) assert_allclose(utils.compute_beta_s(z_src, z_cl, z_inf, cosmo), beta_s_test, **TOLERANCE) - + # beta mean from distributions + for model in (None, zdist.chang2013, zdist.desc_srd): # None defaults to chang2013 for compute_beta* functions - test1 = utils.compute_beta_s_mean_from_distribution(z_cl, z_inf, cosmo, zmax, z_distrib_func=model) - test2 = utils.compute_beta_s_square_mean_from_distribution(z_cl, z_inf, cosmo, zmax, - z_distrib_func=model) - if model is None: model = zdist.chang2013 @@ -567,14 +566,52 @@ def integrand1(z_i, z_inf=z_inf, z_cl=z_cl, cosmo=cosmo): return utils.compute_beta_s(z_i, z_cl, z_inf, cosmo) * model(z_i) def integrand2(z_i, z_inf=z_inf, z_cl=z_cl, cosmo=cosmo): - return utils.compute_beta_s(z_i, z_cl, z_inf, cosmo)**2 * model(z_i) + return utils.compute_beta_s(z_i, z_cl, z_inf, cosmo) ** 2 * model(z_i) + + assert_allclose( + utils.compute_beta_s_mean_from_distribution( + z_cl, z_inf, cosmo, zmax, z_distrib_func=model + ), + quad(integrand1, zmin, zmax)[0] / quad(model, zmin, zmax)[0], + **TOLERANCE + ) + assert_allclose( + utils.compute_beta_s_square_mean_from_distribution( + z_cl, z_inf, cosmo, zmax, z_distrib_func=model + ), + quad(integrand2, zmin, zmax)[0] / quad(model, zmin, zmax)[0], + **TOLERANCE + ) + + # beta mean from weights - assert_allclose(test1, quad(integrand1, zmin, zmax)[0] / quad(model, zmin, zmax)[0], - **TOLERANCE) - assert_allclose(test2, quad(integrand2, zmin, zmax)[0] / quad(model, zmin, zmax)[0], - **TOLERANCE) + assert_allclose( + utils.compute_beta_s_mean_from_weights(z_src, z_cl, z_inf, cosmo, shape_weights), + np.sum( + shape_weights * utils.compute_beta_s(z_src, z_cl, z_inf, cosmo) / np.sum(shape_weights) + ), + **TOLERANCE + ) + assert_allclose( + utils.compute_beta_s_square_mean_from_weights(z_src, z_cl, z_inf, cosmo, shape_weights), + np.sum( + shape_weights + * utils.compute_beta_s(z_src, z_cl, z_inf, cosmo) ** 2 + / np.sum(shape_weights) + ), + **TOLERANCE + ) - test3 = utils.compute_beta_s_mean_from_weights(z_src, z_cl, z_inf,cosmo, shape_weights) - test4 = utils.compute_beta_s_square_mean_from_weights(z_src, z_cl, z_inf,cosmo, shape_weights) - assert_allclose(test3, np.sum(shape_weights * utils.compute_beta_s(z_src, z_cl, z_inf, cosmo) / np.sum(shape_weights)), **TOLERANCE) - assert_allclose(test4, np.sum(shape_weights * utils.compute_beta_s(z_src, z_cl, z_inf, cosmo)**2 / np.sum(shape_weights)), **TOLERANCE) + no_weights = [1, 1] + assert_allclose( + utils.compute_beta_s_mean_from_weights(z_src, z_cl, z_inf, cosmo, None), + np.sum(no_weights * utils.compute_beta_s(z_src, z_cl, z_inf, cosmo) / np.sum(no_weights)), + **TOLERANCE + ) + assert_allclose( + utils.compute_beta_s_square_mean_from_weights(z_src, z_cl, z_inf, cosmo, None), + np.sum( + no_weights * utils.compute_beta_s(z_src, z_cl, z_inf, cosmo) ** 2 / np.sum(no_weights) + ), + **TOLERANCE + ) From a500d61f04fac3e14418583dd65dd879001b772e Mon Sep 17 00:00:00 2001 From: m-aguena Date: Wed, 12 Jul 2023 18:20:43 +0200 Subject: [PATCH 29/38] add compute_beta_s_mean_from_weights to demo_theory_functionality_diff_z_types.ipynb --- ...mo_theory_functionality_diff_z_types.ipynb | 42 +++++++++++++++++-- 1 file changed, 38 insertions(+), 4 deletions(-) diff --git a/examples/demo_theory_functionality_diff_z_types.ipynb b/examples/demo_theory_functionality_diff_z_types.ipynb index afc536658..8239be5d8 100644 --- a/examples/demo_theory_functionality_diff_z_types.ipynb +++ b/examples/demo_theory_functionality_diff_z_types.ipynb @@ -219,7 +219,7 @@ "source": [ "z_inf = 1000\n", "\n", - "beta_s_mean = clmm.utils.beta_lens.compute_beta_s_mean_from_distribution(\n", + "beta_s_mean = clmm.utils.compute_beta_s_mean_from_distribution(\n", " cluster_z,\n", " z_inf,\n", " cosmo,\n", @@ -228,7 +228,7 @@ " zmin=None,\n", " z_distrib_func=model_z_distrib_dict[\"func\"],\n", ")\n", - "beta_s_square_mean = clmm.utils.beta_lens.compute_beta_s_square_mean_from_distribution(\n", + "beta_s_square_mean = clmm.utils.compute_beta_s_square_mean_from_distribution(\n", " cluster_z,\n", " z_inf,\n", " cosmo,\n", @@ -242,6 +242,40 @@ "display(Math(beta_sq_label(beta_s_square_mean)))" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It is also possible to compute $\\langle\\beta_s\\rangle$ and $\\langle\\beta_s^2\\rangle$ using galaxy shape weights:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "z_inf = 1000\n", + "\n", + "beta_s_mean_wts = clmm.utils.compute_beta_s_mean_from_weights(\n", + " source_catalog['z'],\n", + " cluster_z,\n", + " z_inf,\n", + " cosmo,\n", + " shape_weights=None,\n", + ")\n", + "beta_s_square_mean_wts = clmm.utils.compute_beta_s_square_mean_from_weights(\n", + " source_catalog['z'],\n", + " cluster_z,\n", + " z_inf,\n", + " cosmo,\n", + " shape_weights=None,\n", + ")\n", + "\n", + "display(Math(beta_label(beta_s_mean_wts)))\n", + "display(Math(beta_sq_label(beta_s_square_mean_wts)))" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -839,9 +873,9 @@ "metadata": { "anaconda-cloud": {}, "kernelspec": { - "display_name": "Python (firecrown2.0)", + "display_name": "Python 3 (ipykernel)", "language": "python", - "name": "firecrown" + "name": "python3" }, "language_info": { "codemirror_mode": { From 6faa95ed157b8ade5158c9d167c892d4202b1a6d Mon Sep 17 00:00:00 2001 From: m-aguena Date: Wed, 12 Jul 2023 18:50:02 +0200 Subject: [PATCH 30/38] reorder funcs in cosmo parent --- clmm/cosmology/parent_class.py | 151 +++++++++++++++++---------------- 1 file changed, 78 insertions(+), 73 deletions(-) diff --git a/clmm/cosmology/parent_class.py b/clmm/cosmology/parent_class.py index 5f562a41e..ef9164c48 100644 --- a/clmm/cosmology/parent_class.py +++ b/clmm/cosmology/parent_class.py @@ -1,4 +1,5 @@ """@file parent_class.py +CLMMCosmology abstract class """ # CLMM Cosmology object abstract superclass import numpy as np @@ -41,7 +42,83 @@ def __setitem__(self, key, val): else: raise TypeError(f"key input must be str, not {type(key)}") - # Public functions + # 1. Functions to be implemented by children classes + + def _init_from_cosmo(self, be_cosmo): + raise NotImplementedError + + def _init_from_params(self, **kwargs): + raise NotImplementedError + + def _set_param(self, key, value): + raise NotImplementedError + + def _get_param(self, key): + raise NotImplementedError + + def _get_Omega_m(self, z): + raise NotImplementedError + + def _get_E2(self, z): + raise NotImplementedError + + def _get_E2Omega_m(self, z): + raise NotImplementedError + + def _get_rho_c(self, z): + raise NotImplementedError + + + def _eval_da_z1z2_core(self, z1, z2): + raise NotImplementedError + + + def _eval_sigma_crit_core(self, z_len, z_src): + raise NotImplementedError + + def _eval_linear_matter_powerspectrum(self, k_vals, redshift): + raise NotImplementedError + + # 2. Functions that can be used by all subclasses + + def _get_rho_m(self, z): + rhocrit_cd2018 = (3.0e16 * const.PC_TO_METER.value) / ( + 8.0 * np.pi * const.GNEWT.value * const.SOLAR_MASS.value + ) + return rhocrit_cd2018 * (z + 1) ** 3 * self["Omega_m0"] * self["h"] ** 2 + + def _eval_da_z1z2(self, z1, z2): + warning_msg = "\nSome values of z2 are lower than z1." + "\nda = np.nan for those." + return compute_for_good_redshifts( + self._eval_da_z1z2_core, z1, z2, np.nan, warning_message=warning_msg + ) + def _eval_da(self, z): + return self._eval_da_z1z2(0.0, z) + + def _get_a_from_z(self, z): + z = np.array(z) + return 1.0 / (1.0 + z) + + def _get_z_from_a(self, a): + a = np.array(a) + return (1.0 / a) - 1.0 + + def _eval_sigma_crit(self, z_len, z_src): + warning_msg = ( + "\nSome source redshifts are lower than the cluster redshift." + + "\nSigma_crit = np.inf for those galaxies." + ) + return compute_for_good_redshifts( + self._eval_sigma_crit_core, + z_len, + z_src, + np.inf, + z1_arg_name="z_len", + z2_arg_name="z_src", + warning_message=warning_msg, + ) + + # 3. Wrapper functions for input validation def get_desc(self): """ @@ -411,75 +488,3 @@ def eval_linear_matter_powerspectrum(self, k_vals, redshift): validate_argument(locals(), "redshift", float, argmin=0, eqmin=True) return self._eval_linear_matter_powerspectrum(k_vals, redshift) - # Private functions - - def _init_from_cosmo(self, be_cosmo): - raise NotImplementedError - - def _init_from_params(self, **kwargs): - raise NotImplementedError - - def _set_param(self, key, value): - raise NotImplementedError - - def _get_param(self, key): - raise NotImplementedError - - def _get_Omega_m(self, z): - raise NotImplementedError - - def _get_E2(self, z): - raise NotImplementedError - - def _get_E2Omega_m(self, z): - raise NotImplementedError - - def _get_rho_m(self, z): - rhocrit_cd2018 = (3.0e16 * const.PC_TO_METER.value) / ( - 8.0 * np.pi * const.GNEWT.value * const.SOLAR_MASS.value - ) - return rhocrit_cd2018 * (z + 1) ** 3 * self["Omega_m0"] * self["h"] ** 2 - - def _get_rho_c(self, z): - raise NotImplementedError - - def _eval_da_z1z2(self, z1, z2): - warning_msg = "\nSome values of z2 are lower than z1." + "\nda = np.nan for those." - return compute_for_good_redshifts( - self._eval_da_z1z2_core, z1, z2, np.nan, warning_message=warning_msg - ) - - def _eval_da_z1z2_core(self, z1, z2): - raise NotImplementedError - - def _eval_da(self, z): - return self._eval_da_z1z2(0.0, z) - - def _get_a_from_z(self, z): - z = np.array(z) - return 1.0 / (1.0 + z) - - def _get_z_from_a(self, a): - a = np.array(a) - return (1.0 / a) - 1.0 - - def _eval_sigma_crit(self, z_len, z_src): - warning_msg = ( - "\nSome source redshifts are lower than the cluster redshift." - + "\nSigma_crit = np.inf for those galaxies." - ) - return compute_for_good_redshifts( - self._eval_sigma_crit_core, - z_len, - z_src, - np.inf, - z1_arg_name="z_len", - z2_arg_name="z_src", - warning_message=warning_msg, - ) - - def _eval_sigma_crit_core(self, z_len, z_src): - raise NotImplementedError - - def _eval_linear_matter_powerspectrum(self, k_vals, redshift): - raise NotImplementedError From 2416457d544dc5b46f0760d20405401729510fde Mon Sep 17 00:00:00 2001 From: m-aguena Date: Wed, 12 Jul 2023 18:50:43 +0200 Subject: [PATCH 31/38] add fix for pylint duplicate-code error bug --- clmm/theory/parent_class.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/clmm/theory/parent_class.py b/clmm/theory/parent_class.py index 6c7a9196a..c6d875259 100644 --- a/clmm/theory/parent_class.py +++ b/clmm/theory/parent_class.py @@ -64,6 +64,10 @@ class CLMModeling: The value used as infinite redshift """ # pylint: disable=too-many-instance-attributes + # The disable below is added to avoid a pylint error where it thinks CLMMCosmlogy + # has duplicates since both have many NotImplementedError functions + # description of bug at https://github.com/pylint-dev/pylint/issues/7213 + # pylint: disable=duplicate-code def __init__(self, validate_input=True, z_inf=1000): self.backend = None From 82ca49742c7fff0596d71de52e8a905dc7eba92a Mon Sep 17 00:00:00 2001 From: m-aguena Date: Wed, 12 Jul 2023 18:51:04 +0200 Subject: [PATCH 32/38] add pylint skip --- clmm/utils/beta_lens.py | 1 + 1 file changed, 1 insertion(+) diff --git a/clmm/utils/beta_lens.py b/clmm/utils/beta_lens.py index 8d00d6c26..26ce410f7 100644 --- a/clmm/utils/beta_lens.py +++ b/clmm/utils/beta_lens.py @@ -27,6 +27,7 @@ def compute_beta(z_src, z_cl, cosmo): float, array Geometric lensing efficicency """ + # pylint: disable-msg=protected-access _z_src = np.array(z_src) return ( np.heaviside(_z_src - z_cl, 0) * cosmo._eval_da_z1z2(z_cl, _z_src) / cosmo._eval_da(_z_src) From 2dd7b83bb59fe66e3405ab2c312e9199bf2f994d Mon Sep 17 00:00:00 2001 From: m-aguena Date: Wed, 12 Jul 2023 19:01:50 +0200 Subject: [PATCH 33/38] fix linebreaks --- clmm/cosmology/parent_class.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/clmm/cosmology/parent_class.py b/clmm/cosmology/parent_class.py index ef9164c48..e970b4245 100644 --- a/clmm/cosmology/parent_class.py +++ b/clmm/cosmology/parent_class.py @@ -68,11 +68,9 @@ def _get_E2Omega_m(self, z): def _get_rho_c(self, z): raise NotImplementedError - def _eval_da_z1z2_core(self, z1, z2): raise NotImplementedError - def _eval_sigma_crit_core(self, z_len, z_src): raise NotImplementedError @@ -92,6 +90,7 @@ def _eval_da_z1z2(self, z1, z2): return compute_for_good_redshifts( self._eval_da_z1z2_core, z1, z2, np.nan, warning_message=warning_msg ) + def _eval_da(self, z): return self._eval_da_z1z2(0.0, z) @@ -487,4 +486,3 @@ def eval_linear_matter_powerspectrum(self, k_vals, redshift): validate_argument(locals(), "k_vals", "float_array", argmin=0) validate_argument(locals(), "redshift", float, argmin=0, eqmin=True) return self._eval_linear_matter_powerspectrum(k_vals, redshift) - From 1cc32c2876b64f513055d481523538130c8a582b Mon Sep 17 00:00:00 2001 From: m-aguena Date: Fri, 10 Nov 2023 09:23:50 -0800 Subject: [PATCH 34/38] fix new use in examples/mass_fitting/Example3_Fit_Halo_Mass_to_Shear_Catalog.ipynb --- ...mple3_Fit_Halo_Mass_to_Shear_Catalog.ipynb | 115 +++++++++--------- 1 file changed, 57 insertions(+), 58 deletions(-) diff --git a/examples/mass_fitting/Example3_Fit_Halo_Mass_to_Shear_Catalog.ipynb b/examples/mass_fitting/Example3_Fit_Halo_Mass_to_Shear_Catalog.ipynb index 0cbce9bb9..6c9c07b41 100644 --- a/examples/mass_fitting/Example3_Fit_Halo_Mass_to_Shear_Catalog.ipynb +++ b/examples/mass_fitting/Example3_Fit_Halo_Mass_to_Shear_Catalog.ipynb @@ -444,46 +444,45 @@ "# The default mass is M200m; use massdef='critical' for M200c.\n", "\n", "\n", - "def model_reduced_tangential_shear_applegate14(logm, catalog, profile):\n", - " z_values = catalog.galcat[\"z\"]\n", - " z_cl = cluster_z\n", + "def _model_reduced_tangential_shear(logm, catalog, profile, approx):\n", + " beta_kwargs = {\n", + " \"z_cl\": cluster_z,\n", + " \"z_inf\": 10.0,\n", + " \"cosmo\": cosmo,\n", + " #'zmax' :zsrc_max,\n", + " #'delta_z_cut': delta_z_cut,\n", + " #'zmin': None,\n", + " # We provide the redshift distribution (default: Chang et al. 2013) for calculating the beta_s statistics\n", + " \"z_distrib_func\": clmm.redshift.distributions.chang2013,\n", + " }\n", + " beta_s_mean = clmm.utils.compute_beta_s_mean_from_distribution(**beta_kwargs)\n", + " beta_s_square_mean = clmm.utils.compute_beta_s_square_mean_from_distribution(**beta_kwargs)\n", + "\n", " gt_model = clmm.compute_reduced_tangential_shear(\n", " r_proj=profile[\"radius\"], # Radial component of the profile\n", " mdelta=10**logm, # Mass of the cluster [M_sun]\n", " cdelta=concentration, # Concentration of the cluster\n", " z_cluster=cluster_z, # Redshift of the cluster\n", - " z_src=clmm.redshift.distributions.chang2013, # We provide the redshift distribution (default: Chang et al. 2013) for calculating the beta_s statistics\n", + " z_src=[beta_s_mean, beta_s_square_mean],\n", " cosmo=cosmo,\n", " delta_mdef=200,\n", " # massdef='critical',\n", " halo_profile_model=\"nfw\",\n", - " z_src_info=\"distribution\",\n", - " approx=\"order1\",\n", - " # beta_s_mean=None, # beta_s_mean and beta_s_square_mean can be provided (default: None)\n", + " z_src_info=\"beta\",\n", + " approx=approx,\n", + " # beta_s_mean=None,\n", " # beta_s_square_mean=None\n", " )\n", " return gt_model\n", "\n", "\n", - "# Similarly, we also consider the method from Schrabback et al. (2018), called 'order12' in CLMM.\n", + "def model_reduced_tangential_shear_applegate14(logm, catalog, profile):\n", + " return _model_reduced_tangential_shear(logm, catalog, profile, approx=\"order1\")\n", + "\n", + "\n", + "# Similarly, we also consider the method from Schrabback et al. (2018), called 'order2' in CLMM.\n", "def model_reduced_tangential_shear_schrabback18(logm, catalog, profile):\n", - " z_values = catalog.galcat[\"z\"]\n", - " gt_model = clmm.compute_reduced_tangential_shear(\n", - " r_proj=profile[\"radius\"], # Radial component of the profile\n", - " mdelta=10**logm, # Mass of the cluster [M_sun]\n", - " cdelta=concentration, # Concentration of the cluster\n", - " z_cluster=cluster_z, # Redshift of the cluster\n", - " z_src=clmm.redshift.distributions.chang2013, # We provide the redshift distribution (default: Chang et al. 2013) for calculating the beta_s statistics\n", - " cosmo=cosmo,\n", - " delta_mdef=200,\n", - " # massdef='critical',\n", - " halo_profile_model=\"nfw\",\n", - " z_src_info=\"distribution\",\n", - " approx=\"order2\",\n", - " # beta_s_mean=None,\n", - " # beta_s_square_mean=None\n", - " )\n", - " return gt_model" + " return _model_reduced_tangential_shear(logm, catalog, profile, approx=\"order2\")" ] }, { @@ -551,25 +550,25 @@ " r,\n", " gt_model_ideal_zdistrib,\n", " \"-b\",\n", - " label=r\"model w/ zdistrib, $M_{input}$ = %.2e Msun\" % cluster_m,\n", + " label=r\"w/ zdistrib, $M_{input}$ = %.2e Msun\" % cluster_m,\n", ")\n", "plt.loglog(\n", " r,\n", " gt_model_ideal_singlez,\n", " \"-y\",\n", - " label=r\"model w/o zdistrib, $M_{input}$ = %.2e Msun\" % cluster_m,\n", + " label=r\"w/o zdistrib, $M_{input}$ = %.2e Msun\" % cluster_m,\n", ")\n", "plt.loglog(\n", " r,\n", " gt_model_ideal_applegate14,\n", " \":r\",\n", - " label=r\"model applegate14, $M_{input}$ = %.2e Msun\" % cluster_m,\n", + " label=r\"applegate14, $M_{input}$ = %.2e Msun\" % cluster_m,\n", ")\n", "plt.loglog(\n", " r,\n", " gt_model_ideal_schrabback18,\n", " \":g\",\n", - " label=r\"model schrabback18, $M_{input}$ = %.2e Msun\" % cluster_m,\n", + " label=r\"schrabback18, $M_{input}$ = %.2e Msun\" % cluster_m,\n", ")\n", "\n", "plt.xlabel(\"r [Mpc]\", fontsize=20)\n", @@ -594,25 +593,25 @@ " r,\n", " gt_model_noisy_zdistrib,\n", " \"-b\",\n", - " label=r\"model w/ zdistrib, $M_{input}$ = %.2e Msun\" % cluster_m,\n", + " label=r\"w/ zdistrib, $M_{input}$ = %.2e Msun\" % cluster_m,\n", ")\n", "plt.loglog(\n", " r,\n", " gt_model_noisy_singlez,\n", " \"-y\",\n", - " label=r\"model w/o zdistrib, $M_{input}$ = %.2e Msun\" % cluster_m,\n", + " label=r\"w/o zdistrib, $M_{input}$ = %.2e Msun\" % cluster_m,\n", ")\n", "plt.loglog(\n", " r,\n", " gt_model_noisy_applegate14,\n", " \":r\",\n", - " label=r\"model applegate14, $M_{input}$ = %.2e Msun\" % cluster_m,\n", + " label=r\"applegate14, $M_{input}$ = %.2e Msun\" % cluster_m,\n", ")\n", "plt.loglog(\n", " r,\n", " gt_model_noisy_schrabback18,\n", " \":g\",\n", - " label=r\"model schrabback18, $M_{input}$ = %.2e Msun\" % cluster_m,\n", + " label=r\"schrabback18, $M_{input}$ = %.2e Msun\" % cluster_m,\n", ")\n", "\n", "plt.xlabel(\"r [Mpc]\", fontsize=20)\n", @@ -764,36 +763,32 @@ "source": [ "print(f\"The input mass = {cluster_m:.2e} Msun\\n\")\n", "\n", + "_prt_mfit = lambda mass, mass_err: f\"{mass*1e-14:.2f} +/- {mass_err*1e-14:.2f} x 10^14 Msun\"\n", + "\n", "print(\"Without accounting for the redshift distribution in the model\\n\")\n", - "print(\n", - " f\"Best fit mass for ideal data = {m_est_ideal_singlez:.2e} +/- {m_est_err_ideal_singlez:.2e} Msun\"\n", - ")\n", - "print(\n", - " f\"Best fit mass for noisy data = {m_est_noisy_singlez:.2e} +/- {m_est_err_noisy_singlez:.2e} Msun\\n\"\n", - ")\n", + "print(f\"Best fit mass for ideal data = {_prt_mfit(m_est_ideal_singlez, m_est_err_ideal_singlez)}\")\n", + "print(f\"Best fit mass for noisy data = {_prt_mfit(m_est_noisy_singlez, m_est_err_noisy_singlez)}\\n\")\n", "\n", "print(\"Accounting for the redshift distribution in the model\\n\")\n", + "print(f\"Best fit mass for ideal data = {_prt_mfit(m_est_ideal_zdistrib, m_est_err_ideal_zdistrib)}\")\n", "print(\n", - " f\"Best fit mass for ideal data = {m_est_ideal_zdistrib:.2e} +/- {m_est_err_ideal_zdistrib:.2e} Msun\"\n", - ")\n", - "print(\n", - " f\"Best fit mass for noisy data = {m_est_noisy_zdistrib:.2e} +/- {m_est_err_noisy_zdistrib:.2e} Msun\\n\"\n", + " f\"Best fit mass for noisy data = {_prt_mfit(m_est_noisy_zdistrib, m_est_err_noisy_zdistrib)}\\n\"\n", ")\n", "\n", "print(\"Using applegate14 (Applegate et al. 2014)\\n\")\n", "print(\n", - " f\"Best fit mass for ideal data = {m_est_ideal_applegate14:.2e} +/- {m_est_err_ideal_applegate14:.2e} Msun\"\n", + " f\"Best fit mass for ideal data = {_prt_mfit(m_est_ideal_applegate14, m_est_err_ideal_applegate14)}\"\n", ")\n", "print(\n", - " f\"Best fit mass for noisy data = {m_est_noisy_applegate14:.2e} +/- {m_est_err_noisy_applegate14:.2e} Msun\\n\"\n", + " f\"Best fit mass for noisy data = {_prt_mfit(m_est_noisy_applegate14, m_est_err_noisy_applegate14)}\\n\"\n", ")\n", "\n", "print(\"Using schrabback18 (Schrabback et al. 2018)\\n\")\n", "print(\n", - " f\"Best fit mass for ideal data = {m_est_ideal_schrabback18:.2e} +/- {m_est_err_ideal_schrabback18:.2e} Msun\"\n", + " f\"Best fit mass for ideal data = {_prt_mfit(m_est_ideal_schrabback18, m_est_err_ideal_schrabback18)}\"\n", ")\n", "print(\n", - " f\"Best fit mass for noisy data = {m_est_noisy_schrabback18:.2e} +/- {m_est_err_noisy_schrabback18:.2e} Msun\\n\"\n", + " f\"Best fit mass for noisy data = {_prt_mfit(m_est_noisy_schrabback18, m_est_err_noisy_schrabback18)}\\n\"\n", ")" ] }, @@ -864,6 +859,10 @@ "metadata": {}, "outputs": [], "source": [ + "_prt_mfit_lab = (\n", + " lambda mass, mass_err: rf\"${mass*1e-14:.2f} (\\pm {mass_err*1e-14:.2f}) \\times 10^{{14}}$ $M_\\odot$\"\n", + ")\n", + "\n", "plt.figure(figsize=(20, 10))\n", "plt.subplot(1, 2, 1)\n", "plt.title(r\"tangential shear $g_t$ (ideal data)\", fontsize=20)\n", @@ -874,31 +873,31 @@ " c=\"k\",\n", " linestyle=\"\",\n", " marker=\"o\",\n", - " label=r\"ideal data, $M_{input}$ = %.1e Msun\" % cluster_m,\n", + " label=rf\"ideal data, $M_{{input}}$ = ${cluster_m*1e-14:.2f} \\times 10^{{14}}$ $M_\\odot$\",\n", ")\n", "plt.loglog(\n", " r,\n", " gt_est_ideal_zdistrib,\n", " \"-b\",\n", - " label=rf\"model w/ zdistrib, M_fit = {m_est_ideal_zdistrib:.2e} $\\pm$ {m_est_err_ideal_zdistrib:.2e} Msun\",\n", + " label=rf\"w/ zdistrib, M_fit = {_prt_mfit_lab(m_est_ideal_zdistrib, m_est_err_ideal_zdistrib)}\",\n", ")\n", "plt.loglog(\n", " r,\n", " gt_est_ideal_applegate14,\n", " \":r\",\n", - " label=rf\"model applegate14, M_fit = {m_est_ideal_applegate14:.2e} $\\pm$ {m_est_err_ideal_applegate14:.2e} Msun\",\n", + " label=rf\"applegate14, M_fit = {_prt_mfit_lab(m_est_ideal_applegate14, m_est_err_ideal_applegate14)}\",\n", ")\n", "plt.loglog(\n", " r,\n", " gt_est_ideal_schrabback18,\n", " \":g\",\n", - " label=rf\"model schrabback18, M_fit = {m_est_ideal_schrabback18:.2e} $\\pm$ {m_est_err_ideal_schrabback18:.2e} Msun\",\n", + " label=rf\"schrabback18, M_fit = {_prt_mfit_lab(m_est_ideal_schrabback18, m_est_err_ideal_schrabback18)}\",\n", ")\n", "plt.loglog(\n", " r,\n", " gt_est_ideal_singlez,\n", " \"-y\",\n", - " label=rf\"model w/o zdistrib, M_fit = {m_est_ideal_singlez:.2e} $\\pm$ {m_est_err_ideal_singlez:.2e} Msun\",\n", + " label=rf\"w/o zdistrib, M_fit = {_prt_mfit_lab(m_est_ideal_singlez, m_est_err_ideal_singlez)}\",\n", ")\n", "\n", "plt.xlabel(\"r [Mpc]\", fontsize=20)\n", @@ -916,32 +915,32 @@ " c=\"k\",\n", " linestyle=\"\",\n", " marker=\"o\",\n", - " label=r\"noisy data, $M_{input}$ = %.1e Msun\" % cluster_m,\n", + " label=rf\"noisy data, $M_{{input}}$ = ${cluster_m*1e-14:.2f} \\times 10^{{14}}$ $M_\\odot$\",\n", ")\n", "# plt.loglog(r,gt_model_noisy,'-r', label='model, $M_{input}$ = %.3e Msun' % cluster_m)\n", "plt.loglog(\n", " r,\n", " gt_est_noisy_zdistrib,\n", " \"-b\",\n", - " label=rf\"model w/ zdistrib, M_fit = {m_est_noisy_zdistrib:.2e} $\\pm$ {m_est_err_noisy_zdistrib:.2e} Msun\",\n", + " label=rf\"w/ zdistrib, M_fit = {_prt_mfit_lab(m_est_noisy_zdistrib, m_est_err_noisy_zdistrib)}\",\n", ")\n", "plt.loglog(\n", " r,\n", " gt_est_noisy_applegate14,\n", " \":r\",\n", - " label=rf\"model applegate14, M_fit = {m_est_noisy_applegate14:.2e} $\\pm$ {m_est_err_noisy_applegate14:.2e} Msun\",\n", + " label=rf\"applegate14, M_fit = {_prt_mfit_lab(m_est_noisy_applegate14, m_est_err_noisy_applegate14)}\",\n", ")\n", "plt.loglog(\n", " r,\n", " gt_est_noisy_schrabback18,\n", " \":g\",\n", - " label=rf\"model schrabback18, M_fit = {m_est_noisy_schrabback18:.2e} $\\pm$ {m_est_err_noisy_schrabback18:.2e} Msun\",\n", + " label=rf\"schrabback18, M_fit = {_prt_mfit_lab(m_est_noisy_schrabback18, m_est_err_noisy_schrabback18)}\",\n", ")\n", "plt.loglog(\n", " r,\n", " gt_est_noisy_singlez,\n", " \"-y\",\n", - " label=rf\"model w/o zdistrib, M_fit = {m_est_noisy_singlez:.2e} $\\pm$ {m_est_err_noisy_singlez:.2e} Msun\",\n", + " label=rf\"w/o zdistrib, M_fit = {_prt_mfit_lab(m_est_noisy_singlez, m_est_err_noisy_singlez)}\",\n", ")\n", "\n", "plt.xlabel(\"r [Mpc]\", fontsize=20)\n", @@ -974,7 +973,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.6" + "version": "3.11.5" } }, "nbformat": 4, From 1b29e0b06a870075678da3c59fd8f05eed9df8a6 Mon Sep 17 00:00:00 2001 From: m-aguena Date: Thu, 16 Nov 2023 11:18:33 -0800 Subject: [PATCH 35/38] fix new use in examples/demo_theory_functionality.ipynb --- examples/demo_theory_functionality.ipynb | 21 +++++++++++++++++---- 1 file changed, 17 insertions(+), 4 deletions(-) diff --git a/examples/demo_theory_functionality.ipynb b/examples/demo_theory_functionality.ipynb index 31d720432..ce22a18b8 100644 --- a/examples/demo_theory_functionality.ipynb +++ b/examples/demo_theory_functionality.ipynb @@ -285,16 +285,29 @@ "metadata": {}, "outputs": [], "source": [ + "# Compute first beta\n", + "beta_kwargs = {\n", + " \"z_cl\": z_cl,\n", + " \"z_inf\": 10.0,\n", + " \"cosmo\": cosmo,\n", + " #'zmax' :zsrc_max,\n", + " #'delta_z_cut': delta_z_cut,\n", + " #'zmin': None,\n", + " \"z_distrib_func\": z_distrib_func,\n", + "}\n", + "beta_s_mean = clmm.utils.compute_beta_s_mean_from_distribution(**beta_kwargs)\n", + "beta_s_square_mean = clmm.utils.compute_beta_s_square_mean_from_distribution(**beta_kwargs)\n", + "\n", "gt_z = m.compute_reduced_tangential_shear(\n", " r3d,\n", " mdelta=cluster_mass,\n", " cdelta=cluster_concentration,\n", " z_cluster=z_cl,\n", - " z_src=z_distrib_func,\n", + " z_src=[beta_s_mean, beta_s_square_mean],\n", " cosmo=cosmo,\n", " delta_mdef=mass_Delta,\n", " halo_profile_model=density_profile_parametrization,\n", - " z_src_info=\"distribution\",\n", + " z_src_info=\"beta\",\n", " approx=\"order2\",\n", ")" ] @@ -496,7 +509,7 @@ " cosmo=cosmo,\n", " halo_profile_model=\"einasto\",\n", " alpha_ein=0.17,\n", - " use_projected_quad=True, # use quad_vec\n", + " use_projected_quad=True, # use quad_vec\n", " verbose=True,\n", ")\n", "\n", @@ -518,7 +531,7 @@ " cosmo=cosmo,\n", " halo_profile_model=\"einasto\",\n", " alpha_ein=0.17,\n", - " use_projected_quad=False, # default\n", + " use_projected_quad=False, # default\n", " verbose=True,\n", ")\n", "\n", From 5e8af97347875275ce3dc5ede2ffebc5336aa0a2 Mon Sep 17 00:00:00 2001 From: m-aguena Date: Thu, 16 Nov 2023 11:22:19 -0800 Subject: [PATCH 36/38] fix new use in examples/demo_theory_functionality_oo.ipynb --- examples/demo_theory_functionality_oo.ipynb | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/examples/demo_theory_functionality_oo.ipynb b/examples/demo_theory_functionality_oo.ipynb index 2274307df..b0d773f0b 100644 --- a/examples/demo_theory_functionality_oo.ipynb +++ b/examples/demo_theory_functionality_oo.ipynb @@ -132,8 +132,19 @@ "\n", "gt = moo.eval_reduced_tangential_shear(r3d, z_cl, z_src)\n", "# Lensing quantities assuming sources follow a given redshift distribution.\n", + "\n", + "# Compute first beta\n", + "beta_kwargs = {\n", + " \"z_cl\": z_cl,\n", + " \"z_inf\": 10.0,\n", + " \"cosmo\": cosmo,\n", + " \"z_distrib_func\": z_distrib_func,\n", + "}\n", + "beta_s_mean = clmm.utils.compute_beta_s_mean_from_distribution(**beta_kwargs)\n", + "beta_s_square_mean = clmm.utils.compute_beta_s_square_mean_from_distribution(**beta_kwargs)\n", + "\n", "gt_z = moo.eval_reduced_tangential_shear(\n", - " r3d, z_cl, z_distrib_func, z_src_info=\"distribution\", approx=\"order2\"\n", + " r3d, z_cl, [beta_s_mean, beta_s_square_mean], z_src_info=\"beta\", approx=\"order2\"\n", ")\n", "\n", "mu = moo.eval_magnification(r3d, z_cl, z_src)\n", From 024139cfe5303093591368d10af34128a02615fd Mon Sep 17 00:00:00 2001 From: m-aguena Date: Thu, 28 Mar 2024 08:53:43 -0700 Subject: [PATCH 37/38] Update version to 1.12.0 --- clmm/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/clmm/__init__.py b/clmm/__init__.py index b5e90d638..3499c132b 100644 --- a/clmm/__init__.py +++ b/clmm/__init__.py @@ -26,4 +26,4 @@ ) from . import support -__version__ = "1.11.1" +__version__ = "1.12.0" From b044dd776d47fd20bb900648ad032343aa0b49d5 Mon Sep 17 00:00:00 2001 From: m-aguena Date: Thu, 28 Mar 2024 10:24:09 -0700 Subject: [PATCH 38/38] add fix to skip pylint for astropy.units (fails in astropy 6) --- .github/workflows/build_check.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/build_check.yml b/.github/workflows/build_check.yml index a87a0a0bc..0949a3d07 100644 --- a/.github/workflows/build_check.yml +++ b/.github/workflows/build_check.yml @@ -41,7 +41,7 @@ jobs: - name: Analysing the code with pylint run: | pip install pylint - pylint clmm + pylint clmm --ignored-classes=astropy.units - name: Run the unit tests run: | pip install pytest pytest-cov