From 6f59c3bf391282dad66c188500ef0dd918ab7775 Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Sun, 28 Apr 2024 18:21:02 -0400 Subject: [PATCH 01/62] new line of sight distribution handling for multiple distributions and separate list of dictionary, including generalized extreme value distribution --- hierarc/Diagnostics/goodness_of_fit.py | 18 ++- .../KDELikelihood/kde_likelihood.py | 4 +- .../LensLikelihood/double_source_plane.py | 3 +- hierarc/Likelihood/cosmo_likelihood.py | 20 ++-- hierarc/Likelihood/hierarchy_likelihood.py | 79 ++++++------ hierarc/Likelihood/lens_sample_likelihood.py | 11 +- hierarc/Likelihood/los_distributions.py | 80 +++++++++++++ hierarc/Sampling/ParamManager/lens_param.py | 34 ------ hierarc/Sampling/ParamManager/los_param.py | 113 ++++++++++++++++++ .../Sampling/ParamManager/param_manager.py | 37 ++++-- test/test_Diagnostics/test_goodness_of_fit.py | 9 +- .../test_hierarchy_likelihood.py | 35 +++--- .../test_lens_sample_likelihood.py | 2 +- test/test_Likelihood/test_los_distribution.py | 103 ++++++++++++++++ .../test_ParamManager/test_lens_param.py | 16 +-- .../test_ParamManager/test_los_param.py | 75 ++++++++++++ .../test_ParamManager/test_param_manager.py | 31 +++-- 17 files changed, 524 insertions(+), 146 deletions(-) create mode 100644 hierarc/Likelihood/los_distributions.py create mode 100644 hierarc/Sampling/ParamManager/los_param.py create mode 100644 test/test_Likelihood/test_los_distribution.py create mode 100644 test/test_Sampling/test_ParamManager/test_los_param.py diff --git a/hierarc/Diagnostics/goodness_of_fit.py b/hierarc/Diagnostics/goodness_of_fit.py index cdfd82cf..8f14cb14 100644 --- a/hierarc/Diagnostics/goodness_of_fit.py +++ b/hierarc/Diagnostics/goodness_of_fit.py @@ -28,6 +28,7 @@ def plot_ddt_fit( cosmo, kwargs_lens, kwargs_kin, + kwargs_los, color_measurement=None, color_prediction=None, redshift_trend=False, @@ -64,7 +65,7 @@ def plot_ddt_fit( ddt_model_sigma, dd_model_mean, dd_model_sigma, - ) = likelihood.ddt_dd_model_prediction(cosmo, kwargs_lens=kwargs_lens) + ) = likelihood.ddt_dd_model_prediction(cosmo, kwargs_lens=kwargs_lens, kwargs_los=kwargs_los) ddt_name_list.append(name) ddt_model_mean_list.append(ddt_model_mean) @@ -134,13 +135,14 @@ def plot_ddt_fit( ax.legend() return f, ax - def kin_fit(self, cosmo, kwargs_lens, kwargs_kin): + def kin_fit(self, cosmo, kwargs_lens, kwargs_kin, kwargs_los): """Plots the prediction and the uncorrelated error bars on the individual lenses currently works for likelihood classes 'TDKinGaussian', 'KinGaussian'. :param cosmo: astropy.cosmology instance :param kwargs_lens: lens model parameter keyword arguments :param kwargs_kin: kinematics model keyword arguments + :param kwargs_los: line of sight list of dictionaries :return: list of name, measurement, measurement errors, model prediction, model prediction error """ @@ -160,7 +162,7 @@ def kin_fit(self, cosmo, kwargs_lens, kwargs_kin): sigma_v_predict_mean, cov_error_predict, ) = likelihood.sigma_v_measured_vs_predict( - cosmo, kwargs_lens=kwargs_lens, kwargs_kin=kwargs_kin + cosmo, kwargs_lens=kwargs_lens, kwargs_kin=kwargs_kin, kwargs_los=kwargs_los ) if sigma_v_measurement is not None: @@ -188,6 +190,7 @@ def plot_kin_fit( cosmo, kwargs_lens, kwargs_kin, + kwargs_los, color_measurement=None, color_prediction=None, ): @@ -197,11 +200,12 @@ def plot_kin_fit( :param cosmo: astropy.cosmology instance :param kwargs_lens: lens model parameter keyword arguments :param kwargs_kin: kinematics model keyword arguments + :param kwargs_los: line of sight list of dictionaries :param color_measurement: color of measurement :param color_prediction: color of model prediction :return: fig, axes of matplotlib instance """ - logL = self._sample_likelihood.log_likelihood(cosmo, kwargs_lens, kwargs_kin) + logL = self._sample_likelihood.log_likelihood(cosmo, kwargs_lens, kwargs_kin, kwargs_los=kwargs_los) print(logL, "log likelihood") ( sigma_v_name_list, @@ -209,7 +213,7 @@ def plot_kin_fit( sigma_v_measurement_error_list, sigma_v_model_list, sigma_v_model_error_list, - ) = self.kin_fit(cosmo, kwargs_lens, kwargs_kin) + ) = self.kin_fit(cosmo, kwargs_lens, kwargs_kin, kwargs_los) f, ax = plt.subplots(1, 1, figsize=(int(len(sigma_v_name_list) / 2), 4)) ax.errorbar( @@ -256,6 +260,7 @@ def plot_ifu_fit( cosmo, kwargs_lens, kwargs_kin, + kwargs_los, lens_index, bin_edges, show_legend=True, @@ -268,6 +273,7 @@ def plot_ifu_fit( :param cosmo: astropy.cosmology instance :param kwargs_lens: lens model parameter keyword arguments :param kwargs_kin: kinematics model keyword arguments + :param kwargs_los: line of sight list of dictionaries :param lens_index: int, index in kwargs_lens to be plotted (needs to be of type 'IFUKinCov') :param bin_edges: radial bin edges in arc seconds. If number, then uniform @@ -293,7 +299,7 @@ def plot_ifu_fit( sigma_v_predict_mean, cov_error_predict, ) = likelihood.sigma_v_measured_vs_predict( - cosmo, kwargs_lens=kwargs_lens, kwargs_kin=kwargs_kin + cosmo, kwargs_lens=kwargs_lens, kwargs_kin=kwargs_kin, kwargs_los=kwargs_los ) if len(np.atleast_1d(bin_edges)) < 2: diff --git a/hierarc/Likelihood/KDELikelihood/kde_likelihood.py b/hierarc/Likelihood/KDELikelihood/kde_likelihood.py index 809bd63e..7357c1a9 100644 --- a/hierarc/Likelihood/KDELikelihood/kde_likelihood.py +++ b/hierarc/Likelihood/KDELikelihood/kde_likelihood.py @@ -64,9 +64,9 @@ def init_loglikelihood(self): ) self.loglikelihood = self.kdelikelihood() else: - raise ValueError( + raise NameError( "likelihood_type %s not supported! Supported are %s." - % (likelihood_type, LIKELIHOOD_TYPES) + % (self.loglikelihood_type, LIKELIHOOD_TYPES) ) def kdelikelihood(self): diff --git a/hierarc/Likelihood/LensLikelihood/double_source_plane.py b/hierarc/Likelihood/LensLikelihood/double_source_plane.py index d45dd009..b742183a 100644 --- a/hierarc/Likelihood/LensLikelihood/double_source_plane.py +++ b/hierarc/Likelihood/LensLikelihood/double_source_plane.py @@ -30,7 +30,7 @@ def __init__( self._normalized = normalized def lens_log_likelihood( - self, cosmo, kwargs_lens=None, kwargs_kin=None, kwargs_source=None + self, cosmo, kwargs_lens=None, kwargs_kin=None, kwargs_source=None, kwargs_los=None ): """Log likelihood of the data given a model. @@ -38,6 +38,7 @@ def lens_log_likelihood( :param kwargs_lens: keyword arguments of lens :param kwargs_kin: keyword arguments of kinematics :param kwargs_source: keyword argument of source + :param kwargs_los: keyword argument list of line of sight :return: log likelihood of data given model """ beta_model = self._beta_model(cosmo) diff --git a/hierarc/Likelihood/cosmo_likelihood.py b/hierarc/Likelihood/cosmo_likelihood.py index 5be38d85..46c9c2ae 100644 --- a/hierarc/Likelihood/cosmo_likelihood.py +++ b/hierarc/Likelihood/cosmo_likelihood.py @@ -27,8 +27,8 @@ def __init__( gamma_in_distribution="NONE", log_m2l_sampling=False, log_m2l_distribution="NONE", - kappa_ext_sampling=False, - kappa_ext_distribution="NONE", + los_sampling=False, + los_distributions=None, alpha_lambda_sampling=False, beta_lambda_sampling=False, alpha_gamma_in_sampling=False, @@ -73,8 +73,10 @@ def __init__( according to the lens posterior kwargs 'lambda_scaling_property' :param beta_lambda_sampling: bool, if True samples a parameter beta_lambda, which scales lambda_mst linearly according to the lens posterior kwargs 'lambda_scaling_property_beta' - :param kappa_ext_sampling: bool, if True samples a global external convergence parameter - :param kappa_ext_distribution: string, distribution function of the kappa_ext parameter + :param los_sampling: if sampling of the parameters should be done + :type los_sampling: bool + :param los_distributions: what distribution to be sampled + :type los_distributions: list of str :param anisotropy_sampling: bool, if True adds a global stellar anisotropy parameter that alters the single lens kinematic prediction :param anisotropy_model: string, specifies the stellar anisotropy model @@ -106,7 +108,8 @@ def __init__( if sigma_v_systematics is True: normalized = True self._likelihoodLensSample = LensSampleLikelihood( - kwargs_likelihood_list, normalized=normalized + kwargs_likelihood_list, normalized=normalized, + los_distributions=los_distributions ) self.param = ParamManager( cosmology, @@ -127,8 +130,8 @@ def __init__( sne_distribution=sne_distribution, z_apparent_m_anchor=z_apparent_m_anchor, sigma_v_systematics=sigma_v_systematics, - kappa_ext_sampling=kappa_ext_sampling, - kappa_ext_distribution=kappa_ext_distribution, + los_sampling=los_sampling, + los_distributions=los_distributions, anisotropy_sampling=anisotropy_sampling, anisotropy_model=anisotropy_model, anisotropy_distribution=anisotropy_distribution, @@ -188,7 +191,7 @@ def likelihood(self, args, kwargs_cosmo_interp=None): if args[i] < self._lower_limit[i] or args[i] > self._upper_limit[i]: return -np.inf - kwargs_cosmo, kwargs_lens, kwargs_kin, kwargs_source = self.param.args2kwargs( + kwargs_cosmo, kwargs_lens, kwargs_kin, kwargs_source, kwargs_los = self.param.args2kwargs( args ) if self._cosmology == "oLCDM": @@ -215,6 +218,7 @@ def likelihood(self, args, kwargs_cosmo_interp=None): kwargs_lens=kwargs_lens, kwargs_kin=kwargs_kin, kwargs_source=kwargs_source, + kwargs_los=kwargs_los, ) if self._sne_evaluate is True: diff --git a/hierarc/Likelihood/hierarchy_likelihood.py b/hierarc/Likelihood/hierarchy_likelihood.py index af2127fd..3294023b 100644 --- a/hierarc/Likelihood/hierarchy_likelihood.py +++ b/hierarc/Likelihood/hierarchy_likelihood.py @@ -1,13 +1,13 @@ from hierarc.Likelihood.transformed_cosmography import TransformedCosmography from hierarc.Likelihood.LensLikelihood.base_lens_likelihood import LensLikelihoodBase from hierarc.Likelihood.parameter_scaling import ParameterScalingIFU -from hierarc.Util.distribution_util import PDFSampling +from hierarc.Likelihood.los_distributions import LOSDistribution import numpy as np import copy class LensLikelihood(TransformedCosmography, LensLikelihoodBase, ParameterScalingIFU): - """Master class containing the likelihood definitions of different analysis for s + """Master class containing the likelihood definitions of different analysis for a single lens.""" def __init__( @@ -24,7 +24,7 @@ def __init__( log_m2l_array=None, param_scaling_grid_list=None, num_distribution_draws=50, - kappa_ext_bias=False, + global_los_distribution=False, kappa_pdf=None, kappa_bin_edges=None, mst_ifu=False, @@ -34,6 +34,7 @@ def __init__( kwargs_lens_properties=None, gamma_in_prior_mean=None, gamma_in_prior_std=None, + los_distributions=None, **kwargs_likelihood ): """ @@ -52,8 +53,9 @@ def __init__( anisotropy, gamma_in, and log_m2l. In that case, gamma_in_array and log_m2l_array need to be provided. :param num_distribution_draws: int, number of distribution draws from the likelihood that are being averaged over - :param kappa_ext_bias: bool, if True incorporates the global external selection function into the likelihood. - If False, the likelihood needs to incorporate the individual selection function with sufficient accuracy. + :param global_los_distribution: if integer, will draw from the global kappa distribution specified in that + integer. If False, will instead draw from the distribution specified in kappa_pdf. + :type global_los_distribution: bool or integer :param kappa_pdf: array of probability density function of the external convergence distribution binned according to kappa_bin_edges :param kappa_bin_edges: array of length (len(kappa_pdf)+1), bin edges of the kappa PDF @@ -69,7 +71,9 @@ def __init__( :param gamma_in_prior_mean: prior mean for inner power-law slope of the NFW profile, if available :param gamma_in_prior_std: standard deviation of the Gaussian prior for gamma_in :param kwargs_likelihood: keyword arguments specifying the likelihood function, - see individual classes for their use + see individual classes for their use + :param los_distributions: list of all line of sight distributions parameterized + :type los_distributions: list of str or None """ TransformedCosmography.__init__(self, z_lens=z_lens, z_source=z_source) if ani_scaling_array_list is None and ani_scaling_array is not None: @@ -122,15 +126,11 @@ def __init__( **kwargs_likelihood ) self._num_distribution_draws = int(num_distribution_draws) - self._kappa_ext_bias = kappa_ext_bias + + self._los = LOSDistribution(kappa_pdf=kappa_pdf, kappa_bin_edges=kappa_bin_edges, + global_los_distribution=global_los_distribution, + los_distributions=los_distributions) self._mst_ifu = mst_ifu - if kappa_pdf is not None and kappa_bin_edges is not None: - self._kappa_dist = PDFSampling( - bin_edges=kappa_bin_edges, pdf_array=kappa_pdf - ) - self._draw_kappa = True - else: - self._draw_kappa = False self._lambda_scaling_property = lambda_scaling_property self._lambda_scaling_property_beta = lambda_scaling_property_beta self._gamma_in_array = gamma_in_array @@ -140,7 +140,7 @@ def __init__( self._gamma_in_prior_std = gamma_in_prior_std def lens_log_likelihood( - self, cosmo, kwargs_lens=None, kwargs_kin=None, kwargs_source=None + self, cosmo, kwargs_lens=None, kwargs_kin=None, kwargs_source=None, kwargs_los=None, ): """Log likelihood of the data of a lens given a model (defined with hyper- parameters) and cosmology. @@ -149,6 +149,7 @@ def lens_log_likelihood( :param kwargs_lens: keywords of the hyper parameters of the lens model :param kwargs_kin: keyword arguments of the kinematic model hyper parameters :param kwargs_source: keyword argument of the source model (such as SNe) + :param kwargs_los: list of keyword arguments of global line of sight distributions :return: log likelihood of the data given the model """ @@ -168,6 +169,7 @@ def lens_log_likelihood( kwargs_lens=kwargs_lens, kwargs_kin=kwargs_kin, kwargs_source=kwargs_source, + kwargs_los=kwargs_los, cosmo=cosmo, ) return a @@ -180,6 +182,7 @@ def hyper_param_likelihood( kwargs_lens=None, kwargs_kin=None, kwargs_source=None, + kwargs_los=None, cosmo=None, ): """Log likelihood of the data of a lens given a model (defined with hyper- @@ -191,6 +194,7 @@ def hyper_param_likelihood( :param kwargs_lens: keywords of the hyper parameters of the lens model :param kwargs_kin: keyword arguments of the kinematic model hyper parameters :param kwargs_source: keyword argument of the source model (such as SNe) + :param kwargs_los: list of keyword arguments of global line of sight distributions :param cosmo: astropy.cosmology instance :return: log likelihood given the single lens analysis for the given hyper parameter @@ -202,7 +206,7 @@ def hyper_param_likelihood( sigma_v_sys_error = kwargs_kin_copy.pop("sigma_v_sys_error", None) if self.check_dist( - kwargs_lens, kwargs_kin, kwargs_source + kwargs_lens, kwargs_kin, kwargs_source, kwargs_los ): # sharp distributions return self.log_likelihood_single( ddt, @@ -211,6 +215,7 @@ def hyper_param_likelihood( kwargs_lens, kwargs_kin_copy, kwargs_source, + kwargs_los, sigma_v_sys_error=sigma_v_sys_error, ) else: @@ -223,6 +228,7 @@ def hyper_param_likelihood( kwargs_lens, kwargs_kin_copy, kwargs_source, + kwargs_los, sigma_v_sys_error=sigma_v_sys_error, ) exp_logl = np.exp(logl) @@ -240,6 +246,7 @@ def log_likelihood_single( kwargs_lens, kwargs_kin, kwargs_source, + kwargs_los=None, sigma_v_sys_error=None, ): """Log likelihood of the data of a lens given a specific model (as a draw from @@ -251,12 +258,14 @@ def log_likelihood_single( :param kwargs_lens: keywords of the hyper parameters of the lens model :param kwargs_kin: keyword arguments of the kinematic model hyper parameters :param kwargs_source: keyword arguments of source brightness + :param kwargs_los: line of sight list of dictionaries :param sigma_v_sys_error: unaccounted uncertainty in the velocity dispersion measurement :return: log likelihood given the single lens analysis for a single (random) realization of the hyper parameter distribution """ - lambda_mst, kappa_ext, gamma_ppn = self.draw_lens(**kwargs_lens) + lambda_mst, gamma_ppn = self.draw_lens(**kwargs_lens) + kappa_ext = self._los.draw_los(kwargs_los) # draw intrinsic source magnitude mag_source = self.draw_source(lum_dist=delta_lum_dist, **kwargs_source) ddt_, dd_, mag_source_ = self.displace_prediction( @@ -420,37 +429,35 @@ def luminosity_distance_modulus(self, cosmo, z_apparent_m_anchor): delta_lum_dist = lum_dists - lum_dist_anchor return delta_lum_dist - def check_dist(self, kwargs_lens, kwargs_kin, kwargs_source): + def check_dist(self, kwargs_lens, kwargs_kin, kwargs_source, kwargs_los): """Checks if the provided keyword arguments describe a distribution function of hyper parameters or are single values. :param kwargs_lens: lens model hyper-parameter keywords :param kwargs_kin: kinematic model hyper-parameter keywords :param kwargs_source: source brightness hyper-parameter keywords + :param kwargs_los: list of dictionaries for line of sight hyper-parameters :return: bool, True if delta function, else False """ lambda_mst_sigma = kwargs_lens.get("lambda_mst_sigma", 0) # scatter in MST - kappa_ext_sigma = kwargs_lens.get("kappa_ext_sigma", 0) + draw_kappa_bool = self._los.draw_bool(kwargs_los) a_ani_sigma = kwargs_kin.get("a_ani_sigma", 0) beta_inf_sigma = kwargs_kin.get("beta_inf_sigma", 0) sne_sigma = kwargs_source.get("sigma_sne", 0) if ( a_ani_sigma == 0 and lambda_mst_sigma == 0 - and kappa_ext_sigma == 0 and beta_inf_sigma == 0 and sne_sigma == 0 + and not draw_kappa_bool ): - if self._draw_kappa is False: - return True + return True return False def draw_lens( self, lambda_mst=1, lambda_mst_sigma=0, - kappa_ext=0, - kappa_ext_sigma=0, gamma_ppn=1, lambda_ifu=1, lambda_ifu_sigma=0, @@ -468,8 +475,6 @@ def draw_lens( :param lambda_mst: MST transform :param lambda_mst_sigma: spread in the distribution - :param kappa_ext: external convergence mean in distribution - :param kappa_ext_sigma: spread in the distribution :param gamma_ppn: Post-Newtonian parameter :param lambda_ifu: secondary lambda_mst parameter for subset of lenses specified for @@ -503,13 +508,7 @@ def draw_lens( + beta_lambda * self._lambda_scaling_property_beta ) lambda_mst_draw = np.random.normal(lambda_lens, lambda_mst_sigma) - if self._draw_kappa is True: - kappa_ext_draw = self._kappa_dist.draw_one - elif self._kappa_ext_bias is True: - kappa_ext_draw = np.random.normal(kappa_ext, kappa_ext_sigma) - else: - kappa_ext_draw = 0 - return lambda_mst_draw, kappa_ext_draw, gamma_ppn + return lambda_mst_draw, gamma_ppn @staticmethod def draw_source(mu_sne=1, sigma_sne=0, lum_dist=0, **kwargs): @@ -530,13 +529,14 @@ def draw_source(mu_sne=1, sigma_sne=0, lum_dist=0, **kwargs): # return linear amplitude with base log 10 return mag_source - def sigma_v_measured_vs_predict(self, cosmo, kwargs_lens=None, kwargs_kin=None): + def sigma_v_measured_vs_predict(self, cosmo, kwargs_lens=None, kwargs_kin=None, kwargs_los=None): """Mean and error covariance of velocity dispersion measurement mean and error covariance of velocity dispersion predictions. :param cosmo: astropy.cosmology instance :param kwargs_lens: keywords of the hyper parameters of the lens model - :param kwargs_kin: keyword arguments of the kinematic model hyper parameters + :param kwargs_kin: keyword arguments of the kinematic model hyper-parameters + :param kwargs_los: line of sight parapers :return: sigma_v_measurement, cov_error_measurement, sigma_v_predict_mean, cov_error_predict """ @@ -557,7 +557,8 @@ def sigma_v_measured_vs_predict(self, cosmo, kwargs_lens=None, kwargs_kin=None): sigma_v_predict_mean = np.zeros_like(sigma_v_measurement) cov_error_predict = np.zeros_like(cov_error_measurement) for i in range(self._num_distribution_draws): - lambda_mst, kappa_ext, gamma_ppn = self.draw_lens(**kwargs_lens) + lambda_mst, gamma_ppn = self.draw_lens(**kwargs_lens) + kappa_ext = self._los.draw_los(kwargs_los) ddt_, dd_, _ = self.displace_prediction( ddt, dd, gamma_ppn=gamma_ppn, lambda_mst=lambda_mst, kappa_ext=kappa_ext ) @@ -586,12 +587,13 @@ def sigma_v_measured_vs_predict(self, cosmo, kwargs_lens=None, kwargs_kin=None): cov_error_predict, ) - def ddt_dd_model_prediction(self, cosmo, kwargs_lens=None): + def ddt_dd_model_prediction(self, cosmo, kwargs_lens=None, kwargs_los=None): """Predicts the model uncertainty corrected ddt prediction of the applied model (e.g. power-law) :param cosmo: astropy.cosmology instance :param kwargs_lens: keywords of the hyper parameters of the lens model + :param kwargs_los: line of slight list of dictionaries :return: ddt_model mean, ddt_model sigma, dd_model mean, dd_model sigma """ if kwargs_lens is None: @@ -600,7 +602,8 @@ def ddt_dd_model_prediction(self, cosmo, kwargs_lens=None): ddt_draws = [] dd_draws = [] for i in range(self._num_distribution_draws): - lambda_mst, kappa_ext, gamma_ppn = self.draw_lens(**kwargs_lens) + lambda_mst, gamma_ppn = self.draw_lens(**kwargs_lens) + kappa_ext = self._los.draw_los(kwargs_los) ddt_, dd_, _ = self.displace_prediction( ddt, dd, gamma_ppn=gamma_ppn, lambda_mst=lambda_mst, kappa_ext=kappa_ext ) diff --git a/hierarc/Likelihood/lens_sample_likelihood.py b/hierarc/Likelihood/lens_sample_likelihood.py index 7385aa3c..3b0bc539 100644 --- a/hierarc/Likelihood/lens_sample_likelihood.py +++ b/hierarc/Likelihood/lens_sample_likelihood.py @@ -9,12 +9,14 @@ class LensSampleLikelihood(object): diameter posteriors Currently this class does not include possible covariances between the lens samples.""" - def __init__(self, kwargs_lens_list, normalized=False): + def __init__(self, kwargs_lens_list, normalized=False, los_distributions=None): """ :param kwargs_lens_list: keyword argument list specifying the arguments of the LensLikelihood class :param normalized: bool, if True, returns the normalized likelihood, if False, separates the constant prefactor (in case of a Gaussian 1/(sigma sqrt(2 pi)) ) to compute the reduced chi2 statistics + :param los_distributions: list of all line of sight distributions parameterized + :type los_distributions: list of str or None """ self._lens_list = [] for kwargs_lens in kwargs_lens_list: @@ -26,11 +28,12 @@ def __init__(self, kwargs_lens_list, normalized=False): ) else: self._lens_list.append( - LensLikelihood(normalized=normalized, **kwargs_lens) + LensLikelihood(normalized=normalized, los_distributions=los_distributions, **kwargs_lens) ) def log_likelihood( - self, cosmo, kwargs_lens=None, kwargs_kin=None, kwargs_source=None + self, cosmo, kwargs_lens=None, kwargs_kin=None, kwargs_source=None, + kwargs_los=None, ): """ @@ -38,6 +41,7 @@ def log_likelihood( :param kwargs_lens: keywords of the parameters of the lens model :param kwargs_kin: keyword arguments of the kinematic model :param kwargs_source: keyword argument of the source model (such as SNe) + :param kwargs_los: line of sight keyword argument list :return: log likelihood of the combined lenses """ log_likelihood = 0 @@ -47,6 +51,7 @@ def log_likelihood( kwargs_lens=kwargs_lens, kwargs_kin=kwargs_kin, kwargs_source=kwargs_source, + kwargs_los=kwargs_los, ) return log_likelihood diff --git a/hierarc/Likelihood/los_distributions.py b/hierarc/Likelihood/los_distributions.py new file mode 100644 index 00000000..9a7bd8a5 --- /dev/null +++ b/hierarc/Likelihood/los_distributions.py @@ -0,0 +1,80 @@ +import numpy as np +from hierarc.Util.distribution_util import PDFSampling + + +class LOSDistribution(object): + """ + line of sight distribution drawing + """ + def __init__(self, kappa_pdf=None, kappa_bin_edges=None, global_los_distribution=False, + los_distributions=None): + """ + + :param global_los_distribution: if integer, will draw from the global kappa distribution specified in that + integer. If False, will instead draw from the distribution specified in kappa_pdf. + :type global_los_distribution: bool or int + :param kappa_pdf: array of probability density function of the external convergence distribution + binned according to kappa_bin_edges + :param kappa_bin_edges: array of length (len(kappa_pdf)+1), bin edges of the kappa PDF + :param los_distributions: list of all line of sight distributions parameterized + :type los_distributions: list of str or None + """ + + self._global_los_distribution = global_los_distribution + if isinstance(self._global_los_distribution, int) and self._global_los_distribution is not False: + self._draw_kappa_global = True + self._los_distribution = los_distributions[global_los_distribution] + else: + self._draw_kappa_global = False + if kappa_pdf is not None and kappa_bin_edges is not None and not self._draw_kappa_global: + print("test kappa pdf sampling") + self._kappa_dist = PDFSampling( + bin_edges=kappa_bin_edges, pdf_array=kappa_pdf + ) + self._draw_kappa_individual = True + else: + self._draw_kappa_individual = False + + def draw_los(self, kwargs_los, size=1): + """ + Draw from the distribution of line of sight convergence + + :param kwargs_los: line of sight parameters + :type kwargs_los: list of dict + :param size: how many samples to be drawn + :type size: int>0 + :return: external convergence draw + """ + if self._draw_kappa_individual is True: + kappa_ext_draw = self._kappa_dist.draw(n=size) + elif self._draw_kappa_global: + kwargs_los_i = kwargs_los[self._global_los_distribution] + if self._los_distribution == "GAUSSIAN": + los_mean = kwargs_los_i["mean"] + los_sigma = kwargs_los_i["sigma"] + kappa_ext_draw = np.random.normal(los_mean, los_sigma, size=size) + elif self._los_distribution == "GEV": + mean = kwargs_los_i["mean"] + sigma = kwargs_los_i["sigma"] + xi = kwargs_los_i["xi"] + from scipy.stats import genextreme + kappa_ext_draw = genextreme.rvs(c=xi, loc=mean, scale=sigma, size=size) + else: + raise ValueError("line of sight distribution %s not valid." % self._los_distribution) + else: + kappa_ext_draw = 0 + return kappa_ext_draw + + def draw_bool(self, kwargs_los): + """ + whether single-valued or extended distribution (need to draw from) + + :param kwargs_los: list of keyword arguments for line of sight distributions + :return: boolean, True with samples need to be drawn, else False + """ + if self._draw_kappa_individual is True: + return True + elif self._draw_kappa_global is True: + if kwargs_los[self._global_los_distribution]["sigma"] != 0: + return True + return False diff --git a/hierarc/Sampling/ParamManager/lens_param.py b/hierarc/Sampling/ParamManager/lens_param.py index 7cda2414..9b2e03af 100644 --- a/hierarc/Sampling/ParamManager/lens_param.py +++ b/hierarc/Sampling/ParamManager/lens_param.py @@ -14,8 +14,6 @@ def __init__( gamma_in_distribution="NONE", log_m2l_sampling=False, log_m2l_distribution="NONE", - kappa_ext_sampling=False, - kappa_ext_distribution="NONE", alpha_lambda_sampling=False, beta_lambda_sampling=False, alpha_gamma_in_sampling=False, @@ -58,8 +56,6 @@ def __init__( self._gamma_in_distribution = gamma_in_distribution self._log_m2l_sampling = log_m2l_sampling self._log_m2l_distribution = log_m2l_distribution - self._kappa_ext_sampling = kappa_ext_sampling - self._kappa_ext_distribution = kappa_ext_distribution self._alpha_lambda_sampling = alpha_lambda_sampling self._beta_lambda_sampling = beta_lambda_sampling self._alpha_gamma_in_sampling = alpha_gamma_in_sampling @@ -137,18 +133,6 @@ def param_list(self, latex_style=False): list.append(r"$\sigma(\Upsilon_{\rm stars})$") else: list.append("log_m2l_sigma") - if self._kappa_ext_sampling is True: - if "kappa_ext" not in self._kwargs_fixed: - if latex_style is True: - list.append(r"$\overline{\kappa}_{\rm ext}$") - else: - list.append("kappa_ext") - if self._kappa_ext_distribution == "GAUSSIAN": - if "kappa_ext_sigma" not in self._kwargs_fixed: - if latex_style is True: - list.append(r"$\sigma(\kappa_{\rm ext})$") - else: - list.append("kappa_ext_sigma") if self._alpha_lambda_sampling is True: if "alpha_lambda" not in self._kwargs_fixed: if latex_style is True: @@ -242,18 +226,6 @@ def args2kwargs(self, args, i=0): else: kwargs["log_m2l_sigma"] = args[i] i += 1 - if self._kappa_ext_sampling is True: - if "kappa_ext" in self._kwargs_fixed: - kwargs["kappa_ext"] = self._kwargs_fixed["kappa_ext"] - else: - kwargs["kappa_ext"] = args[i] - i += 1 - if self._kappa_ext_distribution == "GAUSSIAN": - if "kappa_ext_sigma" in self._kwargs_fixed: - kwargs["kappa_ext_sigma"] = self._kwargs_fixed["kappa_ext_sigma"] - else: - kwargs["kappa_ext_sigma"] = args[i] - i += 1 if self._alpha_lambda_sampling is True: if "alpha_lambda" in self._kwargs_fixed: kwargs["alpha_lambda"] = self._kwargs_fixed["alpha_lambda"] @@ -324,12 +296,6 @@ def kwargs2args(self, kwargs): args.append(np.log10(kwargs["log_m2l_sigma"])) else: args.append(kwargs["log_m2l_sigma"]) - if self._kappa_ext_sampling is True: - if "kappa_ext" not in self._kwargs_fixed: - args.append(kwargs["kappa_ext"]) - if self._kappa_ext_distribution == "GAUSSIAN": - if "kappa_ext_sigma" not in self._kwargs_fixed: - args.append(kwargs["kappa_ext_sigma"]) if self._alpha_lambda_sampling is True: if "alpha_lambda" not in self._kwargs_fixed: args.append(kwargs["alpha_lambda"]) diff --git a/hierarc/Sampling/ParamManager/los_param.py b/hierarc/Sampling/ParamManager/los_param.py new file mode 100644 index 00000000..3ed09df3 --- /dev/null +++ b/hierarc/Sampling/ParamManager/los_param.py @@ -0,0 +1,113 @@ +_LOS_DISTRIBUTIONS = ["GEV", "GAUSSIAN", "NONE"] + + +class LOSParam(object): + """Manager for the source property parameters (currently particularly source + magnitudes for SNe)""" + + def __init__( + self, + los_sampling=False, + los_distributions=None, + kwargs_fixed=None, + + ): + """ + + :param los_sampling: if sampling of the parameters should be done + :type los_sampling: bool + :param los_distributions: what distribution to be sampled + :type los_distributions: list of str + :param kwargs_fixed: fixed arguments in sampling + :type kwargs_fixed: list of dictionaries or None + """ + self._los_sampling = los_sampling + if los_distributions is None: + los_distributions = [] + for los_distribution in los_distributions: + if los_distribution not in _LOS_DISTRIBUTIONS: + raise ValueError( + "SNE distribution %s not supported. Please chose among %s." + % (los_distribution, _LOS_DISTRIBUTIONS) + ) + self._los_distributions = los_distributions + if kwargs_fixed is None: + kwargs_fixed = [{} for _ in range(len(los_distributions))] + self._kwargs_fixed = kwargs_fixed + + def param_list(self, latex_style=False): + """ + + :param latex_style: bool, if True returns strings in latex symbols, else in the convention of the sampler + :return: list of the free parameters being sampled in the same order as the sampling + """ + name_list = [] + if self._los_sampling is True: + for i, los_distribution in enumerate(self._los_distributions): + if los_distribution in ["GEV", "GAUSSIAN"]: + if "mean" not in self._kwargs_fixed[i]: + if latex_style is True: + name_list.append(r"$\mu_{\rm los %s}$" %i) + else: + name_list.append(str("mean_los_"+str(i))) + if "sigma" not in self._kwargs_fixed[i]: + if latex_style is True: + name_list.append(r"$\sigma_{\rm los %s}$" %i) + else: + name_list.append(str("sigma_los_"+str(i))) + if los_distribution in ["GEV"]: + if "xi" not in self._kwargs_fixed[i]: + if latex_style is True: + name_list.append(r"$\xi_{\rm los} %s$" %i) + else: + name_list.append(str("xi_los_" + str(i))) + #str(name + "_" + type + str(k)) + return name_list + + def args2kwargs(self, args, i=0): + """ + + :param args: sampling argument list + :param i: index of argument list to start reading out + :return: keyword argument list with parameter names + """ + kwargs = [{} for _ in range(len(self._los_distributions))] + if self._los_sampling is True: + for k, los_distribution in enumerate(self._los_distributions): + if los_distribution in ["GEV", "GAUSSIAN"]: + if "mean" in self._kwargs_fixed[k]: + kwargs[k]["mean"] = self._kwargs_fixed[k]["mean"] + else: + kwargs[k]["mean"] = args[i] + i += 1 + if "sigma" in self._kwargs_fixed[k]: + kwargs[k]["sigma"] = self._kwargs_fixed[k]["sigma"] + else: + kwargs[k]["sigma"] = args[i] + i += 1 + if los_distribution in ["GEV"]: + if "xi" in self._kwargs_fixed[k]: + kwargs[k]["xi"] = self._kwargs_fixed[k]["xi"] + else: + kwargs[k]["xi"] = args[i] + i += 1 + return kwargs, i + + def kwargs2args(self, kwargs): + """ + + :param kwargs: keyword argument list of parameters + :return: sampling argument list in specified order + """ + args = [] + if self._los_sampling is True: + for k, los_distribution in enumerate(self._los_distributions): + if los_distribution in ["GEV", "GAUSSIAN"]: + if "mean" not in self._kwargs_fixed[k]: + args.append(kwargs[k]["mean"]) + if "sigma" not in self._kwargs_fixed[k]: + args.append(kwargs[k]["sigma"]) + if los_distribution in ["GEV"]: + if "xi" not in self._kwargs_fixed[k]: + args.append(kwargs[k]["xi"]) + return args diff --git a/hierarc/Sampling/ParamManager/param_manager.py b/hierarc/Sampling/ParamManager/param_manager.py index aa56ec6b..34c00b51 100644 --- a/hierarc/Sampling/ParamManager/param_manager.py +++ b/hierarc/Sampling/ParamManager/param_manager.py @@ -2,6 +2,7 @@ from hierarc.Sampling.ParamManager.cosmo_param import CosmoParam from hierarc.Sampling.ParamManager.lens_param import LensParam from hierarc.Sampling.ParamManager.source_param import SourceParam +from hierarc.Sampling.ParamManager.los_param import LOSParam class ParamManager(object): @@ -20,8 +21,6 @@ def __init__( gamma_in_distribution="NONE", log_m2l_sampling=False, log_m2l_distribution="NONE", - kappa_ext_sampling=False, - kappa_ext_distribution="NONE", lambda_ifu_sampling=False, lambda_ifu_distribution="NONE", alpha_lambda_sampling=False, @@ -33,6 +32,8 @@ def __init__( sne_distribution="GAUSSIAN", z_apparent_m_anchor=0.1, log_scatter=False, + los_sampling=False, + los_distributions=None, kwargs_lower_cosmo=None, kwargs_upper_cosmo=None, kwargs_fixed_cosmo=None, @@ -45,6 +46,9 @@ def __init__( kwargs_lower_source=None, kwargs_upper_source=None, kwargs_fixed_source=None, + kwargs_lower_los=None, + kwargs_upper_los=None, + kwargs_fixed_los=None, ): """ @@ -78,6 +82,12 @@ def __init__( :param sigma_v_systematics: bool, if True samples paramaters relative to systematics in the velocity dispersion measurement :param log_scatter: boolean, if True, samples the Gaussian scatter amplitude in log space (and thus flat prior in log) + :param los_sampling: if sampling of the parameters should be done + :type los_sampling: bool + :param los_distributions: list of line of sight distributions to be sampled + :type los_distributions: list of str + :param kwargs_fixed_los: fixed arguments in sampling + :type kwargs_fixed_los: list of dictionaries for each los distribution """ self._kin_param = KinParam( anisotropy_sampling=anisotropy_sampling, @@ -101,8 +111,6 @@ def __init__( gamma_in_distribution=gamma_in_distribution, log_m2l_sampling=log_m2l_sampling, log_m2l_distribution=log_m2l_distribution, - kappa_ext_sampling=kappa_ext_sampling, - kappa_ext_distribution=kappa_ext_distribution, alpha_lambda_sampling=alpha_lambda_sampling, beta_lambda_sampling=beta_lambda_sampling, alpha_gamma_in_sampling=alpha_gamma_in_sampling, @@ -116,6 +124,9 @@ def __init__( z_apparent_m_anchor=z_apparent_m_anchor, kwargs_fixed=kwargs_fixed_source, ) + self._los_param = LOSParam(los_sampling=los_sampling, + los_distributions=los_distributions, + kwargs_fixed=kwargs_fixed_los,) self._kwargs_upper_cosmo, self._kwargs_lower_cosmo = ( kwargs_upper_cosmo, kwargs_lower_cosmo, @@ -132,6 +143,10 @@ def __init__( kwargs_upper_source, kwargs_lower_source, ) + self._kwargs_upper_los, self._kwargs_lower_los = ( + kwargs_upper_los, + kwargs_lower_los, + ) @property def num_param(self): @@ -152,6 +167,7 @@ def param_list(self, latex_style=False): list_param += self._lens_param.param_list(latex_style=latex_style) list_param += self._kin_param.param_list(latex_style=latex_style) list_param += self._source_param.param_list(latex_style=latex_style) + list_param += self._los_param.param_list(latex_style=latex_style) return list_param def args2kwargs(self, args): @@ -165,10 +181,12 @@ def args2kwargs(self, args): kwargs_lens, i = self._lens_param.args2kwargs(args, i=i) kwargs_kin, i = self._kin_param.args2kwargs(args, i=i) kwargs_source, i = self._source_param.args2kwargs(args, i=i) - return kwargs_cosmo, kwargs_lens, kwargs_kin, kwargs_source + kwargs_los, i = self._los_param.args2kwargs(args, i=i) + return kwargs_cosmo, kwargs_lens, kwargs_kin, kwargs_source, kwargs_los def kwargs2args( - self, kwargs_cosmo=None, kwargs_lens=None, kwargs_kin=None, kwargs_source=None + self, kwargs_cosmo=None, kwargs_lens=None, kwargs_kin=None, kwargs_source=None, + kwargs_los=None ): """ @@ -176,6 +194,7 @@ def kwargs2args( :param kwargs_lens: keyword argument list of parameters for lens model sampling :param kwargs_kin: keyword argument list of parameters for kinematic sampling :param kwargs_source: keyword arguments of parameters of source brightness + :param kwargs_los: keyword arguments of parameters of the line of sight :return: sampling argument list in specified order """ args = [] @@ -183,13 +202,15 @@ def kwargs2args( args += self._lens_param.kwargs2args(kwargs_lens) args += self._kin_param.kwargs2args(kwargs_kin) args += self._source_param.kwargs2args(kwargs_source) + args += self._los_param.kwargs2args(kwargs_los) return args def cosmo(self, kwargs_cosmo): """ :param kwargs_cosmo: keyword arguments of parameters (can include others not used for the cosmology) - :return: astropy.cosmology instance + :return: cosmology + :rtype: ~astropy.cosmology instance """ return self._cosmo_param.cosmo(kwargs_cosmo) @@ -204,11 +225,13 @@ def param_bounds(self): kwargs_lens=self._kwargs_lower_lens, kwargs_kin=self._kwargs_lower_kin, kwargs_source=self._kwargs_lower_source, + kwargs_los=self._kwargs_lower_los, ) upper_limit = self.kwargs2args( kwargs_cosmo=self._kwargs_upper_cosmo, kwargs_lens=self._kwargs_upper_lens, kwargs_kin=self._kwargs_upper_kin, kwargs_source=self._kwargs_upper_source, + kwargs_los=self._kwargs_upper_los, ) return lower_limit, upper_limit diff --git a/test/test_Diagnostics/test_goodness_of_fit.py b/test/test_Diagnostics/test_goodness_of_fit.py index b832c8ab..82ec6748 100644 --- a/test/test_Diagnostics/test_goodness_of_fit.py +++ b/test/test_Diagnostics/test_goodness_of_fit.py @@ -104,18 +104,18 @@ def test_plot_ddt_fit(self): kwargs_lens = {"lambda_mst": 1} kwargs_kin = {} f, ax = self.goodnessofFit.plot_ddt_fit( - self.cosmo, kwargs_lens, kwargs_kin, redshift_trend=False + self.cosmo, kwargs_lens, kwargs_kin, kwargs_los=None, redshift_trend=False ) plt.close() f, ax = self.goodnessofFit.plot_ddt_fit( - self.cosmo, kwargs_lens, kwargs_kin, redshift_trend=True + self.cosmo, kwargs_lens, kwargs_kin, kwargs_los=None, redshift_trend=True ) plt.close() def test_plot_kin_fit(self): kwargs_lens = {"lambda_mst": 1} kwargs_kin = {} - f, ax = self.goodnessofFit.plot_kin_fit(self.cosmo, kwargs_lens, kwargs_kin) + f, ax = self.goodnessofFit.plot_kin_fit(self.cosmo, kwargs_lens, kwargs_kin, kwargs_los=None) plt.close() def test_plot_ifu_fit(self): @@ -127,6 +127,7 @@ def test_plot_ifu_fit(self): self.cosmo, kwargs_lens, kwargs_kin, + kwargs_los=None, lens_index=self.ifu_index, bin_edges=1.0, show_legend=True, @@ -152,12 +153,14 @@ def test_raise(self): f, ax = plt.subplots(1, 1, figsize=(4, 4)) kwargs_lens = {"lambda_mst": 1} kwargs_kin = {} + kwargs_los = None cosmo = FlatLambdaCDM(H0=70, Om0=0.3, Ob0=0.0) goodness_of_fit.plot_ifu_fit( ax, cosmo, kwargs_lens, kwargs_kin, + kwargs_los=kwargs_los, lens_index=0, bin_edges=1, show_legend=True, diff --git a/test/test_Likelihood/test_hierarchy_likelihood.py b/test/test_Likelihood/test_hierarchy_likelihood.py index 86bbafd7..9dc3e676 100644 --- a/test/test_Likelihood/test_hierarchy_likelihood.py +++ b/test/test_Likelihood/test_hierarchy_likelihood.py @@ -1,7 +1,6 @@ from hierarc.Likelihood.hierarchy_likelihood import LensLikelihood from astropy.cosmology import FlatLambdaCDM import pytest -import unittest import numpy as np import numpy.testing as npt @@ -35,7 +34,8 @@ def setup_method(self): ani_scaling_array_list=None, ani_scaling_array=ani_scaling_array, num_distribution_draws=200, - kappa_ext_bias=True, + los_distributions=["GAUSSIAN"], + global_los_distribution=0, kappa_pdf=None, kappa_bin_edges=None, mst_ifu=True, @@ -51,7 +51,8 @@ def setup_method(self): ani_scaling_array_list=None, ani_scaling_array=ani_scaling_array, num_distribution_draws=200, - kappa_ext_bias=False, + los_distributions=["GAUSSIAN"], + global_los_distribution=0, # testing previously set to =False kappa_pdf=None, kappa_bin_edges=None, mst_ifu=False, @@ -67,7 +68,8 @@ def setup_method(self): ani_scaling_array_list=None, ani_scaling_array=ani_scaling_array, num_distribution_draws=0, - kappa_ext_bias=True, + los_distributions=["GAUSSIAN"], + global_los_distribution=0, kappa_pdf=None, kappa_bin_edges=None, mst_ifu=True, @@ -86,7 +88,8 @@ def setup_method(self): ani_scaling_array_list=None, ani_scaling_array=ani_scaling_array, num_distribution_draws=200, - kappa_ext_bias=True, + # los_distributions=["GAUSSIAN"], + global_los_distribution=False, kappa_pdf=kappa_pdf, kappa_bin_edges=kappa_bin_edges, mst_ifu=False, @@ -111,7 +114,6 @@ def setup_method(self): gamma_in_array=gamma_in_array, log_m2l_array=log_m2l_array, num_distribution_draws=200, - kappa_ext_bias=False, kappa_pdf=None, kappa_bin_edges=None, mst_ifu=False, @@ -130,7 +132,6 @@ def setup_method(self): gamma_in_array=gamma_in_array, log_m2l_array=log_m2l_array, num_distribution_draws=200, - kappa_ext_bias=False, kappa_pdf=None, kappa_bin_edges=None, mst_ifu=False, @@ -149,7 +150,6 @@ def setup_method(self): gamma_in_array=gamma_in_array, log_m2l_array=log_m2l_array, num_distribution_draws=200, - kappa_ext_bias=False, kappa_pdf=None, kappa_bin_edges=None, mst_ifu=False, @@ -162,43 +162,42 @@ def test_lens_log_likelihood(self): kwargs_lens = { "lambda_mst": 1, "lambda_mst_sigma": 0.01, - "kappa_ext": 0, - "kappa_ext_sigma": 0.03, "lambda_ifu": 1, "lambda_ifu_sigma": 0.01, } + kwargs_los = [{"mean": 0, "sigma": 0.03}] + kwargs_kin = {"a_ani": 1, "a_ani_sigma": 0.1} ln_likelihood = self.likelihood.lens_log_likelihood( - self.cosmo, kwargs_lens=kwargs_lens, kwargs_kin=kwargs_kin + self.cosmo, kwargs_lens=kwargs_lens, kwargs_kin=kwargs_kin, kwargs_los=kwargs_los ) npt.assert_almost_equal(ln_likelihood, -0.5, decimal=1) ln_likelihood_zero = self.likelihood_zero_dist.lens_log_likelihood( - self.cosmo, kwargs_lens=kwargs_lens, kwargs_kin=kwargs_kin + self.cosmo, kwargs_lens=kwargs_lens, kwargs_kin=kwargs_kin, kwargs_los=kwargs_los ) assert ln_likelihood_zero == -np.inf ln_likelihood_kappa_ext = self.likelihood_kappa_ext.lens_log_likelihood( - self.cosmo, kwargs_lens=kwargs_lens, kwargs_kin=kwargs_kin + self.cosmo, kwargs_lens=kwargs_lens, kwargs_kin=kwargs_kin, kwargs_los=kwargs_los ) npt.assert_almost_equal(ln_likelihood, ln_likelihood_kappa_ext, decimal=1) kwargs_lens = { "lambda_mst": 1000000, "lambda_mst_sigma": 0, - "kappa_ext": 0, - "kappa_ext_sigma": 0, "lambda_ifu": 1, "lambda_ifu_sigma": 0, } + kwargs_los = [{"mean": 0, "sigma": 0}] kwargs_kin = {"a_ani": 1, "a_ani_sigma": 0} ln_inf = self.likelihood_single.lens_log_likelihood( - self.cosmo, kwargs_lens=kwargs_lens, kwargs_kin=kwargs_kin + self.cosmo, kwargs_lens=kwargs_lens, kwargs_kin=kwargs_kin, kwargs_los=kwargs_los ) assert ln_inf < -10000000 ln_inf = self.likelihood_single.lens_log_likelihood( - self.cosmo, kwargs_lens=None, kwargs_kin=kwargs_kin + self.cosmo, kwargs_lens=None, kwargs_kin=kwargs_kin, kwargs_los=kwargs_los ) npt.assert_almost_equal(ln_inf, 0.0, decimal=1) @@ -250,7 +249,7 @@ def test_lens_log_likelihood(self): ddt = (1.0 + z_lens) * dd * ds / dds ln_likelihood = self.likelihood_gamma_in_fail_case.log_likelihood_single( - ddt, dd, delta_lum_dist, kwargs_lens, kwargs_kin, kwargs_source + ddt, dd, delta_lum_dist, kwargs_lens, kwargs_kin, kwargs_source, kwargs_los ) assert ln_likelihood < -10000000 diff --git a/test/test_Likelihood/test_lens_sample_likelihood.py b/test/test_Likelihood/test_lens_sample_likelihood.py index 194490ed..8bd3acc0 100644 --- a/test/test_Likelihood/test_lens_sample_likelihood.py +++ b/test/test_Likelihood/test_lens_sample_likelihood.py @@ -54,7 +54,7 @@ def setup_method(self): self.likelihood = LensSampleLikelihood(kwargs_lens_list=self.kwargs_lens_list) def test_log_likelihood(self): - kwargs_lens = {"kappa_ext": 0, "gamma_ppn": 1} + kwargs_lens = {"gamma_ppn": 1} kwargs_kin = {"a_ani": 1} logl = self.likelihood.log_likelihood( self.cosmo, kwargs_lens=kwargs_lens, kwargs_kin=kwargs_kin diff --git a/test/test_Likelihood/test_los_distribution.py b/test/test_Likelihood/test_los_distribution.py new file mode 100644 index 00000000..c0df55b7 --- /dev/null +++ b/test/test_Likelihood/test_los_distribution.py @@ -0,0 +1,103 @@ +from hierarc.Likelihood.los_distributions import LOSDistribution +from scipy.stats import genextreme +import numpy as np +import numpy.testing as npt + + +class TestLOSDistribution(object): + + def setup_method(self): + pass + + def test_gev(self): + + xi = -0.1 + mean_gev = 0.02 + sigma_gev = np.exp(-5.46) + + mean_gauss = 0.1 + sigma_gauss = 0.2 + + kappa_ext_draw = genextreme.rvs(c=xi, loc=mean_gev, scale=sigma_gev, size=10000) + npt.assert_almost_equal(np.mean(kappa_ext_draw), mean_gev, decimal=2) + npt.assert_almost_equal(np.std(kappa_ext_draw), sigma_gev, decimal=2) + + kappa_pdf, kappa_bin_edges = np.histogram(kappa_ext_draw, bins=100) + kappa_pdf = np.array(kappa_pdf, dtype=float) / np.sum(kappa_pdf) + + los_distribution = ["GAUSSIAN", "GEV"] + + kwargs_los = [{"mean": mean_gauss, "sigma": sigma_gauss}, + {"mean": mean_gev, "sigma": sigma_gev, "xi": xi}] + + # here we draw from the scipy function + dist_gev = LOSDistribution(kappa_pdf=kappa_pdf, kappa_bin_edges=kappa_bin_edges, + global_los_distribution=1, + los_distributions=los_distribution) + + kappa_dist_drawn = dist_gev.draw_los(kwargs_los, size=10000) + npt.assert_almost_equal(np.mean(kappa_dist_drawn), mean_gev, decimal=2) + npt.assert_almost_equal(np.std(kappa_dist_drawn), sigma_gev, decimal=2) + + # here we draw from the distribution + dist_gev = LOSDistribution(kappa_pdf=kappa_pdf, kappa_bin_edges=kappa_bin_edges, + global_los_distribution=False, + los_distributions=los_distribution) + + kappa_dist_drawn = dist_gev.draw_los(kwargs_los, size=10000) + npt.assert_almost_equal(np.mean(kappa_dist_drawn), mean_gev, decimal=2) + npt.assert_almost_equal(np.std(kappa_dist_drawn), sigma_gev, decimal=2) + + # draw from Gaussian + dist_gev = LOSDistribution(kappa_pdf=kappa_pdf, kappa_bin_edges=kappa_bin_edges, + global_los_distribution=0, + los_distributions=los_distribution) + + kappa_dist_drawn = dist_gev.draw_los(kwargs_los, size=10000) + npt.assert_almost_equal(np.mean(kappa_dist_drawn), mean_gauss, decimal=2) + npt.assert_almost_equal(np.std(kappa_dist_drawn), sigma_gauss, decimal=2) + + + def test_draw_bool(self): + xi = -0.1 + mean_gev = 0.02 + sigma_gev = np.exp(-5.46) + + mean_gauss = 0.1 + sigma_gauss = 0 + + kappa_ext_draw = genextreme.rvs(c=xi, loc=mean_gev, scale=sigma_gev, size=10000) + npt.assert_almost_equal(np.mean(kappa_ext_draw), mean_gev, decimal=2) + npt.assert_almost_equal(np.std(kappa_ext_draw), sigma_gev, decimal=2) + + kappa_pdf, kappa_bin_edges = np.histogram(kappa_ext_draw, bins=100) + kappa_pdf = np.array(kappa_pdf, dtype=float) / np.sum(kappa_pdf) + + los_distribution = ["GAUSSIAN", "GEV"] + + kwargs_los = [{"mean": mean_gauss, "sigma": sigma_gauss}, + {"mean": mean_gev, "sigma": sigma_gev, "xi": xi}] + + dist = LOSDistribution(kappa_pdf=kappa_pdf, kappa_bin_edges=kappa_bin_edges, + global_los_distribution=1, + los_distributions=los_distribution) + bool_draw = dist.draw_bool(kwargs_los) + assert bool_draw is True + + dist = LOSDistribution(kappa_pdf=kappa_pdf, kappa_bin_edges=kappa_bin_edges, + global_los_distribution=0, + los_distributions=los_distribution) + bool_draw = dist.draw_bool(kwargs_los) + assert bool_draw is False + + dist = LOSDistribution(kappa_pdf=kappa_pdf, kappa_bin_edges=kappa_bin_edges, + global_los_distribution=False, + los_distributions=los_distribution) + bool_draw = dist.draw_bool(kwargs_los) + assert bool_draw is True + + + + + + diff --git a/test/test_Sampling/test_ParamManager/test_lens_param.py b/test/test_Sampling/test_ParamManager/test_lens_param.py index dd4b96c8..9267d3e2 100644 --- a/test/test_Sampling/test_ParamManager/test_lens_param.py +++ b/test/test_Sampling/test_ParamManager/test_lens_param.py @@ -7,8 +7,6 @@ def setup_method(self): self._param = LensParam( lambda_mst_sampling=True, lambda_mst_distribution="GAUSSIAN", - kappa_ext_sampling=True, - kappa_ext_distribution="GAUSSIAN", lambda_ifu_sampling=True, lambda_ifu_distribution="GAUSSIAN", alpha_lambda_sampling=True, @@ -21,16 +19,12 @@ def setup_method(self): "lambda_mst_sigma": 0.1, "lambda_ifu": 1.1, "lambda_ifu_sigma": 0.2, - "kappa_ext": 0.01, - "kappa_ext_sigma": 0.03, "alpha_lambda": 0, "beta_lambda": 0, } self._param_fixed = LensParam( lambda_mst_sampling=True, lambda_mst_distribution="GAUSSIAN", - kappa_ext_sampling=True, - kappa_ext_distribution="GAUSSIAN", lambda_ifu_sampling=True, lambda_ifu_distribution="GAUSSIAN", alpha_lambda_sampling=True, @@ -40,8 +34,6 @@ def setup_method(self): self._param_log_scatter = LensParam( lambda_mst_sampling=True, lambda_mst_distribution="GAUSSIAN", - kappa_ext_sampling=True, - kappa_ext_distribution="GAUSSIAN", lambda_ifu_sampling=True, lambda_ifu_distribution="GAUSSIAN", alpha_lambda_sampling=True, @@ -52,14 +44,14 @@ def setup_method(self): def test_param_list(self): param_list = self._param.param_list(latex_style=False) - assert len(param_list) == 8 + assert len(param_list) == 6 param_list = self._param.param_list(latex_style=True) - assert len(param_list) == 8 + assert len(param_list) == 6 param_list = self._param_log_scatter.param_list(latex_style=False) - assert len(param_list) == 8 + assert len(param_list) == 6 param_list = self._param_log_scatter.param_list(latex_style=True) - assert len(param_list) == 8 + assert len(param_list) == 6 param_list = self._param_fixed.param_list(latex_style=False) assert len(param_list) == 0 diff --git a/test/test_Sampling/test_ParamManager/test_los_param.py b/test/test_Sampling/test_ParamManager/test_los_param.py new file mode 100644 index 00000000..e86ad012 --- /dev/null +++ b/test/test_Sampling/test_ParamManager/test_los_param.py @@ -0,0 +1,75 @@ +from hierarc.Sampling.ParamManager.los_param import LOSParam +import numpy.testing as npt +import pytest + + +class TestLOSParam(object): + def setup_method(self): + self._param = LOSParam( + los_sampling=True, + los_distributions=["GEV"], + kwargs_fixed=None, + ) + + self._param_gauss = LOSParam( + los_sampling=True, + los_distributions=["GAUSSIAN"], + kwargs_fixed=None, + ) + + kwargs_fixed = [{ + "mean": 0, + "sigma": 0.05, + "xi": 0.1, + }] + self._param_fixed = LOSParam( + los_sampling=True, + los_distributions=["GEV"], + kwargs_fixed=kwargs_fixed, + ) + + def test_param_list(self): + param_list = self._param.param_list(latex_style=False) + assert len(param_list) == 3 + param_list = self._param.param_list(latex_style=True) + assert len(param_list) == 3 + + param_list = self._param_gauss.param_list(latex_style=False) + assert len(param_list) == 2 + param_list = self._param_gauss.param_list(latex_style=True) + assert len(param_list) == 2 + + param_list = self._param_fixed.param_list(latex_style=False) + assert len(param_list) == 0 + param_list = self._param_fixed.param_list(latex_style=True) + assert len(param_list) == 0 + + def test_args2kwargs(self): + kwargs = [{ + "mean": 0.1, + "sigma": 0.1, + "xi": 0.2, + }] + + kwargs_gauss = [{ + "mean": 0.1, + "sigma": 0.1, + }] + args = self._param.kwargs2args(kwargs) + kwargs_new, i = self._param.args2kwargs(args, i=0) + args_new = self._param.kwargs2args(kwargs_new) + npt.assert_almost_equal(args_new, args) + + args = self._param_gauss.kwargs2args(kwargs_gauss) + kwargs_new, i = self._param_gauss.args2kwargs(args, i=0) + args_new = self._param_gauss.kwargs2args(kwargs_new) + npt.assert_almost_equal(args_new, args) + + args = self._param_fixed.kwargs2args(kwargs) + kwargs_new, i = self._param_fixed.args2kwargs(args, i=0) + args_new = self._param_fixed.kwargs2args(kwargs_new) + npt.assert_almost_equal(args_new, args) + + +if __name__ == "__main__": + pytest.main() diff --git a/test/test_Sampling/test_ParamManager/test_param_manager.py b/test/test_Sampling/test_ParamManager/test_param_manager.py index 85f0ec58..37f54568 100644 --- a/test/test_Sampling/test_ParamManager/test_param_manager.py +++ b/test/test_Sampling/test_ParamManager/test_param_manager.py @@ -19,9 +19,8 @@ def setup_method(self): kwargs_lower_lens = { "lambda_mst": 0, "lambda_mst_sigma": 0.1, - "kappa_ext": -0.2, - "kappa_ext_sigma": 0, } + kwargs_lower_los = [{"mean": -0.2, "sigma": 0.0}] kwargs_lower_kin = {"a_ani": 0.1, "a_ani_sigma": 0.1} kwargs_lower_source = {"mu_sne": 0, "sigma_sne": 0} @@ -37,9 +36,8 @@ def setup_method(self): kwargs_upper_lens = { "lambda_mst": 2, "lambda_mst_sigma": 0.1, - "kappa_ext": 0.2, - "kappa_ext_sigma": 1, } + kwargs_upper_los = [{"mean": 0.2, "sigma": 0.5}] kwargs_upper_kin = {"a_ani": 0.1, "a_ani_sigma": 0.1} kwargs_upper_source = {"mu_sne": 100, "sigma_sne": 10} @@ -55,9 +53,8 @@ def setup_method(self): kwargs_fixed_lens = { "lambda_mst": 1, "lambda_mst_sigma": 0.1, - "kappa_ext": 0, - "kappa_ext_sigma": 0, } + kwargs_fixed_los = [{"mean": 0, "sigma": 0.0}] kwargs_fixed_kin = {"a_ani": 0.1, "a_ani_sigma": 0.1} kwargs_fixed_source = {"mu_sne": 1, "sigma_sne": 0.1} @@ -73,8 +70,8 @@ def setup_method(self): anisotropy_sampling=True, anisotropy_model="OM", kwargs_lower_cosmo=kwargs_lower_cosmo, - kappa_ext_sampling=True, - kappa_ext_distribution="GAUSSIAN", + los_sampling=True, + los_distributions=["GAUSSIAN"], sne_apparent_m_sampling=True, sne_distribution="GAUSSIAN", kwargs_upper_cosmo=kwargs_upper_cosmo, @@ -88,6 +85,9 @@ def setup_method(self): kwargs_fixed_source=kwargs_fixed_source, kwargs_lower_source=kwargs_lower_source, kwargs_upper_source=kwargs_upper_source, + kwargs_fixed_los=kwargs_fixed_los, + kwargs_lower_los=kwargs_lower_los, + kwargs_upper_los=kwargs_upper_los ) ) @@ -100,8 +100,8 @@ def setup_method(self): anisotropy_distribution="GAUSSIAN", anisotropy_sampling=True, anisotropy_model="OM", - kappa_ext_sampling=True, - kappa_ext_distribution="GAUSSIAN", + los_sampling=True, + los_distributions=["GAUSSIAN"], sne_apparent_m_sampling=True, sne_distribution="GAUSSIAN", kwargs_lower_cosmo=kwargs_lower_cosmo, @@ -116,6 +116,9 @@ def setup_method(self): kwargs_lower_source=kwargs_lower_source, kwargs_upper_source=kwargs_upper_source, kwargs_fixed_source=None, + kwargs_lower_los=kwargs_lower_los, + kwargs_upper_los=kwargs_upper_los, + kwargs_fixed_los=None ) ) self.param_list = param_list @@ -142,9 +145,9 @@ def test_kwargs2args(self): kwargs_lens = { "lambda_mst": 1, "lambda_mst_sigma": 0, - "kappa_ext": 0, - "kappa_ext_sigma": 0, + } + kwargs_los = [{"mean": 0, "sigma": 0.05}] kwargs_kin = {"a_ani": 1, "a_ani_sigma": 0.3} kwargs_source = {"mu_sne": 2, "sigma_sne": 0.2} for param in self.param_list: @@ -153,15 +156,17 @@ def test_kwargs2args(self): kwargs_lens=kwargs_lens, kwargs_kin=kwargs_kin, kwargs_source=kwargs_source, + kwargs_los=kwargs_los ) ( kwargs_cosmo_new, kwargs_lens_new, kwargs_kin_new, kwargs_source_new, + kwargs_los_new ) = param.args2kwargs(args) args_new = param.kwargs2args( - kwargs_cosmo_new, kwargs_lens_new, kwargs_kin_new, kwargs_source_new + kwargs_cosmo_new, kwargs_lens_new, kwargs_kin_new, kwargs_source_new, kwargs_los_new ) npt.assert_almost_equal(args_new, args) From f1cf577e411d69443fadf2503619e017037f30f5 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Sun, 28 Apr 2024 22:22:01 +0000 Subject: [PATCH 02/62] [pre-commit.ci] auto fixes from pre-commit.com hooks --- hierarc/Diagnostics/goodness_of_fit.py | 13 +++- .../LensLikelihood/double_source_plane.py | 7 +- hierarc/Likelihood/cosmo_likelihood.py | 9 ++- hierarc/Likelihood/hierarchy_likelihood.py | 26 +++++-- hierarc/Likelihood/lens_sample_likelihood.py | 12 ++- hierarc/Likelihood/los_distributions.py | 36 ++++++--- hierarc/Sampling/ParamManager/los_param.py | 13 ++-- .../Sampling/ParamManager/param_manager.py | 16 ++-- test/test_Diagnostics/test_goodness_of_fit.py | 4 +- .../test_hierarchy_likelihood.py | 20 ++++- test/test_Likelihood/test_los_distribution.py | 75 +++++++++++-------- .../test_ParamManager/test_los_param.py | 34 +++++---- .../test_ParamManager/test_param_manager.py | 15 ++-- 13 files changed, 184 insertions(+), 96 deletions(-) diff --git a/hierarc/Diagnostics/goodness_of_fit.py b/hierarc/Diagnostics/goodness_of_fit.py index 8f14cb14..c65158d0 100644 --- a/hierarc/Diagnostics/goodness_of_fit.py +++ b/hierarc/Diagnostics/goodness_of_fit.py @@ -65,7 +65,9 @@ def plot_ddt_fit( ddt_model_sigma, dd_model_mean, dd_model_sigma, - ) = likelihood.ddt_dd_model_prediction(cosmo, kwargs_lens=kwargs_lens, kwargs_los=kwargs_los) + ) = likelihood.ddt_dd_model_prediction( + cosmo, kwargs_lens=kwargs_lens, kwargs_los=kwargs_los + ) ddt_name_list.append(name) ddt_model_mean_list.append(ddt_model_mean) @@ -162,7 +164,10 @@ def kin_fit(self, cosmo, kwargs_lens, kwargs_kin, kwargs_los): sigma_v_predict_mean, cov_error_predict, ) = likelihood.sigma_v_measured_vs_predict( - cosmo, kwargs_lens=kwargs_lens, kwargs_kin=kwargs_kin, kwargs_los=kwargs_los + cosmo, + kwargs_lens=kwargs_lens, + kwargs_kin=kwargs_kin, + kwargs_los=kwargs_los, ) if sigma_v_measurement is not None: @@ -205,7 +210,9 @@ def plot_kin_fit( :param color_prediction: color of model prediction :return: fig, axes of matplotlib instance """ - logL = self._sample_likelihood.log_likelihood(cosmo, kwargs_lens, kwargs_kin, kwargs_los=kwargs_los) + logL = self._sample_likelihood.log_likelihood( + cosmo, kwargs_lens, kwargs_kin, kwargs_los=kwargs_los + ) print(logL, "log likelihood") ( sigma_v_name_list, diff --git a/hierarc/Likelihood/LensLikelihood/double_source_plane.py b/hierarc/Likelihood/LensLikelihood/double_source_plane.py index b742183a..c0b5fa12 100644 --- a/hierarc/Likelihood/LensLikelihood/double_source_plane.py +++ b/hierarc/Likelihood/LensLikelihood/double_source_plane.py @@ -30,7 +30,12 @@ def __init__( self._normalized = normalized def lens_log_likelihood( - self, cosmo, kwargs_lens=None, kwargs_kin=None, kwargs_source=None, kwargs_los=None + self, + cosmo, + kwargs_lens=None, + kwargs_kin=None, + kwargs_source=None, + kwargs_los=None, ): """Log likelihood of the data given a model. diff --git a/hierarc/Likelihood/cosmo_likelihood.py b/hierarc/Likelihood/cosmo_likelihood.py index 46c9c2ae..c627dbe2 100644 --- a/hierarc/Likelihood/cosmo_likelihood.py +++ b/hierarc/Likelihood/cosmo_likelihood.py @@ -108,8 +108,9 @@ def __init__( if sigma_v_systematics is True: normalized = True self._likelihoodLensSample = LensSampleLikelihood( - kwargs_likelihood_list, normalized=normalized, - los_distributions=los_distributions + kwargs_likelihood_list, + normalized=normalized, + los_distributions=los_distributions, ) self.param = ParamManager( cosmology, @@ -191,8 +192,8 @@ def likelihood(self, args, kwargs_cosmo_interp=None): if args[i] < self._lower_limit[i] or args[i] > self._upper_limit[i]: return -np.inf - kwargs_cosmo, kwargs_lens, kwargs_kin, kwargs_source, kwargs_los = self.param.args2kwargs( - args + kwargs_cosmo, kwargs_lens, kwargs_kin, kwargs_source, kwargs_los = ( + self.param.args2kwargs(args) ) if self._cosmology == "oLCDM": # assert we are not in a crazy cosmological situation that prevents computing the angular distance integral diff --git a/hierarc/Likelihood/hierarchy_likelihood.py b/hierarc/Likelihood/hierarchy_likelihood.py index 3294023b..5ff14904 100644 --- a/hierarc/Likelihood/hierarchy_likelihood.py +++ b/hierarc/Likelihood/hierarchy_likelihood.py @@ -127,9 +127,12 @@ def __init__( ) self._num_distribution_draws = int(num_distribution_draws) - self._los = LOSDistribution(kappa_pdf=kappa_pdf, kappa_bin_edges=kappa_bin_edges, - global_los_distribution=global_los_distribution, - los_distributions=los_distributions) + self._los = LOSDistribution( + kappa_pdf=kappa_pdf, + kappa_bin_edges=kappa_bin_edges, + global_los_distribution=global_los_distribution, + los_distributions=los_distributions, + ) self._mst_ifu = mst_ifu self._lambda_scaling_property = lambda_scaling_property self._lambda_scaling_property_beta = lambda_scaling_property_beta @@ -140,7 +143,12 @@ def __init__( self._gamma_in_prior_std = gamma_in_prior_std def lens_log_likelihood( - self, cosmo, kwargs_lens=None, kwargs_kin=None, kwargs_source=None, kwargs_los=None, + self, + cosmo, + kwargs_lens=None, + kwargs_kin=None, + kwargs_source=None, + kwargs_los=None, ): """Log likelihood of the data of a lens given a model (defined with hyper- parameters) and cosmology. @@ -149,7 +157,8 @@ def lens_log_likelihood( :param kwargs_lens: keywords of the hyper parameters of the lens model :param kwargs_kin: keyword arguments of the kinematic model hyper parameters :param kwargs_source: keyword argument of the source model (such as SNe) - :param kwargs_los: list of keyword arguments of global line of sight distributions + :param kwargs_los: list of keyword arguments of global line of sight + distributions :return: log likelihood of the data given the model """ @@ -194,7 +203,8 @@ def hyper_param_likelihood( :param kwargs_lens: keywords of the hyper parameters of the lens model :param kwargs_kin: keyword arguments of the kinematic model hyper parameters :param kwargs_source: keyword argument of the source model (such as SNe) - :param kwargs_los: list of keyword arguments of global line of sight distributions + :param kwargs_los: list of keyword arguments of global line of sight + distributions :param cosmo: astropy.cosmology instance :return: log likelihood given the single lens analysis for the given hyper parameter @@ -529,7 +539,9 @@ def draw_source(mu_sne=1, sigma_sne=0, lum_dist=0, **kwargs): # return linear amplitude with base log 10 return mag_source - def sigma_v_measured_vs_predict(self, cosmo, kwargs_lens=None, kwargs_kin=None, kwargs_los=None): + def sigma_v_measured_vs_predict( + self, cosmo, kwargs_lens=None, kwargs_kin=None, kwargs_los=None + ): """Mean and error covariance of velocity dispersion measurement mean and error covariance of velocity dispersion predictions. diff --git a/hierarc/Likelihood/lens_sample_likelihood.py b/hierarc/Likelihood/lens_sample_likelihood.py index 3b0bc539..dedf24e9 100644 --- a/hierarc/Likelihood/lens_sample_likelihood.py +++ b/hierarc/Likelihood/lens_sample_likelihood.py @@ -28,11 +28,19 @@ def __init__(self, kwargs_lens_list, normalized=False, los_distributions=None): ) else: self._lens_list.append( - LensLikelihood(normalized=normalized, los_distributions=los_distributions, **kwargs_lens) + LensLikelihood( + normalized=normalized, + los_distributions=los_distributions, + **kwargs_lens + ) ) def log_likelihood( - self, cosmo, kwargs_lens=None, kwargs_kin=None, kwargs_source=None, + self, + cosmo, + kwargs_lens=None, + kwargs_kin=None, + kwargs_source=None, kwargs_los=None, ): """ diff --git a/hierarc/Likelihood/los_distributions.py b/hierarc/Likelihood/los_distributions.py index 9a7bd8a5..2e02b3e8 100644 --- a/hierarc/Likelihood/los_distributions.py +++ b/hierarc/Likelihood/los_distributions.py @@ -3,11 +3,15 @@ class LOSDistribution(object): - """ - line of sight distribution drawing - """ - def __init__(self, kappa_pdf=None, kappa_bin_edges=None, global_los_distribution=False, - los_distributions=None): + """Line of sight distribution drawing.""" + + def __init__( + self, + kappa_pdf=None, + kappa_bin_edges=None, + global_los_distribution=False, + los_distributions=None, + ): """ :param global_los_distribution: if integer, will draw from the global kappa distribution specified in that @@ -21,12 +25,19 @@ def __init__(self, kappa_pdf=None, kappa_bin_edges=None, global_los_distribution """ self._global_los_distribution = global_los_distribution - if isinstance(self._global_los_distribution, int) and self._global_los_distribution is not False: + if ( + isinstance(self._global_los_distribution, int) + and self._global_los_distribution is not False + ): self._draw_kappa_global = True self._los_distribution = los_distributions[global_los_distribution] else: self._draw_kappa_global = False - if kappa_pdf is not None and kappa_bin_edges is not None and not self._draw_kappa_global: + if ( + kappa_pdf is not None + and kappa_bin_edges is not None + and not self._draw_kappa_global + ): print("test kappa pdf sampling") self._kappa_dist = PDFSampling( bin_edges=kappa_bin_edges, pdf_array=kappa_pdf @@ -36,8 +47,7 @@ def __init__(self, kappa_pdf=None, kappa_bin_edges=None, global_los_distribution self._draw_kappa_individual = False def draw_los(self, kwargs_los, size=1): - """ - Draw from the distribution of line of sight convergence + """Draw from the distribution of line of sight convergence. :param kwargs_los: line of sight parameters :type kwargs_los: list of dict @@ -58,16 +68,18 @@ def draw_los(self, kwargs_los, size=1): sigma = kwargs_los_i["sigma"] xi = kwargs_los_i["xi"] from scipy.stats import genextreme + kappa_ext_draw = genextreme.rvs(c=xi, loc=mean, scale=sigma, size=size) else: - raise ValueError("line of sight distribution %s not valid." % self._los_distribution) + raise ValueError( + "line of sight distribution %s not valid." % self._los_distribution + ) else: kappa_ext_draw = 0 return kappa_ext_draw def draw_bool(self, kwargs_los): - """ - whether single-valued or extended distribution (need to draw from) + """Whether single-valued or extended distribution (need to draw from) :param kwargs_los: list of keyword arguments for line of sight distributions :return: boolean, True with samples need to be drawn, else False diff --git a/hierarc/Sampling/ParamManager/los_param.py b/hierarc/Sampling/ParamManager/los_param.py index 3ed09df3..e2292215 100644 --- a/hierarc/Sampling/ParamManager/los_param.py +++ b/hierarc/Sampling/ParamManager/los_param.py @@ -10,7 +10,6 @@ def __init__( los_sampling=False, los_distributions=None, kwargs_fixed=None, - ): """ @@ -47,21 +46,21 @@ def param_list(self, latex_style=False): if los_distribution in ["GEV", "GAUSSIAN"]: if "mean" not in self._kwargs_fixed[i]: if latex_style is True: - name_list.append(r"$\mu_{\rm los %s}$" %i) + name_list.append(r"$\mu_{\rm los %s}$" % i) else: - name_list.append(str("mean_los_"+str(i))) + name_list.append(str("mean_los_" + str(i))) if "sigma" not in self._kwargs_fixed[i]: if latex_style is True: - name_list.append(r"$\sigma_{\rm los %s}$" %i) + name_list.append(r"$\sigma_{\rm los %s}$" % i) else: - name_list.append(str("sigma_los_"+str(i))) + name_list.append(str("sigma_los_" + str(i))) if los_distribution in ["GEV"]: if "xi" not in self._kwargs_fixed[i]: if latex_style is True: - name_list.append(r"$\xi_{\rm los} %s$" %i) + name_list.append(r"$\xi_{\rm los} %s$" % i) else: name_list.append(str("xi_los_" + str(i))) - #str(name + "_" + type + str(k)) + # str(name + "_" + type + str(k)) return name_list def args2kwargs(self, args, i=0): diff --git a/hierarc/Sampling/ParamManager/param_manager.py b/hierarc/Sampling/ParamManager/param_manager.py index 34c00b51..11413773 100644 --- a/hierarc/Sampling/ParamManager/param_manager.py +++ b/hierarc/Sampling/ParamManager/param_manager.py @@ -124,9 +124,11 @@ def __init__( z_apparent_m_anchor=z_apparent_m_anchor, kwargs_fixed=kwargs_fixed_source, ) - self._los_param = LOSParam(los_sampling=los_sampling, - los_distributions=los_distributions, - kwargs_fixed=kwargs_fixed_los,) + self._los_param = LOSParam( + los_sampling=los_sampling, + los_distributions=los_distributions, + kwargs_fixed=kwargs_fixed_los, + ) self._kwargs_upper_cosmo, self._kwargs_lower_cosmo = ( kwargs_upper_cosmo, kwargs_lower_cosmo, @@ -185,8 +187,12 @@ def args2kwargs(self, args): return kwargs_cosmo, kwargs_lens, kwargs_kin, kwargs_source, kwargs_los def kwargs2args( - self, kwargs_cosmo=None, kwargs_lens=None, kwargs_kin=None, kwargs_source=None, - kwargs_los=None + self, + kwargs_cosmo=None, + kwargs_lens=None, + kwargs_kin=None, + kwargs_source=None, + kwargs_los=None, ): """ diff --git a/test/test_Diagnostics/test_goodness_of_fit.py b/test/test_Diagnostics/test_goodness_of_fit.py index 82ec6748..0c9be7d8 100644 --- a/test/test_Diagnostics/test_goodness_of_fit.py +++ b/test/test_Diagnostics/test_goodness_of_fit.py @@ -115,7 +115,9 @@ def test_plot_ddt_fit(self): def test_plot_kin_fit(self): kwargs_lens = {"lambda_mst": 1} kwargs_kin = {} - f, ax = self.goodnessofFit.plot_kin_fit(self.cosmo, kwargs_lens, kwargs_kin, kwargs_los=None) + f, ax = self.goodnessofFit.plot_kin_fit( + self.cosmo, kwargs_lens, kwargs_kin, kwargs_los=None + ) plt.close() def test_plot_ifu_fit(self): diff --git a/test/test_Likelihood/test_hierarchy_likelihood.py b/test/test_Likelihood/test_hierarchy_likelihood.py index 9dc3e676..a150d70c 100644 --- a/test/test_Likelihood/test_hierarchy_likelihood.py +++ b/test/test_Likelihood/test_hierarchy_likelihood.py @@ -169,17 +169,26 @@ def test_lens_log_likelihood(self): kwargs_kin = {"a_ani": 1, "a_ani_sigma": 0.1} ln_likelihood = self.likelihood.lens_log_likelihood( - self.cosmo, kwargs_lens=kwargs_lens, kwargs_kin=kwargs_kin, kwargs_los=kwargs_los + self.cosmo, + kwargs_lens=kwargs_lens, + kwargs_kin=kwargs_kin, + kwargs_los=kwargs_los, ) npt.assert_almost_equal(ln_likelihood, -0.5, decimal=1) ln_likelihood_zero = self.likelihood_zero_dist.lens_log_likelihood( - self.cosmo, kwargs_lens=kwargs_lens, kwargs_kin=kwargs_kin, kwargs_los=kwargs_los + self.cosmo, + kwargs_lens=kwargs_lens, + kwargs_kin=kwargs_kin, + kwargs_los=kwargs_los, ) assert ln_likelihood_zero == -np.inf ln_likelihood_kappa_ext = self.likelihood_kappa_ext.lens_log_likelihood( - self.cosmo, kwargs_lens=kwargs_lens, kwargs_kin=kwargs_kin, kwargs_los=kwargs_los + self.cosmo, + kwargs_lens=kwargs_lens, + kwargs_kin=kwargs_kin, + kwargs_los=kwargs_los, ) npt.assert_almost_equal(ln_likelihood, ln_likelihood_kappa_ext, decimal=1) @@ -192,7 +201,10 @@ def test_lens_log_likelihood(self): kwargs_los = [{"mean": 0, "sigma": 0}] kwargs_kin = {"a_ani": 1, "a_ani_sigma": 0} ln_inf = self.likelihood_single.lens_log_likelihood( - self.cosmo, kwargs_lens=kwargs_lens, kwargs_kin=kwargs_kin, kwargs_los=kwargs_los + self.cosmo, + kwargs_lens=kwargs_lens, + kwargs_kin=kwargs_kin, + kwargs_los=kwargs_los, ) assert ln_inf < -10000000 diff --git a/test/test_Likelihood/test_los_distribution.py b/test/test_Likelihood/test_los_distribution.py index c0df55b7..4fdef5be 100644 --- a/test/test_Likelihood/test_los_distribution.py +++ b/test/test_Likelihood/test_los_distribution.py @@ -27,37 +27,47 @@ def test_gev(self): los_distribution = ["GAUSSIAN", "GEV"] - kwargs_los = [{"mean": mean_gauss, "sigma": sigma_gauss}, - {"mean": mean_gev, "sigma": sigma_gev, "xi": xi}] + kwargs_los = [ + {"mean": mean_gauss, "sigma": sigma_gauss}, + {"mean": mean_gev, "sigma": sigma_gev, "xi": xi}, + ] # here we draw from the scipy function - dist_gev = LOSDistribution(kappa_pdf=kappa_pdf, kappa_bin_edges=kappa_bin_edges, - global_los_distribution=1, - los_distributions=los_distribution) + dist_gev = LOSDistribution( + kappa_pdf=kappa_pdf, + kappa_bin_edges=kappa_bin_edges, + global_los_distribution=1, + los_distributions=los_distribution, + ) kappa_dist_drawn = dist_gev.draw_los(kwargs_los, size=10000) npt.assert_almost_equal(np.mean(kappa_dist_drawn), mean_gev, decimal=2) npt.assert_almost_equal(np.std(kappa_dist_drawn), sigma_gev, decimal=2) # here we draw from the distribution - dist_gev = LOSDistribution(kappa_pdf=kappa_pdf, kappa_bin_edges=kappa_bin_edges, - global_los_distribution=False, - los_distributions=los_distribution) + dist_gev = LOSDistribution( + kappa_pdf=kappa_pdf, + kappa_bin_edges=kappa_bin_edges, + global_los_distribution=False, + los_distributions=los_distribution, + ) kappa_dist_drawn = dist_gev.draw_los(kwargs_los, size=10000) npt.assert_almost_equal(np.mean(kappa_dist_drawn), mean_gev, decimal=2) npt.assert_almost_equal(np.std(kappa_dist_drawn), sigma_gev, decimal=2) # draw from Gaussian - dist_gev = LOSDistribution(kappa_pdf=kappa_pdf, kappa_bin_edges=kappa_bin_edges, - global_los_distribution=0, - los_distributions=los_distribution) + dist_gev = LOSDistribution( + kappa_pdf=kappa_pdf, + kappa_bin_edges=kappa_bin_edges, + global_los_distribution=0, + los_distributions=los_distribution, + ) kappa_dist_drawn = dist_gev.draw_los(kwargs_los, size=10000) npt.assert_almost_equal(np.mean(kappa_dist_drawn), mean_gauss, decimal=2) npt.assert_almost_equal(np.std(kappa_dist_drawn), sigma_gauss, decimal=2) - def test_draw_bool(self): xi = -0.1 mean_gev = 0.02 @@ -75,29 +85,34 @@ def test_draw_bool(self): los_distribution = ["GAUSSIAN", "GEV"] - kwargs_los = [{"mean": mean_gauss, "sigma": sigma_gauss}, - {"mean": mean_gev, "sigma": sigma_gev, "xi": xi}] - - dist = LOSDistribution(kappa_pdf=kappa_pdf, kappa_bin_edges=kappa_bin_edges, - global_los_distribution=1, - los_distributions=los_distribution) + kwargs_los = [ + {"mean": mean_gauss, "sigma": sigma_gauss}, + {"mean": mean_gev, "sigma": sigma_gev, "xi": xi}, + ] + + dist = LOSDistribution( + kappa_pdf=kappa_pdf, + kappa_bin_edges=kappa_bin_edges, + global_los_distribution=1, + los_distributions=los_distribution, + ) bool_draw = dist.draw_bool(kwargs_los) assert bool_draw is True - dist = LOSDistribution(kappa_pdf=kappa_pdf, kappa_bin_edges=kappa_bin_edges, - global_los_distribution=0, - los_distributions=los_distribution) + dist = LOSDistribution( + kappa_pdf=kappa_pdf, + kappa_bin_edges=kappa_bin_edges, + global_los_distribution=0, + los_distributions=los_distribution, + ) bool_draw = dist.draw_bool(kwargs_los) assert bool_draw is False - dist = LOSDistribution(kappa_pdf=kappa_pdf, kappa_bin_edges=kappa_bin_edges, - global_los_distribution=False, - los_distributions=los_distribution) + dist = LOSDistribution( + kappa_pdf=kappa_pdf, + kappa_bin_edges=kappa_bin_edges, + global_los_distribution=False, + los_distributions=los_distribution, + ) bool_draw = dist.draw_bool(kwargs_los) assert bool_draw is True - - - - - - diff --git a/test/test_Sampling/test_ParamManager/test_los_param.py b/test/test_Sampling/test_ParamManager/test_los_param.py index e86ad012..85b95ab1 100644 --- a/test/test_Sampling/test_ParamManager/test_los_param.py +++ b/test/test_Sampling/test_ParamManager/test_los_param.py @@ -17,11 +17,13 @@ def setup_method(self): kwargs_fixed=None, ) - kwargs_fixed = [{ - "mean": 0, - "sigma": 0.05, - "xi": 0.1, - }] + kwargs_fixed = [ + { + "mean": 0, + "sigma": 0.05, + "xi": 0.1, + } + ] self._param_fixed = LOSParam( los_sampling=True, los_distributions=["GEV"], @@ -45,16 +47,20 @@ def test_param_list(self): assert len(param_list) == 0 def test_args2kwargs(self): - kwargs = [{ - "mean": 0.1, - "sigma": 0.1, - "xi": 0.2, - }] + kwargs = [ + { + "mean": 0.1, + "sigma": 0.1, + "xi": 0.2, + } + ] - kwargs_gauss = [{ - "mean": 0.1, - "sigma": 0.1, - }] + kwargs_gauss = [ + { + "mean": 0.1, + "sigma": 0.1, + } + ] args = self._param.kwargs2args(kwargs) kwargs_new, i = self._param.args2kwargs(args, i=0) args_new = self._param.kwargs2args(kwargs_new) diff --git a/test/test_Sampling/test_ParamManager/test_param_manager.py b/test/test_Sampling/test_ParamManager/test_param_manager.py index 37f54568..a8967af9 100644 --- a/test/test_Sampling/test_ParamManager/test_param_manager.py +++ b/test/test_Sampling/test_ParamManager/test_param_manager.py @@ -87,7 +87,7 @@ def setup_method(self): kwargs_upper_source=kwargs_upper_source, kwargs_fixed_los=kwargs_fixed_los, kwargs_lower_los=kwargs_lower_los, - kwargs_upper_los=kwargs_upper_los + kwargs_upper_los=kwargs_upper_los, ) ) @@ -118,7 +118,7 @@ def setup_method(self): kwargs_fixed_source=None, kwargs_lower_los=kwargs_lower_los, kwargs_upper_los=kwargs_upper_los, - kwargs_fixed_los=None + kwargs_fixed_los=None, ) ) self.param_list = param_list @@ -145,7 +145,6 @@ def test_kwargs2args(self): kwargs_lens = { "lambda_mst": 1, "lambda_mst_sigma": 0, - } kwargs_los = [{"mean": 0, "sigma": 0.05}] kwargs_kin = {"a_ani": 1, "a_ani_sigma": 0.3} @@ -156,17 +155,21 @@ def test_kwargs2args(self): kwargs_lens=kwargs_lens, kwargs_kin=kwargs_kin, kwargs_source=kwargs_source, - kwargs_los=kwargs_los + kwargs_los=kwargs_los, ) ( kwargs_cosmo_new, kwargs_lens_new, kwargs_kin_new, kwargs_source_new, - kwargs_los_new + kwargs_los_new, ) = param.args2kwargs(args) args_new = param.kwargs2args( - kwargs_cosmo_new, kwargs_lens_new, kwargs_kin_new, kwargs_source_new, kwargs_los_new + kwargs_cosmo_new, + kwargs_lens_new, + kwargs_kin_new, + kwargs_source_new, + kwargs_los_new, ) npt.assert_almost_equal(args_new, args) From 077e42f9807789b82ad54e96a78be31173ff3e16 Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Sun, 28 Apr 2024 21:37:19 -0400 Subject: [PATCH 03/62] improved unit testing --- test/test_Likelihood/test_los_distribution.py | 12 ++++++++---- .../test_ParamManager/test_los_param.py | 12 ++++++++++++ 2 files changed, 20 insertions(+), 4 deletions(-) diff --git a/test/test_Likelihood/test_los_distribution.py b/test/test_Likelihood/test_los_distribution.py index c0df55b7..463cb55a 100644 --- a/test/test_Likelihood/test_los_distribution.py +++ b/test/test_Likelihood/test_los_distribution.py @@ -2,6 +2,7 @@ from scipy.stats import genextreme import numpy as np import numpy.testing as npt +import unittest class TestLOSDistribution(object): @@ -97,7 +98,10 @@ def test_draw_bool(self): assert bool_draw is True - - - - +class TestRaise(unittest.TestCase): + def test_raise(self): + with self.assertRaises(ValueError): + los = LOSDistribution(kappa_pdf=None, kappa_bin_edges=None, + global_los_distribution=0, + los_distributions=["BAD"]) + los.draw_los(kwargs_los=[{}]) diff --git a/test/test_Sampling/test_ParamManager/test_los_param.py b/test/test_Sampling/test_ParamManager/test_los_param.py index e86ad012..c786fef1 100644 --- a/test/test_Sampling/test_ParamManager/test_los_param.py +++ b/test/test_Sampling/test_ParamManager/test_los_param.py @@ -1,6 +1,7 @@ from hierarc.Sampling.ParamManager.los_param import LOSParam import numpy.testing as npt import pytest +import unittest class TestLOSParam(object): @@ -71,5 +72,16 @@ def test_args2kwargs(self): npt.assert_almost_equal(args_new, args) +class TestRaise(unittest.TestCase): + def test_raise(self): + with self.assertRaises(ValueError): + LOSParam( + los_sampling=True, + los_distributions=["BAD"], + kwargs_fixed=[{}], + ) + + + if __name__ == "__main__": pytest.main() From 93d44e215e5f3f727298d58e1a42a9b8513b2630 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 29 Apr 2024 01:38:15 +0000 Subject: [PATCH 04/62] [pre-commit.ci] auto fixes from pre-commit.com hooks --- test/test_Likelihood/test_los_distribution.py | 9 ++++++--- test/test_Sampling/test_ParamManager/test_los_param.py | 1 - 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/test/test_Likelihood/test_los_distribution.py b/test/test_Likelihood/test_los_distribution.py index a611aa0e..3ac5434e 100644 --- a/test/test_Likelihood/test_los_distribution.py +++ b/test/test_Likelihood/test_los_distribution.py @@ -122,7 +122,10 @@ def test_draw_bool(self): class TestRaise(unittest.TestCase): def test_raise(self): with self.assertRaises(ValueError): - los = LOSDistribution(kappa_pdf=None, kappa_bin_edges=None, - global_los_distribution=0, - los_distributions=["BAD"]) + los = LOSDistribution( + kappa_pdf=None, + kappa_bin_edges=None, + global_los_distribution=0, + los_distributions=["BAD"], + ) los.draw_los(kwargs_los=[{}]) diff --git a/test/test_Sampling/test_ParamManager/test_los_param.py b/test/test_Sampling/test_ParamManager/test_los_param.py index dfb280c6..3715c4dc 100644 --- a/test/test_Sampling/test_ParamManager/test_los_param.py +++ b/test/test_Sampling/test_ParamManager/test_los_param.py @@ -88,6 +88,5 @@ def test_raise(self): ) - if __name__ == "__main__": pytest.main() From 93d931bdfd98a7b54fc62d8a9de141fdaec10f03 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 6 May 2024 20:16:41 +0000 Subject: [PATCH 05/62] [pre-commit.ci] pre-commit autoupdate MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit updates: - [github.com/psf/black: 24.3.0 → 24.4.2](https://github.com/psf/black/compare/24.3.0...24.4.2) - [github.com/psf/black: 24.3.0 → 24.4.2](https://github.com/psf/black/compare/24.3.0...24.4.2) --- .pre-commit-config.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index b9f411ef..b6e94b74 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -10,7 +10,7 @@ ci: repos: - repo: https://github.com/psf/black - rev: 24.3.0 + rev: 24.4.2 hooks: - id: black # It is recommended to specify the latest version of Python @@ -19,7 +19,7 @@ repos: # https://pre-commit.com/#top_level-default_language_version language_version: python3 - repo: https://github.com/psf/black - rev: 24.3.0 + rev: 24.4.2 hooks: - id: black-jupyter language_version: python3 From cec874cb5f9d46692a576ae3c555c7e9fae6539e Mon Sep 17 00:00:00 2001 From: Anowar Shajib Date: Tue, 14 May 2024 23:46:46 -0500 Subject: [PATCH 06/62] Fix error message --- hierarc/Sampling/ParamManager/los_param.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/hierarc/Sampling/ParamManager/los_param.py b/hierarc/Sampling/ParamManager/los_param.py index e2292215..2f2e3558 100644 --- a/hierarc/Sampling/ParamManager/los_param.py +++ b/hierarc/Sampling/ParamManager/los_param.py @@ -26,7 +26,7 @@ def __init__( for los_distribution in los_distributions: if los_distribution not in _LOS_DISTRIBUTIONS: raise ValueError( - "SNE distribution %s not supported. Please chose among %s." + "LOS distribution %s not supported. Please chose among %s." % (los_distribution, _LOS_DISTRIBUTIONS) ) self._los_distributions = los_distributions From 5fdae6b9f24c8c7747880ca11706381e400e2934 Mon Sep 17 00:00:00 2001 From: Anowar Shajib Date: Thu, 16 May 2024 12:02:09 -0500 Subject: [PATCH 07/62] Refactor MCMCSampler class to separate the EMCEE sampling and sampler retrieval --- hierarc/Sampling/mcmc_sampling.py | 41 ++++++++++++++++++++++++++++--- 1 file changed, 38 insertions(+), 3 deletions(-) diff --git a/hierarc/Sampling/mcmc_sampling.py b/hierarc/Sampling/mcmc_sampling.py index 036c0fe2..95477148 100644 --- a/hierarc/Sampling/mcmc_sampling.py +++ b/hierarc/Sampling/mcmc_sampling.py @@ -15,7 +15,7 @@ def __init__(self, *args, **kwargs): self.chain = CosmoLikelihood(*args, **kwargs) self.param = self.chain.param - def mcmc_emcee( + def get_emcee_sampler( self, n_walkers, n_burn, @@ -25,7 +25,7 @@ def mcmc_emcee( continue_from_backend=False, **kwargs_emcee ): - """Runs the EMCEE MCMC sampling. + """Runs the EMCEE MCMC sampling and returns the sampler. :param n_walkers: number of walkers :param n_burn: number of iteration of burn in (not stored in the output sample @@ -36,7 +36,7 @@ def mcmc_emcee( :param continue_from_backend: bool, if True and 'backend' in kwargs_emcee, will continue a chain sampling from backend :param kwargs_emcee: keyword argument for the emcee (e.g. to specify backend) - :return: samples of the EMCEE run + :return: sampler of the EMCEE run """ num_param = self.param.num_param @@ -53,6 +53,41 @@ def mcmc_emcee( else: backend.reset(n_walkers, num_param) sampler.run_mcmc(p0, n_burn + n_run, progress=True) + + return sampler + + def mcmc_emcee( + self, + n_walkers, + n_burn, + n_run, + kwargs_mean_start, + kwargs_sigma_start, + continue_from_backend=False, + **kwargs_emcee + ): + """Runs the EMCEE MCMC sampling and returns the flat chain. + + :param n_walkers: number of walkers + :param n_burn: number of iteration of burn in (not stored in the output sample + :param n_run: number of iterations (after burn in) to be sampled + :param kwargs_mean_start: keyword arguments of the mean starting position + :param kwargs_sigma_start: keyword arguments of the spread in the initial + particles per parameter + :param continue_from_backend: bool, if True and 'backend' in kwargs_emcee, will + continue a chain sampling from backend + :param kwargs_emcee: keyword argument for the emcee (e.g. to specify backend) + :return: samples of the EMCEE run + """ + sampler = self.get_emcee_sampler( + n_walkers, + n_burn, + n_run, + kwargs_mean_start, + kwargs_sigma_start, + continue_from_backend=continue_from_backend, + **kwargs_emcee + ) flat_samples = sampler.get_chain(discard=n_burn, thin=1, flat=True) log_prob = sampler.get_log_prob(discard=n_burn, thin=1, flat=True) return flat_samples, log_prob From aec7509b004ee62db0e5d917e3d19ece046534c2 Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Thu, 16 May 2024 13:41:39 -0400 Subject: [PATCH 08/62] added codecov token --- codecov.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/codecov.yml b/codecov.yml index 4e42443f..4b3f9894 100644 --- a/codecov.yml +++ b/codecov.yml @@ -1,3 +1,5 @@ +codecov: + token: 399bc344-9039-4f2b-9ade-fee2aac10b78 comment: # this is a top-level key layout: " diff, flags, files" behavior: default From dc5de27b251e43fad73e9b4f9f06c1085b664ff6 Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Wed, 29 May 2024 09:37:56 -0400 Subject: [PATCH 09/62] added codecov token --- hierarc/Likelihood/cosmo_likelihood.py | 2 +- hierarc/Likelihood/los_distributions.py | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/hierarc/Likelihood/cosmo_likelihood.py b/hierarc/Likelihood/cosmo_likelihood.py index c627dbe2..d5d22a38 100644 --- a/hierarc/Likelihood/cosmo_likelihood.py +++ b/hierarc/Likelihood/cosmo_likelihood.py @@ -241,7 +241,7 @@ def likelihood(self, args, kwargs_cosmo_interp=None): log_l += self._kde_likelihood.kdelikelihood_samples(cosmo_params)[0] if self._prior_add is True: log_l += self._custom_prior( - kwargs_cosmo, kwargs_lens, kwargs_kin, kwargs_source + kwargs_cosmo, kwargs_lens, kwargs_kin, kwargs_source, kwargs_los ) return log_l diff --git a/hierarc/Likelihood/los_distributions.py b/hierarc/Likelihood/los_distributions.py index 2e02b3e8..69f4aef9 100644 --- a/hierarc/Likelihood/los_distributions.py +++ b/hierarc/Likelihood/los_distributions.py @@ -38,7 +38,6 @@ def __init__( and kappa_bin_edges is not None and not self._draw_kappa_global ): - print("test kappa pdf sampling") self._kappa_dist = PDFSampling( bin_edges=kappa_bin_edges, pdf_array=kappa_pdf ) From 905f027909ffee63323a792aab9c670e553aacd5 Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Wed, 29 May 2024 09:49:32 -0400 Subject: [PATCH 10/62] fix test --- test/test_Likelihood/test_cosmo_likelihood.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/test_Likelihood/test_cosmo_likelihood.py b/test/test_Likelihood/test_cosmo_likelihood.py index dc323736..6035cbae 100644 --- a/test/test_Likelihood/test_cosmo_likelihood.py +++ b/test/test_Likelihood/test_cosmo_likelihood.py @@ -78,7 +78,7 @@ def test_log_likelihood(self): cosmo_fixed=None, ) - def custom_prior(kwargs_cosmo, kwargs_lens, kwargs_kin, kwargs_source): + def custom_prior(kwargs_cosmo, kwargs_lens, kwargs_kin, kwargs_source, kwargs_los): return -1 cosmoL_prior = CosmoLikelihood( From a38dd3b97cd0aa469eb014201e602a51b83ea0e0 Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Wed, 26 Jun 2024 21:55:37 -0400 Subject: [PATCH 11/62] major restructuring of parameter distribution and design of the interpolation grid for the kinematic scaling --- hierarc/LensPosterior/base_config.py | 12 +- hierarc/LensPosterior/ddt_kin_constraints.py | 5 +- .../ddt_kin_gauss_constraints.py | 5 +- hierarc/LensPosterior/kin_constraints.py | 20 +- .../kin_constraints_composite.py | 50 ++- ...otropy_config.py => kin_scaling_config.py} | 38 +- hierarc/Likelihood/cosmo_likelihood.py | 86 +--- hierarc/Likelihood/hierarchy_likelihood.py | 334 +++++--------- hierarc/Likelihood/kin_scaling.py | 138 ++++++ hierarc/Likelihood/lens_sample_likelihood.py | 50 ++- hierarc/Likelihood/parameter_scaling.py | 227 ---------- hierarc/Sampling/Distributions/__init__.py | 0 .../Distributions/anisotropy_distributions.py | 78 ++++ .../Distributions/lens_distribution.py | 189 ++++++++ .../Distributions}/los_distributions.py | 0 .../Sampling/ParamManager/param_manager.py | 2 +- .../test_anisotropy_config.py | 24 +- .../test_kin_constraints_composite.py | 52 +-- test/test_Likelihood/test_cosmo_likelihood.py | 27 +- .../test_hierarchy_likelihood.py | 110 +++-- test/test_Likelihood/test_kin_scaling.py | 269 +++++++++++ .../test_lens_sample_likelihood.py | 7 +- test/test_Likelihood/test_los_distribution.py | 2 +- .../test_Likelihood/test_parameter_scaling.py | 417 ------------------ .../test_Distributions/__init__.py | 0 .../test_anisotropy_distribution.py | 36 ++ .../test_lens_distribution.py | 51 +++ test/test_Sampling/test_mcmc_sampling.py | 13 +- 28 files changed, 1129 insertions(+), 1113 deletions(-) rename hierarc/LensPosterior/{anisotropy_config.py => kin_scaling_config.py} (65%) create mode 100644 hierarc/Likelihood/kin_scaling.py delete mode 100644 hierarc/Likelihood/parameter_scaling.py create mode 100644 hierarc/Sampling/Distributions/__init__.py create mode 100644 hierarc/Sampling/Distributions/anisotropy_distributions.py create mode 100644 hierarc/Sampling/Distributions/lens_distribution.py rename hierarc/{Likelihood => Sampling/Distributions}/los_distributions.py (100%) create mode 100644 test/test_Likelihood/test_kin_scaling.py delete mode 100644 test/test_Likelihood/test_parameter_scaling.py create mode 100644 test/test_Sampling/test_Distributions/__init__.py create mode 100644 test/test_Sampling/test_Distributions/test_anisotropy_distribution.py create mode 100644 test/test_Sampling/test_Distributions/test_lens_distribution.py diff --git a/hierarc/LensPosterior/base_config.py b/hierarc/LensPosterior/base_config.py index 9fef09ec..258c12f7 100644 --- a/hierarc/LensPosterior/base_config.py +++ b/hierarc/LensPosterior/base_config.py @@ -1,9 +1,9 @@ from lenstronomy.Analysis.td_cosmography import TDCosmography from hierarc.LensPosterior.imaging_constraints import ImageModelPosterior -from hierarc.LensPosterior.anisotropy_config import AnisotropyConfig +from hierarc.LensPosterior.kin_scaling_config import KinScalingConfig -class BaseLensConfig(TDCosmography, ImageModelPosterior, AnisotropyConfig): +class BaseLensConfig(TDCosmography, ImageModelPosterior, KinScalingConfig): """This class contains and manages the base configurations of the lens posteriors and makes sure that they are universally applied consistently through the different likelihood definitions.""" @@ -33,6 +33,8 @@ def __init__( num_kin_sampling=1000, multi_observations=False, cosmo_fiducial=None, + gamma_in_scaling=None, + log_m2l_scaling=None, ): """ @@ -62,6 +64,8 @@ def __init__( light profile :param cosmo_fiducial: astropy.cosmology instance, if None, uses astropy's default cosmology + :param gamma_in_scaling: array of gamma_in parameter to be interpolated (optional, otherwise None) + :param log_m2l_scaling: array of log_m2l parameter to be interpolated (optional, otherwise None) """ self._z_lens, self._z_source = z_lens, z_source @@ -105,4 +109,6 @@ def __init__( ImageModelPosterior.__init__( self, theta_E, theta_E_error, gamma, gamma_error, r_eff, r_eff_error ) - AnisotropyConfig.__init__(self, anisotropy_model, r_eff) + KinScalingConfig.__init__(self, anisotropy_model, r_eff, + gamma_in_scaling=gamma_in_scaling, + log_m2l_scaling=log_m2l_scaling) diff --git a/hierarc/LensPosterior/ddt_kin_constraints.py b/hierarc/LensPosterior/ddt_kin_constraints.py index 68b23726..3c825e2a 100644 --- a/hierarc/LensPosterior/ddt_kin_constraints.py +++ b/hierarc/LensPosterior/ddt_kin_constraints.py @@ -124,7 +124,8 @@ def hierarchy_configuration(self, num_sample_model=20): "j_model": j_model_list, "error_cov_measurement": error_cov_measurement, "error_cov_j_sqrt": error_cov_j_sqrt, - "ani_param_array": self.ani_param_array, - "ani_scaling_array_list": ani_scaling_array_list, + "kin_scaling_param_list": self.param_name_list, + "j_kin_scaling_param_axes": self.kin_scaling_param_array, + "j_kin_scaling_grid_list": ani_scaling_array_list, } return kwargs_likelihood diff --git a/hierarc/LensPosterior/ddt_kin_gauss_constraints.py b/hierarc/LensPosterior/ddt_kin_gauss_constraints.py index 4112c74a..6507d485 100644 --- a/hierarc/LensPosterior/ddt_kin_gauss_constraints.py +++ b/hierarc/LensPosterior/ddt_kin_gauss_constraints.py @@ -123,7 +123,8 @@ def hierarchy_configuration(self, num_sample_model=20): "j_model": j_model_list, "error_cov_measurement": error_cov_measurement, "error_cov_j_sqrt": error_cov_j_sqrt, - "ani_param_array": self.ani_param_array, - "ani_scaling_array_list": ani_scaling_array_list, + "kin_scaling_param_list": self.param_name_list, + "j_kin_scaling_param_axes": self.kin_scaling_param_array, + "j_kin_scaling_grid_list": ani_scaling_array_list, } return kwargs_likelihood diff --git a/hierarc/LensPosterior/kin_constraints.py b/hierarc/LensPosterior/kin_constraints.py index 74147ff1..7bae1ea4 100644 --- a/hierarc/LensPosterior/kin_constraints.py +++ b/hierarc/LensPosterior/kin_constraints.py @@ -36,6 +36,8 @@ def __init__( num_kin_sampling=1000, multi_observations=False, cosmo_fiducial=None, + gamma_in_scaling=None, + log_m2l_scaling=None, ): """ @@ -77,6 +79,8 @@ def __init__( kwargs_seeing as lists of multiple observations :param cosmo_fiducial: astropy.cosmology instance, if None, uses astropy's default + :param gamma_in_scaling: array of gamma_in parameter to be interpolated (optional, otherwise None) + :param log_m2l_scaling: array of log_m2l parameter to be interpolated (optional, otherwise None) """ self._sigma_v_measured = np.array(sigma_v_measured) self._sigma_v_error_independent = np.array(sigma_v_error_independent) @@ -111,6 +115,8 @@ def __init__( num_kin_sampling=num_kin_sampling, multi_observations=multi_observations, cosmo_fiducial=cosmo_fiducial, + gamma_in_scaling=gamma_in_scaling, + log_m2l_scaling=log_m2l_scaling, ) def j_kin_draw(self, kwargs_anisotropy, no_error=False): @@ -171,8 +177,10 @@ def hierarchy_configuration(self, num_sample_model=20): "j_model": j_model_list, "error_cov_measurement": error_cov_measurement, "error_cov_j_sqrt": error_cov_j_sqrt, - "ani_param_array": self.ani_param_array, - "ani_scaling_array_list": ani_scaling_array_list, + "kin_scaling_param_list": self.param_name_list, + "j_kin_scaling_param_axes": self.kin_scaling_param_array, + "j_kin_scaling_grid_list": ani_scaling_array_list, + } return kwargs_likelihood @@ -245,11 +253,11 @@ def _anisotropy_scaling_relative(self, j_ani_0): if self._anisotropy_model == "GOM": ani_scaling_array_list = [ - np.zeros((len(self.ani_param_array[0]), len(self.ani_param_array[1]))) + np.zeros((len(self.kin_scaling_param_array[0]), len(self.kin_scaling_param_array[1]))) for _ in range(num_data) ] - for i, a_ani in enumerate(self.ani_param_array[0]): - for j, beta_inf in enumerate(self.ani_param_array[1]): + for i, a_ani in enumerate(self.kin_scaling_param_array[0]): + for j, beta_inf in enumerate(self.kin_scaling_param_array[1]): kwargs_anisotropy = self.anisotropy_kwargs( a_ani=a_ani, beta_inf=beta_inf ) @@ -260,7 +268,7 @@ def _anisotropy_scaling_relative(self, j_ani_0): ) # perhaps change the order elif self._anisotropy_model in ["OM", "const"]: ani_scaling_array_list = [[] for _ in range(num_data)] - for a_ani in self.ani_param_array: + for a_ani in self.kin_scaling_param_array[0]: kwargs_anisotropy = self.anisotropy_kwargs(a_ani) j_kin_ani = self.j_kin_draw(kwargs_anisotropy, no_error=True) for i, j_kin in enumerate(j_kin_ani): diff --git a/hierarc/LensPosterior/kin_constraints_composite.py b/hierarc/LensPosterior/kin_constraints_composite.py index fdc2cf0e..99e87118 100644 --- a/hierarc/LensPosterior/kin_constraints_composite.py +++ b/hierarc/LensPosterior/kin_constraints_composite.py @@ -115,6 +115,12 @@ def __init__( lens_model_list = ["GNFW", "MULTI_GAUSSIAN_KAPPA"] + # log_m2l is interpolated when sampled on the population level, otherwise marginalized + if is_m2l_population_level: + log_m2l_scaling = log_m2l_array + else: + log_m2l_scaling = None + super(KinConstraintsComposite, self).__init__( z_lens, z_source, @@ -142,6 +148,8 @@ def __init__( num_psf_sampling=num_psf_sampling, num_kin_sampling=num_kin_sampling, multi_observations=multi_observations, + gamma_in_scaling=gamma_in_array, + log_m2l_scaling=log_m2l_scaling, ) if self._check_arrays(kappa_s_array, r_s_angle_array): @@ -392,16 +400,22 @@ def hierarchy_configuration(self, num_sample_model=20): "j_model": j_model_list, "error_cov_measurement": error_cov_measurement, "error_cov_j_sqrt": error_cov_j_sqrt, - "ani_param_array": self.ani_param_array, - "gamma_in_array": self.gamma_in_array, - "log_m2l_array": self.log_m2l_array, - "param_scaling_grid_list": ani_scaling_grid_list, + + #"ani_param_array": self.kin_scaling_param_array, + #"gamma_in_array": self.gamma_in_array, + #"log_m2l_array": self.log_m2l_array, + #"param_scaling_grid_list": ani_scaling_grid_list, + "gamma_in_prior_mean": self._gamma_in_prior_mean, "gamma_in_prior_std": self._gamma_in_prior_std, + + "kin_scaling_param_list": self.param_name_list, + "j_kin_scaling_param_axes": self.kin_scaling_param_array, + "j_kin_scaling_grid_list": ani_scaling_grid_list, } - if not self._is_m2l_population_level: - kwargs_likelihood["log_m2l_array"] = None + #if not self._is_m2l_population_level: + # kwargs_likelihood["log_m2l_array"] = None return kwargs_likelihood def anisotropy_scaling(self): @@ -438,16 +452,16 @@ def _anisotropy_scaling_relative(self, j_ani_0): ani_scaling_grid_list = [ np.zeros( ( - len(self.ani_param_array[0]), - len(self.ani_param_array[1]), + len(self.kin_scaling_param_array[0]), + len(self.kin_scaling_param_array[1]), len(self.gamma_in_array), len(self.log_m2l_array), ) ) for _ in range(num_data) ] - for i, a_ani in enumerate(self.ani_param_array[0]): - for j, beta_inf in enumerate(self.ani_param_array[1]): + for i, a_ani in enumerate(self.kin_scaling_param_array[0]): + for j, beta_inf in enumerate(self.kin_scaling_param_array[1]): for k, g_in in enumerate(self.gamma_in_array): for l, log_m2l in enumerate(self.log_m2l_array): kwargs_anisotropy = self.anisotropy_kwargs( @@ -466,14 +480,14 @@ def _anisotropy_scaling_relative(self, j_ani_0): ani_scaling_grid_list = [ np.zeros( ( - len(self.ani_param_array), + len(self.kin_scaling_param_array[0]), len(self.gamma_in_array), len(self.log_m2l_array), ) ) for _ in range(num_data) ] - for i, a_ani in enumerate(self.ani_param_array): + for i, a_ani in enumerate(self.kin_scaling_param_array[0]): for k, g_in in enumerate(self.gamma_in_array): for l, log_m2l in enumerate(self.log_m2l_array): kwargs_anisotropy = self.anisotropy_kwargs(a_ani) @@ -500,15 +514,15 @@ def _anisotropy_scaling_relative_m2l(self, j_ani_0): ani_scaling_grid_list = [ np.zeros( ( - len(self.ani_param_array[0]), - len(self.ani_param_array[1]), + len(self.kin_scaling_param_array[0]), + len(self.kin_scaling_param_array[1]), len(self.gamma_in_array), ) ) for _ in range(num_data) ] - for i, a_ani in enumerate(self.ani_param_array[0]): - for j, beta_inf in enumerate(self.ani_param_array[1]): + for i, a_ani in enumerate(self.kin_scaling_param_array[0]): + for j, beta_inf in enumerate(self.kin_scaling_param_array[1]): for k, g_in in enumerate(self.gamma_in_array): kwargs_anisotropy = self.anisotropy_kwargs( a_ani=a_ani, beta_inf=beta_inf @@ -524,13 +538,13 @@ def _anisotropy_scaling_relative_m2l(self, j_ani_0): ani_scaling_grid_list = [ np.zeros( ( - len(self.ani_param_array), + len(self.kin_scaling_param_array[0]), len(self.gamma_in_array), ) ) for _ in range(num_data) ] - for i, a_ani in enumerate(self.ani_param_array): + for i, a_ani in enumerate(self.kin_scaling_param_array[0]): for k, g_in in enumerate(self.gamma_in_array): kwargs_anisotropy = self.anisotropy_kwargs(a_ani) j_kin_ani = self.j_kin_draw_composite_m2l( diff --git a/hierarc/LensPosterior/anisotropy_config.py b/hierarc/LensPosterior/kin_scaling_config.py similarity index 65% rename from hierarc/LensPosterior/anisotropy_config.py rename to hierarc/LensPosterior/kin_scaling_config.py index d827d408..8a51b2ad 100644 --- a/hierarc/LensPosterior/anisotropy_config.py +++ b/hierarc/LensPosterior/kin_scaling_config.py @@ -1,36 +1,47 @@ import numpy as np -class AnisotropyConfig(object): +class KinScalingConfig(object): """Class to manage the anisotropy model and parameters for the Posterior processing.""" - def __init__(self, anisotropy_model, r_eff): + def __init__(self, anisotropy_model, r_eff, gamma_in_scaling=None, log_m2l_scaling=None): """ :param anisotropy_model: type of stellar anisotropy model. Supported are 'OM' and 'GOM' or 'const', see details in lenstronomy.Galkin module :param r_eff: half-light radius of the deflector galaxy + :param gamma_in_scaling: array of gamma_in parameter to be interpolated (optional, otherwise None) + :param log_m2l_scaling: array of log_m2l parameter to be interpolated (optional, otherwise None) """ self._r_eff = r_eff self._anisotropy_model = anisotropy_model + self._param_name_list = [] if self._anisotropy_model == "OM": - self._ani_param_array = np.array( - [0.1, 0.2, 0.5, 1, 2, 5] - ) # used for r_ani OsipkovMerritt anisotropy description + self._ani_param_array = [np.array([0.1, 0.2, 0.5, 1, 2, 5])] + # used for r_ani OsipkovMerritt anisotropy description + self._param_name_list = ["a_ani"] elif self._anisotropy_model == "GOM": self._ani_param_array = [ np.array([0.1, 0.2, 0.5, 1, 2, 5]), np.array([0, 0.5, 0.8, 1]), ] + self._param_name_list = ["a_ani", "beta_inf"] elif self._anisotropy_model == "const": - self._ani_param_array = np.linspace( - -0.49, 1, 7 - ) # used for constant anisotropy description + self._ani_param_array = [np.linspace(-0.49, 1, 7)] # used for constant anisotropy description + self._param_name_list = ["a_ani"] + elif self._anisotropy_model == "NONE": + self._param_name_list =[] else: raise ValueError( "anisotropy model %s not supported." % self._anisotropy_model ) + if gamma_in_scaling is not None: + self._param_name_list.append("gamma_in") + self._ani_param_array.append(np.array(gamma_in_scaling)) + if log_m2l_scaling is not None: + self._param_name_list.append("log_m2l") + self._ani_param_array.append(np.array(log_m2l_scaling)) @property def kwargs_anisotropy_base(self): @@ -57,13 +68,22 @@ def kwargs_anisotropy_base(self): return kwargs_anisotropy_0 @property - def ani_param_array(self): + def kin_scaling_param_array(self): """ :return: numpy array of anisotropy parameter values to be explored """ return self._ani_param_array + @property + def param_name_list(self): + """ + list of parameters in same order as interpolated + + :return: + """ + return self._param_name_list + def anisotropy_kwargs(self, a_ani, beta_inf=None): """ diff --git a/hierarc/Likelihood/cosmo_likelihood.py b/hierarc/Likelihood/cosmo_likelihood.py index d5d22a38..f900cbfa 100644 --- a/hierarc/Likelihood/cosmo_likelihood.py +++ b/hierarc/Likelihood/cosmo_likelihood.py @@ -14,35 +14,13 @@ def __init__( self, kwargs_likelihood_list, cosmology, + kwargs_model, kwargs_bounds, sne_likelihood=None, kwargs_sne_likelihood=None, KDE_likelihood_chain=None, kwargs_kde_likelihood=None, - ppn_sampling=False, - lambda_mst_sampling=False, - lambda_mst_distribution="delta", - anisotropy_sampling=False, - gamma_in_sampling=False, - gamma_in_distribution="NONE", - log_m2l_sampling=False, - log_m2l_distribution="NONE", - los_sampling=False, - los_distributions=None, - alpha_lambda_sampling=False, - beta_lambda_sampling=False, - alpha_gamma_in_sampling=False, - alpha_log_m2l_sampling=False, - lambda_ifu_sampling=False, - lambda_ifu_distribution="NONE", - sigma_v_systematics=False, - sne_apparent_m_sampling=False, - sne_distribution="GAUSSIAN", - z_apparent_m_anchor=0.1, - log_scatter=False, normalized=False, - anisotropy_model="OM", - anisotropy_distribution="NONE", custom_prior=None, interpolate_cosmo=True, num_redshift_interp=100, @@ -52,6 +30,8 @@ def __init__( :param kwargs_likelihood_list: keyword argument list specifying the arguments of the LensLikelihood class :param cosmology: string describing cosmological model + :param kwargs_model: model settings for ParamManager() class + :type kwargs_model: dict :param kwargs_bounds: keyword arguments of the lower and upper bounds and parameters that are held fixed. Includes: 'kwargs_lower_lens', 'kwargs_upper_lens', 'kwargs_fixed_lens', @@ -63,38 +43,6 @@ def __init__( :param sne_likelihood: (string), optional. Sampling supernovae relative expansion history likelihood, see SneLikelihood module for options :param kwargs_sne_likelihood: keyword argument for the SNe likelihood, see SneLikelihood module for options - :param ppn_sampling:post-newtonian parameter sampling - :param lambda_mst_sampling: bool, if True adds a global mass-sheet transform parameter in the sampling - :param lambda_mst_distribution: string, defines the distribution function of lambda_mst - :param lambda_ifu_sampling: bool, if True samples a separate lambda_mst for a second (e.g. IFU) data set - independently - :param lambda_ifu_distribution: string, distribution function of the lambda_ifu parameter - :param alpha_lambda_sampling: bool, if True samples a parameter alpha_lambda, which scales lambda_mst linearly - according to the lens posterior kwargs 'lambda_scaling_property' - :param beta_lambda_sampling: bool, if True samples a parameter beta_lambda, which scales lambda_mst linearly - according to the lens posterior kwargs 'lambda_scaling_property_beta' - :param los_sampling: if sampling of the parameters should be done - :type los_sampling: bool - :param los_distributions: what distribution to be sampled - :type los_distributions: list of str - :param anisotropy_sampling: bool, if True adds a global stellar anisotropy parameter that alters the single lens - kinematic prediction - :param anisotropy_model: string, specifies the stellar anisotropy model - :param anisotropy_distribution: string, distribution of the anisotropy parameters - :param gamma_in_sampling: bool, if True samples gNFW inner slope parameter - :param gamma_in_distribution: string, distribution function of the gamma_in parameter - :param log_m2l_sampling: bool, if True samples a global mass-to-light ratio parameter in logarithmic scale - :param log_m2l_distribution: string, distribution function of the log_m2l parameter - :param sigma_v_systematics: bool, if True samples paramaters relative to systematics in the velocity dispersion - measurement - :param sne_apparent_m_sampling: boolean, if True, samples/queries SNe unlensed magnitude distribution - (not intrinsic magnitudes but apparent!) - :param sne_distribution: string, apparent non-lensed brightness distribution (in linear space). - Currently supports: - 'GAUSSIAN': Gaussian distribution - :param z_apparent_m_anchor: redshift of pivot/anchor at which the apparent SNe brightness is defined relative to - :param log_scatter: boolean, if True, samples the Gaussian scatter amplitude in log space - (and thus flat prior in log) :param custom_prior: None or a definition that takes the keywords from the CosmoParam conventions and returns a log likelihood value (e.g. prior) :param interpolate_cosmo: bool, if True, uses interpolated comoving distance in the calculation for speed-up @@ -105,38 +53,16 @@ def __init__( """ self._cosmology = cosmology self._kwargs_lens_list = kwargs_likelihood_list - if sigma_v_systematics is True: + if kwargs_model.get("sigma_v_systematics", False) is True: normalized = True self._likelihoodLensSample = LensSampleLikelihood( kwargs_likelihood_list, normalized=normalized, - los_distributions=los_distributions, + kwargs_global_model=kwargs_model, ) self.param = ParamManager( cosmology, - ppn_sampling=ppn_sampling, - lambda_mst_sampling=lambda_mst_sampling, - lambda_mst_distribution=lambda_mst_distribution, - lambda_ifu_sampling=lambda_ifu_sampling, - lambda_ifu_distribution=lambda_ifu_distribution, - alpha_lambda_sampling=alpha_lambda_sampling, - beta_lambda_sampling=beta_lambda_sampling, - gamma_in_sampling=gamma_in_sampling, - gamma_in_distribution=gamma_in_distribution, - log_m2l_sampling=log_m2l_sampling, - log_m2l_distribution=log_m2l_distribution, - alpha_gamma_in_sampling=alpha_gamma_in_sampling, - alpha_log_m2l_sampling=alpha_log_m2l_sampling, - sne_apparent_m_sampling=sne_apparent_m_sampling, - sne_distribution=sne_distribution, - z_apparent_m_anchor=z_apparent_m_anchor, - sigma_v_systematics=sigma_v_systematics, - los_sampling=los_sampling, - los_distributions=los_distributions, - anisotropy_sampling=anisotropy_sampling, - anisotropy_model=anisotropy_model, - anisotropy_distribution=anisotropy_distribution, - log_scatter=log_scatter, + **kwargs_model, **kwargs_bounds ) self._lower_limit, self._upper_limit = self.param.param_bounds diff --git a/hierarc/Likelihood/hierarchy_likelihood.py b/hierarc/Likelihood/hierarchy_likelihood.py index 5ff14904..2b5aaf7b 100644 --- a/hierarc/Likelihood/hierarchy_likelihood.py +++ b/hierarc/Likelihood/hierarchy_likelihood.py @@ -1,40 +1,59 @@ from hierarc.Likelihood.transformed_cosmography import TransformedCosmography from hierarc.Likelihood.LensLikelihood.base_lens_likelihood import LensLikelihoodBase -from hierarc.Likelihood.parameter_scaling import ParameterScalingIFU -from hierarc.Likelihood.los_distributions import LOSDistribution +from hierarc.Likelihood.kin_scaling import KinScaling +from hierarc.Sampling.Distributions.los_distributions import LOSDistribution +from hierarc.Sampling.Distributions.anisotropy_distributions import AnisotropyDistribution +from hierarc.Sampling.Distributions.lens_distribution import LensDistribution import numpy as np import copy -class LensLikelihood(TransformedCosmography, LensLikelihoodBase, ParameterScalingIFU): +class LensLikelihood(TransformedCosmography, LensLikelihoodBase, KinScaling): """Master class containing the likelihood definitions of different analysis for a single lens.""" def __init__( self, + # properties of the lens z_lens, z_source, name="name", likelihood_type="TDKin", + lambda_scaling_property=0, + lambda_scaling_property_beta=0, + kwargs_lens_properties=None, + # specific distribution settings for individual lenses + global_los_distribution=False, + mst_ifu=False, + # global distributions anisotropy_model="NONE", - ani_param_array=None, - ani_scaling_array=None, - ani_scaling_array_list=None, - gamma_in_array=None, - log_m2l_array=None, - param_scaling_grid_list=None, + anisotropy_sampling=False, + anisotroy_distribution_function="NONE", # make sure input is provided + los_distributions=None, + lambda_mst_distribution="NONE", + gamma_in_sampling=False, + gamma_in_distribution="NONE", + log_m2l_sampling=False, + log_m2l_distribution="NONE", + alpha_lambda_sampling=False, + beta_lambda_sampling=False, + alpha_gamma_in_sampling=False, + alpha_log_m2l_sampling=False, + log_scatter=False, + # kinematic model quantities + kin_scaling_param_list=None, + j_kin_scaling_param_axes=None, + j_kin_scaling_grid_list=None, + # likelihood evaluation quantities num_distribution_draws=50, - global_los_distribution=False, + normalized=True, + # kappa quantities kappa_pdf=None, kappa_bin_edges=None, - mst_ifu=False, - lambda_scaling_property=0, - lambda_scaling_property_beta=0, - normalized=True, - kwargs_lens_properties=None, - gamma_in_prior_mean=None, + # priors + gamma_in_prior_mean=None, # TODO: make a separate prior class with inputs gamma_in_prior_std=None, - los_distributions=None, + # specifics for each lens **kwargs_likelihood ): """ @@ -43,14 +62,10 @@ def __init__( :param z_source: source redshift :param name: string (optional) to name the specific lens :param likelihood_type: string to specify the likelihood type - :param ani_param_array: array of anisotropy parameter values for which the kinematics are predicted - :param ani_scaling_array: velocity dispersion sigma**2 scaling (also J scaling) of anisotropy parameter relative - to default prediction. The scaling corresponds to the ani_param_array parameter spacing - (to generate an interpolation function). A value =1 in ani_scaling_array results in the value stored in the - provided J() predictions. - :param param_scaling_grid_list: list of N-dimensional arrays with the - scalings of J() for each IFU. Needed when simultaneously scaling - anisotropy, gamma_in, and log_m2l. In that case, gamma_in_array and log_m2l_array need to be provided. + :param j_kin_scaling_param_axes: array of parameter values for each axes of j_kin_scaling_grid + :param j_kin_scaling_grid_list: list of array with the scalings of J() for each IFU + :param j_kin_scaling_param_name_list: list of strings for the parameters as they are interpolated in the same + order as j_kin_scaling_grid :param num_distribution_draws: int, number of distribution draws from the likelihood that are being averaged over :param global_los_distribution: if integer, will draw from the global kappa distribution specified in that @@ -74,46 +89,16 @@ def __init__( see individual classes for their use :param los_distributions: list of all line of sight distributions parameterized :type los_distributions: list of str or None + :param anisotropy_sampling: bool, if True adds a global stellar anisotropy parameter that alters the single lens + kinematic prediction """ TransformedCosmography.__init__(self, z_lens=z_lens, z_source=z_source) - if ani_scaling_array_list is None and ani_scaling_array is not None: - ani_scaling_array_list = [ani_scaling_array] - - # AnisotropyScalingIFU.__init__( - # self, - # anisotropy_model=anisotropy_model, - # ani_param_array=ani_param_array, - # ani_scaling_array_list=ani_scaling_array_list, - # ) - if gamma_in_array is not None and log_m2l_array is not None: - if isinstance(ani_param_array, list): - param_arrays = ani_param_array + [gamma_in_array, log_m2l_array] - else: - param_arrays = [ani_param_array, gamma_in_array, log_m2l_array] - ParameterScalingIFU.__init__( - self, - anisotropy_model=anisotropy_model, - param_arrays=param_arrays, - scaling_grid_list=param_scaling_grid_list, - ) - elif gamma_in_array is not None and log_m2l_array is None: - if isinstance(ani_param_array, list): - param_arrays = ani_param_array + [gamma_in_array] - else: - param_arrays = [ani_param_array, gamma_in_array] - ParameterScalingIFU.__init__( - self, - anisotropy_model=anisotropy_model, - param_arrays=param_arrays, - scaling_grid_list=param_scaling_grid_list, - ) - else: - ParameterScalingIFU.__init__( - self, - anisotropy_model=anisotropy_model, - param_arrays=ani_param_array, - scaling_grid_list=ani_scaling_array_list, - ) + + KinScaling.__init__(self, + j_kin_scaling_param_axes=j_kin_scaling_param_axes, + j_kin_scaling_grid_list=j_kin_scaling_grid_list, + j_kin_scaling_param_name_list=kin_scaling_param_list + ) LensLikelihoodBase.__init__( self, @@ -133,11 +118,29 @@ def __init__( global_los_distribution=global_los_distribution, los_distributions=los_distributions, ) - self._mst_ifu = mst_ifu - self._lambda_scaling_property = lambda_scaling_property - self._lambda_scaling_property_beta = lambda_scaling_property_beta - self._gamma_in_array = gamma_in_array - self._log_m2l_array = log_m2l_array + kwargs_min, kwargs_max = self.param_bounds_interpol() + self._lens_distribution = LensDistribution(lambda_mst_sampling=False, + lambda_mst_distribution=lambda_mst_distribution, + gamma_in_sampling=gamma_in_sampling, + gamma_in_distribution=gamma_in_distribution, + log_m2l_sampling=log_m2l_sampling, + log_m2l_distribution=log_m2l_distribution, + alpha_lambda_sampling=alpha_lambda_sampling, + beta_lambda_sampling=beta_lambda_sampling, + alpha_gamma_in_sampling=alpha_gamma_in_sampling, + alpha_log_m2l_sampling=alpha_log_m2l_sampling, + log_scatter=log_scatter, + mst_ifu=mst_ifu, + lambda_scaling_property=lambda_scaling_property, + lambda_scaling_property_beta=lambda_scaling_property_beta, + kwargs_min=kwargs_min, + kwargs_max=kwargs_max,) + + self._aniso_distribution = AnisotropyDistribution(anisotropy_model=anisotropy_model, + anisotropy_sampling=anisotropy_sampling, + distribution_function=anisotroy_distribution_function, + kwargs_anisotropy_min=kwargs_min, + kwargs_anisotropy_max=kwargs_max) self._gamma_in_prior_mean = gamma_in_prior_mean self._gamma_in_prior_std = gamma_in_prior_std @@ -265,17 +268,19 @@ def log_likelihood_single( :param ddt: time-delay distance :param dd: angular diameter distance to the deflector :param delta_lum_dist: relative luminosity distance to pivot redshift - :param kwargs_lens: keywords of the hyper parameters of the lens model - :param kwargs_kin: keyword arguments of the kinematic model hyper parameters + :param kwargs_lens: keywords of the hyperparameters of the lens model + :param kwargs_kin: keyword arguments of the kinematic model hyperparameters :param kwargs_source: keyword arguments of source brightness :param kwargs_los: line of sight list of dictionaries :param sigma_v_sys_error: unaccounted uncertainty in the velocity dispersion measurement :return: log likelihood given the single lens analysis for a single (random) - realization of the hyper parameter distribution + realization of the hyperparameter distribution """ - lambda_mst, gamma_ppn = self.draw_lens(**kwargs_lens) + kwargs_lens_draw = self._lens_distribution.draw_lens(**kwargs_lens) + lambda_mst, gamma_ppn = kwargs_lens_draw["lambda_mst"], kwargs_lens_draw["gamma_ppn"] kappa_ext = self._los.draw_los(kwargs_los) + # draw intrinsic source magnitude mag_source = self.draw_source(lum_dist=delta_lum_dist, **kwargs_source) ddt_, dd_, mag_source_ = self.displace_prediction( @@ -286,13 +291,9 @@ def log_likelihood_single( kappa_ext=kappa_ext, mag_source=mag_source, ) - try: - scaling_param_array = self.draw_scaling_params( - kwargs_lens=kwargs_lens, **kwargs_kin - ) - except ValueError: - return np.nan_to_num(-np.inf) - kin_scaling = self.param_scaling(scaling_param_array) + kwargs_kin_draw = self._aniso_distribution.draw_anisotropy(**kwargs_kin) + kwargs_param = {**kwargs_lens_draw, **kwargs_kin_draw} + kin_scaling = self.kin_scaling(kwargs_param) lnlikelihood = self.log_likelihood( ddt_, @@ -305,97 +306,15 @@ def log_likelihood_single( if ( self._gamma_in_prior_mean is not None and self._gamma_in_prior_std is not None + and "gamma_in" in kwargs_lens_draw ): - if self._gamma_in_array is not None and self._log_m2l_array is not None: - lnlikelihood -= ( - self._gamma_in_prior_mean - scaling_param_array[-2] - ) ** 2 / (2 * self._gamma_in_prior_std**2) - elif self._gamma_in_array is not None and self._log_m2l_array is None: - lnlikelihood -= ( - self._gamma_in_prior_mean - scaling_param_array[-1] - ) ** 2 / (2 * self._gamma_in_prior_std**2) + gamma_in = kwargs_lens_draw["gamma_in"] + lnlikelihood -= ( + self._gamma_in_prior_mean - gamma_in + ) ** 2 / (2 * self._gamma_in_prior_std**2) return np.nan_to_num(lnlikelihood) - def draw_scaling_params(self, kwargs_lens=None, **kwargs_kin): - """Draws a realization of the anisotropy parameter scaling from the distribution - function. - - :return: array of anisotropy parameter scaling - """ - ani_param = self.draw_anisotropy(**kwargs_kin) - if self._gamma_in_array is not None and self._log_m2l_array is not None: - gamma_in, log_m2l = self.draw_lens_scaling_params(**kwargs_lens) - return np.concatenate([ani_param, [gamma_in, log_m2l]]) - elif self._gamma_in_array is not None and self._log_m2l_array is None: - gamma_in = self.draw_lens_scaling_params(**kwargs_lens) - return np.concatenate([ani_param, [gamma_in]]) - else: - return ani_param - - def draw_lens_scaling_params( - self, - lambda_mst=1, - lambda_mst_sigma=0, - kappa_ext=0, - kappa_ext_sigma=0, - gamma_ppn=1, - lambda_ifu=1, - lambda_ifu_sigma=0, - alpha_lambda=0, - beta_lambda=0, - gamma_in=1, - gamma_in_sigma=0, - alpha_gamma_in=0, - log_m2l=1, - log_m2l_sigma=0, - alpha_log_m2l=0, - ): - """Draws a realization of the anisotropy parameter scaling from the - distribution. - - :param lambda_mst: MST transform - :param lambda_mst_sigma: spread in the distribution - :param kappa_ext: external convergence mean in distribution - :param kappa_ext_sigma: spread in the distribution - :param gamma_ppn: Post-Newtonian parameter - :param lambda_ifu: secondary lambda_mst parameter for subset of lenses specified - for - :param lambda_ifu_sigma: secondary lambda_mst_sigma parameter for subset of - lenses specified for - :param alpha_lambda: float, linear slope of the lambda_int scaling relation with - lens quantity self._lambda_scaling_property - :param beta_lambda: float, a second linear slope of the lambda_int scaling - relation with lens quantity self._lambda_scaling_property_beta - :param gamma_in: inner slope of the NFW profile - :param gamma_in_sigma: spread in the distribution - :param alpha_gamma_in: float, linear slope of the gamma_in scaling relation with - lens quantity self._lambda_scaling_property - :param log_m2l: log(mass-to-light ratio) - :param log_m2l_sigma: spread in the distribution - :param alpha_log_m2l: float, linear slope of the log(m2l) scaling relation with - lens quantity self._lambda_scaling_property - :return: draw from the distributions - """ - if self._gamma_in_array is not None and self._log_m2l_array is not None: - gamma_in_draw, log_m2l_draw = self.draw_lens_parameters( - gamma_in + alpha_gamma_in * self._lambda_scaling_property, - gamma_in_sigma, - log_m2l + alpha_log_m2l * self._lambda_scaling_property, - log_m2l_sigma, - ) - return gamma_in_draw, log_m2l_draw - - elif self._gamma_in_array is not None and self._log_m2l_array is None: - gamma_in_draw = self.draw_lens_parameters( - gamma_in + alpha_gamma_in * self._lambda_scaling_property, - gamma_in_sigma, - ) - return gamma_in_draw - - else: - return None - def angular_diameter_distances(self, cosmo): """Time-delay distance Ddt, angular diameter distance to the lens (dd) @@ -441,12 +360,12 @@ def luminosity_distance_modulus(self, cosmo, z_apparent_m_anchor): def check_dist(self, kwargs_lens, kwargs_kin, kwargs_source, kwargs_los): """Checks if the provided keyword arguments describe a distribution function of - hyper parameters or are single values. + hyperparameters or are single values. - :param kwargs_lens: lens model hyper-parameter keywords - :param kwargs_kin: kinematic model hyper-parameter keywords - :param kwargs_source: source brightness hyper-parameter keywords - :param kwargs_los: list of dictionaries for line of sight hyper-parameters + :param kwargs_lens: lens model hyperparameter keywords + :param kwargs_kin: kinematic model hyperparameter keywords + :param kwargs_source: source brightness hyperparameter keywords + :param kwargs_los: list of dictionaries for line of sight hyperparameters :return: bool, True if delta function, else False """ lambda_mst_sigma = kwargs_lens.get("lambda_mst_sigma", 0) # scatter in MST @@ -464,62 +383,6 @@ def check_dist(self, kwargs_lens, kwargs_kin, kwargs_source, kwargs_los): return True return False - def draw_lens( - self, - lambda_mst=1, - lambda_mst_sigma=0, - gamma_ppn=1, - lambda_ifu=1, - lambda_ifu_sigma=0, - alpha_lambda=0, - beta_lambda=0, - gamma_in=1, - gamma_in_sigma=0, - alpha_gamma_in=0, - log_m2l=1, - log_m2l_sigma=0, - alpha_log_m2l=0, - ): - """Draws a realization of a specific model from the hyper-parameter - distribution. - - :param lambda_mst: MST transform - :param lambda_mst_sigma: spread in the distribution - :param gamma_ppn: Post-Newtonian parameter - :param lambda_ifu: secondary lambda_mst parameter for subset of lenses specified - for - :param lambda_ifu_sigma: secondary lambda_mst_sigma parameter for subset of - lenses specified for - :param alpha_lambda: float, linear slope of the lambda_int scaling relation with - lens quantity self._lambda_scaling_property - :param beta_lambda: float, a second linear slope of the lambda_int scaling - relation with lens quantity self._lambda_scaling_property_beta - :param gamma_in: inner slope of the NFW profile - :param gamma_in_sigma: spread in the distribution - :param alpha_gamma_in: float, linear slope of the gamma_in scaling relation with - lens quantity self._lambda_scaling_property - :param log_m2l: log(mass-to-light ratio) - :param log_m2l_sigma: spread in the distribution - :param alpha_log_m2l: float, linear slope of the log(m2l) scaling relation with - lens quantity self._lambda_scaling_property - :return: draw from the distributions - """ - if self._mst_ifu is True: - lambda_lens = ( - lambda_ifu - + alpha_lambda * self._lambda_scaling_property - + beta_lambda * self._lambda_scaling_property_beta - ) - lambda_mst_draw = np.random.normal(lambda_lens, lambda_ifu_sigma) - else: - lambda_lens = ( - lambda_mst - + alpha_lambda * self._lambda_scaling_property - + beta_lambda * self._lambda_scaling_property_beta - ) - lambda_mst_draw = np.random.normal(lambda_lens, lambda_mst_sigma) - return lambda_mst_draw, gamma_ppn - @staticmethod def draw_source(mu_sne=1, sigma_sne=0, lum_dist=0, **kwargs): """Draws a source magnitude from a distribution specified by population @@ -546,8 +409,8 @@ def sigma_v_measured_vs_predict( covariance of velocity dispersion predictions. :param cosmo: astropy.cosmology instance - :param kwargs_lens: keywords of the hyper parameters of the lens model - :param kwargs_kin: keyword arguments of the kinematic model hyper-parameters + :param kwargs_lens: keywords of the hyperparameters of the lens model + :param kwargs_kin: keyword arguments of the kinematic model hyperparameters :param kwargs_los: line of sight parapers :return: sigma_v_measurement, cov_error_measurement, sigma_v_predict_mean, cov_error_predict @@ -569,15 +432,15 @@ def sigma_v_measured_vs_predict( sigma_v_predict_mean = np.zeros_like(sigma_v_measurement) cov_error_predict = np.zeros_like(cov_error_measurement) for i in range(self._num_distribution_draws): - lambda_mst, gamma_ppn = self.draw_lens(**kwargs_lens) + kwargs_lens_draw = self._lens_distribution.draw_lens(**kwargs_lens) + lambda_mst, gamma_ppn = kwargs_lens_draw["lambda_mst"], kwargs_lens_draw["gamma_ppn"] kappa_ext = self._los.draw_los(kwargs_los) ddt_, dd_, _ = self.displace_prediction( ddt, dd, gamma_ppn=gamma_ppn, lambda_mst=lambda_mst, kappa_ext=kappa_ext ) - scaling_param_array = self.draw_scaling_params( - kwargs_lens=kwargs_lens, **kwargs_kin_copy - ) - kin_scaling = self.param_scaling(scaling_param_array) + kwargs_kin_draw = self._aniso_distribution.draw_anisotropy(**kwargs_kin) + kwargs_param = {**kwargs_lens_draw, **kwargs_kin_draw} + kin_scaling = self.kin_scaling(kwargs_param) sigma_v_predict_i, cov_error_predict_i = self.sigma_v_prediction( ddt_, dd_, kin_scaling=kin_scaling ) @@ -614,7 +477,8 @@ def ddt_dd_model_prediction(self, cosmo, kwargs_lens=None, kwargs_los=None): ddt_draws = [] dd_draws = [] for i in range(self._num_distribution_draws): - lambda_mst, gamma_ppn = self.draw_lens(**kwargs_lens) + kwargs_lens_draw = self._lens_distribution.draw_lens(**kwargs_lens) + lambda_mst, gamma_ppn = kwargs_lens_draw["lambda_mst"], kwargs_lens_draw["gamma_ppn"] kappa_ext = self._los.draw_los(kwargs_los) ddt_, dd_, _ = self.displace_prediction( ddt, dd, gamma_ppn=gamma_ppn, lambda_mst=lambda_mst, kappa_ext=kappa_ext diff --git a/hierarc/Likelihood/kin_scaling.py b/hierarc/Likelihood/kin_scaling.py new file mode 100644 index 00000000..f016adf8 --- /dev/null +++ b/hierarc/Likelihood/kin_scaling.py @@ -0,0 +1,138 @@ +__author__ = "sibirrer", "ajshajib" + +from scipy.interpolate import interp1d +from scipy.interpolate import interp2d +from scipy.interpolate import RegularGridInterpolator +import numpy as np + + +class ParameterScalingSingleMeasurement(object): + """Class to manage anisotropy scaling for single slit observation.""" + + def __init__(self, param_grid_axes, j_kin_scaling_grid): + """ + + :param param_grid_axes: list of arrays of interpolated parameter values + :param j_kin_scaling_grid: array with the scaling of J() for single measurement bin in same dimensions as the + param_arrays + """ + self._evalute_scaling = False + # check if param arrays is 1d list or 2d list + if param_grid_axes is not None and j_kin_scaling_grid is not None: + if isinstance(param_grid_axes, list): + self._dim_scaling = len(param_grid_axes) + else: + self._dim_scaling = 1 + param_grid_axes = [param_grid_axes] + + if self._dim_scaling == 1: + self._f_ani = interp1d(param_grid_axes[0], j_kin_scaling_grid, kind="linear") + elif self._dim_scaling == 2: + self._f_ani = interp2d(param_grid_axes[0], param_grid_axes[1], j_kin_scaling_grid.T) + else: + self._f_ani = RegularGridInterpolator( + tuple(param_grid_axes), + j_kin_scaling_grid, + ) + self._evalute_scaling = True + + def j_scaling(self, param_array): + """ + + :param param_array: sorted list of parameters for the interpolation function + :return: scaling J(a_ani) for single slit + """ + + if self._evalute_scaling is not True or len(param_array) == 0: + return 1 + if self._dim_scaling == 1: + return self._f_ani(param_array[0]) + elif self._dim_scaling == 2: + return self._f_ani(param_array[0], param_array[1])[0] + else: + return self._f_ani(param_array)[0] + + +class KinScaling(object): + """Class to manage model parameter and anisotropy scalings for IFU data.""" + + def __init__( + self, j_kin_scaling_param_axes=None, j_kin_scaling_grid_list=None, j_kin_scaling_param_name_list=None + ): + """ + + :param j_kin_scaling_param_axes: array of parameter values for each axes of j_kin_scaling_grid + :param j_kin_scaling_grid_list: list of array with the scalings of J() for each IFU + :param j_kin_scaling_param_name_list: list of strings for the parameters as they are interpolated in the same + order as j_kin_scaling_grid + """ + if j_kin_scaling_param_name_list is None: + self._param_list = [] + else: + self._param_list = j_kin_scaling_param_name_list + self._param_arrays = j_kin_scaling_param_axes + if not isinstance(j_kin_scaling_param_axes, list) and j_kin_scaling_param_name_list is not None: + self._param_arrays = [j_kin_scaling_param_axes] + self._evaluate_scaling = False + self._is_log_m2l_population_level = False + if ( + j_kin_scaling_param_axes is not None + and j_kin_scaling_grid_list is not None + and j_kin_scaling_param_name_list is not None + ): + self._evaluate_scaling = True + self._j_scaling_ifu = [] + self._f_ani_list = [] + for scaling_grid in j_kin_scaling_grid_list: + self._j_scaling_ifu.append( + ParameterScalingSingleMeasurement(j_kin_scaling_param_axes, scaling_grid) + ) + + if isinstance(j_kin_scaling_param_axes, list): + self._dim_scaling = len(j_kin_scaling_param_axes) + else: + self._dim_scaling = 1 + + def _kwargs2param_array(self, kwargs): + """ + converts dictionary to sorted array in same order as interpolation grid + + :param kwargs: dictionary of all model components, must include the one that are interpolated + :return: sorted list of parameters to interpolate + """ + param_array = [] + for param in self._param_list: + if param not in kwargs: + raise ValueError("key %s not in parameters and hence kinematic scaling not possible" % param) + param_array.append(kwargs.get(param)) + return param_array + + def param_bounds_interpol(self): + """ + minimum and maximum bounds of parameters that are being used to call interpolation function + + :return: dictionaries of minimum and maximum bounds + """ + kwargs_min, kwargs_max = {}, {} + if self._evaluate_scaling is True: + for i, key in enumerate(self._param_list): + kwargs_min[key] = min(self._param_arrays[i]) + kwargs_max[key] = max(self._param_arrays[i]) + return kwargs_min, kwargs_max + + def kin_scaling(self, kwargs_param): + """ + + :param kwargs_param: dictionary of parameters for scaling the kinematics + :return: scaling J(a_ani) for the IFU's + """ + if kwargs_param is None: + return np.ones(self._dim_scaling) + param_array = self._kwargs2param_array(kwargs_param) + if self._evaluate_scaling is not True or len(param_array) == 0: + return np.ones(self._dim_scaling) + scaling_list = [] + for scaling_class in self._j_scaling_ifu: + scaling = scaling_class.j_scaling(param_array) + scaling_list.append(scaling) + return np.array(scaling_list) diff --git a/hierarc/Likelihood/lens_sample_likelihood.py b/hierarc/Likelihood/lens_sample_likelihood.py index dedf24e9..d168b097 100644 --- a/hierarc/Likelihood/lens_sample_likelihood.py +++ b/hierarc/Likelihood/lens_sample_likelihood.py @@ -9,15 +9,17 @@ class LensSampleLikelihood(object): diameter posteriors Currently this class does not include possible covariances between the lens samples.""" - def __init__(self, kwargs_lens_list, normalized=False, los_distributions=None): + def __init__(self, kwargs_lens_list, normalized=False, kwargs_global_model=None): """ :param kwargs_lens_list: keyword argument list specifying the arguments of the LensLikelihood class :param normalized: bool, if True, returns the normalized likelihood, if False, separates the constant prefactor (in case of a Gaussian 1/(sigma sqrt(2 pi)) ) to compute the reduced chi2 statistics - :param los_distributions: list of all line of sight distributions parameterized - :type los_distributions: list of str or None + :param kwargs_global_model: arguments of global distribution parameters for initialization of + ParamManager() class """ + if kwargs_global_model is None: + kwargs_global_model = {} self._lens_list = [] for kwargs_lens in kwargs_lens_list: if kwargs_lens["likelihood_type"] == "DSPL": @@ -27,12 +29,10 @@ def __init__(self, kwargs_lens_list, normalized=False, los_distributions=None): DSPLikelihood(normalized=normalized, **_kwargs_lens) ) else: + kwargs_lens_ = self._merge_global2local_settings(kwargs_global_model=kwargs_global_model, + kwargs_lens=kwargs_lens) self._lens_list.append( - LensLikelihood( - normalized=normalized, - los_distributions=los_distributions, - **kwargs_lens - ) + LensLikelihood(**kwargs_lens_) ) def log_likelihood( @@ -72,3 +72,37 @@ def num_data(self): for lens in self._lens_list: num += lens.num_data() return num + + @staticmethod + def _merge_global2local_settings(kwargs_global_model, kwargs_lens): + """ + + :param kwargs_global_model: dictionary of global model settings and distribution functions + :param kwargs_lens: specific settings of an individual lens + :return: joint dictionary that overwrites global with local parameters (if needed) and only keeps the relevant + arguments that an individual lens likelihood needs + :rtype: dict + """ + kwargs_global_model_ = {} + for key in _input_param_list: + if key in kwargs_global_model: + kwargs_global_model_[key] = kwargs_global_model[key] + kwargs_global_model_subset = copy.deepcopy(kwargs_global_model_) + return {**kwargs_global_model_subset, **kwargs_lens} + + +_input_param_list = ["anisotropy_model", + "anisotropy_sampling", + "anisotroy_distribution_function", + "los_distributions", + "lambda_mst_distribution", + "gamma_in_sampling", + "gamma_in_distribution", + "log_m2l_sampling", + "log_m2l_distribution", + "alpha_lambda_sampling", + "beta_lambda_sampling", + "alpha_gamma_in_sampling", + "alpha_log_m2l_sampling", + "log_scatter" + ] diff --git a/hierarc/Likelihood/parameter_scaling.py b/hierarc/Likelihood/parameter_scaling.py deleted file mode 100644 index 4739ce57..00000000 --- a/hierarc/Likelihood/parameter_scaling.py +++ /dev/null @@ -1,227 +0,0 @@ -__author__ = "sibirrer", "ajshajib" - -from scipy.interpolate import interp1d -from scipy.interpolate import interp2d -from scipy.interpolate import RegularGridInterpolator -import numpy as np - - -class ParameterScalingSingleAperture(object): - """Class to manage anisotropy scaling for single slit observation.""" - - def __init__(self, param_arrays, scaling_grid): - """ - - :param param_arrays: list of arrays of interpolated parameter values - :param scaling_grid: array with the scaling of J() for single slit - """ - self._evalute_scaling = False - # check if param arrays is 1d list or 2d list - if param_arrays is not None and scaling_grid is not None: - if isinstance(param_arrays, list): - self._dim_scaling = len(param_arrays) - else: - self._dim_scaling = 1 - - if self._dim_scaling == 1: - self._f_ani = interp1d(param_arrays, scaling_grid, kind="linear") - elif self._dim_scaling == 2: - self._f_ani = interp2d(param_arrays[0], param_arrays[1], scaling_grid.T) - else: - self._f_ani = RegularGridInterpolator( - tuple(param_arrays), - scaling_grid, - ) - self._evalute_scaling = True - - def param_scaling(self, param_array): - """ - - :param param_array: anisotropy parameter array - :return: scaling J(a_ani) for single slit - """ - if self._evalute_scaling is not True or param_array is None: - return 1 - if self._dim_scaling == 1: - return self._f_ani(param_array[0]) - elif self._dim_scaling == 2: - return self._f_ani(param_array[0], param_array[1])[0] - else: - return self._f_ani(param_array)[0] - - -class ParameterScalingIFU(object): - """Class to manage model parameter and anisotropy scalings for IFU data.""" - - def __init__( - self, anisotropy_model="NONE", param_arrays=None, scaling_grid_list=None - ): - """ - - :param anisotropy_model: string, either 'NONE', 'OM' or 'GOM' - :param param_arrays: array of parameter values - :param scaling_grid_list: list of array with the scalings of J() for each IFU - """ - self._anisotropy_model = anisotropy_model - self._evalute_ani = False - self._is_log_m2l_population_level = False - if ( - param_arrays is not None - and scaling_grid_list is not None - and self._anisotropy_model != "NONE" - ): - self._evalute_ani = True - self._anisotropy_scaling_list = [] - self._f_ani_list = [] - for scaling_grid in scaling_grid_list: - self._anisotropy_scaling_list.append( - ParameterScalingSingleAperture(param_arrays, scaling_grid) - ) - - if isinstance(param_arrays, list): - self._dim_scaling = len(param_arrays) - else: - self._dim_scaling = 1 - - if anisotropy_model in ["OM", "const"]: - if self._dim_scaling == 1: - self._ani_param_min = np.min(param_arrays) - self._ani_param_max = np.max(param_arrays) - else: - self._ani_param_min = np.min(param_arrays[0]) - self._ani_param_max = np.max(param_arrays[0]) - - if self._dim_scaling > 1: - self._gamma_in_min = np.min(param_arrays[1]) - self._gamma_in_max = np.max(param_arrays[1]) - if self._dim_scaling > 2: - self._log_m2l_min = np.min(param_arrays[2]) - self._log_m2l_max = np.max(param_arrays[2]) - self._is_log_m2l_population_level = True - - elif anisotropy_model == "GOM": - self._ani_param_min = [min(param_arrays[0]), min(param_arrays[1])] - self._ani_param_max = [max(param_arrays[0]), max(param_arrays[1])] - - if self._dim_scaling > 2: - self._gamma_in_min = np.min(param_arrays[2]) - self._gamma_in_max = np.max(param_arrays[2]) - if self._dim_scaling > 3: - self._log_m2l_min = np.min(param_arrays[3]) - self._log_m2l_max = np.max(param_arrays[3]) - self._is_log_m2l_population_level = True - else: - raise ValueError( - f"Anisotropy model {anisotropy_model} is not recognized!" - ) - - def param_scaling(self, param_array): - """ - - :param param_array: parameter array for scaling - :return: scaling J(a_ani) for the IFU's - """ - if self._evalute_ani is not True or param_array is None: - return [1] - scaling_list = [] - for scaling_class in self._anisotropy_scaling_list: - scaling = scaling_class.param_scaling(param_array) - scaling_list.append(scaling) - return np.array(scaling_list) - - def draw_anisotropy( - self, a_ani=None, a_ani_sigma=0, beta_inf=None, beta_inf_sigma=0 - ): - """Draw Gaussian distribution and re-sample if outside bounds. - - :param a_ani: mean of the distribution - :param a_ani_sigma: std of the distribution - :param beta_inf: anisotropy at infinity (relevant for GOM model) - :param beta_inf_sigma: std of beta_inf distribution - :return: random draw from the distribution - """ - if self._anisotropy_model in ["OM", "const"]: - if a_ani < self._ani_param_min or a_ani > self._ani_param_max: - raise ValueError( - "anisotropy parameter is out of bounds of the interpolated range!" - ) - # we draw a linear gaussian for 'const' anisotropy and a scaled proportional one for 'OM - if self._anisotropy_model == "OM": - a_ani_draw = np.random.normal(a_ani, a_ani_sigma * a_ani) - else: - a_ani_draw = np.random.normal(a_ani, a_ani_sigma) - if a_ani_draw < self._ani_param_min or a_ani_draw > self._ani_param_max: - return self.draw_anisotropy(a_ani, a_ani_sigma) - return np.array([a_ani_draw]) - elif self._anisotropy_model in ["GOM"]: - if ( - a_ani < self._ani_param_min[0] - or a_ani > self._ani_param_max[0] - or beta_inf < self._ani_param_min[1] - or beta_inf > self._ani_param_max[1] - ): - raise ValueError( - "anisotropy parameter is out of bounds of the interpolated range!" - ) - a_ani_draw = np.random.normal(a_ani, a_ani_sigma * a_ani) - beta_inf_draw = np.random.normal(beta_inf, beta_inf_sigma) - if ( - a_ani_draw < self._ani_param_min[0] - or a_ani_draw > self._ani_param_max[0] - or beta_inf_draw < self._ani_param_min[1] - or beta_inf_draw > self._ani_param_max[1] - ): - return self.draw_anisotropy( - a_ani, a_ani_sigma, beta_inf, beta_inf_sigma - ) - return np.array([a_ani_draw, beta_inf_draw]) - return None - - def draw_lens_parameters( - self, gamma_in=None, gamma_in_sigma=0, log_m2l=None, log_m2l_sigma=0 - ): - """Draw Gaussian distribution and re-sample if outside bounds. - - :param gamma_in: mean of the distribution - :param gamma_in_sigma: std of the distribution - :param log_m2l: mean of the distribution - :param log_m2l_sigma: std of the distribution - :return: random draw from the distribution - """ - if self._is_log_m2l_population_level: - if gamma_in < self._gamma_in_min or gamma_in > self._gamma_in_max: - raise ValueError( - "gamma_in parameter is out of bounds of the interpolated range!" - ) - if log_m2l < self._log_m2l_min or log_m2l > self._log_m2l_max: - raise ValueError( - "m2l parameter is out of bounds of the interpolated range!" - ) - - gamma_in_draw = np.random.normal(gamma_in, gamma_in_sigma) - log_m2l_draw = np.random.normal(log_m2l, log_m2l_sigma) - - if ( - gamma_in_draw < self._gamma_in_min - or gamma_in_draw > self._gamma_in_max - or log_m2l_draw < self._log_m2l_min - or log_m2l_draw > self._log_m2l_max - ): - return self.draw_lens_parameters( - gamma_in, gamma_in_sigma, log_m2l, log_m2l_sigma - ) - - return gamma_in_draw, log_m2l_draw - - else: - if gamma_in < self._gamma_in_min or gamma_in > self._gamma_in_max: - raise ValueError( - "gamma_in parameter is out of bounds of the interpolated range!" - ) - - gamma_in_draw = np.random.normal(gamma_in, gamma_in_sigma) - - if gamma_in_draw < self._gamma_in_min or gamma_in_draw > self._gamma_in_max: - return self.draw_lens_parameters(gamma_in, gamma_in_sigma) - - return gamma_in_draw diff --git a/hierarc/Sampling/Distributions/__init__.py b/hierarc/Sampling/Distributions/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/hierarc/Sampling/Distributions/anisotropy_distributions.py b/hierarc/Sampling/Distributions/anisotropy_distributions.py new file mode 100644 index 00000000..c5f92a0a --- /dev/null +++ b/hierarc/Sampling/Distributions/anisotropy_distributions.py @@ -0,0 +1,78 @@ +import numpy as np + + +class AnisotropyDistribution(object): + """ + class to draw anisotropy parameters from hyperparameter distributions + """ + def __init__(self, anisotropy_model, anisotropy_sampling, + distribution_function, kwargs_anisotropy_min, kwargs_anisotropy_max): + """ + + :param anisotropy_model: string, name of anisotropy model to consider + :param anisotropy_sampling: bool, if True adds a global stellar anisotropy parameter that alters the single lens + kinematic prediction + :param distribution_function: string, 'NONE', 'GAUSSIAN', description of the distribution function of the + anisotropy model parameters + """ + + self._anisotropy_model = anisotropy_model + self._anisotropy_sampling = anisotropy_sampling + self._distribution_function = distribution_function + if kwargs_anisotropy_min is None: + kwargs_anisotropy_min = {} + if kwargs_anisotropy_max is None: + kwargs_anisotropy_max = {} + self._kwargs_min = kwargs_anisotropy_min + self._kwargs_max = kwargs_anisotropy_max + self._a_ani_min, self._a_ani_max = self._kwargs_min.get("a_ani", -np.inf), self._kwargs_max.get("a_ani", np.inf) + self._beta_inf_min = self._kwargs_min.get("beta_inf", -np.inf) + self._beta_inf_max = self._kwargs_max.get("beta_inf", np.inf) + + def draw_anisotropy(self, a_ani=None, a_ani_sigma=0, beta_inf=None, beta_inf_sigma=0): + """Draw Gaussian distribution and re-sample if outside bounds. + + :param a_ani: mean of the distribution + :param a_ani_sigma: std of the distribution + :param beta_inf: anisotropy at infinity (relevant for GOM model) + :param beta_inf_sigma: std of beta_inf distribution + :return: random draw from the distribution + """ + kwargs_return = {} + if not self._anisotropy_sampling: + if a_ani is not None: + kwargs_return["a_ani"] = a_ani + if beta_inf is not None: + kwargs_return["beta_inf"] = beta_inf + return kwargs_return + if self._anisotropy_model in ["OM", "const", "GOM"]: + if a_ani < self._a_ani_min or a_ani > self._a_ani_max: + raise ValueError( + "anisotropy parameter is out of bounds of the interpolated range!" + ) + # we draw a linear gaussian for 'const' anisotropy and a scaled proportional one for 'OM + if self._distribution_function in ["GAUSSIAN"]: + if self._anisotropy_model == "OM": + a_ani_draw = np.random.normal(a_ani, a_ani_sigma * a_ani) + else: + a_ani_draw = np.random.normal(a_ani, a_ani_sigma) + if a_ani_draw < self._a_ani_min or a_ani_draw > self._a_ani_max: + return self.draw_anisotropy(a_ani, a_ani_sigma) + kwargs_return["a_ani"] = a_ani_draw + else: + kwargs_return["a_ani"] = a_ani + if self._anisotropy_model in ["GOM"]: + if beta_inf < self._beta_inf_min or beta_inf > self._beta_inf_max: + raise ValueError( + "anisotropy parameter is out of bounds of the interpolated range!" + ) + if self._distribution_function in ["GAUSSIAN"]: + beta_inf_draw = np.random.normal(beta_inf, beta_inf_sigma) + else: + beta_inf_draw = beta_inf + if beta_inf_draw < self._beta_inf_min or beta_inf_draw > self._beta_inf_max: + return self.draw_anisotropy( + a_ani, a_ani_sigma, beta_inf, beta_inf_sigma + ) + kwargs_return["beta_inf"] = beta_inf_draw + return kwargs_return diff --git a/hierarc/Sampling/Distributions/lens_distribution.py b/hierarc/Sampling/Distributions/lens_distribution.py new file mode 100644 index 00000000..dd1c2738 --- /dev/null +++ b/hierarc/Sampling/Distributions/lens_distribution.py @@ -0,0 +1,189 @@ +import numpy as np + + +class LensDistribution(object): + """ + class to draw lens parameters of individual lens from distributions + """ + + def __init__( + self, + lambda_mst_sampling=False, + lambda_mst_distribution="NONE", + gamma_in_sampling=False, + gamma_in_distribution="NONE", + log_m2l_sampling=False, + log_m2l_distribution="NONE", + alpha_lambda_sampling=False, + beta_lambda_sampling=False, + alpha_gamma_in_sampling=False, + alpha_log_m2l_sampling=False, + log_scatter=False, + mst_ifu=False, + lambda_scaling_property=0, + lambda_scaling_property_beta=0, + kwargs_min=None, + kwargs_max=None, + ): + """ + + :param lambda_mst_sampling: bool, if True adds a global mass-sheet transform parameter in the sampling + :param lambda_mst_distribution: string, distribution function of the MST transform + :param gamma_in_sampling: bool, if True samples the inner slope of the GNFW profile + :param gamma_in_distribution: string, distribution function of the inner + slope of the GNFW profile + :param log_m2l_sampling: bool, if True samples the mass to light ratio of + the stars in logarithmic scale + :param log_m2l_distribution: string, distribution function of the logarithm of mass to + light ratio of the lens + :param alpha_lambda_sampling: bool, if True samples a parameter alpha_lambda, which scales lambda_mst linearly + according to a predefined quantity of the lens + :param beta_lambda_sampling: bool, if True samples a parameter beta_lambda, which scales lambda_mst linearly + according to a predefined quantity of the lens + :param alpha_gamma_in_sampling: bool, if True samples a parameter alpha_gamma_in, which scales gamma_in linearly + :param alpha_log_m2l_sampling: bool, if True samples a parameter alpha_log_m2l, which scales log_m2l linearly + :param log_scatter: boolean, if True, samples the Gaussian scatter amplitude in log space + (and thus flat prior in log) + :param mst_ifu: bool, if True replaces the lambda_mst parameter by the lambda_ifu parameter (and distribution) + in sampling this lens. + :param lambda_scaling_property: float (optional), scaling of + lambda_mst = lambda_mst_global + alpha * lambda_scaling_property + :param lambda_scaling_property_beta: float (optional), scaling of + lambda_mst = lambda_mst_global + beta * lambda_scaling_property_beta + :param kwargs_min: minimum arguments of parameters supported by each lens + :type kwargs_min: dict or None + :param kwargs_max: maximum arguments of parameters supported by each lens + :type kwargs_max: dict or None + """ + self._lambda_mst_sampling = lambda_mst_sampling + self._lambda_mst_distribution = lambda_mst_distribution + self._gamma_in_sampling = gamma_in_sampling + self._gamma_in_distribution = gamma_in_distribution + self._log_m2l_sampling = log_m2l_sampling + self._log_m2l_distribution = log_m2l_distribution + self._alpha_lambda_sampling = alpha_lambda_sampling + self._beta_lambda_sampling = beta_lambda_sampling + self._alpha_gamma_in_sampling = alpha_gamma_in_sampling + self._alpha_log_m2l_sampling = alpha_log_m2l_sampling + self._mst_ifu = mst_ifu + self._lambda_scaling_property = lambda_scaling_property + self._lambda_scaling_property_beta = lambda_scaling_property_beta + + self._log_scatter = log_scatter + if kwargs_max is None: + kwargs_max = {} + if kwargs_min is None: + kwargs_min = {} + self._gamma_in_min, self._gamma_in_max = kwargs_min.get("gamma_in", -np.inf), kwargs_max.get("gamma_in", np.inf) + self._log_m2l_min, self._log_m2l_max = kwargs_min.get("log_m2l", -np.inf), kwargs_max.get("log_m2l", np.inf) + + def draw_lens( + self, + lambda_mst=1, + lambda_mst_sigma=0, + gamma_ppn=1, + lambda_ifu=1, + lambda_ifu_sigma=0, + alpha_lambda=0, + beta_lambda=0, + gamma_in=1, + gamma_in_sigma=0, + alpha_gamma_in=0, + log_m2l=1, + log_m2l_sigma=0, + alpha_log_m2l=0, + ): + """Draws a realization of a specific model from the hyperparameter + distribution. + + :param lambda_mst: MST transform + :param lambda_mst_sigma: spread in the distribution + :param gamma_ppn: Post-Newtonian parameter + :param lambda_ifu: secondary lambda_mst parameter for subset of lenses specified + for + :param lambda_ifu_sigma: secondary lambda_mst_sigma parameter for subset of + lenses specified for + :param alpha_lambda: float, linear slope of the lambda_int scaling relation with + lens quantity self._lambda_scaling_property + :param beta_lambda: float, a second linear slope of the lambda_int scaling + relation with lens quantity self._lambda_scaling_property_beta + :param gamma_in: inner slope of the NFW profile + :param gamma_in_sigma: spread in the distribution + :param alpha_gamma_in: float, linear slope of the gamma_in scaling relation with + lens quantity self._lambda_scaling_property + :param log_m2l: log(mass-to-light ratio) + :param log_m2l_sigma: spread in the distribution + :param alpha_log_m2l: float, linear slope of the log(m2l) scaling relation with + lens quantity self._lambda_scaling_property + :return: draw from the distributions + """ + kwargs_return = {} + + if self._mst_ifu is True: + lambda_mst_mean_lens = lambda_ifu + else: + lambda_mst_mean_lens = lambda_mst + + lambda_lens = (lambda_mst_mean_lens + + alpha_lambda * self._lambda_scaling_property + + beta_lambda * self._lambda_scaling_property_beta + ) + lambda_mst_draw = lambda_lens + if self._lambda_mst_sampling: + if self._lambda_mst_distribution in ["GAUSSIAN"]: + lambda_mst_draw = np.random.normal(lambda_lens, lambda_ifu_sigma) + + kwargs_return["lambda_mst"] = lambda_mst_draw + kwargs_return["gamma_ppn"] = gamma_ppn + + if self._gamma_in_sampling: + if gamma_in < self._gamma_in_min or gamma_in > self._gamma_in_max: + raise ValueError( + "gamma_in parameter is out of bounds of the interpolated range!" + ) + if self._gamma_in_distribution in ["GAUSSIAN"]: + gamma_in_lens = gamma_in + alpha_gamma_in * self._lambda_scaling_property + else: + gamma_in_lens = gamma_in + gamma_in_draw = np.random.normal(gamma_in_lens, gamma_in_sigma) + if gamma_in_draw < self._gamma_in_min or gamma_in_draw > self._gamma_in_max: + return self.draw_lens(lambda_mst=lambda_mst, + lambda_mst_sigma=lambda_mst_sigma, + gamma_ppn=gamma_ppn, + lambda_ifu=lambda_ifu, + lambda_ifu_sigma=lambda_ifu_sigma, + alpha_lambda=alpha_lambda, + beta_lambda=beta_lambda, + gamma_in=gamma_in, + gamma_in_sigma=gamma_in_sigma, + alpha_gamma_in=alpha_gamma_in, + log_m2l=log_m2l, + log_m2l_sigma=log_m2l_sigma, + alpha_log_m2l=alpha_log_m2l) + kwargs_return["gamma_in"] = gamma_in_draw + if self._log_m2l_sampling: + + if log_m2l < self._log_m2l_min or log_m2l > self._log_m2l_max: + raise ValueError( + "m2l parameter is out of bounds of the interpolated range!" + ) + + log_m2l_lens = log_m2l + alpha_log_m2l * self._lambda_scaling_property + log_m2l_draw = np.random.normal(log_m2l_lens, log_m2l_sigma) + + if log_m2l_draw < self._log_m2l_min or log_m2l_draw > self._log_m2l_max: + return self.draw_lens(lambda_mst=lambda_mst, + lambda_mst_sigma=lambda_mst_sigma, + gamma_ppn=gamma_ppn, + lambda_ifu=lambda_ifu, + lambda_ifu_sigma=lambda_ifu_sigma, + alpha_lambda=alpha_lambda, + beta_lambda=beta_lambda, + gamma_in=gamma_in, + gamma_in_sigma=gamma_in_sigma, + alpha_gamma_in=alpha_gamma_in, + log_m2l=log_m2l, + log_m2l_sigma=log_m2l_sigma, + alpha_log_m2l=alpha_log_m2l) + kwargs_return["log_m2l"] = log_m2l_draw + return kwargs_return diff --git a/hierarc/Likelihood/los_distributions.py b/hierarc/Sampling/Distributions/los_distributions.py similarity index 100% rename from hierarc/Likelihood/los_distributions.py rename to hierarc/Sampling/Distributions/los_distributions.py diff --git a/hierarc/Sampling/ParamManager/param_manager.py b/hierarc/Sampling/ParamManager/param_manager.py index 11413773..8b87363d 100644 --- a/hierarc/Sampling/ParamManager/param_manager.py +++ b/hierarc/Sampling/ParamManager/param_manager.py @@ -64,7 +64,7 @@ def __init__( according to a predefined quantity of the lens :param lambda_ifu_distribution: string, distribution function of the lambda_ifu parameter :param anisotropy_sampling: bool, if True adds a global stellar anisotropy parameter that alters the single lens - kinematic prediction + kinematic prediction :param anisotropy_distribution: string, indicating the distribution function of the anisotropy model :param gamma_in_sampling: bool, if True samples gNFW inner slope parameter :param gamma_in_distribution: string, distribution function of the gamma_in parameter diff --git a/test/test_LensPosterior/test_anisotropy_config.py b/test/test_LensPosterior/test_anisotropy_config.py index 040ed4c2..ed668744 100644 --- a/test/test_LensPosterior/test_anisotropy_config.py +++ b/test/test_LensPosterior/test_anisotropy_config.py @@ -1,4 +1,4 @@ -from hierarc.LensPosterior.anisotropy_config import AnisotropyConfig +from hierarc.LensPosterior.kin_scaling_config import KinScalingConfig import unittest import pytest @@ -6,9 +6,9 @@ class TestAnisotropyConfig(object): def setup_method(self): self.r_eff = 2 - self.config_om = AnisotropyConfig(anisotropy_model="OM", r_eff=self.r_eff) - self.config_gom = AnisotropyConfig(anisotropy_model="GOM", r_eff=self.r_eff) - self.config_const = AnisotropyConfig(anisotropy_model="const", r_eff=self.r_eff) + self.config_om = KinScalingConfig(anisotropy_model="OM", r_eff=self.r_eff) + self.config_gom = KinScalingConfig(anisotropy_model="GOM", r_eff=self.r_eff) + self.config_const = KinScalingConfig(anisotropy_model="const", r_eff=self.r_eff) def test_kwargs_anisotropy_base(self): kwargs = self.config_om.kwargs_anisotropy_base @@ -22,15 +22,15 @@ def test_kwargs_anisotropy_base(self): assert kwargs["beta"] == 0.1 def test_ani_param_array(self): - ani_param_array = self.config_om.ani_param_array - assert len(ani_param_array) == 6 + ani_param_array = self.config_om.kin_scaling_param_array + assert len(ani_param_array[0]) == 6 - ani_param_array = self.config_gom.ani_param_array + ani_param_array = self.config_gom.kin_scaling_param_array assert len(ani_param_array[0]) == 6 assert len(ani_param_array[1]) == 4 - ani_param_array = self.config_const.ani_param_array - assert len(ani_param_array) == 7 + ani_param_array = self.config_const.kin_scaling_param_array + assert len(ani_param_array[0]) == 7 def test_anisotropy_kwargs(self): a_ani = 2 @@ -49,15 +49,15 @@ def test_anisotropy_kwargs(self): class TestRaise(unittest.TestCase): def test_raise(self): with self.assertRaises(ValueError): - AnisotropyConfig(anisotropy_model="BAD", r_eff=1) + KinScalingConfig(anisotropy_model="BAD", r_eff=1) with self.assertRaises(ValueError): - conf = AnisotropyConfig(anisotropy_model="OM", r_eff=1) + conf = KinScalingConfig(anisotropy_model="OM", r_eff=1) conf._anisotropy_model = "BAD" kwargs = conf.kwargs_anisotropy_base with self.assertRaises(ValueError): - conf = AnisotropyConfig(anisotropy_model="OM", r_eff=1) + conf = KinScalingConfig(anisotropy_model="OM", r_eff=1) conf._anisotropy_model = "BAD" kwargs = conf.anisotropy_kwargs(a_ani=1, beta_inf=1) diff --git a/test/test_LensPosterior/test_kin_constraints_composite.py b/test/test_LensPosterior/test_kin_constraints_composite.py index 0ff86961..f99c6168 100644 --- a/test/test_LensPosterior/test_kin_constraints_composite.py +++ b/test/test_LensPosterior/test_kin_constraints_composite.py @@ -104,9 +104,9 @@ def test_likelihoodconfiguration_om(self): kwargs_likelihood = kin_constraints.hierarchy_configuration(num_sample_model=5) kwargs_likelihood["normalized"] = False - ln_class = LensLikelihood(**kwargs_likelihood) + ln_class = LensLikelihood(gamma_in_sampling=True, log_m2l_sampling=True, **kwargs_likelihood) kwargs_kin = {"a_ani": 1} - ln_class.lens_log_likelihood(cosmo, kwargs_lens={}, kwargs_kin=kwargs_kin) + ln_class.lens_log_likelihood(cosmo, kwargs_lens={"gamma_in": 2, "log_m2l": 1}, kwargs_kin=kwargs_kin) kwargs_lens_light_test = [{"amp": [1, 1], "sigma": [1, 2]}] lens_light_model_list_test = ["MULTI_GAUSSIAN"] @@ -135,8 +135,8 @@ def test_likelihoodconfiguration_om(self): **kwargs_kin_api_settings ) - kappa_s_array = 10 ** np.random.normal(8, 0, 100) / 1e6 - r_s_angle_array = np.random.normal(0.1, 0, 100) + kappa_s_array = 10 ** np.random.normal(8, 0, 10) / 1e6 + r_s_angle_array = np.random.normal(0.1, 0, 10) kin_constraints_kappa = KinConstraintsComposite( z_lens=z_lens, @@ -224,8 +224,8 @@ def test_likelihoodconfiguration_gom(self): gamma_in_array = np.linspace(0.1, 2.9, 5) log_m2l_array = np.linspace(0.1, 1, 5) - rho0_array = 10 ** np.random.normal(8, 0, 100) / 1e6 - r_s_array = np.random.normal(0.1, 0, 100) + rho0_array = 10 ** np.random.normal(8, 0, 10) / 1e6 + r_s_array = np.random.normal(0.1, 0, 10) # compute likelihood kin_constraints = KinConstraintsComposite( @@ -256,9 +256,9 @@ def test_likelihoodconfiguration_gom(self): kwargs_likelihood = kin_constraints.hierarchy_configuration(num_sample_model=5) kwargs_likelihood["normalized"] = False - ln_class = LensLikelihood(**kwargs_likelihood) + ln_class = LensLikelihood(gamma_in_sampling=True, log_m2l_sampling=True, **kwargs_likelihood) kwargs_kin = {"a_ani": 1, "beta_inf": 0.5} - ln_class.lens_log_likelihood(cosmo, kwargs_lens={}, kwargs_kin=kwargs_kin) + ln_class.lens_log_likelihood(cosmo, kwargs_lens={"gamma_in": 2, "log_m2l": 1}, kwargs_kin=kwargs_kin) class TestKinConstraintsCompositeM2l(object): @@ -324,9 +324,9 @@ def test_likelihoodconfiguration_om(self): gamma_in_array = np.linspace(0.1, 2.9, 5) - log_m2l_array = np.random.uniform(0.1, 1, 100) - rho0_array = 10 ** np.random.normal(8, 0, 100) / 1e6 - r_s_array = np.random.normal(0.1, 0, 100) + log_m2l_array = np.random.uniform(0.1, 1, 5) + rho0_array = 10 ** np.random.normal(8, 0, 5) / 1e6 + r_s_array = np.random.normal(0.1, 0, 5) # compute likelihood kin_constraints = KinConstraintsComposite( @@ -360,9 +360,9 @@ def test_likelihoodconfiguration_om(self): kwargs_likelihood = kin_constraints.hierarchy_configuration(num_sample_model=5) kwargs_likelihood["normalized"] = False - ln_class = LensLikelihood(**kwargs_likelihood) + ln_class = LensLikelihood(gamma_in_sampling=True, log_m2l_sampling=False, **kwargs_likelihood) kwargs_kin = {"a_ani": 1} - ln_class.lens_log_likelihood(cosmo, kwargs_lens={}, kwargs_kin=kwargs_kin) + ln_class.lens_log_likelihood(cosmo, kwargs_lens={"gamma_in": 2, "log_m2l": 0}, kwargs_kin=kwargs_kin) def test_likelihoodconfiguration_gom(self): anisotropy_model = "GOM" @@ -423,9 +423,9 @@ def test_likelihoodconfiguration_gom(self): gamma_in_array = np.linspace(0.1, 2.9, 5) - log_m2l_array = np.random.uniform(0.1, 1, 100) - rho0_array = 10 ** np.random.normal(8, 0, 100) / 1e6 - r_s_array = np.random.normal(0.1, 0, 100) + log_m2l_array = np.random.uniform(0.1, 1, 10) + rho0_array = 10 ** np.random.normal(8, 0, 10) / 1e6 + r_s_array = np.random.normal(0.1, 0, 10) # compute likelihood kin_constraints = KinConstraintsComposite( @@ -455,9 +455,9 @@ def test_likelihoodconfiguration_gom(self): kwargs_likelihood = kin_constraints.hierarchy_configuration(num_sample_model=5) kwargs_likelihood["normalized"] = False - ln_class = LensLikelihood(**kwargs_likelihood) + ln_class = LensLikelihood(gamma_in_sampling=True, **kwargs_likelihood) kwargs_kin = {"a_ani": 1, "beta_inf": 0.5} - ln_class.lens_log_likelihood(cosmo, kwargs_lens={}, kwargs_kin=kwargs_kin) + ln_class.lens_log_likelihood(cosmo, kwargs_lens={"gamma_in": 2}, kwargs_kin=kwargs_kin) class TestRaise(unittest.TestCase): @@ -510,8 +510,8 @@ def test_raise(self): gamma_in_array = np.linspace(0.1, 2.9, 5) log_m2l_array = np.linspace(0.1, 1, 5) - rho0_array = 10 ** np.random.normal(8, 0.2, 100) / 1e6 - r_s_array = np.random.normal(0.1, 0.01, 100) + rho0_array = 10 ** np.random.normal(8, 0.2, 10) / 1e6 + r_s_array = np.random.normal(0.1, 0.01, 10) kin_constraints = KinConstraintsComposite( z_lens=z_lens, @@ -737,9 +737,9 @@ def test_raise_m2l(self): kwargs_lens_light = [{"Rs": r_eff * 0.551, "amp": 1.0}] gamma_in_array = np.linspace(0.1, 2.9, 5) - log_m2l_array = np.random.uniform(0.1, 1, 100) - rho0_array = 10 ** np.random.normal(8, 0.2, 100) / 1e6 - r_s_array = np.random.normal(0.1, 0.01, 100) + log_m2l_array = np.random.uniform(0.1, 1, 10) + rho0_array = 10 ** np.random.normal(8, 0.2, 10) / 1e6 + r_s_array = np.random.normal(0.1, 0.01, 10) kin_constraints = KinConstraintsComposite( z_lens=z_lens, @@ -890,9 +890,9 @@ def test_raise_m2l(self): kwargs_lens_light = [{"Rs": r_eff * 0.551, "amp": 1.0}] gamma_in_array = np.linspace(0.1, 2.9, 5) - log_m2l_array = np.linspace(0.1, 1, 100) - rho0_array = 10 ** np.random.normal(8, 0.2, 100) / 1e6 - r_s_array = np.random.normal(0.1, 0.01, 100) + log_m2l_array = np.linspace(0.1, 1, 10) + rho0_array = 10 ** np.random.normal(8, 0.2, 10) / 1e6 + r_s_array = np.random.normal(0.1, 0.01, 10) kin_constraints = KinConstraintsComposite( z_lens=z_lens, diff --git a/test/test_Likelihood/test_cosmo_likelihood.py b/test/test_Likelihood/test_cosmo_likelihood.py index 6035cbae..aa863637 100644 --- a/test/test_Likelihood/test_cosmo_likelihood.py +++ b/test/test_Likelihood/test_cosmo_likelihood.py @@ -57,6 +57,11 @@ def setup_method(self): "kwargs_lower_cosmo": kwargs_lower_cosmo, "kwargs_upper_cosmo": kwargs_upper_cosmo, } + self.kwargs_model = {"ppn_sampling": False, + "lambda_mst_sampling": False, + "lambda_mst_distribution": "delta", + "anisotropy_sampling": False, + "anisotropy_model": "OM",} # self.kwargs_likelihood_list = [{'z_lens': self.z_L, 'z_source': self.z_S, 'likelihood_type': 'TDKinKDE', # 'dd_sample': self.dd_samples, 'ddt_sample': self.ddt_samples, @@ -66,12 +71,8 @@ def test_log_likelihood(self): cosmoL = CosmoLikelihood( self.kwargs_likelihood_list, self.cosmology, + self.kwargs_model, self.kwargs_bounds, - ppn_sampling=False, - lambda_mst_sampling=False, - lambda_mst_distribution="delta", - anisotropy_sampling=False, - anisotropy_model="OM", custom_prior=None, interpolate_cosmo=True, num_redshift_interp=100, @@ -84,12 +85,8 @@ def custom_prior(kwargs_cosmo, kwargs_lens, kwargs_kin, kwargs_source, kwargs_lo cosmoL_prior = CosmoLikelihood( self.kwargs_likelihood_list, self.cosmology, + self.kwargs_model, self.kwargs_bounds, - ppn_sampling=False, - lambda_mst_sampling=False, - lambda_mst_distribution="delta", - anisotropy_sampling=False, - anisotropy_model="OM", custom_prior=custom_prior, interpolate_cosmo=True, num_redshift_interp=100, @@ -128,6 +125,7 @@ def test_cosmo_instance(self): cosmoL = CosmoLikelihood( self.kwargs_likelihood_list, self.cosmology, + self.kwargs_model, self.kwargs_bounds, interpolate_cosmo=False, cosmo_fixed=None, @@ -137,6 +135,7 @@ def test_cosmo_instance(self): cosmoL = CosmoLikelihood( self.kwargs_likelihood_list, self.cosmology, + self.kwargs_model, self.kwargs_bounds, interpolate_cosmo=True, num_redshift_interp=100, @@ -147,6 +146,7 @@ def test_cosmo_instance(self): cosmoL = CosmoLikelihood( self.kwargs_likelihood_list, self.cosmology, + self.kwargs_model, self.kwargs_bounds, interpolate_cosmo=True, num_redshift_interp=100, @@ -158,6 +158,7 @@ def test_cosmo_instance(self): cosmoL = CosmoLikelihood( self.kwargs_likelihood_list, self.cosmology, + self.kwargs_model, self.kwargs_bounds, interpolate_cosmo=False, num_redshift_interp=100, @@ -209,6 +210,7 @@ def test_oLCDM_init(self): cosmoL = CosmoLikelihood( kwargs_likelihood_list, self.cosmology, + self.kwargs_model, self.kwargs_bounds, interpolate_cosmo=False, cosmo_fixed=None, @@ -218,6 +220,7 @@ def test_sne_likelihood_integration(self): cosmoL = CosmoLikelihood( [], self.cosmology, + self.kwargs_model, self.kwargs_bounds, sne_likelihood="Pantheon_binned", interpolate_cosmo=True, @@ -238,8 +241,8 @@ def test_kde_likelihood_integration(self): self.cosmology, rescale=True, ) - cosmoL = CosmoLikelihood( - [], "FLCDM", self.kwargs_bounds, KDE_likelihood_chain=chain + cosmoL = CosmoLikelihood([], "FLCDM", self.kwargs_model, + self.kwargs_bounds, KDE_likelihood_chain=chain ) kwargs_cosmo = {"h0": self.H0_true, "om": self.omega_m_true, "ok": 0} args = cosmoL.param.kwargs2args(kwargs_cosmo=kwargs_cosmo) diff --git a/test/test_Likelihood/test_hierarchy_likelihood.py b/test/test_Likelihood/test_hierarchy_likelihood.py index a150d70c..f17c828a 100644 --- a/test/test_Likelihood/test_hierarchy_likelihood.py +++ b/test/test_Likelihood/test_hierarchy_likelihood.py @@ -24,56 +24,67 @@ def setup_method(self): "dd_mean": dd, "dd_sigma": dd / 10, } + kwargs_model = {"anisotropy_model": "OM", + "anisotropy_sampling": True, + "anisotroy_distribution_function": "GAUSSIAN", + "lambda_mst_distribution": "GAUSSIAN", + } + # "gamma_in_sampling" = False, + gamma_in_distribution = "NONE", + log_m2l_sampling = False, + log_m2l_distribution = "NONE", + + self.likelihood = LensLikelihood( z_lens, z_source, name="name", likelihood_type="DdtDdGaussian", - anisotropy_model="OM", - ani_param_array=ani_param_array, - ani_scaling_array_list=None, - ani_scaling_array=ani_scaling_array, + kin_scaling_param_list=["a_ani"], + j_kin_scaling_param_axes=ani_param_array, + j_kin_scaling_grid_list=[ani_scaling_array], num_distribution_draws=200, los_distributions=["GAUSSIAN"], global_los_distribution=0, kappa_pdf=None, kappa_bin_edges=None, mst_ifu=True, - **kwargs_likelihood + **kwargs_likelihood, + **kwargs_model ) self.likelihood_single = LensLikelihood( z_lens, z_source, name="name", likelihood_type="DdtDdGaussian", - anisotropy_model="OM", - ani_param_array=ani_param_array, - ani_scaling_array_list=None, - ani_scaling_array=ani_scaling_array, + kin_scaling_param_list=["a_ani"], + j_kin_scaling_param_axes=ani_param_array, + j_kin_scaling_grid_list=[ani_scaling_array], num_distribution_draws=200, los_distributions=["GAUSSIAN"], global_los_distribution=0, # testing previously set to =False kappa_pdf=None, kappa_bin_edges=None, mst_ifu=False, - **kwargs_likelihood + **kwargs_likelihood, + **kwargs_model ) self.likelihood_zero_dist = LensLikelihood( z_lens, z_source, name="name", likelihood_type="DdtDdGaussian", - anisotropy_model="OM", - ani_param_array=ani_param_array, - ani_scaling_array_list=None, - ani_scaling_array=ani_scaling_array, + kin_scaling_param_list=["a_ani"], + j_kin_scaling_param_axes=ani_param_array, + j_kin_scaling_grid_list=[ani_scaling_array], num_distribution_draws=0, los_distributions=["GAUSSIAN"], global_los_distribution=0, kappa_pdf=None, kappa_bin_edges=None, mst_ifu=True, - **kwargs_likelihood + **kwargs_likelihood, + **kwargs_model ) kappa_posterior = np.random.normal(loc=0, scale=0.03, size=100000) @@ -83,17 +94,17 @@ def setup_method(self): z_source, name="name", likelihood_type="DdtDdGaussian", - anisotropy_model="OM", - ani_param_array=ani_param_array, - ani_scaling_array_list=None, - ani_scaling_array=ani_scaling_array, + kin_scaling_param_list=["a_ani"], + j_kin_scaling_param_axes=ani_param_array, + j_kin_scaling_grid_list=[ani_scaling_array], num_distribution_draws=200, # los_distributions=["GAUSSIAN"], global_los_distribution=False, kappa_pdf=kappa_pdf, kappa_bin_edges=kappa_bin_edges, mst_ifu=False, - **kwargs_likelihood + **kwargs_likelihood, + **kwargs_model ) gamma_in_array = np.linspace(start=0.1, stop=2.9, num=5) @@ -102,40 +113,49 @@ def setup_method(self): np.ones_like(ani_param_array), np.outer(np.ones_like(gamma_in_array), np.ones_like(log_m2l_array)), ) + j_kin_scaling_param_axes = [ani_param_array, gamma_in_array, log_m2l_array] self.likelihood_gamma_in_log_m2l_list_ani = LensLikelihood( z_lens, z_source, name="name", likelihood_type="DdtDdGaussian", - anisotropy_model="OM", - ani_param_array=[ani_param_array], - ani_scaling_array_list=None, - param_scaling_grid_list=[param_scaling_array], - gamma_in_array=gamma_in_array, - log_m2l_array=log_m2l_array, + kin_scaling_param_list=["a_ani", "gamma_in", "log_m2l"], + j_kin_scaling_param_axes=j_kin_scaling_param_axes, + j_kin_scaling_grid_list=[param_scaling_array], num_distribution_draws=200, kappa_pdf=None, kappa_bin_edges=None, mst_ifu=False, - **kwargs_likelihood + gamma_in_sampling=False, + gamma_in_distribution="GAUSSIAN", + log_m2l_sampling=True, + log_m2l_distribution="GAUSSIAN", + **kwargs_likelihood, + **kwargs_model ) + param_scaling_array = np.outer(np.ones_like(gamma_in_array), np.ones_like(log_m2l_array)) + + j_kin_scaling_param_axes = [gamma_in_array, log_m2l_array] + self.likelihood_gamma_in_log_m2l = LensLikelihood( z_lens, z_source, name="name", likelihood_type="DdtDdGaussian", - anisotropy_model="OM", - ani_param_array=ani_param_array, - ani_scaling_array_list=None, - param_scaling_grid_list=[param_scaling_array], - gamma_in_array=gamma_in_array, - log_m2l_array=log_m2l_array, + kin_scaling_param_list=["gamma_in", "log_m2l"], + j_kin_scaling_param_axes=j_kin_scaling_param_axes, + j_kin_scaling_grid_list=[param_scaling_array], num_distribution_draws=200, kappa_pdf=None, kappa_bin_edges=None, mst_ifu=False, - **kwargs_likelihood + gamma_in_sampling=True, + gamma_in_distribution="GAUSSIAN", + log_m2l_sampling=True, + log_m2l_distribution="GAUSSIAN", + **kwargs_likelihood, + **kwargs_model # TODO: remove anisotropy sampling in that scenario? ) self.likelihood_gamma_in_fail_case = LensLikelihood( @@ -143,18 +163,16 @@ def setup_method(self): z_source, name="name", likelihood_type="DdtDdGaussian", - anisotropy_model="OM", - ani_param_array=ani_param_array, - ani_scaling_array_list=None, - param_scaling_grid_list=[param_scaling_array], - gamma_in_array=gamma_in_array, - log_m2l_array=log_m2l_array, + kin_scaling_param_list=["a_ani"], + j_kin_scaling_param_axes=ani_param_array, + j_kin_scaling_grid_list=[ani_scaling_array], num_distribution_draws=200, kappa_pdf=None, kappa_bin_edges=None, mst_ifu=False, lambda_scaling_property=100, - **kwargs_likelihood + **kwargs_likelihood, + **kwargs_model ) def test_lens_log_likelihood(self): @@ -221,8 +239,6 @@ def test_lens_log_likelihood(self): kwargs_test = self.likelihood._kwargs_init(kwargs=None) assert type(kwargs_test) is dict - gamma_in_draw = self.likelihood.draw_lens_scaling_params() - assert gamma_in_draw is None kwargs_lens = { "gamma_in": 1, @@ -260,11 +276,11 @@ def test_lens_log_likelihood(self): dds = self.cosmo.angular_diameter_distance_z1z2(z1=z_lens, z2=z_source).value ddt = (1.0 + z_lens) * dd * ds / dds - ln_likelihood = self.likelihood_gamma_in_fail_case.log_likelihood_single( - ddt, dd, delta_lum_dist, kwargs_lens, kwargs_kin, kwargs_source, kwargs_los - ) + #ln_likelihood = self.likelihood_gamma_in_fail_case.log_likelihood_single( + # ddt, dd, delta_lum_dist, kwargs_lens, kwargs_kin, kwargs_source, kwargs_los + #) - assert ln_likelihood < -10000000 + #assert ln_likelihood < -10000000 if __name__ == "__main__": diff --git a/test/test_Likelihood/test_kin_scaling.py b/test/test_Likelihood/test_kin_scaling.py new file mode 100644 index 00000000..f66aa32f --- /dev/null +++ b/test/test_Likelihood/test_kin_scaling.py @@ -0,0 +1,269 @@ +import numpy as np +import numpy.testing as npt +import pytest + +from hierarc.Likelihood.kin_scaling import KinScaling, ParameterScalingSingleMeasurement + + +class TestKinScaling(object): + + def test_single_param(self): + param_arrays = np.linspace(0, 1, 11) + scaling_grid_list = [param_arrays**2] + param_list = ["a"] + kin_scaling = KinScaling(j_kin_scaling_param_axes=param_arrays, + j_kin_scaling_grid_list=scaling_grid_list, + j_kin_scaling_param_name_list=param_list) + kwargs_param = {"a": 0.5} + j_scaling = kin_scaling.kin_scaling(kwargs_param=kwargs_param) + npt.assert_almost_equal(j_scaling, 0.5**2, decimal=2) + kwargs_min, kwargs_max = kin_scaling.param_bounds_interpol() + assert kwargs_min["a"] == 0 + + param_arrays = np.linspace(0, 1, 11) + scaling_grid_list = [param_arrays ** 2] + param_list = ["a"] + kin_scaling = KinScaling(j_kin_scaling_param_axes=[param_arrays], + j_kin_scaling_grid_list=scaling_grid_list, + j_kin_scaling_param_name_list=param_list) + kwargs_param = {"a": 0.5} + j_scaling = kin_scaling.kin_scaling(kwargs_param=kwargs_param) + npt.assert_almost_equal(j_scaling, 0.5 ** 2, decimal=2) + kwargs_min, kwargs_max = kin_scaling.param_bounds_interpol() + assert kwargs_min["a"] == 0 + + def test_two_parameters(self): + param_arrays = [np.linspace(0, 1, 11), np.linspace(0, 2, 21)] + xy, uv = np.meshgrid(param_arrays[0], param_arrays[1]) + scaling_grid_list = [xy.T * uv.T, xy.T, uv.T] + shape_scaling = np.shape(scaling_grid_list[0]) + assert shape_scaling[0] == 11 + assert shape_scaling[1] == 21 + # assert 1 == 0 + param_list = ["a", "b"] + kin_scaling = KinScaling(j_kin_scaling_param_axes=param_arrays, + j_kin_scaling_grid_list=scaling_grid_list, + j_kin_scaling_param_name_list=param_list) + kwargs_param = {"a": 0.5, "b": 0.3} + j_scaling = kin_scaling.kin_scaling(kwargs_param=kwargs_param) + print(j_scaling) + npt.assert_almost_equal(j_scaling[0], 0.5 * 0.3, decimal=2) + npt.assert_almost_equal(j_scaling[1], 0.5, decimal=2) + npt.assert_almost_equal(j_scaling[2], 0.3, decimal=2) + kwargs_min, kwargs_max = kin_scaling.param_bounds_interpol() + assert kwargs_min["a"] == 0 + + def test__kwargs2param_array(self): + param_arrays = [np.linspace(0, 1, 11), np.linspace(0, 2, 11)] + xy, uv = np.meshgrid(param_arrays[0], param_arrays[1]) + scaling_grid_list = [xy * uv, xy, uv] + + param_list = ["a", "b"] + kin_scaling = KinScaling(j_kin_scaling_param_axes=param_arrays, + j_kin_scaling_grid_list=scaling_grid_list, + j_kin_scaling_param_name_list=param_list) + kwargs_param = {"a": 0.5, "b": 0.3} + param_array = kin_scaling._kwargs2param_array(kwargs_param) + assert param_array[0] == kwargs_param["a"] + assert param_array[1] == kwargs_param["b"] + kwargs_min, kwargs_max = kin_scaling.param_bounds_interpol() + assert kwargs_min["a"] == 0 + assert kwargs_min["b"] == 0 + assert kwargs_max["b"] == 2 + assert kwargs_max["a"] == 1 + + def test_empty(self): + kin_scaling = KinScaling(j_kin_scaling_param_axes=None, j_kin_scaling_grid_list=None, j_kin_scaling_param_name_list=None) + output = kin_scaling.kin_scaling(kwargs_param=None) + assert output == 1 + kwargs_min, kwargs_max = kin_scaling.param_bounds_interpol() + +class TestParameterScalingSingleAperture(object): + def setup_method(self): + ani_param_array = np.linspace(start=0, stop=1, num=10) + param_scaling_array = ani_param_array * 2 + self.scaling = ParameterScalingSingleMeasurement( + ani_param_array, param_scaling_array + ) + + ani_param_array = [ + np.linspace(start=0, stop=1, num=10), + np.linspace(start=1, stop=2, num=5), + ] + param_scaling_array = np.outer(ani_param_array[0], ani_param_array[1]) + print(np.shape(param_scaling_array), 'test shape') + self.scaling_2d = ParameterScalingSingleMeasurement( + ani_param_array, param_scaling_array + ) + + ani_param_array = np.linspace(start=0, stop=1, num=10) + gamma_in_array = np.linspace(start=0.1, stop=2.9, num=5) + log_m2l_array = np.linspace(start=0.1, stop=1, num=10) + + param_arrays = [ani_param_array, gamma_in_array, log_m2l_array] + param_scaling_array = np.multiply.outer( + ani_param_array, + np.outer(gamma_in_array, log_m2l_array), + ) + self.scaling_nfw = ParameterScalingSingleMeasurement( + param_arrays, param_scaling_array + ) + + gom_param_array = [ + np.linspace(start=0, stop=1, num=10), + np.linspace(start=1, stop=2, num=5), + ] + param_arrays = [ + gom_param_array[0], + gom_param_array[1], + gamma_in_array, + log_m2l_array, + ] + param_scaling_array = np.multiply.outer( + gom_param_array[0], + np.multiply.outer( + gom_param_array[1], + np.outer(gamma_in_array, log_m2l_array), + ), + ) + + self.scaling_nfw_2d = ParameterScalingSingleMeasurement( + param_arrays, param_scaling_array + ) + + def test_param_scaling(self): + scaling = self.scaling.j_scaling(param_array=[1]) + assert scaling == np.array([2]) + + scaling = self.scaling.j_scaling(param_array=[]) + assert scaling == 1 + + scaling = self.scaling_2d.j_scaling(param_array=[1, 2]) + assert scaling == 2 + + scaling = self.scaling_nfw.j_scaling(param_array=[1, 2.9, 0.5]) + assert scaling == 1 * 2.9 * 0.5 + + scaling = self.scaling_nfw_2d.j_scaling(param_array=[1, 2, 2.9, 0.5]) + assert scaling == 1 * 2 * 2.9 * 0.5 + + +class TestParameterScalingIFU(object): + def setup_method(self): + ani_param_array = np.linspace(start=0, stop=1, num=10) + param_scaling_array = ani_param_array * 2 + self.scaling = KinScaling( + j_kin_scaling_param_axes=ani_param_array, j_kin_scaling_grid_list=[param_scaling_array], + j_kin_scaling_param_name_list=["a"] + ) + + ani_param_array = [ + np.linspace(start=0, stop=1, num=10), + np.linspace(start=1, stop=2, num=5), + ] + param_scaling_array = np.outer(ani_param_array[0], ani_param_array[1]) + self.scaling_2d = KinScaling(j_kin_scaling_param_axes=ani_param_array, + j_kin_scaling_grid_list=[param_scaling_array], + j_kin_scaling_param_name_list=["a", "b"] + ) + + ani_param_array = np.linspace(start=0, stop=1, num=10) + gamma_in_array = np.linspace(start=0.1, stop=2.9, num=5) + log_m2l_array = np.linspace(start=0.1, stop=1, num=10) + + param_arrays = [ani_param_array, gamma_in_array, log_m2l_array] + param_scaling_array = np.multiply.outer( + ani_param_array, + np.outer(gamma_in_array, log_m2l_array), + ) + self.scaling_nfw = KinScaling(j_kin_scaling_param_axes=param_arrays, + j_kin_scaling_grid_list=[param_scaling_array], + j_kin_scaling_param_name_list=["a", "b", "c"] + ) + + + gom_param_array = [ + np.linspace(start=0, stop=1, num=10), + np.linspace(start=1, stop=2, num=5), + ] + param_arrays = [ + gom_param_array[0], + gom_param_array[1], + gamma_in_array, + log_m2l_array, + ] + param_scaling_array = np.multiply.outer( + gom_param_array[0], + np.multiply.outer( + gom_param_array[1], + np.outer(gamma_in_array, log_m2l_array), + ), + ) + self.scaling_nfw_2d = KinScaling(j_kin_scaling_param_axes=param_arrays, + j_kin_scaling_grid_list=[param_scaling_array], + j_kin_scaling_param_name_list=["a", "b", "c", "d"] + ) + + + param_arrays = [ani_param_array, gamma_in_array] + param_scaling_array = np.multiply.outer( + ani_param_array, + gamma_in_array, + ) + self.scaling_nfw_no_m2l = KinScaling(j_kin_scaling_param_axes=param_arrays, + j_kin_scaling_grid_list=[param_scaling_array], + j_kin_scaling_param_name_list=["a", "b"] + ) + + gom_param_array = [ + np.linspace(start=0, stop=1, num=10), + np.linspace(start=1, stop=2, num=5), + ] + param_arrays = [ + gom_param_array[0], + gom_param_array[1], + gamma_in_array, + ] + param_scaling_array = np.multiply.outer( + gom_param_array[0], + np.multiply.outer( + gom_param_array[1], + gamma_in_array, + ), + ) + self.scaling_nfw_2d_no_m2l = KinScaling(j_kin_scaling_param_axes=param_arrays, + j_kin_scaling_grid_list=[param_scaling_array], + j_kin_scaling_param_name_list=["a", "b", "c"] + ) + + def test_kin_scaling(self): + + scaling = self.scaling.kin_scaling(kwargs_param=None) + assert scaling[0] == 1 + + scaling = self.scaling.kin_scaling(kwargs_param={"a":1}) + assert scaling[0] == 2 + + kwargs_param = {"a": 1, "b": 2} + scaling = self.scaling_2d.kin_scaling(kwargs_param=kwargs_param) + assert scaling[0] == 2 + + kwargs_param = {"a": 1, "b": 2.9, "c": 0.5} + scaling = self.scaling_nfw.kin_scaling(kwargs_param=kwargs_param) + assert scaling[0] == 1 * 2.9 * 0.5 + + kwargs_param = {"a": 1, "b": 2., "c": 2.9, "d": 0.5} + scaling = self.scaling_nfw_2d.kin_scaling(kwargs_param=kwargs_param) + assert scaling[0] == 1 * 2 * 2.9 * 0.5 + + kwargs_param = {"a": 1, "b": 2.9} + scaling = self.scaling_nfw_no_m2l.kin_scaling(kwargs_param=kwargs_param) + assert scaling[0] == 1 * 2.9 + + kwargs_param = {"a": 1, "b": 2, "c": 2.9} + scaling = self.scaling_nfw_2d_no_m2l.kin_scaling(kwargs_param=kwargs_param) + assert scaling[0] == 1 * 2 * 2.9 + + +if __name__ == "__main__": + pytest.main() diff --git a/test/test_Likelihood/test_lens_sample_likelihood.py b/test/test_Likelihood/test_lens_sample_likelihood.py index 8bd3acc0..f0d3b487 100644 --- a/test/test_Likelihood/test_lens_sample_likelihood.py +++ b/test/test_Likelihood/test_lens_sample_likelihood.py @@ -47,10 +47,13 @@ def setup_method(self): "likelihood_type": "DsDdsGaussian", "ds_dds_mean": lensCosmo.ds / lensCosmo.dds, "ds_dds_sigma": 1, - "ani_param_array": ani_param_array, - "ani_scaling_array": ani_scaling_array, + "kin_scaling_param_list": ["a_ani"], + "j_kin_scaling_param_axes": ani_param_array, + "j_kin_scaling_grid_list": [ani_scaling_array], }, ] + kwargs_global_model = {"anisotropy_sampling": True} + self.likelihood = LensSampleLikelihood(kwargs_lens_list=self.kwargs_lens_list) def test_log_likelihood(self): diff --git a/test/test_Likelihood/test_los_distribution.py b/test/test_Likelihood/test_los_distribution.py index 3ac5434e..97b25d08 100644 --- a/test/test_Likelihood/test_los_distribution.py +++ b/test/test_Likelihood/test_los_distribution.py @@ -1,4 +1,4 @@ -from hierarc.Likelihood.los_distributions import LOSDistribution +from hierarc.Sampling.Distributions.los_distributions import LOSDistribution from scipy.stats import genextreme import numpy as np import numpy.testing as npt diff --git a/test/test_Likelihood/test_parameter_scaling.py b/test/test_Likelihood/test_parameter_scaling.py deleted file mode 100644 index d96695fd..00000000 --- a/test/test_Likelihood/test_parameter_scaling.py +++ /dev/null @@ -1,417 +0,0 @@ -import pytest -import numpy as np -import unittest -from hierarc.Likelihood.parameter_scaling import ( - ParameterScalingSingleAperture, - ParameterScalingIFU, -) - - -class TestParameterScalingSingleAperture(object): - def setup_method(self): - ani_param_array = np.linspace(start=0, stop=1, num=10) - param_scaling_array = ani_param_array * 2 - self.scaling = ParameterScalingSingleAperture( - ani_param_array, param_scaling_array - ) - - ani_param_array = [ - np.linspace(start=0, stop=1, num=10), - np.linspace(start=1, stop=2, num=5), - ] - param_scaling_array = np.outer(ani_param_array[0], ani_param_array[1]) - self.scaling_2d = ParameterScalingSingleAperture( - ani_param_array, param_scaling_array - ) - - ani_param_array = np.linspace(start=0, stop=1, num=10) - gamma_in_array = np.linspace(start=0.1, stop=2.9, num=5) - log_m2l_array = np.linspace(start=0.1, stop=1, num=10) - - param_arrays = [ani_param_array, gamma_in_array, log_m2l_array] - param_scaling_array = np.multiply.outer( - ani_param_array, - np.outer(gamma_in_array, log_m2l_array), - ) - self.scaling_nfw = ParameterScalingSingleAperture( - param_arrays, param_scaling_array - ) - - gom_param_array = [ - np.linspace(start=0, stop=1, num=10), - np.linspace(start=1, stop=2, num=5), - ] - param_arrays = [ - gom_param_array[0], - gom_param_array[1], - gamma_in_array, - log_m2l_array, - ] - param_scaling_array = np.multiply.outer( - gom_param_array[0], - np.multiply.outer( - gom_param_array[1], - np.outer(gamma_in_array, log_m2l_array), - ), - ) - - self.scaling_nfw_2d = ParameterScalingSingleAperture( - param_arrays, param_scaling_array - ) - - def test_param_scaling(self): - scaling = self.scaling.param_scaling(param_array=[1]) - assert scaling == np.array([2]) - - scaling = self.scaling.param_scaling(param_array=None) - assert scaling == 1 - - scaling = self.scaling_2d.param_scaling(param_array=[1, 2]) - assert scaling == 2 - - scaling = self.scaling_nfw.param_scaling(param_array=[1, 2.9, 0.5]) - assert scaling == 1 * 2.9 * 0.5 - - scaling = self.scaling_nfw_2d.param_scaling(param_array=[1, 2, 2.9, 0.5]) - assert scaling == 1 * 2 * 2.9 * 0.5 - - -class TestParameterScalingIFU(object): - def setup_method(self): - ani_param_array = np.linspace(start=0, stop=1, num=10) - param_scaling_array = ani_param_array * 2 - self.scaling = ParameterScalingIFU( - anisotropy_model="OM", - param_arrays=ani_param_array, - scaling_grid_list=[param_scaling_array], - ) - - ani_param_array = [ - np.linspace(start=0, stop=1, num=10), - np.linspace(start=1, stop=2, num=5), - ] - param_scaling_array = np.outer(ani_param_array[0], ani_param_array[1]) - self.scaling_2d = ParameterScalingIFU( - anisotropy_model="GOM", - param_arrays=ani_param_array, - scaling_grid_list=[param_scaling_array], - ) - - ani_param_array = np.linspace(start=0, stop=1, num=10) - gamma_in_array = np.linspace(start=0.1, stop=2.9, num=5) - log_m2l_array = np.linspace(start=0.1, stop=1, num=10) - - param_arrays = [ani_param_array, gamma_in_array, log_m2l_array] - param_scaling_array = np.multiply.outer( - ani_param_array, - np.outer(gamma_in_array, log_m2l_array), - ) - self.scaling_nfw = ParameterScalingIFU( - anisotropy_model="OM", - param_arrays=param_arrays, - scaling_grid_list=[param_scaling_array], - ) - - gom_param_array = [ - np.linspace(start=0, stop=1, num=10), - np.linspace(start=1, stop=2, num=5), - ] - param_arrays = [ - gom_param_array[0], - gom_param_array[1], - gamma_in_array, - log_m2l_array, - ] - param_scaling_array = np.multiply.outer( - gom_param_array[0], - np.multiply.outer( - gom_param_array[1], - np.outer(gamma_in_array, log_m2l_array), - ), - ) - self.scaling_nfw_2d = ParameterScalingIFU( - anisotropy_model="GOM", - param_arrays=param_arrays, - scaling_grid_list=[param_scaling_array], - ) - - param_arrays = [ani_param_array, gamma_in_array] - param_scaling_array = np.multiply.outer( - ani_param_array, - gamma_in_array, - ) - self.scaling_nfw_no_m2l = ParameterScalingIFU( - anisotropy_model="OM", - param_arrays=param_arrays, - scaling_grid_list=[param_scaling_array], - ) - - gom_param_array = [ - np.linspace(start=0, stop=1, num=10), - np.linspace(start=1, stop=2, num=5), - ] - param_arrays = [ - gom_param_array[0], - gom_param_array[1], - gamma_in_array, - ] - param_scaling_array = np.multiply.outer( - gom_param_array[0], - np.multiply.outer( - gom_param_array[1], - gamma_in_array, - ), - ) - self.scaling_nfw_2d_no_m2l = ParameterScalingIFU( - anisotropy_model="GOM", - param_arrays=param_arrays, - scaling_grid_list=[param_scaling_array], - ) - - def test_param_scaling(self): - scaling = self.scaling.param_scaling(param_array=None) - assert scaling[0] == 1 - - scaling = self.scaling.param_scaling(param_array=[1]) - assert scaling[0] == 2 - - scaling = self.scaling_2d.param_scaling(param_array=[1, 2]) - assert scaling[0] == 2 - - scaling = self.scaling_nfw.param_scaling(param_array=[1, 2.9, 0.5]) - assert scaling[0] == 1 * 2.9 * 0.5 - - scaling = self.scaling_nfw_2d.param_scaling(param_array=[1, 2, 2.9, 0.5]) - assert scaling[0] == 1 * 2 * 2.9 * 0.5 - - scaling = self.scaling_nfw_no_m2l.param_scaling(param_array=[1, 2.9]) - assert scaling[0] == 1 * 2.9 - - scaling = self.scaling_nfw_2d_no_m2l.param_scaling(param_array=[1, 2, 2.9]) - assert scaling[0] == 1 * 2 * 2.9 - - def test_draw_anisotropy(self): - a_ani = 1 - beta_inf = 1.5 - param_draw = self.scaling.draw_anisotropy( - a_ani=1, a_ani_sigma=0, beta_inf=beta_inf, beta_inf_sigma=0 - ) - assert param_draw[0] == a_ani - for i in range(100): - param_draw = self.scaling.draw_anisotropy( - a_ani=1, a_ani_sigma=1, beta_inf=beta_inf, beta_inf_sigma=1 - ) - self.scaling._anisotropy_model = "const" - param_draw = self.scaling.draw_anisotropy( - a_ani=1, a_ani_sigma=0, beta_inf=beta_inf, beta_inf_sigma=0 - ) - assert param_draw[0] == 1 - - param_draw = self.scaling_2d.draw_anisotropy( - a_ani=1, a_ani_sigma=0, beta_inf=beta_inf, beta_inf_sigma=0 - ) - assert param_draw[0] == a_ani - assert param_draw[1] == beta_inf - for i in range(100): - param_draw = self.scaling_2d.draw_anisotropy( - a_ani=1, a_ani_sigma=1, beta_inf=beta_inf, beta_inf_sigma=1 - ) - - param_draw = self.scaling_nfw.draw_anisotropy( - a_ani=1, a_ani_sigma=0, beta_inf=beta_inf, beta_inf_sigma=0 - ) - assert param_draw[0] == a_ani - for i in range(100): - param_draw = self.scaling_nfw.draw_anisotropy( - a_ani=1, a_ani_sigma=1, beta_inf=beta_inf, beta_inf_sigma=1 - ) - - param_draw = self.scaling_nfw_2d.draw_anisotropy( - a_ani=1, a_ani_sigma=0, beta_inf=beta_inf, beta_inf_sigma=0 - ) - assert param_draw[0] == a_ani - assert param_draw[1] == beta_inf - for i in range(100): - param_draw = self.scaling_nfw_2d.draw_anisotropy( - a_ani=1, a_ani_sigma=1, beta_inf=beta_inf, beta_inf_sigma=1 - ) - - param_draw = self.scaling_nfw_no_m2l.draw_anisotropy( - a_ani=1, a_ani_sigma=0, beta_inf=beta_inf, beta_inf_sigma=0 - ) - assert param_draw[0] == a_ani - for i in range(100): - param_draw = self.scaling_nfw_no_m2l.draw_anisotropy( - a_ani=1, a_ani_sigma=1, beta_inf=beta_inf, beta_inf_sigma=1 - ) - - param_draw = self.scaling_nfw_2d_no_m2l.draw_anisotropy( - a_ani=1, a_ani_sigma=0, beta_inf=beta_inf, beta_inf_sigma=0 - ) - assert param_draw[0] == a_ani - assert param_draw[1] == beta_inf - for i in range(100): - param_draw = self.scaling_nfw_2d_no_m2l.draw_anisotropy( - a_ani=1, a_ani_sigma=1, beta_inf=beta_inf, beta_inf_sigma=1 - ) - - scaling = ParameterScalingIFU(anisotropy_model="NONE") - param_draw = scaling.draw_anisotropy( - a_ani=1, a_ani_sigma=0, beta_inf=beta_inf, beta_inf_sigma=0 - ) - assert param_draw is None - - def test_draw_lens_parameters(self): - param_draw = self.scaling_nfw.draw_lens_parameters( - gamma_in=1, gamma_in_sigma=0, log_m2l=0.5, log_m2l_sigma=0 - ) - assert param_draw[0] == 1 - assert param_draw[1] == 0.5 - for i in range(100): - param_draw = self.scaling_nfw.draw_lens_parameters( - gamma_in=1, gamma_in_sigma=1, log_m2l=0.5, log_m2l_sigma=3 - ) - - param_draw = self.scaling_nfw_2d.draw_lens_parameters( - gamma_in=1, gamma_in_sigma=0, log_m2l=0.5, log_m2l_sigma=0 - ) - assert param_draw[0] == 1 - assert param_draw[1] == 0.5 - - for i in range(100): - param_draw = self.scaling_nfw_2d.draw_lens_parameters( - gamma_in=1, gamma_in_sigma=1, log_m2l=0.5, log_m2l_sigma=3 - ) - - param_draw = self.scaling_nfw_no_m2l.draw_lens_parameters( - gamma_in=1, gamma_in_sigma=0, log_m2l=0.5, log_m2l_sigma=0 - ) - assert param_draw == 1 - for i in range(100): - param_draw = self.scaling_nfw_no_m2l.draw_lens_parameters( - gamma_in=1, gamma_in_sigma=1, log_m2l=0.5, log_m2l_sigma=3 - ) - - param_draw = self.scaling_nfw_2d_no_m2l.draw_lens_parameters( - gamma_in=1, gamma_in_sigma=0, log_m2l=0.5, log_m2l_sigma=0 - ) - assert param_draw == 1 - for i in range(100): - param_draw = self.scaling_nfw_2d_no_m2l.draw_lens_parameters( - gamma_in=1, gamma_in_sigma=1, log_m2l=0.5, log_m2l_sigma=3 - ) - - -class TestRaise(unittest.TestCase): - def test_raise(self): - with self.assertRaises(ValueError): - ParameterScalingIFU( - anisotropy_model="blabla", - param_arrays=np.array([0, 1]), - scaling_grid_list=[np.array([0, 1])], - ) - - ani_param_array = np.linspace(start=0, stop=1, num=10) - ani_scaling_array = ani_param_array * 2 - scaling = ParameterScalingIFU( - anisotropy_model="OM", - param_arrays=ani_param_array, - scaling_grid_list=[ani_scaling_array], - ) - with self.assertRaises(ValueError): - scaling.draw_anisotropy( - a_ani=-1, a_ani_sigma=0, beta_inf=-1, beta_inf_sigma=0 - ) - - ani_param_array = [ - np.linspace(start=0, stop=1, num=10), - np.linspace(start=1, stop=2, num=5), - ] - ani_scaling_array = np.outer(ani_param_array[0], ani_param_array[1]) - scaling = ParameterScalingIFU( - anisotropy_model="GOM", - param_arrays=ani_param_array, - scaling_grid_list=[ani_scaling_array], - ) - with self.assertRaises(ValueError): - scaling.draw_anisotropy( - a_ani=0.5, a_ani_sigma=0, beta_inf=-1, beta_inf_sigma=0 - ) - - ani_param_array = np.linspace(start=0, stop=1, num=10) - gamma_in_array = np.linspace(start=0.1, stop=2.9, num=5) - log_m2l_array = np.linspace(start=0.1, stop=1, num=10) - - param_arrays = [ani_param_array, gamma_in_array, log_m2l_array] - param_scaling_array = np.multiply.outer( - ani_param_array, - np.multiply.outer(gamma_in_array, log_m2l_array), - ) - print(param_scaling_array.shape) - scaling = ParameterScalingIFU( - anisotropy_model="OM", - param_arrays=param_arrays, - scaling_grid_list=[param_scaling_array], - ) - with self.assertRaises(ValueError): - scaling.draw_lens_parameters( - gamma_in=-1, gamma_in_sigma=0.1, log_m2l=0.5, log_m2l_sigma=0.1 - ) - with self.assertRaises(ValueError): - scaling.draw_lens_parameters( - gamma_in=1, gamma_in_sigma=0.1, log_m2l=-0.5, log_m2l_sigma=0.1 - ) - - ani_param_array = np.linspace(start=0, stop=1, num=10) - gamma_in_array = np.linspace(start=0.1, stop=2.9, num=5) - log_m2l_array = np.linspace(start=0.1, stop=1, num=10) - - param_arrays = [ani_param_array, gamma_in_array, log_m2l_array] - param_scaling_array = np.multiply.outer( - ani_param_array, - np.multiply.outer(gamma_in_array, log_m2l_array), - ) - - scaling = ParameterScalingIFU( - anisotropy_model="OM", - param_arrays=param_arrays, - scaling_grid_list=[param_scaling_array], - ) - with self.assertRaises(ValueError): - scaling.draw_lens_parameters( - gamma_in=1, gamma_in_sigma=0, log_m2l=0, log_m2l_sigma=0 - ) - - gom_param_array = [ - np.linspace(start=0, stop=1, num=10), - np.linspace(start=1, stop=2, num=5), - ] - - gamma_in_array = np.linspace(start=0.1, stop=2.9, num=5) - - param_arrays = [ - gom_param_array[0], - gom_param_array[1], - gamma_in_array, - ] - param_scaling_array = np.multiply.outer( - gom_param_array[0], - np.multiply.outer( - gom_param_array[1], - gamma_in_array, - ), - ) - self.scaling_nfw_2d_no_m2l = ParameterScalingIFU( - anisotropy_model="GOM", - param_arrays=param_arrays, - scaling_grid_list=[param_scaling_array], - ) - - with self.assertRaises(ValueError): - param_draw = self.scaling_nfw_2d_no_m2l.draw_lens_parameters( - gamma_in=-1, gamma_in_sigma=1, log_m2l=0.5, log_m2l_sigma=3 - ) - - -if __name__ == "__main__": - pytest.main() diff --git a/test/test_Sampling/test_Distributions/__init__.py b/test/test_Sampling/test_Distributions/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/test/test_Sampling/test_Distributions/test_anisotropy_distribution.py b/test/test_Sampling/test_Distributions/test_anisotropy_distribution.py new file mode 100644 index 00000000..6dd65ce8 --- /dev/null +++ b/test/test_Sampling/test_Distributions/test_anisotropy_distribution.py @@ -0,0 +1,36 @@ +from hierarc.Sampling.Distributions.anisotropy_distributions import AnisotropyDistribution + + +class TestAnisotropyDistribution(object): + + def setup_method(self): + anisotropy_model = "GOM" + distribution_function = "GAUSSIAN" + kwargs_anisotropy_min = {"a_ani": 0, "beta_inf": 0.1} + kwargs_anisotropy_max = {"a_ani": 5, "beta_inf": 1} + + self._ani_dist = AnisotropyDistribution(anisotropy_model=anisotropy_model, + anisotropy_sampling=True, + distribution_function=distribution_function, + kwargs_anisotropy_min=kwargs_anisotropy_min, + kwargs_anisotropy_max=kwargs_anisotropy_max) + + ani_dist = AnisotropyDistribution(anisotropy_model=anisotropy_model, + anisotropy_sampling=False, + distribution_function=distribution_function, + kwargs_anisotropy_min=kwargs_anisotropy_min, + kwargs_anisotropy_max=kwargs_anisotropy_max) + + def test_draw_anisotropy(self): + kwargs_anisotropy = {"a_ani": 1, "beta_inf": 0.8, "a_ani_sigma": 0.1, "beta_inf_sigma": 0.2} + kwargs_drawn = self._ani_dist.draw_anisotropy(**kwargs_anisotropy) + assert "a_ani" in kwargs_drawn + assert "beta_inf" in kwargs_drawn + + ani_dist = AnisotropyDistribution(anisotropy_model="NONE", + anisotropy_sampling=False, + distribution_function="NONE", + kwargs_anisotropy_min=None, + kwargs_anisotropy_max=None) + kwargs_drawn = ani_dist.draw_anisotropy() + assert "a_ani" not in kwargs_drawn diff --git a/test/test_Sampling/test_Distributions/test_lens_distribution.py b/test/test_Sampling/test_Distributions/test_lens_distribution.py new file mode 100644 index 00000000..6f71712f --- /dev/null +++ b/test/test_Sampling/test_Distributions/test_lens_distribution.py @@ -0,0 +1,51 @@ +import copy + +from hierarc.Sampling.Distributions.lens_distribution import LensDistribution + + +class TestLensDistribution(object): + + def setup_method(self): + self.kwargs_sampling = {"lambda_mst_distribution": "GAUSSIAN", + "gamma_in_sampling": True, + "gamma_in_distribution": "GAUSSIAN", + "log_m2l_sampling": True, + "log_m2l_distribution" : "GAUSSIAN", + "alpha_lambda_sampling": True, + "beta_lambda_sampling": True, + "alpha_gamma_in_sampling": True, + "alpha_log_m2l_sampling": True, + "log_scatter": False, # change for different tests + "mst_ifu": False, # change for different tests + "lambda_scaling_property": 0.1, + "lambda_scaling_property_beta": 0.2, + "kwargs_min": {"gamma_in": 0, "log_m2l": -3}, + "kwargs_max": {"gamma_in": 3, "log_m2l": 3}} + + self.kwargs_lens = {"lambda_mst": 1.1, + "lambda_mst_sigma": 0.1, + "gamma_ppn": 0.9, + "lambda_ifu": 0.5, + "lambda_ifu_sigma": 0.2, + "alpha_lambda": -0.2, + "beta_lambda": 0.3, + "gamma_in": 1.5, + "gamma_in_sigma": 0.2, + "alpha_gamma_in": 0.2, + "log_m2l": 0.6, + "log_m2l_sigma": 0.2, + "alpha_log_m2l": -0.1} + + def test_draw_lens(self): + lens_dist = LensDistribution(**self.kwargs_sampling) + kwargs_return = lens_dist.draw_lens(**self.kwargs_lens) + + assert "lambda_mst" in kwargs_return + + kwargs_sampling = copy.deepcopy(self.kwargs_sampling) + kwargs_sampling["log_scatter"] = True + kwargs_sampling["lambda_ifu"] = True + lens_dist = LensDistribution(kwargs_sampling) + kwargs_return = lens_dist.draw_lens(**self.kwargs_lens) + + assert "lambda_mst" in kwargs_return diff --git a/test/test_Sampling/test_mcmc_sampling.py b/test/test_Sampling/test_mcmc_sampling.py index 8926e01d..e27550ec 100644 --- a/test/test_Sampling/test_mcmc_sampling.py +++ b/test/test_Sampling/test_mcmc_sampling.py @@ -67,16 +67,19 @@ def test_mcmc_emcee(self): backend = emcee.backends.HDFBackend(backup_filename) kwargs_emcee = {"backend": backend} + kwargs_model = {"ppn_sampling": False, + "lambda_mst_sampling": False, + "lambda_mst_distribution": "delta", + "anisotropy_sampling": False, + "anisotropy_model": "OM", + + } mcmc_sampler = MCMCSampler( kwargs_likelihood_list=kwargs_likelihood_list, cosmology=cosmology, kwargs_bounds=kwargs_bounds, - ppn_sampling=False, - lambda_mst_sampling=False, - lambda_mst_distribution="delta", - anisotropy_sampling=False, - anisotropy_model="OM", + kwargs_model=kwargs_model, custom_prior=None, interpolate_cosmo=True, num_redshift_interp=100, From 4bb09ba9f96c261a633a4ac2b4f7529dbcf549b9 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 27 Jun 2024 01:57:35 +0000 Subject: [PATCH 12/62] [pre-commit.ci] auto fixes from pre-commit.com hooks --- hierarc/LensPosterior/base_config.py | 10 +- hierarc/LensPosterior/kin_constraints.py | 8 +- .../kin_constraints_composite.py | 13 +-- hierarc/LensPosterior/kin_scaling_config.py | 13 ++- hierarc/Likelihood/cosmo_likelihood.py | 6 +- hierarc/Likelihood/hierarchy_likelihood.py | 84 +++++++++------ hierarc/Likelihood/kin_scaling.py | 37 +++++-- hierarc/Likelihood/lens_sample_likelihood.py | 38 +++---- .../Distributions/anisotropy_distributions.py | 23 ++-- .../Distributions/lens_distribution.py | 84 ++++++++------- .../test_kin_constraints_composite.py | 28 +++-- test/test_Likelihood/test_cosmo_likelihood.py | 24 +++-- .../test_hierarchy_likelihood.py | 29 ++--- test/test_Likelihood/test_kin_scaling.py | 101 ++++++++++-------- .../test_anisotropy_distribution.py | 47 +++++--- .../test_lens_distribution.py | 62 ++++++----- test/test_Sampling/test_mcmc_sampling.py | 14 +-- 17 files changed, 365 insertions(+), 256 deletions(-) diff --git a/hierarc/LensPosterior/base_config.py b/hierarc/LensPosterior/base_config.py index 258c12f7..ee39e438 100644 --- a/hierarc/LensPosterior/base_config.py +++ b/hierarc/LensPosterior/base_config.py @@ -109,6 +109,10 @@ def __init__( ImageModelPosterior.__init__( self, theta_E, theta_E_error, gamma, gamma_error, r_eff, r_eff_error ) - KinScalingConfig.__init__(self, anisotropy_model, r_eff, - gamma_in_scaling=gamma_in_scaling, - log_m2l_scaling=log_m2l_scaling) + KinScalingConfig.__init__( + self, + anisotropy_model, + r_eff, + gamma_in_scaling=gamma_in_scaling, + log_m2l_scaling=log_m2l_scaling, + ) diff --git a/hierarc/LensPosterior/kin_constraints.py b/hierarc/LensPosterior/kin_constraints.py index 7bae1ea4..15cf2a9a 100644 --- a/hierarc/LensPosterior/kin_constraints.py +++ b/hierarc/LensPosterior/kin_constraints.py @@ -180,7 +180,6 @@ def hierarchy_configuration(self, num_sample_model=20): "kin_scaling_param_list": self.param_name_list, "j_kin_scaling_param_axes": self.kin_scaling_param_array, "j_kin_scaling_grid_list": ani_scaling_array_list, - } return kwargs_likelihood @@ -253,7 +252,12 @@ def _anisotropy_scaling_relative(self, j_ani_0): if self._anisotropy_model == "GOM": ani_scaling_array_list = [ - np.zeros((len(self.kin_scaling_param_array[0]), len(self.kin_scaling_param_array[1]))) + np.zeros( + ( + len(self.kin_scaling_param_array[0]), + len(self.kin_scaling_param_array[1]), + ) + ) for _ in range(num_data) ] for i, a_ani in enumerate(self.kin_scaling_param_array[0]): diff --git a/hierarc/LensPosterior/kin_constraints_composite.py b/hierarc/LensPosterior/kin_constraints_composite.py index 99e87118..60bcc145 100644 --- a/hierarc/LensPosterior/kin_constraints_composite.py +++ b/hierarc/LensPosterior/kin_constraints_composite.py @@ -400,21 +400,18 @@ def hierarchy_configuration(self, num_sample_model=20): "j_model": j_model_list, "error_cov_measurement": error_cov_measurement, "error_cov_j_sqrt": error_cov_j_sqrt, - - #"ani_param_array": self.kin_scaling_param_array, - #"gamma_in_array": self.gamma_in_array, - #"log_m2l_array": self.log_m2l_array, - #"param_scaling_grid_list": ani_scaling_grid_list, - + # "ani_param_array": self.kin_scaling_param_array, + # "gamma_in_array": self.gamma_in_array, + # "log_m2l_array": self.log_m2l_array, + # "param_scaling_grid_list": ani_scaling_grid_list, "gamma_in_prior_mean": self._gamma_in_prior_mean, "gamma_in_prior_std": self._gamma_in_prior_std, - "kin_scaling_param_list": self.param_name_list, "j_kin_scaling_param_axes": self.kin_scaling_param_array, "j_kin_scaling_grid_list": ani_scaling_grid_list, } - #if not self._is_m2l_population_level: + # if not self._is_m2l_population_level: # kwargs_likelihood["log_m2l_array"] = None return kwargs_likelihood diff --git a/hierarc/LensPosterior/kin_scaling_config.py b/hierarc/LensPosterior/kin_scaling_config.py index 8a51b2ad..d6979f3d 100644 --- a/hierarc/LensPosterior/kin_scaling_config.py +++ b/hierarc/LensPosterior/kin_scaling_config.py @@ -5,7 +5,9 @@ class KinScalingConfig(object): """Class to manage the anisotropy model and parameters for the Posterior processing.""" - def __init__(self, anisotropy_model, r_eff, gamma_in_scaling=None, log_m2l_scaling=None): + def __init__( + self, anisotropy_model, r_eff, gamma_in_scaling=None, log_m2l_scaling=None + ): """ :param anisotropy_model: type of stellar anisotropy model. Supported are 'OM' and 'GOM' or 'const', see details in lenstronomy.Galkin module @@ -28,10 +30,12 @@ def __init__(self, anisotropy_model, r_eff, gamma_in_scaling=None, log_m2l_scali ] self._param_name_list = ["a_ani", "beta_inf"] elif self._anisotropy_model == "const": - self._ani_param_array = [np.linspace(-0.49, 1, 7)] # used for constant anisotropy description + self._ani_param_array = [ + np.linspace(-0.49, 1, 7) + ] # used for constant anisotropy description self._param_name_list = ["a_ani"] elif self._anisotropy_model == "NONE": - self._param_name_list =[] + self._param_name_list = [] else: raise ValueError( "anisotropy model %s not supported." % self._anisotropy_model @@ -77,8 +81,7 @@ def kin_scaling_param_array(self): @property def param_name_list(self): - """ - list of parameters in same order as interpolated + """List of parameters in same order as interpolated. :return: """ diff --git a/hierarc/Likelihood/cosmo_likelihood.py b/hierarc/Likelihood/cosmo_likelihood.py index f900cbfa..8ad2a06f 100644 --- a/hierarc/Likelihood/cosmo_likelihood.py +++ b/hierarc/Likelihood/cosmo_likelihood.py @@ -60,11 +60,7 @@ def __init__( normalized=normalized, kwargs_global_model=kwargs_model, ) - self.param = ParamManager( - cosmology, - **kwargs_model, - **kwargs_bounds - ) + self.param = ParamManager(cosmology, **kwargs_model, **kwargs_bounds) self._lower_limit, self._upper_limit = self.param.param_bounds self._prior_add = False if custom_prior is not None: diff --git a/hierarc/Likelihood/hierarchy_likelihood.py b/hierarc/Likelihood/hierarchy_likelihood.py index 2b5aaf7b..16ba54fb 100644 --- a/hierarc/Likelihood/hierarchy_likelihood.py +++ b/hierarc/Likelihood/hierarchy_likelihood.py @@ -2,7 +2,9 @@ from hierarc.Likelihood.LensLikelihood.base_lens_likelihood import LensLikelihoodBase from hierarc.Likelihood.kin_scaling import KinScaling from hierarc.Sampling.Distributions.los_distributions import LOSDistribution -from hierarc.Sampling.Distributions.anisotropy_distributions import AnisotropyDistribution +from hierarc.Sampling.Distributions.anisotropy_distributions import ( + AnisotropyDistribution, +) from hierarc.Sampling.Distributions.lens_distribution import LensDistribution import numpy as np import copy @@ -94,11 +96,12 @@ def __init__( """ TransformedCosmography.__init__(self, z_lens=z_lens, z_source=z_source) - KinScaling.__init__(self, - j_kin_scaling_param_axes=j_kin_scaling_param_axes, - j_kin_scaling_grid_list=j_kin_scaling_grid_list, - j_kin_scaling_param_name_list=kin_scaling_param_list - ) + KinScaling.__init__( + self, + j_kin_scaling_param_axes=j_kin_scaling_param_axes, + j_kin_scaling_grid_list=j_kin_scaling_grid_list, + j_kin_scaling_param_name_list=kin_scaling_param_list, + ) LensLikelihoodBase.__init__( self, @@ -119,28 +122,32 @@ def __init__( los_distributions=los_distributions, ) kwargs_min, kwargs_max = self.param_bounds_interpol() - self._lens_distribution = LensDistribution(lambda_mst_sampling=False, - lambda_mst_distribution=lambda_mst_distribution, - gamma_in_sampling=gamma_in_sampling, - gamma_in_distribution=gamma_in_distribution, - log_m2l_sampling=log_m2l_sampling, - log_m2l_distribution=log_m2l_distribution, - alpha_lambda_sampling=alpha_lambda_sampling, - beta_lambda_sampling=beta_lambda_sampling, - alpha_gamma_in_sampling=alpha_gamma_in_sampling, - alpha_log_m2l_sampling=alpha_log_m2l_sampling, - log_scatter=log_scatter, - mst_ifu=mst_ifu, - lambda_scaling_property=lambda_scaling_property, - lambda_scaling_property_beta=lambda_scaling_property_beta, - kwargs_min=kwargs_min, - kwargs_max=kwargs_max,) - - self._aniso_distribution = AnisotropyDistribution(anisotropy_model=anisotropy_model, - anisotropy_sampling=anisotropy_sampling, - distribution_function=anisotroy_distribution_function, - kwargs_anisotropy_min=kwargs_min, - kwargs_anisotropy_max=kwargs_max) + self._lens_distribution = LensDistribution( + lambda_mst_sampling=False, + lambda_mst_distribution=lambda_mst_distribution, + gamma_in_sampling=gamma_in_sampling, + gamma_in_distribution=gamma_in_distribution, + log_m2l_sampling=log_m2l_sampling, + log_m2l_distribution=log_m2l_distribution, + alpha_lambda_sampling=alpha_lambda_sampling, + beta_lambda_sampling=beta_lambda_sampling, + alpha_gamma_in_sampling=alpha_gamma_in_sampling, + alpha_log_m2l_sampling=alpha_log_m2l_sampling, + log_scatter=log_scatter, + mst_ifu=mst_ifu, + lambda_scaling_property=lambda_scaling_property, + lambda_scaling_property_beta=lambda_scaling_property_beta, + kwargs_min=kwargs_min, + kwargs_max=kwargs_max, + ) + + self._aniso_distribution = AnisotropyDistribution( + anisotropy_model=anisotropy_model, + anisotropy_sampling=anisotropy_sampling, + distribution_function=anisotroy_distribution_function, + kwargs_anisotropy_min=kwargs_min, + kwargs_anisotropy_max=kwargs_max, + ) self._gamma_in_prior_mean = gamma_in_prior_mean self._gamma_in_prior_std = gamma_in_prior_std @@ -278,7 +285,10 @@ def log_likelihood_single( realization of the hyperparameter distribution """ kwargs_lens_draw = self._lens_distribution.draw_lens(**kwargs_lens) - lambda_mst, gamma_ppn = kwargs_lens_draw["lambda_mst"], kwargs_lens_draw["gamma_ppn"] + lambda_mst, gamma_ppn = ( + kwargs_lens_draw["lambda_mst"], + kwargs_lens_draw["gamma_ppn"], + ) kappa_ext = self._los.draw_los(kwargs_los) # draw intrinsic source magnitude @@ -309,9 +319,9 @@ def log_likelihood_single( and "gamma_in" in kwargs_lens_draw ): gamma_in = kwargs_lens_draw["gamma_in"] - lnlikelihood -= ( - self._gamma_in_prior_mean - gamma_in - ) ** 2 / (2 * self._gamma_in_prior_std**2) + lnlikelihood -= (self._gamma_in_prior_mean - gamma_in) ** 2 / ( + 2 * self._gamma_in_prior_std**2 + ) return np.nan_to_num(lnlikelihood) @@ -433,7 +443,10 @@ def sigma_v_measured_vs_predict( cov_error_predict = np.zeros_like(cov_error_measurement) for i in range(self._num_distribution_draws): kwargs_lens_draw = self._lens_distribution.draw_lens(**kwargs_lens) - lambda_mst, gamma_ppn = kwargs_lens_draw["lambda_mst"], kwargs_lens_draw["gamma_ppn"] + lambda_mst, gamma_ppn = ( + kwargs_lens_draw["lambda_mst"], + kwargs_lens_draw["gamma_ppn"], + ) kappa_ext = self._los.draw_los(kwargs_los) ddt_, dd_, _ = self.displace_prediction( ddt, dd, gamma_ppn=gamma_ppn, lambda_mst=lambda_mst, kappa_ext=kappa_ext @@ -478,7 +491,10 @@ def ddt_dd_model_prediction(self, cosmo, kwargs_lens=None, kwargs_los=None): dd_draws = [] for i in range(self._num_distribution_draws): kwargs_lens_draw = self._lens_distribution.draw_lens(**kwargs_lens) - lambda_mst, gamma_ppn = kwargs_lens_draw["lambda_mst"], kwargs_lens_draw["gamma_ppn"] + lambda_mst, gamma_ppn = ( + kwargs_lens_draw["lambda_mst"], + kwargs_lens_draw["gamma_ppn"], + ) kappa_ext = self._los.draw_los(kwargs_los) ddt_, dd_, _ = self.displace_prediction( ddt, dd, gamma_ppn=gamma_ppn, lambda_mst=lambda_mst, kappa_ext=kappa_ext diff --git a/hierarc/Likelihood/kin_scaling.py b/hierarc/Likelihood/kin_scaling.py index f016adf8..40e75f58 100644 --- a/hierarc/Likelihood/kin_scaling.py +++ b/hierarc/Likelihood/kin_scaling.py @@ -26,9 +26,13 @@ def __init__(self, param_grid_axes, j_kin_scaling_grid): param_grid_axes = [param_grid_axes] if self._dim_scaling == 1: - self._f_ani = interp1d(param_grid_axes[0], j_kin_scaling_grid, kind="linear") + self._f_ani = interp1d( + param_grid_axes[0], j_kin_scaling_grid, kind="linear" + ) elif self._dim_scaling == 2: - self._f_ani = interp2d(param_grid_axes[0], param_grid_axes[1], j_kin_scaling_grid.T) + self._f_ani = interp2d( + param_grid_axes[0], param_grid_axes[1], j_kin_scaling_grid.T + ) else: self._f_ani = RegularGridInterpolator( tuple(param_grid_axes), @@ -57,7 +61,10 @@ class KinScaling(object): """Class to manage model parameter and anisotropy scalings for IFU data.""" def __init__( - self, j_kin_scaling_param_axes=None, j_kin_scaling_grid_list=None, j_kin_scaling_param_name_list=None + self, + j_kin_scaling_param_axes=None, + j_kin_scaling_grid_list=None, + j_kin_scaling_param_name_list=None, ): """ @@ -71,7 +78,10 @@ def __init__( else: self._param_list = j_kin_scaling_param_name_list self._param_arrays = j_kin_scaling_param_axes - if not isinstance(j_kin_scaling_param_axes, list) and j_kin_scaling_param_name_list is not None: + if ( + not isinstance(j_kin_scaling_param_axes, list) + and j_kin_scaling_param_name_list is not None + ): self._param_arrays = [j_kin_scaling_param_axes] self._evaluate_scaling = False self._is_log_m2l_population_level = False @@ -85,7 +95,9 @@ def __init__( self._f_ani_list = [] for scaling_grid in j_kin_scaling_grid_list: self._j_scaling_ifu.append( - ParameterScalingSingleMeasurement(j_kin_scaling_param_axes, scaling_grid) + ParameterScalingSingleMeasurement( + j_kin_scaling_param_axes, scaling_grid + ) ) if isinstance(j_kin_scaling_param_axes, list): @@ -94,22 +106,25 @@ def __init__( self._dim_scaling = 1 def _kwargs2param_array(self, kwargs): - """ - converts dictionary to sorted array in same order as interpolation grid + """Converts dictionary to sorted array in same order as interpolation grid. - :param kwargs: dictionary of all model components, must include the one that are interpolated + :param kwargs: dictionary of all model components, must include the one that are + interpolated :return: sorted list of parameters to interpolate """ param_array = [] for param in self._param_list: if param not in kwargs: - raise ValueError("key %s not in parameters and hence kinematic scaling not possible" % param) + raise ValueError( + "key %s not in parameters and hence kinematic scaling not possible" + % param + ) param_array.append(kwargs.get(param)) return param_array def param_bounds_interpol(self): - """ - minimum and maximum bounds of parameters that are being used to call interpolation function + """Minimum and maximum bounds of parameters that are being used to call + interpolation function. :return: dictionaries of minimum and maximum bounds """ diff --git a/hierarc/Likelihood/lens_sample_likelihood.py b/hierarc/Likelihood/lens_sample_likelihood.py index d168b097..a8e1431d 100644 --- a/hierarc/Likelihood/lens_sample_likelihood.py +++ b/hierarc/Likelihood/lens_sample_likelihood.py @@ -29,11 +29,10 @@ def __init__(self, kwargs_lens_list, normalized=False, kwargs_global_model=None) DSPLikelihood(normalized=normalized, **_kwargs_lens) ) else: - kwargs_lens_ = self._merge_global2local_settings(kwargs_global_model=kwargs_global_model, - kwargs_lens=kwargs_lens) - self._lens_list.append( - LensLikelihood(**kwargs_lens_) + kwargs_lens_ = self._merge_global2local_settings( + kwargs_global_model=kwargs_global_model, kwargs_lens=kwargs_lens ) + self._lens_list.append(LensLikelihood(**kwargs_lens_)) def log_likelihood( self, @@ -91,18 +90,19 @@ def _merge_global2local_settings(kwargs_global_model, kwargs_lens): return {**kwargs_global_model_subset, **kwargs_lens} -_input_param_list = ["anisotropy_model", - "anisotropy_sampling", - "anisotroy_distribution_function", - "los_distributions", - "lambda_mst_distribution", - "gamma_in_sampling", - "gamma_in_distribution", - "log_m2l_sampling", - "log_m2l_distribution", - "alpha_lambda_sampling", - "beta_lambda_sampling", - "alpha_gamma_in_sampling", - "alpha_log_m2l_sampling", - "log_scatter" - ] +_input_param_list = [ + "anisotropy_model", + "anisotropy_sampling", + "anisotroy_distribution_function", + "los_distributions", + "lambda_mst_distribution", + "gamma_in_sampling", + "gamma_in_distribution", + "log_m2l_sampling", + "log_m2l_distribution", + "alpha_lambda_sampling", + "beta_lambda_sampling", + "alpha_gamma_in_sampling", + "alpha_log_m2l_sampling", + "log_scatter", +] diff --git a/hierarc/Sampling/Distributions/anisotropy_distributions.py b/hierarc/Sampling/Distributions/anisotropy_distributions.py index c5f92a0a..1050a1fb 100644 --- a/hierarc/Sampling/Distributions/anisotropy_distributions.py +++ b/hierarc/Sampling/Distributions/anisotropy_distributions.py @@ -2,11 +2,16 @@ class AnisotropyDistribution(object): - """ - class to draw anisotropy parameters from hyperparameter distributions - """ - def __init__(self, anisotropy_model, anisotropy_sampling, - distribution_function, kwargs_anisotropy_min, kwargs_anisotropy_max): + """Class to draw anisotropy parameters from hyperparameter distributions.""" + + def __init__( + self, + anisotropy_model, + anisotropy_sampling, + distribution_function, + kwargs_anisotropy_min, + kwargs_anisotropy_max, + ): """ :param anisotropy_model: string, name of anisotropy model to consider @@ -25,11 +30,15 @@ def __init__(self, anisotropy_model, anisotropy_sampling, kwargs_anisotropy_max = {} self._kwargs_min = kwargs_anisotropy_min self._kwargs_max = kwargs_anisotropy_max - self._a_ani_min, self._a_ani_max = self._kwargs_min.get("a_ani", -np.inf), self._kwargs_max.get("a_ani", np.inf) + self._a_ani_min, self._a_ani_max = self._kwargs_min.get( + "a_ani", -np.inf + ), self._kwargs_max.get("a_ani", np.inf) self._beta_inf_min = self._kwargs_min.get("beta_inf", -np.inf) self._beta_inf_max = self._kwargs_max.get("beta_inf", np.inf) - def draw_anisotropy(self, a_ani=None, a_ani_sigma=0, beta_inf=None, beta_inf_sigma=0): + def draw_anisotropy( + self, a_ani=None, a_ani_sigma=0, beta_inf=None, beta_inf_sigma=0 + ): """Draw Gaussian distribution and re-sample if outside bounds. :param a_ani: mean of the distribution diff --git a/hierarc/Sampling/Distributions/lens_distribution.py b/hierarc/Sampling/Distributions/lens_distribution.py index dd1c2738..0c98b168 100644 --- a/hierarc/Sampling/Distributions/lens_distribution.py +++ b/hierarc/Sampling/Distributions/lens_distribution.py @@ -2,9 +2,7 @@ class LensDistribution(object): - """ - class to draw lens parameters of individual lens from distributions - """ + """Class to draw lens parameters of individual lens from distributions.""" def __init__( self, @@ -74,8 +72,12 @@ def __init__( kwargs_max = {} if kwargs_min is None: kwargs_min = {} - self._gamma_in_min, self._gamma_in_max = kwargs_min.get("gamma_in", -np.inf), kwargs_max.get("gamma_in", np.inf) - self._log_m2l_min, self._log_m2l_max = kwargs_min.get("log_m2l", -np.inf), kwargs_max.get("log_m2l", np.inf) + self._gamma_in_min, self._gamma_in_max = kwargs_min.get( + "gamma_in", -np.inf + ), kwargs_max.get("gamma_in", np.inf) + self._log_m2l_min, self._log_m2l_max = kwargs_min.get( + "log_m2l", -np.inf + ), kwargs_max.get("log_m2l", np.inf) def draw_lens( self, @@ -93,8 +95,7 @@ def draw_lens( log_m2l_sigma=0, alpha_log_m2l=0, ): - """Draws a realization of a specific model from the hyperparameter - distribution. + """Draws a realization of a specific model from the hyperparameter distribution. :param lambda_mst: MST transform :param lambda_mst_sigma: spread in the distribution @@ -124,10 +125,11 @@ def draw_lens( else: lambda_mst_mean_lens = lambda_mst - lambda_lens = (lambda_mst_mean_lens - + alpha_lambda * self._lambda_scaling_property - + beta_lambda * self._lambda_scaling_property_beta - ) + lambda_lens = ( + lambda_mst_mean_lens + + alpha_lambda * self._lambda_scaling_property + + beta_lambda * self._lambda_scaling_property_beta + ) lambda_mst_draw = lambda_lens if self._lambda_mst_sampling: if self._lambda_mst_distribution in ["GAUSSIAN"]: @@ -142,24 +144,28 @@ def draw_lens( "gamma_in parameter is out of bounds of the interpolated range!" ) if self._gamma_in_distribution in ["GAUSSIAN"]: - gamma_in_lens = gamma_in + alpha_gamma_in * self._lambda_scaling_property + gamma_in_lens = ( + gamma_in + alpha_gamma_in * self._lambda_scaling_property + ) else: gamma_in_lens = gamma_in gamma_in_draw = np.random.normal(gamma_in_lens, gamma_in_sigma) if gamma_in_draw < self._gamma_in_min or gamma_in_draw > self._gamma_in_max: - return self.draw_lens(lambda_mst=lambda_mst, - lambda_mst_sigma=lambda_mst_sigma, - gamma_ppn=gamma_ppn, - lambda_ifu=lambda_ifu, - lambda_ifu_sigma=lambda_ifu_sigma, - alpha_lambda=alpha_lambda, - beta_lambda=beta_lambda, - gamma_in=gamma_in, - gamma_in_sigma=gamma_in_sigma, - alpha_gamma_in=alpha_gamma_in, - log_m2l=log_m2l, - log_m2l_sigma=log_m2l_sigma, - alpha_log_m2l=alpha_log_m2l) + return self.draw_lens( + lambda_mst=lambda_mst, + lambda_mst_sigma=lambda_mst_sigma, + gamma_ppn=gamma_ppn, + lambda_ifu=lambda_ifu, + lambda_ifu_sigma=lambda_ifu_sigma, + alpha_lambda=alpha_lambda, + beta_lambda=beta_lambda, + gamma_in=gamma_in, + gamma_in_sigma=gamma_in_sigma, + alpha_gamma_in=alpha_gamma_in, + log_m2l=log_m2l, + log_m2l_sigma=log_m2l_sigma, + alpha_log_m2l=alpha_log_m2l, + ) kwargs_return["gamma_in"] = gamma_in_draw if self._log_m2l_sampling: @@ -172,18 +178,20 @@ def draw_lens( log_m2l_draw = np.random.normal(log_m2l_lens, log_m2l_sigma) if log_m2l_draw < self._log_m2l_min or log_m2l_draw > self._log_m2l_max: - return self.draw_lens(lambda_mst=lambda_mst, - lambda_mst_sigma=lambda_mst_sigma, - gamma_ppn=gamma_ppn, - lambda_ifu=lambda_ifu, - lambda_ifu_sigma=lambda_ifu_sigma, - alpha_lambda=alpha_lambda, - beta_lambda=beta_lambda, - gamma_in=gamma_in, - gamma_in_sigma=gamma_in_sigma, - alpha_gamma_in=alpha_gamma_in, - log_m2l=log_m2l, - log_m2l_sigma=log_m2l_sigma, - alpha_log_m2l=alpha_log_m2l) + return self.draw_lens( + lambda_mst=lambda_mst, + lambda_mst_sigma=lambda_mst_sigma, + gamma_ppn=gamma_ppn, + lambda_ifu=lambda_ifu, + lambda_ifu_sigma=lambda_ifu_sigma, + alpha_lambda=alpha_lambda, + beta_lambda=beta_lambda, + gamma_in=gamma_in, + gamma_in_sigma=gamma_in_sigma, + alpha_gamma_in=alpha_gamma_in, + log_m2l=log_m2l, + log_m2l_sigma=log_m2l_sigma, + alpha_log_m2l=alpha_log_m2l, + ) kwargs_return["log_m2l"] = log_m2l_draw return kwargs_return diff --git a/test/test_LensPosterior/test_kin_constraints_composite.py b/test/test_LensPosterior/test_kin_constraints_composite.py index f99c6168..5b7b7791 100644 --- a/test/test_LensPosterior/test_kin_constraints_composite.py +++ b/test/test_LensPosterior/test_kin_constraints_composite.py @@ -104,9 +104,13 @@ def test_likelihoodconfiguration_om(self): kwargs_likelihood = kin_constraints.hierarchy_configuration(num_sample_model=5) kwargs_likelihood["normalized"] = False - ln_class = LensLikelihood(gamma_in_sampling=True, log_m2l_sampling=True, **kwargs_likelihood) + ln_class = LensLikelihood( + gamma_in_sampling=True, log_m2l_sampling=True, **kwargs_likelihood + ) kwargs_kin = {"a_ani": 1} - ln_class.lens_log_likelihood(cosmo, kwargs_lens={"gamma_in": 2, "log_m2l": 1}, kwargs_kin=kwargs_kin) + ln_class.lens_log_likelihood( + cosmo, kwargs_lens={"gamma_in": 2, "log_m2l": 1}, kwargs_kin=kwargs_kin + ) kwargs_lens_light_test = [{"amp": [1, 1], "sigma": [1, 2]}] lens_light_model_list_test = ["MULTI_GAUSSIAN"] @@ -256,9 +260,13 @@ def test_likelihoodconfiguration_gom(self): kwargs_likelihood = kin_constraints.hierarchy_configuration(num_sample_model=5) kwargs_likelihood["normalized"] = False - ln_class = LensLikelihood(gamma_in_sampling=True, log_m2l_sampling=True, **kwargs_likelihood) + ln_class = LensLikelihood( + gamma_in_sampling=True, log_m2l_sampling=True, **kwargs_likelihood + ) kwargs_kin = {"a_ani": 1, "beta_inf": 0.5} - ln_class.lens_log_likelihood(cosmo, kwargs_lens={"gamma_in": 2, "log_m2l": 1}, kwargs_kin=kwargs_kin) + ln_class.lens_log_likelihood( + cosmo, kwargs_lens={"gamma_in": 2, "log_m2l": 1}, kwargs_kin=kwargs_kin + ) class TestKinConstraintsCompositeM2l(object): @@ -360,9 +368,13 @@ def test_likelihoodconfiguration_om(self): kwargs_likelihood = kin_constraints.hierarchy_configuration(num_sample_model=5) kwargs_likelihood["normalized"] = False - ln_class = LensLikelihood(gamma_in_sampling=True, log_m2l_sampling=False, **kwargs_likelihood) + ln_class = LensLikelihood( + gamma_in_sampling=True, log_m2l_sampling=False, **kwargs_likelihood + ) kwargs_kin = {"a_ani": 1} - ln_class.lens_log_likelihood(cosmo, kwargs_lens={"gamma_in": 2, "log_m2l": 0}, kwargs_kin=kwargs_kin) + ln_class.lens_log_likelihood( + cosmo, kwargs_lens={"gamma_in": 2, "log_m2l": 0}, kwargs_kin=kwargs_kin + ) def test_likelihoodconfiguration_gom(self): anisotropy_model = "GOM" @@ -457,7 +469,9 @@ def test_likelihoodconfiguration_gom(self): kwargs_likelihood["normalized"] = False ln_class = LensLikelihood(gamma_in_sampling=True, **kwargs_likelihood) kwargs_kin = {"a_ani": 1, "beta_inf": 0.5} - ln_class.lens_log_likelihood(cosmo, kwargs_lens={"gamma_in": 2}, kwargs_kin=kwargs_kin) + ln_class.lens_log_likelihood( + cosmo, kwargs_lens={"gamma_in": 2}, kwargs_kin=kwargs_kin + ) class TestRaise(unittest.TestCase): diff --git a/test/test_Likelihood/test_cosmo_likelihood.py b/test/test_Likelihood/test_cosmo_likelihood.py index aa863637..fcbd2fc9 100644 --- a/test/test_Likelihood/test_cosmo_likelihood.py +++ b/test/test_Likelihood/test_cosmo_likelihood.py @@ -57,11 +57,13 @@ def setup_method(self): "kwargs_lower_cosmo": kwargs_lower_cosmo, "kwargs_upper_cosmo": kwargs_upper_cosmo, } - self.kwargs_model = {"ppn_sampling": False, - "lambda_mst_sampling": False, - "lambda_mst_distribution": "delta", - "anisotropy_sampling": False, - "anisotropy_model": "OM",} + self.kwargs_model = { + "ppn_sampling": False, + "lambda_mst_sampling": False, + "lambda_mst_distribution": "delta", + "anisotropy_sampling": False, + "anisotropy_model": "OM", + } # self.kwargs_likelihood_list = [{'z_lens': self.z_L, 'z_source': self.z_S, 'likelihood_type': 'TDKinKDE', # 'dd_sample': self.dd_samples, 'ddt_sample': self.ddt_samples, @@ -79,7 +81,9 @@ def test_log_likelihood(self): cosmo_fixed=None, ) - def custom_prior(kwargs_cosmo, kwargs_lens, kwargs_kin, kwargs_source, kwargs_los): + def custom_prior( + kwargs_cosmo, kwargs_lens, kwargs_kin, kwargs_source, kwargs_los + ): return -1 cosmoL_prior = CosmoLikelihood( @@ -241,8 +245,12 @@ def test_kde_likelihood_integration(self): self.cosmology, rescale=True, ) - cosmoL = CosmoLikelihood([], "FLCDM", self.kwargs_model, - self.kwargs_bounds, KDE_likelihood_chain=chain + cosmoL = CosmoLikelihood( + [], + "FLCDM", + self.kwargs_model, + self.kwargs_bounds, + KDE_likelihood_chain=chain, ) kwargs_cosmo = {"h0": self.H0_true, "om": self.omega_m_true, "ok": 0} args = cosmoL.param.kwargs2args(kwargs_cosmo=kwargs_cosmo) diff --git a/test/test_Likelihood/test_hierarchy_likelihood.py b/test/test_Likelihood/test_hierarchy_likelihood.py index f17c828a..f89e8a2d 100644 --- a/test/test_Likelihood/test_hierarchy_likelihood.py +++ b/test/test_Likelihood/test_hierarchy_likelihood.py @@ -24,16 +24,16 @@ def setup_method(self): "dd_mean": dd, "dd_sigma": dd / 10, } - kwargs_model = {"anisotropy_model": "OM", - "anisotropy_sampling": True, - "anisotroy_distribution_function": "GAUSSIAN", - "lambda_mst_distribution": "GAUSSIAN", - } + kwargs_model = { + "anisotropy_model": "OM", + "anisotropy_sampling": True, + "anisotroy_distribution_function": "GAUSSIAN", + "lambda_mst_distribution": "GAUSSIAN", + } # "gamma_in_sampling" = False, - gamma_in_distribution = "NONE", - log_m2l_sampling = False, - log_m2l_distribution = "NONE", - + gamma_in_distribution = ("NONE",) + log_m2l_sampling = (False,) + log_m2l_distribution = ("NONE",) self.likelihood = LensLikelihood( z_lens, @@ -134,7 +134,9 @@ def setup_method(self): **kwargs_model ) - param_scaling_array = np.outer(np.ones_like(gamma_in_array), np.ones_like(log_m2l_array)) + param_scaling_array = np.outer( + np.ones_like(gamma_in_array), np.ones_like(log_m2l_array) + ) j_kin_scaling_param_axes = [gamma_in_array, log_m2l_array] @@ -239,7 +241,6 @@ def test_lens_log_likelihood(self): kwargs_test = self.likelihood._kwargs_init(kwargs=None) assert type(kwargs_test) is dict - kwargs_lens = { "gamma_in": 1, "gamma_in_sigma": 0, @@ -276,11 +277,11 @@ def test_lens_log_likelihood(self): dds = self.cosmo.angular_diameter_distance_z1z2(z1=z_lens, z2=z_source).value ddt = (1.0 + z_lens) * dd * ds / dds - #ln_likelihood = self.likelihood_gamma_in_fail_case.log_likelihood_single( + # ln_likelihood = self.likelihood_gamma_in_fail_case.log_likelihood_single( # ddt, dd, delta_lum_dist, kwargs_lens, kwargs_kin, kwargs_source, kwargs_los - #) + # ) - #assert ln_likelihood < -10000000 + # assert ln_likelihood < -10000000 if __name__ == "__main__": diff --git a/test/test_Likelihood/test_kin_scaling.py b/test/test_Likelihood/test_kin_scaling.py index f66aa32f..f1201660 100644 --- a/test/test_Likelihood/test_kin_scaling.py +++ b/test/test_Likelihood/test_kin_scaling.py @@ -11,9 +11,11 @@ def test_single_param(self): param_arrays = np.linspace(0, 1, 11) scaling_grid_list = [param_arrays**2] param_list = ["a"] - kin_scaling = KinScaling(j_kin_scaling_param_axes=param_arrays, - j_kin_scaling_grid_list=scaling_grid_list, - j_kin_scaling_param_name_list=param_list) + kin_scaling = KinScaling( + j_kin_scaling_param_axes=param_arrays, + j_kin_scaling_grid_list=scaling_grid_list, + j_kin_scaling_param_name_list=param_list, + ) kwargs_param = {"a": 0.5} j_scaling = kin_scaling.kin_scaling(kwargs_param=kwargs_param) npt.assert_almost_equal(j_scaling, 0.5**2, decimal=2) @@ -21,14 +23,16 @@ def test_single_param(self): assert kwargs_min["a"] == 0 param_arrays = np.linspace(0, 1, 11) - scaling_grid_list = [param_arrays ** 2] + scaling_grid_list = [param_arrays**2] param_list = ["a"] - kin_scaling = KinScaling(j_kin_scaling_param_axes=[param_arrays], - j_kin_scaling_grid_list=scaling_grid_list, - j_kin_scaling_param_name_list=param_list) + kin_scaling = KinScaling( + j_kin_scaling_param_axes=[param_arrays], + j_kin_scaling_grid_list=scaling_grid_list, + j_kin_scaling_param_name_list=param_list, + ) kwargs_param = {"a": 0.5} j_scaling = kin_scaling.kin_scaling(kwargs_param=kwargs_param) - npt.assert_almost_equal(j_scaling, 0.5 ** 2, decimal=2) + npt.assert_almost_equal(j_scaling, 0.5**2, decimal=2) kwargs_min, kwargs_max = kin_scaling.param_bounds_interpol() assert kwargs_min["a"] == 0 @@ -41,9 +45,11 @@ def test_two_parameters(self): assert shape_scaling[1] == 21 # assert 1 == 0 param_list = ["a", "b"] - kin_scaling = KinScaling(j_kin_scaling_param_axes=param_arrays, - j_kin_scaling_grid_list=scaling_grid_list, - j_kin_scaling_param_name_list=param_list) + kin_scaling = KinScaling( + j_kin_scaling_param_axes=param_arrays, + j_kin_scaling_grid_list=scaling_grid_list, + j_kin_scaling_param_name_list=param_list, + ) kwargs_param = {"a": 0.5, "b": 0.3} j_scaling = kin_scaling.kin_scaling(kwargs_param=kwargs_param) print(j_scaling) @@ -59,9 +65,11 @@ def test__kwargs2param_array(self): scaling_grid_list = [xy * uv, xy, uv] param_list = ["a", "b"] - kin_scaling = KinScaling(j_kin_scaling_param_axes=param_arrays, - j_kin_scaling_grid_list=scaling_grid_list, - j_kin_scaling_param_name_list=param_list) + kin_scaling = KinScaling( + j_kin_scaling_param_axes=param_arrays, + j_kin_scaling_grid_list=scaling_grid_list, + j_kin_scaling_param_name_list=param_list, + ) kwargs_param = {"a": 0.5, "b": 0.3} param_array = kin_scaling._kwargs2param_array(kwargs_param) assert param_array[0] == kwargs_param["a"] @@ -73,11 +81,16 @@ def test__kwargs2param_array(self): assert kwargs_max["a"] == 1 def test_empty(self): - kin_scaling = KinScaling(j_kin_scaling_param_axes=None, j_kin_scaling_grid_list=None, j_kin_scaling_param_name_list=None) + kin_scaling = KinScaling( + j_kin_scaling_param_axes=None, + j_kin_scaling_grid_list=None, + j_kin_scaling_param_name_list=None, + ) output = kin_scaling.kin_scaling(kwargs_param=None) assert output == 1 kwargs_min, kwargs_max = kin_scaling.param_bounds_interpol() + class TestParameterScalingSingleAperture(object): def setup_method(self): ani_param_array = np.linspace(start=0, stop=1, num=10) @@ -91,7 +104,7 @@ def setup_method(self): np.linspace(start=1, stop=2, num=5), ] param_scaling_array = np.outer(ani_param_array[0], ani_param_array[1]) - print(np.shape(param_scaling_array), 'test shape') + print(np.shape(param_scaling_array), "test shape") self.scaling_2d = ParameterScalingSingleMeasurement( ani_param_array, param_scaling_array ) @@ -153,8 +166,9 @@ def setup_method(self): ani_param_array = np.linspace(start=0, stop=1, num=10) param_scaling_array = ani_param_array * 2 self.scaling = KinScaling( - j_kin_scaling_param_axes=ani_param_array, j_kin_scaling_grid_list=[param_scaling_array], - j_kin_scaling_param_name_list=["a"] + j_kin_scaling_param_axes=ani_param_array, + j_kin_scaling_grid_list=[param_scaling_array], + j_kin_scaling_param_name_list=["a"], ) ani_param_array = [ @@ -162,10 +176,11 @@ def setup_method(self): np.linspace(start=1, stop=2, num=5), ] param_scaling_array = np.outer(ani_param_array[0], ani_param_array[1]) - self.scaling_2d = KinScaling(j_kin_scaling_param_axes=ani_param_array, - j_kin_scaling_grid_list=[param_scaling_array], - j_kin_scaling_param_name_list=["a", "b"] - ) + self.scaling_2d = KinScaling( + j_kin_scaling_param_axes=ani_param_array, + j_kin_scaling_grid_list=[param_scaling_array], + j_kin_scaling_param_name_list=["a", "b"], + ) ani_param_array = np.linspace(start=0, stop=1, num=10) gamma_in_array = np.linspace(start=0.1, stop=2.9, num=5) @@ -176,11 +191,11 @@ def setup_method(self): ani_param_array, np.outer(gamma_in_array, log_m2l_array), ) - self.scaling_nfw = KinScaling(j_kin_scaling_param_axes=param_arrays, - j_kin_scaling_grid_list=[param_scaling_array], - j_kin_scaling_param_name_list=["a", "b", "c"] - ) - + self.scaling_nfw = KinScaling( + j_kin_scaling_param_axes=param_arrays, + j_kin_scaling_grid_list=[param_scaling_array], + j_kin_scaling_param_name_list=["a", "b", "c"], + ) gom_param_array = [ np.linspace(start=0, stop=1, num=10), @@ -199,21 +214,22 @@ def setup_method(self): np.outer(gamma_in_array, log_m2l_array), ), ) - self.scaling_nfw_2d = KinScaling(j_kin_scaling_param_axes=param_arrays, - j_kin_scaling_grid_list=[param_scaling_array], - j_kin_scaling_param_name_list=["a", "b", "c", "d"] - ) - + self.scaling_nfw_2d = KinScaling( + j_kin_scaling_param_axes=param_arrays, + j_kin_scaling_grid_list=[param_scaling_array], + j_kin_scaling_param_name_list=["a", "b", "c", "d"], + ) param_arrays = [ani_param_array, gamma_in_array] param_scaling_array = np.multiply.outer( ani_param_array, gamma_in_array, ) - self.scaling_nfw_no_m2l = KinScaling(j_kin_scaling_param_axes=param_arrays, - j_kin_scaling_grid_list=[param_scaling_array], - j_kin_scaling_param_name_list=["a", "b"] - ) + self.scaling_nfw_no_m2l = KinScaling( + j_kin_scaling_param_axes=param_arrays, + j_kin_scaling_grid_list=[param_scaling_array], + j_kin_scaling_param_name_list=["a", "b"], + ) gom_param_array = [ np.linspace(start=0, stop=1, num=10), @@ -231,17 +247,18 @@ def setup_method(self): gamma_in_array, ), ) - self.scaling_nfw_2d_no_m2l = KinScaling(j_kin_scaling_param_axes=param_arrays, - j_kin_scaling_grid_list=[param_scaling_array], - j_kin_scaling_param_name_list=["a", "b", "c"] - ) + self.scaling_nfw_2d_no_m2l = KinScaling( + j_kin_scaling_param_axes=param_arrays, + j_kin_scaling_grid_list=[param_scaling_array], + j_kin_scaling_param_name_list=["a", "b", "c"], + ) def test_kin_scaling(self): scaling = self.scaling.kin_scaling(kwargs_param=None) assert scaling[0] == 1 - scaling = self.scaling.kin_scaling(kwargs_param={"a":1}) + scaling = self.scaling.kin_scaling(kwargs_param={"a": 1}) assert scaling[0] == 2 kwargs_param = {"a": 1, "b": 2} @@ -252,7 +269,7 @@ def test_kin_scaling(self): scaling = self.scaling_nfw.kin_scaling(kwargs_param=kwargs_param) assert scaling[0] == 1 * 2.9 * 0.5 - kwargs_param = {"a": 1, "b": 2., "c": 2.9, "d": 0.5} + kwargs_param = {"a": 1, "b": 2.0, "c": 2.9, "d": 0.5} scaling = self.scaling_nfw_2d.kin_scaling(kwargs_param=kwargs_param) assert scaling[0] == 1 * 2 * 2.9 * 0.5 diff --git a/test/test_Sampling/test_Distributions/test_anisotropy_distribution.py b/test/test_Sampling/test_Distributions/test_anisotropy_distribution.py index 6dd65ce8..55b954f5 100644 --- a/test/test_Sampling/test_Distributions/test_anisotropy_distribution.py +++ b/test/test_Sampling/test_Distributions/test_anisotropy_distribution.py @@ -1,4 +1,6 @@ -from hierarc.Sampling.Distributions.anisotropy_distributions import AnisotropyDistribution +from hierarc.Sampling.Distributions.anisotropy_distributions import ( + AnisotropyDistribution, +) class TestAnisotropyDistribution(object): @@ -9,28 +11,39 @@ def setup_method(self): kwargs_anisotropy_min = {"a_ani": 0, "beta_inf": 0.1} kwargs_anisotropy_max = {"a_ani": 5, "beta_inf": 1} - self._ani_dist = AnisotropyDistribution(anisotropy_model=anisotropy_model, - anisotropy_sampling=True, - distribution_function=distribution_function, - kwargs_anisotropy_min=kwargs_anisotropy_min, - kwargs_anisotropy_max=kwargs_anisotropy_max) + self._ani_dist = AnisotropyDistribution( + anisotropy_model=anisotropy_model, + anisotropy_sampling=True, + distribution_function=distribution_function, + kwargs_anisotropy_min=kwargs_anisotropy_min, + kwargs_anisotropy_max=kwargs_anisotropy_max, + ) - ani_dist = AnisotropyDistribution(anisotropy_model=anisotropy_model, - anisotropy_sampling=False, - distribution_function=distribution_function, - kwargs_anisotropy_min=kwargs_anisotropy_min, - kwargs_anisotropy_max=kwargs_anisotropy_max) + ani_dist = AnisotropyDistribution( + anisotropy_model=anisotropy_model, + anisotropy_sampling=False, + distribution_function=distribution_function, + kwargs_anisotropy_min=kwargs_anisotropy_min, + kwargs_anisotropy_max=kwargs_anisotropy_max, + ) def test_draw_anisotropy(self): - kwargs_anisotropy = {"a_ani": 1, "beta_inf": 0.8, "a_ani_sigma": 0.1, "beta_inf_sigma": 0.2} + kwargs_anisotropy = { + "a_ani": 1, + "beta_inf": 0.8, + "a_ani_sigma": 0.1, + "beta_inf_sigma": 0.2, + } kwargs_drawn = self._ani_dist.draw_anisotropy(**kwargs_anisotropy) assert "a_ani" in kwargs_drawn assert "beta_inf" in kwargs_drawn - ani_dist = AnisotropyDistribution(anisotropy_model="NONE", - anisotropy_sampling=False, - distribution_function="NONE", - kwargs_anisotropy_min=None, - kwargs_anisotropy_max=None) + ani_dist = AnisotropyDistribution( + anisotropy_model="NONE", + anisotropy_sampling=False, + distribution_function="NONE", + kwargs_anisotropy_min=None, + kwargs_anisotropy_max=None, + ) kwargs_drawn = ani_dist.draw_anisotropy() assert "a_ani" not in kwargs_drawn diff --git a/test/test_Sampling/test_Distributions/test_lens_distribution.py b/test/test_Sampling/test_Distributions/test_lens_distribution.py index 6f71712f..f5a30a27 100644 --- a/test/test_Sampling/test_Distributions/test_lens_distribution.py +++ b/test/test_Sampling/test_Distributions/test_lens_distribution.py @@ -6,35 +6,39 @@ class TestLensDistribution(object): def setup_method(self): - self.kwargs_sampling = {"lambda_mst_distribution": "GAUSSIAN", - "gamma_in_sampling": True, - "gamma_in_distribution": "GAUSSIAN", - "log_m2l_sampling": True, - "log_m2l_distribution" : "GAUSSIAN", - "alpha_lambda_sampling": True, - "beta_lambda_sampling": True, - "alpha_gamma_in_sampling": True, - "alpha_log_m2l_sampling": True, - "log_scatter": False, # change for different tests - "mst_ifu": False, # change for different tests - "lambda_scaling_property": 0.1, - "lambda_scaling_property_beta": 0.2, - "kwargs_min": {"gamma_in": 0, "log_m2l": -3}, - "kwargs_max": {"gamma_in": 3, "log_m2l": 3}} - - self.kwargs_lens = {"lambda_mst": 1.1, - "lambda_mst_sigma": 0.1, - "gamma_ppn": 0.9, - "lambda_ifu": 0.5, - "lambda_ifu_sigma": 0.2, - "alpha_lambda": -0.2, - "beta_lambda": 0.3, - "gamma_in": 1.5, - "gamma_in_sigma": 0.2, - "alpha_gamma_in": 0.2, - "log_m2l": 0.6, - "log_m2l_sigma": 0.2, - "alpha_log_m2l": -0.1} + self.kwargs_sampling = { + "lambda_mst_distribution": "GAUSSIAN", + "gamma_in_sampling": True, + "gamma_in_distribution": "GAUSSIAN", + "log_m2l_sampling": True, + "log_m2l_distribution": "GAUSSIAN", + "alpha_lambda_sampling": True, + "beta_lambda_sampling": True, + "alpha_gamma_in_sampling": True, + "alpha_log_m2l_sampling": True, + "log_scatter": False, # change for different tests + "mst_ifu": False, # change for different tests + "lambda_scaling_property": 0.1, + "lambda_scaling_property_beta": 0.2, + "kwargs_min": {"gamma_in": 0, "log_m2l": -3}, + "kwargs_max": {"gamma_in": 3, "log_m2l": 3}, + } + + self.kwargs_lens = { + "lambda_mst": 1.1, + "lambda_mst_sigma": 0.1, + "gamma_ppn": 0.9, + "lambda_ifu": 0.5, + "lambda_ifu_sigma": 0.2, + "alpha_lambda": -0.2, + "beta_lambda": 0.3, + "gamma_in": 1.5, + "gamma_in_sigma": 0.2, + "alpha_gamma_in": 0.2, + "log_m2l": 0.6, + "log_m2l_sigma": 0.2, + "alpha_log_m2l": -0.1, + } def test_draw_lens(self): lens_dist = LensDistribution(**self.kwargs_sampling) diff --git a/test/test_Sampling/test_mcmc_sampling.py b/test/test_Sampling/test_mcmc_sampling.py index e27550ec..22287009 100644 --- a/test/test_Sampling/test_mcmc_sampling.py +++ b/test/test_Sampling/test_mcmc_sampling.py @@ -67,13 +67,13 @@ def test_mcmc_emcee(self): backend = emcee.backends.HDFBackend(backup_filename) kwargs_emcee = {"backend": backend} - kwargs_model = {"ppn_sampling": False, - "lambda_mst_sampling": False, - "lambda_mst_distribution": "delta", - "anisotropy_sampling": False, - "anisotropy_model": "OM", - - } + kwargs_model = { + "ppn_sampling": False, + "lambda_mst_sampling": False, + "lambda_mst_distribution": "delta", + "anisotropy_sampling": False, + "anisotropy_model": "OM", + } mcmc_sampler = MCMCSampler( kwargs_likelihood_list=kwargs_likelihood_list, From be0329780fd068c94c04cabe974944dcdc11b5f6 Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Thu, 27 Jun 2024 14:05:53 -0400 Subject: [PATCH 13/62] Update setup.py update for new version --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 05112d7b..56003942 100644 --- a/setup.py +++ b/setup.py @@ -64,7 +64,7 @@ def run_tests(self): test_suite="test", tests_require=test_requirements, url="https://github.com/sibirrer/hierarc", - version="1.1.2", + version="1.1.3", zip_safe=False, cmdclass={"test": PyTest}, ) From e55fa33ee9f67bc6bcd9464cbaeb8cb15dc8eed1 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 27 Jun 2024 18:06:13 +0000 Subject: [PATCH 14/62] [pre-commit.ci] auto fixes from pre-commit.com hooks --- test/test_Likelihood/test_cosmo_likelihood.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/test/test_Likelihood/test_cosmo_likelihood.py b/test/test_Likelihood/test_cosmo_likelihood.py index 6035cbae..5b154245 100644 --- a/test/test_Likelihood/test_cosmo_likelihood.py +++ b/test/test_Likelihood/test_cosmo_likelihood.py @@ -78,7 +78,9 @@ def test_log_likelihood(self): cosmo_fixed=None, ) - def custom_prior(kwargs_cosmo, kwargs_lens, kwargs_kin, kwargs_source, kwargs_los): + def custom_prior( + kwargs_cosmo, kwargs_lens, kwargs_kin, kwargs_source, kwargs_los + ): return -1 cosmoL_prior = CosmoLikelihood( From 87f81f3e50ab7c2bc1e8c958d611ec4b1800f52a Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Thu, 27 Jun 2024 14:06:26 -0400 Subject: [PATCH 15/62] Update __init__.py --- hierarc/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/hierarc/__init__.py b/hierarc/__init__.py index e0f2203e..679c5c7f 100644 --- a/hierarc/__init__.py +++ b/hierarc/__init__.py @@ -2,4 +2,4 @@ __author__ = """Simon Birrer""" __email__ = "sibirrer@gmail.com" -__version__ = "1.1.2" +__version__ = "1.1.3" From b07cf43598ac5f52884a905314981ea77f4b0a0d Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Thu, 27 Jun 2024 14:07:25 -0400 Subject: [PATCH 16/62] Update HISTORY.rst --- HISTORY.rst | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/HISTORY.rst b/HISTORY.rst index ba4f73f4..e4a299f2 100644 --- a/HISTORY.rst +++ b/HISTORY.rst @@ -28,3 +28,8 @@ History * double source plane likelihood * Pantheon+ likelihood * improved API + +1.1.3 (2024-06-27) +------------------ + +* composite model likelihood and fitting From 58d9bd4a1ded80cd6455a79ab5581d9ac00bcb14 Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Thu, 27 Jun 2024 14:29:48 -0400 Subject: [PATCH 17/62] minor change in plotting if there is only a single lens --- hierarc/Diagnostics/goodness_of_fit.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/hierarc/Diagnostics/goodness_of_fit.py b/hierarc/Diagnostics/goodness_of_fit.py index c65158d0..79c0b01a 100644 --- a/hierarc/Diagnostics/goodness_of_fit.py +++ b/hierarc/Diagnostics/goodness_of_fit.py @@ -222,7 +222,7 @@ def plot_kin_fit( sigma_v_model_error_list, ) = self.kin_fit(cosmo, kwargs_lens, kwargs_kin, kwargs_los) - f, ax = plt.subplots(1, 1, figsize=(int(len(sigma_v_name_list) / 2), 4)) + f, ax = plt.subplots(1, 1, figsize=(max(int(len(sigma_v_name_list) / 2), 1), 4)) ax.errorbar( np.arange(len(sigma_v_name_list)), sigma_v_measurement_list, From c0ed4a6578cc3b10c29b688e08c3e2bf24475c5c Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Thu, 27 Jun 2024 14:44:49 -0400 Subject: [PATCH 18/62] improved tests in lens distribution draws --- .../test_lens_distribution.py | 34 ++++++++++++++----- 1 file changed, 26 insertions(+), 8 deletions(-) diff --git a/test/test_Sampling/test_Distributions/test_lens_distribution.py b/test/test_Sampling/test_Distributions/test_lens_distribution.py index 6f71712f..f1442ca6 100644 --- a/test/test_Sampling/test_Distributions/test_lens_distribution.py +++ b/test/test_Sampling/test_Distributions/test_lens_distribution.py @@ -1,4 +1,5 @@ import copy +import numpy.testing as npt from hierarc.Sampling.Distributions.lens_distribution import LensDistribution @@ -6,11 +7,13 @@ class TestLensDistribution(object): def setup_method(self): - self.kwargs_sampling = {"lambda_mst_distribution": "GAUSSIAN", + self.kwargs_sampling = { + "lambda_mst_sampling": True, + "lambda_mst_distribution": "GAUSSIAN", "gamma_in_sampling": True, "gamma_in_distribution": "GAUSSIAN", "log_m2l_sampling": True, - "log_m2l_distribution" : "GAUSSIAN", + "log_m2l_distribution": "GAUSSIAN", "alpha_lambda_sampling": True, "beta_lambda_sampling": True, "alpha_gamma_in_sampling": True, @@ -19,8 +22,8 @@ def setup_method(self): "mst_ifu": False, # change for different tests "lambda_scaling_property": 0.1, "lambda_scaling_property_beta": 0.2, - "kwargs_min": {"gamma_in": 0, "log_m2l": -3}, - "kwargs_max": {"gamma_in": 3, "log_m2l": 3}} + "kwargs_min": {"gamma_in": 1, "log_m2l": 0}, + "kwargs_max": {"gamma_in": 2, "log_m2l": 1}} self.kwargs_lens = {"lambda_mst": 1.1, "lambda_mst_sigma": 0.1, @@ -30,10 +33,10 @@ def setup_method(self): "alpha_lambda": -0.2, "beta_lambda": 0.3, "gamma_in": 1.5, - "gamma_in_sigma": 0.2, + "gamma_in_sigma": 1, "alpha_gamma_in": 0.2, "log_m2l": 0.6, - "log_m2l_sigma": 0.2, + "log_m2l_sigma": 1, "alpha_log_m2l": -0.1} def test_draw_lens(self): @@ -46,6 +49,21 @@ def test_draw_lens(self): kwargs_sampling["log_scatter"] = True kwargs_sampling["lambda_ifu"] = True lens_dist = LensDistribution(kwargs_sampling) - kwargs_return = lens_dist.draw_lens(**self.kwargs_lens) + for i in range(100): + kwargs_return = lens_dist.draw_lens(**self.kwargs_lens) - assert "lambda_mst" in kwargs_return + assert "lambda_mst" in kwargs_return + + def test_raises(self): + + with npt.assert_raises(ValueError): + lens_dist = LensDistribution(**self.kwargs_sampling) + kwargs_lens = copy.deepcopy(self.kwargs_lens) + kwargs_lens["gamma_in"] = -10 + kwargs_return = lens_dist.draw_lens(**kwargs_lens) + + with npt.assert_raises(ValueError): + lens_dist = LensDistribution(**self.kwargs_sampling) + kwargs_lens = copy.deepcopy(self.kwargs_lens) + kwargs_lens["log_m2l"] = -100 + kwargs_return = lens_dist.draw_lens(**kwargs_lens) From 567b0d458364777eb9d983611c559179fe870447 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 27 Jun 2024 18:45:59 +0000 Subject: [PATCH 19/62] [pre-commit.ci] auto fixes from pre-commit.com hooks --- .../test_lens_distribution.py | 61 ++++++++++--------- 1 file changed, 32 insertions(+), 29 deletions(-) diff --git a/test/test_Sampling/test_Distributions/test_lens_distribution.py b/test/test_Sampling/test_Distributions/test_lens_distribution.py index f1442ca6..bb9513aa 100644 --- a/test/test_Sampling/test_Distributions/test_lens_distribution.py +++ b/test/test_Sampling/test_Distributions/test_lens_distribution.py @@ -8,36 +8,39 @@ class TestLensDistribution(object): def setup_method(self): self.kwargs_sampling = { - "lambda_mst_sampling": True, - "lambda_mst_distribution": "GAUSSIAN", - "gamma_in_sampling": True, - "gamma_in_distribution": "GAUSSIAN", - "log_m2l_sampling": True, - "log_m2l_distribution": "GAUSSIAN", - "alpha_lambda_sampling": True, - "beta_lambda_sampling": True, - "alpha_gamma_in_sampling": True, - "alpha_log_m2l_sampling": True, - "log_scatter": False, # change for different tests - "mst_ifu": False, # change for different tests - "lambda_scaling_property": 0.1, - "lambda_scaling_property_beta": 0.2, - "kwargs_min": {"gamma_in": 1, "log_m2l": 0}, - "kwargs_max": {"gamma_in": 2, "log_m2l": 1}} + "lambda_mst_sampling": True, + "lambda_mst_distribution": "GAUSSIAN", + "gamma_in_sampling": True, + "gamma_in_distribution": "GAUSSIAN", + "log_m2l_sampling": True, + "log_m2l_distribution": "GAUSSIAN", + "alpha_lambda_sampling": True, + "beta_lambda_sampling": True, + "alpha_gamma_in_sampling": True, + "alpha_log_m2l_sampling": True, + "log_scatter": False, # change for different tests + "mst_ifu": False, # change for different tests + "lambda_scaling_property": 0.1, + "lambda_scaling_property_beta": 0.2, + "kwargs_min": {"gamma_in": 1, "log_m2l": 0}, + "kwargs_max": {"gamma_in": 2, "log_m2l": 1}, + } - self.kwargs_lens = {"lambda_mst": 1.1, - "lambda_mst_sigma": 0.1, - "gamma_ppn": 0.9, - "lambda_ifu": 0.5, - "lambda_ifu_sigma": 0.2, - "alpha_lambda": -0.2, - "beta_lambda": 0.3, - "gamma_in": 1.5, - "gamma_in_sigma": 1, - "alpha_gamma_in": 0.2, - "log_m2l": 0.6, - "log_m2l_sigma": 1, - "alpha_log_m2l": -0.1} + self.kwargs_lens = { + "lambda_mst": 1.1, + "lambda_mst_sigma": 0.1, + "gamma_ppn": 0.9, + "lambda_ifu": 0.5, + "lambda_ifu_sigma": 0.2, + "alpha_lambda": -0.2, + "beta_lambda": 0.3, + "gamma_in": 1.5, + "gamma_in_sigma": 1, + "alpha_gamma_in": 0.2, + "log_m2l": 0.6, + "log_m2l_sigma": 1, + "alpha_log_m2l": -0.1, + } def test_draw_lens(self): lens_dist = LensDistribution(**self.kwargs_sampling) From caa13ded9678e8b290e67a028f2cbcdbfde4b24b Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Thu, 27 Jun 2024 21:50:29 -0400 Subject: [PATCH 20/62] improve testing and stability --- .../Distributions/anisotropy_distributions.py | 2 +- .../test_anisotropy_distribution.py | 42 +++++++++++++++++++ 2 files changed, 43 insertions(+), 1 deletion(-) diff --git a/hierarc/Sampling/Distributions/anisotropy_distributions.py b/hierarc/Sampling/Distributions/anisotropy_distributions.py index 1050a1fb..0b66627b 100644 --- a/hierarc/Sampling/Distributions/anisotropy_distributions.py +++ b/hierarc/Sampling/Distributions/anisotropy_distributions.py @@ -66,7 +66,7 @@ def draw_anisotropy( else: a_ani_draw = np.random.normal(a_ani, a_ani_sigma) if a_ani_draw < self._a_ani_min or a_ani_draw > self._a_ani_max: - return self.draw_anisotropy(a_ani, a_ani_sigma) + return self.draw_anisotropy(a_ani, a_ani_sigma, beta_inf, beta_inf_sigma) kwargs_return["a_ani"] = a_ani_draw else: kwargs_return["a_ani"] = a_ani diff --git a/test/test_Sampling/test_Distributions/test_anisotropy_distribution.py b/test/test_Sampling/test_Distributions/test_anisotropy_distribution.py index 55b954f5..70e9324e 100644 --- a/test/test_Sampling/test_Distributions/test_anisotropy_distribution.py +++ b/test/test_Sampling/test_Distributions/test_anisotropy_distribution.py @@ -1,3 +1,4 @@ +import numpy.testing as npt from hierarc.Sampling.Distributions.anisotropy_distributions import ( AnisotropyDistribution, ) @@ -47,3 +48,44 @@ def test_draw_anisotropy(self): ) kwargs_drawn = ani_dist.draw_anisotropy() assert "a_ani" not in kwargs_drawn + + ani_dist = AnisotropyDistribution( + anisotropy_model="GOM", + anisotropy_sampling=True, + distribution_function="NONE", + kwargs_anisotropy_min=None, + kwargs_anisotropy_max=None, + ) + kwargs_drawn = ani_dist.draw_anisotropy(a_ani=1, beta_inf=0.9) + assert kwargs_drawn["a_ani"] == 1 + assert kwargs_drawn["beta_inf"] == 0.9 + + kwargs_anisotropy = { + "a_ani": 1, + "beta_inf": 0.8, + "a_ani_sigma": 2, + "beta_inf_sigma": 2, + } + + for i in range(100): + kwargs_drawn = self._ani_dist.draw_anisotropy(**kwargs_anisotropy) + + def test_raises(self): + + with npt.assert_raises(ValueError): + kwargs_anisotropy = { + "a_ani": -1, + "beta_inf": 0.8, + "a_ani_sigma": 0.1, + "beta_inf_sigma": 0.2, + } + kwargs_drawn = self._ani_dist.draw_anisotropy(**kwargs_anisotropy) + + with npt.assert_raises(ValueError): + kwargs_anisotropy = { + "a_ani": 1, + "beta_inf": -1, + "a_ani_sigma": 0.1, + "beta_inf_sigma": 0.2, + } + kwargs_drawn = self._ani_dist.draw_anisotropy(**kwargs_anisotropy) From f5c5b13bd7abacf2917b98fc80d1d8897d20b848 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 28 Jun 2024 01:50:42 +0000 Subject: [PATCH 21/62] [pre-commit.ci] auto fixes from pre-commit.com hooks --- hierarc/Sampling/Distributions/anisotropy_distributions.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/hierarc/Sampling/Distributions/anisotropy_distributions.py b/hierarc/Sampling/Distributions/anisotropy_distributions.py index 0b66627b..231c9f76 100644 --- a/hierarc/Sampling/Distributions/anisotropy_distributions.py +++ b/hierarc/Sampling/Distributions/anisotropy_distributions.py @@ -66,7 +66,9 @@ def draw_anisotropy( else: a_ani_draw = np.random.normal(a_ani, a_ani_sigma) if a_ani_draw < self._a_ani_min or a_ani_draw > self._a_ani_max: - return self.draw_anisotropy(a_ani, a_ani_sigma, beta_inf, beta_inf_sigma) + return self.draw_anisotropy( + a_ani, a_ani_sigma, beta_inf, beta_inf_sigma + ) kwargs_return["a_ani"] = a_ani_draw else: kwargs_return["a_ani"] = a_ani From 4758eab4d6e54caa63a4d5f0e8de2b7f6adf2660 Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Fri, 28 Jun 2024 18:15:21 -0400 Subject: [PATCH 22/62] re-definition of distribution functions for OM and GOM model for a_ani with scaled function separately --- .../Distributions/anisotropy_distributions.py | 29 ++++++++--- hierarc/Sampling/ParamManager/kin_param.py | 4 +- .../test_anisotropy_distribution.py | 50 ++++++++++++++++++- 3 files changed, 71 insertions(+), 12 deletions(-) diff --git a/hierarc/Sampling/Distributions/anisotropy_distributions.py b/hierarc/Sampling/Distributions/anisotropy_distributions.py index 0b66627b..0aec213d 100644 --- a/hierarc/Sampling/Distributions/anisotropy_distributions.py +++ b/hierarc/Sampling/Distributions/anisotropy_distributions.py @@ -1,5 +1,8 @@ import numpy as np +_SUPPORTED_DISTRIBUTIONS = ["GAUSSIAN", "GAUSSIAN_SCALED", "NONE"] +_SUPPORTED_MODELS = ["OM", "GOM", "const", "NONE"] + class AnisotropyDistribution(object): """Class to draw anisotropy parameters from hyperparameter distributions.""" @@ -17,12 +20,20 @@ def __init__( :param anisotropy_model: string, name of anisotropy model to consider :param anisotropy_sampling: bool, if True adds a global stellar anisotropy parameter that alters the single lens kinematic prediction - :param distribution_function: string, 'NONE', 'GAUSSIAN', description of the distribution function of the - anisotropy model parameters + :param distribution_function: string, 'NONE', 'GAUSSIAN', 'GAUSSIAN_SCALED', + description of the distribution function of the anisotropy model parameters """ - + if anisotropy_model not in _SUPPORTED_MODELS: + raise ValueError("Anisotropy model %s not supported. Chose among %s." + % (anisotropy_model, _SUPPORTED_MODELS)) self._anisotropy_model = anisotropy_model self._anisotropy_sampling = anisotropy_sampling + if distribution_function not in _SUPPORTED_DISTRIBUTIONS: + raise ValueError("Anisotropy distribution function %s not supported. Chose among %s." + % (distribution_function, _SUPPORTED_DISTRIBUTIONS)) + if anisotropy_model not in ["OM", "GOM"] and distribution_function == "GAUSSIAN_SCALED": + raise ValueError("GAUSSIAN_SCALED distribution only supported for 'OM' and 'GOM' models, not for %s." + % anisotropy_model) self._distribution_function = distribution_function if kwargs_anisotropy_min is None: kwargs_anisotropy_min = {} @@ -60,22 +71,24 @@ def draw_anisotropy( "anisotropy parameter is out of bounds of the interpolated range!" ) # we draw a linear gaussian for 'const' anisotropy and a scaled proportional one for 'OM - if self._distribution_function in ["GAUSSIAN"]: - if self._anisotropy_model == "OM": - a_ani_draw = np.random.normal(a_ani, a_ani_sigma * a_ani) - else: + if self._distribution_function in ["GAUSSIAN", "GAUSSIAN_SCALED"]: + if self._distribution_function in ["GAUSSIAN"]: a_ani_draw = np.random.normal(a_ani, a_ani_sigma) + else: + a_ani_draw = np.random.normal(a_ani, a_ani_sigma * a_ani) + if a_ani_draw < self._a_ani_min or a_ani_draw > self._a_ani_max: return self.draw_anisotropy(a_ani, a_ani_sigma, beta_inf, beta_inf_sigma) kwargs_return["a_ani"] = a_ani_draw else: kwargs_return["a_ani"] = a_ani + if self._anisotropy_model in ["GOM"]: if beta_inf < self._beta_inf_min or beta_inf > self._beta_inf_max: raise ValueError( "anisotropy parameter is out of bounds of the interpolated range!" ) - if self._distribution_function in ["GAUSSIAN"]: + if self._distribution_function in ["GAUSSIAN", "GAUSSIAN_SCALED"]: beta_inf_draw = np.random.normal(beta_inf, beta_inf_sigma) else: beta_inf_draw = beta_inf diff --git a/hierarc/Sampling/ParamManager/kin_param.py b/hierarc/Sampling/ParamManager/kin_param.py index d8023c76..155e2a6b 100644 --- a/hierarc/Sampling/ParamManager/kin_param.py +++ b/hierarc/Sampling/ParamManager/kin_param.py @@ -49,7 +49,7 @@ def param_list(self, latex_style=False): list.append(r"$\langle a_{\rm ani}\rangle$") else: list.append("a_ani") - if self._distribution_function in ["GAUSSIAN"]: + if self._distribution_function in ["GAUSSIAN", "GAUSSIAN_SCALED"]: if "a_ani_sigma" not in self._kwargs_fixed: if latex_style is True: if self._log_scatter is True: @@ -64,7 +64,7 @@ def param_list(self, latex_style=False): list.append(r"$\beta_{\infty}$") else: list.append("beta_inf") - if self._distribution_function in ["GAUSSIAN"]: + if self._distribution_function in ["GAUSSIAN", "GAUSSIAN_SCALED"]: if "beta_inf_sigma" not in self._kwargs_fixed: if latex_style is True: if self._log_scatter is True: diff --git a/test/test_Sampling/test_Distributions/test_anisotropy_distribution.py b/test/test_Sampling/test_Distributions/test_anisotropy_distribution.py index 70e9324e..218bb52d 100644 --- a/test/test_Sampling/test_Distributions/test_anisotropy_distribution.py +++ b/test/test_Sampling/test_Distributions/test_anisotropy_distribution.py @@ -20,10 +20,10 @@ def setup_method(self): kwargs_anisotropy_max=kwargs_anisotropy_max, ) - ani_dist = AnisotropyDistribution( + self._ani_dist_scaled = AnisotropyDistribution( anisotropy_model=anisotropy_model, anisotropy_sampling=False, - distribution_function=distribution_function, + distribution_function="GAUSSIAN_SCALED", kwargs_anisotropy_min=kwargs_anisotropy_min, kwargs_anisotropy_max=kwargs_anisotropy_max, ) @@ -39,6 +39,10 @@ def test_draw_anisotropy(self): assert "a_ani" in kwargs_drawn assert "beta_inf" in kwargs_drawn + kwargs_drawn = self._ani_dist_scaled.draw_anisotropy(**kwargs_anisotropy) + assert "a_ani" in kwargs_drawn + assert "beta_inf" in kwargs_drawn + ani_dist = AnisotropyDistribution( anisotropy_model="NONE", anisotropy_sampling=False, @@ -89,3 +93,45 @@ def test_raises(self): "beta_inf_sigma": 0.2, } kwargs_drawn = self._ani_dist.draw_anisotropy(**kwargs_anisotropy) + + with npt.assert_raises(ValueError): + anisotropy_model = "const" + distribution_function = "GAUSSIAN_SCALED" + kwargs_anisotropy_min = {"a_ani": 0, "beta_inf": 0.1} + kwargs_anisotropy_max = {"a_ani": 5, "beta_inf": 1} + + AnisotropyDistribution( + anisotropy_model=anisotropy_model, + anisotropy_sampling=True, + distribution_function=distribution_function, + kwargs_anisotropy_min=kwargs_anisotropy_min, + kwargs_anisotropy_max=kwargs_anisotropy_max, + ) + + with npt.assert_raises(ValueError): + anisotropy_model = "const" + distribution_function = "INVALID" + kwargs_anisotropy_min = {"a_ani": 0, "beta_inf": 0.1} + kwargs_anisotropy_max = {"a_ani": 5, "beta_inf": 1} + + AnisotropyDistribution( + anisotropy_model=anisotropy_model, + anisotropy_sampling=True, + distribution_function=distribution_function, + kwargs_anisotropy_min=kwargs_anisotropy_min, + kwargs_anisotropy_max=kwargs_anisotropy_max, + ) + + with npt.assert_raises(ValueError): + anisotropy_model = "INVALID" + distribution_function = "GAUSSIAN" + kwargs_anisotropy_min = {"a_ani": 0, "beta_inf": 0.1} + kwargs_anisotropy_max = {"a_ani": 5, "beta_inf": 1} + + AnisotropyDistribution( + anisotropy_model=anisotropy_model, + anisotropy_sampling=True, + distribution_function=distribution_function, + kwargs_anisotropy_min=kwargs_anisotropy_min, + kwargs_anisotropy_max=kwargs_anisotropy_max, + ) From 73a3464a666edfeb12b2d10f4a093cf77c6f2dd1 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 28 Jun 2024 22:15:59 +0000 Subject: [PATCH 23/62] [pre-commit.ci] auto fixes from pre-commit.com hooks --- .../Distributions/anisotropy_distributions.py | 23 +++++++++++++------ 1 file changed, 16 insertions(+), 7 deletions(-) diff --git a/hierarc/Sampling/Distributions/anisotropy_distributions.py b/hierarc/Sampling/Distributions/anisotropy_distributions.py index cf83256b..abc97388 100644 --- a/hierarc/Sampling/Distributions/anisotropy_distributions.py +++ b/hierarc/Sampling/Distributions/anisotropy_distributions.py @@ -24,16 +24,25 @@ def __init__( description of the distribution function of the anisotropy model parameters """ if anisotropy_model not in _SUPPORTED_MODELS: - raise ValueError("Anisotropy model %s not supported. Chose among %s." - % (anisotropy_model, _SUPPORTED_MODELS)) + raise ValueError( + "Anisotropy model %s not supported. Chose among %s." + % (anisotropy_model, _SUPPORTED_MODELS) + ) self._anisotropy_model = anisotropy_model self._anisotropy_sampling = anisotropy_sampling if distribution_function not in _SUPPORTED_DISTRIBUTIONS: - raise ValueError("Anisotropy distribution function %s not supported. Chose among %s." - % (distribution_function, _SUPPORTED_DISTRIBUTIONS)) - if anisotropy_model not in ["OM", "GOM"] and distribution_function == "GAUSSIAN_SCALED": - raise ValueError("GAUSSIAN_SCALED distribution only supported for 'OM' and 'GOM' models, not for %s." - % anisotropy_model) + raise ValueError( + "Anisotropy distribution function %s not supported. Chose among %s." + % (distribution_function, _SUPPORTED_DISTRIBUTIONS) + ) + if ( + anisotropy_model not in ["OM", "GOM"] + and distribution_function == "GAUSSIAN_SCALED" + ): + raise ValueError( + "GAUSSIAN_SCALED distribution only supported for 'OM' and 'GOM' models, not for %s." + % anisotropy_model + ) self._distribution_function = distribution_function if kwargs_anisotropy_min is None: kwargs_anisotropy_min = {} From 506df698aa21c517b9e6feee8e04f4733739cb0b Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Fri, 28 Jun 2024 18:30:11 -0400 Subject: [PATCH 24/62] minor testing changes --- test/test_LensPosterior/test_kin_scaling_config.py | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 test/test_LensPosterior/test_kin_scaling_config.py diff --git a/test/test_LensPosterior/test_kin_scaling_config.py b/test/test_LensPosterior/test_kin_scaling_config.py new file mode 100644 index 00000000..aed0bcf7 --- /dev/null +++ b/test/test_LensPosterior/test_kin_scaling_config.py @@ -0,0 +1,9 @@ +from hierarc.LensPosterior.kin_scaling_config import KinScalingConfig + +class TestKinScalingConfig(object): + + def setup_method(self): + pass + + def test_init(self): + KinScalingConfig(anisotropy_model="NONE", r_eff=None, gamma_in_scaling=None, log_m2l_scaling=None) From 7ce952a31080248cfd925366efeebe4250c911a7 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 28 Jun 2024 22:30:34 +0000 Subject: [PATCH 25/62] [pre-commit.ci] auto fixes from pre-commit.com hooks --- test/test_LensPosterior/test_kin_scaling_config.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/test/test_LensPosterior/test_kin_scaling_config.py b/test/test_LensPosterior/test_kin_scaling_config.py index aed0bcf7..48a2df92 100644 --- a/test/test_LensPosterior/test_kin_scaling_config.py +++ b/test/test_LensPosterior/test_kin_scaling_config.py @@ -1,9 +1,15 @@ from hierarc.LensPosterior.kin_scaling_config import KinScalingConfig + class TestKinScalingConfig(object): def setup_method(self): pass def test_init(self): - KinScalingConfig(anisotropy_model="NONE", r_eff=None, gamma_in_scaling=None, log_m2l_scaling=None) + KinScalingConfig( + anisotropy_model="NONE", + r_eff=None, + gamma_in_scaling=None, + log_m2l_scaling=None, + ) From 36c98e42cd7598c7aa290c445775009158712a1b Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Fri, 28 Jun 2024 18:33:05 -0400 Subject: [PATCH 26/62] minor testing changes --- hierarc/LensPosterior/kin_scaling_config.py | 2 +- test/test_LensPosterior/test_kin_scaling_config.py | 7 ++++++- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/hierarc/LensPosterior/kin_scaling_config.py b/hierarc/LensPosterior/kin_scaling_config.py index d6979f3d..efb927f7 100644 --- a/hierarc/LensPosterior/kin_scaling_config.py +++ b/hierarc/LensPosterior/kin_scaling_config.py @@ -87,7 +87,7 @@ def param_name_list(self): """ return self._param_name_list - def anisotropy_kwargs(self, a_ani, beta_inf=None): + def anisotropy_kwargs(self, a_ani=None, beta_inf=None): """ :param a_ani: anisotropy parameter diff --git a/test/test_LensPosterior/test_kin_scaling_config.py b/test/test_LensPosterior/test_kin_scaling_config.py index aed0bcf7..01a3f773 100644 --- a/test/test_LensPosterior/test_kin_scaling_config.py +++ b/test/test_LensPosterior/test_kin_scaling_config.py @@ -1,4 +1,5 @@ from hierarc.LensPosterior.kin_scaling_config import KinScalingConfig +import numpy.testing as npt class TestKinScalingConfig(object): @@ -6,4 +7,8 @@ def setup_method(self): pass def test_init(self): - KinScalingConfig(anisotropy_model="NONE", r_eff=None, gamma_in_scaling=None, log_m2l_scaling=None) + kin_scaling = KinScalingConfig(anisotropy_model="NONE", r_eff=None, gamma_in_scaling=None, log_m2l_scaling=None) + kin_scaling._anisotropy_model = "BAD" + + with npt.assert_raises(ValueError): + kin_scaling.anisotropy_kwargs() From 3e6a1e1fb4f096a1056cb8c75004846f1dbef9a5 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 28 Jun 2024 22:33:45 +0000 Subject: [PATCH 27/62] [pre-commit.ci] auto fixes from pre-commit.com hooks --- test/test_LensPosterior/test_kin_scaling_config.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/test/test_LensPosterior/test_kin_scaling_config.py b/test/test_LensPosterior/test_kin_scaling_config.py index e8e39853..20677b8c 100644 --- a/test/test_LensPosterior/test_kin_scaling_config.py +++ b/test/test_LensPosterior/test_kin_scaling_config.py @@ -8,7 +8,12 @@ def setup_method(self): pass def test_init(self): - kin_scaling = KinScalingConfig(anisotropy_model="NONE", r_eff=None, gamma_in_scaling=None, log_m2l_scaling=None) + kin_scaling = KinScalingConfig( + anisotropy_model="NONE", + r_eff=None, + gamma_in_scaling=None, + log_m2l_scaling=None, + ) kin_scaling._anisotropy_model = "BAD" with npt.assert_raises(ValueError): From a68ea3e54f7a2ed1a267546415b90e845de2a54b Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Fri, 28 Jun 2024 21:10:07 -0400 Subject: [PATCH 28/62] minor testing changes --- test/test_Likelihood/test_kin_scaling.py | 4 ++++ .../test_Distributions/test_anisotropy_distribution.py | 2 +- .../test_Distributions/test_lens_distribution.py | 1 + 3 files changed, 6 insertions(+), 1 deletion(-) diff --git a/test/test_Likelihood/test_kin_scaling.py b/test/test_Likelihood/test_kin_scaling.py index f1201660..9b8d1c63 100644 --- a/test/test_Likelihood/test_kin_scaling.py +++ b/test/test_Likelihood/test_kin_scaling.py @@ -80,6 +80,10 @@ def test__kwargs2param_array(self): assert kwargs_max["b"] == 2 assert kwargs_max["a"] == 1 + with npt.assert_raises(ValueError): + kwargs_param = {"a": 0.5} # remove parameter "b" and expect a raise + param_array = kin_scaling._kwargs2param_array(kwargs_param) + def test_empty(self): kin_scaling = KinScaling( j_kin_scaling_param_axes=None, diff --git a/test/test_Sampling/test_Distributions/test_anisotropy_distribution.py b/test/test_Sampling/test_Distributions/test_anisotropy_distribution.py index 218bb52d..51683fca 100644 --- a/test/test_Sampling/test_Distributions/test_anisotropy_distribution.py +++ b/test/test_Sampling/test_Distributions/test_anisotropy_distribution.py @@ -22,7 +22,7 @@ def setup_method(self): self._ani_dist_scaled = AnisotropyDistribution( anisotropy_model=anisotropy_model, - anisotropy_sampling=False, + anisotropy_sampling=True, distribution_function="GAUSSIAN_SCALED", kwargs_anisotropy_min=kwargs_anisotropy_min, kwargs_anisotropy_max=kwargs_anisotropy_max, diff --git a/test/test_Sampling/test_Distributions/test_lens_distribution.py b/test/test_Sampling/test_Distributions/test_lens_distribution.py index bb9513aa..db250ea6 100644 --- a/test/test_Sampling/test_Distributions/test_lens_distribution.py +++ b/test/test_Sampling/test_Distributions/test_lens_distribution.py @@ -51,6 +51,7 @@ def test_draw_lens(self): kwargs_sampling = copy.deepcopy(self.kwargs_sampling) kwargs_sampling["log_scatter"] = True kwargs_sampling["lambda_ifu"] = True + kwargs_sampling["gamma_in_sampling"] = False lens_dist = LensDistribution(kwargs_sampling) for i in range(100): kwargs_return = lens_dist.draw_lens(**self.kwargs_lens) From 0611f3ff49053026f93a79d5a71206a234c4e9e6 Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Mon, 1 Jul 2024 19:43:07 -0400 Subject: [PATCH 29/62] first simplification of code to implement gamma_pl in kinematics --- hierarc/LensPosterior/kin_constraints.py | 23 ++++++++++------------- 1 file changed, 10 insertions(+), 13 deletions(-) diff --git a/hierarc/LensPosterior/kin_constraints.py b/hierarc/LensPosterior/kin_constraints.py index 15cf2a9a..0702cec2 100644 --- a/hierarc/LensPosterior/kin_constraints.py +++ b/hierarc/LensPosterior/kin_constraints.py @@ -38,6 +38,7 @@ def __init__( cosmo_fiducial=None, gamma_in_scaling=None, log_m2l_scaling=None, + gamma_pl_scaling=None, ): """ @@ -81,6 +82,7 @@ def __init__( uses astropy's default :param gamma_in_scaling: array of gamma_in parameter to be interpolated (optional, otherwise None) :param log_m2l_scaling: array of log_m2l parameter to be interpolated (optional, otherwise None) + :param gamma_pl_scaling: array of mass density profile power-law slope values (optional, otherwise None) """ self._sigma_v_measured = np.array(sigma_v_measured) self._sigma_v_error_independent = np.array(sigma_v_error_independent) @@ -249,17 +251,10 @@ def _anisotropy_scaling_relative(self, j_ani_0): scaling """ num_data = len(self._sigma_v_measured) + len_list = [len(a) for a in self.kin_scaling_param_array] + ani_scaling_array_list = [np.zeros(len_list) for _ in range(num_data)] if self._anisotropy_model == "GOM": - ani_scaling_array_list = [ - np.zeros( - ( - len(self.kin_scaling_param_array[0]), - len(self.kin_scaling_param_array[1]), - ) - ) - for _ in range(num_data) - ] for i, a_ani in enumerate(self.kin_scaling_param_array[0]): for j, beta_inf in enumerate(self.kin_scaling_param_array[1]): kwargs_anisotropy = self.anisotropy_kwargs( @@ -271,12 +266,14 @@ def _anisotropy_scaling_relative(self, j_ani_0): j_kin / j_ani_0[k] ) # perhaps change the order elif self._anisotropy_model in ["OM", "const"]: - ani_scaling_array_list = [[] for _ in range(num_data)] - for a_ani in self.kin_scaling_param_array[0]: + for i, a_ani in enumerate(self.kin_scaling_param_array[0]): kwargs_anisotropy = self.anisotropy_kwargs(a_ani) j_kin_ani = self.j_kin_draw(kwargs_anisotropy, no_error=True) - for i, j_kin in enumerate(j_kin_ani): - ani_scaling_array_list[i].append(j_kin / j_ani_0[i]) + for k, j_kin in enumerate(j_kin_ani): + ani_scaling_array_list[k][i] = ( + j_kin / j_ani_0[k] + ) + # ani_scaling_array_list[k].append(j_kin / j_ani_0[k]) else: raise ValueError("anisotropy model %s not valid." % self._anisotropy_model) return ani_scaling_array_list From f94945bac9f800c4f512b7aebbfd4a69b9eb2cf2 Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Mon, 1 Jul 2024 22:14:25 -0400 Subject: [PATCH 30/62] re-structuring of code, before major refactoring --- hierarc/LensPosterior/base_config.py | 3 + hierarc/LensPosterior/imaging_constraints.py | 19 +++-- hierarc/LensPosterior/kin_constraints.py | 42 +++++----- hierarc/LensPosterior/kin_scaling_config.py | 36 ++++++-- hierarc/Likelihood/kin_scaling.py | 88 +++++++++++++++----- test/test_Likelihood/test_kin_scaling.py | 4 +- 6 files changed, 135 insertions(+), 57 deletions(-) diff --git a/hierarc/LensPosterior/base_config.py b/hierarc/LensPosterior/base_config.py index ee39e438..f0f3a16a 100644 --- a/hierarc/LensPosterior/base_config.py +++ b/hierarc/LensPosterior/base_config.py @@ -35,6 +35,7 @@ def __init__( cosmo_fiducial=None, gamma_in_scaling=None, log_m2l_scaling=None, + gamma_pl_scaling=None, ): """ @@ -66,6 +67,7 @@ def __init__( uses astropy's default cosmology :param gamma_in_scaling: array of gamma_in parameter to be interpolated (optional, otherwise None) :param log_m2l_scaling: array of log_m2l parameter to be interpolated (optional, otherwise None) + :param gamma_pl_scaling: array of power-law density profile slopes to be interpolated (optional, otherwise None) """ self._z_lens, self._z_source = z_lens, z_source @@ -115,4 +117,5 @@ def __init__( r_eff, gamma_in_scaling=gamma_in_scaling, log_m2l_scaling=log_m2l_scaling, + gamma_pl_scaling=gamma_pl_scaling, ) diff --git a/hierarc/LensPosterior/imaging_constraints.py b/hierarc/LensPosterior/imaging_constraints.py index fab2217c..68d96cc7 100644 --- a/hierarc/LensPosterior/imaging_constraints.py +++ b/hierarc/LensPosterior/imaging_constraints.py @@ -18,10 +18,12 @@ def __init__(self, theta_E, theta_E_error, gamma, gamma_error, r_eff, r_eff_erro self._gamma, self._gamma_error = gamma, gamma_error self._r_eff, self._r_eff_error = r_eff, r_eff_error - def draw_lens(self, no_error=False): + def draw_lens(self, gamma_pl=None, no_error=False): """ :param no_error: bool, if True, does not render from the uncertainty but uses the mean values instead + :param gamma_pl: power law slope, if None, draws from measurement uncertainty, otherwise takes at fixed value + :type gamma_pl: float or None :return: theta_E, gamma, r_eff, delta_r_eff """ if no_error is True: @@ -29,12 +31,15 @@ def draw_lens(self, no_error=False): theta_E_draw = np.maximum( np.random.normal(loc=self._theta_E, scale=self._theta_E_error), 0 ) - gamma_draw = np.random.normal(loc=self._gamma, scale=self._gamma_error) - # distributions are drawn in the range [1, 3) - # the power-law slope gamma=3 is divergent in mass in the center and values close close to =3 may be unstable - # to compute the kinematics for. - gamma_draw = np.maximum(gamma_draw, 1.0) - gamma_draw = np.minimum(gamma_draw, 2.999) + if gamma_pl is None: + gamma_draw = np.random.normal(loc=self._gamma, scale=self._gamma_error) + # distributions are drawn in the range [1, 3) + # the power-law slope gamma=3 is divergent in mass in the center and values close to =3 may be unstable + # to compute the kinematics for. + gamma_draw = np.maximum(gamma_draw, 1.0) + gamma_draw = np.minimum(gamma_draw, 2.999) + else: + gamma_draw = gamma_pl # we make sure no negative r_eff are being sampled delta_r_eff = np.maximum( np.random.normal(loc=1, scale=self._r_eff_error / self._r_eff), 0.001 diff --git a/hierarc/LensPosterior/kin_constraints.py b/hierarc/LensPosterior/kin_constraints.py index 0702cec2..9bb8b8df 100644 --- a/hierarc/LensPosterior/kin_constraints.py +++ b/hierarc/LensPosterior/kin_constraints.py @@ -119,17 +119,20 @@ def __init__( cosmo_fiducial=cosmo_fiducial, gamma_in_scaling=gamma_in_scaling, log_m2l_scaling=log_m2l_scaling, + gamma_pl_scaling=gamma_pl_scaling ) - def j_kin_draw(self, kwargs_anisotropy, no_error=False): + def j_kin_draw(self, kwargs_anisotropy, gamma_pl=None, no_error=False): """One simple sampling realization of the dimensionless kinematics of the model. :param kwargs_anisotropy: keyword argument of anisotropy setting + :param gamma_pl: power law slope, if None, draws from measurement uncertainty, otherwise takes at fixed value + :type gamma_pl: float or None :param no_error: bool, if True, does not render from the uncertainty but uses the mean values instead :return: dimensionless kinematic component J() Birrer et al. 2016, 2019 """ - theta_E_draw, gamma_draw, r_eff_draw, delta_r_eff = self.draw_lens( + theta_E_draw, gamma_draw, r_eff_draw, delta_r_eff = self.draw_lens(gamma_pl=gamma_pl, no_error=no_error ) kwargs_lens = [ @@ -198,7 +201,7 @@ def model_marginalization(self, num_sample_model=20): (num_sample_model, num_data) ) # matrix that contains the sampled J() distribution for i in range(num_sample_model): - j_kin = self.j_kin_draw(self.kwargs_anisotropy_base, no_error=False) + j_kin = self.j_kin_draw(self.kwargs_anisotropy_base, no_error=False, **self.kwargs_lens_base) j_kin_matrix[i, :] = j_kin error_cov_j_sqrt = np.cov(np.sqrt(j_kin_matrix.T)) @@ -240,7 +243,7 @@ def anisotropy_scaling(self): :return: anisotropy scaling grid along the axes defined by ani_param_array """ - j_ani_0 = self.j_kin_draw(self.kwargs_anisotropy_base, no_error=True) + j_ani_0 = self.j_kin_draw(self.kwargs_anisotropy_base, no_error=True, **self.kwargs_lens_base) return self._anisotropy_scaling_relative(j_ani_0) def _anisotropy_scaling_relative(self, j_ani_0): @@ -254,26 +257,25 @@ def _anisotropy_scaling_relative(self, j_ani_0): len_list = [len(a) for a in self.kin_scaling_param_array] ani_scaling_array_list = [np.zeros(len_list) for _ in range(num_data)] - if self._anisotropy_model == "GOM": + if self._anisotropy_model in ["OM", "const", "GOM"]: for i, a_ani in enumerate(self.kin_scaling_param_array[0]): - for j, beta_inf in enumerate(self.kin_scaling_param_array[1]): - kwargs_anisotropy = self.anisotropy_kwargs( - a_ani=a_ani, beta_inf=beta_inf - ) + if self._anisotropy_model == "GOM": + for j, beta_inf in enumerate(self.kin_scaling_param_array[1]): + kwargs_anisotropy = self.anisotropy_kwargs( + a_ani=a_ani, beta_inf=beta_inf + ) + j_kin_ani = self.j_kin_draw(kwargs_anisotropy, no_error=True) + for k, j_kin in enumerate(j_kin_ani): + ani_scaling_array_list[k][i, j] = ( + j_kin / j_ani_0[k] + ) # perhaps change the order + else: + kwargs_anisotropy = self.anisotropy_kwargs(a_ani) j_kin_ani = self.j_kin_draw(kwargs_anisotropy, no_error=True) for k, j_kin in enumerate(j_kin_ani): - ani_scaling_array_list[k][i, j] = ( + ani_scaling_array_list[k][i] = ( j_kin / j_ani_0[k] - ) # perhaps change the order - elif self._anisotropy_model in ["OM", "const"]: - for i, a_ani in enumerate(self.kin_scaling_param_array[0]): - kwargs_anisotropy = self.anisotropy_kwargs(a_ani) - j_kin_ani = self.j_kin_draw(kwargs_anisotropy, no_error=True) - for k, j_kin in enumerate(j_kin_ani): - ani_scaling_array_list[k][i] = ( - j_kin / j_ani_0[k] - ) - # ani_scaling_array_list[k].append(j_kin / j_ani_0[k]) + ) else: raise ValueError("anisotropy model %s not valid." % self._anisotropy_model) return ani_scaling_array_list diff --git a/hierarc/LensPosterior/kin_scaling_config.py b/hierarc/LensPosterior/kin_scaling_config.py index efb927f7..711775b8 100644 --- a/hierarc/LensPosterior/kin_scaling_config.py +++ b/hierarc/LensPosterior/kin_scaling_config.py @@ -1,19 +1,22 @@ import numpy as np +from hierarc.Likelihood.kin_scaling import KinScalingParamManager -class KinScalingConfig(object): +class KinScalingConfig(KinScalingParamManager): """Class to manage the anisotropy model and parameters for the Posterior processing.""" def __init__( - self, anisotropy_model, r_eff, gamma_in_scaling=None, log_m2l_scaling=None + self, anisotropy_model, r_eff, gamma_in_scaling=None, log_m2l_scaling=None, gamma_pl_scaling=None ): """ - :param anisotropy_model: type of stellar anisotropy model. Supported are 'OM' and 'GOM' or 'const', see details in lenstronomy.Galkin module + :param anisotropy_model: type of stellar anisotropy model. Supported are 'OM' and 'GOM' or 'const', + see details in lenstronomy.Galkin module :param r_eff: half-light radius of the deflector galaxy :param gamma_in_scaling: array of gamma_in parameter to be interpolated (optional, otherwise None) :param log_m2l_scaling: array of log_m2l parameter to be interpolated (optional, otherwise None) + :param gamma_pl_scaling: array of power-law density profile slopes to be interpolated (optional, otherwise None) """ self._r_eff = r_eff self._anisotropy_model = anisotropy_model @@ -40,12 +43,20 @@ def __init__( raise ValueError( "anisotropy model %s not supported." % self._anisotropy_model ) + self._gamma_in_scaling = gamma_in_scaling + self._log_m2l_scaling = log_m2l_scaling + self._gamma_pl_scaling = gamma_pl_scaling + if gamma_in_scaling is not None: self._param_name_list.append("gamma_in") self._ani_param_array.append(np.array(gamma_in_scaling)) if log_m2l_scaling is not None: self._param_name_list.append("log_m2l") self._ani_param_array.append(np.array(log_m2l_scaling)) + if gamma_pl_scaling is not None: + self._param_name_list.append("gamma_pl") + self._ani_param_array.append(np.array(gamma_pl_scaling)) + KinScalingParamManager.__init__(self, j_kin_scaling_param_name_list=self._param_name_list) @property def kwargs_anisotropy_base(self): @@ -71,11 +82,26 @@ def kwargs_anisotropy_base(self): ) return kwargs_anisotropy_0 + @property + def kwargs_lens_base(self): + """ + + :return: keyword arguments of lens model parameters that are getting interpolated + """ + kwargs_base = {} + if "gamma_in" in self._param_name_list: + kwargs_base["gamma_in"] = np.mean(self._gamma_in_scaling) + if "log_m2l" in self._param_name_list: + kwargs_base["log_m2l"] = np.mean(self._log_m2l_scaling) + if "gamma_pl" in self._param_name_list: + kwargs_base["gamma_pl"] = np.mean(self._gamma_pl_scaling) + return kwargs_base + @property def kin_scaling_param_array(self): """ - :return: numpy array of anisotropy parameter values to be explored + :return: numpy array of kinematic scaling parameter values to be explored, list of 1D arrays """ return self._ani_param_array @@ -92,7 +118,7 @@ def anisotropy_kwargs(self, a_ani=None, beta_inf=None): :param a_ani: anisotropy parameter :param beta_inf: anisotropy at infinity (only used for 'GOM' model) - :return: list of anisotropy keyword arguments, value of anisotropy parameter list + :return: list of anisotropy keyword arguments for GalKin module """ if self._anisotropy_model == "OM": diff --git a/hierarc/Likelihood/kin_scaling.py b/hierarc/Likelihood/kin_scaling.py index 40e75f58..299858f6 100644 --- a/hierarc/Likelihood/kin_scaling.py +++ b/hierarc/Likelihood/kin_scaling.py @@ -6,6 +6,67 @@ import numpy as np +class KinScalingParamManager(object): + """ + class to handle the sorting of parameters in the kinematics scaling + """ + + def __init__(self, j_kin_scaling_param_name_list): + """ + + :param j_kin_scaling_param_name_list: list of strings for the parameters as they are interpolated in the same + order as j_kin_scaling_grid + """ + if j_kin_scaling_param_name_list is None: + self._param_list = [] + else: + self._param_list = j_kin_scaling_param_name_list + self._num_param = len(self._param_list) + + @property + def num_scaling_dim(self): + """ + number of parameter dimensions for kinematic scaling + + :return: number of scaling dimensions + :rtype: int + """ + return self._num_param + + def kwargs2param_array(self, kwargs): + """Converts dictionary to sorted array in same order as interpolation grid. + + :param kwargs: dictionary of all model components, must include the one that are + interpolated + :return: sorted list of parameters to interpolate + """ + param_array = [] + for param in self._param_list: + if param not in kwargs: + raise ValueError( + "key %s not in parameters and hence kinematic scaling not possible" + % param + ) + param_array.append(kwargs.get(param)) + return param_array + + def param_array2kwargs(self, param_array): + """ + inverse function of kwargs2param_array + for a given param_array returns the dictionary split in anisotropy and lens models + + :param param_array: + :return: kwargs_anisotropy, kwargs_lens + """ + kwargs_anisotropy, kwargs_lens = {}, {} + for i, param in enumerate(self._param_list): + if param in ["gamma_in", "gamma_pl", "log_m2l"]: + kwargs_lens[param] = param_array[i] + else: + kwargs_anisotropy[param] = param_array[i] + return kwargs_anisotropy, kwargs_lens + + class ParameterScalingSingleMeasurement(object): """Class to manage anisotropy scaling for single slit observation.""" @@ -57,7 +118,7 @@ def j_scaling(self, param_array): return self._f_ani(param_array)[0] -class KinScaling(object): +class KinScaling(KinScalingParamManager): """Class to manage model parameter and anisotropy scalings for IFU data.""" def __init__( @@ -73,10 +134,7 @@ def __init__( :param j_kin_scaling_param_name_list: list of strings for the parameters as they are interpolated in the same order as j_kin_scaling_grid """ - if j_kin_scaling_param_name_list is None: - self._param_list = [] - else: - self._param_list = j_kin_scaling_param_name_list + self._param_arrays = j_kin_scaling_param_axes if ( not isinstance(j_kin_scaling_param_axes, list) @@ -104,23 +162,7 @@ def __init__( self._dim_scaling = len(j_kin_scaling_param_axes) else: self._dim_scaling = 1 - - def _kwargs2param_array(self, kwargs): - """Converts dictionary to sorted array in same order as interpolation grid. - - :param kwargs: dictionary of all model components, must include the one that are - interpolated - :return: sorted list of parameters to interpolate - """ - param_array = [] - for param in self._param_list: - if param not in kwargs: - raise ValueError( - "key %s not in parameters and hence kinematic scaling not possible" - % param - ) - param_array.append(kwargs.get(param)) - return param_array + KinScalingParamManager.__init__(self, j_kin_scaling_param_name_list=j_kin_scaling_param_name_list) def param_bounds_interpol(self): """Minimum and maximum bounds of parameters that are being used to call @@ -143,7 +185,7 @@ def kin_scaling(self, kwargs_param): """ if kwargs_param is None: return np.ones(self._dim_scaling) - param_array = self._kwargs2param_array(kwargs_param) + param_array = self.kwargs2param_array(kwargs_param) if self._evaluate_scaling is not True or len(param_array) == 0: return np.ones(self._dim_scaling) scaling_list = [] diff --git a/test/test_Likelihood/test_kin_scaling.py b/test/test_Likelihood/test_kin_scaling.py index 9b8d1c63..c92bf4a8 100644 --- a/test/test_Likelihood/test_kin_scaling.py +++ b/test/test_Likelihood/test_kin_scaling.py @@ -71,7 +71,7 @@ def test__kwargs2param_array(self): j_kin_scaling_param_name_list=param_list, ) kwargs_param = {"a": 0.5, "b": 0.3} - param_array = kin_scaling._kwargs2param_array(kwargs_param) + param_array = kin_scaling.kwargs2param_array(kwargs_param) assert param_array[0] == kwargs_param["a"] assert param_array[1] == kwargs_param["b"] kwargs_min, kwargs_max = kin_scaling.param_bounds_interpol() @@ -82,7 +82,7 @@ def test__kwargs2param_array(self): with npt.assert_raises(ValueError): kwargs_param = {"a": 0.5} # remove parameter "b" and expect a raise - param_array = kin_scaling._kwargs2param_array(kwargs_param) + param_array = kin_scaling.kwargs2param_array(kwargs_param) def test_empty(self): kin_scaling = KinScaling( From 5ad80b2d6140b962db4d9998b6ec8695d548ad67 Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Tue, 2 Jul 2024 13:57:38 -0400 Subject: [PATCH 31/62] generalized treatment of different dimensions in the kinematic pre-processing --- hierarc/LensPosterior/kin_constraints.py | 55 +++++++++++++++--------- 1 file changed, 35 insertions(+), 20 deletions(-) diff --git a/hierarc/LensPosterior/kin_constraints.py b/hierarc/LensPosterior/kin_constraints.py index 9bb8b8df..a18a7aba 100644 --- a/hierarc/LensPosterior/kin_constraints.py +++ b/hierarc/LensPosterior/kin_constraints.py @@ -256,26 +256,41 @@ def _anisotropy_scaling_relative(self, j_ani_0): num_data = len(self._sigma_v_measured) len_list = [len(a) for a in self.kin_scaling_param_array] ani_scaling_array_list = [np.zeros(len_list) for _ in range(num_data)] - - if self._anisotropy_model in ["OM", "const", "GOM"]: - for i, a_ani in enumerate(self.kin_scaling_param_array[0]): - if self._anisotropy_model == "GOM": - for j, beta_inf in enumerate(self.kin_scaling_param_array[1]): - kwargs_anisotropy = self.anisotropy_kwargs( - a_ani=a_ani, beta_inf=beta_inf - ) - j_kin_ani = self.j_kin_draw(kwargs_anisotropy, no_error=True) - for k, j_kin in enumerate(j_kin_ani): - ani_scaling_array_list[k][i, j] = ( - j_kin / j_ani_0[k] - ) # perhaps change the order - else: - kwargs_anisotropy = self.anisotropy_kwargs(a_ani) - j_kin_ani = self.j_kin_draw(kwargs_anisotropy, no_error=True) - for k, j_kin in enumerate(j_kin_ani): - ani_scaling_array_list[k][i] = ( - j_kin / j_ani_0[k] + num = self.num_scaling_dim + if num == 1: + for i, param in enumerate(self.kin_scaling_param_array[0]): + param_array = [param] + kwargs_ani, kwargs_lens = self.param_array2kwargs(param_array=param_array) + kwargs_anisotropy = self.anisotropy_kwargs(**kwargs_ani) + j_kin_ani = self.j_kin_draw(kwargs_anisotropy, no_error=True, **kwargs_lens) + for s, j_kin in enumerate(j_kin_ani): + ani_scaling_array_list[s][i] = ( + j_kin / j_ani_0[s] + ) + elif num == 2: + for i, param_i in enumerate(self.kin_scaling_param_array[0]): + for j, param_j in enumerate(self.kin_scaling_param_array[1]): + param_array = [param_i, param_j] + kwargs_ani, kwargs_lens = self.param_array2kwargs(param_array=param_array) + kwargs_anisotropy = self.anisotropy_kwargs(**kwargs_ani) + j_kin_ani = self.j_kin_draw(kwargs_anisotropy, no_error=True, **kwargs_lens) + for s, j_kin in enumerate(j_kin_ani): + ani_scaling_array_list[s][i, j] = ( + j_kin / j_ani_0[s] ) + elif num == 3: + for i, param_i in enumerate(self.kin_scaling_param_array[0]): + for j, param_j in enumerate(self.kin_scaling_param_array[1]): + for k, param_k in enumerate(self.kin_scaling_param_array[2]): + param_array = [param_i, param_j, param_k] + kwargs_ani, kwargs_lens = self.param_array2kwargs(param_array=param_array) + kwargs_anisotropy = self.anisotropy_kwargs(**kwargs_ani) + j_kin_ani = self.j_kin_draw(kwargs_anisotropy, no_error=True, **kwargs_lens) + for s, j_kin in enumerate(j_kin_ani): + ani_scaling_array_list[s][i, j, k] = ( + j_kin / j_ani_0[s] + ) else: - raise ValueError("anisotropy model %s not valid." % self._anisotropy_model) + ValueError("Kin scaling with parameter dimension %s not supported, chose between 1-3." % num) + return ani_scaling_array_list From 2261583ae31f2c6af8fccccfa4fdcfc9fb2a9742 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Tue, 2 Jul 2024 18:00:08 +0000 Subject: [PATCH 32/62] [pre-commit.ci] auto fixes from pre-commit.com hooks --- hierarc/LensPosterior/kin_constraints.py | 58 +++++++++++++-------- hierarc/LensPosterior/kin_scaling_config.py | 11 +++- hierarc/Likelihood/kin_scaling.py | 16 +++--- 3 files changed, 52 insertions(+), 33 deletions(-) diff --git a/hierarc/LensPosterior/kin_constraints.py b/hierarc/LensPosterior/kin_constraints.py index a18a7aba..7af091f1 100644 --- a/hierarc/LensPosterior/kin_constraints.py +++ b/hierarc/LensPosterior/kin_constraints.py @@ -119,21 +119,22 @@ def __init__( cosmo_fiducial=cosmo_fiducial, gamma_in_scaling=gamma_in_scaling, log_m2l_scaling=log_m2l_scaling, - gamma_pl_scaling=gamma_pl_scaling + gamma_pl_scaling=gamma_pl_scaling, ) def j_kin_draw(self, kwargs_anisotropy, gamma_pl=None, no_error=False): """One simple sampling realization of the dimensionless kinematics of the model. :param kwargs_anisotropy: keyword argument of anisotropy setting - :param gamma_pl: power law slope, if None, draws from measurement uncertainty, otherwise takes at fixed value + :param gamma_pl: power law slope, if None, draws from measurement uncertainty, + otherwise takes at fixed value :type gamma_pl: float or None :param no_error: bool, if True, does not render from the uncertainty but uses the mean values instead :return: dimensionless kinematic component J() Birrer et al. 2016, 2019 """ - theta_E_draw, gamma_draw, r_eff_draw, delta_r_eff = self.draw_lens(gamma_pl=gamma_pl, - no_error=no_error + theta_E_draw, gamma_draw, r_eff_draw, delta_r_eff = self.draw_lens( + gamma_pl=gamma_pl, no_error=no_error ) kwargs_lens = [ {"theta_E": theta_E_draw, "gamma": gamma_draw, "center_x": 0, "center_y": 0} @@ -201,7 +202,9 @@ def model_marginalization(self, num_sample_model=20): (num_sample_model, num_data) ) # matrix that contains the sampled J() distribution for i in range(num_sample_model): - j_kin = self.j_kin_draw(self.kwargs_anisotropy_base, no_error=False, **self.kwargs_lens_base) + j_kin = self.j_kin_draw( + self.kwargs_anisotropy_base, no_error=False, **self.kwargs_lens_base + ) j_kin_matrix[i, :] = j_kin error_cov_j_sqrt = np.cov(np.sqrt(j_kin_matrix.T)) @@ -243,7 +246,9 @@ def anisotropy_scaling(self): :return: anisotropy scaling grid along the axes defined by ani_param_array """ - j_ani_0 = self.j_kin_draw(self.kwargs_anisotropy_base, no_error=True, **self.kwargs_lens_base) + j_ani_0 = self.j_kin_draw( + self.kwargs_anisotropy_base, no_error=True, **self.kwargs_lens_base + ) return self._anisotropy_scaling_relative(j_ani_0) def _anisotropy_scaling_relative(self, j_ani_0): @@ -260,37 +265,46 @@ def _anisotropy_scaling_relative(self, j_ani_0): if num == 1: for i, param in enumerate(self.kin_scaling_param_array[0]): param_array = [param] - kwargs_ani, kwargs_lens = self.param_array2kwargs(param_array=param_array) + kwargs_ani, kwargs_lens = self.param_array2kwargs( + param_array=param_array + ) kwargs_anisotropy = self.anisotropy_kwargs(**kwargs_ani) - j_kin_ani = self.j_kin_draw(kwargs_anisotropy, no_error=True, **kwargs_lens) + j_kin_ani = self.j_kin_draw( + kwargs_anisotropy, no_error=True, **kwargs_lens + ) for s, j_kin in enumerate(j_kin_ani): - ani_scaling_array_list[s][i] = ( - j_kin / j_ani_0[s] - ) + ani_scaling_array_list[s][i] = j_kin / j_ani_0[s] elif num == 2: for i, param_i in enumerate(self.kin_scaling_param_array[0]): for j, param_j in enumerate(self.kin_scaling_param_array[1]): param_array = [param_i, param_j] - kwargs_ani, kwargs_lens = self.param_array2kwargs(param_array=param_array) + kwargs_ani, kwargs_lens = self.param_array2kwargs( + param_array=param_array + ) kwargs_anisotropy = self.anisotropy_kwargs(**kwargs_ani) - j_kin_ani = self.j_kin_draw(kwargs_anisotropy, no_error=True, **kwargs_lens) + j_kin_ani = self.j_kin_draw( + kwargs_anisotropy, no_error=True, **kwargs_lens + ) for s, j_kin in enumerate(j_kin_ani): - ani_scaling_array_list[s][i, j] = ( - j_kin / j_ani_0[s] - ) + ani_scaling_array_list[s][i, j] = j_kin / j_ani_0[s] elif num == 3: for i, param_i in enumerate(self.kin_scaling_param_array[0]): for j, param_j in enumerate(self.kin_scaling_param_array[1]): for k, param_k in enumerate(self.kin_scaling_param_array[2]): param_array = [param_i, param_j, param_k] - kwargs_ani, kwargs_lens = self.param_array2kwargs(param_array=param_array) + kwargs_ani, kwargs_lens = self.param_array2kwargs( + param_array=param_array + ) kwargs_anisotropy = self.anisotropy_kwargs(**kwargs_ani) - j_kin_ani = self.j_kin_draw(kwargs_anisotropy, no_error=True, **kwargs_lens) + j_kin_ani = self.j_kin_draw( + kwargs_anisotropy, no_error=True, **kwargs_lens + ) for s, j_kin in enumerate(j_kin_ani): - ani_scaling_array_list[s][i, j, k] = ( - j_kin / j_ani_0[s] - ) + ani_scaling_array_list[s][i, j, k] = j_kin / j_ani_0[s] else: - ValueError("Kin scaling with parameter dimension %s not supported, chose between 1-3." % num) + ValueError( + "Kin scaling with parameter dimension %s not supported, chose between 1-3." + % num + ) return ani_scaling_array_list diff --git a/hierarc/LensPosterior/kin_scaling_config.py b/hierarc/LensPosterior/kin_scaling_config.py index 711775b8..f9ae31c0 100644 --- a/hierarc/LensPosterior/kin_scaling_config.py +++ b/hierarc/LensPosterior/kin_scaling_config.py @@ -7,7 +7,12 @@ class KinScalingConfig(KinScalingParamManager): processing.""" def __init__( - self, anisotropy_model, r_eff, gamma_in_scaling=None, log_m2l_scaling=None, gamma_pl_scaling=None + self, + anisotropy_model, + r_eff, + gamma_in_scaling=None, + log_m2l_scaling=None, + gamma_pl_scaling=None, ): """ @@ -56,7 +61,9 @@ def __init__( if gamma_pl_scaling is not None: self._param_name_list.append("gamma_pl") self._ani_param_array.append(np.array(gamma_pl_scaling)) - KinScalingParamManager.__init__(self, j_kin_scaling_param_name_list=self._param_name_list) + KinScalingParamManager.__init__( + self, j_kin_scaling_param_name_list=self._param_name_list + ) @property def kwargs_anisotropy_base(self): diff --git a/hierarc/Likelihood/kin_scaling.py b/hierarc/Likelihood/kin_scaling.py index 299858f6..44b10229 100644 --- a/hierarc/Likelihood/kin_scaling.py +++ b/hierarc/Likelihood/kin_scaling.py @@ -7,9 +7,7 @@ class KinScalingParamManager(object): - """ - class to handle the sorting of parameters in the kinematics scaling - """ + """Class to handle the sorting of parameters in the kinematics scaling.""" def __init__(self, j_kin_scaling_param_name_list): """ @@ -25,8 +23,7 @@ def __init__(self, j_kin_scaling_param_name_list): @property def num_scaling_dim(self): - """ - number of parameter dimensions for kinematic scaling + """Number of parameter dimensions for kinematic scaling. :return: number of scaling dimensions :rtype: int @@ -51,9 +48,8 @@ def kwargs2param_array(self, kwargs): return param_array def param_array2kwargs(self, param_array): - """ - inverse function of kwargs2param_array - for a given param_array returns the dictionary split in anisotropy and lens models + """Inverse function of kwargs2param_array for a given param_array returns the + dictionary split in anisotropy and lens models. :param param_array: :return: kwargs_anisotropy, kwargs_lens @@ -162,7 +158,9 @@ def __init__( self._dim_scaling = len(j_kin_scaling_param_axes) else: self._dim_scaling = 1 - KinScalingParamManager.__init__(self, j_kin_scaling_param_name_list=j_kin_scaling_param_name_list) + KinScalingParamManager.__init__( + self, j_kin_scaling_param_name_list=j_kin_scaling_param_name_list + ) def param_bounds_interpol(self): """Minimum and maximum bounds of parameters that are being used to call From f01f94289939608f668b27f8806c9f7e2a72d91f Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Tue, 2 Jul 2024 14:04:32 -0400 Subject: [PATCH 33/62] added tests --- test/test_Likelihood/test_kin_scaling.py | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/test/test_Likelihood/test_kin_scaling.py b/test/test_Likelihood/test_kin_scaling.py index c92bf4a8..353d7ffa 100644 --- a/test/test_Likelihood/test_kin_scaling.py +++ b/test/test_Likelihood/test_kin_scaling.py @@ -2,7 +2,7 @@ import numpy.testing as npt import pytest -from hierarc.Likelihood.kin_scaling import KinScaling, ParameterScalingSingleMeasurement +from hierarc.Likelihood.kin_scaling import KinScaling, ParameterScalingSingleMeasurement, KinScalingParamManager class TestKinScaling(object): @@ -286,5 +286,18 @@ def test_kin_scaling(self): assert scaling[0] == 1 * 2 * 2.9 +class TestKinScalingParamManager(object): + + def test_(self): + kin_param_manager = KinScalingParamManager(j_kin_scaling_param_name_list=["gamma_pl", "a_ani", "beta_inf"]) + param_array = [1, 2, 3] + kwargs_anisotropy, kwargs_deflector = kin_param_manager.param_array2kwargs(param_array=param_array) + assert kwargs_deflector["gamma_pl"] == param_array[0] + + param_array_new = kin_param_manager.kwargs2param_array(kwargs={**kwargs_anisotropy, **kwargs_deflector}) + for i, param in enumerate(param_array_new): + assert param == param_array[i] + + if __name__ == "__main__": pytest.main() From 7a9d2dd8560c9e3946907298c417e77326a24407 Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Tue, 2 Jul 2024 23:33:14 -0400 Subject: [PATCH 34/62] priors reformulated --- hierarc/LensPosterior/kin_constraints.py | 7 ++++ .../kin_constraints_composite.py | 10 ++++-- hierarc/Likelihood/hierarchy_likelihood.py | 24 ++++--------- hierarc/Likelihood/prior_likelihood.py | 36 +++++++++++++++++++ .../test_Likelihood/test_prior_likelilhood.py | 25 +++++++++++++ 5 files changed, 81 insertions(+), 21 deletions(-) create mode 100644 hierarc/Likelihood/prior_likelihood.py create mode 100644 test/test_Likelihood/test_prior_likelilhood.py diff --git a/hierarc/LensPosterior/kin_constraints.py b/hierarc/LensPosterior/kin_constraints.py index a18a7aba..b4a449ff 100644 --- a/hierarc/LensPosterior/kin_constraints.py +++ b/hierarc/LensPosterior/kin_constraints.py @@ -186,6 +186,13 @@ def hierarchy_configuration(self, num_sample_model=20): "j_kin_scaling_param_axes": self.kin_scaling_param_array, "j_kin_scaling_grid_list": ani_scaling_array_list, } + prior_list = [] + if "gamma_pl" in self._param_name_list: + prior_list.append(["gamma_pl", self._gamma, self._gamma_error]) + # TODO: make sure to add other priors if needed or available + #if "gamma_in" in self._param_name_list: + # prior_list.append(["gamma_in"]) + kwargs_likelihood["prior_list"] = prior_list return kwargs_likelihood def model_marginalization(self, num_sample_model=20): diff --git a/hierarc/LensPosterior/kin_constraints_composite.py b/hierarc/LensPosterior/kin_constraints_composite.py index 60bcc145..75b3b7f9 100644 --- a/hierarc/LensPosterior/kin_constraints_composite.py +++ b/hierarc/LensPosterior/kin_constraints_composite.py @@ -404,13 +404,17 @@ def hierarchy_configuration(self, num_sample_model=20): # "gamma_in_array": self.gamma_in_array, # "log_m2l_array": self.log_m2l_array, # "param_scaling_grid_list": ani_scaling_grid_list, - "gamma_in_prior_mean": self._gamma_in_prior_mean, - "gamma_in_prior_std": self._gamma_in_prior_std, + "kin_scaling_param_list": self.param_name_list, "j_kin_scaling_param_axes": self.kin_scaling_param_array, "j_kin_scaling_grid_list": ani_scaling_grid_list, } - + prior_list = None + if self.gamma_in_array is not None \ + and self._gamma_in_prior_mean is not None \ + and self._gamma_in_prior_std is not None: + prior_list =[["gamma_in", self._gamma_in_prior_mean, self._gamma_in_prior_std]] + kwargs_likelihood["prior_list"] = prior_list # if not self._is_m2l_population_level: # kwargs_likelihood["log_m2l_array"] = None return kwargs_likelihood diff --git a/hierarc/Likelihood/hierarchy_likelihood.py b/hierarc/Likelihood/hierarchy_likelihood.py index 16ba54fb..b67feaa1 100644 --- a/hierarc/Likelihood/hierarchy_likelihood.py +++ b/hierarc/Likelihood/hierarchy_likelihood.py @@ -1,6 +1,7 @@ from hierarc.Likelihood.transformed_cosmography import TransformedCosmography from hierarc.Likelihood.LensLikelihood.base_lens_likelihood import LensLikelihoodBase from hierarc.Likelihood.kin_scaling import KinScaling +from hierarc.Likelihood.prior_likelihood import PriorLikelihood from hierarc.Sampling.Distributions.los_distributions import LOSDistribution from hierarc.Sampling.Distributions.anisotropy_distributions import ( AnisotropyDistribution, @@ -53,8 +54,7 @@ def __init__( kappa_pdf=None, kappa_bin_edges=None, # priors - gamma_in_prior_mean=None, # TODO: make a separate prior class with inputs - gamma_in_prior_std=None, + prior_list=None, # specifics for each lens **kwargs_likelihood ): @@ -85,8 +85,8 @@ def __init__( :param normalized: bool, if True, returns the normalized likelihood, if False, separates the constant prefactor (in case of a Gaussian 1/(sigma sqrt(2 pi)) ) to compute the reduced chi2 statistics :param kwargs_lens_properties: keyword arguments of the lens properties - :param gamma_in_prior_mean: prior mean for inner power-law slope of the NFW profile, if available - :param gamma_in_prior_std: standard deviation of the Gaussian prior for gamma_in + :param prior_list: list of [[name, mean, sigma], [],...] for priors on parameters being sampled for + individual lenses :param kwargs_likelihood: keyword arguments specifying the likelihood function, see individual classes for their use :param los_distributions: list of all line of sight distributions parameterized @@ -148,9 +148,7 @@ def __init__( kwargs_anisotropy_min=kwargs_min, kwargs_anisotropy_max=kwargs_max, ) - - self._gamma_in_prior_mean = gamma_in_prior_mean - self._gamma_in_prior_std = gamma_in_prior_std + self._prior = PriorLikelihood(prior_list=prior_list) def lens_log_likelihood( self, @@ -312,17 +310,7 @@ def log_likelihood_single( sigma_v_sys_error=sigma_v_sys_error, mu_intrinsic=mag_source_, ) - - if ( - self._gamma_in_prior_mean is not None - and self._gamma_in_prior_std is not None - and "gamma_in" in kwargs_lens_draw - ): - gamma_in = kwargs_lens_draw["gamma_in"] - lnlikelihood -= (self._gamma_in_prior_mean - gamma_in) ** 2 / ( - 2 * self._gamma_in_prior_std**2 - ) - + lnlikelihood += self._prior.log_likelihood(kwargs_param) return np.nan_to_num(lnlikelihood) def angular_diameter_distances(self, cosmo): diff --git a/hierarc/Likelihood/prior_likelihood.py b/hierarc/Likelihood/prior_likelihood.py new file mode 100644 index 00000000..bff436ad --- /dev/null +++ b/hierarc/Likelihood/prior_likelihood.py @@ -0,0 +1,36 @@ + + +class PriorLikelihood(object): + """ + class to define priors for individual lenses, e.g. from lens models etc. + """ + + def __init__(self, prior_list=None): + """ + + :param prior_list: list of [[name, mean, sigma], [],...] + """ + if prior_list is None: + prior_list = [] + self._prior_list = prior_list + self._param_name_list = [] + self._param_mean_list = [] + self._param_sigma_list = [] + print(prior_list, 'test prior_list') + for i, param in enumerate(prior_list): + self._param_name_list.append(param[0]) + self._param_mean_list.append(param[1]) + self._param_sigma_list.append(param[2]) + + def log_likelihood(self, kwargs): + """ + + :param kwargs: + :type kwargs: dict + :return: log likelihood + """ + lnlikelihood = 0 + for i, param in enumerate(self._param_name_list): + if param in kwargs: + lnlikelihood -= (kwargs[param] - self._param_mean_list[i]) ** 2 / (2 * self._param_sigma_list[i] ** 2) + return lnlikelihood diff --git a/test/test_Likelihood/test_prior_likelilhood.py b/test/test_Likelihood/test_prior_likelilhood.py new file mode 100644 index 00000000..9dbc7330 --- /dev/null +++ b/test/test_Likelihood/test_prior_likelilhood.py @@ -0,0 +1,25 @@ +from hierarc.Likelihood.prior_likelihood import PriorLikelihood +import numpy.testing as npt + + +class TestPriorLikelihood(object): + + def test_likelihood(self): + prior_list = [["a", 0, 1], ["b", 1, 0.1]] + prior_likelihood = PriorLikelihood(prior_list=prior_list) + + kwargs = {"a": 0} + ln_l = prior_likelihood.log_likelihood(kwargs) + npt.assert_almost_equal(ln_l, 0, decimal=5) + + kwargs = {"a": 1} + ln_l = prior_likelihood.log_likelihood(kwargs) + npt.assert_almost_equal(ln_l, -1/2, decimal=5) + + kwargs = {"a": 1, "b": 1} + ln_l = prior_likelihood.log_likelihood(kwargs) + npt.assert_almost_equal(ln_l, -1 / 2, decimal=5) + + prior_likelihood = PriorLikelihood(prior_list=None) + ln_l = prior_likelihood.log_likelihood(kwargs) + npt.assert_almost_equal(ln_l, 0, decimal=5) From 721e13b03bd6d96cfc220427c5096b01e4cf415a Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Wed, 3 Jul 2024 03:33:40 +0000 Subject: [PATCH 35/62] [pre-commit.ci] auto fixes from pre-commit.com hooks --- hierarc/LensPosterior/kin_constraints.py | 2 +- .../LensPosterior/kin_constraints_composite.py | 13 ++++++++----- hierarc/Likelihood/prior_likelihood.py | 12 +++++------- test/test_Likelihood/test_kin_scaling.py | 18 ++++++++++++++---- test/test_Likelihood/test_prior_likelilhood.py | 2 +- 5 files changed, 29 insertions(+), 18 deletions(-) diff --git a/hierarc/LensPosterior/kin_constraints.py b/hierarc/LensPosterior/kin_constraints.py index e81aa686..16ff378e 100644 --- a/hierarc/LensPosterior/kin_constraints.py +++ b/hierarc/LensPosterior/kin_constraints.py @@ -191,7 +191,7 @@ def hierarchy_configuration(self, num_sample_model=20): if "gamma_pl" in self._param_name_list: prior_list.append(["gamma_pl", self._gamma, self._gamma_error]) # TODO: make sure to add other priors if needed or available - #if "gamma_in" in self._param_name_list: + # if "gamma_in" in self._param_name_list: # prior_list.append(["gamma_in"]) kwargs_likelihood["prior_list"] = prior_list return kwargs_likelihood diff --git a/hierarc/LensPosterior/kin_constraints_composite.py b/hierarc/LensPosterior/kin_constraints_composite.py index 75b3b7f9..92dab5db 100644 --- a/hierarc/LensPosterior/kin_constraints_composite.py +++ b/hierarc/LensPosterior/kin_constraints_composite.py @@ -404,16 +404,19 @@ def hierarchy_configuration(self, num_sample_model=20): # "gamma_in_array": self.gamma_in_array, # "log_m2l_array": self.log_m2l_array, # "param_scaling_grid_list": ani_scaling_grid_list, - "kin_scaling_param_list": self.param_name_list, "j_kin_scaling_param_axes": self.kin_scaling_param_array, "j_kin_scaling_grid_list": ani_scaling_grid_list, } prior_list = None - if self.gamma_in_array is not None \ - and self._gamma_in_prior_mean is not None \ - and self._gamma_in_prior_std is not None: - prior_list =[["gamma_in", self._gamma_in_prior_mean, self._gamma_in_prior_std]] + if ( + self.gamma_in_array is not None + and self._gamma_in_prior_mean is not None + and self._gamma_in_prior_std is not None + ): + prior_list = [ + ["gamma_in", self._gamma_in_prior_mean, self._gamma_in_prior_std] + ] kwargs_likelihood["prior_list"] = prior_list # if not self._is_m2l_population_level: # kwargs_likelihood["log_m2l_array"] = None diff --git a/hierarc/Likelihood/prior_likelihood.py b/hierarc/Likelihood/prior_likelihood.py index bff436ad..a62acf3f 100644 --- a/hierarc/Likelihood/prior_likelihood.py +++ b/hierarc/Likelihood/prior_likelihood.py @@ -1,9 +1,5 @@ - - class PriorLikelihood(object): - """ - class to define priors for individual lenses, e.g. from lens models etc. - """ + """Class to define priors for individual lenses, e.g. from lens models etc.""" def __init__(self, prior_list=None): """ @@ -16,7 +12,7 @@ def __init__(self, prior_list=None): self._param_name_list = [] self._param_mean_list = [] self._param_sigma_list = [] - print(prior_list, 'test prior_list') + print(prior_list, "test prior_list") for i, param in enumerate(prior_list): self._param_name_list.append(param[0]) self._param_mean_list.append(param[1]) @@ -32,5 +28,7 @@ def log_likelihood(self, kwargs): lnlikelihood = 0 for i, param in enumerate(self._param_name_list): if param in kwargs: - lnlikelihood -= (kwargs[param] - self._param_mean_list[i]) ** 2 / (2 * self._param_sigma_list[i] ** 2) + lnlikelihood -= (kwargs[param] - self._param_mean_list[i]) ** 2 / ( + 2 * self._param_sigma_list[i] ** 2 + ) return lnlikelihood diff --git a/test/test_Likelihood/test_kin_scaling.py b/test/test_Likelihood/test_kin_scaling.py index 353d7ffa..4d19d52c 100644 --- a/test/test_Likelihood/test_kin_scaling.py +++ b/test/test_Likelihood/test_kin_scaling.py @@ -2,7 +2,11 @@ import numpy.testing as npt import pytest -from hierarc.Likelihood.kin_scaling import KinScaling, ParameterScalingSingleMeasurement, KinScalingParamManager +from hierarc.Likelihood.kin_scaling import ( + KinScaling, + ParameterScalingSingleMeasurement, + KinScalingParamManager, +) class TestKinScaling(object): @@ -289,12 +293,18 @@ def test_kin_scaling(self): class TestKinScalingParamManager(object): def test_(self): - kin_param_manager = KinScalingParamManager(j_kin_scaling_param_name_list=["gamma_pl", "a_ani", "beta_inf"]) + kin_param_manager = KinScalingParamManager( + j_kin_scaling_param_name_list=["gamma_pl", "a_ani", "beta_inf"] + ) param_array = [1, 2, 3] - kwargs_anisotropy, kwargs_deflector = kin_param_manager.param_array2kwargs(param_array=param_array) + kwargs_anisotropy, kwargs_deflector = kin_param_manager.param_array2kwargs( + param_array=param_array + ) assert kwargs_deflector["gamma_pl"] == param_array[0] - param_array_new = kin_param_manager.kwargs2param_array(kwargs={**kwargs_anisotropy, **kwargs_deflector}) + param_array_new = kin_param_manager.kwargs2param_array( + kwargs={**kwargs_anisotropy, **kwargs_deflector} + ) for i, param in enumerate(param_array_new): assert param == param_array[i] diff --git a/test/test_Likelihood/test_prior_likelilhood.py b/test/test_Likelihood/test_prior_likelilhood.py index 9dbc7330..fdca4811 100644 --- a/test/test_Likelihood/test_prior_likelilhood.py +++ b/test/test_Likelihood/test_prior_likelilhood.py @@ -14,7 +14,7 @@ def test_likelihood(self): kwargs = {"a": 1} ln_l = prior_likelihood.log_likelihood(kwargs) - npt.assert_almost_equal(ln_l, -1/2, decimal=5) + npt.assert_almost_equal(ln_l, -1 / 2, decimal=5) kwargs = {"a": 1, "b": 1} ln_l = prior_likelihood.log_likelihood(kwargs) From 65f971b12461cae7a92e8f0d793e28c5ec444e04 Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Fri, 5 Jul 2024 14:45:23 -0400 Subject: [PATCH 36/62] first implementation of sampling individual power-law density profiles --- hierarc/LensPosterior/ddt_kin_constraints.py | 15 +++++++++++++++ hierarc/LensPosterior/kin_constraints.py | 2 ++ hierarc/Likelihood/cosmo_likelihood.py | 3 ++- hierarc/Likelihood/hierarchy_likelihood.py | 4 ++++ hierarc/Likelihood/lens_sample_likelihood.py | 18 +++++++++++++++++- .../Distributions/lens_distribution.py | 16 ++++++++++++++++ hierarc/Sampling/ParamManager/lens_param.py | 17 +++++++++++++++++ hierarc/Sampling/ParamManager/param_manager.py | 3 +++ .../test_ParamManager/test_lens_param.py | 8 ++++++-- 9 files changed, 82 insertions(+), 4 deletions(-) diff --git a/hierarc/LensPosterior/ddt_kin_constraints.py b/hierarc/LensPosterior/ddt_kin_constraints.py index 3c825e2a..4aa76f9e 100644 --- a/hierarc/LensPosterior/ddt_kin_constraints.py +++ b/hierarc/LensPosterior/ddt_kin_constraints.py @@ -36,6 +36,7 @@ def __init__( num_psf_sampling=100, num_kin_sampling=1000, multi_observations=False, + gamma_pl_scaling=None, ): """ @@ -67,6 +68,7 @@ def __init__( :param kappa_ext_sigma: 1-sigma distribution uncertainty from which the ddt constraints are coming from :param multi_observations: bool, if True, interprets kwargs_aperture and kwargs_seeing as lists of multiple observations + :param gamma_pl_scaling: array of mass density profile power-law slope values (optional, otherwise None) """ self._ddt_sample, self._ddt_weights = ddt_samples, ddt_weights self._kappa_ext_mean, self._kappa_ext_sigma = kappa_ext, kappa_ext_sigma @@ -96,6 +98,7 @@ def __init__( num_psf_sampling=num_psf_sampling, num_kin_sampling=num_kin_sampling, multi_observations=multi_observations, + gamma_pl_scaling=gamma_pl_scaling, ) def hierarchy_configuration(self, num_sample_model=20): @@ -128,4 +131,16 @@ def hierarchy_configuration(self, num_sample_model=20): "j_kin_scaling_param_axes": self.kin_scaling_param_array, "j_kin_scaling_grid_list": ani_scaling_array_list, } + + prior_list = [] + if "gamma_pl" in self._param_name_list: + prior_list.append(["gamma_pl", self._gamma, self._gamma_error]) + # TODO: make sure to add other priors if needed or available + # if "gamma_in" in self._param_name_list: + # prior_list.append(["gamma_in"]) + kwargs_likelihood["prior_list"] = prior_list + if "gamma_pl" in self._param_name_list: + kwargs_likelihood["gamma_pl_sampling"] = True + + return kwargs_likelihood diff --git a/hierarc/LensPosterior/kin_constraints.py b/hierarc/LensPosterior/kin_constraints.py index e81aa686..c1325451 100644 --- a/hierarc/LensPosterior/kin_constraints.py +++ b/hierarc/LensPosterior/kin_constraints.py @@ -194,6 +194,8 @@ def hierarchy_configuration(self, num_sample_model=20): #if "gamma_in" in self._param_name_list: # prior_list.append(["gamma_in"]) kwargs_likelihood["prior_list"] = prior_list + if "gamma_pl" in self._param_name_list: + kwargs_likelihood["gamma_pl_sampling"] = True return kwargs_likelihood def model_marginalization(self, num_sample_model=20): diff --git a/hierarc/Likelihood/cosmo_likelihood.py b/hierarc/Likelihood/cosmo_likelihood.py index 8ad2a06f..b3d58694 100644 --- a/hierarc/Likelihood/cosmo_likelihood.py +++ b/hierarc/Likelihood/cosmo_likelihood.py @@ -60,7 +60,8 @@ def __init__( normalized=normalized, kwargs_global_model=kwargs_model, ) - self.param = ParamManager(cosmology, **kwargs_model, **kwargs_bounds) + gamma_pl_num = self._likelihoodLensSample.gamma_pl_num + self.param = ParamManager(cosmology, gamma_pl_num=gamma_pl_num, **kwargs_model, **kwargs_bounds) self._lower_limit, self._upper_limit = self.param.param_bounds self._prior_add = False if custom_prior is not None: diff --git a/hierarc/Likelihood/hierarchy_likelihood.py b/hierarc/Likelihood/hierarchy_likelihood.py index b67feaa1..bc645aea 100644 --- a/hierarc/Likelihood/hierarchy_likelihood.py +++ b/hierarc/Likelihood/hierarchy_likelihood.py @@ -43,6 +43,7 @@ def __init__( alpha_gamma_in_sampling=False, alpha_log_m2l_sampling=False, log_scatter=False, + gamma_pl_index=None, # kinematic model quantities kin_scaling_param_list=None, j_kin_scaling_param_axes=None, @@ -82,6 +83,8 @@ def __init__( lambda_mst = lambda_mst_global + alpha * lambda_scaling_property :param lambda_scaling_property_beta: float (optional), scaling of lambda_mst = lambda_mst_global + beta * lambda_scaling_property_beta + :param gamma_pl_index: index of gamma_pl parameter associated with this lens + :type gamma_pl_index: int or None :param normalized: bool, if True, returns the normalized likelihood, if False, separates the constant prefactor (in case of a Gaussian 1/(sigma sqrt(2 pi)) ) to compute the reduced chi2 statistics :param kwargs_lens_properties: keyword arguments of the lens properties @@ -139,6 +142,7 @@ def __init__( lambda_scaling_property_beta=lambda_scaling_property_beta, kwargs_min=kwargs_min, kwargs_max=kwargs_max, + gamma_pl_index=gamma_pl_index, ) self._aniso_distribution = AnisotropyDistribution( diff --git a/hierarc/Likelihood/lens_sample_likelihood.py b/hierarc/Likelihood/lens_sample_likelihood.py index a8e1431d..d320bdbe 100644 --- a/hierarc/Likelihood/lens_sample_likelihood.py +++ b/hierarc/Likelihood/lens_sample_likelihood.py @@ -21,7 +21,14 @@ def __init__(self, kwargs_lens_list, normalized=False, kwargs_global_model=None) if kwargs_global_model is None: kwargs_global_model = {} self._lens_list = [] + self._gamma_pl_num = 0 + gamma_pl_index = 0 for kwargs_lens in kwargs_lens_list: + gamma_pl_index_ = None + if kwargs_lens.get("gamma_pl_sampling", False) is True: + self._gamma_pl_num += 1 + gamma_pl_index_ = copy.deepcopy(gamma_pl_index) + gamma_pl_index += 1 if kwargs_lens["likelihood_type"] == "DSPL": _kwargs_lens = copy.deepcopy(kwargs_lens) _kwargs_lens.pop("likelihood_type") @@ -32,7 +39,7 @@ def __init__(self, kwargs_lens_list, normalized=False, kwargs_global_model=None) kwargs_lens_ = self._merge_global2local_settings( kwargs_global_model=kwargs_global_model, kwargs_lens=kwargs_lens ) - self._lens_list.append(LensLikelihood(**kwargs_lens_)) + self._lens_list.append(LensLikelihood(gamma_pl_index=gamma_pl_index_, **kwargs_lens_)) def log_likelihood( self, @@ -72,6 +79,15 @@ def num_data(self): num += lens.num_data() return num + @property + def gamma_pl_num(self): + """ + number of power-law density slope parameters being sampled on individual lenses + + :return: number of power-law density slope parameters being sampled on individual lenses + """ + return self._gamma_pl_num + @staticmethod def _merge_global2local_settings(kwargs_global_model, kwargs_lens): """ diff --git a/hierarc/Sampling/Distributions/lens_distribution.py b/hierarc/Sampling/Distributions/lens_distribution.py index 0c98b168..8e6a706e 100644 --- a/hierarc/Sampling/Distributions/lens_distribution.py +++ b/hierarc/Sampling/Distributions/lens_distribution.py @@ -22,6 +22,7 @@ def __init__( lambda_scaling_property_beta=0, kwargs_min=None, kwargs_max=None, + gamma_pl_index=None, ): """ @@ -52,6 +53,8 @@ def __init__( :type kwargs_min: dict or None :param kwargs_max: maximum arguments of parameters supported by each lens :type kwargs_max: dict or None + :param gamma_pl_index: index of gamma_pl parameter associated with this lens + :type gamma_pl_index: int or None """ self._lambda_mst_sampling = lambda_mst_sampling self._lambda_mst_distribution = lambda_mst_distribution @@ -78,6 +81,12 @@ def __init__( self._log_m2l_min, self._log_m2l_max = kwargs_min.get( "log_m2l", -np.inf ), kwargs_max.get("log_m2l", np.inf) + if gamma_pl_index is not None: + self._gamma_pl_model = True + self._gamma_pl_index = gamma_pl_index + else: + self._gamma_pl_model = False + self._gamma_pl_index = None def draw_lens( self, @@ -94,6 +103,7 @@ def draw_lens( log_m2l=1, log_m2l_sigma=0, alpha_log_m2l=0, + gamma_pl_list=None, ): """Draws a realization of a specific model from the hyperparameter distribution. @@ -116,6 +126,8 @@ def draw_lens( :param log_m2l_sigma: spread in the distribution :param alpha_log_m2l: float, linear slope of the log(m2l) scaling relation with lens quantity self._lambda_scaling_property + :param gamma_pl_list: power-law density slopes as lists (for multiple lenses) + :type gamma_pl_list: list or None :return: draw from the distributions """ kwargs_return = {} @@ -165,6 +177,7 @@ def draw_lens( log_m2l=log_m2l, log_m2l_sigma=log_m2l_sigma, alpha_log_m2l=alpha_log_m2l, + gamma_pl_list=gamma_pl_list, ) kwargs_return["gamma_in"] = gamma_in_draw if self._log_m2l_sampling: @@ -192,6 +205,9 @@ def draw_lens( log_m2l=log_m2l, log_m2l_sigma=log_m2l_sigma, alpha_log_m2l=alpha_log_m2l, + gamma_pl_list=gamma_pl_list, ) kwargs_return["log_m2l"] = log_m2l_draw + if self._gamma_pl_model is True: + kwargs_return["gamma_pl"] = gamma_pl_list[self._gamma_pl_index] return kwargs_return diff --git a/hierarc/Sampling/ParamManager/lens_param.py b/hierarc/Sampling/ParamManager/lens_param.py index 9b2e03af..3b3b3eae 100644 --- a/hierarc/Sampling/ParamManager/lens_param.py +++ b/hierarc/Sampling/ParamManager/lens_param.py @@ -18,6 +18,7 @@ def __init__( beta_lambda_sampling=False, alpha_gamma_in_sampling=False, alpha_log_m2l_sampling=False, + gamma_pl_num=0, kwargs_fixed=None, log_scatter=False, ): @@ -45,6 +46,7 @@ def __init__( according to a predefined quantity of the lens :param alpha_gamma_in_sampling: bool, if True samples a parameter alpha_gamma_in, which scales gamma_in linearly :param alpha_log_m2l_sampling: bool, if True samples a parameter alpha_log_m2l, which scales log_m2l linearly + :param gamma_pl_num: int, number of power-law density slopes being sampled (to be assigned to individual lenses) :param log_scatter: boolean, if True, samples the Gaussian scatter amplitude in log space (and thus flat prior in log) :param kwargs_fixed: keyword arguments that are held fixed through the sampling """ @@ -60,6 +62,7 @@ def __init__( self._beta_lambda_sampling = beta_lambda_sampling self._alpha_gamma_in_sampling = alpha_gamma_in_sampling self._alpha_log_m2l_sampling = alpha_log_m2l_sampling + self._gamma_pl_num = gamma_pl_num self._log_scatter = log_scatter if kwargs_fixed is None: @@ -157,6 +160,11 @@ def param_list(self, latex_style=False): list.append(r"$\alpha_{\Upsilon_{\rm stars}}$") else: list.append("alpha_log_m2l") + for i in range(self._gamma_pl_num): + if latex_style is True: + list.append(r"$\gamma_{\rm pl %i}$" % i) + else: + list.append("gamma_pl_%s" % i) return list def args2kwargs(self, args, i=0): @@ -250,6 +258,12 @@ def args2kwargs(self, args, i=0): else: kwargs["alpha_log_m2l"] = args[i] i += 1 + if self._gamma_pl_num > 0: + gamma_pl_list = [] + for k in range(self._gamma_pl_num): + gamma_pl_list.append(args[i]) + i += 1 + kwargs["gamma_pl_list"] = gamma_pl_list return kwargs, i @@ -308,4 +322,7 @@ def kwargs2args(self, kwargs): if self._alpha_log_m2l_sampling is True: if "alpha_log_m2l" not in self._kwargs_fixed: args.append(kwargs["alpha_log_m2l"]) + if self._gamma_pl_num > 0: + for i in range(self._gamma_pl_num): + args.append(kwargs["gamma_pl_list"][i]) return args diff --git a/hierarc/Sampling/ParamManager/param_manager.py b/hierarc/Sampling/ParamManager/param_manager.py index 8b87363d..4acf7604 100644 --- a/hierarc/Sampling/ParamManager/param_manager.py +++ b/hierarc/Sampling/ParamManager/param_manager.py @@ -27,6 +27,7 @@ def __init__( beta_lambda_sampling=False, alpha_gamma_in_sampling=False, alpha_log_m2l_sampling=False, + gamma_pl_num=0, sigma_v_systematics=False, sne_apparent_m_sampling=False, sne_distribution="GAUSSIAN", @@ -74,6 +75,7 @@ def __init__( according to a predefined quantity of the lens :param alpha_log_m2l_sampling: bool, if True samples a parameter alpha_log_m2l, which scales log_m2l linearly according to a predefined quantity of the lens + :param gamma_pl_num: int, number of power-law density slopes being sampled (to be assigned to individual lenses) :param sne_apparent_m_sampling: boolean, if True, samples/queries SNe unlensed magnitude distribution (not intrinsic magnitudes but apparent!) :param sne_distribution: string, apparent non-lensed brightness distribution (in linear space). @@ -115,6 +117,7 @@ def __init__( beta_lambda_sampling=beta_lambda_sampling, alpha_gamma_in_sampling=alpha_gamma_in_sampling, alpha_log_m2l_sampling=alpha_log_m2l_sampling, + gamma_pl_num=gamma_pl_num, log_scatter=log_scatter, kwargs_fixed=kwargs_fixed_lens, ) diff --git a/test/test_Sampling/test_ParamManager/test_lens_param.py b/test/test_Sampling/test_ParamManager/test_lens_param.py index 9267d3e2..18d9e337 100644 --- a/test/test_Sampling/test_ParamManager/test_lens_param.py +++ b/test/test_Sampling/test_ParamManager/test_lens_param.py @@ -12,6 +12,7 @@ def setup_method(self): alpha_lambda_sampling=True, beta_lambda_sampling=True, kwargs_fixed={}, + gamma_pl_num=2, ) kwargs_fixed = { @@ -44,9 +45,9 @@ def setup_method(self): def test_param_list(self): param_list = self._param.param_list(latex_style=False) - assert len(param_list) == 6 + assert len(param_list) == 8 param_list = self._param.param_list(latex_style=True) - assert len(param_list) == 6 + assert len(param_list) == 8 param_list = self._param_log_scatter.param_list(latex_style=False) assert len(param_list) == 6 @@ -68,9 +69,12 @@ def test_args2kwargs(self): "kappa_ext_sigma": 0.03, "alpha_lambda": 0.1, "beta_lambda": 0.1, + "gamma_pl_list": [2, 2.5], } args = self._param.kwargs2args(kwargs) + print(args, 'test args') kwargs_new, i = self._param.args2kwargs(args, i=0) + print(kwargs_new, 'test kwargs_new') args_new = self._param.kwargs2args(kwargs_new) npt.assert_almost_equal(args_new, args) From f637d52a9ab22593c99b7bbedda8f7f14f5d1d58 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 5 Jul 2024 18:46:01 +0000 Subject: [PATCH 37/62] [pre-commit.ci] auto fixes from pre-commit.com hooks --- hierarc/LensPosterior/ddt_kin_constraints.py | 1 - hierarc/Likelihood/cosmo_likelihood.py | 4 +++- hierarc/Likelihood/lens_sample_likelihood.py | 11 +++++++---- .../test_ParamManager/test_lens_param.py | 4 ++-- 4 files changed, 12 insertions(+), 8 deletions(-) diff --git a/hierarc/LensPosterior/ddt_kin_constraints.py b/hierarc/LensPosterior/ddt_kin_constraints.py index 4aa76f9e..9542129b 100644 --- a/hierarc/LensPosterior/ddt_kin_constraints.py +++ b/hierarc/LensPosterior/ddt_kin_constraints.py @@ -142,5 +142,4 @@ def hierarchy_configuration(self, num_sample_model=20): if "gamma_pl" in self._param_name_list: kwargs_likelihood["gamma_pl_sampling"] = True - return kwargs_likelihood diff --git a/hierarc/Likelihood/cosmo_likelihood.py b/hierarc/Likelihood/cosmo_likelihood.py index b3d58694..4b1cfc75 100644 --- a/hierarc/Likelihood/cosmo_likelihood.py +++ b/hierarc/Likelihood/cosmo_likelihood.py @@ -61,7 +61,9 @@ def __init__( kwargs_global_model=kwargs_model, ) gamma_pl_num = self._likelihoodLensSample.gamma_pl_num - self.param = ParamManager(cosmology, gamma_pl_num=gamma_pl_num, **kwargs_model, **kwargs_bounds) + self.param = ParamManager( + cosmology, gamma_pl_num=gamma_pl_num, **kwargs_model, **kwargs_bounds + ) self._lower_limit, self._upper_limit = self.param.param_bounds self._prior_add = False if custom_prior is not None: diff --git a/hierarc/Likelihood/lens_sample_likelihood.py b/hierarc/Likelihood/lens_sample_likelihood.py index d320bdbe..f8167eb1 100644 --- a/hierarc/Likelihood/lens_sample_likelihood.py +++ b/hierarc/Likelihood/lens_sample_likelihood.py @@ -39,7 +39,9 @@ def __init__(self, kwargs_lens_list, normalized=False, kwargs_global_model=None) kwargs_lens_ = self._merge_global2local_settings( kwargs_global_model=kwargs_global_model, kwargs_lens=kwargs_lens ) - self._lens_list.append(LensLikelihood(gamma_pl_index=gamma_pl_index_, **kwargs_lens_)) + self._lens_list.append( + LensLikelihood(gamma_pl_index=gamma_pl_index_, **kwargs_lens_) + ) def log_likelihood( self, @@ -81,10 +83,11 @@ def num_data(self): @property def gamma_pl_num(self): - """ - number of power-law density slope parameters being sampled on individual lenses + """Number of power-law density slope parameters being sampled on individual + lenses. - :return: number of power-law density slope parameters being sampled on individual lenses + :return: number of power-law density slope parameters being sampled on + individual lenses """ return self._gamma_pl_num diff --git a/test/test_Sampling/test_ParamManager/test_lens_param.py b/test/test_Sampling/test_ParamManager/test_lens_param.py index 18d9e337..b39d30fb 100644 --- a/test/test_Sampling/test_ParamManager/test_lens_param.py +++ b/test/test_Sampling/test_ParamManager/test_lens_param.py @@ -72,9 +72,9 @@ def test_args2kwargs(self): "gamma_pl_list": [2, 2.5], } args = self._param.kwargs2args(kwargs) - print(args, 'test args') + print(args, "test args") kwargs_new, i = self._param.args2kwargs(args, i=0) - print(kwargs_new, 'test kwargs_new') + print(kwargs_new, "test kwargs_new") args_new = self._param.kwargs2args(kwargs_new) npt.assert_almost_equal(args_new, args) From d5f7faf4404a4cabc27f9012746336f75190591e Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Fri, 5 Jul 2024 19:48:32 -0400 Subject: [PATCH 38/62] fully integrated with sampling --- hierarc/LensPosterior/ddt_kin_constraints.py | 4 ++-- hierarc/LensPosterior/kin_constraints.py | 6 +++--- hierarc/Likelihood/lens_sample_likelihood.py | 11 +++++++---- hierarc/Likelihood/prior_likelihood.py | 1 - 4 files changed, 12 insertions(+), 10 deletions(-) diff --git a/hierarc/LensPosterior/ddt_kin_constraints.py b/hierarc/LensPosterior/ddt_kin_constraints.py index 4aa76f9e..c6fb840d 100644 --- a/hierarc/LensPosterior/ddt_kin_constraints.py +++ b/hierarc/LensPosterior/ddt_kin_constraints.py @@ -139,8 +139,8 @@ def hierarchy_configuration(self, num_sample_model=20): # if "gamma_in" in self._param_name_list: # prior_list.append(["gamma_in"]) kwargs_likelihood["prior_list"] = prior_list - if "gamma_pl" in self._param_name_list: - kwargs_likelihood["gamma_pl_sampling"] = True + # if "gamma_pl" in self._param_name_list: + # kwargs_likelihood["gamma_pl_sampling"] = True return kwargs_likelihood diff --git a/hierarc/LensPosterior/kin_constraints.py b/hierarc/LensPosterior/kin_constraints.py index a664e3bb..8ed46f06 100644 --- a/hierarc/LensPosterior/kin_constraints.py +++ b/hierarc/LensPosterior/kin_constraints.py @@ -188,14 +188,14 @@ def hierarchy_configuration(self, num_sample_model=20): "j_kin_scaling_grid_list": ani_scaling_array_list, } prior_list = [] - if "gamma_pl" in self._param_name_list: + if "gamma_pl" in self.param_name_list: prior_list.append(["gamma_pl", self._gamma, self._gamma_error]) # TODO: make sure to add other priors if needed or available # if "gamma_in" in self._param_name_list: # prior_list.append(["gamma_in"]) kwargs_likelihood["prior_list"] = prior_list - if "gamma_pl" in self._param_name_list: - kwargs_likelihood["gamma_pl_sampling"] = True + #if "gamma_pl" in self.param_name_list: + # kwargs_likelihood["gamma_pl_sampling"] = True return kwargs_likelihood def model_marginalization(self, num_sample_model=20): diff --git a/hierarc/Likelihood/lens_sample_likelihood.py b/hierarc/Likelihood/lens_sample_likelihood.py index d320bdbe..636da0b5 100644 --- a/hierarc/Likelihood/lens_sample_likelihood.py +++ b/hierarc/Likelihood/lens_sample_likelihood.py @@ -25,10 +25,13 @@ def __init__(self, kwargs_lens_list, normalized=False, kwargs_global_model=None) gamma_pl_index = 0 for kwargs_lens in kwargs_lens_list: gamma_pl_index_ = None - if kwargs_lens.get("gamma_pl_sampling", False) is True: - self._gamma_pl_num += 1 - gamma_pl_index_ = copy.deepcopy(gamma_pl_index) - gamma_pl_index += 1 + if "kin_scaling_param_list" in kwargs_lens: + kin_scaling_param_list = kwargs_lens["kin_scaling_param_list"] + if "gamma_pl" in kin_scaling_param_list: + self._gamma_pl_num += 1 + gamma_pl_index_ = copy.deepcopy(gamma_pl_index) + gamma_pl_index += 1 + # kwargs_lens.pop("gamma_pl_sampling") if kwargs_lens["likelihood_type"] == "DSPL": _kwargs_lens = copy.deepcopy(kwargs_lens) _kwargs_lens.pop("likelihood_type") diff --git a/hierarc/Likelihood/prior_likelihood.py b/hierarc/Likelihood/prior_likelihood.py index a62acf3f..c42e590f 100644 --- a/hierarc/Likelihood/prior_likelihood.py +++ b/hierarc/Likelihood/prior_likelihood.py @@ -12,7 +12,6 @@ def __init__(self, prior_list=None): self._param_name_list = [] self._param_mean_list = [] self._param_sigma_list = [] - print(prior_list, "test prior_list") for i, param in enumerate(prior_list): self._param_name_list.append(param[0]) self._param_mean_list.append(param[1]) From 314b6fb69ee8b0f740bbb896e7b38538c9117937 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 5 Jul 2024 23:49:01 +0000 Subject: [PATCH 39/62] [pre-commit.ci] auto fixes from pre-commit.com hooks --- hierarc/LensPosterior/kin_constraints.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/hierarc/LensPosterior/kin_constraints.py b/hierarc/LensPosterior/kin_constraints.py index 8ed46f06..085b546b 100644 --- a/hierarc/LensPosterior/kin_constraints.py +++ b/hierarc/LensPosterior/kin_constraints.py @@ -194,7 +194,7 @@ def hierarchy_configuration(self, num_sample_model=20): # if "gamma_in" in self._param_name_list: # prior_list.append(["gamma_in"]) kwargs_likelihood["prior_list"] = prior_list - #if "gamma_pl" in self.param_name_list: + # if "gamma_pl" in self.param_name_list: # kwargs_likelihood["gamma_pl_sampling"] = True return kwargs_likelihood From d36c598dc9290065fff04103904b477c72d97ddf Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Fri, 5 Jul 2024 20:43:51 -0400 Subject: [PATCH 40/62] tests improvements and base model for gamma_pl adapted --- hierarc/LensPosterior/base_config.py | 1 + hierarc/LensPosterior/kin_scaling_config.py | 5 ++++- hierarc/Likelihood/hierarchy_likelihood.py | 2 +- test/test_LensPosterior/test_kin_constraints.py | 7 +++++-- 4 files changed, 11 insertions(+), 4 deletions(-) diff --git a/hierarc/LensPosterior/base_config.py b/hierarc/LensPosterior/base_config.py index f0f3a16a..23bfd0e1 100644 --- a/hierarc/LensPosterior/base_config.py +++ b/hierarc/LensPosterior/base_config.py @@ -118,4 +118,5 @@ def __init__( gamma_in_scaling=gamma_in_scaling, log_m2l_scaling=log_m2l_scaling, gamma_pl_scaling=gamma_pl_scaling, + gamma_pl_mean=gamma, ) diff --git a/hierarc/LensPosterior/kin_scaling_config.py b/hierarc/LensPosterior/kin_scaling_config.py index f9ae31c0..980341e8 100644 --- a/hierarc/LensPosterior/kin_scaling_config.py +++ b/hierarc/LensPosterior/kin_scaling_config.py @@ -13,6 +13,7 @@ def __init__( gamma_in_scaling=None, log_m2l_scaling=None, gamma_pl_scaling=None, + gamma_pl_mean=None, ): """ @@ -22,6 +23,7 @@ def __init__( :param gamma_in_scaling: array of gamma_in parameter to be interpolated (optional, otherwise None) :param log_m2l_scaling: array of log_m2l parameter to be interpolated (optional, otherwise None) :param gamma_pl_scaling: array of power-law density profile slopes to be interpolated (optional, otherwise None) + :param gamma_pl_mean: mean gamma_pl upon which the covariances are calculated """ self._r_eff = r_eff self._anisotropy_model = anisotropy_model @@ -51,6 +53,7 @@ def __init__( self._gamma_in_scaling = gamma_in_scaling self._log_m2l_scaling = log_m2l_scaling self._gamma_pl_scaling = gamma_pl_scaling + self._gamma_pl_mean = gamma_pl_mean if gamma_in_scaling is not None: self._param_name_list.append("gamma_in") @@ -101,7 +104,7 @@ def kwargs_lens_base(self): if "log_m2l" in self._param_name_list: kwargs_base["log_m2l"] = np.mean(self._log_m2l_scaling) if "gamma_pl" in self._param_name_list: - kwargs_base["gamma_pl"] = np.mean(self._gamma_pl_scaling) + kwargs_base["gamma_pl"] = self._gamma_pl_mean return kwargs_base @property diff --git a/hierarc/Likelihood/hierarchy_likelihood.py b/hierarc/Likelihood/hierarchy_likelihood.py index bc645aea..c137ca57 100644 --- a/hierarc/Likelihood/hierarchy_likelihood.py +++ b/hierarc/Likelihood/hierarchy_likelihood.py @@ -306,7 +306,7 @@ def log_likelihood_single( kwargs_kin_draw = self._aniso_distribution.draw_anisotropy(**kwargs_kin) kwargs_param = {**kwargs_lens_draw, **kwargs_kin_draw} kin_scaling = self.kin_scaling(kwargs_param) - + print(kwargs_lens_draw, 'test kwargs_lens_draw') lnlikelihood = self.log_likelihood( ddt_, dd_, diff --git a/test/test_LensPosterior/test_kin_constraints.py b/test/test_LensPosterior/test_kin_constraints.py index b9fb7f68..5197c898 100644 --- a/test/test_LensPosterior/test_kin_constraints.py +++ b/test/test_LensPosterior/test_kin_constraints.py @@ -2,6 +2,7 @@ from lenstronomy.Analysis.kinematics_api import KinematicsAPI from hierarc.Likelihood.hierarchy_likelihood import LensLikelihood import numpy.testing as npt +import numpy as np import pytest import unittest @@ -105,15 +106,17 @@ def test_likelihoodconfiguration_om(self): kwargs_aperture=kwargs_aperture, kwargs_seeing=kwargs_seeing, anisotropy_model=anisotropy_model, + gamma_pl_scaling=np.linspace(1.8, 2.2, 5), **kwargs_kin_api_settings ) kwargs_likelihood = kin_constraints.hierarchy_configuration(num_sample_model=5) kwargs_likelihood["normalized"] = False - ln_class = LensLikelihood(**kwargs_likelihood) + ln_class = LensLikelihood(gamma_pl_index=0, **kwargs_likelihood) kwargs_kin = {"a_ani": 1} + kwargs_lens = {"gamma_pl_list": [gamma]} ln_likelihood = ln_class.lens_log_likelihood( - cosmo, kwargs_lens={}, kwargs_kin=kwargs_kin + cosmo, kwargs_lens=kwargs_lens, kwargs_kin=kwargs_kin ) npt.assert_almost_equal(ln_likelihood, 0, decimal=1) From 474d7e741e1061efb851b33f154328b5e414c981 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Sat, 6 Jul 2024 00:44:10 +0000 Subject: [PATCH 41/62] [pre-commit.ci] auto fixes from pre-commit.com hooks --- hierarc/Likelihood/hierarchy_likelihood.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/hierarc/Likelihood/hierarchy_likelihood.py b/hierarc/Likelihood/hierarchy_likelihood.py index c137ca57..4293faf4 100644 --- a/hierarc/Likelihood/hierarchy_likelihood.py +++ b/hierarc/Likelihood/hierarchy_likelihood.py @@ -306,7 +306,7 @@ def log_likelihood_single( kwargs_kin_draw = self._aniso_distribution.draw_anisotropy(**kwargs_kin) kwargs_param = {**kwargs_lens_draw, **kwargs_kin_draw} kin_scaling = self.kin_scaling(kwargs_param) - print(kwargs_lens_draw, 'test kwargs_lens_draw') + print(kwargs_lens_draw, "test kwargs_lens_draw") lnlikelihood = self.log_likelihood( ddt_, dd_, From ee1af420dfd28d23fa05182d605ca341439cc998 Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Fri, 5 Jul 2024 22:18:04 -0400 Subject: [PATCH 42/62] changed test settings --- test/test_LensPosterior/test_kin_constraints.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/test/test_LensPosterior/test_kin_constraints.py b/test/test_LensPosterior/test_kin_constraints.py index 5197c898..78d9179e 100644 --- a/test/test_LensPosterior/test_kin_constraints.py +++ b/test/test_LensPosterior/test_kin_constraints.py @@ -12,7 +12,7 @@ def setup_method(self): pass def test_likelihoodconfiguration_om(self): - anisotropy_model = "OM" + anisotropy_model = "GOM" kwargs_aperture = { "aperture_type": "shell", "r_in": 0, @@ -77,8 +77,9 @@ def test_likelihoodconfiguration_om(self): kwargs_lens = [ {"theta_E": theta_E, "gamma": gamma, "center_x": 0, "center_y": 0} ] + beta_inf = 0.9 kwargs_lens_light = [{"Rs": r_eff * 0.551, "amp": 1.0}] - kwargs_anisotropy = {"r_ani": r_eff} + kwargs_anisotropy = {"r_ani": r_eff, "beta_inf": beta_inf} sigma_v = kin_api.velocity_dispersion( kwargs_lens, kwargs_lens_light, @@ -113,7 +114,7 @@ def test_likelihoodconfiguration_om(self): kwargs_likelihood = kin_constraints.hierarchy_configuration(num_sample_model=5) kwargs_likelihood["normalized"] = False ln_class = LensLikelihood(gamma_pl_index=0, **kwargs_likelihood) - kwargs_kin = {"a_ani": 1} + kwargs_kin = {"a_ani": 1, "beta_inf": beta_inf} kwargs_lens = {"gamma_pl_list": [gamma]} ln_likelihood = ln_class.lens_log_likelihood( cosmo, kwargs_lens=kwargs_lens, kwargs_kin=kwargs_kin From 31acffe268b9e95b8cbf7339e0c092c990e9b080 Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Fri, 5 Jul 2024 23:30:59 -0400 Subject: [PATCH 43/62] added testing --- test/test_LensPosterior/test_kin_scaling_config.py | 11 +++++++++++ test/test_Likelihood/test_lens_sample_likelihood.py | 8 ++++---- 2 files changed, 15 insertions(+), 4 deletions(-) diff --git a/test/test_LensPosterior/test_kin_scaling_config.py b/test/test_LensPosterior/test_kin_scaling_config.py index 20677b8c..783710a7 100644 --- a/test/test_LensPosterior/test_kin_scaling_config.py +++ b/test/test_LensPosterior/test_kin_scaling_config.py @@ -1,3 +1,5 @@ +import numpy as np + from hierarc.LensPosterior.kin_scaling_config import KinScalingConfig import numpy.testing as npt @@ -7,6 +9,15 @@ class TestKinScalingConfig(object): def setup_method(self): pass + def test_kwargs_lens_base(self): + kin_scaling = KinScalingConfig(anisotropy_model="GOM", + r_eff=1, + gamma_pl_scaling=np.linspace(1.5, 2.5, 5), + log_m2l_scaling=np.linspace(0, 1, 5), + gamma_in_scaling=np.linspace(0.5, 1.5, 5), + ) + kin_scaling.kwargs_lens_base + def test_init(self): kin_scaling = KinScalingConfig( anisotropy_model="NONE", diff --git a/test/test_Likelihood/test_lens_sample_likelihood.py b/test/test_Likelihood/test_lens_sample_likelihood.py index f0d3b487..b2356e36 100644 --- a/test/test_Likelihood/test_lens_sample_likelihood.py +++ b/test/test_Likelihood/test_lens_sample_likelihood.py @@ -29,8 +29,8 @@ def setup_method(self): self.D_dt_true, self.sigma_Ddt, num_samples ) self.D_d_samples = np.random.normal(self.Dd_true, self.sigma_Dd, num_samples) - ani_param_array = np.linspace(0, 2, 10) - ani_scaling_array = np.ones_like(ani_param_array) + ani_param_array = [np.linspace(0, 2, 10), np.linspace(1.5, 2.5, 10)] + ani_scaling_array = np.ones((len(ani_param_array[0]), len(ani_param_array[1]))) self.kwargs_lens_list = [ { "z_lens": self.z_L, @@ -47,7 +47,7 @@ def setup_method(self): "likelihood_type": "DsDdsGaussian", "ds_dds_mean": lensCosmo.ds / lensCosmo.dds, "ds_dds_sigma": 1, - "kin_scaling_param_list": ["a_ani"], + "kin_scaling_param_list": ["a_ani", "gamma_pl"], "j_kin_scaling_param_axes": ani_param_array, "j_kin_scaling_grid_list": [ani_scaling_array], }, @@ -57,7 +57,7 @@ def setup_method(self): self.likelihood = LensSampleLikelihood(kwargs_lens_list=self.kwargs_lens_list) def test_log_likelihood(self): - kwargs_lens = {"gamma_ppn": 1} + kwargs_lens = {"gamma_ppn": 1, "gamma_pl_list": [2]} kwargs_kin = {"a_ani": 1} logl = self.likelihood.log_likelihood( self.cosmo, kwargs_lens=kwargs_lens, kwargs_kin=kwargs_kin From 78a994f1c5586b5081691866a67caea7160bec1f Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Sat, 6 Jul 2024 03:31:10 +0000 Subject: [PATCH 44/62] [pre-commit.ci] auto fixes from pre-commit.com hooks --- test/test_LensPosterior/test_kin_scaling_config.py | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/test/test_LensPosterior/test_kin_scaling_config.py b/test/test_LensPosterior/test_kin_scaling_config.py index 783710a7..680ae274 100644 --- a/test/test_LensPosterior/test_kin_scaling_config.py +++ b/test/test_LensPosterior/test_kin_scaling_config.py @@ -10,12 +10,13 @@ def setup_method(self): pass def test_kwargs_lens_base(self): - kin_scaling = KinScalingConfig(anisotropy_model="GOM", - r_eff=1, - gamma_pl_scaling=np.linspace(1.5, 2.5, 5), - log_m2l_scaling=np.linspace(0, 1, 5), - gamma_in_scaling=np.linspace(0.5, 1.5, 5), - ) + kin_scaling = KinScalingConfig( + anisotropy_model="GOM", + r_eff=1, + gamma_pl_scaling=np.linspace(1.5, 2.5, 5), + log_m2l_scaling=np.linspace(0, 1, 5), + gamma_in_scaling=np.linspace(0.5, 1.5, 5), + ) kin_scaling.kwargs_lens_base def test_init(self): From bee9c59d98620785dab4b827ec34bc4962a1510c Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Mon, 29 Jul 2024 18:56:07 -0400 Subject: [PATCH 45/62] refactored LOSDistribution --- hierarc/Likelihood/hierarchy_likelihood.py | 20 +++--- .../Distributions/los_distributions.py | 62 ++++++++++++++----- test/test_Diagnostics/test_goodness_of_fit.py | 4 +- .../test_hierarchy_likelihood.py | 22 +++---- test/test_Likelihood/test_los_distribution.py | 36 ++++++----- 5 files changed, 93 insertions(+), 51 deletions(-) diff --git a/hierarc/Likelihood/hierarchy_likelihood.py b/hierarc/Likelihood/hierarchy_likelihood.py index 4293faf4..6e327600 100644 --- a/hierarc/Likelihood/hierarchy_likelihood.py +++ b/hierarc/Likelihood/hierarchy_likelihood.py @@ -52,8 +52,8 @@ def __init__( num_distribution_draws=50, normalized=True, # kappa quantities - kappa_pdf=None, - kappa_bin_edges=None, + los_distribution_individual=None, + kwargs_los_individual=None, # priors prior_list=None, # specifics for each lens @@ -74,9 +74,16 @@ def __init__( :param global_los_distribution: if integer, will draw from the global kappa distribution specified in that integer. If False, will instead draw from the distribution specified in kappa_pdf. :type global_los_distribution: bool or integer - :param kappa_pdf: array of probability density function of the external convergence distribution + :param los_distribution_individual: name of the individual distribution ["GEV" and "PDF"] + :type los_distribution_individual: str or None + :param kwargs_los_individual: dictionary of the parameters of the individual distribution + If individual_distribution is "PDF": + "pdf_array": array of probability density function of the external convergence distribution binned according to kappa_bin_edges - :param kappa_bin_edges: array of length (len(kappa_pdf)+1), bin edges of the kappa PDF + "bin_edges": array of length (len(kappa_pdf)+1), bin edges of the kappa PDF + If individual_distribution is "GEV": + "xi", "mean", "sigma" + :type kwargs_los_individual: dict or None :param mst_ifu: bool, if True replaces the lambda_mst parameter by the lambda_ifu parameter (and distribution) in sampling this lens. :param lambda_scaling_property: float (optional), scaling of @@ -119,10 +126,10 @@ def __init__( self._num_distribution_draws = int(num_distribution_draws) self._los = LOSDistribution( - kappa_pdf=kappa_pdf, - kappa_bin_edges=kappa_bin_edges, global_los_distribution=global_los_distribution, los_distributions=los_distributions, + individual_distribution=los_distribution_individual, + kwargs_individual=kwargs_los_individual ) kwargs_min, kwargs_max = self.param_bounds_interpol() self._lens_distribution = LensDistribution( @@ -306,7 +313,6 @@ def log_likelihood_single( kwargs_kin_draw = self._aniso_distribution.draw_anisotropy(**kwargs_kin) kwargs_param = {**kwargs_lens_draw, **kwargs_kin_draw} kin_scaling = self.kin_scaling(kwargs_param) - print(kwargs_lens_draw, "test kwargs_lens_draw") lnlikelihood = self.log_likelihood( ddt_, dd_, diff --git a/hierarc/Sampling/Distributions/los_distributions.py b/hierarc/Sampling/Distributions/los_distributions.py index 69f4aef9..5f095ecb 100644 --- a/hierarc/Sampling/Distributions/los_distributions.py +++ b/hierarc/Sampling/Distributions/los_distributions.py @@ -1,5 +1,6 @@ import numpy as np from hierarc.Util.distribution_util import PDFSampling +from scipy.stats import genextreme class LOSDistribution(object): @@ -7,21 +8,28 @@ class LOSDistribution(object): def __init__( self, - kappa_pdf=None, - kappa_bin_edges=None, global_los_distribution=False, los_distributions=None, + individual_distribution=None, + kwargs_individual=None, ): """ :param global_los_distribution: if integer, will draw from the global kappa distribution specified in that integer. If False, will instead draw from the distribution specified in kappa_pdf. :type global_los_distribution: bool or int - :param kappa_pdf: array of probability density function of the external convergence distribution - binned according to kappa_bin_edges - :param kappa_bin_edges: array of length (len(kappa_pdf)+1), bin edges of the kappa PDF :param los_distributions: list of all line of sight distributions parameterized :type los_distributions: list of str or None + :param individual_distribution: name of the individual distribution ["GEV" and "PDF"] + :type individual_distribution: str or None + :param kwargs_individual: dictionary of the parameters of the individual distribution + If individual_distribution is "PDF": + "pdf_array": array of probability density function of the external convergence distribution + binned according to kappa_bin_edges + "bin_edges": array of length (len(kappa_pdf)+1), bin edges of the kappa PDF + If individual_distribution is "GEV": + "xi", "mean", "sigma" + :type kwargs_individual: dict or None """ self._global_los_distribution = global_los_distribution @@ -33,14 +41,14 @@ def __init__( self._los_distribution = los_distributions[global_los_distribution] else: self._draw_kappa_global = False - if ( - kappa_pdf is not None - and kappa_bin_edges is not None - and not self._draw_kappa_global + if (not self._draw_kappa_global and individual_distribution is not None ): - self._kappa_dist = PDFSampling( - bin_edges=kappa_bin_edges, pdf_array=kappa_pdf - ) + if individual_distribution == "PDF": + self._kappa_dist = PDFSampling(**kwargs_individual) + elif individual_distribution == "GEV": + self._kappa_dist = GEV(**kwargs_individual) + else: + raise ValueError("individual_distribution %s not supported. Chose among 'GEV' and 'PDF'") self._draw_kappa_individual = True else: self._draw_kappa_individual = False @@ -54,6 +62,7 @@ def draw_los(self, kwargs_los, size=1): :type size: int>0 :return: external convergence draw """ + if self._draw_kappa_individual is True: kappa_ext_draw = self._kappa_dist.draw(n=size) elif self._draw_kappa_global: @@ -66,8 +75,6 @@ def draw_los(self, kwargs_los, size=1): mean = kwargs_los_i["mean"] sigma = kwargs_los_i["sigma"] xi = kwargs_los_i["xi"] - from scipy.stats import genextreme - kappa_ext_draw = genextreme.rvs(c=xi, loc=mean, scale=sigma, size=size) else: raise ValueError( @@ -89,3 +96,30 @@ def draw_bool(self, kwargs_los): if kwargs_los[self._global_los_distribution]["sigma"] != 0: return True return False + + +class GEV(object): + """ + draw from General Extreme Value distribution + """ + def __init__(self, xi, mean, sigma): + """ + + :param xi: Xi value of GEV + :param mean: mean of GEV + :param sigma: sigma of GEV + """ + self._xi = xi + self._mean = mean + self._sigma = sigma + + def draw(self, n=1): + """ + draws from the PDF of the GEV distribution + + :param n: number of draws from distribution + :type n: int + :return: draws according to the PDF of the distribution + """ + kappa_ext_draw = genextreme.rvs(c=self._xi, loc=self._mean, scale=self._sigma, size=n) + return kappa_ext_draw diff --git a/test/test_Diagnostics/test_goodness_of_fit.py b/test/test_Diagnostics/test_goodness_of_fit.py index 0c9be7d8..db480e59 100644 --- a/test/test_Diagnostics/test_goodness_of_fit.py +++ b/test/test_Diagnostics/test_goodness_of_fit.py @@ -71,8 +71,8 @@ def setup_method(self): }, { "ddt_samples": ddt_samples, - "kappa_pdf": kappa_pdf, - "kappa_bin_edges": kappa_bin_edges, + "los_distribution_individual": "PDF", + "kwargs_los_individual": {"bin_edges": kappa_bin_edges, "pdf_array": kappa_pdf}, }, {"ddt_samples": ddt_samples}, { diff --git a/test/test_Likelihood/test_hierarchy_likelihood.py b/test/test_Likelihood/test_hierarchy_likelihood.py index f89e8a2d..d4b5ecda 100644 --- a/test/test_Likelihood/test_hierarchy_likelihood.py +++ b/test/test_Likelihood/test_hierarchy_likelihood.py @@ -46,8 +46,8 @@ def setup_method(self): num_distribution_draws=200, los_distributions=["GAUSSIAN"], global_los_distribution=0, - kappa_pdf=None, - kappa_bin_edges=None, + los_distribution_individual=None, + kwargs_los_individual=None, mst_ifu=True, **kwargs_likelihood, **kwargs_model @@ -63,8 +63,8 @@ def setup_method(self): num_distribution_draws=200, los_distributions=["GAUSSIAN"], global_los_distribution=0, # testing previously set to =False - kappa_pdf=None, - kappa_bin_edges=None, + los_distribution_individual=None, + kwargs_los_individual=None, mst_ifu=False, **kwargs_likelihood, **kwargs_model @@ -80,8 +80,8 @@ def setup_method(self): num_distribution_draws=0, los_distributions=["GAUSSIAN"], global_los_distribution=0, - kappa_pdf=None, - kappa_bin_edges=None, + los_distribution_individual=None, + kwargs_los_individual=None, mst_ifu=True, **kwargs_likelihood, **kwargs_model @@ -100,8 +100,8 @@ def setup_method(self): num_distribution_draws=200, # los_distributions=["GAUSSIAN"], global_los_distribution=False, - kappa_pdf=kappa_pdf, - kappa_bin_edges=kappa_bin_edges, + los_distribution_individual="PDF", + kwargs_los_individual={"bin_edges": kappa_bin_edges, "pdf_array": kappa_pdf}, mst_ifu=False, **kwargs_likelihood, **kwargs_model @@ -123,8 +123,6 @@ def setup_method(self): j_kin_scaling_param_axes=j_kin_scaling_param_axes, j_kin_scaling_grid_list=[param_scaling_array], num_distribution_draws=200, - kappa_pdf=None, - kappa_bin_edges=None, mst_ifu=False, gamma_in_sampling=False, gamma_in_distribution="GAUSSIAN", @@ -149,8 +147,6 @@ def setup_method(self): j_kin_scaling_param_axes=j_kin_scaling_param_axes, j_kin_scaling_grid_list=[param_scaling_array], num_distribution_draws=200, - kappa_pdf=None, - kappa_bin_edges=None, mst_ifu=False, gamma_in_sampling=True, gamma_in_distribution="GAUSSIAN", @@ -169,8 +165,6 @@ def setup_method(self): j_kin_scaling_param_axes=ani_param_array, j_kin_scaling_grid_list=[ani_scaling_array], num_distribution_draws=200, - kappa_pdf=None, - kappa_bin_edges=None, mst_ifu=False, lambda_scaling_property=100, **kwargs_likelihood, diff --git a/test/test_Likelihood/test_los_distribution.py b/test/test_Likelihood/test_los_distribution.py index 97b25d08..7a49e85a 100644 --- a/test/test_Likelihood/test_los_distribution.py +++ b/test/test_Likelihood/test_los_distribution.py @@ -35,10 +35,10 @@ def test_gev(self): # here we draw from the scipy function dist_gev = LOSDistribution( - kappa_pdf=kappa_pdf, - kappa_bin_edges=kappa_bin_edges, global_los_distribution=1, los_distributions=los_distribution, + individual_distribution="PDF", + kwargs_individual={"pdf_array": kappa_pdf, "bin_edges": kappa_bin_edges} ) kappa_dist_drawn = dist_gev.draw_los(kwargs_los, size=10000) @@ -47,10 +47,10 @@ def test_gev(self): # here we draw from the distribution dist_gev = LOSDistribution( - kappa_pdf=kappa_pdf, - kappa_bin_edges=kappa_bin_edges, global_los_distribution=False, los_distributions=los_distribution, + individual_distribution="PDF", + kwargs_individual={"pdf_array": kappa_pdf, "bin_edges": kappa_bin_edges} ) kappa_dist_drawn = dist_gev.draw_los(kwargs_los, size=10000) @@ -59,10 +59,10 @@ def test_gev(self): # draw from Gaussian dist_gev = LOSDistribution( - kappa_pdf=kappa_pdf, - kappa_bin_edges=kappa_bin_edges, global_los_distribution=0, los_distributions=los_distribution, + individual_distribution="PDF", + kwargs_individual={"pdf_array": kappa_pdf, "bin_edges": kappa_bin_edges} ) kappa_dist_drawn = dist_gev.draw_los(kwargs_los, size=10000) @@ -92,28 +92,28 @@ def test_draw_bool(self): ] dist = LOSDistribution( - kappa_pdf=kappa_pdf, - kappa_bin_edges=kappa_bin_edges, global_los_distribution=1, los_distributions=los_distribution, + individual_distribution="PDF", + kwargs_individual={"pdf_array": kappa_pdf, "bin_edges": kappa_bin_edges} ) bool_draw = dist.draw_bool(kwargs_los) assert bool_draw is True dist = LOSDistribution( - kappa_pdf=kappa_pdf, - kappa_bin_edges=kappa_bin_edges, global_los_distribution=0, los_distributions=los_distribution, + individual_distribution="PDF", + kwargs_individual={"pdf_array": kappa_pdf, "bin_edges": kappa_bin_edges} ) bool_draw = dist.draw_bool(kwargs_los) assert bool_draw is False dist = LOSDistribution( - kappa_pdf=kappa_pdf, - kappa_bin_edges=kappa_bin_edges, global_los_distribution=False, los_distributions=los_distribution, + individual_distribution="PDF", + kwargs_individual={"pdf_array": kappa_pdf, "bin_edges": kappa_bin_edges} ) bool_draw = dist.draw_bool(kwargs_los) assert bool_draw is True @@ -123,9 +123,17 @@ class TestRaise(unittest.TestCase): def test_raise(self): with self.assertRaises(ValueError): los = LOSDistribution( - kappa_pdf=None, - kappa_bin_edges=None, + individual_distribution=None, + kwargs_individual=None, global_los_distribution=0, los_distributions=["BAD"], ) los.draw_los(kwargs_los=[{}]) + + with self.assertRaises(ValueError): + los = LOSDistribution( + individual_distribution="BAD", + kwargs_individual=None, + global_los_distribution=False, + los_distributions=None, + ) From dcf3d3bef312cbb3f0c7c0de28855f2bad305f6d Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Mon, 29 Jul 2024 21:56:36 -0400 Subject: [PATCH 46/62] update to latest version of lenstronomy --- hierarc/LensPosterior/kin_constraints_composite.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/hierarc/LensPosterior/kin_constraints_composite.py b/hierarc/LensPosterior/kin_constraints_composite.py index 92dab5db..9d00ab4f 100644 --- a/hierarc/LensPosterior/kin_constraints_composite.py +++ b/hierarc/LensPosterior/kin_constraints_composite.py @@ -113,7 +113,7 @@ def __init__( lens_light_model_list = ["MULTI_GAUSSIAN"] kwargs_lens_light = [{"amp": amps, "sigma": sigmas}] - lens_model_list = ["GNFW", "MULTI_GAUSSIAN_KAPPA"] + lens_model_list = ["GNFW", "MULTI_GAUSSIAN"] # log_m2l is interpolated when sampled on the population level, otherwise marginalized if is_m2l_population_level: From 18ac255c13dfcf3d336c4e1e6492df7f291334b8 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 5 Aug 2024 20:58:49 +0000 Subject: [PATCH 47/62] [pre-commit.ci] pre-commit autoupdate MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit updates: - [github.com/psf/black: 24.4.2 → 24.8.0](https://github.com/psf/black/compare/24.4.2...24.8.0) - [github.com/psf/black: 24.4.2 → 24.8.0](https://github.com/psf/black/compare/24.4.2...24.8.0) --- .pre-commit-config.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index b6e94b74..121ee6a7 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -10,7 +10,7 @@ ci: repos: - repo: https://github.com/psf/black - rev: 24.4.2 + rev: 24.8.0 hooks: - id: black # It is recommended to specify the latest version of Python @@ -19,7 +19,7 @@ repos: # https://pre-commit.com/#top_level-default_language_version language_version: python3 - repo: https://github.com/psf/black - rev: 24.4.2 + rev: 24.8.0 hooks: - id: black-jupyter language_version: python3 From 84bc01c6b7c365ce178c835363f67ce816b62acc Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 5 Aug 2024 20:59:03 +0000 Subject: [PATCH 48/62] [pre-commit.ci] auto fixes from pre-commit.com hooks --- hierarc/Likelihood/hierarchy_likelihood.py | 2 +- .../Distributions/los_distributions.py | 19 ++++++++++--------- test/test_Diagnostics/test_goodness_of_fit.py | 5 ++++- .../test_hierarchy_likelihood.py | 5 ++++- test/test_Likelihood/test_los_distribution.py | 12 ++++++------ 5 files changed, 25 insertions(+), 18 deletions(-) diff --git a/hierarc/Likelihood/hierarchy_likelihood.py b/hierarc/Likelihood/hierarchy_likelihood.py index 6e327600..306c5324 100644 --- a/hierarc/Likelihood/hierarchy_likelihood.py +++ b/hierarc/Likelihood/hierarchy_likelihood.py @@ -129,7 +129,7 @@ def __init__( global_los_distribution=global_los_distribution, los_distributions=los_distributions, individual_distribution=los_distribution_individual, - kwargs_individual=kwargs_los_individual + kwargs_individual=kwargs_los_individual, ) kwargs_min, kwargs_max = self.param_bounds_interpol() self._lens_distribution = LensDistribution( diff --git a/hierarc/Sampling/Distributions/los_distributions.py b/hierarc/Sampling/Distributions/los_distributions.py index 5f095ecb..ff5b669e 100644 --- a/hierarc/Sampling/Distributions/los_distributions.py +++ b/hierarc/Sampling/Distributions/los_distributions.py @@ -41,14 +41,15 @@ def __init__( self._los_distribution = los_distributions[global_los_distribution] else: self._draw_kappa_global = False - if (not self._draw_kappa_global and individual_distribution is not None - ): + if not self._draw_kappa_global and individual_distribution is not None: if individual_distribution == "PDF": self._kappa_dist = PDFSampling(**kwargs_individual) elif individual_distribution == "GEV": self._kappa_dist = GEV(**kwargs_individual) else: - raise ValueError("individual_distribution %s not supported. Chose among 'GEV' and 'PDF'") + raise ValueError( + "individual_distribution %s not supported. Chose among 'GEV' and 'PDF'" + ) self._draw_kappa_individual = True else: self._draw_kappa_individual = False @@ -99,9 +100,8 @@ def draw_bool(self, kwargs_los): class GEV(object): - """ - draw from General Extreme Value distribution - """ + """Draw from General Extreme Value distribution.""" + def __init__(self, xi, mean, sigma): """ @@ -114,12 +114,13 @@ def __init__(self, xi, mean, sigma): self._sigma = sigma def draw(self, n=1): - """ - draws from the PDF of the GEV distribution + """Draws from the PDF of the GEV distribution. :param n: number of draws from distribution :type n: int :return: draws according to the PDF of the distribution """ - kappa_ext_draw = genextreme.rvs(c=self._xi, loc=self._mean, scale=self._sigma, size=n) + kappa_ext_draw = genextreme.rvs( + c=self._xi, loc=self._mean, scale=self._sigma, size=n + ) return kappa_ext_draw diff --git a/test/test_Diagnostics/test_goodness_of_fit.py b/test/test_Diagnostics/test_goodness_of_fit.py index db480e59..714b0090 100644 --- a/test/test_Diagnostics/test_goodness_of_fit.py +++ b/test/test_Diagnostics/test_goodness_of_fit.py @@ -72,7 +72,10 @@ def setup_method(self): { "ddt_samples": ddt_samples, "los_distribution_individual": "PDF", - "kwargs_los_individual": {"bin_edges": kappa_bin_edges, "pdf_array": kappa_pdf}, + "kwargs_los_individual": { + "bin_edges": kappa_bin_edges, + "pdf_array": kappa_pdf, + }, }, {"ddt_samples": ddt_samples}, { diff --git a/test/test_Likelihood/test_hierarchy_likelihood.py b/test/test_Likelihood/test_hierarchy_likelihood.py index d4b5ecda..16e28cfa 100644 --- a/test/test_Likelihood/test_hierarchy_likelihood.py +++ b/test/test_Likelihood/test_hierarchy_likelihood.py @@ -101,7 +101,10 @@ def setup_method(self): # los_distributions=["GAUSSIAN"], global_los_distribution=False, los_distribution_individual="PDF", - kwargs_los_individual={"bin_edges": kappa_bin_edges, "pdf_array": kappa_pdf}, + kwargs_los_individual={ + "bin_edges": kappa_bin_edges, + "pdf_array": kappa_pdf, + }, mst_ifu=False, **kwargs_likelihood, **kwargs_model diff --git a/test/test_Likelihood/test_los_distribution.py b/test/test_Likelihood/test_los_distribution.py index 7a49e85a..21bf9fd5 100644 --- a/test/test_Likelihood/test_los_distribution.py +++ b/test/test_Likelihood/test_los_distribution.py @@ -38,7 +38,7 @@ def test_gev(self): global_los_distribution=1, los_distributions=los_distribution, individual_distribution="PDF", - kwargs_individual={"pdf_array": kappa_pdf, "bin_edges": kappa_bin_edges} + kwargs_individual={"pdf_array": kappa_pdf, "bin_edges": kappa_bin_edges}, ) kappa_dist_drawn = dist_gev.draw_los(kwargs_los, size=10000) @@ -50,7 +50,7 @@ def test_gev(self): global_los_distribution=False, los_distributions=los_distribution, individual_distribution="PDF", - kwargs_individual={"pdf_array": kappa_pdf, "bin_edges": kappa_bin_edges} + kwargs_individual={"pdf_array": kappa_pdf, "bin_edges": kappa_bin_edges}, ) kappa_dist_drawn = dist_gev.draw_los(kwargs_los, size=10000) @@ -62,7 +62,7 @@ def test_gev(self): global_los_distribution=0, los_distributions=los_distribution, individual_distribution="PDF", - kwargs_individual={"pdf_array": kappa_pdf, "bin_edges": kappa_bin_edges} + kwargs_individual={"pdf_array": kappa_pdf, "bin_edges": kappa_bin_edges}, ) kappa_dist_drawn = dist_gev.draw_los(kwargs_los, size=10000) @@ -95,7 +95,7 @@ def test_draw_bool(self): global_los_distribution=1, los_distributions=los_distribution, individual_distribution="PDF", - kwargs_individual={"pdf_array": kappa_pdf, "bin_edges": kappa_bin_edges} + kwargs_individual={"pdf_array": kappa_pdf, "bin_edges": kappa_bin_edges}, ) bool_draw = dist.draw_bool(kwargs_los) assert bool_draw is True @@ -104,7 +104,7 @@ def test_draw_bool(self): global_los_distribution=0, los_distributions=los_distribution, individual_distribution="PDF", - kwargs_individual={"pdf_array": kappa_pdf, "bin_edges": kappa_bin_edges} + kwargs_individual={"pdf_array": kappa_pdf, "bin_edges": kappa_bin_edges}, ) bool_draw = dist.draw_bool(kwargs_los) assert bool_draw is False @@ -113,7 +113,7 @@ def test_draw_bool(self): global_los_distribution=False, los_distributions=los_distribution, individual_distribution="PDF", - kwargs_individual={"pdf_array": kappa_pdf, "bin_edges": kappa_bin_edges} + kwargs_individual={"pdf_array": kappa_pdf, "bin_edges": kappa_bin_edges}, ) bool_draw = dist.draw_bool(kwargs_los) assert bool_draw is True From 25cd5de315badf50c6f44effb62e034721d4f230 Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Mon, 5 Aug 2024 23:31:24 -0400 Subject: [PATCH 49/62] double source plane likelihood with power-law and MST transform in place --- .../LensLikelihood/base_lens_likelihood.py | 35 ++++++++++- .../LensLikelihood/double_source_plane.py | 61 ++++++++----------- hierarc/Likelihood/hierarchy_likelihood.py | 42 ++++++++----- hierarc/Likelihood/lens_sample_likelihood.py | 21 ++----- .../test_double_source_plane.py | 19 ++---- test/test_Likelihood/test_cosmo_likelihood.py | 4 +- .../test_lens_sample_likelihood.py | 4 +- 7 files changed, 97 insertions(+), 89 deletions(-) diff --git a/hierarc/Likelihood/LensLikelihood/base_lens_likelihood.py b/hierarc/Likelihood/LensLikelihood/base_lens_likelihood.py index c618311b..0b570528 100644 --- a/hierarc/Likelihood/LensLikelihood/base_lens_likelihood.py +++ b/hierarc/Likelihood/LensLikelihood/base_lens_likelihood.py @@ -1,5 +1,6 @@ __author__ = "sibirrer" +from hierarc.Likelihood.LensLikelihood.double_source_plane import beta_double_source_plane LIKELIHOOD_TYPES = [ "DdtGaussian", @@ -15,6 +16,7 @@ "Mag", "TDMag", "TDMagMagnitude", + "DSPL", ] @@ -26,6 +28,7 @@ def __init__( z_lens, z_source, likelihood_type, + z_source2=None, name="name", normalized=False, kwargs_lens_properties=None, @@ -37,6 +40,7 @@ def __init__( :param z_source: source redshift :param name: string (optional) to name the specific lens :param likelihood_type: string to specify the likelihood type + :param z_source2: redshift of the second source for the double source plane lens type "DSP" :param normalized: bool, if True, returns the normalized likelihood, if False, separates the constant prefactor (in case of a Gaussian 1/(sigma sqrt(2 pi)) ) to compute the reduced chi2 statistics :param kwargs_lens_properties: keyword arguments of the lens properties @@ -46,6 +50,7 @@ def __init__( self._name = name self.z_lens = z_lens self.z_source = z_source + self.z_source2 = z_source2 self.likelihood_type = likelihood_type if kwargs_lens_properties is None: kwargs_lens_properties = {} @@ -97,14 +102,14 @@ def __init__( DdtHistLikelihood, ) - self._lens_type = DdtHistLikelihood(z_lens, z_source, **kwargs_likelihood) + self._lens_type = DdtHistLikelihood(z_lens, z_source, normalized=normalized, **kwargs_likelihood) elif likelihood_type == "DdtHistKDE": from hierarc.Likelihood.LensLikelihood.ddt_hist_likelihood import ( DdtHistKDELikelihood, ) self._lens_type = DdtHistKDELikelihood( - z_lens, z_source, **kwargs_likelihood + z_lens, z_source, normalized=normalized, **kwargs_likelihood ) elif likelihood_type == "DdtHistKin": from hierarc.Likelihood.LensLikelihood.ddt_hist_kin_likelihood import ( @@ -140,6 +145,9 @@ def __init__( ) self._lens_type = TDMagMagnitudeLikelihood(**kwargs_likelihood) + elif likelihood_type == "DSPL": + from hierarc.Likelihood.LensLikelihood.double_source_plane import DSPLikelihood + self._lens_type = DSPLikelihood(normalized=normalized, **kwargs_likelihood) else: raise ValueError( "likelihood_type %s not supported! Supported are %s." @@ -154,17 +162,22 @@ def num_data(self): return self._lens_type.num_data def log_likelihood( - self, ddt, dd, kin_scaling=None, sigma_v_sys_error=None, mu_intrinsic=None + self, ddt, dd, beta_dsp=None, kin_scaling=None, sigma_v_sys_error=None, mu_intrinsic=None, + gamma_pl=None, lambda_mst=None ): """ :param ddt: time-delay distance [physical Mpc] :param dd: angular diameter distance to the lens [physical Mpc] + :param beta_dsp: ratio of reduced deflection angles between first and second source redshift, + dds1 / ds1 * ds2 / dds2 :param kin_scaling: array of size of the velocity dispersion measurement or None, scaling of the predicted dimensionless quantity J (proportional to sigma_v^2) of the anisotropy model in the sampling relative to the anisotropy model used to derive the prediction and covariance matrix in the init of this class. :param sigma_v_sys_error: unaccounted uncertainty in the velocity dispersion measurement :param mu_intrinsic: float, intrinsic source brightness (in magnitude) + :param gamma_pl: power-law density slope of main deflector (=2 being isothermal) (only used for DSP likelihood) + :param lambda_mst: mass-sheet transform at the main deflector (only used for DSP likelihood) :return: natural logarithm of the likelihood of the data given the model """ if self.likelihood_type in [ @@ -187,6 +200,8 @@ def log_likelihood( return self._lens_type.log_likelihood(mu_intrinsic=mu_intrinsic) elif self.likelihood_type in ["TDMag", "TDMagMagnitude"]: return self._lens_type.log_likelihood(ddt=ddt, mu_intrinsic=mu_intrinsic) + elif self.likelihood_type in ["DSPL"]: + return self._lens_type.log_likelihood(beta_dsp=beta_dsp, gamma_pl=gamma_pl, lambda_mst=lambda_mst) else: raise ValueError( "likelihood type %s not fully supported." % self.likelihood_type @@ -231,3 +246,17 @@ def sigma_v_prediction(self, ddt, dd, kin_scaling=None): if self.likelihood_type in ["DdtHistKin", "IFUKinCov", "DdtGaussKin"]: return self._lens_type.sigma_v_prediction(ddt, dd, kin_scaling) return None, None + + def beta_dsp(self, cosmo): + """Model prediction of ratio of Einstein radii theta_E_1 / theta_E_2 or scaled + deflection angles. Only computes it when likelihood is DSP + + :param cosmo: ~astropy.cosmology instance + :return: beta + """ + if self.likelihood_type == "DSPL": + beta = beta_double_source_plane(z_lens=self.z_lens, z_source_1=self.z_source, z_source_2=self.z_source2, + cosmo=cosmo) + else: + beta = None + return beta diff --git a/hierarc/Likelihood/LensLikelihood/double_source_plane.py b/hierarc/Likelihood/LensLikelihood/double_source_plane.py index c0b5fa12..fc43b7b4 100644 --- a/hierarc/Likelihood/LensLikelihood/double_source_plane.py +++ b/hierarc/Likelihood/LensLikelihood/double_source_plane.py @@ -6,48 +6,36 @@ class DSPLikelihood(object): def __init__( self, - z_lens, - z_source_1, - z_source_2, beta_dspl, sigma_beta_dspl, normalized=False, ): """ - :param z_lens: lens redshift - :param z_source_1: redshift of first source - :param z_source_2: redshift of second source :param beta_dspl: measured ratio of Einstein rings theta_E_1 / theta_E_2 - :param sigma_beta_dspl: + :param sigma_beta_dspl: 1-sigma uncertainty in the measurement of the Einstein radius ratio :param normalized: normalize the likelihood :type normalized: boolean """ - self._z_lens = z_lens - self._z_source_1 = z_source_1 - self._z_source_2 = z_source_2 self._beta_dspl = beta_dspl self._sigma_beta_dspl = sigma_beta_dspl self._normalized = normalized - def lens_log_likelihood( + def log_likelihood( self, - cosmo, - kwargs_lens=None, - kwargs_kin=None, - kwargs_source=None, - kwargs_los=None, + beta_dsp, + gamma_pl=2, + lambda_mst=1, ): """Log likelihood of the data given a model. - :param cosmo: astropy.cosmology instance - :param kwargs_lens: keyword arguments of lens - :param kwargs_kin: keyword arguments of kinematics - :param kwargs_source: keyword argument of source - :param kwargs_los: keyword argument list of line of sight + :param beta_dsp: scaled deflection angles alpha_1 / alpha_2 as ratio + between z_source and z_source2 source planes + :param gamma_pl: power-law density slope of main deflector (=2 being isothermal) + :param lambda_mst: mass-sheet transform at the main deflector :return: log likelihood of data given model """ - beta_model = self._beta_model(cosmo) - log_l = -0.5 * ((beta_model - self._beta_dspl) / self._sigma_beta_dspl) ** 2 + theta_E_ratio = beta2theta_e_ratio(beta_dsp, gamma_pl=gamma_pl, lambda_mst=lambda_mst) + log_l = -0.5 * ((theta_E_ratio - self._beta_dspl) / self._sigma_beta_dspl) ** 2 if self._normalized: log_l -= 1 / 2.0 * np.log(2 * np.pi * self._sigma_beta_dspl**2) return log_l @@ -59,18 +47,6 @@ def num_data(self): """ return 1 - def _beta_model(self, cosmo): - """Model prediction of ratio of Einstein radii theta_E_1 / theta_E_2 or scaled - deflection angles. - - :param cosmo: astropy.cosmology instance - :return: beta - """ - beta = beta_double_source_plane( - self._z_lens, self._z_source_1, self._z_source_2, cosmo=cosmo - ) - return beta - def beta_double_source_plane(z_lens, z_source_1, z_source_2, cosmo): """Model prediction of ratio of Einstein radii theta_E_1 / theta_E_2 or scaled @@ -79,7 +55,7 @@ def beta_double_source_plane(z_lens, z_source_1, z_source_2, cosmo): :param z_lens: lens redshift :param z_source_1: source_1 redshift :param z_source_2: source_2 redshift - :param cosmo: astropy.cosmology instance + :param cosmo: ~astropy.cosmology instance :return: beta """ ds1 = cosmo.angular_diameter_distance(z=z_source_1).value @@ -88,3 +64,16 @@ def beta_double_source_plane(z_lens, z_source_1, z_source_2, cosmo): dds2 = cosmo.angular_diameter_distance_z1z2(z1=z_lens, z2=z_source_2).value beta = dds1 / ds1 * ds2 / dds2 return beta + + +def beta2theta_e_ratio(beta_dsp, gamma_pl=2, lambda_mst=1): + """ + calculates Einstein radii ratio for a power-law + MST profile with given parameters + + :param beta_dsp: scaled deflection angles alpha_1 / alpha_2 as ratio + between z_source and z_source2 source planes + :param gamma_pl: power-law density slope of main deflector (=2 being isothermal) + :param lambda_mst: mass-sheet transform at the main deflector + :return: theta_E1 / theta_E2 + """ + return (beta_dsp - (1 - lambda_mst) * (1 - beta_dsp)) ** (1/(gamma_pl - 1)) diff --git a/hierarc/Likelihood/hierarchy_likelihood.py b/hierarc/Likelihood/hierarchy_likelihood.py index 6e327600..c51f1b09 100644 --- a/hierarc/Likelihood/hierarchy_likelihood.py +++ b/hierarc/Likelihood/hierarchy_likelihood.py @@ -185,6 +185,7 @@ def lens_log_likelihood( # Note: Distances are in physical units of Mpc. Make sure the posteriors to evaluate this likelihood is in the # same units ddt, dd = self.angular_diameter_distances(cosmo) + beta_dsp = self.beta_dsp(cosmo) kwargs_source = self._kwargs_init(kwargs_source) z_apparent_m_anchor = kwargs_source.get("z_apparent_m_anchor", 0.1) delta_lum_dist = self.luminosity_distance_modulus(cosmo, z_apparent_m_anchor) @@ -194,6 +195,7 @@ def lens_log_likelihood( ddt, dd, delta_lum_dist, + beta_dsp=beta_dsp, kwargs_lens=kwargs_lens, kwargs_kin=kwargs_kin, kwargs_source=kwargs_source, @@ -207,26 +209,26 @@ def hyper_param_likelihood( ddt, dd, delta_lum_dist, + beta_dsp=None, kwargs_lens=None, kwargs_kin=None, kwargs_source=None, kwargs_los=None, cosmo=None, ): - """Log likelihood of the data of a lens given a model (defined with hyper- - parameters) and cosmological distances. + """Log likelihood of the data of a lens given a model (defined with hyperparameters) and cosmological distances. :param ddt: time-delay distance :param dd: angular diameter distance to the deflector :param delta_lum_dist: relative luminosity distance to pivot redshift - :param kwargs_lens: keywords of the hyper parameters of the lens model - :param kwargs_kin: keyword arguments of the kinematic model hyper parameters + :param beta_dsp: Model prediction of ratio of Einstein radii theta_E_1 / theta_E_2 + :param kwargs_lens: keywords of the hyperparameters of the lens model + :param kwargs_kin: keyword arguments of the kinematic model hyperparameters :param kwargs_source: keyword argument of the source model (such as SNe) :param kwargs_los: list of keyword arguments of global line of sight distributions - :param cosmo: astropy.cosmology instance - :return: log likelihood given the single lens analysis for the given hyper - parameter + :param cosmo: ~astropy.cosmology instance + :return: log likelihood given the single lens analysis for the given hyperparameter """ kwargs_lens = self._kwargs_init(kwargs_lens) kwargs_kin = self._kwargs_init(kwargs_kin) @@ -241,10 +243,11 @@ def hyper_param_likelihood( ddt, dd, delta_lum_dist, - kwargs_lens, - kwargs_kin_copy, - kwargs_source, - kwargs_los, + beta_dsp=beta_dsp, + kwargs_lens=kwargs_lens, + kwargs_kin=kwargs_kin_copy, + kwargs_source=kwargs_source, + kwargs_los=kwargs_los, sigma_v_sys_error=sigma_v_sys_error, ) else: @@ -254,10 +257,11 @@ def hyper_param_likelihood( ddt, dd, delta_lum_dist, - kwargs_lens, - kwargs_kin_copy, - kwargs_source, - kwargs_los, + beta_dsp=beta_dsp, + kwargs_lens=kwargs_lens, + kwargs_kin=kwargs_kin_copy, + kwargs_source=kwargs_source, + kwargs_los=kwargs_los, sigma_v_sys_error=sigma_v_sys_error, ) exp_logl = np.exp(logl) @@ -272,6 +276,7 @@ def log_likelihood_single( ddt, dd, delta_lum_dist, + beta_dsp, kwargs_lens, kwargs_kin, kwargs_source, @@ -279,11 +284,12 @@ def log_likelihood_single( sigma_v_sys_error=None, ): """Log likelihood of the data of a lens given a specific model (as a draw from - hyper-parameters) and cosmological distances. + hyperparameters) and cosmological distances. :param ddt: time-delay distance :param dd: angular diameter distance to the deflector :param delta_lum_dist: relative luminosity distance to pivot redshift + :param beta_dsp: Model prediction of ratio of Einstein radii theta_E_1 / theta_E_2 :param kwargs_lens: keywords of the hyperparameters of the lens model :param kwargs_kin: keyword arguments of the kinematic model hyperparameters :param kwargs_source: keyword arguments of source brightness @@ -298,6 +304,7 @@ def log_likelihood_single( kwargs_lens_draw["lambda_mst"], kwargs_lens_draw["gamma_ppn"], ) + gamma_pl = kwargs_lens_draw.get("gamma_pl", 2) kappa_ext = self._los.draw_los(kwargs_los) # draw intrinsic source magnitude @@ -316,9 +323,12 @@ def log_likelihood_single( lnlikelihood = self.log_likelihood( ddt_, dd_, + beta_dsp=beta_dsp, kin_scaling=kin_scaling, sigma_v_sys_error=sigma_v_sys_error, mu_intrinsic=mag_source_, + gamma_pl=gamma_pl, + lambda_mst=lambda_mst, ) lnlikelihood += self._prior.log_likelihood(kwargs_param) return np.nan_to_num(lnlikelihood) diff --git a/hierarc/Likelihood/lens_sample_likelihood.py b/hierarc/Likelihood/lens_sample_likelihood.py index 933ddfc6..f6b114de 100644 --- a/hierarc/Likelihood/lens_sample_likelihood.py +++ b/hierarc/Likelihood/lens_sample_likelihood.py @@ -1,7 +1,6 @@ import copy from hierarc.Likelihood.hierarchy_likelihood import LensLikelihood -from hierarc.Likelihood.LensLikelihood.double_source_plane import DSPLikelihood class LensSampleLikelihood(object): @@ -31,20 +30,12 @@ def __init__(self, kwargs_lens_list, normalized=False, kwargs_global_model=None) self._gamma_pl_num += 1 gamma_pl_index_ = copy.deepcopy(gamma_pl_index) gamma_pl_index += 1 - # kwargs_lens.pop("gamma_pl_sampling") - if kwargs_lens["likelihood_type"] == "DSPL": - _kwargs_lens = copy.deepcopy(kwargs_lens) - _kwargs_lens.pop("likelihood_type") - self._lens_list.append( - DSPLikelihood(normalized=normalized, **_kwargs_lens) - ) - else: - kwargs_lens_ = self._merge_global2local_settings( - kwargs_global_model=kwargs_global_model, kwargs_lens=kwargs_lens - ) - self._lens_list.append( - LensLikelihood(gamma_pl_index=gamma_pl_index_, **kwargs_lens_) - ) + kwargs_lens_ = self._merge_global2local_settings( + kwargs_global_model=kwargs_global_model, kwargs_lens=kwargs_lens + ) + self._lens_list.append( + LensLikelihood(gamma_pl_index=gamma_pl_index_, normalized=normalized, **kwargs_lens_) + ) def log_likelihood( self, diff --git a/test/test_Likelihood/test_LensLikelihood/test_double_source_plane.py b/test/test_Likelihood/test_LensLikelihood/test_double_source_plane.py index 101e6877..31f9a346 100644 --- a/test/test_Likelihood/test_LensLikelihood/test_double_source_plane.py +++ b/test/test_Likelihood/test_LensLikelihood/test_double_source_plane.py @@ -28,45 +28,34 @@ def test_log_likelihood(self): # make cosmo instance # compute beta dspl_likelihood = DSPLikelihood( - z_lens=self.zl, - z_source_1=self.zs1, - z_source_2=self.zs2, beta_dspl=self.beta, sigma_beta_dspl=self.sigma_beta, normalized=False, ) - log_l = dspl_likelihood.lens_log_likelihood(cosmo=self.cosmo) + + log_l = dspl_likelihood.log_likelihood(beta_dsp=self.beta) npt.assert_almost_equal(log_l, 0, decimal=5) dspl_likelihood = DSPLikelihood( - z_lens=self.zl, - z_source_1=self.zs1, - z_source_2=self.zs2, beta_dspl=self.beta - self.sigma_beta, sigma_beta_dspl=self.sigma_beta, normalized=False, ) - log_l = dspl_likelihood.lens_log_likelihood(cosmo=self.cosmo) + log_l = dspl_likelihood.log_likelihood(beta_dsp=self.beta) npt.assert_almost_equal(log_l, -0.5, decimal=5) dspl_likelihood = DSPLikelihood( - z_lens=self.zl, - z_source_1=self.zs1, - z_source_2=self.zs2, beta_dspl=self.beta, sigma_beta_dspl=self.sigma_beta, normalized=True, ) - log_l = dspl_likelihood.lens_log_likelihood(cosmo=self.cosmo) + log_l = dspl_likelihood.log_likelihood(beta_dsp=self.beta) npt.assert_almost_equal( log_l, np.log(1 / np.sqrt(2 * np.pi) / self.sigma_beta), decimal=5 ) def test_num_data(self): dspl_likelihood = DSPLikelihood( - z_lens=self.zl, - z_source_1=self.zs1, - z_source_2=self.zs2, beta_dspl=self.beta, sigma_beta_dspl=self.sigma_beta, normalized=False, diff --git a/test/test_Likelihood/test_cosmo_likelihood.py b/test/test_Likelihood/test_cosmo_likelihood.py index fcbd2fc9..1f3c48bf 100644 --- a/test/test_Likelihood/test_cosmo_likelihood.py +++ b/test/test_Likelihood/test_cosmo_likelihood.py @@ -205,8 +205,8 @@ def test_oLCDM_init(self): { "likelihood_type": "DSPL", "z_lens": 0.3, - "z_source_1": 0.5, - "z_source_2": 1.5, + "z_source": 0.5, + "z_source2": 1.5, "beta_dspl": 1.2, "sigma_beta_dspl": 0.01, } diff --git a/test/test_Likelihood/test_lens_sample_likelihood.py b/test/test_Likelihood/test_lens_sample_likelihood.py index b2356e36..3aad47c8 100644 --- a/test/test_Likelihood/test_lens_sample_likelihood.py +++ b/test/test_Likelihood/test_lens_sample_likelihood.py @@ -85,8 +85,8 @@ def test_double_source_plane(self): kwargs_lens_list = [ { "z_lens": zl, - "z_source_1": zs1, - "z_source_2": zs2, + "z_source": zs1, + "z_source2": zs2, "beta_dspl": beta, "sigma_beta_dspl": sigma_beta, "likelihood_type": "DSPL", From 252f5c81a79c215eb0527f88429810d564f1d8b5 Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Wed, 7 Aug 2024 13:10:53 -0400 Subject: [PATCH 50/62] double source plane sampling with gamma_pl globally in place --- hierarc/Likelihood/cosmo_likelihood.py | 18 +- hierarc/Likelihood/hierarchy_likelihood.py | 19 +- hierarc/Likelihood/lens_sample_likelihood.py | 7 +- .../Distributions/lens_distribution.py | 22 +++ hierarc/Sampling/ParamManager/lens_param.py | 40 ++++- .../Sampling/ParamManager/param_manager.py | 7 + notebooks/double_source_plane.ipynb | 168 ++++++++++++++---- .../test_ParamManager/test_lens_param.py | 18 +- 8 files changed, 247 insertions(+), 52 deletions(-) diff --git a/hierarc/Likelihood/cosmo_likelihood.py b/hierarc/Likelihood/cosmo_likelihood.py index 4b1cfc75..ffe64614 100644 --- a/hierarc/Likelihood/cosmo_likelihood.py +++ b/hierarc/Likelihood/cosmo_likelihood.py @@ -33,10 +33,10 @@ def __init__( :param kwargs_model: model settings for ParamManager() class :type kwargs_model: dict :param kwargs_bounds: keyword arguments of the lower and upper bounds and parameters that are held fixed. - Includes: - 'kwargs_lower_lens', 'kwargs_upper_lens', 'kwargs_fixed_lens', - 'kwargs_lower_kin', 'kwargs_upper_kin', 'kwargs_fixed_kin' - 'kwargs_lower_cosmo', 'kwargs_upper_cosmo', 'kwargs_fixed_cosmo' + Includes: + 'kwargs_lower_lens', 'kwargs_upper_lens', 'kwargs_fixed_lens', + 'kwargs_lower_kin', 'kwargs_upper_kin', 'kwargs_fixed_kin' + 'kwargs_lower_cosmo', 'kwargs_upper_cosmo', 'kwargs_fixed_cosmo' :param KDE_likelihood_chain: (Likelihood.chain.Chain). Chain object to be evaluated with a kernel density estimator :param kwargs_kde_likelihood: keyword argument for the KDE likelihood, see KDELikelihood module for options @@ -99,9 +99,9 @@ def __init__( if "z_source" in kwargs_lens: if kwargs_lens["z_source"] > z_max: z_max = kwargs_lens["z_source"] - if "z_source_2" in kwargs_lens: - if kwargs_lens["z_source_2"] > z_max: - z_max = kwargs_lens["z_source_2"] + if "z_source2" in kwargs_lens: + if kwargs_lens["z_source2"] > z_max: + z_max = kwargs_lens["z_source2"] self._z_max = z_max def likelihood(self, args, kwargs_cosmo_interp=None): @@ -126,8 +126,8 @@ def likelihood(self, args, kwargs_cosmo_interp=None): for lens in self._kwargs_lens_list: if "z_source" in lens: z = lens["z_source"] - elif "z_source_2" in lens: - z = lens["z_source_2"] + elif "z_source2" in lens: + z = lens["z_source2"] else: z = 1100 cut = ok * (1.0 + z) ** 2 + om * (1.0 + z) ** 3 + (1.0 - om - ok) diff --git a/hierarc/Likelihood/hierarchy_likelihood.py b/hierarc/Likelihood/hierarchy_likelihood.py index c51f1b09..83c8d026 100644 --- a/hierarc/Likelihood/hierarchy_likelihood.py +++ b/hierarc/Likelihood/hierarchy_likelihood.py @@ -44,6 +44,8 @@ def __init__( alpha_log_m2l_sampling=False, log_scatter=False, gamma_pl_index=None, + gamma_pl_global_sampling=False, + gamma_pl_global_dist="NONE", # kinematic model quantities kin_scaling_param_list=None, j_kin_scaling_param_axes=None, @@ -92,6 +94,9 @@ def __init__( lambda_mst = lambda_mst_global + beta * lambda_scaling_property_beta :param gamma_pl_index: index of gamma_pl parameter associated with this lens :type gamma_pl_index: int or None + :param gamma_pl_global_sampling: if sampling a global power-law density slope distribution + :type gamma_pl_global_sampling: bool + :param gamma_pl_global_dist: distribution of global gamma_pl distribution ("GAUSSIAN" or "NONE") :param normalized: bool, if True, returns the normalized likelihood, if False, separates the constant prefactor (in case of a Gaussian 1/(sigma sqrt(2 pi)) ) to compute the reduced chi2 statistics :param kwargs_lens_properties: keyword arguments of the lens properties @@ -150,6 +155,8 @@ def __init__( kwargs_min=kwargs_min, kwargs_max=kwargs_max, gamma_pl_index=gamma_pl_index, + gamma_pl_global_sampling=gamma_pl_global_sampling, + gamma_pl_global_dist=gamma_pl_global_dist, ) self._aniso_distribution = AnisotropyDistribution( @@ -202,7 +209,7 @@ def lens_log_likelihood( kwargs_los=kwargs_los, cosmo=cosmo, ) - return a + return np.nan_to_num(a) def hyper_param_likelihood( self, @@ -331,14 +338,16 @@ def log_likelihood_single( lambda_mst=lambda_mst, ) lnlikelihood += self._prior.log_likelihood(kwargs_param) - return np.nan_to_num(lnlikelihood) + return lnlikelihood def angular_diameter_distances(self, cosmo): """Time-delay distance Ddt, angular diameter distance to the lens (dd) :param cosmo: astropy.cosmology instance (or equivalent with interpolation) - :return: ddt, dd, ds in units physical Mpc + :return: ddt, dd in units physical Mpc """ + if self.likelihood_type in ["DSPL"]: + return 0, 0 # just returns some random numbers as not being used dd = cosmo.angular_diameter_distance(z=self._z_lens).value ds = cosmo.angular_diameter_distance(z=self._z_source).value dds = cosmo.angular_diameter_distance_z1z2( @@ -358,6 +367,8 @@ def luminosity_distance_modulus(self, cosmo, z_apparent_m_anchor): :param z_apparent_m_anchor: redshift of pivot/anchor at which the apparent SNe brightness is defined relative to :return: lum_dist(z_source) - lum_dist(z_pivot) """ + if self.likelihood_type not in ["Mag", "TDMag", "TDMagMagnitude"]: + return 0 angular_diameter_distances = np.maximum( np.nan_to_num(cosmo.angular_diameter_distance(self._z_source).value), 0.00001, @@ -391,11 +402,13 @@ def check_dist(self, kwargs_lens, kwargs_kin, kwargs_source, kwargs_los): a_ani_sigma = kwargs_kin.get("a_ani_sigma", 0) beta_inf_sigma = kwargs_kin.get("beta_inf_sigma", 0) sne_sigma = kwargs_source.get("sigma_sne", 0) + gamma_pl_sigma = kwargs_lens.get("gamma_pl_sigma", 0) if ( a_ani_sigma == 0 and lambda_mst_sigma == 0 and beta_inf_sigma == 0 and sne_sigma == 0 + and gamma_pl_sigma == 0 and not draw_kappa_bool ): return True diff --git a/hierarc/Likelihood/lens_sample_likelihood.py b/hierarc/Likelihood/lens_sample_likelihood.py index f6b114de..0c543d24 100644 --- a/hierarc/Likelihood/lens_sample_likelihood.py +++ b/hierarc/Likelihood/lens_sample_likelihood.py @@ -22,9 +22,12 @@ def __init__(self, kwargs_lens_list, normalized=False, kwargs_global_model=None) self._lens_list = [] self._gamma_pl_num = 0 gamma_pl_index = 0 + + gamma_pl_global_sampling = kwargs_global_model.get("gamma_pl_global_sampling", False) + for kwargs_lens in kwargs_lens_list: gamma_pl_index_ = None - if "kin_scaling_param_list" in kwargs_lens: + if "kin_scaling_param_list" in kwargs_lens and not gamma_pl_global_sampling: kin_scaling_param_list = kwargs_lens["kin_scaling_param_list"] if "gamma_pl" in kin_scaling_param_list: self._gamma_pl_num += 1 @@ -117,5 +120,7 @@ def _merge_global2local_settings(kwargs_global_model, kwargs_lens): "beta_lambda_sampling", "alpha_gamma_in_sampling", "alpha_log_m2l_sampling", + "gamma_pl_global_sampling", + "gamma_pl_global_dist", "log_scatter", ] diff --git a/hierarc/Sampling/Distributions/lens_distribution.py b/hierarc/Sampling/Distributions/lens_distribution.py index 8e6a706e..eb407259 100644 --- a/hierarc/Sampling/Distributions/lens_distribution.py +++ b/hierarc/Sampling/Distributions/lens_distribution.py @@ -23,6 +23,8 @@ def __init__( kwargs_min=None, kwargs_max=None, gamma_pl_index=None, + gamma_pl_global_sampling=False, + gamma_pl_global_dist="NONE", ): """ @@ -55,6 +57,9 @@ def __init__( :type kwargs_max: dict or None :param gamma_pl_index: index of gamma_pl parameter associated with this lens :type gamma_pl_index: int or None + :param gamma_pl_global_sampling: if sampling a global power-law density slope distribution + :type gamma_pl_global_sampling: bool + :param gamma_pl_global_dist: distribution of global gamma_pl distribution ("GAUSSIAN" or "NONE") """ self._lambda_mst_sampling = lambda_mst_sampling self._lambda_mst_distribution = lambda_mst_distribution @@ -69,6 +74,8 @@ def __init__( self._mst_ifu = mst_ifu self._lambda_scaling_property = lambda_scaling_property self._lambda_scaling_property_beta = lambda_scaling_property_beta + self._gamma_pl_global_sampling = gamma_pl_global_sampling + self._gamma_pl_global_dist = gamma_pl_global_dist self._log_scatter = log_scatter if kwargs_max is None: @@ -104,6 +111,8 @@ def draw_lens( log_m2l_sigma=0, alpha_log_m2l=0, gamma_pl_list=None, + gamma_pl_mean=2, + gamma_pl_sigma=0, ): """Draws a realization of a specific model from the hyperparameter distribution. @@ -128,6 +137,8 @@ def draw_lens( lens quantity self._lambda_scaling_property :param gamma_pl_list: power-law density slopes as lists (for multiple lenses) :type gamma_pl_list: list or None + :param gamma_pl_mean: mean of gamma_pl of the global distribution + :param gamma_pl_sigma: sigma of the gamma_pl global distribution :return: draw from the distributions """ kwargs_return = {} @@ -178,6 +189,8 @@ def draw_lens( log_m2l_sigma=log_m2l_sigma, alpha_log_m2l=alpha_log_m2l, gamma_pl_list=gamma_pl_list, + gamma_pl_mean=gamma_pl_mean, + gamma_pl_sigma=gamma_pl_sigma, ) kwargs_return["gamma_in"] = gamma_in_draw if self._log_m2l_sampling: @@ -206,8 +219,17 @@ def draw_lens( log_m2l_sigma=log_m2l_sigma, alpha_log_m2l=alpha_log_m2l, gamma_pl_list=gamma_pl_list, + gamma_pl_mean=gamma_pl_mean, + gamma_pl_sigma=gamma_pl_sigma, ) kwargs_return["log_m2l"] = log_m2l_draw if self._gamma_pl_model is True: kwargs_return["gamma_pl"] = gamma_pl_list[self._gamma_pl_index] + elif self._gamma_pl_global_sampling is True: + if self._gamma_pl_global_dist in ["GAUSSIAN"]: + gamma_pl_draw = np.random.normal(gamma_pl_mean, gamma_pl_sigma) + else: + gamma_pl_draw = gamma_pl_mean + kwargs_return["gamma_pl"] = gamma_pl_draw + return kwargs_return diff --git a/hierarc/Sampling/ParamManager/lens_param.py b/hierarc/Sampling/ParamManager/lens_param.py index 3b3b3eae..9928a327 100644 --- a/hierarc/Sampling/ParamManager/lens_param.py +++ b/hierarc/Sampling/ParamManager/lens_param.py @@ -19,6 +19,8 @@ def __init__( alpha_gamma_in_sampling=False, alpha_log_m2l_sampling=False, gamma_pl_num=0, + gamma_pl_global_sampling=False, + gamma_pl_global_dist="NONE", kwargs_fixed=None, log_scatter=False, ): @@ -47,7 +49,11 @@ def __init__( :param alpha_gamma_in_sampling: bool, if True samples a parameter alpha_gamma_in, which scales gamma_in linearly :param alpha_log_m2l_sampling: bool, if True samples a parameter alpha_log_m2l, which scales log_m2l linearly :param gamma_pl_num: int, number of power-law density slopes being sampled (to be assigned to individual lenses) - :param log_scatter: boolean, if True, samples the Gaussian scatter amplitude in log space (and thus flat prior in log) + :param gamma_pl_global_sampling: if sampling a global power-law density slope distribution + :type gamma_pl_global_sampling: bool + :param gamma_pl_global_dist: distribution of global gamma_pl distribution ("GAUSSIAN" or "NONE") + :param log_scatter: boolean, if True, samples the Gaussian scatter amplitude in log space (and thus flat prior + in log) :param kwargs_fixed: keyword arguments that are held fixed through the sampling """ self._lambda_mst_sampling = lambda_mst_sampling @@ -63,6 +69,8 @@ def __init__( self._alpha_gamma_in_sampling = alpha_gamma_in_sampling self._alpha_log_m2l_sampling = alpha_log_m2l_sampling self._gamma_pl_num = gamma_pl_num + self._gamma_pl_global_sampling = gamma_pl_global_sampling + self._gamma_pl_global_dist = gamma_pl_global_dist self._log_scatter = log_scatter if kwargs_fixed is None: @@ -165,6 +173,18 @@ def param_list(self, latex_style=False): list.append(r"$\gamma_{\rm pl %i}$" % i) else: list.append("gamma_pl_%s" % i) + if self._gamma_pl_global_sampling is True: + if "gamma_pl_mean" not in self._kwargs_fixed: + if latex_style is True: + list.append(r"$\gamma_{\rm pl, global}$") + else: + list.append("gamma_pl_mean") + if self._gamma_pl_global_dist == "GAUSSIAN": + if "gamma_pl_sigma" not in self._kwargs_fixed: + if latex_style is True: + list.append(r"$\sigma(\gamma_{\rm pl, global})$") + else: + list.append("gamma_pl_sigma") return list def args2kwargs(self, args, i=0): @@ -264,6 +284,18 @@ def args2kwargs(self, args, i=0): gamma_pl_list.append(args[i]) i += 1 kwargs["gamma_pl_list"] = gamma_pl_list + if self._gamma_pl_global_sampling is True: + if "gamma_pl_mean" in self._kwargs_fixed: + kwargs["gamma_pl_mean"] = self._kwargs_fixed["gamma_pl_mean"] + else: + kwargs["gamma_pl_mean"] = args[i] + i += 1 + if self._gamma_pl_global_dist == "GAUSSIAN": + if "gamma_pl_sigma" in self._kwargs_fixed: + kwargs["gamma_pl_sigma"] = self._kwargs_fixed["gamma_pl_sigma"] + else: + kwargs["gamma_pl_sigma"] = args[i] + i += 1 return kwargs, i @@ -325,4 +357,10 @@ def kwargs2args(self, kwargs): if self._gamma_pl_num > 0: for i in range(self._gamma_pl_num): args.append(kwargs["gamma_pl_list"][i]) + if self._gamma_pl_global_sampling is True: + if "gamma_pl_mean" not in self._kwargs_fixed: + args.append(kwargs["gamma_pl_mean"]) + if self._gamma_pl_global_dist == "GAUSSIAN": + if "gamma_pl_sigma" not in self._kwargs_fixed: + args.append(kwargs["gamma_pl_sigma"]) return args diff --git a/hierarc/Sampling/ParamManager/param_manager.py b/hierarc/Sampling/ParamManager/param_manager.py index 4acf7604..14ce69d7 100644 --- a/hierarc/Sampling/ParamManager/param_manager.py +++ b/hierarc/Sampling/ParamManager/param_manager.py @@ -28,6 +28,8 @@ def __init__( alpha_gamma_in_sampling=False, alpha_log_m2l_sampling=False, gamma_pl_num=0, + gamma_pl_global_sampling=False, + gamma_pl_global_dist="NONE", sigma_v_systematics=False, sne_apparent_m_sampling=False, sne_distribution="GAUSSIAN", @@ -76,6 +78,9 @@ def __init__( :param alpha_log_m2l_sampling: bool, if True samples a parameter alpha_log_m2l, which scales log_m2l linearly according to a predefined quantity of the lens :param gamma_pl_num: int, number of power-law density slopes being sampled (to be assigned to individual lenses) + :param gamma_pl_global_sampling: if sampling a global power-law density slope distribution + :type gamma_pl_global_sampling: bool + :param gamma_pl_global_dist: distribution of global gamma_pl distribution ("GAUSSIAN" or "NONE") :param sne_apparent_m_sampling: boolean, if True, samples/queries SNe unlensed magnitude distribution (not intrinsic magnitudes but apparent!) :param sne_distribution: string, apparent non-lensed brightness distribution (in linear space). @@ -118,6 +123,8 @@ def __init__( alpha_gamma_in_sampling=alpha_gamma_in_sampling, alpha_log_m2l_sampling=alpha_log_m2l_sampling, gamma_pl_num=gamma_pl_num, + gamma_pl_global_sampling=gamma_pl_global_sampling, + gamma_pl_global_dist=gamma_pl_global_dist, log_scatter=log_scatter, kwargs_fixed=kwargs_fixed_lens, ) diff --git a/notebooks/double_source_plane.ipynb b/notebooks/double_source_plane.ipynb index 14df8691..ba0158cc 100644 --- a/notebooks/double_source_plane.ipynb +++ b/notebooks/double_source_plane.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "aaf95f3e", "metadata": {}, "outputs": [], @@ -49,19 +49,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "e78f8e6a", "metadata": {}, "outputs": [], "source": [ "from hierarc.Likelihood.LensLikelihood.double_source_plane import (\n", - " beta_double_source_plane,\n", + " beta_double_source_plane, beta2theta_e_ratio\n", ")\n", "\n", "# define a cosmology\n", - "cosmology = \"FLCDM\" # Flat LCDM cosmology\n", - "# other options are: \"FwCDM\", \"w0waCDM\", \"oLCDM\"\n", - "kwargs_cosmo_true = {\"h0\": 70, \"om\": 0.3} # cosmological model of the forecast\n", + "cosmology = \"FwCDM\" # Flat wCDM cosmology\n", + "# other options are: \"FLCDM FwCDM\", \"w0waCDM\", \"oLCDM\"\n", + "kwargs_cosmo_true = {\"h0\": 70, \"om\": 0.3, \"w\": -1} # cosmological model of the forecast\n", "\n", "# create astropy.cosmology instance of input cosmology\n", "cosmo_param = CosmoParam(cosmology=cosmology)\n", @@ -69,28 +69,37 @@ "\n", "\n", "# =====================================\n", - "# TODO: match settings with publication\n", + "# Settings for pupulation of DSP\n", "# =====================================\n", "\n", "# number of double source plane lenses\n", "num_dspl = 87\n", "\n", "sigma_beta = 0.05 # relative precision on Einstein radius ratio\n", + "gamma_pl_mean = 2.05\n", + "gamma_pl_sigma = 0.05\n", + "\n", + "lambda_mst_mean = 1\n", + "lambda_mst_sigma = 0.0\n", "\n", "\n", - "def draw_lens():\n", + "def draw_lens(lambda_mst_mean, lambda_mst_sigma, gamma_pl_mean, gamma_pl_sigma):\n", " \"\"\"\n", " draw the likelihood object of a double source plane lens\n", " \"\"\"\n", " z_lens = np.random.uniform(low=0.2, high=0.5)\n", - " z_source1 = np.random.uniform(low=z_lens + 0.2, high=3)\n", - " z_source2 = np.random.uniform(low=z_source1, high=5)\n", + " z_source1 = np.random.uniform(low=z_lens + 0.2, high=1.5)\n", + " z_source2 = np.random.uniform(low=z_source1, high=3)\n", " beta = beta_double_source_plane(z_lens, z_source1, z_source2, cosmo_true)\n", - " beta_measured = beta + np.random.normal(loc=0, scale=sigma_beta * beta)\n", + " # TODO: translate to measured Einstein radius ratio\n", + " lambda_mst = np.random.normal(lambda_mst_mean, lambda_mst_sigma)\n", + " gamma_pl = np.random.normal(gamma_pl_mean, gamma_pl_sigma)\n", + " beta_transformed = beta2theta_e_ratio(beta_dsp=beta, gamma_pl=gamma_pl, lambda_mst=lambda_mst)\n", + " beta_measured = beta_transformed + np.random.normal(loc=0, scale=sigma_beta * beta_transformed)\n", " kwargs_likelihood = {\n", " \"z_lens\": z_lens,\n", - " \"z_source_1\": z_source1,\n", - " \"z_source_2\": z_source2,\n", + " \"z_source\": z_source1,\n", + " \"z_source2\": z_source2,\n", " \"beta_dspl\": beta_measured,\n", " \"sigma_beta_dspl\": sigma_beta * beta,\n", " \"likelihood_type\": \"DSPL\",\n", @@ -101,7 +110,7 @@ "kwargs_dspl_list = []\n", "\n", "for i in range(num_dspl):\n", - " kwargs_dspl_list.append(draw_lens())" + " kwargs_dspl_list.append(draw_lens(lambda_mst_mean, lambda_mst_sigma, gamma_pl_mean, gamma_pl_sigma))" ] }, { @@ -114,7 +123,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "84bcf905", "metadata": {}, "outputs": [], @@ -126,44 +135,135 @@ "\n", "cosmology = \"FwCDM\"\n", "\n", - "kwargs_mean_start = {\"kwargs_cosmo\": {\"h0\": 70, \"om\": 0.3, \"w\": -1}}\n", + "kwargs_mean_start = {\"kwargs_cosmo\": {\"h0\": 70, \"om\": 0.3, \"w\": -1},\n", + " \"kwargs_lens\": {\"lambda_mst\": lambda_mst_mean, \"lambda_mst_sigma\": lambda_mst_sigma,\n", + " \"gamma_pl_mean\": gamma_pl_mean, \"gamma_pl_sigma\": gamma_pl_sigma}}\n", "\n", - "kwargs_sigma_start = {\"kwargs_cosmo\": {\"h0\": 10, \"om\": 0.05, \"w\": 0.2}}\n", + "kwargs_sigma_start = {\"kwargs_cosmo\": {\"h0\": 10, \"om\": 0.05, \"w\": 0.2},\n", + " \"kwargs_lens\": {\"lambda_mst\": 0.1, \"lambda_mst_sigma\": 0.01,\n", + " \"gamma_pl_mean\": 0.1, \"gamma_pl_sigma\": 0.01}}\n", "\n", "\n", "kwargs_bounds = {\n", " \"kwargs_lower_cosmo\": {\"h0\": 0, \"om\": 0, \"w\": -2},\n", " \"kwargs_upper_cosmo\": {\"h0\": 200, \"om\": 1, \"w\": 0},\n", " \"kwargs_fixed_cosmo\": {\"h0\": kwargs_cosmo_true[\"h0\"]},\n", + " \n", + " \"kwargs_lower_lens\": {\"lambda_mst\": 0.8, \"gamma_pl_mean\": 1.5},\n", + " \"kwargs_upper_lens\": {\"lambda_mst\": 1.2, \"gamma_pl_mean\": 2.5},\n", + " \"kwargs_fixed_lens\": {\"gamma_pl_sigma\": gamma_pl_sigma, \"lambda_mst_sigma\": lambda_mst_sigma}\n", "}\n", "\n", "\n", + "# TODO: add gamma_pl population sampling\n", + "# TODO: add lambda_mst_sigma sampling\n", + "\n", "# joint options for hierArc sampling\n", - "kwargs_sampler = {\n", - " \"cosmology\": cosmology,\n", - " \"kwargs_bounds\": kwargs_bounds,\n", - " \"lambda_mst_sampling\": False,\n", - " \"anisotropy_sampling\": False,\n", - " \"kappa_ext_sampling\": False,\n", - " \"kappa_ext_distribution\": \"NONE\",\n", - " \"alpha_lambda_sampling\": False,\n", - " \"sigma_v_systematics\": False,\n", + "\n", + "\n", + "\n", + "kwargs_model = {\n", + " \"lambda_mst_sampling\": True,\n", + " \"lambda_mst_distribution\": \"NONE\", # TODO: switch to GAUSSIAN\n", + " \"gamma_pl_global_sampling\": True,\n", + " \"gamma_pl_global_dist\": \"GAUSSIAN\", # TODO: switch to GAUSSIAN\n", " \"log_scatter\": False,\n", - " \"custom_prior\": None,\n", - " \"interpolate_cosmo\": False,\n", - " \"num_redshift_interp\": 100,\n", - " \"cosmo_fixed\": None,\n", - "}" + "}\n", + "\n", + "\n", + "kwargs_sampler = {\"custom_prior\": None,\n", + " \"interpolate_cosmo\": False,\n", + " \"num_redshift_interp\": 100,\n", + " \"cosmo_fixed\": None,\n", + " }" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "d6d585f6", "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "90.7 ms ± 763 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + ] + } + ], + "source": [ + "mcmc_sampler = MCMCSampler(kwargs_dspl_list, cosmology=cosmology, \n", + " kwargs_model=kwargs_model, kwargs_bounds=kwargs_bounds,\n", + " **kwargs_sampler)\n", + "\n", + "likelihood = mcmc_sampler.chain\n", + "param = mcmc_sampler.param\n", + "\n", + "kwargs_test = {\"kwargs_cosmo\": {\"h0\": 70, \"om\": 0.3, \"w\": -1},\n", + " \"kwargs_lens\": {\"lambda_mst\": lambda_mst_mean, \"lambda_mst_sigma\": lambda_mst_sigma,\n", + " \"gamma_pl_mean\": gamma_pl_mean+0., \"gamma_pl_sigma\": gamma_pl_sigma}}\n", + "\n", + "args = param.kwargs2args(**kwargs_test)\n", + "\n", + "%timeit likelihood.likelihood(args)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "7b0f2000", + "metadata": {}, "outputs": [], "source": [ - "mcmc_sampler = MCMCSampler(kwargs_dspl_list, **kwargs_sampler)\n", + "%load_ext line_profiler\n", + "\n", + "# %lprun -f likelihood.likelihood likelihood.likelihood(args) # first level\n", + "\n", + "from hierarc.Likelihood.lens_sample_likelihood import LensSampleLikelihood\n", + "# %lprun -f LensSampleLikelihood.log_likelihood likelihood.likelihood(args) # second level\n", + "\n", + "\n", + "from hierarc.Likelihood.hierarchy_likelihood import LensLikelihood\n", + "# %lprun -f LensLikelihood.lens_log_likelihood likelihood.likelihood(args) # third level\n", + "\n", + "# %lprun -f LensLikelihood.hyper_param_likelihood likelihood.likelihood(args) # 4th level\n", + "\n", + "%lprun -f LensLikelihood.log_likelihood_single likelihood.likelihood(args) # 5th level\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f9c3d24e", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 400/400 [9:29:56<00:00, 6.13s/it] \n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "\n", "mcmc_samples, log_prob = mcmc_sampler.mcmc_emcee(\n", " n_walkers, n_burn, n_run, kwargs_mean_start, kwargs_sigma_start\n", ")\n", @@ -177,7 +277,7 @@ { "cell_type": "code", "execution_count": null, - "id": "f9c3d24e", + "id": "319cc4e8", "metadata": {}, "outputs": [], "source": [] diff --git a/test/test_Sampling/test_ParamManager/test_lens_param.py b/test/test_Sampling/test_ParamManager/test_lens_param.py index b39d30fb..db10c7b4 100644 --- a/test/test_Sampling/test_ParamManager/test_lens_param.py +++ b/test/test_Sampling/test_ParamManager/test_lens_param.py @@ -11,6 +11,8 @@ def setup_method(self): lambda_ifu_distribution="GAUSSIAN", alpha_lambda_sampling=True, beta_lambda_sampling=True, + gamma_pl_global_sampling=True, + gamma_pl_global_dist="GAUSSIAN", kwargs_fixed={}, gamma_pl_num=2, ) @@ -22,6 +24,8 @@ def setup_method(self): "lambda_ifu_sigma": 0.2, "alpha_lambda": 0, "beta_lambda": 0, + "gamma_pl_mean": 2, + "gamma_pl_sigma": 0.1, } self._param_fixed = LensParam( lambda_mst_sampling=True, @@ -30,6 +34,8 @@ def setup_method(self): lambda_ifu_distribution="GAUSSIAN", alpha_lambda_sampling=True, beta_lambda_sampling=True, + gamma_pl_global_sampling=True, + gamma_pl_global_dist="GAUSSIAN", kwargs_fixed=kwargs_fixed, ) self._param_log_scatter = LensParam( @@ -39,20 +45,22 @@ def setup_method(self): lambda_ifu_distribution="GAUSSIAN", alpha_lambda_sampling=True, beta_lambda_sampling=True, + gamma_pl_global_sampling=True, + gamma_pl_global_dist="GAUSSIAN", log_scatter=True, kwargs_fixed={}, ) def test_param_list(self): param_list = self._param.param_list(latex_style=False) - assert len(param_list) == 8 + assert len(param_list) == 10 param_list = self._param.param_list(latex_style=True) - assert len(param_list) == 8 + assert len(param_list) == 10 param_list = self._param_log_scatter.param_list(latex_style=False) - assert len(param_list) == 6 + assert len(param_list) == 8 param_list = self._param_log_scatter.param_list(latex_style=True) - assert len(param_list) == 6 + assert len(param_list) == 8 param_list = self._param_fixed.param_list(latex_style=False) assert len(param_list) == 0 @@ -70,6 +78,8 @@ def test_args2kwargs(self): "alpha_lambda": 0.1, "beta_lambda": 0.1, "gamma_pl_list": [2, 2.5], + "gamma_pl_mean": 2., + "gamma_pl_sigma": 0.1, } args = self._param.kwargs2args(kwargs) print(args, "test args") From e1a42d28e69183fde8cb20909b6ec86e5c05b4f5 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Wed, 7 Aug 2024 17:18:07 +0000 Subject: [PATCH 51/62] [pre-commit.ci] auto fixes from pre-commit.com hooks --- .../LensLikelihood/base_lens_likelihood.py | 38 +++++++-- .../LensLikelihood/double_source_plane.py | 18 ++-- hierarc/Likelihood/hierarchy_likelihood.py | 12 ++- hierarc/Likelihood/lens_sample_likelihood.py | 10 ++- notebooks/double_source_plane.ipynb | 83 +++++++++++++------ .../test_ParamManager/test_lens_param.py | 2 +- 6 files changed, 112 insertions(+), 51 deletions(-) diff --git a/hierarc/Likelihood/LensLikelihood/base_lens_likelihood.py b/hierarc/Likelihood/LensLikelihood/base_lens_likelihood.py index 0b570528..663839d7 100644 --- a/hierarc/Likelihood/LensLikelihood/base_lens_likelihood.py +++ b/hierarc/Likelihood/LensLikelihood/base_lens_likelihood.py @@ -1,6 +1,8 @@ __author__ = "sibirrer" -from hierarc.Likelihood.LensLikelihood.double_source_plane import beta_double_source_plane +from hierarc.Likelihood.LensLikelihood.double_source_plane import ( + beta_double_source_plane, +) LIKELIHOOD_TYPES = [ "DdtGaussian", @@ -102,7 +104,9 @@ def __init__( DdtHistLikelihood, ) - self._lens_type = DdtHistLikelihood(z_lens, z_source, normalized=normalized, **kwargs_likelihood) + self._lens_type = DdtHistLikelihood( + z_lens, z_source, normalized=normalized, **kwargs_likelihood + ) elif likelihood_type == "DdtHistKDE": from hierarc.Likelihood.LensLikelihood.ddt_hist_likelihood import ( DdtHistKDELikelihood, @@ -146,7 +150,10 @@ def __init__( self._lens_type = TDMagMagnitudeLikelihood(**kwargs_likelihood) elif likelihood_type == "DSPL": - from hierarc.Likelihood.LensLikelihood.double_source_plane import DSPLikelihood + from hierarc.Likelihood.LensLikelihood.double_source_plane import ( + DSPLikelihood, + ) + self._lens_type = DSPLikelihood(normalized=normalized, **kwargs_likelihood) else: raise ValueError( @@ -162,8 +169,15 @@ def num_data(self): return self._lens_type.num_data def log_likelihood( - self, ddt, dd, beta_dsp=None, kin_scaling=None, sigma_v_sys_error=None, mu_intrinsic=None, - gamma_pl=None, lambda_mst=None + self, + ddt, + dd, + beta_dsp=None, + kin_scaling=None, + sigma_v_sys_error=None, + mu_intrinsic=None, + gamma_pl=None, + lambda_mst=None, ): """ @@ -201,7 +215,9 @@ def log_likelihood( elif self.likelihood_type in ["TDMag", "TDMagMagnitude"]: return self._lens_type.log_likelihood(ddt=ddt, mu_intrinsic=mu_intrinsic) elif self.likelihood_type in ["DSPL"]: - return self._lens_type.log_likelihood(beta_dsp=beta_dsp, gamma_pl=gamma_pl, lambda_mst=lambda_mst) + return self._lens_type.log_likelihood( + beta_dsp=beta_dsp, gamma_pl=gamma_pl, lambda_mst=lambda_mst + ) else: raise ValueError( "likelihood type %s not fully supported." % self.likelihood_type @@ -249,14 +265,18 @@ def sigma_v_prediction(self, ddt, dd, kin_scaling=None): def beta_dsp(self, cosmo): """Model prediction of ratio of Einstein radii theta_E_1 / theta_E_2 or scaled - deflection angles. Only computes it when likelihood is DSP + deflection angles. Only computes it when likelihood is DSP. :param cosmo: ~astropy.cosmology instance :return: beta """ if self.likelihood_type == "DSPL": - beta = beta_double_source_plane(z_lens=self.z_lens, z_source_1=self.z_source, z_source_2=self.z_source2, - cosmo=cosmo) + beta = beta_double_source_plane( + z_lens=self.z_lens, + z_source_1=self.z_source, + z_source_2=self.z_source2, + cosmo=cosmo, + ) else: beta = None return beta diff --git a/hierarc/Likelihood/LensLikelihood/double_source_plane.py b/hierarc/Likelihood/LensLikelihood/double_source_plane.py index fc43b7b4..fc33119d 100644 --- a/hierarc/Likelihood/LensLikelihood/double_source_plane.py +++ b/hierarc/Likelihood/LensLikelihood/double_source_plane.py @@ -28,13 +28,15 @@ def log_likelihood( ): """Log likelihood of the data given a model. - :param beta_dsp: scaled deflection angles alpha_1 / alpha_2 as ratio - between z_source and z_source2 source planes + :param beta_dsp: scaled deflection angles alpha_1 / alpha_2 as ratio between + z_source and z_source2 source planes :param gamma_pl: power-law density slope of main deflector (=2 being isothermal) :param lambda_mst: mass-sheet transform at the main deflector :return: log likelihood of data given model """ - theta_E_ratio = beta2theta_e_ratio(beta_dsp, gamma_pl=gamma_pl, lambda_mst=lambda_mst) + theta_E_ratio = beta2theta_e_ratio( + beta_dsp, gamma_pl=gamma_pl, lambda_mst=lambda_mst + ) log_l = -0.5 * ((theta_E_ratio - self._beta_dspl) / self._sigma_beta_dspl) ** 2 if self._normalized: log_l -= 1 / 2.0 * np.log(2 * np.pi * self._sigma_beta_dspl**2) @@ -67,13 +69,13 @@ def beta_double_source_plane(z_lens, z_source_1, z_source_2, cosmo): def beta2theta_e_ratio(beta_dsp, gamma_pl=2, lambda_mst=1): - """ - calculates Einstein radii ratio for a power-law + MST profile with given parameters + """Calculates Einstein radii ratio for a power-law + MST profile with given + parameters. - :param beta_dsp: scaled deflection angles alpha_1 / alpha_2 as ratio - between z_source and z_source2 source planes + :param beta_dsp: scaled deflection angles alpha_1 / alpha_2 as ratio between + z_source and z_source2 source planes :param gamma_pl: power-law density slope of main deflector (=2 being isothermal) :param lambda_mst: mass-sheet transform at the main deflector :return: theta_E1 / theta_E2 """ - return (beta_dsp - (1 - lambda_mst) * (1 - beta_dsp)) ** (1/(gamma_pl - 1)) + return (beta_dsp - (1 - lambda_mst) * (1 - beta_dsp)) ** (1 / (gamma_pl - 1)) diff --git a/hierarc/Likelihood/hierarchy_likelihood.py b/hierarc/Likelihood/hierarchy_likelihood.py index 83c8d026..c6a4d4b5 100644 --- a/hierarc/Likelihood/hierarchy_likelihood.py +++ b/hierarc/Likelihood/hierarchy_likelihood.py @@ -223,19 +223,22 @@ def hyper_param_likelihood( kwargs_los=None, cosmo=None, ): - """Log likelihood of the data of a lens given a model (defined with hyperparameters) and cosmological distances. + """Log likelihood of the data of a lens given a model (defined with + hyperparameters) and cosmological distances. :param ddt: time-delay distance :param dd: angular diameter distance to the deflector :param delta_lum_dist: relative luminosity distance to pivot redshift - :param beta_dsp: Model prediction of ratio of Einstein radii theta_E_1 / theta_E_2 + :param beta_dsp: Model prediction of ratio of Einstein radii theta_E_1 / + theta_E_2 :param kwargs_lens: keywords of the hyperparameters of the lens model :param kwargs_kin: keyword arguments of the kinematic model hyperparameters :param kwargs_source: keyword argument of the source model (such as SNe) :param kwargs_los: list of keyword arguments of global line of sight distributions :param cosmo: ~astropy.cosmology instance - :return: log likelihood given the single lens analysis for the given hyperparameter + :return: log likelihood given the single lens analysis for the given + hyperparameter """ kwargs_lens = self._kwargs_init(kwargs_lens) kwargs_kin = self._kwargs_init(kwargs_kin) @@ -296,7 +299,8 @@ def log_likelihood_single( :param ddt: time-delay distance :param dd: angular diameter distance to the deflector :param delta_lum_dist: relative luminosity distance to pivot redshift - :param beta_dsp: Model prediction of ratio of Einstein radii theta_E_1 / theta_E_2 + :param beta_dsp: Model prediction of ratio of Einstein radii theta_E_1 / + theta_E_2 :param kwargs_lens: keywords of the hyperparameters of the lens model :param kwargs_kin: keyword arguments of the kinematic model hyperparameters :param kwargs_source: keyword arguments of source brightness diff --git a/hierarc/Likelihood/lens_sample_likelihood.py b/hierarc/Likelihood/lens_sample_likelihood.py index 0c543d24..61499326 100644 --- a/hierarc/Likelihood/lens_sample_likelihood.py +++ b/hierarc/Likelihood/lens_sample_likelihood.py @@ -23,7 +23,9 @@ def __init__(self, kwargs_lens_list, normalized=False, kwargs_global_model=None) self._gamma_pl_num = 0 gamma_pl_index = 0 - gamma_pl_global_sampling = kwargs_global_model.get("gamma_pl_global_sampling", False) + gamma_pl_global_sampling = kwargs_global_model.get( + "gamma_pl_global_sampling", False + ) for kwargs_lens in kwargs_lens_list: gamma_pl_index_ = None @@ -37,7 +39,11 @@ def __init__(self, kwargs_lens_list, normalized=False, kwargs_global_model=None) kwargs_global_model=kwargs_global_model, kwargs_lens=kwargs_lens ) self._lens_list.append( - LensLikelihood(gamma_pl_index=gamma_pl_index_, normalized=normalized, **kwargs_lens_) + LensLikelihood( + gamma_pl_index=gamma_pl_index_, + normalized=normalized, + **kwargs_lens_ + ) ) def log_likelihood( diff --git a/notebooks/double_source_plane.ipynb b/notebooks/double_source_plane.ipynb index ba0158cc..9ee1b1bd 100644 --- a/notebooks/double_source_plane.ipynb +++ b/notebooks/double_source_plane.ipynb @@ -55,7 +55,8 @@ "outputs": [], "source": [ "from hierarc.Likelihood.LensLikelihood.double_source_plane import (\n", - " beta_double_source_plane, beta2theta_e_ratio\n", + " beta_double_source_plane,\n", + " beta2theta_e_ratio,\n", ")\n", "\n", "# define a cosmology\n", @@ -94,8 +95,12 @@ " # TODO: translate to measured Einstein radius ratio\n", " lambda_mst = np.random.normal(lambda_mst_mean, lambda_mst_sigma)\n", " gamma_pl = np.random.normal(gamma_pl_mean, gamma_pl_sigma)\n", - " beta_transformed = beta2theta_e_ratio(beta_dsp=beta, gamma_pl=gamma_pl, lambda_mst=lambda_mst)\n", - " beta_measured = beta_transformed + np.random.normal(loc=0, scale=sigma_beta * beta_transformed)\n", + " beta_transformed = beta2theta_e_ratio(\n", + " beta_dsp=beta, gamma_pl=gamma_pl, lambda_mst=lambda_mst\n", + " )\n", + " beta_measured = beta_transformed + np.random.normal(\n", + " loc=0, scale=sigma_beta * beta_transformed\n", + " )\n", " kwargs_likelihood = {\n", " \"z_lens\": z_lens,\n", " \"z_source\": z_source1,\n", @@ -110,7 +115,9 @@ "kwargs_dspl_list = []\n", "\n", "for i in range(num_dspl):\n", - " kwargs_dspl_list.append(draw_lens(lambda_mst_mean, lambda_mst_sigma, gamma_pl_mean, gamma_pl_sigma))" + " kwargs_dspl_list.append(\n", + " draw_lens(lambda_mst_mean, lambda_mst_sigma, gamma_pl_mean, gamma_pl_sigma)\n", + " )" ] }, { @@ -135,23 +142,37 @@ "\n", "cosmology = \"FwCDM\"\n", "\n", - "kwargs_mean_start = {\"kwargs_cosmo\": {\"h0\": 70, \"om\": 0.3, \"w\": -1},\n", - " \"kwargs_lens\": {\"lambda_mst\": lambda_mst_mean, \"lambda_mst_sigma\": lambda_mst_sigma,\n", - " \"gamma_pl_mean\": gamma_pl_mean, \"gamma_pl_sigma\": gamma_pl_sigma}}\n", + "kwargs_mean_start = {\n", + " \"kwargs_cosmo\": {\"h0\": 70, \"om\": 0.3, \"w\": -1},\n", + " \"kwargs_lens\": {\n", + " \"lambda_mst\": lambda_mst_mean,\n", + " \"lambda_mst_sigma\": lambda_mst_sigma,\n", + " \"gamma_pl_mean\": gamma_pl_mean,\n", + " \"gamma_pl_sigma\": gamma_pl_sigma,\n", + " },\n", + "}\n", "\n", - "kwargs_sigma_start = {\"kwargs_cosmo\": {\"h0\": 10, \"om\": 0.05, \"w\": 0.2},\n", - " \"kwargs_lens\": {\"lambda_mst\": 0.1, \"lambda_mst_sigma\": 0.01,\n", - " \"gamma_pl_mean\": 0.1, \"gamma_pl_sigma\": 0.01}}\n", + "kwargs_sigma_start = {\n", + " \"kwargs_cosmo\": {\"h0\": 10, \"om\": 0.05, \"w\": 0.2},\n", + " \"kwargs_lens\": {\n", + " \"lambda_mst\": 0.1,\n", + " \"lambda_mst_sigma\": 0.01,\n", + " \"gamma_pl_mean\": 0.1,\n", + " \"gamma_pl_sigma\": 0.01,\n", + " },\n", + "}\n", "\n", "\n", "kwargs_bounds = {\n", " \"kwargs_lower_cosmo\": {\"h0\": 0, \"om\": 0, \"w\": -2},\n", " \"kwargs_upper_cosmo\": {\"h0\": 200, \"om\": 1, \"w\": 0},\n", " \"kwargs_fixed_cosmo\": {\"h0\": kwargs_cosmo_true[\"h0\"]},\n", - " \n", " \"kwargs_lower_lens\": {\"lambda_mst\": 0.8, \"gamma_pl_mean\": 1.5},\n", " \"kwargs_upper_lens\": {\"lambda_mst\": 1.2, \"gamma_pl_mean\": 2.5},\n", - " \"kwargs_fixed_lens\": {\"gamma_pl_sigma\": gamma_pl_sigma, \"lambda_mst_sigma\": lambda_mst_sigma}\n", + " \"kwargs_fixed_lens\": {\n", + " \"gamma_pl_sigma\": gamma_pl_sigma,\n", + " \"lambda_mst_sigma\": lambda_mst_sigma,\n", + " },\n", "}\n", "\n", "\n", @@ -161,7 +182,6 @@ "# joint options for hierArc sampling\n", "\n", "\n", - "\n", "kwargs_model = {\n", " \"lambda_mst_sampling\": True,\n", " \"lambda_mst_distribution\": \"NONE\", # TODO: switch to GAUSSIAN\n", @@ -171,11 +191,12 @@ "}\n", "\n", "\n", - "kwargs_sampler = {\"custom_prior\": None,\n", - " \"interpolate_cosmo\": False,\n", - " \"num_redshift_interp\": 100,\n", - " \"cosmo_fixed\": None,\n", - " }" + "kwargs_sampler = {\n", + " \"custom_prior\": None,\n", + " \"interpolate_cosmo\": False,\n", + " \"num_redshift_interp\": 100,\n", + " \"cosmo_fixed\": None,\n", + "}" ] }, { @@ -193,20 +214,30 @@ } ], "source": [ - "mcmc_sampler = MCMCSampler(kwargs_dspl_list, cosmology=cosmology, \n", - " kwargs_model=kwargs_model, kwargs_bounds=kwargs_bounds,\n", - " **kwargs_sampler)\n", + "mcmc_sampler = MCMCSampler(\n", + " kwargs_dspl_list,\n", + " cosmology=cosmology,\n", + " kwargs_model=kwargs_model,\n", + " kwargs_bounds=kwargs_bounds,\n", + " **kwargs_sampler\n", + ")\n", "\n", "likelihood = mcmc_sampler.chain\n", "param = mcmc_sampler.param\n", "\n", - "kwargs_test = {\"kwargs_cosmo\": {\"h0\": 70, \"om\": 0.3, \"w\": -1},\n", - " \"kwargs_lens\": {\"lambda_mst\": lambda_mst_mean, \"lambda_mst_sigma\": lambda_mst_sigma,\n", - " \"gamma_pl_mean\": gamma_pl_mean+0., \"gamma_pl_sigma\": gamma_pl_sigma}}\n", + "kwargs_test = {\n", + " \"kwargs_cosmo\": {\"h0\": 70, \"om\": 0.3, \"w\": -1},\n", + " \"kwargs_lens\": {\n", + " \"lambda_mst\": lambda_mst_mean,\n", + " \"lambda_mst_sigma\": lambda_mst_sigma,\n", + " \"gamma_pl_mean\": gamma_pl_mean + 0.0,\n", + " \"gamma_pl_sigma\": gamma_pl_sigma,\n", + " },\n", + "}\n", "\n", "args = param.kwargs2args(**kwargs_test)\n", "\n", - "%timeit likelihood.likelihood(args)\n" + "%timeit likelihood.likelihood(args)" ] }, { @@ -262,8 +293,6 @@ } ], "source": [ - "\n", - "\n", "mcmc_samples, log_prob = mcmc_sampler.mcmc_emcee(\n", " n_walkers, n_burn, n_run, kwargs_mean_start, kwargs_sigma_start\n", ")\n", diff --git a/test/test_Sampling/test_ParamManager/test_lens_param.py b/test/test_Sampling/test_ParamManager/test_lens_param.py index db10c7b4..2f0dcf4f 100644 --- a/test/test_Sampling/test_ParamManager/test_lens_param.py +++ b/test/test_Sampling/test_ParamManager/test_lens_param.py @@ -78,7 +78,7 @@ def test_args2kwargs(self): "alpha_lambda": 0.1, "beta_lambda": 0.1, "gamma_pl_list": [2, 2.5], - "gamma_pl_mean": 2., + "gamma_pl_mean": 2.0, "gamma_pl_sigma": 0.1, } args = self._param.kwargs2args(kwargs) From bbaace3f8429c57e27cba41a68e40402eda1e628 Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Wed, 7 Aug 2024 15:05:15 -0400 Subject: [PATCH 52/62] tests updated --- test/test_Likelihood/test_hierarchy_likelihood.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/test_Likelihood/test_hierarchy_likelihood.py b/test/test_Likelihood/test_hierarchy_likelihood.py index d4b5ecda..9c8ac0d2 100644 --- a/test/test_Likelihood/test_hierarchy_likelihood.py +++ b/test/test_Likelihood/test_hierarchy_likelihood.py @@ -196,7 +196,7 @@ def test_lens_log_likelihood(self): kwargs_kin=kwargs_kin, kwargs_los=kwargs_los, ) - assert ln_likelihood_zero == -np.inf + assert np.nan_to_num(ln_likelihood_zero) <= -10 ** 300 ln_likelihood_kappa_ext = self.likelihood_kappa_ext.lens_log_likelihood( self.cosmo, From 8c7d31401f12cb97eb932cba6a7f350c69548351 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Wed, 7 Aug 2024 19:05:32 +0000 Subject: [PATCH 53/62] [pre-commit.ci] auto fixes from pre-commit.com hooks --- test/test_Likelihood/test_hierarchy_likelihood.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/test_Likelihood/test_hierarchy_likelihood.py b/test/test_Likelihood/test_hierarchy_likelihood.py index 9c8ac0d2..5bfc2e00 100644 --- a/test/test_Likelihood/test_hierarchy_likelihood.py +++ b/test/test_Likelihood/test_hierarchy_likelihood.py @@ -196,7 +196,7 @@ def test_lens_log_likelihood(self): kwargs_kin=kwargs_kin, kwargs_los=kwargs_los, ) - assert np.nan_to_num(ln_likelihood_zero) <= -10 ** 300 + assert np.nan_to_num(ln_likelihood_zero) <= -(10**300) ln_likelihood_kappa_ext = self.likelihood_kappa_ext.lens_log_likelihood( self.cosmo, From cbf807f0b4113007069bd5ea9711420d4a289495 Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Wed, 7 Aug 2024 15:49:54 -0400 Subject: [PATCH 54/62] improved testing and slight re-working of interpolated cosmology --- hierarc/Likelihood/cosmo_likelihood.py | 13 ++++++------- test/test_Likelihood/test_cosmo_likelihood.py | 5 ++--- .../test_Distributions/test_lens_distribution.py | 4 ++++ 3 files changed, 12 insertions(+), 10 deletions(-) diff --git a/hierarc/Likelihood/cosmo_likelihood.py b/hierarc/Likelihood/cosmo_likelihood.py index ffe64614..0e0efdc6 100644 --- a/hierarc/Likelihood/cosmo_likelihood.py +++ b/hierarc/Likelihood/cosmo_likelihood.py @@ -124,10 +124,10 @@ def likelihood(self, args, kwargs_cosmo_interp=None): # assert we are not in a crazy cosmological situation that prevents computing the angular distance integral h0, ok, om = kwargs_cosmo["h0"], kwargs_cosmo["ok"], kwargs_cosmo["om"] for lens in self._kwargs_lens_list: - if "z_source" in lens: - z = lens["z_source"] - elif "z_source2" in lens: + if "z_source2" in lens: z = lens["z_source2"] + elif "z_source" in lens: + z = lens["z_source"] else: z = 1100 cut = ok * (1.0 + z) ** 2 + om * (1.0 + z) ** 3 + (1.0 - om - ok) @@ -174,11 +174,10 @@ def cosmo_instance(self, kwargs_cosmo): """ :param kwargs_cosmo: cosmology parameter keyword argument list - :return: astropy.cosmology (or equivalent interpolation scheme class) + :return: ~astropy.cosmology (or equivalent interpolation scheme class) """ - if hasattr(kwargs_cosmo, "ang_diameter_distances") and hasattr( - kwargs_cosmo, "redshifts" - ): + print(kwargs_cosmo, "test kwargs_cosmo") + if "ang_diameter_distances" in kwargs_cosmo and "redshifts" in kwargs_cosmo: # in that case we use directly the interpolation mode to approximate angular diameter distances cosmo = CosmoInterp( ang_dist_list=kwargs_cosmo["ang_diameter_distances"], diff --git a/test/test_Likelihood/test_cosmo_likelihood.py b/test/test_Likelihood/test_cosmo_likelihood.py index 1f3c48bf..a438c580 100644 --- a/test/test_Likelihood/test_cosmo_likelihood.py +++ b/test/test_Likelihood/test_cosmo_likelihood.py @@ -179,12 +179,11 @@ def test_cosmo_instance(self): cosmo_interp.k ) # compute the curvature from the interpolation class (as easily available) kwargs_cosmo_interp = { - "ang_diameter_distances": ang_diameter_distances, + "ang_diameter_distances": ang_diameter_distances.value, "redshifts": redshifts, "ok": Ok0, - "K": K, + "K": K.value, } - cosmo_interp_input = cosmoL.cosmo_instance(kwargs_cosmo_interp) z = 1 diff --git a/test/test_Sampling/test_Distributions/test_lens_distribution.py b/test/test_Sampling/test_Distributions/test_lens_distribution.py index db250ea6..ab2066ce 100644 --- a/test/test_Sampling/test_Distributions/test_lens_distribution.py +++ b/test/test_Sampling/test_Distributions/test_lens_distribution.py @@ -15,6 +15,8 @@ def setup_method(self): "log_m2l_sampling": True, "log_m2l_distribution": "GAUSSIAN", "alpha_lambda_sampling": True, + "gamma_pl_global_sampling": True, + "gamma_pl_global_dist": "GAUSSIAN", "beta_lambda_sampling": True, "alpha_gamma_in_sampling": True, "alpha_log_m2l_sampling": True, @@ -40,6 +42,8 @@ def setup_method(self): "log_m2l": 0.6, "log_m2l_sigma": 1, "alpha_log_m2l": -0.1, + "gamma_pl_mean": 2., + "gamma_pl_sigma": 0.1, } def test_draw_lens(self): From 318e8c7e6ebe0b458d70fa16fd7c1833acca4ac1 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Wed, 7 Aug 2024 19:50:12 +0000 Subject: [PATCH 55/62] [pre-commit.ci] auto fixes from pre-commit.com hooks --- test/test_Sampling/test_Distributions/test_lens_distribution.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/test_Sampling/test_Distributions/test_lens_distribution.py b/test/test_Sampling/test_Distributions/test_lens_distribution.py index ab2066ce..8021db9e 100644 --- a/test/test_Sampling/test_Distributions/test_lens_distribution.py +++ b/test/test_Sampling/test_Distributions/test_lens_distribution.py @@ -42,7 +42,7 @@ def setup_method(self): "log_m2l": 0.6, "log_m2l_sigma": 1, "alpha_log_m2l": -0.1, - "gamma_pl_mean": 2., + "gamma_pl_mean": 2.0, "gamma_pl_sigma": 0.1, } From df999a3b1353fd1652776e819ba30197616a252c Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Wed, 7 Aug 2024 20:23:45 -0400 Subject: [PATCH 56/62] improve testing --- .../LensLikelihood/mag_likelihood.py | 4 +- notebooks/double_source_plane.ipynb | 29 ++++++++- .../test_hierarchy_likelihood.py | 60 +++++++++++++++++++ .../test_lens_distribution.py | 5 +- 4 files changed, 91 insertions(+), 7 deletions(-) diff --git a/hierarc/Likelihood/LensLikelihood/mag_likelihood.py b/hierarc/Likelihood/LensLikelihood/mag_likelihood.py index a755015d..2a6a94e5 100644 --- a/hierarc/Likelihood/LensLikelihood/mag_likelihood.py +++ b/hierarc/Likelihood/LensLikelihood/mag_likelihood.py @@ -19,9 +19,9 @@ def __init__( :param amp_measured: array, amplitudes of measured fluxes of image positions :param cov_amp_measured: 2d array, error covariance matrix of the measured amplitudes, in linear space - for given magnitude zero point + for given magnitude zero point :param magnitude_zero_point: magnitude zero point for which the image amplitudes and covariance matrix are - defined + defined :param magnification_model: mean magnification of the model prediction (array with number of images) :param cov_magnification_model: 2d array (image amplitudes); model lensing magnification covariances """ diff --git a/notebooks/double_source_plane.ipynb b/notebooks/double_source_plane.ipynb index 9ee1b1bd..524bbaa8 100644 --- a/notebooks/double_source_plane.ipynb +++ b/notebooks/double_source_plane.ipynb @@ -243,7 +243,7 @@ { "cell_type": "code", "execution_count": 5, - "id": "7b0f2000", + "id": "b690fbd7", "metadata": {}, "outputs": [], "source": [ @@ -296,17 +296,40 @@ "mcmc_samples, log_prob = mcmc_sampler.mcmc_emcee(\n", " n_walkers, n_burn, n_run, kwargs_mean_start, kwargs_sigma_start\n", ")\n", - "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "067b6673", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ "corner.corner(\n", " mcmc_samples, show_titles=True, labels=mcmc_sampler.param_names(latex_style=True)\n", ")\n", + "plt.savefig(\"dsp_mst_gamma.pdf\", format=\"pdf\", bbox_inches=\"tight\")\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, - "id": "319cc4e8", + "id": "860181a1", "metadata": {}, "outputs": [], "source": [] diff --git a/test/test_Likelihood/test_hierarchy_likelihood.py b/test/test_Likelihood/test_hierarchy_likelihood.py index 5bfc2e00..cb0d702e 100644 --- a/test/test_Likelihood/test_hierarchy_likelihood.py +++ b/test/test_Likelihood/test_hierarchy_likelihood.py @@ -3,6 +3,7 @@ import pytest import numpy as np import numpy.testing as npt +from lenstronomy.Util.data_util import magnitude2cps class TestLensLikelihood(object): @@ -277,6 +278,65 @@ def test_lens_log_likelihood(self): # assert ln_likelihood < -10000000 + def test_lum_dist_likelihood(self): + "Mag" + kwargs_model = {} + z_lens, z_source = 0.2, 0.5 + mu_sne = 10 + z_apparent_m_anchor = 0.2 + kwargs_source = {"mu_sne": mu_sne, "z_apparent_m_anchor": z_apparent_m_anchor} + + cosmo = FlatLambdaCDM(H0=70, Om0=0.3, Ob0=0.05) + angular_diameter_distances = np.maximum( + np.nan_to_num(cosmo.angular_diameter_distance(z_source).value), + 0.00001, + ) + lum_dists = 5 * np.log10( + (1 + z_source) * (1 + z_source) * angular_diameter_distances + ) + + z_anchor = z_apparent_m_anchor + ang_dist_anchor = np.maximum( + np.nan_to_num(cosmo.angular_diameter_distance(z_anchor).value), 0.00001 + ) + lum_dist_anchor = 5 * np.log10( + (1 + z_anchor) * (1 + z_anchor) * ang_dist_anchor + ) + delta_lum_dist = lum_dists - lum_dist_anchor + + mag_source = mu_sne + delta_lum_dist + num = 4 + magnitude_intrinsic = mag_source + magnitude_zero_point = 20 + + amp_int = magnitude2cps( + magnitude=magnitude_intrinsic, magnitude_zero_point=magnitude_zero_point + ) + magnification_model = np.ones(num) + magnification_model_cov = np.diag((magnification_model / 10) ** 2) + + magnitude_measured = magnification_model * amp_int + magnitude_measured_cov = np.diag((magnitude_measured / 10) ** 2) + + kwargs_likelihood = {"amp_measured": magnitude_measured, + "cov_amp_measured": magnitude_measured_cov, + "magnification_model": magnification_model, + "cov_magnification_model": magnification_model_cov, + "magnitude_zero_point": magnitude_zero_point} + + + likelihood = LensLikelihood( + z_lens=z_lens, + z_source=z_source, + name="name", + likelihood_type="Mag", + num_distribution_draws=100, + **kwargs_likelihood, + **kwargs_model + ) + log_l = likelihood.lens_log_likelihood(cosmo=cosmo, kwargs_source=kwargs_source) + npt.assert_almost_equal(log_l, -24, decimal=0) + if __name__ == "__main__": pytest.main() diff --git a/test/test_Sampling/test_Distributions/test_lens_distribution.py b/test/test_Sampling/test_Distributions/test_lens_distribution.py index ab2066ce..4fd4aee2 100644 --- a/test/test_Sampling/test_Distributions/test_lens_distribution.py +++ b/test/test_Sampling/test_Distributions/test_lens_distribution.py @@ -54,9 +54,10 @@ def test_draw_lens(self): kwargs_sampling = copy.deepcopy(self.kwargs_sampling) kwargs_sampling["log_scatter"] = True - kwargs_sampling["lambda_ifu"] = True + kwargs_sampling["mst_ifu"] = True kwargs_sampling["gamma_in_sampling"] = False - lens_dist = LensDistribution(kwargs_sampling) + kwargs_sampling["gamma_pl_global_dist"] = "NONE" + lens_dist = LensDistribution(**kwargs_sampling) for i in range(100): kwargs_return = lens_dist.draw_lens(**self.kwargs_lens) From 40832a89f4815aed997aa343a3c04efcabf1868a Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 8 Aug 2024 00:24:38 +0000 Subject: [PATCH 57/62] [pre-commit.ci] auto fixes from pre-commit.com hooks --- notebooks/double_source_plane.ipynb | 3 +-- test/test_Likelihood/test_hierarchy_likelihood.py | 7 ++++--- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/notebooks/double_source_plane.ipynb b/notebooks/double_source_plane.ipynb index 524bbaa8..10744290 100644 --- a/notebooks/double_source_plane.ipynb +++ b/notebooks/double_source_plane.ipynb @@ -295,8 +295,7 @@ "source": [ "mcmc_samples, log_prob = mcmc_sampler.mcmc_emcee(\n", " n_walkers, n_burn, n_run, kwargs_mean_start, kwargs_sigma_start\n", - ")\n", - "\n" + ")" ] }, { diff --git a/test/test_Likelihood/test_hierarchy_likelihood.py b/test/test_Likelihood/test_hierarchy_likelihood.py index cb0d702e..28e48344 100644 --- a/test/test_Likelihood/test_hierarchy_likelihood.py +++ b/test/test_Likelihood/test_hierarchy_likelihood.py @@ -318,12 +318,13 @@ def test_lum_dist_likelihood(self): magnitude_measured = magnification_model * amp_int magnitude_measured_cov = np.diag((magnitude_measured / 10) ** 2) - kwargs_likelihood = {"amp_measured": magnitude_measured, + kwargs_likelihood = { + "amp_measured": magnitude_measured, "cov_amp_measured": magnitude_measured_cov, "magnification_model": magnification_model, "cov_magnification_model": magnification_model_cov, - "magnitude_zero_point": magnitude_zero_point} - + "magnitude_zero_point": magnitude_zero_point, + } likelihood = LensLikelihood( z_lens=z_lens, From b0c3508ece0a98835aa0ffa0ae3e76b69da13ba6 Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Mon, 12 Aug 2024 21:46:17 -0400 Subject: [PATCH 58/62] verbose feature for better diagnostics for the likelihood --- hierarc/Likelihood/cosmo_likelihood.py | 11 +++++++++-- hierarc/Likelihood/hierarchy_likelihood.py | 9 +++++++-- hierarc/Likelihood/lens_sample_likelihood.py | 4 ++++ test/test_Likelihood/test_cosmo_likelihood.py | 2 +- 4 files changed, 21 insertions(+), 5 deletions(-) diff --git a/hierarc/Likelihood/cosmo_likelihood.py b/hierarc/Likelihood/cosmo_likelihood.py index 0e0efdc6..5cd1fa24 100644 --- a/hierarc/Likelihood/cosmo_likelihood.py +++ b/hierarc/Likelihood/cosmo_likelihood.py @@ -104,17 +104,22 @@ def __init__( z_max = kwargs_lens["z_source2"] self._z_max = z_max - def likelihood(self, args, kwargs_cosmo_interp=None): + def likelihood(self, args, kwargs_cosmo_interp=None, verbose=False): """ :param args: list of sampled parameters :param kwargs_cosmo_interp: interpolated angular diameter distances with 'ang_diameter_distances' and 'redshifts', and optionally 'ok' and 'K' in none-flat scenarios :type kwargs_cosmo_interp: dict + :param verbose: If true, prints intermediate outputs of likelihood calculation + :type verbose: bool :return: log likelihood of the combined lenses """ for i in range(0, len(args)): if args[i] < self._lower_limit[i] or args[i] > self._upper_limit[i]: + if verbose: + print("Parameter %i with value %s out of range [%s, %s]" % (i, args[i], self._lower_limit[i], + self._upper_limit[i])) return -np.inf kwargs_cosmo, kwargs_lens, kwargs_kin, kwargs_source, kwargs_los = ( @@ -135,6 +140,8 @@ def likelihood(self, args, kwargs_cosmo_interp=None): return -np.inf # make sure that Omega_DE is not negative... if 1.0 - om - ok <= 0: + if verbose: + print("curvature unphysical with 1-Om - Ok <= 0") return -np.inf if kwargs_cosmo_interp is not None: kwargs_cosmo = {**kwargs_cosmo, **kwargs_cosmo_interp} @@ -145,6 +152,7 @@ def likelihood(self, args, kwargs_cosmo_interp=None): kwargs_kin=kwargs_kin, kwargs_source=kwargs_source, kwargs_los=kwargs_los, + verbose=verbose, ) if self._sne_evaluate is True: @@ -176,7 +184,6 @@ def cosmo_instance(self, kwargs_cosmo): :param kwargs_cosmo: cosmology parameter keyword argument list :return: ~astropy.cosmology (or equivalent interpolation scheme class) """ - print(kwargs_cosmo, "test kwargs_cosmo") if "ang_diameter_distances" in kwargs_cosmo and "redshifts" in kwargs_cosmo: # in that case we use directly the interpolation mode to approximate angular diameter distances cosmo = CosmoInterp( diff --git a/hierarc/Likelihood/hierarchy_likelihood.py b/hierarc/Likelihood/hierarchy_likelihood.py index c6a4d4b5..cfa29d4d 100644 --- a/hierarc/Likelihood/hierarchy_likelihood.py +++ b/hierarc/Likelihood/hierarchy_likelihood.py @@ -175,16 +175,19 @@ def lens_log_likelihood( kwargs_kin=None, kwargs_source=None, kwargs_los=None, + verbose=False, ): """Log likelihood of the data of a lens given a model (defined with hyper- parameters) and cosmology. :param cosmo: astropy.cosmology instance - :param kwargs_lens: keywords of the hyper parameters of the lens model - :param kwargs_kin: keyword arguments of the kinematic model hyper parameters + :param kwargs_lens: keywords of the hyperparameters of the lens model + :param kwargs_kin: keyword arguments of the kinematic model hyperparameters :param kwargs_source: keyword argument of the source model (such as SNe) :param kwargs_los: list of keyword arguments of global line of sight distributions + :param verbose: If true, prints intermediate outputs of likelihood calculation + :type verbose: bool :return: log likelihood of the data given the model """ @@ -209,6 +212,8 @@ def lens_log_likelihood( kwargs_los=kwargs_los, cosmo=cosmo, ) + if verbose: + print("log likelihood of lens %s = %s" % (self._name, a)) return np.nan_to_num(a) def hyper_param_likelihood( diff --git a/hierarc/Likelihood/lens_sample_likelihood.py b/hierarc/Likelihood/lens_sample_likelihood.py index 61499326..0e366cdb 100644 --- a/hierarc/Likelihood/lens_sample_likelihood.py +++ b/hierarc/Likelihood/lens_sample_likelihood.py @@ -53,6 +53,7 @@ def log_likelihood( kwargs_kin=None, kwargs_source=None, kwargs_los=None, + verbose=False, ): """ @@ -61,6 +62,8 @@ def log_likelihood( :param kwargs_kin: keyword arguments of the kinematic model :param kwargs_source: keyword argument of the source model (such as SNe) :param kwargs_los: line of sight keyword argument list + :param verbose: If true, prints intermediate outputs of likelihood calculation + :type verbose: bool :return: log likelihood of the combined lenses """ log_likelihood = 0 @@ -71,6 +74,7 @@ def log_likelihood( kwargs_kin=kwargs_kin, kwargs_source=kwargs_source, kwargs_los=kwargs_los, + verbose=verbose, ) return log_likelihood diff --git a/test/test_Likelihood/test_cosmo_likelihood.py b/test/test_Likelihood/test_cosmo_likelihood.py index a438c580..937af1d9 100644 --- a/test/test_Likelihood/test_cosmo_likelihood.py +++ b/test/test_Likelihood/test_cosmo_likelihood.py @@ -99,7 +99,7 @@ def custom_prior( kwargs_cosmo = {"h0": self.H0_true, "om": self.omega_m_true, "ok": 0} args = cosmoL.param.kwargs2args(kwargs_cosmo=kwargs_cosmo) - logl = cosmoL.likelihood(args=args) + logl = cosmoL.likelihood(args=args, verbose=True) logl_prior = cosmoL_prior.likelihood(args=args) npt.assert_almost_equal(logl - logl_prior, 1, decimal=8) From 232c5ca24e94bf6c73fcde2872dee8516fddcb3e Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Tue, 13 Aug 2024 01:47:34 +0000 Subject: [PATCH 59/62] [pre-commit.ci] auto fixes from pre-commit.com hooks --- hierarc/Likelihood/cosmo_likelihood.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/hierarc/Likelihood/cosmo_likelihood.py b/hierarc/Likelihood/cosmo_likelihood.py index 5cd1fa24..5435f80f 100644 --- a/hierarc/Likelihood/cosmo_likelihood.py +++ b/hierarc/Likelihood/cosmo_likelihood.py @@ -118,8 +118,10 @@ def likelihood(self, args, kwargs_cosmo_interp=None, verbose=False): for i in range(0, len(args)): if args[i] < self._lower_limit[i] or args[i] > self._upper_limit[i]: if verbose: - print("Parameter %i with value %s out of range [%s, %s]" % (i, args[i], self._lower_limit[i], - self._upper_limit[i])) + print( + "Parameter %i with value %s out of range [%s, %s]" + % (i, args[i], self._lower_limit[i], self._upper_limit[i]) + ) return -np.inf kwargs_cosmo, kwargs_lens, kwargs_kin, kwargs_source, kwargs_los = ( From da203728da200519e0178d15de31f1abd3355750 Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Mon, 12 Aug 2024 22:04:03 -0400 Subject: [PATCH 60/62] testing improved with verbose --- test/test_Likelihood/test_cosmo_likelihood.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/test/test_Likelihood/test_cosmo_likelihood.py b/test/test_Likelihood/test_cosmo_likelihood.py index 937af1d9..0d3de12d 100644 --- a/test/test_Likelihood/test_cosmo_likelihood.py +++ b/test/test_Likelihood/test_cosmo_likelihood.py @@ -100,28 +100,28 @@ def custom_prior( kwargs_cosmo = {"h0": self.H0_true, "om": self.omega_m_true, "ok": 0} args = cosmoL.param.kwargs2args(kwargs_cosmo=kwargs_cosmo) logl = cosmoL.likelihood(args=args, verbose=True) - logl_prior = cosmoL_prior.likelihood(args=args) + logl_prior = cosmoL_prior.likelihood(args=args, verbose=True) npt.assert_almost_equal(logl - logl_prior, 1, decimal=8) kwargs = {"h0": self.H0_true * 0.99, "om": self.omega_m_true, "ok": 0} args = cosmoL.param.kwargs2args(kwargs_cosmo=kwargs) - logl_sigma = cosmoL.likelihood(args=args) + logl_sigma = cosmoL.likelihood(args=args, verbose=True) npt.assert_almost_equal(logl - logl_sigma, 0.5, decimal=2) kwargs = {"h0": 100, "om": 1.0, "ok": 0.1} args = cosmoL.param.kwargs2args(kwargs) - logl = cosmoL.likelihood(args=args) + logl = cosmoL.likelihood(args=args, verbose=True) assert logl == -np.inf kwargs = {"h0": 100, "om": 0.1, "ok": -0.6} args = cosmoL.param.kwargs2args(kwargs) - logl = cosmoL.likelihood(args=args) + logl = cosmoL.likelihood(args=args, verbose=True) assert logl == -np.inf # outside the prior limit kwargs = {"h0": 1000, "om": 0.3, "ok": -0.1} args = cosmoL.param.kwargs2args(kwargs) - logl = cosmoL.likelihood(args=args) + logl = cosmoL.likelihood(args=args, verbose=True) assert logl == -np.inf def test_cosmo_instance(self): @@ -232,7 +232,7 @@ def test_sne_likelihood_integration(self): ) kwargs_cosmo = {"h0": self.H0_true, "om": self.omega_m_true, "ok": 0} args = cosmoL.param.kwargs2args(kwargs_cosmo=kwargs_cosmo) - logl = cosmoL.likelihood(args=args) + logl = cosmoL.likelihood(args=args, verbose=True) assert logl < 0 def test_kde_likelihood_integration(self): @@ -253,7 +253,7 @@ def test_kde_likelihood_integration(self): ) kwargs_cosmo = {"h0": self.H0_true, "om": self.omega_m_true, "ok": 0} args = cosmoL.param.kwargs2args(kwargs_cosmo=kwargs_cosmo) - logl = cosmoL.likelihood(args=args) + logl = cosmoL.likelihood(args=args, verbose=True) assert logl < 0 From 3a5a45befd63d9179dd4dac432e95a68bc8738d5 Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Tue, 13 Aug 2024 14:34:53 -0400 Subject: [PATCH 61/62] added GAUSSIAN_SCALED in parameter handling --- hierarc/Sampling/ParamManager/kin_param.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/hierarc/Sampling/ParamManager/kin_param.py b/hierarc/Sampling/ParamManager/kin_param.py index 155e2a6b..812e0884 100644 --- a/hierarc/Sampling/ParamManager/kin_param.py +++ b/hierarc/Sampling/ParamManager/kin_param.py @@ -17,8 +17,8 @@ def __init__( :param anisotropy_sampling: bool, if True, makes use of this module, else ignores it's functionalities :param anisotropy_model: string, name of anisotropy model to consider - :param distribution_function: string, 'NONE', 'GAUSSIAN', description of the distribution function of the - anisotropy model parameters + :param distribution_function: string, 'NONE', 'GAUSSIAN', 'GAUSSIAN_SCALED', description of the distribution + function of the anisotropy model parameters :param sigma_v_systematics: bool, if True samples parameters relative to systematics in the velocity dispersion measurement :param log_scatter: boolean, if True, samples the Gaussian scatter amplitude in log space (and thus flat prior in log) @@ -99,7 +99,7 @@ def args2kwargs(self, args, i=0): else: kwargs["a_ani"] = args[i] i += 1 - if self._distribution_function in ["GAUSSIAN"]: + if self._distribution_function in ["GAUSSIAN", "GAUSSIAN_SCALED"]: if "a_ani_sigma" in self._kwargs_fixed: kwargs["a_ani_sigma"] = self._kwargs_fixed["a_ani_sigma"] else: @@ -114,7 +114,7 @@ def args2kwargs(self, args, i=0): else: kwargs["beta_inf"] = args[i] i += 1 - if self._distribution_function in ["GAUSSIAN"]: + if self._distribution_function in ["GAUSSIAN", "GAUSSIAN_SCALED"]: if "beta_inf_sigma" in self._kwargs_fixed: kwargs["beta_inf_sigma"] = self._kwargs_fixed["beta_inf_sigma"] else: @@ -145,7 +145,7 @@ def kwargs2args(self, kwargs): if self._anisotropy_model in ["OM", "GOM", "const"]: if "a_ani" not in self._kwargs_fixed: args.append(kwargs["a_ani"]) - if self._distribution_function in ["GAUSSIAN"]: + if self._distribution_function in ["GAUSSIAN", "GAUSSIAN_SCALED"]: if "a_ani_sigma" not in self._kwargs_fixed: if self._log_scatter is True: args.append(np.log10(kwargs["a_ani_sigma"])) @@ -154,7 +154,7 @@ def kwargs2args(self, kwargs): if self._anisotropy_model in ["GOM"]: if "beta_inf" not in self._kwargs_fixed: args.append(kwargs["beta_inf"]) - if self._distribution_function in ["GAUSSIAN"]: + if self._distribution_function in ["GAUSSIAN", "GAUSSIAN_SCALED"]: if "beta_inf_sigma" not in self._kwargs_fixed: if self._log_scatter is True: args.append(np.log10(kwargs["beta_inf_sigma"])) From f482350a17c7915cf9682728b5c48de28f337e42 Mon Sep 17 00:00:00 2001 From: Simon Birrer Date: Tue, 3 Sep 2024 15:42:44 -0400 Subject: [PATCH 62/62] backend ereased before initializing new EMCEE object --- hierarc/Sampling/mcmc_sampling.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/hierarc/Sampling/mcmc_sampling.py b/hierarc/Sampling/mcmc_sampling.py index 95477148..6a360dd6 100644 --- a/hierarc/Sampling/mcmc_sampling.py +++ b/hierarc/Sampling/mcmc_sampling.py @@ -40,9 +40,6 @@ def get_emcee_sampler( """ num_param = self.param.num_param - sampler = emcee.EnsembleSampler( - n_walkers, num_param, self.chain.likelihood, args=(), **kwargs_emcee - ) mean_start = self.param.kwargs2args(**kwargs_mean_start) sigma_start = self.param.kwargs2args(**kwargs_sigma_start) p0 = sampling_util.sample_ball(mean_start, sigma_start, n_walkers) @@ -52,6 +49,9 @@ def get_emcee_sampler( p0 = None else: backend.reset(n_walkers, num_param) + sampler = emcee.EnsembleSampler( + n_walkers, num_param, self.chain.likelihood, args=(), **kwargs_emcee + ) sampler.run_mcmc(p0, n_burn + n_run, progress=True) return sampler