7062833448

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

Build # 7062833448

Build Type

Pull #120

github

Committed by

web-flow

Commit Message

Merge e5341248d into 24e5f6a9b

Pull Request Pull Request #120: Moving to meson

Run Details

14327 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.

57531 of 154555 relevant lines covered (37.22%)

2483188.89 hits per line

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

11.66

/numcosmo/lss/nc_multiplicity_func_st.c

/***************************************************************************
 *            nc_multiplicity_func_st.c
 *
 *  Mon Jun 28 15:09:13 2010
 *  Copyright  2010  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_multiplicity_func_st
 * @title: NcMultiplicityFuncST
 * @short_description: Dark matter halo -- Sheth-Tormen multiplicity function.
 *
 * Computes the multiplicity function of dark matter halos using the
 * Sheth-Tormen model.
 *
 */

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

#include "lss/nc_multiplicity_func_st.h"

struct _NcMultiplicityFuncSTPrivate
{
  NcMultiplicityFuncMassDef mdef;
  gdouble A;
  gdouble b;
  gdouble p;
  gdouble delta_c;
  gdouble Delta;
};

enum
{
  PROP_0,
  PROP_A,
  PROP_B,
  PROP_P,
  PROP_DELTA_C,
  PROP_SIZE,
};

G_DEFINE_TYPE_WITH_PRIVATE (NcMultiplicityFuncST, nc_multiplicity_func_st, NC_TYPE_MULTIPLICITY_FUNC)

static void
nc_multiplicity_func_st_init (NcMultiplicityFuncST *mst)
{
  NcMultiplicityFuncSTPrivate * const self = mst->priv = nc_multiplicity_func_st_get_instance_private (mst);

  self->mdef    = NC_MULTIPLICITY_FUNC_MASS_DEF_LEN;
  self->A       = 0.0;
  self->b       = 0.0;
  self->p       = 0.0;
  self->delta_c = 0.0;
  self->Delta   = 0.0;
}

static void
_nc_multiplicity_func_st_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
{
  NcMultiplicityFuncST *mst = NC_MULTIPLICITY_FUNC_ST (object);

  g_return_if_fail (NC_IS_MULTIPLICITY_FUNC_ST (object));

  switch (prop_id)
  {
    case PROP_A:
      nc_multiplicity_func_st_set_A (mst, g_value_get_double (value));
      break;
    case PROP_B:
      nc_multiplicity_func_st_set_b (mst, g_value_get_double (value));
      break;
    case PROP_P:
      nc_multiplicity_func_st_set_p (mst, g_value_get_double (value));
      break;
    case PROP_DELTA_C:
      nc_multiplicity_func_st_set_delta_c (mst, g_value_get_double (value));
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static void
_nc_multiplicity_func_st_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
  NcMultiplicityFuncST *mst = NC_MULTIPLICITY_FUNC_ST (object);

  g_return_if_fail (NC_IS_MULTIPLICITY_FUNC_ST (object));

  switch (prop_id)
  {
    case PROP_A:
      g_value_set_double (value, nc_multiplicity_func_st_get_A (mst));
      break;
    case PROP_B:
      g_value_set_double (value, nc_multiplicity_func_st_get_b (mst));
      break;
    case PROP_P:
      g_value_set_double (value, nc_multiplicity_func_st_get_p (mst));
      break;
    case PROP_DELTA_C:
      g_value_set_double (value, nc_multiplicity_func_st_get_delta_c (mst));
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

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

static void _nc_multiplicity_func_st_set_mdef (NcMultiplicityFunc *mulf, NcMultiplicityFuncMassDef mdef);
static void _nc_multiplicity_func_st_set_Delta (NcMultiplicityFunc *mulf, gdouble Delta);
static NcMultiplicityFuncMassDef _nc_multiplicity_func_st_get_mdef (NcMultiplicityFunc *mulf);
static gdouble _nc_multiplicity_func_st_get_Delta (NcMultiplicityFunc *mulf);
static gdouble _nc_multiplicity_func_st_eval (NcMultiplicityFunc *mulf, NcHICosmo *cosmo, gdouble sigma, gdouble z);

static void
nc_multiplicity_func_st_class_init (NcMultiplicityFuncSTClass *klass)
{
  GObjectClass *object_class            = G_OBJECT_CLASS (klass);
  NcMultiplicityFuncClass *parent_class = NC_MULTIPLICITY_FUNC_CLASS (klass);

  object_class->set_property = _nc_multiplicity_func_st_set_property;
  object_class->get_property = _nc_multiplicity_func_st_get_property;
  object_class->finalize     = _nc_multiplicity_func_st_finalize;

  /**
   * NcMultiplicityFuncST:A:
   *
   * FIXME Set correct values (limits)
   */
  g_object_class_install_property (object_class,
                                   PROP_A,
                                   g_param_spec_double ("A",
                                                        NULL,
                                                        "A",
                                                        -G_MAXDOUBLE, G_MAXDOUBLE, 0.3222,
                                                        G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB));

  /**
   * NcMultiplicityFuncST:b:
   *
   * FIXME Set correct values (limits)
   */
  g_object_class_install_property (object_class,
                                   PROP_B,
                                   g_param_spec_double ("b",
                                                        NULL,
                                                        "b",
                                                        -G_MAXDOUBLE, G_MAXDOUBLE, 0.707,
                                                        G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB));

  /**
   * NcMultiplicityFuncST:p:
   *
   * FIXME Set correct values (limits)
   */
  g_object_class_install_property (object_class,
                                   PROP_P,
                                   g_param_spec_double ("p",
                                                        NULL,
                                                        "p",
                                                        -G_MAXDOUBLE, G_MAXDOUBLE, 0.3,
                                                        G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB));

  /**
   * NcMultiplicityFuncST:critical_delta:
   *
   * FIXME Set correct values (limits)
   */
  g_object_class_install_property (object_class,
                                   PROP_DELTA_C,
                                   g_param_spec_double ("critical-delta",
                                                        NULL,
                                                        "Critical delta",
                                                        -G_MAXDOUBLE, G_MAXDOUBLE, NC_MULTIPLICITY_FUNC_DELTA_C0,
                                                        G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB));
  parent_class->set_mdef  = &_nc_multiplicity_func_st_set_mdef;
  parent_class->get_mdef  = &_nc_multiplicity_func_st_get_mdef;
  parent_class->set_Delta = &_nc_multiplicity_func_st_set_Delta;
  parent_class->get_Delta = &_nc_multiplicity_func_st_get_Delta;
  parent_class->eval      = &_nc_multiplicity_func_st_eval;
}

static void
_nc_multiplicity_func_st_set_mdef (NcMultiplicityFunc *mulf, NcMultiplicityFuncMassDef mdef)
{
  NcMultiplicityFuncST *mst                = NC_MULTIPLICITY_FUNC_ST (mulf);
  NcMultiplicityFuncSTPrivate * const self = mst->priv;

  switch (mdef)
  {
    case NC_MULTIPLICITY_FUNC_MASS_DEF_MEAN:
      /* nothing to do */
      break;
    case NC_MULTIPLICITY_FUNC_MASS_DEF_CRITICAL:
      g_error ("NcMultiplicityFuncST does not support critical mass def");
      break;
    case NC_MULTIPLICITY_FUNC_MASS_DEF_VIRIAL:
      g_error ("NcMultiplicityFuncST does not support virial mass def");
      break;
    case NC_MULTIPLICITY_FUNC_MASS_DEF_FOF:
      g_error ("NcMultiplicityFuncST does not support fof mass def");
      break;
    default:
      g_assert_not_reached ();
      break;
  }

  self->mdef = mdef;
}

static NcMultiplicityFuncMassDef
_nc_multiplicity_func_st_get_mdef (NcMultiplicityFunc *mulf)
{
  NcMultiplicityFuncST *mst                = NC_MULTIPLICITY_FUNC_ST (mulf);
  NcMultiplicityFuncSTPrivate * const self = mst->priv;

  return self->mdef;
}

static void
_nc_multiplicity_func_st_set_Delta (NcMultiplicityFunc *mulf, gdouble Delta)
{
  NcMultiplicityFuncST *mst                = NC_MULTIPLICITY_FUNC_ST (mulf);
  NcMultiplicityFuncSTPrivate * const self = mst->priv;

  self->Delta = Delta;
}

static gdouble
_nc_multiplicity_func_st_get_Delta (NcMultiplicityFunc *mulf)
{
  NcMultiplicityFuncST *mst                = NC_MULTIPLICITY_FUNC_ST (mulf);
  NcMultiplicityFuncSTPrivate * const self = mst->priv;

  return self->Delta;
}

static gdouble
_nc_multiplicity_func_st_eval (NcMultiplicityFunc *mulf, NcHICosmo *cosmo, gdouble sigma, gdouble z) /* f(\sigma) - Sheth \& Tormen (ST) */
{
  NcMultiplicityFuncST *mst                = NC_MULTIPLICITY_FUNC_ST (mulf);
  NcMultiplicityFuncSTPrivate * const self = mst->priv;

/*  const gdouble bc1 = sqrt(b/(2.0 * M_PI)); */
  const gdouble A   = self->A;
  const gdouble b   = self->b;
  const gdouble bc1 = sqrt (2.0 * b / M_PI);
  const gdouble p   = self->p;
  gdouble x         = self->delta_c / sigma;
  gdouble x2        = x * x;
  /*gdouble b2 = b * b; */
  gdouble f_ST = A * bc1 * (1.0 + pow (x2 * b, -p)) * exp (-(b * x2) / 2.0) * x; /* Jenkin's and Crocce's paper */

  /*gdouble f_ST = A * bc1 * (1.0 + pow(x * b, -p)) * exp(-(b2 * x2) / 2.0) * x; // Evrard' s paper */

  NCM_UNUSED (cosmo);
  NCM_UNUSED (z);
  /*  printf ("A = %.5g, b=%.5g, p=%.5g, delta_c= %.5g\n", A, b, p, mulf_st->delta_c); */

  return f_ST;
}

/**
 * nc_multiplicity_func_st_new:
 *
 * FIXME
 *
 * Returns: A new #NcMultiplicityFuncST.
 */
NcMultiplicityFuncST *
nc_multiplicity_func_st_new (void)
{
  return g_object_new (NC_TYPE_MULTIPLICITY_FUNC_ST,
                       "mass-def", NC_MULTIPLICITY_FUNC_MASS_DEF_MEAN,
                       NULL);
}

/**
 * nc_multiplicity_func_st_ref:
 * @mst: a #NcMultiplicityFuncST
 *
 * Increases the reference count of @mst by one.
 *
 * Returns: (transfer full): @mst
 */
NcMultiplicityFuncST *
nc_multiplicity_func_st_ref (NcMultiplicityFuncST *mst)
{
  return g_object_ref (mst);
}

/**
 * nc_multiplicity_func_st_free:
 * @mst: a #NcMultiplicityFuncST
 *
 * Atomically decrements the reference count of @mst by one. If the reference count drops to 0,
 * all memory allocated by @mst is released.
 *
 */
void
nc_multiplicity_func_st_free (NcMultiplicityFuncST *mst)
{
  g_object_unref (mst);
}

/**
 * nc_multiplicity_func_st_clear:
 * @mst: a #NcMultiplicityFuncST
 *
 * Atomically decrements the reference count of @mst by one. If the reference count drops to 0,
 * all memory allocated by @mst is released. Set the pointer to NULL;
 *
 */
void
nc_multiplicity_func_st_clear (NcMultiplicityFuncST **mst)
{
  g_clear_object (mst);
}

/**
 * nc_multiplicity_func_st_set_A:
 * @mst: a #NcMultiplicityFuncST.
 * @A: value of #NcMultiplicityFuncST:A.
 *
 * Sets the value @A to the #NcMultiplicityFuncST:A property.
 *
 */
void
nc_multiplicity_func_st_set_A (NcMultiplicityFuncST *mst, gdouble A)
{
  NcMultiplicityFuncSTPrivate * const self = mst->priv;

  g_assert (A >= 0);

  self->A = A;
}

/**
 * nc_multiplicity_func_st_get_A:
 * @mst: a #NcMultiplicityFuncST.
 *
 * Returns: the value of #NcMultiplicityFuncST:A property.
 */
gdouble
nc_multiplicity_func_st_get_A (const NcMultiplicityFuncST *mst)
{
  NcMultiplicityFuncSTPrivate * const self = mst->priv;

  return self->A;
}

/**
 * nc_multiplicity_func_st_set_b:
 * @mst: a #NcMultiplicityFuncST.
 * @b: value of #NcMultiplicityFuncST:b.
 *
 * Sets the value @b to the #NcMultiplicityFuncST:b property.
 *
 */
void
nc_multiplicity_func_st_set_b (NcMultiplicityFuncST *mst, gdouble b)
{
  NcMultiplicityFuncSTPrivate * const self = mst->priv;

  g_assert (b >= 0);

  self->b = b;
}

/**
 * nc_multiplicity_func_st_get_b:
 * @mst: a #NcMultiplicityFuncST.
 *
 * Returns: the value of #NcMultiplicityFuncST:b property.
 */
gdouble
nc_multiplicity_func_st_get_b (const NcMultiplicityFuncST *mst)
{
  NcMultiplicityFuncSTPrivate * const self = mst->priv;

  return self->b;
}

/**
 * nc_multiplicity_func_st_set_p:
 * @mst: a #NcMultiplicityFuncST.
 * @p: value of #NcMultiplicityFuncST:p.
 *
 * Sets the value @p to the #NcMultiplicityFuncST:p property.
 *
 */
void
nc_multiplicity_func_st_set_p (NcMultiplicityFuncST *mst, gdouble p)
{
  NcMultiplicityFuncSTPrivate * const self = mst->priv;

  g_assert (p >= 0);

  self->p = p;
}

/**
 * nc_multiplicity_func_st_get_p:
 * @mst: a #NcMultiplicityFuncST.
 *
 * Returns: the value of #NcMultiplicityFuncST:p property.
 */
gdouble
nc_multiplicity_func_st_get_p (const NcMultiplicityFuncST *mst)
{
  NcMultiplicityFuncSTPrivate * const self = mst->priv;

  return self->p;
}

/**
 * nc_multiplicity_func_st_set_delta_c:
 * @mst: a #NcMultiplicityFuncST.
 * @delta_c: value of #NcMultiplicityFuncST:critical-delta.
 *
 * Sets the value @delta_c to the #NcMultiplicityFuncST:critical-delta property.
 *
 */
void
nc_multiplicity_func_st_set_delta_c (NcMultiplicityFuncST *mst, gdouble delta_c)
{
  NcMultiplicityFuncSTPrivate * const self = mst->priv;

  g_assert (delta_c >= 0);

  self->delta_c = delta_c;
}

/**
 * nc_multiplicity_func_st_get_delta_c:
 * @mst: a #NcMultiplicityFuncST.
 *
 * Returns: the value of #NcMultiplicityFuncST:critical_delta property.
 */
gdouble
nc_multiplicity_func_st_get_delta_c (const NcMultiplicityFuncST *mst)
{
  NcMultiplicityFuncSTPrivate * const self = mst->priv;

  return self->delta_c;
}


1	/***************************************************************************
2	* nc_multiplicity_func_st.c
3	*
4	* Mon Jun 28 15:09:13 2010
5	* Copyright 2010 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_multiplicity_func_st
28	* @title: NcMultiplicityFuncST
29	* @short_description: Dark matter halo -- Sheth-Tormen multiplicity function.
30	*
31	* Computes the multiplicity function of dark matter halos using the
32	* Sheth-Tormen model.
33	*
34	*/
35
36	#ifdef HAVE_CONFIG_H
37	# include "config.h"
38	#endif /* HAVE_CONFIG_H */
39	#include "build_cfg.h"
40
41	#include "lss/nc_multiplicity_func_st.h"
42
43	struct _NcMultiplicityFuncSTPrivate
44	{
45	NcMultiplicityFuncMassDef mdef;
46	gdouble A;
47	gdouble b;
48	gdouble p;
49	gdouble delta_c;
50	gdouble Delta;
51	};
52
53	enum
54	{
55	PROP_0,
56	PROP_A,
57	PROP_B,
58	PROP_P,
59	PROP_DELTA_C,
60	PROP_SIZE,
61	};
62
63	G_DEFINE_TYPE_WITH_PRIVATE (NcMultiplicityFuncST, nc_multiplicity_func_st, NC_TYPE_MULTIPLICITY_FUNC)	333!
64
65	static void
66	nc_multiplicity_func_st_init (NcMultiplicityFuncST *mst)	×
67	{
68	NcMultiplicityFuncSTPrivate * const self = mst->priv = nc_multiplicity_func_st_get_instance_private (mst);	×
69
70	self->mdef = NC_MULTIPLICITY_FUNC_MASS_DEF_LEN;	×
71	self->A = 0.0;	×
72	self->b = 0.0;	×
73	self->p = 0.0;	×
74	self->delta_c = 0.0;	×
75	self->Delta = 0.0;	×
76	}	×
77
78	static void
79	_nc_multiplicity_func_st_set_property (GObject object, guint prop_id, const GValue value, GParamSpec *pspec)	×
80	{
81	NcMultiplicityFuncST *mst = NC_MULTIPLICITY_FUNC_ST (object);	×
82
83	g_return_if_fail (NC_IS_MULTIPLICITY_FUNC_ST (object));	×
84
85	switch (prop_id)	×
86	{
87	case PROP_A:	×
88	nc_multiplicity_func_st_set_A (mst, g_value_get_double (value));	×
89	break;	×
90	case PROP_B:	×
91	nc_multiplicity_func_st_set_b (mst, g_value_get_double (value));	×
92	break;	×
93	case PROP_P:	×
94	nc_multiplicity_func_st_set_p (mst, g_value_get_double (value));	×
95	break;	×
96	case PROP_DELTA_C:	×
97	nc_multiplicity_func_st_set_delta_c (mst, g_value_get_double (value));	×
98	break;	×
99	default:	×
100	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
101	break;	×
102	}
103	}
104
105	static void
106	_nc_multiplicity_func_st_get_property (GObject object, guint prop_id, GValue value, GParamSpec *pspec)	×
107	{
108	NcMultiplicityFuncST *mst = NC_MULTIPLICITY_FUNC_ST (object);	×
109
110	g_return_if_fail (NC_IS_MULTIPLICITY_FUNC_ST (object));	×
111
112	switch (prop_id)	×
113	{
114	case PROP_A:	×
115	g_value_set_double (value, nc_multiplicity_func_st_get_A (mst));	×
116	break;	×
117	case PROP_B:	×
118	g_value_set_double (value, nc_multiplicity_func_st_get_b (mst));	×
119	break;	×
120	case PROP_P:	×
121	g_value_set_double (value, nc_multiplicity_func_st_get_p (mst));	×
122	break;	×
123	case PROP_DELTA_C:	×
124	g_value_set_double (value, nc_multiplicity_func_st_get_delta_c (mst));	×
125	break;	×
126	default:	×
127	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
128	break;	×
129	}
130	}
131
132	static void
133	_nc_multiplicity_func_st_finalize (GObject *object)	×
134	{
135	/* Chain up : end */
136	G_OBJECT_CLASS (nc_multiplicity_func_st_parent_class)->finalize (object);	×
137	}	×
138
139	static void _nc_multiplicity_func_st_set_mdef (NcMultiplicityFunc *mulf, NcMultiplicityFuncMassDef mdef);
140	static void _nc_multiplicity_func_st_set_Delta (NcMultiplicityFunc *mulf, gdouble Delta);
141	static NcMultiplicityFuncMassDef _nc_multiplicity_func_st_get_mdef (NcMultiplicityFunc *mulf);
142	static gdouble _nc_multiplicity_func_st_get_Delta (NcMultiplicityFunc *mulf);
143	static gdouble _nc_multiplicity_func_st_eval (NcMultiplicityFunc mulf, NcHICosmo cosmo, gdouble sigma, gdouble z);
144
145	static void
146	nc_multiplicity_func_st_class_init (NcMultiplicityFuncSTClass *klass)	111✔
147	{
148	GObjectClass *object_class = G_OBJECT_CLASS (klass);	111✔
149	NcMultiplicityFuncClass *parent_class = NC_MULTIPLICITY_FUNC_CLASS (klass);	111✔
150
151	object_class->set_property = _nc_multiplicity_func_st_set_property;	111✔
152	object_class->get_property = _nc_multiplicity_func_st_get_property;	111✔
153	object_class->finalize = _nc_multiplicity_func_st_finalize;	111✔
154
155	/**
156	* NcMultiplicityFuncST:A:
157	*
158	* FIXME Set correct values (limits)
159	*/
160	g_object_class_install_property (object_class,	111✔
161	PROP_A,
162	g_param_spec_double ("A",
163	NULL,
164	"A",
165	-G_MAXDOUBLE, G_MAXDOUBLE, 0.3222,
166	G_PARAM_READWRITE \| G_PARAM_CONSTRUCT_ONLY \| G_PARAM_STATIC_NAME \| G_PARAM_STATIC_BLURB));
167
168	/**
169	* NcMultiplicityFuncST:b:
170	*
171	* FIXME Set correct values (limits)
172	*/
173	g_object_class_install_property (object_class,	111✔
174	PROP_B,
175	g_param_spec_double ("b",
176	NULL,
177	"b",
178	-G_MAXDOUBLE, G_MAXDOUBLE, 0.707,
179	G_PARAM_READWRITE \| G_PARAM_CONSTRUCT_ONLY \| G_PARAM_STATIC_NAME \| G_PARAM_STATIC_BLURB));
180
181	/**
182	* NcMultiplicityFuncST:p:
183	*
184	* FIXME Set correct values (limits)
185	*/
186	g_object_class_install_property (object_class,	111✔
187	PROP_P,
188	g_param_spec_double ("p",
189	NULL,
190	"p",
191	-G_MAXDOUBLE, G_MAXDOUBLE, 0.3,
192	G_PARAM_READWRITE \| G_PARAM_CONSTRUCT_ONLY \| G_PARAM_STATIC_NAME \| G_PARAM_STATIC_BLURB));
193
194	/**
195	* NcMultiplicityFuncST:critical_delta:
196	*
197	* FIXME Set correct values (limits)
198	*/
199	g_object_class_install_property (object_class,	111✔
200	PROP_DELTA_C,
201	g_param_spec_double ("critical-delta",
202	NULL,
203	"Critical delta",
204	-G_MAXDOUBLE, G_MAXDOUBLE, NC_MULTIPLICITY_FUNC_DELTA_C0,
205	G_PARAM_READWRITE \| G_PARAM_CONSTRUCT_ONLY \| G_PARAM_STATIC_NAME \| G_PARAM_STATIC_BLURB));
206	parent_class->set_mdef = &_nc_multiplicity_func_st_set_mdef;	111✔
207	parent_class->get_mdef = &_nc_multiplicity_func_st_get_mdef;	111✔
208	parent_class->set_Delta = &_nc_multiplicity_func_st_set_Delta;	111✔
209	parent_class->get_Delta = &_nc_multiplicity_func_st_get_Delta;	111✔
210	parent_class->eval = &_nc_multiplicity_func_st_eval;	111✔
211	}	111✔
212
213	static void
214	_nc_multiplicity_func_st_set_mdef (NcMultiplicityFunc *mulf, NcMultiplicityFuncMassDef mdef)	×
215	{
216	NcMultiplicityFuncST *mst = NC_MULTIPLICITY_FUNC_ST (mulf);	×
217	NcMultiplicityFuncSTPrivate * const self = mst->priv;	×
218
219	switch (mdef)	×
220	{
221	case NC_MULTIPLICITY_FUNC_MASS_DEF_MEAN:
222	/* nothing to do */
223	break;	×
224	case NC_MULTIPLICITY_FUNC_MASS_DEF_CRITICAL:	×
225	g_error ("NcMultiplicityFuncST does not support critical mass def");
226	break;
227	case NC_MULTIPLICITY_FUNC_MASS_DEF_VIRIAL:	×
228	g_error ("NcMultiplicityFuncST does not support virial mass def");
229	break;
230	case NC_MULTIPLICITY_FUNC_MASS_DEF_FOF:	×
231	g_error ("NcMultiplicityFuncST does not support fof mass def");
232	break;
233	default:	×
234	g_assert_not_reached ();
235	break;
236	}
237
238	self->mdef = mdef;	×
239	}	×
240
241	static NcMultiplicityFuncMassDef
242	_nc_multiplicity_func_st_get_mdef (NcMultiplicityFunc *mulf)	×
243	{
244	NcMultiplicityFuncST *mst = NC_MULTIPLICITY_FUNC_ST (mulf);	×
245	NcMultiplicityFuncSTPrivate * const self = mst->priv;	×
246
247	return self->mdef;	×
248	}
249
250	static void
251	_nc_multiplicity_func_st_set_Delta (NcMultiplicityFunc *mulf, gdouble Delta)	×
252	{
253	NcMultiplicityFuncST *mst = NC_MULTIPLICITY_FUNC_ST (mulf);	×
254	NcMultiplicityFuncSTPrivate * const self = mst->priv;	×
255
256	self->Delta = Delta;	×
257	}	×
258
259	static gdouble
260	_nc_multiplicity_func_st_get_Delta (NcMultiplicityFunc *mulf)	×
261	{
262	NcMultiplicityFuncST *mst = NC_MULTIPLICITY_FUNC_ST (mulf);	×
263	NcMultiplicityFuncSTPrivate * const self = mst->priv;	×
264
265	return self->Delta;	×
266	}
267
268	static gdouble
269	_nc_multiplicity_func_st_eval (NcMultiplicityFunc mulf, NcHICosmo cosmo, gdouble sigma, gdouble z) /* f(\sigma) - Sheth \& Tormen (ST) */	×
270	{
271	NcMultiplicityFuncST *mst = NC_MULTIPLICITY_FUNC_ST (mulf);	×
272	NcMultiplicityFuncSTPrivate * const self = mst->priv;	×
273
274	/* const gdouble bc1 = sqrt(b/(2.0 * M_PI)); */
275	const gdouble A = self->A;	×
276	const gdouble b = self->b;	×
277	const gdouble bc1 = sqrt (2.0 * b / M_PI);	×
278	const gdouble p = self->p;	×
279	gdouble x = self->delta_c / sigma;	×
280	gdouble x2 = x * x;	×
281	/gdouble b2 = b b; */
282	gdouble f_ST = A * bc1 * (1.0 + pow (x2 * b, -p)) * exp (-(b * x2) / 2.0) * x; /* Jenkin's and Crocce's paper */	×
283
284	/gdouble f_ST = A bc1 * (1.0 + pow(x * b, -p)) * exp(-(b2 * x2) / 2.0) * x; // Evrard' s paper */
285
UNCOV 286	NCM_UNUSED (cosmo);	×
UNCOV 287	NCM_UNUSED (z);	×
288	/* printf ("A = %.5g, b=%.5g, p=%.5g, delta_c= %.5g\n", A, b, p, mulf_st->delta_c); */
289
290	return f_ST;	×
291	}
292
293	/**
294	* nc_multiplicity_func_st_new:
295	*
296	* FIXME
297	*
298	* Returns: A new #NcMultiplicityFuncST.
299	*/
300	NcMultiplicityFuncST *
301	nc_multiplicity_func_st_new (void)	×
302	{
303	return g_object_new (NC_TYPE_MULTIPLICITY_FUNC_ST,	×
304	"mass-def", NC_MULTIPLICITY_FUNC_MASS_DEF_MEAN,
305	NULL);
306	}
307
308	/**
309	* nc_multiplicity_func_st_ref:
310	* @mst: a #NcMultiplicityFuncST
311	*
312	* Increases the reference count of @mst by one.
313	*
314	* Returns: (transfer full): @mst
315	*/
316	NcMultiplicityFuncST *
317	nc_multiplicity_func_st_ref (NcMultiplicityFuncST *mst)	×
318	{
319	return g_object_ref (mst);	×
320	}
321
322	/**
323	* nc_multiplicity_func_st_free:
324	* @mst: a #NcMultiplicityFuncST
325	*
326	* Atomically decrements the reference count of @mst by one. If the reference count drops to 0,
327	* all memory allocated by @mst is released.
328	*
329	*/
330	void
331	nc_multiplicity_func_st_free (NcMultiplicityFuncST *mst)	×
332	{
333	g_object_unref (mst);	×
334	}	×
335
336	/**
337	* nc_multiplicity_func_st_clear:
338	* @mst: a #NcMultiplicityFuncST
339	*
340	* Atomically decrements the reference count of @mst by one. If the reference count drops to 0,
341	* all memory allocated by @mst is released. Set the pointer to NULL;
342	*
343	*/
344	void
345	nc_multiplicity_func_st_clear (NcMultiplicityFuncST **mst)	×
346	{
347	g_clear_object (mst);	×
348	}	×
349
350	/**
351	* nc_multiplicity_func_st_set_A:
352	* @mst: a #NcMultiplicityFuncST.
353	* @A: value of #NcMultiplicityFuncST:A.
354	*
355	* Sets the value @A to the #NcMultiplicityFuncST:A property.
356	*
357	*/
358	void
359	nc_multiplicity_func_st_set_A (NcMultiplicityFuncST *mst, gdouble A)	×
360	{
361	NcMultiplicityFuncSTPrivate * const self = mst->priv;	×
362
363	g_assert (A >= 0);	×
364
365	self->A = A;	×
366	}	×
367
368	/**
369	* nc_multiplicity_func_st_get_A:
370	* @mst: a #NcMultiplicityFuncST.
371	*
372	* Returns: the value of #NcMultiplicityFuncST:A property.
373	*/
374	gdouble
375	nc_multiplicity_func_st_get_A (const NcMultiplicityFuncST *mst)	×
376	{
377	NcMultiplicityFuncSTPrivate * const self = mst->priv;	×
378
379	return self->A;	×
380	}
381
382	/**
383	* nc_multiplicity_func_st_set_b:
384	* @mst: a #NcMultiplicityFuncST.
385	* @b: value of #NcMultiplicityFuncST:b.
386	*
387	* Sets the value @b to the #NcMultiplicityFuncST:b property.
388	*
389	*/
390	void
391	nc_multiplicity_func_st_set_b (NcMultiplicityFuncST *mst, gdouble b)	×
392	{
393	NcMultiplicityFuncSTPrivate * const self = mst->priv;	×
394
395	g_assert (b >= 0);	×
396
397	self->b = b;	×
398	}	×
399
400	/**
401	* nc_multiplicity_func_st_get_b:
402	* @mst: a #NcMultiplicityFuncST.
403	*
404	* Returns: the value of #NcMultiplicityFuncST:b property.
405	*/
406	gdouble
407	nc_multiplicity_func_st_get_b (const NcMultiplicityFuncST *mst)	×
408	{
409	NcMultiplicityFuncSTPrivate * const self = mst->priv;	×
410
411	return self->b;	×
412	}
413
414	/**
415	* nc_multiplicity_func_st_set_p:
416	* @mst: a #NcMultiplicityFuncST.
417	* @p: value of #NcMultiplicityFuncST:p.
418	*
419	* Sets the value @p to the #NcMultiplicityFuncST:p property.
420	*
421	*/
422	void
423	nc_multiplicity_func_st_set_p (NcMultiplicityFuncST *mst, gdouble p)	×
424	{
425	NcMultiplicityFuncSTPrivate * const self = mst->priv;	×
426
427	g_assert (p >= 0);	×
428
429	self->p = p;	×
430	}	×
431
432	/**
433	* nc_multiplicity_func_st_get_p:
434	* @mst: a #NcMultiplicityFuncST.
435	*
436	* Returns: the value of #NcMultiplicityFuncST:p property.
437	*/
438	gdouble
439	nc_multiplicity_func_st_get_p (const NcMultiplicityFuncST *mst)	×
440	{
441	NcMultiplicityFuncSTPrivate * const self = mst->priv;	×
442
443	return self->p;	×
444	}
445
446	/**
447	* nc_multiplicity_func_st_set_delta_c:
448	* @mst: a #NcMultiplicityFuncST.
449	* @delta_c: value of #NcMultiplicityFuncST:critical-delta.
450	*
451	* Sets the value @delta_c to the #NcMultiplicityFuncST:critical-delta property.
452	*
453	*/
454	void
455	nc_multiplicity_func_st_set_delta_c (NcMultiplicityFuncST *mst, gdouble delta_c)	×
456	{
457	NcMultiplicityFuncSTPrivate * const self = mst->priv;	×
458
459	g_assert (delta_c >= 0);	×
460
461	self->delta_c = delta_c;	×
462	}	×
463
464	/**
465	* nc_multiplicity_func_st_get_delta_c:
466	* @mst: a #NcMultiplicityFuncST.
467	*
468	* Returns: the value of #NcMultiplicityFuncST:critical_delta property.
469	*/
470	gdouble
471	nc_multiplicity_func_st_get_delta_c (const NcMultiplicityFuncST *mst)	×
472	{
473	NcMultiplicityFuncSTPrivate * const self = mst->priv;	×
474
475	return self->delta_c;	×
476	}
477

NumCosmo / NumCosmo / 7062833448

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