7064254510

Committed 01 Dec 2023 07:20PM UTC coverage: 38.327% (-15.1%) from 53.447%

Build # 7064254510

Build Type

Pull #120

github

Committed by

web-flow

Commit Message

Merge 151714d78 into 24e5f6a9b

Pull Request Pull Request #120: Moving to meson

Run Details

10932 of 30689 branches covered (0.0%)

Branch coverage included in aggregate %.

2020 of 3551 new or added lines in 314 files covered. (56.89%)

4100 existing lines in 296 files now uncovered.

59884 of 154079 relevant lines covered (38.87%)

2465885.21 hits per line

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

7.83

/numcosmo/lss/nc_multiplicity_func_tinker_mean_normalized.c

/***************************************************************************
 *            nc_multiplicity_func_tinker_mean_normalized.c
 *
 *  Thu July 03 12:29:55 2014
 *  Copyright  2014  Mariana Penna Lima
 *  <pennalima@gmail.com>
 ****************************************************************************/
/*
 * nc_multiplicity_func_tinker_mean_normalized.c
 * Copyright (C) 2014 Mariana Penna Lima <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_tinker_mean_normalized
 * @title: NcMultiplicityFuncTinkerMeanNormalized
 * @short_description: Dark matter halo -- Tinker normalized multiplicity function mean matter density.
 *
 * Normalized multiplicity function that has to be used in the halo model approach.
 * 
 * FIXME
 * Reference: arXiv:1001.3162
 */

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

#include "lss/nc_multiplicity_func_tinker_mean_normalized.h"

struct _NcMultiplicityFuncTinkerMeanNormalizedPrivate
{
  NcMultiplicityFuncMassDef mdef;
  gdouble Delta;
  guint int_Delta;
  gdouble alpha;
  gdouble beta;
  gdouble phi;
  gdouble eta;
  gdouble gamma;
};

enum
{
  PROP_0,
  PROP_SIZE,
};

G_DEFINE_TYPE_WITH_PRIVATE (NcMultiplicityFuncTinkerMeanNormalized, nc_multiplicity_func_tinker_mean_normalized, NC_TYPE_MULTIPLICITY_FUNC)

static void
nc_multiplicity_func_tinker_mean_normalized_init (NcMultiplicityFuncTinkerMeanNormalized *mt10)
{
  NcMultiplicityFuncTinkerMeanNormalizedPrivate * const self = mt10->priv = nc_multiplicity_func_tinker_mean_normalized_get_instance_private (mt10);

  self->mdef      = NC_MULTIPLICITY_FUNC_MASS_DEF_LEN;  
  self->Delta     = 0.0;
  self->int_Delta = 0;
  self->alpha     = 0.0;
  self->beta      = 0.0;
  self->phi       = 0.0;
  self->eta       = 0.0;
  self->gamma     = 0.0;
}

static void
_nc_multiplicity_func_tinker_mean_normalized_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec)
{
  /*NcMultiplicityFuncTinkerMeanNormalized *mt10 = NC_MULTIPLICITY_FUNC_TINKER_MEAN_NORMALIZED (object);*/
  g_return_if_fail (NC_IS_MULTIPLICITY_FUNC_TINKER_MEAN_NORMALIZED (object));

  switch (prop_id)
  {
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static void
_nc_multiplicity_func_tinker_mean_normalized_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
  /*NcMultiplicityFuncTinkerMeanNormalized *mt10 = NC_MULTIPLICITY_FUNC_TINKER_MEAN_NORMALIZED (object);*/
  g_return_if_fail (NC_IS_MULTIPLICITY_FUNC_TINKER_MEAN_NORMALIZED (object));

  switch (prop_id)
  {
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static void
_nc_multiplicity_func_tinker_mean_normalized_finalize (GObject *object)
{

  /* Chain up : end */
  G_OBJECT_CLASS (nc_multiplicity_func_tinker_mean_normalized_parent_class)->finalize (object);
}

static void _nc_multiplicity_func_tinker_mean_normalized_set_mdef (NcMultiplicityFunc *mulf, NcMultiplicityFuncMassDef mdef);
static void _nc_multiplicity_func_tinker_mean_normalized_set_Delta (NcMultiplicityFunc *mulf, gdouble Delta);
static NcMultiplicityFuncMassDef _nc_multiplicity_func_tinker_mean_normalized_get_mdef (NcMultiplicityFunc *mulf);
static gdouble _nc_multiplicity_func_tinker_mean_normalized_get_Delta (NcMultiplicityFunc *mulf);
static gdouble _nc_multiplicity_func_tinker_mean_normalized_eval (NcMultiplicityFunc *mulf, NcHICosmo *cosmo, gdouble sigma, gdouble z);

static void
nc_multiplicity_func_tinker_mean_normalized_class_init (NcMultiplicityFuncTinkerMeanNormalizedClass *klass)
{
  GObjectClass* object_class = G_OBJECT_CLASS (klass);
  NcMultiplicityFuncClass* parent_class = NC_MULTIPLICITY_FUNC_CLASS (klass);

  object_class->set_property = &_nc_multiplicity_func_tinker_mean_normalized_set_property;
  object_class->get_property = &_nc_multiplicity_func_tinker_mean_normalized_get_property;
  object_class->finalize     = &_nc_multiplicity_func_tinker_mean_normalized_finalize;



  parent_class->set_mdef = &_nc_multiplicity_func_tinker_mean_normalized_set_mdef;
  parent_class->set_Delta = &_nc_multiplicity_func_tinker_mean_normalized_set_Delta;
  parent_class->get_mdef = &_nc_multiplicity_func_tinker_mean_normalized_get_mdef;
  parent_class->get_Delta = &_nc_multiplicity_func_tinker_mean_normalized_get_Delta;
  parent_class->eval     = &_nc_multiplicity_func_tinker_mean_normalized_eval;
}

static void 
_nc_multiplicity_func_tinker_mean_normalized_set_mdef (NcMultiplicityFunc *mulf, NcMultiplicityFuncMassDef mdef)
{
  NcMultiplicityFuncTinkerMeanNormalized *mt10 = NC_MULTIPLICITY_FUNC_TINKER_MEAN_NORMALIZED (mulf);
  NcMultiplicityFuncTinkerMeanNormalizedPrivate * const self = mt10->priv;

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

  self->mdef = mdef;
}

static NcMultiplicityFuncMassDef 
_nc_multiplicity_func_tinker_mean_normalized_get_mdef (NcMultiplicityFunc *mulf)
{
  NcMultiplicityFuncTinkerMeanNormalized *mt10 = NC_MULTIPLICITY_FUNC_TINKER_MEAN_NORMALIZED (mulf);
  NcMultiplicityFuncTinkerMeanNormalizedPrivate * const self = mt10->priv;

  return self->mdef;
}

static gdouble
_nc_multiplicity_func_tinker_mean_normalized_eval (NcMultiplicityFunc *mulf, NcHICosmo *cosmo, gdouble sigma, gdouble z)   /* $g(\sigma) = \nu x f(\nu)$ Tinker: Eq. 8 1001.3162 */
{
  NcMultiplicityFuncTinkerMeanNormalized *mt10 = NC_MULTIPLICITY_FUNC_TINKER_MEAN_NORMALIZED (mulf);
  NcMultiplicityFuncTinkerMeanNormalizedPrivate * const self = mt10->priv;

  const gdouble nu = 1.686 / sigma;
  gdouble f_Tinker_mean_normalized;
  
  NCM_UNUSED (cosmo);

  if (self->Delta == 200.0)
  {
    const gdouble alpha_z = self->alpha;
    const gdouble beta_z  = self->beta * pow(1.0 + z, 0.2);
    const gdouble phi_z   = self->phi * pow(1.0 + z, -0.08);
    const gdouble eta_z   = self->eta * pow(1.0 + z, 0.27);
    const gdouble gamma_z = self->gamma * pow(1.0 + z, -0.01);
    f_Tinker_mean_normalized = alpha_z * (1.0 + pow(beta_z * nu, -2.0 * phi_z)) 
                               * pow(nu, 2.0 * eta_z) * exp(-gamma_z * nu * nu / 2.0) * nu;
  }    
  else 
  {
    f_Tinker_mean_normalized = nu * self->alpha * (1.0 + pow(self->beta * nu, -2.0 * self->phi)) 
                               * pow(nu, 2.0 * self->eta) * exp(-self->gamma * nu * nu / 2.0);
  }
  
    return f_Tinker_mean_normalized;
}

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

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

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

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

/**
 * nc_multiplicity_func_tinker_mean_normalized_set_Delta:
 * @mt10: a #NcMultiplicityFuncTinkerMeanNormalized.
 * @Delta: value of #NcMultiplicityFuncTinkerMeanNormalized:Delta.
 *
 * Sets the value @Delta to the #NcMultiplicityFuncTinkerMeanNormalized:Delta property.
 *
 */
static void
_nc_multiplicity_func_tinker_mean_normalized_set_Delta (NcMultiplicityFunc *mulf, gdouble Delta)
{
  NcMultiplicityFuncTinkerMeanNormalized *mt10 = NC_MULTIPLICITY_FUNC_TINKER_MEAN_NORMALIZED (mulf);
  NcMultiplicityFuncTinkerMeanNormalizedPrivate * const self = mt10->priv;
  
  const guint int_Delta = Delta;
  g_assert (Delta >= 0);
  g_assert (Delta == int_Delta);
  
  self->Delta = Delta;
  self->int_Delta = int_Delta;

  switch (self->int_Delta)
  {
    case 200:
      self->alpha =  0.368;
      self->beta  =  0.589;
      self->phi   =  -0.729;
      self->eta   = -0.243;
      self->gamma = 0.864;
      break;
    case 300:
      self->alpha = 0.363;
      self->beta  = 0.585;
      self->phi   = -0.789;
      self->eta   = -0.261;
      self->gamma = 0.922;
      break;
    case 400:
      self->alpha = 0.385;
      self->beta  = 0.544;
      self->phi   = -0.910;
      self->eta   = -0.261;
      self->gamma = 0.987;
      break;  
    case 600:
     self->alpha = 0.389;
     self->beta  = 0.543;
     self->phi   = -1.05;
     self->eta   = -0.273;
     self->gamma = 1.09;
     break;
    case 800:
     self->alpha = 0.393;
     self->beta  = 0.564;
     self->phi   = -1.20;
     self->eta   = -0.278;
     self->gamma = 1.20;
     break;
    case 1200:
     self->alpha = 0.365;
     self->beta  = 0.623;
     self->phi   = -1.26;
     self->eta   = -0.301;
     self->gamma = 1.34;
     break;
    case 1600:
     self->alpha = 0.379;
     self->beta  = 0.637;
     self->phi   = -1.45;
     self->eta   = -0.301;
     self->gamma = 1.50;
     break;
    case 2400:
     self->alpha = 0.355;
     self->beta  = 0.673;
     self->phi   = -1.50;
     self->eta   = -0.319;
     self->gamma = 1.68;
     break;
    case 3200:
     self->alpha = 0.327;
     self->beta  = 0.702;
     self->phi   = -1.49;
     self->eta   = -0.336;
     self->gamma = 1.81;
     break; 
    default:
      g_error ("NcMultiplicityFuncTinkerMeanNormalized: Delta == %u not supported.", self->int_Delta);
    break;
  }
  
}

/**
 * nc_multiplicity_func_tinker_mean_normalized_get_Delta:
 * @mt10: a #NcMultiplicityFuncTinkerMeanNormalized.
 *
 * Returns: the value of #NcMultiplicityFuncTinkerMeanNormalized:Delta property.
 */
static gdouble
_nc_multiplicity_func_tinker_mean_normalized_get_Delta (NcMultiplicityFunc *mulf)
{
  NcMultiplicityFuncTinkerMeanNormalized *mt10 = NC_MULTIPLICITY_FUNC_TINKER_MEAN_NORMALIZED (mulf);
  NcMultiplicityFuncTinkerMeanNormalizedPrivate * const self = mt10->priv;

  return self->Delta;
}



1	/***************************************************************************
2	* nc_multiplicity_func_tinker_mean_normalized.c
3	*
4	* Thu July 03 12:29:55 2014
5	* Copyright 2014 Mariana Penna Lima
6	* <pennalima@gmail.com>
7	****************************************************************************/
8	/*
9	* nc_multiplicity_func_tinker_mean_normalized.c
10	* Copyright (C) 2014 Mariana Penna Lima <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_tinker_mean_normalized
28	* @title: NcMultiplicityFuncTinkerMeanNormalized
29	* @short_description: Dark matter halo -- Tinker normalized multiplicity function mean matter density.
30	*
31	* Normalized multiplicity function that has to be used in the halo model approach.
32	*
33	* FIXME
34	* Reference: arXiv:1001.3162
35	*/
36
37	#ifdef HAVE_CONFIG_H
38	# include "config.h"
39	#endif /* HAVE_CONFIG_H */
40	#include "build_cfg.h"
41
42	#include "lss/nc_multiplicity_func_tinker_mean_normalized.h"
43
44	struct _NcMultiplicityFuncTinkerMeanNormalizedPrivate
45	{
46	NcMultiplicityFuncMassDef mdef;
47	gdouble Delta;
48	guint int_Delta;
49	gdouble alpha;
50	gdouble beta;
51	gdouble phi;
52	gdouble eta;
53	gdouble gamma;
54	};
55
56	enum
57	{
58	PROP_0,
59	PROP_SIZE,
60	};
61
62	G_DEFINE_TYPE_WITH_PRIVATE (NcMultiplicityFuncTinkerMeanNormalized, nc_multiplicity_func_tinker_mean_normalized, NC_TYPE_MULTIPLICITY_FUNC)	666✔
63
64	static void
65	nc_multiplicity_func_tinker_mean_normalized_init (NcMultiplicityFuncTinkerMeanNormalized *mt10)	×
66	{
67	NcMultiplicityFuncTinkerMeanNormalizedPrivate * const self = mt10->priv = nc_multiplicity_func_tinker_mean_normalized_get_instance_private (mt10);	×
68
69	self->mdef = NC_MULTIPLICITY_FUNC_MASS_DEF_LEN;	×
70	self->Delta = 0.0;	×
71	self->int_Delta = 0;	×
72	self->alpha = 0.0;	×
73	self->beta = 0.0;	×
74	self->phi = 0.0;	×
75	self->eta = 0.0;	×
76	self->gamma = 0.0;	×
77	}
78
79	static void
80	_nc_multiplicity_func_tinker_mean_normalized_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec)	×
81	{
82	/NcMultiplicityFuncTinkerMeanNormalized mt10 = NC_MULTIPLICITY_FUNC_TINKER_MEAN_NORMALIZED (object);*/
83	g_return_if_fail (NC_IS_MULTIPLICITY_FUNC_TINKER_MEAN_NORMALIZED (object));	×
84
UNCOV 85	switch (prop_id)	×
86	{
87	default:	×
UNCOV 88	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);	×
89	break;	×
90	}
91	}
92
93	static void
94	_nc_multiplicity_func_tinker_mean_normalized_get_property (GObject object, guint prop_id, GValue value, GParamSpec *pspec)	×
95	{
96	/NcMultiplicityFuncTinkerMeanNormalized mt10 = NC_MULTIPLICITY_FUNC_TINKER_MEAN_NORMALIZED (object);*/
97	g_return_if_fail (NC_IS_MULTIPLICITY_FUNC_TINKER_MEAN_NORMALIZED (object));	×
98
UNCOV 99	switch (prop_id)	×
100	{
101	default:	×
UNCOV 102	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);	×
103	break;	×
104	}
105	}
106
107	static void
108	_nc_multiplicity_func_tinker_mean_normalized_finalize (GObject *object)	×
109	{
110
111	/* Chain up : end */
112	G_OBJECT_CLASS (nc_multiplicity_func_tinker_mean_normalized_parent_class)->finalize (object);	×
113	}
114
115	static void _nc_multiplicity_func_tinker_mean_normalized_set_mdef (NcMultiplicityFunc *mulf, NcMultiplicityFuncMassDef mdef);
116	static void _nc_multiplicity_func_tinker_mean_normalized_set_Delta (NcMultiplicityFunc *mulf, gdouble Delta);
117	static NcMultiplicityFuncMassDef _nc_multiplicity_func_tinker_mean_normalized_get_mdef (NcMultiplicityFunc *mulf);
118	static gdouble _nc_multiplicity_func_tinker_mean_normalized_get_Delta (NcMultiplicityFunc *mulf);
119	static gdouble _nc_multiplicity_func_tinker_mean_normalized_eval (NcMultiplicityFunc mulf, NcHICosmo cosmo, gdouble sigma, gdouble z);
120
121	static void
122	nc_multiplicity_func_tinker_mean_normalized_class_init (NcMultiplicityFuncTinkerMeanNormalizedClass *klass)	111✔
123	{
124	GObjectClass* object_class = G_OBJECT_CLASS (klass);	111✔
125	NcMultiplicityFuncClass* parent_class = NC_MULTIPLICITY_FUNC_CLASS (klass);	111✔
126
127	object_class->set_property = &_nc_multiplicity_func_tinker_mean_normalized_set_property;	111✔
128	object_class->get_property = &_nc_multiplicity_func_tinker_mean_normalized_get_property;	111✔
129	object_class->finalize = &_nc_multiplicity_func_tinker_mean_normalized_finalize;	111✔
130
131
132
133	parent_class->set_mdef = &_nc_multiplicity_func_tinker_mean_normalized_set_mdef;	111✔
134	parent_class->set_Delta = &_nc_multiplicity_func_tinker_mean_normalized_set_Delta;	111✔
135	parent_class->get_mdef = &_nc_multiplicity_func_tinker_mean_normalized_get_mdef;	111✔
136	parent_class->get_Delta = &_nc_multiplicity_func_tinker_mean_normalized_get_Delta;	111✔
137	parent_class->eval = &_nc_multiplicity_func_tinker_mean_normalized_eval;	111✔
138	}
139
140	static void
141	_nc_multiplicity_func_tinker_mean_normalized_set_mdef (NcMultiplicityFunc *mulf, NcMultiplicityFuncMassDef mdef)	×
142	{
143	NcMultiplicityFuncTinkerMeanNormalized *mt10 = NC_MULTIPLICITY_FUNC_TINKER_MEAN_NORMALIZED (mulf);	×
144	NcMultiplicityFuncTinkerMeanNormalizedPrivate * const self = mt10->priv;	×
145
146	switch (mdef)	×
147	{
148	case NC_MULTIPLICITY_FUNC_MASS_DEF_MEAN:
149	/* nothing to do */
150	break;	×
151	case NC_MULTIPLICITY_FUNC_MASS_DEF_CRITICAL:	×
UNCOV 152	g_error ("NcMultiplicityFuncPS does not support critical mass def");	×
153	break;
154	case NC_MULTIPLICITY_FUNC_MASS_DEF_VIRIAL:	×
UNCOV 155	g_error ("NcMultiplicityFuncPS does not support virial mass def");	×
156	break;
157	case NC_MULTIPLICITY_FUNC_MASS_DEF_FOF:	×
UNCOV 158	g_error ("NcMultiplicityFuncPS does not support fof mass def");	×
159	break;
160	default:	×
UNCOV 161	g_assert_not_reached ();	×
162	break;
163	}
164
165	self->mdef = mdef;	×
166	}
167
168	static NcMultiplicityFuncMassDef
169	_nc_multiplicity_func_tinker_mean_normalized_get_mdef (NcMultiplicityFunc *mulf)	×
170	{
171	NcMultiplicityFuncTinkerMeanNormalized *mt10 = NC_MULTIPLICITY_FUNC_TINKER_MEAN_NORMALIZED (mulf);	×
172	NcMultiplicityFuncTinkerMeanNormalizedPrivate * const self = mt10->priv;	×
173
174	return self->mdef;	×
175	}
176
177	static gdouble
178	_nc_multiplicity_func_tinker_mean_normalized_eval (NcMultiplicityFunc mulf, NcHICosmo cosmo, gdouble sigma, gdouble z) /* $g(\sigma) = \nu x f(\nu)$ Tinker: Eq. 8 1001.3162 */	×
179	{
180	NcMultiplicityFuncTinkerMeanNormalized *mt10 = NC_MULTIPLICITY_FUNC_TINKER_MEAN_NORMALIZED (mulf);	×
181	NcMultiplicityFuncTinkerMeanNormalizedPrivate * const self = mt10->priv;	×
182
183	const gdouble nu = 1.686 / sigma;	×
UNCOV 184	gdouble f_Tinker_mean_normalized;	×
185
UNCOV 186	NCM_UNUSED (cosmo);	×
187
188	if (self->Delta == 200.0)	×
189	{
190	const gdouble alpha_z = self->alpha;	×
191	const gdouble beta_z = self->beta * pow(1.0 + z, 0.2);	×
192	const gdouble phi_z = self->phi * pow(1.0 + z, -0.08);	×
193	const gdouble eta_z = self->eta * pow(1.0 + z, 0.27);	×
194	const gdouble gamma_z = self->gamma * pow(1.0 + z, -0.01);	×
195	f_Tinker_mean_normalized = alpha_z * (1.0 + pow(beta_z * nu, -2.0 * phi_z))	×
196	* pow(nu, 2.0 * eta_z) * exp(-gamma_z * nu * nu / 2.0) * nu;	×
197	}
198	else
199	{
200	f_Tinker_mean_normalized = nu * self->alpha * (1.0 + pow(self->beta * nu, -2.0 * self->phi))	×
201	* pow(nu, 2.0 * self->eta) * exp(-self->gamma * nu * nu / 2.0);	×
202	}
203
204	return f_Tinker_mean_normalized;	×
205	}
206
207	/**
208	* nc_multiplicity_func_tinker_mean_normalized_new:
209	*
210	* FIXME
211	*
212	* Returns: A new #NcMultiplicityFuncTinkerMeanNormalized.
213	*/
214	NcMultiplicityFuncTinkerMeanNormalized *
215	nc_multiplicity_func_tinker_mean_normalized_new (void)	×
216	{
217	return g_object_new (NC_TYPE_MULTIPLICITY_FUNC_TINKER_MEAN_NORMALIZED,	×
218	"mass-def", NC_MULTIPLICITY_FUNC_MASS_DEF_MEAN,
219	NULL);
220	}
221
222	/**
223	* nc_multiplicity_func_tinker_mean_normalized_ref:
224	* @mt10: a #NcMultiplicityFuncTinkerMeanNormalized
225	*
226	* Increases the reference count of @mt10 by one.
227	*
228	* Returns: (transfer full): @mt10
229	*/
230	NcMultiplicityFuncTinkerMeanNormalized *
231	nc_multiplicity_func_tinker_mean_normalized_ref (NcMultiplicityFuncTinkerMeanNormalized *mt10)	×
232	{
233	return g_object_ref (mt10);	×
234	}
235
236	/**
237	* nc_multiplicity_func_tinker_mean_normalized_free:
238	* @mt10: a #NcMultiplicityFuncTinkerMeanNormalized
239	*
240	* Atomically decrements the reference count of @mt10 by one. If the reference count drops to 0,
241	* all memory allocated by @mt10 is released.
242	*
243	*/
244	void
245	nc_multiplicity_func_tinker_mean_normalized_free (NcMultiplicityFuncTinkerMeanNormalized *mt10)	×
246	{
247	g_object_unref (mt10);	×
248	}
249
250	/**
251	* nc_multiplicity_func_tinker_mean_normalized_clear:
252	* @mt10: a #NcMultiplicityFuncTinkerMeanNormalized
253	*
254	* Atomically decrements the reference count of @mt10 by one. If the reference count drops to 0,
255	* all memory allocated by @mt10 is released. Set the pointer to NULL;
256	*
257	*/
258	void
259	nc_multiplicity_func_tinker_mean_normalized_clear (NcMultiplicityFuncTinkerMeanNormalized **mt10)	×
260	{
261	g_clear_object (mt10);	×
262	}
263
264	/**
265	* nc_multiplicity_func_tinker_mean_normalized_set_Delta:
266	* @mt10: a #NcMultiplicityFuncTinkerMeanNormalized.
267	* @Delta: value of #NcMultiplicityFuncTinkerMeanNormalized:Delta.
268	*
269	* Sets the value @Delta to the #NcMultiplicityFuncTinkerMeanNormalized:Delta property.
270	*
271	*/
272	static void
273	_nc_multiplicity_func_tinker_mean_normalized_set_Delta (NcMultiplicityFunc *mulf, gdouble Delta)	×
274	{
275	NcMultiplicityFuncTinkerMeanNormalized *mt10 = NC_MULTIPLICITY_FUNC_TINKER_MEAN_NORMALIZED (mulf);	×
276	NcMultiplicityFuncTinkerMeanNormalizedPrivate * const self = mt10->priv;	×
277
278	const guint int_Delta = Delta;	×
279	g_assert (Delta >= 0);	×
280	g_assert (Delta == int_Delta);	×
281
282	self->Delta = Delta;	×
283	self->int_Delta = int_Delta;	×
284
285	switch (self->int_Delta)	×
286	{
287	case 200:	×
288	self->alpha = 0.368;	×
289	self->beta = 0.589;	×
290	self->phi = -0.729;	×
291	self->eta = -0.243;	×
292	self->gamma = 0.864;	×
293	break;	×
294	case 300:	×
295	self->alpha = 0.363;	×
296	self->beta = 0.585;	×
297	self->phi = -0.789;	×
298	self->eta = -0.261;	×
299	self->gamma = 0.922;	×
300	break;	×
301	case 400:	×
302	self->alpha = 0.385;	×
303	self->beta = 0.544;	×
304	self->phi = -0.910;	×
305	self->eta = -0.261;	×
306	self->gamma = 0.987;	×
307	break;	×
308	case 600:	×
309	self->alpha = 0.389;	×
310	self->beta = 0.543;	×
311	self->phi = -1.05;	×
312	self->eta = -0.273;	×
313	self->gamma = 1.09;	×
314	break;	×
315	case 800:	×
316	self->alpha = 0.393;	×
317	self->beta = 0.564;	×
318	self->phi = -1.20;	×
319	self->eta = -0.278;	×
320	self->gamma = 1.20;	×
321	break;	×
322	case 1200:	×
323	self->alpha = 0.365;	×
324	self->beta = 0.623;	×
325	self->phi = -1.26;	×
326	self->eta = -0.301;	×
327	self->gamma = 1.34;	×
328	break;	×
329	case 1600:	×
330	self->alpha = 0.379;	×
331	self->beta = 0.637;	×
332	self->phi = -1.45;	×
333	self->eta = -0.301;	×
334	self->gamma = 1.50;	×
335	break;	×
336	case 2400:	×
337	self->alpha = 0.355;	×
338	self->beta = 0.673;	×
339	self->phi = -1.50;	×
340	self->eta = -0.319;	×
341	self->gamma = 1.68;	×
342	break;	×
343	case 3200:	×
344	self->alpha = 0.327;	×
345	self->beta = 0.702;	×
346	self->phi = -1.49;	×
347	self->eta = -0.336;	×
348	self->gamma = 1.81;	×
349	break;	×
350	default:	×
UNCOV 351	g_error ("NcMultiplicityFuncTinkerMeanNormalized: Delta == %u not supported.", self->int_Delta);	×
352	break;
353	}
354
355	}
356
357	/**
358	* nc_multiplicity_func_tinker_mean_normalized_get_Delta:
359	* @mt10: a #NcMultiplicityFuncTinkerMeanNormalized.
360	*
361	* Returns: the value of #NcMultiplicityFuncTinkerMeanNormalized:Delta property.
362	*/
363	static gdouble
364	_nc_multiplicity_func_tinker_mean_normalized_get_Delta (NcMultiplicityFunc *mulf)	×
365	{
366	NcMultiplicityFuncTinkerMeanNormalized *mt10 = NC_MULTIPLICITY_FUNC_TINKER_MEAN_NORMALIZED (mulf);	×
367	NcMultiplicityFuncTinkerMeanNormalizedPrivate * const self = mt10->priv;	×
368
369	return self->Delta;	×
370	}
371
372

NumCosmo / NumCosmo / 7064254510

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