Repository: sibirrer/hierArc (language: python)

Issue:
readthedocs config and coverall badge added



Discussion / hints:

Fix patch:
diff --git a/AUTHORS.rst b/AUTHORS.rst
index 3fd1e29a..e03b80aa 100644
--- a/AUTHORS.rst
+++ b/AUTHORS.rst
@@ -13,4 +13,6 @@ Contributors (alphabetical)
 * Aymeric Galan `aymgal <https://github.com/aymgal/>`_
 * Martin Millon `martin-millon <https://github.com/martin-millon>`_
 * Ji Won Park `jiwoncpark <https://github.com/jiwoncpark/>`_
+* Anowar Shajib `ajshajib <https://github.com/ajshajib>`_
+* William Sheu `williyamshoe <https://github.com/williyamshoe>`_
 * Chin-Yi Tan `chinyitan <https://github.com/chinyitan>`_
diff --git a/hierarc/LensPosterior/kin_constraints_composite.py b/hierarc/LensPosterior/kin_constraints_composite.py
index ff888594..fdc2cf0e 100644
--- a/hierarc/LensPosterior/kin_constraints_composite.py
+++ b/hierarc/LensPosterior/kin_constraints_composite.py
@@ -29,6 +29,8 @@ def __init__(
         kwargs_seeing,
         kwargs_numerics_galkin,
         anisotropy_model,
+        gamma_in_prior_mean=None,
+        gamma_in_prior_std=None,
         sigma_v_error_independent=None,
         sigma_v_error_covariant=None,
         sigma_v_error_cov_matrix=None,
@@ -78,6 +80,8 @@ def __init__(
             line-of-sight velocity dispersion
         :param anisotropy_model: type of stellar anisotropy model. See details in
             MamonLokasAnisotropy() class of lenstronomy.GalKin.anisotropy
+        :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_lens_light: keyword argument list of lens light model (optional)
         :param kwargs_mge_light: keyword arguments that go into the MGE decomposition
             routine
@@ -156,6 +160,9 @@ def __init__(
         self.log_m2l_array = log_m2l_array
         self._is_m2l_population_level = is_m2l_population_level
 
+        self._gamma_in_prior_mean = gamma_in_prior_mean
+        self._gamma_in_prior_std = gamma_in_prior_std
+
         if not is_m2l_population_level and not self._check_arrays(
             self._kappa_s_array, log_m2l_array
         ):
@@ -300,8 +307,6 @@ def j_kin_draw_composite(
             kwargs_lens_stars,
         ]
 
-        print(kwargs_lens)
-
         j_kin = self.velocity_dispersion_map_dimension_less(
             kwargs_lens=kwargs_lens,
             kwargs_lens_light=kwargs_light,
@@ -391,6 +396,8 @@ 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,
         }
 
         if not self._is_m2l_population_level:
diff --git a/hierarc/Likelihood/cosmo_likelihood.py b/hierarc/Likelihood/cosmo_likelihood.py
index 5d788703..5be38d85 100644
--- a/hierarc/Likelihood/cosmo_likelihood.py
+++ b/hierarc/Likelihood/cosmo_likelihood.py
@@ -25,14 +25,14 @@ def __init__(
         anisotropy_sampling=False,
         gamma_in_sampling=False,
         gamma_in_distribution="NONE",
-        m2l_sampling=False,
-        m2l_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,
-        alpha_m2l_sampling=False,
+        alpha_log_m2l_sampling=False,
         lambda_ifu_sampling=False,
         lambda_ifu_distribution="NONE",
         sigma_v_systematics=False,
@@ -81,8 +81,8 @@ def __init__(
         :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 m2l_sampling: bool, if True samples a global mass-to-light ratio parameter
-        :param m2l_distribution: string, distribution function of the m2l 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
@@ -119,10 +119,10 @@ def __init__(
             beta_lambda_sampling=beta_lambda_sampling,
             gamma_in_sampling=gamma_in_sampling,
             gamma_in_distribution=gamma_in_distribution,
-            m2l_sampling=m2l_sampling,
-            m2l_distribution=m2l_distribution,
+            log_m2l_sampling=log_m2l_sampling,
+            log_m2l_distribution=log_m2l_distribution,
             alpha_gamma_in_sampling=alpha_gamma_in_sampling,
-            alpha_m2l_sampling=alpha_m2l_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,
diff --git a/hierarc/Likelihood/hierarchy_likelihood.py b/hierarc/Likelihood/hierarchy_likelihood.py
index 2e87b264..af2127fd 100644
--- a/hierarc/Likelihood/hierarchy_likelihood.py
+++ b/hierarc/Likelihood/hierarchy_likelihood.py
@@ -32,6 +32,8 @@ def __init__(
         lambda_scaling_property_beta=0,
         normalized=True,
         kwargs_lens_properties=None,
+        gamma_in_prior_mean=None,
+        gamma_in_prior_std=None,
         **kwargs_likelihood
     ):
         """
@@ -64,6 +66,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 kwargs_likelihood: keyword arguments specifying the likelihood function,
         see individual classes for their use
         """
@@ -132,6 +136,9 @@ def __init__(
         self._gamma_in_array = gamma_in_array
         self._log_m2l_array = log_m2l_array
 
+        self._gamma_in_prior_mean = gamma_in_prior_mean
+        self._gamma_in_prior_std = gamma_in_prior_std
+
     def lens_log_likelihood(
         self, cosmo, kwargs_lens=None, kwargs_kin=None, kwargs_source=None
     ):
@@ -275,6 +282,20 @@ 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
+        ):
+            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)
+
         return np.nan_to_num(lnlikelihood)
 
     def draw_scaling_params(self, kwargs_lens=None, **kwargs_kin):
diff --git a/hierarc/Sampling/ParamManager/lens_param.py b/hierarc/Sampling/ParamManager/lens_param.py
index 60b94de0..7cda2414 100644
--- a/hierarc/Sampling/ParamManager/lens_param.py
+++ b/hierarc/Sampling/ParamManager/lens_param.py
@@ -12,14 +12,14 @@ def __init__(
         lambda_ifu_distribution="NONE",
         gamma_in_sampling=False,
         gamma_in_distribution="NONE",
-        m2l_sampling=False,
-        m2l_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,
-        alpha_m2l_sampling=False,
+        alpha_log_m2l_sampling=False,
         kwargs_fixed=None,
         log_scatter=False,
     ):
@@ -33,9 +33,9 @@ def __init__(
         :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 m2l_sampling: bool, if True samples the mass to light ratio of
-            the stars
-        :param m2l_distribution: string, distribution function of the mass to
+        :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 kappa_ext_sampling: bool, if True samples a global external convergence
             parameter
@@ -46,7 +46,7 @@ def __init__(
         :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_m2l_sampling: bool, if True samples a parameter alpha_m2l, which scales m2l 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 kwargs_fixed: keyword arguments that are held fixed through the sampling
         """
@@ -56,14 +56,14 @@ def __init__(
         self._lambda_ifu_distribution = lambda_ifu_distribution
         self._gamma_in_sampling = gamma_in_sampling
         self._gamma_in_distribution = gamma_in_distribution
-        self._m2l_sampling = m2l_sampling
-        self._m2l_distribution = m2l_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
-        self._alpha_m2l_sampling = alpha_m2l_sampling
+        self._alpha_log_m2l_sampling = alpha_log_m2l_sampling
 
         self._log_scatter = log_scatter
         if kwargs_fixed is None:
@@ -122,21 +122,21 @@ def param_list(self, latex_style=False):
                             list.append(r"$\sigma(\gamma_{\rm in})$")
                     else:
                         list.append("gamma_in_sigma")
-        if self._m2l_sampling is True:
-            if "m2l" not in self._kwargs_fixed:
+        if self._log_m2l_sampling is True:
+            if "log_m2l" not in self._kwargs_fixed:
                 if latex_style is True:
                     list.append(r"$\Upsilon_{\rm stars}$")
                 else:
-                    list.append("m2l")
-            if self._m2l_distribution == "GAUSSIAN":
-                if "m2l_sigma" not in self._kwargs_fixed:
+                    list.append("log_m2l")
+            if self._log_m2l_distribution == "GAUSSIAN":
+                if "log_m2l_sigma" not in self._kwargs_fixed:
                     if latex_style is True:
                         if self._log_scatter is True:
                             list.append(r"$\log_{10}\sigma(\Upsilon_{\rm stars})$")
                         else:
                             list.append(r"$\sigma(\Upsilon_{\rm stars})$")
                     else:
-                        list.append("m2l_sigma")
+                        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:
@@ -167,12 +167,12 @@ def param_list(self, latex_style=False):
                     list.append(r"$\alpha_{\gamma_{\rm in}}$")
                 else:
                     list.append("alpha_gamma_in")
-        if self._alpha_m2l_sampling is True:
-            if "alpha_m2l" not in self._kwargs_fixed:
+        if self._alpha_log_m2l_sampling is True:
+            if "alpha_log_m2l" not in self._kwargs_fixed:
                 if latex_style is True:
                     list.append(r"$\alpha_{\Upsilon_{\rm stars}}$")
                 else:
-                    list.append("alpha_m2l")
+                    list.append("alpha_log_m2l")
         return list
 
     def args2kwargs(self, args, i=0):
@@ -227,20 +227,20 @@ def args2kwargs(self, args, i=0):
                     else:
                         kwargs["gamma_in_sigma"] = args[i]
                     i += 1
-        if self._m2l_sampling is True:
-            if "m2l" in self._kwargs_fixed:
-                kwargs["m2l"] = self._kwargs_fixed["m2l"]
+        if self._log_m2l_sampling is True:
+            if "log_m2l" in self._kwargs_fixed:
+                kwargs["log_m2l"] = self._kwargs_fixed["log_m2l"]
             else:
-                kwargs["m2l"] = args[i]
+                kwargs["log_m2l"] = args[i]
                 i += 1
-            if self._m2l_distribution == "GAUSSIAN":
-                if "m2l_sigma" in self._kwargs_fixed:
-                    kwargs["m2l_sigma"] = self._kwargs_fixed["m2l_sigma"]
+            if self._log_m2l_distribution == "GAUSSIAN":
+                if "log_m2l_sigma" in self._kwargs_fixed:
+                    kwargs["log_m2l_sigma"] = self._kwargs_fixed["log_m2l_sigma"]
                 else:
                     if self._log_scatter is True:
-                        kwargs["m2l_sigma"] = 10 ** (args[i])
+                        kwargs["log_m2l_sigma"] = 10 ** (args[i])
                     else:
-                        kwargs["m2l_sigma"] = args[i]
+                        kwargs["log_m2l_sigma"] = args[i]
                     i += 1
         if self._kappa_ext_sampling is True:
             if "kappa_ext" in self._kwargs_fixed:
@@ -272,11 +272,11 @@ def args2kwargs(self, args, i=0):
             else:
                 kwargs["alpha_gamma_in"] = args[i]
                 i += 1
-        if self._alpha_m2l_sampling is True:
-            if "alpha_m2l" in self._kwargs_fixed:
-                kwargs["alpha_m2l"] = self._kwargs_fixed["alpha_m2l"]
+        if self._alpha_log_m2l_sampling is True:
+            if "alpha_log_m2l" in self._kwargs_fixed:
+                kwargs["alpha_log_m2l"] = self._kwargs_fixed["alpha_log_m2l"]
             else:
-                kwargs["alpha_m2l"] = args[i]
+                kwargs["alpha_log_m2l"] = args[i]
                 i += 1
 
         return kwargs, i
@@ -315,15 +315,15 @@ def kwargs2args(self, kwargs):
                         args.append(np.log10(kwargs["gamma_in_sigma"]))
                     else:
                         args.append(kwargs["gamma_in_sigma"])
-        if self._m2l_sampling is True:
-            if "m2l" not in self._kwargs_fixed:
-                args.append(kwargs["m2l"])
-            if self._m2l_distribution == "GAUSSIAN":
-                if "m2l_sigma" not in self._kwargs_fixed:
+        if self._log_m2l_sampling is True:
+            if "log_m2l" not in self._kwargs_fixed:
+                args.append(kwargs["log_m2l"])
+            if self._log_m2l_distribution == "GAUSSIAN":
+                if "log_m2l_sigma" not in self._kwargs_fixed:
                     if self._log_scatter is True:
-                        args.append(np.log10(kwargs["m2l_sigma"]))
+                        args.append(np.log10(kwargs["log_m2l_sigma"]))
                     else:
-                        args.append(kwargs["m2l_sigma"])
+                        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"])
@@ -339,7 +339,7 @@ def kwargs2args(self, kwargs):
         if self._alpha_gamma_in_sampling is True:
             if "alpha_gamma_in" not in self._kwargs_fixed:
                 args.append(kwargs["alpha_gamma_in"])
-        if self._alpha_m2l_sampling is True:
-            if "alpha_m2l" not in self._kwargs_fixed:
-                args.append(kwargs["alpha_m2l"])
+        if self._alpha_log_m2l_sampling is True:
+            if "alpha_log_m2l" not in self._kwargs_fixed:
+                args.append(kwargs["alpha_log_m2l"])
         return args
diff --git a/hierarc/Sampling/ParamManager/param_manager.py b/hierarc/Sampling/ParamManager/param_manager.py
index 9a4f3bd4..aa56ec6b 100644
--- a/hierarc/Sampling/ParamManager/param_manager.py
+++ b/hierarc/Sampling/ParamManager/param_manager.py
@@ -18,8 +18,8 @@ def __init__(
         anisotropy_distribution="NONE",
         gamma_in_sampling=False,
         gamma_in_distribution="NONE",
-        m2l_sampling=False,
-        m2l_distribution="NONE",
+        log_m2l_sampling=False,
+        log_m2l_distribution="NONE",
         kappa_ext_sampling=False,
         kappa_ext_distribution="NONE",
         lambda_ifu_sampling=False,
@@ -27,7 +27,7 @@ def __init__(
         alpha_lambda_sampling=False,
         beta_lambda_sampling=False,
         alpha_gamma_in_sampling=False,
-        alpha_m2l_sampling=False,
+        alpha_log_m2l_sampling=False,
         sigma_v_systematics=False,
         sne_apparent_m_sampling=False,
         sne_distribution="GAUSSIAN",
@@ -64,11 +64,11 @@ def __init__(
         :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
-        :param m2l_sampling: bool, if True samples the mass-to-light ratio of the stars
-        :param m2l_distribution: string, distribution function of the m2l parameter
+        :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 log_m2l parameter
         :param alpha_gamma_in_sampling: bool, if True samples a parameter alpha_gamma_in, which scales gamma_in linearly
             according to a predefined quantity of the lens
-        :param alpha_m2l_sampling: bool, if True samples a parameter alpha_m2l, which scales m2l linearly
+        :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 sne_apparent_m_sampling: boolean, if True, samples/queries SNe unlensed magnitude distribution
          (not intrinsic magnitudes but apparent!)
@@ -99,14 +99,14 @@ def __init__(
             lambda_ifu_distribution=lambda_ifu_distribution,
             gamma_in_sampling=gamma_in_sampling,
             gamma_in_distribution=gamma_in_distribution,
-            m2l_sampling=m2l_sampling,
-            m2l_distribution=m2l_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,
-            alpha_m2l_sampling=alpha_m2l_sampling,
+            alpha_log_m2l_sampling=alpha_log_m2l_sampling,
             log_scatter=log_scatter,
             kwargs_fixed=kwargs_fixed_lens,
         )


Test patch:
diff --git a/test/test_LensPosterior/test_kin_constraints_composite.py b/test/test_LensPosterior/test_kin_constraints_composite.py
index a9d40c05..0ff86961 100644
--- a/test/test_LensPosterior/test_kin_constraints_composite.py
+++ b/test/test_LensPosterior/test_kin_constraints_composite.py
@@ -249,6 +249,8 @@ def test_likelihoodconfiguration_gom(self):
             anisotropy_model=anisotropy_model,
             kwargs_lens_light=kwargs_lens_light,
             lens_light_model_list=lens_light_model_list,
+            gamma_in_prior_mean=2,
+            gamma_in_prior_std=0.5,
             **kwargs_kin_api_settings
         )
 
@@ -349,6 +351,8 @@ def test_likelihoodconfiguration_om(self):
             kwargs_lens_light=kwargs_lens_light,
             lens_light_model_list=lens_light_model_list,
             is_m2l_population_level=False,
+            gamma_in_prior_mean=2,
+            gamma_in_prior_std=0.5,
             **kwargs_kin_api_settings
         )
 
diff --git a/test/test_Sampling/test_ParamManager/test_lens_param.py b/test/test_Sampling/test_ParamManager/test_lens_param.py
index 62c4eba6..dd4b96c8 100644
--- a/test/test_Sampling/test_ParamManager/test_lens_param.py
+++ b/test/test_Sampling/test_ParamManager/test_lens_param.py
@@ -98,10 +98,10 @@ def setup_method(self):
         self._param = LensParam(
             gamma_in_sampling=True,
             gamma_in_distribution="GAUSSIAN",
-            m2l_sampling=True,
-            m2l_distribution="GAUSSIAN",
+            log_m2l_sampling=True,
+            log_m2l_distribution="GAUSSIAN",
             alpha_gamma_in_sampling=True,
-            alpha_m2l_sampling=True,
+            alpha_log_m2l_sampling=True,
             kwargs_fixed={},
             log_scatter=False,
         )
@@ -109,28 +109,28 @@ def setup_method(self):
         kwargs_fixed = {
             "gamma_in": 1,
             "gamma_in_sigma": 0.1,
-            "m2l": 5,
-            "m2l_sigma": 1,
+            "log_m2l": 5,
+            "log_m2l_sigma": 1,
             "alpha_gamma_in": 0.1,
-            "alpha_m2l": -0.5,
+            "alpha_log_m2l": -0.5,
         }
         self._param_fixed = LensParam(
             gamma_in_sampling=True,
             gamma_in_distribution="GAUSSIAN",
-            m2l_sampling=True,
-            m2l_distribution="GAUSSIAN",
+            log_m2l_sampling=True,
+            log_m2l_distribution="GAUSSIAN",
             alpha_gamma_in_sampling=True,
-            alpha_m2l_sampling=True,
+            alpha_log_m2l_sampling=True,
             kwargs_fixed=kwargs_fixed,
             log_scatter=False,
         )
         self._param_log_scatter = LensParam(
             gamma_in_sampling=True,
             gamma_in_distribution="GAUSSIAN",
-            m2l_sampling=True,
-            m2l_distribution="GAUSSIAN",
+            log_m2l_sampling=True,
+            log_m2l_distribution="GAUSSIAN",
             alpha_gamma_in_sampling=True,
-            alpha_m2l_sampling=True,
+            alpha_log_m2l_sampling=True,
             kwargs_fixed={},
             log_scatter=True,
         )
@@ -155,10 +155,10 @@ def test_args2kwargs(self):
         kwargs = {
             "gamma_in": 1,
             "gamma_in_sigma": 0.1,
-            "m2l": 5,
-            "m2l_sigma": 1,
+            "log_m2l": 5,
+            "log_m2l_sigma": 1,
             "alpha_gamma_in": 0.1,
-            "alpha_m2l": -0.5,
+            "alpha_log_m2l": -0.5,
         }
         args = self._param.kwargs2args(kwargs)
         kwargs_new, i = self._param.args2kwargs(args, i=0)