7079494986

Committed 03 Dec 2023 09:32PM UTC coverage: 54.552% (-0.1%) from 54.681%

Build # 7079494986

Build Type

Pull #117

github

Committed by

web-flow

Commit Message

Merge 57d63d504 into 2daee4060

Pull Request Pull Request #117: Adding interface to nc_cluster_mass_ascaso to compute mean and variances

Run Details

7094 of 12406 branches covered (0.0%)

Branch coverage included in aggregate %.

63 of 340 new or added lines in 6 files covered. (18.53%)

9 existing lines in 5 files now uncovered.

46850 of 86480 relevant lines covered (54.17%)

1838688.35 hits per line

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

12.0

/numcosmo/data/nc_data_cluster_mass_rich.c

/***************************************************************************
 *            nc_data_cluster_mass_rich.c
 *
 *  Tue Oct 24 22:22:00 2023
 *  Copyright  2023  Sandro Dias Pinto Vitenti
 *  <vitenti@uel.br>
 ****************************************************************************/
/*
 * nc_data_cluster_mass_rich.c
 * Copyright (C) 2023 Sandro Dias Pinto Vitenti <vitenti@uel.br>
 *
 * 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_data_cluster_mass_rich
 * @title: NcDataClusterMassRich
 * @short_description: Cluster mass richness data object
 * @stability: Stable
 *
 * #NcDataClusterMassRich is a data object that contains the information about a cluster
 * mass richness data. Its main purpose is to be used as a data object for
 * fitting mass richness proxy models.
 *
 */

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

#include "data/nc_data_cluster_mass_rich.h"
#include "lss/nc_cluster_mass_ascaso.h"
#include "lss/nc_cluster_mass_lnrich_ext.h"

#include "math/ncm_cfg.h"
#include "math/ncm_util.h"
#include "math/ncm_integrate.h"
#include "math/ncm_memory_pool.h"

typedef struct _NcDataClusterMassRichPrivate
{
  NcmVector *z_cluster;
  NcmVector *lnM_cluster;
  NcmVector *lnR_cluster;
} NcDataClusterMassRichPrivate;

enum
{
  PROP_0,
  PROP_Z_CLUSTER,
  PROP_LNM_CLUSTER,
  PROP_LNR_CLUSTER,
  PROP_SIZE,
};

struct _NcDataClusterMassRich
{
  NcmData parent_instance;
};

G_DEFINE_TYPE_WITH_PRIVATE (NcDataClusterMassRich, nc_data_cluster_mass_rich, NCM_TYPE_DATA);

static void
nc_data_cluster_mass_rich_init (NcDataClusterMassRich *dmr)
{
  NcDataClusterMassRichPrivate * const self = nc_data_cluster_mass_rich_get_instance_private (dmr);

  self->z_cluster   = NULL;
  self->lnM_cluster = NULL;
  self->lnR_cluster = NULL;
}

static void
nc_data_cluster_mass_rich_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
{
  NcDataClusterMassRich *dmr                = NC_DATA_CLUSTER_MASS_RICH (object);
  NcDataClusterMassRichPrivate * const self = nc_data_cluster_mass_rich_get_instance_private (dmr);

  g_return_if_fail (NC_IS_DATA_CLUSTER_MASS_RICH (object));

  switch (prop_id)
  {
    case PROP_Z_CLUSTER:
      ncm_vector_clear (&self->z_cluster);
      self->z_cluster = g_value_dup_object (value);
      break;
    case PROP_LNM_CLUSTER:
      ncm_vector_clear (&self->lnM_cluster);
      self->lnM_cluster = g_value_dup_object (value);
      break;
    case PROP_LNR_CLUSTER:
      ncm_vector_clear (&self->lnR_cluster);
      self->lnR_cluster = g_value_dup_object (value);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static void
nc_data_cluster_mass_rich_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
  NcDataClusterMassRich *dmr                = NC_DATA_CLUSTER_MASS_RICH (object);
  NcDataClusterMassRichPrivate * const self = nc_data_cluster_mass_rich_get_instance_private (dmr);

  g_return_if_fail (NC_IS_DATA_CLUSTER_MASS_RICH (object));

  switch (prop_id)
  {
    case PROP_Z_CLUSTER:
      g_value_set_object (value, self->z_cluster);
      break;
    case PROP_LNM_CLUSTER:
      g_value_set_object (value, self->lnM_cluster);
      break;
    case PROP_LNR_CLUSTER:
      g_value_set_object (value, self->lnR_cluster);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static void
nc_data_cluster_mass_rich_dispose (GObject *object)
{
  NcDataClusterMassRich *dmr                = NC_DATA_CLUSTER_MASS_RICH (object);
  NcDataClusterMassRichPrivate * const self = nc_data_cluster_mass_rich_get_instance_private (dmr);

  ncm_vector_clear (&self->z_cluster);
  ncm_vector_clear (&self->lnM_cluster);
  ncm_vector_clear (&self->lnR_cluster);

  /* Chain up : end */
  G_OBJECT_CLASS (nc_data_cluster_mass_rich_parent_class)->dispose (object);
}

static void
nc_data_cluster_mass_rich_finalize (GObject *object)
{
  /*NcDataClusterMassRich *dmr = NC_DATA_CLUSTER_MASS_RICH (object);*/

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

static guint _nc_data_cluster_mass_rich_get_length (NcmData *data);
static guint _nc_data_cluster_mass_rich_get_dof (NcmData *data);
static void _nc_data_cluster_mass_rich_m2lnL_val (NcmData *data, NcmMSet *mset, gdouble *m2lnL);
static void _nc_data_cluster_mass_rich_prepare (NcmData *data, NcmMSet *mset);

static void
nc_data_cluster_mass_rich_class_init (NcDataClusterMassRichClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
  NcmDataClass *data_class   = NCM_DATA_CLASS (klass);

  object_class->set_property = nc_data_cluster_mass_rich_set_property;
  object_class->get_property = nc_data_cluster_mass_rich_get_property;
  object_class->dispose      = nc_data_cluster_mass_rich_dispose;
  object_class->finalize     = nc_data_cluster_mass_rich_finalize;

  g_object_class_install_property (object_class,
                                   PROP_Z_CLUSTER,
                                   g_param_spec_object ("z-cluster",
                                                        NULL,
                                                        "Clusters (halo) redshift array",
                                                        NCM_TYPE_VECTOR,
                                                        G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB));
  g_object_class_install_property (object_class,
                                   PROP_LNM_CLUSTER,
                                   g_param_spec_object ("lnM-cluster",
                                                        NULL,
                                                        "Clusters (halo) ln-mass array",
                                                        NCM_TYPE_VECTOR,
                                                        G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB));

  g_object_class_install_property (object_class,
                                   PROP_LNR_CLUSTER,
                                   g_param_spec_object ("lnR-cluster",
                                                        NULL,
                                                        "Clusters (halo) ln-richness array",
                                                        NCM_TYPE_VECTOR,
                                                        G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB));

  data_class->bootstrap  = FALSE;
  data_class->get_length = &_nc_data_cluster_mass_rich_get_length;
  data_class->get_dof    = &_nc_data_cluster_mass_rich_get_dof;
  data_class->m2lnL_val  = &_nc_data_cluster_mass_rich_m2lnL_val;
  data_class->prepare    = &_nc_data_cluster_mass_rich_prepare;
}

static guint
_nc_data_cluster_mass_rich_get_length (NcmData *data)
{
  NcDataClusterMassRich *dmr                = NC_DATA_CLUSTER_MASS_RICH (data);
  NcDataClusterMassRichPrivate * const self = nc_data_cluster_mass_rich_get_instance_private (dmr);

  return ncm_vector_len (self->z_cluster);
}

static guint
_nc_data_cluster_mass_rich_get_dof (NcmData *data)
{
  return _nc_data_cluster_mass_rich_get_length (data);
}

static void
_nc_data_cluster_mass_rich_m2lnL_val (NcmData *data, NcmMSet *mset, gdouble *m2lnL)
{
  NcDataClusterMassRich *dmr                = NC_DATA_CLUSTER_MASS_RICH (data);
  NcDataClusterMassRichPrivate * const self = nc_data_cluster_mass_rich_get_instance_private (dmr);
  NcClusterMass *cluster_mass               = NC_CLUSTER_MASS (ncm_mset_peek (mset, nc_cluster_mass_id ()));
  register gdouble local_m2lnL              = 0.0;

  if (NC_IS_CLUSTER_MASS_ASCASO (cluster_mass))
  {
    NcClusterMassAscaso *ascaso = NC_CLUSTER_MASS_ASCASO (ncm_mset_peek (mset, nc_cluster_mass_id ()));
    const guint ncluster        = ncm_vector_len (self->z_cluster);
    guint i;

    for (i = 0; i < ncluster; i++)
    {
      const gdouble z_i        = ncm_vector_get (self->z_cluster, i);
      const gdouble lnM_i      = ncm_vector_get (self->lnM_cluster, i);
      const gdouble lnR_i      = ncm_vector_get (self->lnR_cluster, i);
      const gdouble lnR_i_mean = nc_cluster_mass_ascaso_get_mean_richness (ascaso, lnM_i, z_i);
      const gdouble lnR_i_std  = nc_cluster_mass_ascaso_get_std_richness (ascaso, lnM_i, z_i);
      const gdouble lnR_cut_i  = nc_cluster_mass_ascaso_get_cut (ascaso, lnM_i, z_i);

      if (lnR_i > lnR_cut_i)
      {
        local_m2lnL = GSL_POSINF;
        break;
      }

      local_m2lnL += gsl_pow_2 ((lnR_i - lnR_i_mean) / lnR_i_std)
                     + 2.0 * log (lnR_i_std)
                     + 2.0 * log1p (erf ((lnR_cut_i - lnR_i_mean) / (M_SQRT2 * lnR_i_std)));
    }
  }
  else if (NC_IS_CLUSTER_MASS_LNRICH_EXT (cluster_mass))
  {
    NcClusterMassLnrichExt *lnrich_ext = NC_CLUSTER_MASS_LNRICH_EXT (ncm_mset_peek (mset, nc_cluster_mass_id ()));
    const guint ncluster               = ncm_vector_len (self->z_cluster);
    guint i;

    for (i = 0; i < ncluster; i++)
    {
      const gdouble z_i        = ncm_vector_get (self->z_cluster, i);
      const gdouble lnM_i      = ncm_vector_get (self->lnM_cluster, i);
      const gdouble lnR_i      = ncm_vector_get (self->lnR_cluster, i);
      const gdouble lnR_i_mean = nc_cluster_mass_lnrich_ext_get_mean_richness (lnrich_ext, lnM_i, z_i);
      const gdouble lnR_i_std  = nc_cluster_mass_lnrich_ext_get_std_richness (lnrich_ext, lnM_i, z_i);
      const gdouble lnR_cut_i  = nc_cluster_mass_lnrich_ext_get_cut (lnrich_ext, lnM_i, z_i);

      if (lnR_i > lnR_cut_i)
      {
        local_m2lnL = GSL_POSINF;
        break;
      }

      local_m2lnL += gsl_pow_2 ((lnR_i - lnR_i_mean) / lnR_i_std)
                     + 2.0 * log (lnR_i_std)
                     + 2.0 * log1p (erf ((lnR_cut_i - lnR_i_mean) / (M_SQRT2 * lnR_i_std)));
    }
  }
  else
  {
    g_error ("nc_data_cluster_mass_rich_mean_func: unsupported cluster mass model");
  }

  *m2lnL = local_m2lnL;
}

static void
_nc_data_cluster_mass_rich_prepare (NcmData *data, NcmMSet *mset)
{
  /*NcDataClusterMassRich *dmr               = NC_DATA_CLUSTER_MASS_RICH (data);*/
  NcClusterMass *cmass = NC_CLUSTER_MASS (ncm_mset_peek (mset, nc_cluster_mass_id ()));

  /* Currently only compatible with #NcClusterMassAscaso */
  g_assert (NC_IS_CLUSTER_MASS_ASCASO (cmass) || NC_IS_CLUSTER_MASS_LNRICH_EXT (cmass));
}

/**
 * nc_data_cluster_mass_rich_new:
 *
 * Creates a new #NcDataClusterMassRich.
 *
 * Returns: the newly created #NcDataClusterMassRich.
 */
NcDataClusterMassRich *
nc_data_cluster_mass_rich_new (void)
{
  NcDataClusterMassRich *dmr = g_object_new (NC_TYPE_DATA_CLUSTER_MASS_RICH,
                                             NULL);

  return dmr;
}

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

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

/**
 * nc_data_cluster_mass_rich_clear:
 * @dmr: a #NcDataClusterMassRich
 *
 * If @dmr is not %NULL, unrefs it and sets the pointer to %NULL.
 *
 */
void
nc_data_cluster_mass_rich_clear (NcDataClusterMassRich **dmr)
{
  g_clear_object (dmr);
}

/**
 * nc_data_cluster_mass_rich_set_data:
 * @dmr: a #NcDataClusterMassRich
 * @lnM: a #NcmVector
 * @z: a #NcmVector
 * @lnR: a #NcmVector
 *
 * Sets the data of @dmr.
 *
 */
void
nc_data_cluster_mass_rich_set_data (NcDataClusterMassRich *dmr, NcmVector *lnM, NcmVector *z, NcmVector *lnR)
{
  NcDataClusterMassRichPrivate * const self = nc_data_cluster_mass_rich_get_instance_private (dmr);
  const guint len                           = ncm_vector_len (lnM);

  if ((len != ncm_vector_len (z)) || (len != ncm_vector_len (lnR)))
  {
    g_error ("nc_data_cluster_mass_rich_set_data: lnM, z and lnR must have the same length");

    return;
  }

  ncm_vector_clear (&self->z_cluster);
  ncm_vector_clear (&self->lnM_cluster);
  ncm_vector_clear (&self->lnR_cluster);

  self->z_cluster   = ncm_vector_dup (z);
  self->lnM_cluster = ncm_vector_dup (lnM);
  self->lnR_cluster = ncm_vector_dup (lnR);

  ncm_data_set_init (NCM_DATA (dmr), TRUE);
}


1	/***************************************************************************
2	* nc_data_cluster_mass_rich.c
3	*
4	* Tue Oct 24 22:22:00 2023
5	* Copyright 2023 Sandro Dias Pinto Vitenti
6	* <vitenti@uel.br>
7	****************************************************************************/
8	/*
9	* nc_data_cluster_mass_rich.c
10	* Copyright (C) 2023 Sandro Dias Pinto Vitenti <vitenti@uel.br>
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_data_cluster_mass_rich
28	* @title: NcDataClusterMassRich
29	* @short_description: Cluster mass richness data object
30	* @stability: Stable
31	*
32	* #NcDataClusterMassRich is a data object that contains the information about a cluster
33	* mass richness data. Its main purpose is to be used as a data object for
34	* fitting mass richness proxy models.
35	*
36	*/
37
38	#ifdef HAVE_CONFIG_H
39	# include "config.h"
40	#endif /* HAVE_CONFIG_H */
41	#include "build_cfg.h"
42
43	#include "data/nc_data_cluster_mass_rich.h"
44	#include "lss/nc_cluster_mass_ascaso.h"
45	#include "lss/nc_cluster_mass_lnrich_ext.h"
46
47	#include "math/ncm_cfg.h"
48	#include "math/ncm_util.h"
49	#include "math/ncm_integrate.h"
50	#include "math/ncm_memory_pool.h"
51
52	typedef struct _NcDataClusterMassRichPrivate
53	{
54	NcmVector *z_cluster;
55	NcmVector *lnM_cluster;
56	NcmVector *lnR_cluster;
57	} NcDataClusterMassRichPrivate;
58
59	enum
60	{
61	PROP_0,
62	PROP_Z_CLUSTER,
63	PROP_LNM_CLUSTER,
64	PROP_LNR_CLUSTER,
65	PROP_SIZE,
66	};
67
68	struct _NcDataClusterMassRich
69	{
70	NcmData parent_instance;
71	};
72
73	G_DEFINE_TYPE_WITH_PRIVATE (NcDataClusterMassRich, nc_data_cluster_mass_rich, NCM_TYPE_DATA);	12✔
74
75	static void
NEW 76	nc_data_cluster_mass_rich_init (NcDataClusterMassRich *dmr)	×
77	{
NEW 78	NcDataClusterMassRichPrivate * const self = nc_data_cluster_mass_rich_get_instance_private (dmr);	×
79
NEW 80	self->z_cluster = NULL;	×
NEW 81	self->lnM_cluster = NULL;	×
NEW 82	self->lnR_cluster = NULL;	×
83	}
84
85	static void
NEW 86	nc_data_cluster_mass_rich_set_property (GObject object, guint prop_id, const GValue value, GParamSpec *pspec)	×
87	{
NEW 88	NcDataClusterMassRich *dmr = NC_DATA_CLUSTER_MASS_RICH (object);	×
NEW 89	NcDataClusterMassRichPrivate * const self = nc_data_cluster_mass_rich_get_instance_private (dmr);	×
90
NEW 91	g_return_if_fail (NC_IS_DATA_CLUSTER_MASS_RICH (object));	×
92
NEW 93	switch (prop_id)	×
94	{
NEW 95	case PROP_Z_CLUSTER:	×
NEW 96	ncm_vector_clear (&self->z_cluster);	×
NEW 97	self->z_cluster = g_value_dup_object (value);	×
NEW 98	break;	×
NEW 99	case PROP_LNM_CLUSTER:	×
NEW 100	ncm_vector_clear (&self->lnM_cluster);	×
NEW 101	self->lnM_cluster = g_value_dup_object (value);	×
NEW 102	break;	×
NEW 103	case PROP_LNR_CLUSTER:	×
NEW 104	ncm_vector_clear (&self->lnR_cluster);	×
NEW 105	self->lnR_cluster = g_value_dup_object (value);	×
NEW 106	break;	×
NEW 107	default:	×
NEW 108	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);	×
NEW 109	break;	×
110	}
111	}
112
113	static void
NEW 114	nc_data_cluster_mass_rich_get_property (GObject object, guint prop_id, GValue value, GParamSpec *pspec)	×
115	{
NEW 116	NcDataClusterMassRich *dmr = NC_DATA_CLUSTER_MASS_RICH (object);	×
NEW 117	NcDataClusterMassRichPrivate * const self = nc_data_cluster_mass_rich_get_instance_private (dmr);	×
118
NEW 119	g_return_if_fail (NC_IS_DATA_CLUSTER_MASS_RICH (object));	×
120
NEW 121	switch (prop_id)	×
122	{
NEW 123	case PROP_Z_CLUSTER:	×
NEW 124	g_value_set_object (value, self->z_cluster);	×
NEW 125	break;	×
NEW 126	case PROP_LNM_CLUSTER:	×
NEW 127	g_value_set_object (value, self->lnM_cluster);	×
NEW 128	break;	×
NEW 129	case PROP_LNR_CLUSTER:	×
NEW 130	g_value_set_object (value, self->lnR_cluster);	×
NEW 131	break;	×
NEW 132	default:	×
NEW 133	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);	×
NEW 134	break;	×
135	}
136	}
137
138	static void
NEW 139	nc_data_cluster_mass_rich_dispose (GObject *object)	×
140	{
NEW 141	NcDataClusterMassRich *dmr = NC_DATA_CLUSTER_MASS_RICH (object);	×
NEW 142	NcDataClusterMassRichPrivate * const self = nc_data_cluster_mass_rich_get_instance_private (dmr);	×
143
NEW 144	ncm_vector_clear (&self->z_cluster);	×
NEW 145	ncm_vector_clear (&self->lnM_cluster);	×
NEW 146	ncm_vector_clear (&self->lnR_cluster);	×
147
148	/* Chain up : end */
NEW 149	G_OBJECT_CLASS (nc_data_cluster_mass_rich_parent_class)->dispose (object);	×
150	}
151
152	static void
NEW 153	nc_data_cluster_mass_rich_finalize (GObject *object)	×
154	{
155	/NcDataClusterMassRich dmr = NC_DATA_CLUSTER_MASS_RICH (object);*/
156
157	/* Chain up : end */
NEW 158	G_OBJECT_CLASS (nc_data_cluster_mass_rich_parent_class)->finalize (object);	×
159	}
160
161	static guint _nc_data_cluster_mass_rich_get_length (NcmData *data);
162	static guint _nc_data_cluster_mass_rich_get_dof (NcmData *data);
163	static void _nc_data_cluster_mass_rich_m2lnL_val (NcmData data, NcmMSet mset, gdouble *m2lnL);
164	static void _nc_data_cluster_mass_rich_prepare (NcmData data, NcmMSet mset);
165
166	static void
167	nc_data_cluster_mass_rich_class_init (NcDataClusterMassRichClass *klass)	2✔
168	{
169	GObjectClass *object_class = G_OBJECT_CLASS (klass);	2✔
170	NcmDataClass *data_class = NCM_DATA_CLASS (klass);	2✔
171
172	object_class->set_property = nc_data_cluster_mass_rich_set_property;	2✔
173	object_class->get_property = nc_data_cluster_mass_rich_get_property;	2✔
174	object_class->dispose = nc_data_cluster_mass_rich_dispose;	2✔
175	object_class->finalize = nc_data_cluster_mass_rich_finalize;	2✔
176
177	g_object_class_install_property (object_class,	2✔
178	PROP_Z_CLUSTER,
179	g_param_spec_object ("z-cluster",
180	NULL,
181	"Clusters (halo) redshift array",
182	NCM_TYPE_VECTOR,
183	G_PARAM_READWRITE \| G_PARAM_STATIC_NAME \| G_PARAM_STATIC_BLURB));
184	g_object_class_install_property (object_class,	2✔
185	PROP_LNM_CLUSTER,
186	g_param_spec_object ("lnM-cluster",
187	NULL,
188	"Clusters (halo) ln-mass array",
189	NCM_TYPE_VECTOR,
190	G_PARAM_READWRITE \| G_PARAM_STATIC_NAME \| G_PARAM_STATIC_BLURB));
191
192	g_object_class_install_property (object_class,	2✔
193	PROP_LNR_CLUSTER,
194	g_param_spec_object ("lnR-cluster",
195	NULL,
196	"Clusters (halo) ln-richness array",
197	NCM_TYPE_VECTOR,
198	G_PARAM_READWRITE \| G_PARAM_STATIC_NAME \| G_PARAM_STATIC_BLURB));
199
200	data_class->bootstrap = FALSE;	2✔
201	data_class->get_length = &_nc_data_cluster_mass_rich_get_length;	2✔
202	data_class->get_dof = &_nc_data_cluster_mass_rich_get_dof;	2✔
203	data_class->m2lnL_val = &_nc_data_cluster_mass_rich_m2lnL_val;	2✔
204	data_class->prepare = &_nc_data_cluster_mass_rich_prepare;	2✔
205	}	2✔
206
207	static guint
NEW 208	_nc_data_cluster_mass_rich_get_length (NcmData *data)	×
209	{
NEW 210	NcDataClusterMassRich *dmr = NC_DATA_CLUSTER_MASS_RICH (data);	×
NEW 211	NcDataClusterMassRichPrivate * const self = nc_data_cluster_mass_rich_get_instance_private (dmr);	×
212
NEW 213	return ncm_vector_len (self->z_cluster);	×
214	}
215
216	static guint
NEW 217	_nc_data_cluster_mass_rich_get_dof (NcmData *data)	×
218	{
NEW 219	return _nc_data_cluster_mass_rich_get_length (data);	×
220	}
221
222	static void
NEW 223	_nc_data_cluster_mass_rich_m2lnL_val (NcmData data, NcmMSet mset, gdouble *m2lnL)	×
224	{
NEW 225	NcDataClusterMassRich *dmr = NC_DATA_CLUSTER_MASS_RICH (data);	×
NEW 226	NcDataClusterMassRichPrivate * const self = nc_data_cluster_mass_rich_get_instance_private (dmr);	×
NEW 227	NcClusterMass *cluster_mass = NC_CLUSTER_MASS (ncm_mset_peek (mset, nc_cluster_mass_id ()));	×
NEW 228	register gdouble local_m2lnL = 0.0;	×
229
NEW 230	if (NC_IS_CLUSTER_MASS_ASCASO (cluster_mass))	×
231	{
NEW 232	NcClusterMassAscaso *ascaso = NC_CLUSTER_MASS_ASCASO (ncm_mset_peek (mset, nc_cluster_mass_id ()));	×
NEW 233	const guint ncluster = ncm_vector_len (self->z_cluster);	×
NEW 234	guint i;	×
235
NEW 236	for (i = 0; i < ncluster; i++)	×
237	{
NEW 238	const gdouble z_i = ncm_vector_get (self->z_cluster, i);	×
NEW 239	const gdouble lnM_i = ncm_vector_get (self->lnM_cluster, i);	×
NEW 240	const gdouble lnR_i = ncm_vector_get (self->lnR_cluster, i);	×
NEW 241	const gdouble lnR_i_mean = nc_cluster_mass_ascaso_get_mean_richness (ascaso, lnM_i, z_i);	×
NEW 242	const gdouble lnR_i_std = nc_cluster_mass_ascaso_get_std_richness (ascaso, lnM_i, z_i);	×
NEW 243	const gdouble lnR_cut_i = nc_cluster_mass_ascaso_get_cut (ascaso, lnM_i, z_i);	×
244
NEW 245	if (lnR_i > lnR_cut_i)	×
246	{
247	local_m2lnL = GSL_POSINF;
248	break;
249	}
250
NEW 251	local_m2lnL += gsl_pow_2 ((lnR_i - lnR_i_mean) / lnR_i_std)	×
NEW 252	+ 2.0 * log (lnR_i_std)	×
NEW 253	+ 2.0 * log1p (erf ((lnR_cut_i - lnR_i_mean) / (M_SQRT2 * lnR_i_std)));	×
254	}
255	}
NEW 256	else if (NC_IS_CLUSTER_MASS_LNRICH_EXT (cluster_mass))	×
257	{
NEW 258	NcClusterMassLnrichExt *lnrich_ext = NC_CLUSTER_MASS_LNRICH_EXT (ncm_mset_peek (mset, nc_cluster_mass_id ()));	×
NEW 259	const guint ncluster = ncm_vector_len (self->z_cluster);	×
NEW 260	guint i;	×
261
NEW 262	for (i = 0; i < ncluster; i++)	×
263	{
NEW 264	const gdouble z_i = ncm_vector_get (self->z_cluster, i);	×
NEW 265	const gdouble lnM_i = ncm_vector_get (self->lnM_cluster, i);	×
NEW 266	const gdouble lnR_i = ncm_vector_get (self->lnR_cluster, i);	×
NEW 267	const gdouble lnR_i_mean = nc_cluster_mass_lnrich_ext_get_mean_richness (lnrich_ext, lnM_i, z_i);	×
NEW 268	const gdouble lnR_i_std = nc_cluster_mass_lnrich_ext_get_std_richness (lnrich_ext, lnM_i, z_i);	×
NEW 269	const gdouble lnR_cut_i = nc_cluster_mass_lnrich_ext_get_cut (lnrich_ext, lnM_i, z_i);	×
270
NEW 271	if (lnR_i > lnR_cut_i)	×
272	{
273	local_m2lnL = GSL_POSINF;
274	break;
275	}
276
NEW 277	local_m2lnL += gsl_pow_2 ((lnR_i - lnR_i_mean) / lnR_i_std)	×
NEW 278	+ 2.0 * log (lnR_i_std)	×
NEW 279	+ 2.0 * log1p (erf ((lnR_cut_i - lnR_i_mean) / (M_SQRT2 * lnR_i_std)));	×
280	}
281	}
282	else
283	{
NEW 284	g_error ("nc_data_cluster_mass_rich_mean_func: unsupported cluster mass model");	×
285	}
286
NEW 287	*m2lnL = local_m2lnL;	×
288	}
289
290	static void
NEW 291	_nc_data_cluster_mass_rich_prepare (NcmData data, NcmMSet mset)	×
292	{
293	/NcDataClusterMassRich dmr = NC_DATA_CLUSTER_MASS_RICH (data);*/
NEW 294	NcClusterMass *cmass = NC_CLUSTER_MASS (ncm_mset_peek (mset, nc_cluster_mass_id ()));	×
295
296	/* Currently only compatible with #NcClusterMassAscaso */
NEW 297	g_assert (NC_IS_CLUSTER_MASS_ASCASO (cmass) \|\| NC_IS_CLUSTER_MASS_LNRICH_EXT (cmass));	×
298	}
299
300	/**
301	* nc_data_cluster_mass_rich_new:
302	*
303	* Creates a new #NcDataClusterMassRich.
304	*
305	* Returns: the newly created #NcDataClusterMassRich.
306	*/
307	NcDataClusterMassRich *
NEW 308	nc_data_cluster_mass_rich_new (void)	×
309	{
NEW 310	NcDataClusterMassRich *dmr = g_object_new (NC_TYPE_DATA_CLUSTER_MASS_RICH,	×
311	NULL);
312
NEW 313	return dmr;	×
314	}
315
316	/**
317	* nc_data_cluster_mass_rich_ref:
318	* @dmr: a #NcDataClusterMassRich
319	*
320	* Increases the reference count of @dmr by one.
321	*
322	* Returns: (transfer full): @dmr
323	*/
324	NcDataClusterMassRich *
NEW 325	nc_data_cluster_mass_rich_ref (NcDataClusterMassRich *dmr)	×
326	{
NEW 327	return g_object_ref (dmr);	×
328	}
329
330	/**
331	* nc_data_cluster_mass_rich_free:
332	* @dmr: a #NcDataClusterMassRich
333	*
334	* Atomically decrements the reference count of @dmr by one. If the reference count drops to 0,
335	* all memory allocated by @dmr is released.
336	*
337	*/
338	void
NEW 339	nc_data_cluster_mass_rich_free (NcDataClusterMassRich *dmr)	×
340	{
NEW 341	g_object_unref (dmr);	×
342	}
343
344	/**
345	* nc_data_cluster_mass_rich_clear:
346	* @dmr: a #NcDataClusterMassRich
347	*
348	* If @dmr is not %NULL, unrefs it and sets the pointer to %NULL.
349	*
350	*/
351	void
NEW 352	nc_data_cluster_mass_rich_clear (NcDataClusterMassRich **dmr)	×
353	{
NEW 354	g_clear_object (dmr);	×
355	}
356
357	/**
358	* nc_data_cluster_mass_rich_set_data:
359	* @dmr: a #NcDataClusterMassRich
360	* @lnM: a #NcmVector
361	* @z: a #NcmVector
362	* @lnR: a #NcmVector
363	*
364	* Sets the data of @dmr.
365	*
366	*/
367	void
NEW 368	nc_data_cluster_mass_rich_set_data (NcDataClusterMassRich dmr, NcmVector lnM, NcmVector z, NcmVector lnR)	×
369	{
NEW 370	NcDataClusterMassRichPrivate * const self = nc_data_cluster_mass_rich_get_instance_private (dmr);	×
NEW 371	const guint len = ncm_vector_len (lnM);	×
372
NEW 373	if ((len != ncm_vector_len (z)) \|\| (len != ncm_vector_len (lnR)))	×
374	{
NEW 375	g_error ("nc_data_cluster_mass_rich_set_data: lnM, z and lnR must have the same length");	×
376
377	return;
378	}
379
NEW 380	ncm_vector_clear (&self->z_cluster);	×
NEW 381	ncm_vector_clear (&self->lnM_cluster);	×
NEW 382	ncm_vector_clear (&self->lnR_cluster);	×
383
NEW 384	self->z_cluster = ncm_vector_dup (z);	×
NEW 385	self->lnM_cluster = ncm_vector_dup (lnM);	×
NEW 386	self->lnR_cluster = ncm_vector_dup (lnR);	×
387
NEW 388	ncm_data_set_init (NCM_DATA (dmr), TRUE);	×
389	}
390

NumCosmo / NumCosmo / 7079494986

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