7062600209

Committed 01 Dec 2023 04:29PM UTC coverage: 31.836% (-21.6%) from 53.447%

Build # 7062600209

Build Type

Pull #120

github

Committed by

web-flow

Commit Message

Merge f437df580 into 24e5f6a9b

Pull Request Pull Request #120: Moving to meson

Run Details

14323 of 71092 branches covered (0.0%)

Branch coverage included in aggregate %.

1956 of 3488 new or added lines in 312 files covered. (56.08%)

3939 existing lines in 210 files now uncovered.

57513 of 154555 relevant lines covered (37.21%)

2590091.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

58.09

/numcosmo/lss/nc_cluster_mass_lnnormal.c

/***************************************************************************
 *            nc_cluster_mass_lnnormal.c
 *
 *  Fri June 22 17:48:55 2012
 *  Copyright  2012  Mariana Penna Lima
 *  <pennalima@gmail.com>
 ****************************************************************************/
/*
 * numcosmo
 * Copyright (C) Mariana Penna Lima 2012 <pennalima@gmail.com>
 *
 * numcosmo is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * numcosmo is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * SECTION:nc_cluster_mass_lnnormal
 * @title: NcClusterMassLnnormal
 * @short_description: Cluster mass ln-normal distribution.
 *
 * FIXME
 */

#ifdef HAVE_CONFIG_H
#  include "config.h"
#endif /* HAVE_CONFIG_H */
#include "build_cfg.h"

#include "lss/nc_cluster_mass_lnnormal.h"
#include "math/ncm_cfg.h"

#ifndef NUMCOSMO_GIR_SCAN
#include <gsl/gsl_randist.h>
#endif /* NUMCOSMO_GIR_SCAN */

G_DEFINE_TYPE (NcClusterMassLnnormal, nc_cluster_mass_lnnormal, NC_TYPE_CLUSTER_MASS)

#define VECTOR (NCM_MODEL (mlnn)->params)
#define BIAS   (ncm_vector_get (VECTOR, NC_CLUSTER_MASS_LNNORMAL_BIAS))
#define SIGMA  (ncm_vector_get (VECTOR, NC_CLUSTER_MASS_LNNORMAL_SIGMA))

enum
{
  PROP_0,
  PROP_LNMOBS_MIN,
  PROP_LNMOBS_MAX,
  PROP_SIZE,
};

static void
nc_cluster_mass_lnnormal_init (NcClusterMassLnnormal *mlnm)
{
  mlnm->lnMobs_min = GSL_NEGINF;
  mlnm->lnMobs_max = GSL_POSINF;
}

static void
_nc_cluster_mass_lnnormal_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
{
  NcClusterMassLnnormal *mlnm = NC_CLUSTER_MASS_LNNORMAL (object);

  g_return_if_fail (NC_IS_CLUSTER_MASS_LNNORMAL (object));

  switch (prop_id)
  {
    case PROP_LNMOBS_MIN:
      mlnm->lnMobs_min = g_value_get_double (value);
      g_assert (mlnm->lnMobs_min < mlnm->lnMobs_max);
      break;
    case PROP_LNMOBS_MAX:
      mlnm->lnMobs_max = g_value_get_double (value);
      g_assert (mlnm->lnMobs_min < mlnm->lnMobs_max);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static void
_nc_cluster_mass_lnnormal_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
  NcClusterMassLnnormal *mlnm = NC_CLUSTER_MASS_LNNORMAL (object);

  g_return_if_fail (NC_IS_CLUSTER_MASS_LNNORMAL (object));

  switch (prop_id)
  {
    case PROP_LNMOBS_MIN:
      g_value_set_double (value, mlnm->lnMobs_min);
      break;
    case PROP_LNMOBS_MAX:
      g_value_set_double (value, mlnm->lnMobs_max);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static void
_nc_cluster_mass_lnnormal_finalize (GObject *object)
{
  /* Chain up : end */
  G_OBJECT_CLASS (nc_cluster_mass_lnnormal_parent_class)->finalize (object);
}

static gdouble _nc_cluster_mass_lnnormal_p (NcClusterMass *clusterm,  NcHICosmo *cosmo, gdouble lnM, gdouble z, const gdouble *lnM_obs, const gdouble *lnM_obs_params);
static gdouble _nc_cluster_mass_lnnormal_intp (NcClusterMass *clusterm,  NcHICosmo *cosmo, gdouble lnM, gdouble z);
static gdouble _nc_cluster_mass_lnnormal_intp_bin (NcClusterMass *clusterm, NcHICosmo *cosmo, gdouble lnM, gdouble z, const gdouble *lnM_obs_lower, const gdouble *lnM_obs_upper, const gdouble *lnM_obs_params);
static gboolean _nc_cluster_mass_lnnormal_resample (NcClusterMass *clusterm,  NcHICosmo *cosmo, gdouble lnM, gdouble z, gdouble *lnM_obs, const gdouble *lnM_obs_params, NcmRNG *rng);
static void _nc_cluster_mass_lnnormal_p_limits (NcClusterMass *clusterm,  NcHICosmo *cosmo, const gdouble *lnM_obs, const gdouble *lnM_obs_params, gdouble *lnM_lower, gdouble *lnM_upper);
static void _nc_cluster_mass_lnnormal_p_limits_bin (NcClusterMass *clusterm,  NcHICosmo *cosmo, const gdouble *lnM_obs_lower, const gdouble *lnM_obs_upper, const gdouble *lnM_obs_params, gdouble *lnM_lower, gdouble *lnM_upper);
static void _nc_cluster_mass_lnnormal_n_limits (NcClusterMass *clusterm,  NcHICosmo *cosmo, gdouble *lnM_lower, gdouble *lnM_upper);

static void
nc_cluster_mass_lnnormal_class_init (NcClusterMassLnnormalClass *klass)
{
  GObjectClass *object_class       = G_OBJECT_CLASS (klass);
  NcClusterMassClass *parent_class = NC_CLUSTER_MASS_CLASS (klass);
  NcmModelClass *model_class       = NCM_MODEL_CLASS (klass);

  object_class->finalize = &_nc_cluster_mass_lnnormal_finalize;

  model_class->set_property = &_nc_cluster_mass_lnnormal_set_property;
  model_class->get_property = &_nc_cluster_mass_lnnormal_get_property;

  ncm_model_class_set_name_nick (model_class, "Ln-normal distribution", "Ln_Normal");
  ncm_model_class_add_params (model_class, 2, 0, PROP_SIZE);

  /**
   * NcClusterMassLnnormal:lnMobs_min:
   *
   * FIXME Set correct values (limits)
   */
  g_object_class_install_property (object_class,
                                   PROP_LNMOBS_MIN,
                                   g_param_spec_double ("lnMobs-min",
                                                        NULL,
                                                        "Minimum LnMobs",
                                                        11.0 * M_LN10, G_MAXDOUBLE, log (5.0) + 13.0 * M_LN10,
                                                        G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB));

  /**
   * NcClusterMassLnnormal:lnMobs_max:
   *
   * FIXME Set correct values (limits)
   */
  g_object_class_install_property (object_class,
                                   PROP_LNMOBS_MAX,
                                   g_param_spec_double ("lnMobs-max",
                                                        NULL,
                                                        "Maximum LnMobs",
                                                        11.0 * M_LN10, G_MAXDOUBLE, 16.0 * M_LN10,
                                                        G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB));

  /**
   * NcClusterMassLnnormal:bias:
   *
   * Distribution's bias.
   * FIXME Set correct values (limits)
   */
  ncm_model_class_set_sparam (model_class, NC_CLUSTER_MASS_LNNORMAL_BIAS, "bias", "bias",
                              0.0,  10.0, 1.0e-2,
                              NC_CLUSTER_MASS_LNNORMAL_DEFAULT_PARAMS_ABSTOL, NC_CLUSTER_MASS_LNNORMAL_DEFAULT_BIAS,
                              NCM_PARAM_TYPE_FIXED);

  /**
   * NcClusterMassLnnormal:sigma:
   *
   * Distribution's standard deviation, $\sigma \in [10^{-4}, 10]$.
   *
   */
  ncm_model_class_set_sparam (model_class, NC_CLUSTER_MASS_LNNORMAL_SIGMA, "sigma", "sigma",
                              1.0e-4,  10.0, 1.0e-2,
                              NC_CLUSTER_MASS_LNNORMAL_DEFAULT_PARAMS_ABSTOL, NC_CLUSTER_MASS_LNNORMAL_DEFAULT_SIGMA,
                              NCM_PARAM_TYPE_FIXED);

  /* Check for errors in parameters initialization */
  ncm_model_class_check_params_info (model_class);

  parent_class->P               = &_nc_cluster_mass_lnnormal_p;
  parent_class->intP            = &_nc_cluster_mass_lnnormal_intp;
  parent_class->intP_bin        = &_nc_cluster_mass_lnnormal_intp_bin;
  parent_class->resample        = &_nc_cluster_mass_lnnormal_resample;
  parent_class->P_limits        = &_nc_cluster_mass_lnnormal_p_limits;
  parent_class->P_bin_limits    = &_nc_cluster_mass_lnnormal_p_limits_bin;
  parent_class->N_limits        = &_nc_cluster_mass_lnnormal_n_limits;
  parent_class->_obs_len        = 1;
  parent_class->_obs_params_len = 0;

  ncm_model_class_add_impl_flag (model_class, NC_CLUSTER_MASS_IMPL_ALL);
}

static gdouble
_nc_cluster_mass_lnnormal_p (NcClusterMass *clusterm,  NcHICosmo *cosmo, gdouble lnM, gdouble z, const gdouble *lnM_obs, const gdouble *lnM_obs_params)
{
  NcClusterMassLnnormal *mlnn = NC_CLUSTER_MASS_LNNORMAL (clusterm);
  const gdouble lnMobs        = lnM_obs[0];
  const gdouble sqrt2_sigma   = M_SQRT2 * SIGMA;
  const gdouble x             = (lnMobs - lnM - BIAS) / sqrt2_sigma;

  NCM_UNUSED (cosmo);
  NCM_UNUSED (z);

  return M_2_SQRTPI / (2.0 * M_SQRT2) * exp (-x * x) / (SIGMA);
}

static gdouble
_nc_cluster_mass_lnnormal_intp (NcClusterMass *clusterm,  NcHICosmo *cosmo, gdouble lnM, gdouble z)
{
  NcClusterMassLnnormal *mlnn = NC_CLUSTER_MASS_LNNORMAL (clusterm);
  const gdouble sqrt2_sigma   = M_SQRT2 * SIGMA;
  const gdouble x_min         = (lnM - mlnn->lnMobs_min) / sqrt2_sigma;
  const gdouble x_max         = (lnM - mlnn->lnMobs_max) / sqrt2_sigma;

  NCM_UNUSED (cosmo);
  NCM_UNUSED (z);

  if (x_max > 4.0)
    return -(erfc (x_min) - erfc (x_max)) / 2.0;
  else
    return (erf (x_min) - erf (x_max)) / 2.0;
}

static gdouble
_nc_cluster_mass_lnnormal_intp_bin (NcClusterMass *clusterm, NcHICosmo *cosmo, gdouble lnM, gdouble z, const gdouble *lnM_obs_lower, const gdouble *lnM_obs_upper, const gdouble *lnM_obs_params)
{
  NcClusterMassLnnormal *mlnn = NC_CLUSTER_MASS_LNNORMAL (clusterm);
  const gdouble sqrt2_sigma   = M_SQRT2 * SIGMA;
  const gdouble x_min         = (lnM - lnM_obs_lower[0]) / sqrt2_sigma;
  const gdouble x_max         = (lnM - lnM_obs_upper[0]) / sqrt2_sigma;

  NCM_UNUSED (cosmo);
  NCM_UNUSED (z);

  if (x_max > 4.0)
    return -(erfc (x_min) - erfc (x_max)) / 2.0;
  else
    return (erf (x_min) - erf (x_max)) / 2.0;
}

static gboolean
_nc_cluster_mass_lnnormal_resample (NcClusterMass *clusterm,  NcHICosmo *cosmo, gdouble lnM, gdouble z, gdouble *lnM_obs, const gdouble *lnM_obs_params, NcmRNG *rng)
{
  NcClusterMassLnnormal *mlnn = NC_CLUSTER_MASS_LNNORMAL (clusterm);

  NCM_UNUSED (cosmo);
  NCM_UNUSED (z);

  ncm_rng_lock (rng);
  lnM_obs[0] = lnM + BIAS + gsl_ran_gaussian (rng->r, SIGMA);
  ncm_rng_unlock (rng);

  return (lnM_obs[0] <= mlnn->lnMobs_max) && (lnM_obs[0] >= mlnn->lnMobs_min);
}

static void
_nc_cluster_mass_lnnormal_p_limits (NcClusterMass *clusterm,  NcHICosmo *cosmo, const gdouble *lnM_obs, const gdouble *lnM_obs_params, gdouble *lnM_lower, gdouble *lnM_upper)
{
  NcClusterMassLnnormal *mlnn = NC_CLUSTER_MASS_LNNORMAL (clusterm);
  const gdouble mean          = lnM_obs[0] - BIAS;
  const gdouble lnMl          = mean - 7.0 * SIGMA;
  const gdouble lnMu          = mean + 7.0 * SIGMA;

  NCM_UNUSED (cosmo);

  *lnM_lower = lnMl;
  *lnM_upper = lnMu;

  return;
}

static void
_nc_cluster_mass_lnnormal_p_limits_bin (NcClusterMass *clusterm, NcHICosmo *cosmo, const gdouble *lnM_obs_lower, const gdouble *lnM_obs_upper, const gdouble *lnM_obs_params, gdouble *lnM_lower, gdouble *lnM_upper)
{
  NcClusterMassLnnormal *mlnn = NC_CLUSTER_MASS_LNNORMAL (clusterm);
  const gdouble lnMl          = lnM_obs_lower[0] - 7.0 * SIGMA;
  const gdouble lnMu          = lnM_obs_upper[0] + 7.0 * SIGMA;

  NCM_UNUSED (cosmo);

  *lnM_lower = lnMl;
  *lnM_upper = lnMu;
}

static void
_nc_cluster_mass_lnnormal_n_limits (NcClusterMass *clusterm,  NcHICosmo *cosmo, gdouble *lnM_lower, gdouble *lnM_upper)
{
  NcClusterMassLnnormal *mlnn = NC_CLUSTER_MASS_LNNORMAL (clusterm);
  const gdouble lnMl          = mlnn->lnMobs_min - 7.0 * SIGMA;
  const gdouble lnMu          = mlnn->lnMobs_max + 7.0 * SIGMA;

  NCM_UNUSED (cosmo);

  *lnM_lower = lnMl;
  *lnM_upper = lnMu;

  return;
}


1	/***************************************************************************
2	* nc_cluster_mass_lnnormal.c
3	*
4	* Fri June 22 17:48:55 2012
5	* Copyright 2012 Mariana Penna Lima
6	* <pennalima@gmail.com>
7	****************************************************************************/
8	/*
9	* numcosmo
10	* Copyright (C) Mariana Penna Lima 2012 <pennalima@gmail.com>
11	*
12	* numcosmo is free software: you can redistribute it and/or modify it
13	* under the terms of the GNU General Public License as published by the
14	* Free Software Foundation, either version 3 of the License, or
15	* (at your option) any later version.
16	*
17	* numcosmo is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
20	* See the GNU General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License along
23	* with this program. If not, see <http://www.gnu.org/licenses/>.
24	*/
25
26	/**
27	* SECTION:nc_cluster_mass_lnnormal
28	* @title: NcClusterMassLnnormal
29	* @short_description: Cluster mass ln-normal distribution.
30	*
31	* FIXME
32	*/
33
34	#ifdef HAVE_CONFIG_H
35	# include "config.h"
36	#endif /* HAVE_CONFIG_H */
37	#include "build_cfg.h"
38
39	#include "lss/nc_cluster_mass_lnnormal.h"
40	#include "math/ncm_cfg.h"
41
42	#ifndef NUMCOSMO_GIR_SCAN
43	#include <gsl/gsl_randist.h>
44	#endif /* NUMCOSMO_GIR_SCAN */
45
46	G_DEFINE_TYPE (NcClusterMassLnnormal, nc_cluster_mass_lnnormal, NC_TYPE_CLUSTER_MASS)	360!
47
48	#define VECTOR (NCM_MODEL (mlnn)->params)
49	#define BIAS (ncm_vector_get (VECTOR, NC_CLUSTER_MASS_LNNORMAL_BIAS))
50	#define SIGMA (ncm_vector_get (VECTOR, NC_CLUSTER_MASS_LNNORMAL_SIGMA))
51
52	enum
53	{
54	PROP_0,
55	PROP_LNMOBS_MIN,
56	PROP_LNMOBS_MAX,
57	PROP_SIZE,
58	};
59
60	static void
61	nc_cluster_mass_lnnormal_init (NcClusterMassLnnormal *mlnm)	11✔
62	{
63	mlnm->lnMobs_min = GSL_NEGINF;	11✔
64	mlnm->lnMobs_max = GSL_POSINF;	11✔
65	}	11✔
66
67	static void
68	_nc_cluster_mass_lnnormal_set_property (GObject object, guint prop_id, const GValue value, GParamSpec *pspec)	22✔
69	{
70	NcClusterMassLnnormal *mlnm = NC_CLUSTER_MASS_LNNORMAL (object);	22✔
71
72	g_return_if_fail (NC_IS_CLUSTER_MASS_LNNORMAL (object));	22✔
73
74	switch (prop_id)	22!
75	{
76	case PROP_LNMOBS_MIN:	11✔
77	mlnm->lnMobs_min = g_value_get_double (value);	11✔
78	g_assert (mlnm->lnMobs_min < mlnm->lnMobs_max);	11✔
79	break;
80	case PROP_LNMOBS_MAX:	11✔
81	mlnm->lnMobs_max = g_value_get_double (value);	11✔
82	g_assert (mlnm->lnMobs_min < mlnm->lnMobs_max);	11✔
83	break;
84	default:	×
85	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
86	break;	×
87	}
88	}
89
90	static void
91	_nc_cluster_mass_lnnormal_get_property (GObject object, guint prop_id, GValue value, GParamSpec *pspec)	4✔
92	{
93	NcClusterMassLnnormal *mlnm = NC_CLUSTER_MASS_LNNORMAL (object);	4✔
94
95	g_return_if_fail (NC_IS_CLUSTER_MASS_LNNORMAL (object));	4✔
96
97	switch (prop_id)	4!
98	{
99	case PROP_LNMOBS_MIN:	2✔
100	g_value_set_double (value, mlnm->lnMobs_min);	2✔
101	break;	2✔
102	case PROP_LNMOBS_MAX:	2✔
103	g_value_set_double (value, mlnm->lnMobs_max);	2✔
104	break;	2✔
105	default:	×
106	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
107	break;	×
108	}
109	}
110
111	static void
112	_nc_cluster_mass_lnnormal_finalize (GObject *object)	11✔
113	{
114	/* Chain up : end */
115	G_OBJECT_CLASS (nc_cluster_mass_lnnormal_parent_class)->finalize (object);	11✔
116	}	11✔
117
118	static gdouble _nc_cluster_mass_lnnormal_p (NcClusterMass clusterm, NcHICosmo cosmo, gdouble lnM, gdouble z, const gdouble lnM_obs, const gdouble lnM_obs_params);
119	static gdouble _nc_cluster_mass_lnnormal_intp (NcClusterMass clusterm, NcHICosmo cosmo, gdouble lnM, gdouble z);
120	static gdouble _nc_cluster_mass_lnnormal_intp_bin (NcClusterMass clusterm, NcHICosmo cosmo, gdouble lnM, gdouble z, const gdouble lnM_obs_lower, const gdouble lnM_obs_upper, const gdouble *lnM_obs_params);
121	static gboolean _nc_cluster_mass_lnnormal_resample (NcClusterMass clusterm, NcHICosmo cosmo, gdouble lnM, gdouble z, gdouble lnM_obs, const gdouble lnM_obs_params, NcmRNG *rng);
122	static void _nc_cluster_mass_lnnormal_p_limits (NcClusterMass clusterm, NcHICosmo cosmo, const gdouble lnM_obs, const gdouble lnM_obs_params, gdouble lnM_lower, gdouble lnM_upper);
123	static void _nc_cluster_mass_lnnormal_p_limits_bin (NcClusterMass clusterm, NcHICosmo cosmo, const gdouble lnM_obs_lower, const gdouble lnM_obs_upper, const gdouble lnM_obs_params, gdouble lnM_lower, gdouble *lnM_upper);
124	static void _nc_cluster_mass_lnnormal_n_limits (NcClusterMass clusterm, NcHICosmo cosmo, gdouble lnM_lower, gdouble lnM_upper);
125
126	static void
127	nc_cluster_mass_lnnormal_class_init (NcClusterMassLnnormalClass *klass)	111✔
128	{
129	GObjectClass *object_class = G_OBJECT_CLASS (klass);	111✔
130	NcClusterMassClass *parent_class = NC_CLUSTER_MASS_CLASS (klass);	111✔
131	NcmModelClass *model_class = NCM_MODEL_CLASS (klass);	111✔
132
133	object_class->finalize = &_nc_cluster_mass_lnnormal_finalize;	111✔
134
135	model_class->set_property = &_nc_cluster_mass_lnnormal_set_property;	111✔
136	model_class->get_property = &_nc_cluster_mass_lnnormal_get_property;	111✔
137
138	ncm_model_class_set_name_nick (model_class, "Ln-normal distribution", "Ln_Normal");	111✔
139	ncm_model_class_add_params (model_class, 2, 0, PROP_SIZE);	111✔
140
141	/**
142	* NcClusterMassLnnormal:lnMobs_min:
143	*
144	* FIXME Set correct values (limits)
145	*/
146	g_object_class_install_property (object_class,	111✔
147	PROP_LNMOBS_MIN,
148	g_param_spec_double ("lnMobs-min",
149	NULL,
150	"Minimum LnMobs",
151	11.0 * M_LN10, G_MAXDOUBLE, log (5.0) + 13.0 * M_LN10,
152	G_PARAM_READWRITE \| G_PARAM_CONSTRUCT_ONLY \| G_PARAM_STATIC_NAME \| G_PARAM_STATIC_BLURB));
153
154	/**
155	* NcClusterMassLnnormal:lnMobs_max:
156	*
157	* FIXME Set correct values (limits)
158	*/
159	g_object_class_install_property (object_class,	111✔
160	PROP_LNMOBS_MAX,
161	g_param_spec_double ("lnMobs-max",
162	NULL,
163	"Maximum LnMobs",
164	11.0 * M_LN10, G_MAXDOUBLE, 16.0 * M_LN10,
165	G_PARAM_READWRITE \| G_PARAM_CONSTRUCT_ONLY \| G_PARAM_STATIC_NAME \| G_PARAM_STATIC_BLURB));
166
167	/**
168	* NcClusterMassLnnormal:bias:
169	*
170	* Distribution's bias.
171	* FIXME Set correct values (limits)
172	*/
173	ncm_model_class_set_sparam (model_class, NC_CLUSTER_MASS_LNNORMAL_BIAS, "bias", "bias",	111✔
174	0.0, 10.0, 1.0e-2,
175	NC_CLUSTER_MASS_LNNORMAL_DEFAULT_PARAMS_ABSTOL, NC_CLUSTER_MASS_LNNORMAL_DEFAULT_BIAS,
176	NCM_PARAM_TYPE_FIXED);
177
178	/**
179	* NcClusterMassLnnormal:sigma:
180	*
181	* Distribution's standard deviation, $\sigma \in [10^{-4}, 10]$.
182	*
183	*/
184	ncm_model_class_set_sparam (model_class, NC_CLUSTER_MASS_LNNORMAL_SIGMA, "sigma", "sigma",	111✔
185	1.0e-4, 10.0, 1.0e-2,
186	NC_CLUSTER_MASS_LNNORMAL_DEFAULT_PARAMS_ABSTOL, NC_CLUSTER_MASS_LNNORMAL_DEFAULT_SIGMA,
187	NCM_PARAM_TYPE_FIXED);
188
189	/* Check for errors in parameters initialization */
190	ncm_model_class_check_params_info (model_class);	111✔
191
192	parent_class->P = &_nc_cluster_mass_lnnormal_p;	111✔
193	parent_class->intP = &_nc_cluster_mass_lnnormal_intp;	111✔
194	parent_class->intP_bin = &_nc_cluster_mass_lnnormal_intp_bin;	111✔
195	parent_class->resample = &_nc_cluster_mass_lnnormal_resample;	111✔
196	parent_class->P_limits = &_nc_cluster_mass_lnnormal_p_limits;	111✔
197	parent_class->P_bin_limits = &_nc_cluster_mass_lnnormal_p_limits_bin;	111✔
198	parent_class->N_limits = &_nc_cluster_mass_lnnormal_n_limits;	111✔
199	parent_class->_obs_len = 1;	111✔
200	parent_class->_obs_params_len = 0;	111✔
201
202	ncm_model_class_add_impl_flag (model_class, NC_CLUSTER_MASS_IMPL_ALL);	111✔
203	}	111✔
204
205	static gdouble
206	_nc_cluster_mass_lnnormal_p (NcClusterMass clusterm, NcHICosmo cosmo, gdouble lnM, gdouble z, const gdouble lnM_obs, const gdouble lnM_obs_params)	×
207	{
208	NcClusterMassLnnormal *mlnn = NC_CLUSTER_MASS_LNNORMAL (clusterm);	×
209	const gdouble lnMobs = lnM_obs[0];	×
210	const gdouble sqrt2_sigma = M_SQRT2 * SIGMA;	×
211	const gdouble x = (lnMobs - lnM - BIAS) / sqrt2_sigma;	×
212
UNCOV 213	NCM_UNUSED (cosmo);	×
UNCOV 214	NCM_UNUSED (z);	×
215
216	return M_2_SQRTPI / (2.0 * M_SQRT2) * exp (-x * x) / (SIGMA);	×
217	}
218
219	static gdouble
220	_nc_cluster_mass_lnnormal_intp (NcClusterMass clusterm, NcHICosmo cosmo, gdouble lnM, gdouble z)	×
221	{
222	NcClusterMassLnnormal *mlnn = NC_CLUSTER_MASS_LNNORMAL (clusterm);	×
223	const gdouble sqrt2_sigma = M_SQRT2 * SIGMA;	×
224	const gdouble x_min = (lnM - mlnn->lnMobs_min) / sqrt2_sigma;	×
225	const gdouble x_max = (lnM - mlnn->lnMobs_max) / sqrt2_sigma;	×
226
UNCOV 227	NCM_UNUSED (cosmo);	×
UNCOV 228	NCM_UNUSED (z);	×
229
230	if (x_max > 4.0)	×
231	return -(erfc (x_min) - erfc (x_max)) / 2.0;	×
232	else
233	return (erf (x_min) - erf (x_max)) / 2.0;	×
234	}
235
236	static gdouble
237	_nc_cluster_mass_lnnormal_intp_bin (NcClusterMass clusterm, NcHICosmo cosmo, gdouble lnM, gdouble z, const gdouble lnM_obs_lower, const gdouble lnM_obs_upper, const gdouble *lnM_obs_params)	×
238	{
239	NcClusterMassLnnormal *mlnn = NC_CLUSTER_MASS_LNNORMAL (clusterm);	×
240	const gdouble sqrt2_sigma = M_SQRT2 * SIGMA;	×
241	const gdouble x_min = (lnM - lnM_obs_lower[0]) / sqrt2_sigma;	×
242	const gdouble x_max = (lnM - lnM_obs_upper[0]) / sqrt2_sigma;	×
243
UNCOV 244	NCM_UNUSED (cosmo);	×
UNCOV 245	NCM_UNUSED (z);	×
246
247	if (x_max > 4.0)	×
248	return -(erfc (x_min) - erfc (x_max)) / 2.0;	×
249	else
250	return (erf (x_min) - erf (x_max)) / 2.0;	×
251	}
252
253	static gboolean
254	_nc_cluster_mass_lnnormal_resample (NcClusterMass clusterm, NcHICosmo cosmo, gdouble lnM, gdouble z, gdouble lnM_obs, const gdouble lnM_obs_params, NcmRNG *rng)	38,300✔
255	{
256	NcClusterMassLnnormal *mlnn = NC_CLUSTER_MASS_LNNORMAL (clusterm);	38,300✔
257
258	NCM_UNUSED (cosmo);	38,300✔
259	NCM_UNUSED (z);	38,300✔
260
261	ncm_rng_lock (rng);	38,300✔
262	lnM_obs[0] = lnM + BIAS + gsl_ran_gaussian (rng->r, SIGMA);	38,300✔
263	ncm_rng_unlock (rng);	38,300✔
264
265	return (lnM_obs[0] <= mlnn->lnMobs_max) && (lnM_obs[0] >= mlnn->lnMobs_min);	38,300!
266	}
267
268	static void
269	_nc_cluster_mass_lnnormal_p_limits (NcClusterMass clusterm, NcHICosmo cosmo, const gdouble lnM_obs, const gdouble lnM_obs_params, gdouble lnM_lower, gdouble lnM_upper)	×
270	{
271	NcClusterMassLnnormal *mlnn = NC_CLUSTER_MASS_LNNORMAL (clusterm);	×
272	const gdouble mean = lnM_obs[0] - BIAS;	×
273	const gdouble lnMl = mean - 7.0 * SIGMA;	×
274	const gdouble lnMu = mean + 7.0 * SIGMA;	×
275
UNCOV 276	NCM_UNUSED (cosmo);	×
277
278	*lnM_lower = lnMl;	×
279	*lnM_upper = lnMu;	×
280
281	return;	×
282	}
283
284	static void
285	_nc_cluster_mass_lnnormal_p_limits_bin (NcClusterMass clusterm, NcHICosmo cosmo, const gdouble lnM_obs_lower, const gdouble lnM_obs_upper, const gdouble lnM_obs_params, gdouble lnM_lower, gdouble *lnM_upper)	×
286	{
287	NcClusterMassLnnormal *mlnn = NC_CLUSTER_MASS_LNNORMAL (clusterm);	×
288	const gdouble lnMl = lnM_obs_lower[0] - 7.0 * SIGMA;	×
289	const gdouble lnMu = lnM_obs_upper[0] + 7.0 * SIGMA;	×
290
UNCOV 291	NCM_UNUSED (cosmo);	×
292
293	*lnM_lower = lnMl;	×
294	*lnM_upper = lnMu;	×
295	}	×
296
297	static void
298	_nc_cluster_mass_lnnormal_n_limits (NcClusterMass clusterm, NcHICosmo cosmo, gdouble lnM_lower, gdouble lnM_upper)	1✔
299	{
300	NcClusterMassLnnormal *mlnn = NC_CLUSTER_MASS_LNNORMAL (clusterm);	1✔
301	const gdouble lnMl = mlnn->lnMobs_min - 7.0 * SIGMA;	1✔
302	const gdouble lnMu = mlnn->lnMobs_max + 7.0 * SIGMA;	1✔
303
304	NCM_UNUSED (cosmo);	1✔
305
306	*lnM_lower = lnMl;	1✔
307	*lnM_upper = lnMu;	1✔
308
309	return;	1✔
310	}
311

NumCosmo / NumCosmo / 7062600209

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous