7270201403

Committed 20 Dec 2023 02:22AM UTC coverage: 55.267% (+0.3%) from 54.995%

Build # 7270201403

Build Type

Pull #126

github

Committed by

web-flow

Commit Message

Merge 8fa1d11cd into bffca6a86

Pull Request Pull Request #126: More objects encapsulation

Run Details

7274 of 12547 branches covered (0.0%)

Branch coverage included in aggregate %.

2533 of 3911 new or added lines in 169 files covered. (64.77%)

148 existing lines in 31 files now uncovered.

47900 of 87284 relevant lines covered (54.88%)

2116860.51 hits per line

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

13.02

/numcosmo/model/nc_hicosmo_de_wspline.c

/***************************************************************************
 *            nc_hicosmo_de_wspline.c
 *
 *  Mon Oct 11 16:22:12 2021
 *  Copyright  2021  Sandro Dias Pinto Vitenti
 *  <vitenti@uel.br>
 *  Copyright  2021  Sanderson Carlos Ribeiro
 *  <sander23.ribeiro@uel.br>
 ****************************************************************************/
/*
 * numcosmo
 * Copyright (C) Sandro Dias Pinto Vitenti 2021 <vitenti@uel.br>
 * Copyright (C) Sanderson Carlos Ribeiro 2021 <sander23.ribeiro@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_hicosmo_de_wspline
 * @title: NcHICosmoDEWSpline
 * @short_description: Dark Energy -- spline equation of state
 *
 * Dark Energy equation of state: $w(\alpha)$ approximated by a cubic spline.
 *
 */

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

#include "model/nc_hicosmo_de_wspline.h"
#include "math/ncm_spline_cubic_notaknot.h"
#include "math/ncm_spline_gsl.h"

struct _NcHICosmoDEWSplinePrivate
{
  guint nknots;
  guint size;
  gdouble z_1;
  gdouble z_f;
  gdouble alpha_f;
  gdouble w_f;
  gdouble int_f;
  NcmSpline *w_alpha;
};

G_DEFINE_TYPE_WITH_PRIVATE (NcHICosmoDEWSpline, nc_hicosmo_de_wspline, NC_TYPE_HICOSMO_DE)

enum
{
  PROP_0,
  PROP_Z_1,
  PROP_Z_F,
  PROP_SIZE,
};

static void
nc_hicosmo_de_wspline_init (NcHICosmoDEWSpline *wspline)
{
  NcHICosmoDEWSplinePrivate * const self = wspline->priv = nc_hicosmo_de_wspline_get_instance_private (wspline);

  self->nknots  = 0;
  self->size    = 0;
  self->z_1     = 0.0;
  self->z_f     = 0.0;
  self->alpha_f = 0.0;
  self->w_f     = 0.0;
  self->int_f   = 0.0;
  self->w_alpha = NULL;
}

static void
_nc_hicosmo_de_wspline_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
  NcHICosmoDEWSpline *wspline            = NC_HICOSMO_DE_WSPLINE (object);
  NcHICosmoDEWSplinePrivate * const self = wspline->priv;

  g_return_if_fail (NC_IS_HICOSMO_DE_WSPLINE (object));

  switch (prop_id)
  {
    case PROP_Z_1:
      g_value_set_double (value, self->z_1);
      break;
    case PROP_Z_F:
      g_value_set_double (value, self->z_f);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static void
_nc_hicosmo_de_wspline_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
{
  NcHICosmoDEWSpline *wspline            = NC_HICOSMO_DE_WSPLINE (object);
  NcHICosmoDEWSplinePrivate * const self = wspline->priv;

  g_return_if_fail (NC_IS_HICOSMO_DE_WSPLINE (object));

  switch (prop_id)
  {
    case PROP_Z_1:
      self->z_1 = g_value_get_double (value);
      break;
    case PROP_Z_F:
      self->z_f = g_value_get_double (value);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static void
_nc_hicosmo_de_wspline_constructed (GObject *object)
{
  /* Chain up : start */
  G_OBJECT_CLASS (nc_hicosmo_de_wspline_parent_class)->constructed (object);
  {
    NcHICosmoDEWSpline *wspline            = NC_HICOSMO_DE_WSPLINE (object);
    NcHICosmoDEWSplinePrivate * const self = wspline->priv;
    NcmModel *model                        = NCM_MODEL (wspline);
    NcmVector *orig_vec                    = ncm_model_orig_params_peek_vector (model);
    NcmModelClass *model_class             = NCM_MODEL_GET_CLASS (model);
    guint wz_size                          = ncm_model_vparam_len (model, NC_HICOSMO_DE_WSPLINE_W);
    const gdouble alpha1                   = log1p (self->z_1);
    const gdouble alphaf                   = log1p (self->z_f);
    NcmVector *alphav, *wv;
    guint i, wvi;

    self->nknots  = wz_size;
    self->size    = model_class->sparam_len + self->nknots;
    self->alpha_f = alphaf * (1.0 - GSL_DBL_EPSILON);

    g_assert_cmpuint (wz_size, >, 2);

    wvi = ncm_model_vparam_index (model, NC_HICOSMO_DE_WSPLINE_W, 0);

    alphav = ncm_vector_new (wz_size);
    wv     = ncm_vector_get_subvector (orig_vec, wvi, wz_size);

    ncm_vector_set (alphav, 0, 0.0);
    ncm_vector_set (alphav, 1, alpha1);

    {
      const gdouble dalpha = (log (alphaf) - log (alpha1)) / (wz_size - 2);

      for (i = 0; i < wz_size - 2; i++)
      {
        const gdouble alpha = alpha1 * exp (dalpha * (i + 1.0));

        ncm_vector_set (alphav, 2 + i, alpha);
      }
    }

    {
      NcmSpline *s;

      if (self->nknots >= 6)
        s = ncm_spline_cubic_notaknot_new ();
      else
        s = ncm_spline_gsl_new (gsl_interp_polynomial);

      self->w_alpha = ncm_spline_new (s, alphav, wv, TRUE);

      ncm_spline_free (s);
      ncm_vector_free (alphav);
      ncm_vector_free (wv);
    }
  }
}

static void
_nc_hicosmo_de_wspline_dispose (GObject *object)
{
  NcHICosmoDEWSpline *wspline            = NC_HICOSMO_DE_WSPLINE (object);
  NcHICosmoDEWSplinePrivate * const self = wspline->priv;

  ncm_spline_clear (&self->w_alpha);

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

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

static gdouble _nc_hicosmo_de_wspline_E2Omega_de (NcHICosmoDE *cosmo_de, gdouble z);
static gdouble _nc_hicosmo_de_wspline_dE2Omega_de_dz (NcHICosmoDE *cosmo_de, gdouble z);
static gdouble _nc_hicosmo_de_wspline_d2E2Omega_de_dz2 (NcHICosmoDE *cosmo_de, gdouble z);
static gdouble _nc_hicosmo_de_wspline_w_de (NcHICosmoDE *cosmo_de, gdouble z);

static void
nc_hicosmo_de_wspline_class_init (NcHICosmoDEWSplineClass *klass)
{
  GObjectClass *object_class     = G_OBJECT_CLASS (klass);
  NcHICosmoDEClass *parent_class = NC_HICOSMO_DE_CLASS (klass);
  NcmModelClass *model_class     = NCM_MODEL_CLASS (klass);

  model_class->set_property = &_nc_hicosmo_de_wspline_set_property;
  model_class->get_property = &_nc_hicosmo_de_wspline_get_property;
  object_class->constructed = &_nc_hicosmo_de_wspline_constructed;
  object_class->dispose     = &_nc_hicosmo_de_wspline_dispose;
  object_class->finalize    = &_nc_hicosmo_de_wspline_finalize;

  ncm_model_class_set_name_nick (model_class, "XCDM - Constant EOS", "XCDM");
  ncm_model_class_add_params (model_class, 0,
                              NC_HICOSMO_DE_WSPLINE_VPARAM_LEN - NC_HICOSMO_DE_VPARAM_LEN,
                              PROP_SIZE);

  g_object_class_install_property (object_class,
                                   PROP_Z_1,
                                   g_param_spec_double ("z1",
                                                        NULL,
                                                        "second redshift knot",
                                                        1.0e-3, 0.5, 1.0e-2,
                                                        G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB));

  g_object_class_install_property (object_class,
                                   PROP_Z_F,
                                   g_param_spec_double ("zf",
                                                        NULL,
                                                        "final redshift",
                                                        1.0, 1.0e10, 2.0,
                                                        G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB));

  /* Set w_0 param info */
  ncm_model_class_set_vparam (model_class, NC_HICOSMO_DE_WSPLINE_W, 6, "w", "w",
                              -5.0, 1.0, 1.0e-2,
                              NC_HICOSMO_DEFAULT_PARAMS_ABSTOL, NC_HICOSMO_DE_WSPLINE_DEFAULT_W0,
                              NCM_PARAM_TYPE_FREE);

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

  nc_hicosmo_de_set_E2Omega_de_impl (parent_class, &_nc_hicosmo_de_wspline_E2Omega_de);
  nc_hicosmo_de_set_dE2Omega_de_dz_impl (parent_class, &_nc_hicosmo_de_wspline_dE2Omega_de_dz);
  nc_hicosmo_de_set_d2E2Omega_de_dz2_impl (parent_class, &_nc_hicosmo_de_wspline_d2E2Omega_de_dz2);
  nc_hicosmo_de_set_w_de_impl (parent_class, &_nc_hicosmo_de_wspline_w_de);
}

#define VECTOR (NCM_MODEL (cosmo_de))
#define OMEGA_X (ncm_model_orig_param_get (VECTOR, NC_HICOSMO_DE_OMEGA_X))

static void
_nc_hicosmo_de_wspline_prepare (NcHICosmoDEWSpline *wspline)
{
  NcHICosmoDEWSplinePrivate * const self = wspline->priv;

  if (!ncm_model_lstate_is_update (NCM_MODEL (wspline), 0))
  {
    ncm_spline_prepare (self->w_alpha);

    self->w_f   = ncm_spline_eval (self->w_alpha, self->alpha_f);
    self->int_f = ncm_spline_eval_integ (self->w_alpha, 0.0, self->alpha_f);

    ncm_model_lstate_set_update (NCM_MODEL (wspline), 0);
  }
  else
  {
    return;
  }
}

static gdouble
_nc_hicosmo_de_wspline_E2Omega_de (NcHICosmoDE *cosmo_de, gdouble z)
{
  NcHICosmoDEWSpline *wspline            = NC_HICOSMO_DE_WSPLINE (cosmo_de);
  NcHICosmoDEWSplinePrivate * const self = wspline->priv;

  _nc_hicosmo_de_wspline_prepare (wspline);

  if (z < self->z_f)
  {
    const gdouble alpha = log1p (z);

    return OMEGA_X * exp (3.0 * (alpha + ncm_spline_eval_integ (self->w_alpha, 0.0, alpha)));
  }
  else
  {
    const gdouble alpha = log1p (z);

    return OMEGA_X * exp (3.0 * (alpha + self->int_f + self->w_f * (alpha - self->alpha_f)));
  }
}

static gdouble
_nc_hicosmo_de_wspline_dE2Omega_de_dz (NcHICosmoDE *cosmo_de, gdouble z)
{
  NcHICosmoDEWSpline *wspline            = NC_HICOSMO_DE_WSPLINE (cosmo_de);
  NcHICosmoDEWSplinePrivate * const self = wspline->priv;

  _nc_hicosmo_de_wspline_prepare (wspline);

  if (z < self->z_f)
  {
    const gdouble alpha             = log1p (z);
    const gdouble w                 = ncm_spline_eval (self->w_alpha, alpha);
    const gdouble int_w             = ncm_spline_eval_integ (self->w_alpha, 0.0, alpha);
    const gdouble exp_malpha_OmegaX = OMEGA_X * exp (2.0 * alpha + 3.0 * int_w);

    return 3.0 * (1.0 + w) * exp_malpha_OmegaX;
  }
  else
  {
    const gdouble alpha = log1p (z);

    return OMEGA_X * 3.0 * (1.0 + self->w_f) * exp (2.0 * alpha + 3.0 * (self->int_f + self->w_f * (alpha - self->alpha_f)));
  }
}

static gdouble
_nc_hicosmo_de_wspline_d2E2Omega_de_dz2 (NcHICosmoDE *cosmo_de, gdouble z)
{
  NcHICosmoDEWSpline *wspline            = NC_HICOSMO_DE_WSPLINE (cosmo_de);
  NcHICosmoDEWSplinePrivate * const self = wspline->priv;

  _nc_hicosmo_de_wspline_prepare (wspline);

  if (z < self->z_f)
  {
    const gdouble alpha              = log1p (z);
    const gdouble w                  = ncm_spline_eval (self->w_alpha, alpha);
    const gdouble dw                 = ncm_spline_eval_deriv (self->w_alpha, alpha);
    const gdouble int_w              = ncm_spline_eval_integ (self->w_alpha, 0.0, alpha);
    const gdouble exp_m2alpha_OmegaX = OMEGA_X * exp (1.0 * alpha + 3.0 * int_w);

    return 3.0 * (2.0 + w * (5.0 + 3.0 * w) + dw) * exp_m2alpha_OmegaX;
  }
  else
  {
    const gdouble alpha              = log1p (z);
    const gdouble exp_m2alpha_OmegaX = OMEGA_X * exp (1.0 * alpha + 3.0 * (self->int_f + self->w_f * (alpha - self->alpha_f)));

    return 3.0 * (2.0 + self->w_f * (5.0 + 3.0 * self->w_f)) * exp_m2alpha_OmegaX;
  }
}

static gdouble
_nc_hicosmo_de_wspline_w_de (NcHICosmoDE *cosmo_de, gdouble z)
{
  NcHICosmoDEWSpline *wspline            = NC_HICOSMO_DE_WSPLINE (cosmo_de);
  NcHICosmoDEWSplinePrivate * const self = wspline->priv;

  _nc_hicosmo_de_wspline_prepare (wspline);

  if (z < self->z_f)
  {
    const gdouble alpha = z < self->z_f ? log1p (z) : log1p (self->z_f);
    const gdouble w     = ncm_spline_eval (self->w_alpha, alpha);

    return w;
  }
  else
  {
    return self->w_f;
  }
}

/**
 * nc_hicosmo_de_wspline_new:
 * @nknots: number of knots in the $w(z)$ spline
 * @z_f: redshift $z_f$ of the last knot.
 *
 * This function instantiates a new object of type #NcHICosmoDEWSpline.
 *
 * Returns: A new #NcHICosmoDEWSpline
 */
NcHICosmoDEWSpline *
nc_hicosmo_de_wspline_new (gsize nknots, const gdouble z_f)
{
  NcHICosmoDEWSpline *wspline = g_object_new (NC_TYPE_HICOSMO_DE_WSPLINE,
                                              "zf", z_f,
                                              "w-length", nknots,
                                              NULL);

  return wspline;
}

/**
 * nc_hicosmo_de_wspline_get_alpha:
 * @wspline: a #NcHICosmoDEWSpline
 *
 * Gets vector with the current knots in $\alpha$.
 *
 * Returns: (transfer none): A new #NcmVector
 */
NcmVector *
nc_hicosmo_de_wspline_get_alpha (NcHICosmoDEWSpline *wspline)
{
  NcHICosmoDEWSplinePrivate * const self = wspline->priv;

  return ncm_spline_peek_xv (self->w_alpha);
}


1	/***************************************************************************
2	* nc_hicosmo_de_wspline.c
3	*
4	* Mon Oct 11 16:22:12 2021
5	* Copyright 2021 Sandro Dias Pinto Vitenti
6	* <vitenti@uel.br>
7	* Copyright 2021 Sanderson Carlos Ribeiro
8	* <sander23.ribeiro@uel.br>
9	****************************************************************************/
10	/*
11	* numcosmo
12	* Copyright (C) Sandro Dias Pinto Vitenti 2021 <vitenti@uel.br>
13	* Copyright (C) Sanderson Carlos Ribeiro 2021 <sander23.ribeiro@uel.br>
14	* numcosmo is free software: you can redistribute it and/or modify it
15	* under the terms of the GNU General Public License as published by the
16	* Free Software Foundation, either version 3 of the License, or
17	* (at your option) any later version.
18	*
19	* numcosmo is distributed in the hope that it will be useful, but
20	* WITHOUT ANY WARRANTY; without even the implied warranty of
21	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
22	* See the GNU General Public License for more details.
23	*
24	* You should have received a copy of the GNU General Public License along
25	* with this program. If not, see <http://www.gnu.org/licenses/>.
26	*/
27
28	/**
29	* SECTION:nc_hicosmo_de_wspline
30	* @title: NcHICosmoDEWSpline
31	* @short_description: Dark Energy -- spline equation of state
32	*
33	* Dark Energy equation of state: $w(\alpha)$ approximated by a cubic spline.
34	*
35	*/
36
37	#ifdef HAVE_CONFIG_H
38	# include "config.h"
39	#endif /* HAVE_CONFIG_H */
40	#include "build_cfg.h"
41
42	#include "model/nc_hicosmo_de_wspline.h"
43	#include "math/ncm_spline_cubic_notaknot.h"
44	#include "math/ncm_spline_gsl.h"
45
46	struct _NcHICosmoDEWSplinePrivate
47	{
48	guint nknots;
49	guint size;
50	gdouble z_1;
51	gdouble z_f;
52	gdouble alpha_f;
53	gdouble w_f;
54	gdouble int_f;
55	NcmSpline *w_alpha;
56	};
57
58	G_DEFINE_TYPE_WITH_PRIVATE (NcHICosmoDEWSpline, nc_hicosmo_de_wspline, NC_TYPE_HICOSMO_DE)	672✔
59
60	enum
61	{
62	PROP_0,
63	PROP_Z_1,
64	PROP_Z_F,
65	PROP_SIZE,
66	};
67
68	static void
69	nc_hicosmo_de_wspline_init (NcHICosmoDEWSpline *wspline)	×
70	{
71	NcHICosmoDEWSplinePrivate * const self = wspline->priv = nc_hicosmo_de_wspline_get_instance_private (wspline);	×
72
73	self->nknots = 0;	×
74	self->size = 0;	×
75	self->z_1 = 0.0;	×
76	self->z_f = 0.0;	×
77	self->alpha_f = 0.0;	×
78	self->w_f = 0.0;	×
79	self->int_f = 0.0;	×
80	self->w_alpha = NULL;	×
81	}
82
83	static void
84	_nc_hicosmo_de_wspline_get_property (GObject object, guint prop_id, GValue value, GParamSpec *pspec)	×
85	{
86	NcHICosmoDEWSpline *wspline = NC_HICOSMO_DE_WSPLINE (object);	×
87	NcHICosmoDEWSplinePrivate * const self = wspline->priv;	×
88
89	g_return_if_fail (NC_IS_HICOSMO_DE_WSPLINE (object));	×
90
91	switch (prop_id)	×
92	{
93	case PROP_Z_1:	×
94	g_value_set_double (value, self->z_1);	×
95	break;	×
96	case PROP_Z_F:	×
97	g_value_set_double (value, self->z_f);	×
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_hicosmo_de_wspline_set_property (GObject object, guint prop_id, const GValue value, GParamSpec *pspec)	×
107	{
108	NcHICosmoDEWSpline *wspline = NC_HICOSMO_DE_WSPLINE (object);	×
109	NcHICosmoDEWSplinePrivate * const self = wspline->priv;	×
110
111	g_return_if_fail (NC_IS_HICOSMO_DE_WSPLINE (object));	×
112
113	switch (prop_id)	×
114	{
115	case PROP_Z_1:	×
116	self->z_1 = g_value_get_double (value);	×
117	break;	×
118	case PROP_Z_F:	×
119	self->z_f = g_value_get_double (value);	×
120	break;	×
121	default:	×
122	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);	×
123	break;	×
124	}
125	}
126
127	static void
128	_nc_hicosmo_de_wspline_constructed (GObject *object)	×
129	{
130	/* Chain up : start */
131	G_OBJECT_CLASS (nc_hicosmo_de_wspline_parent_class)->constructed (object);	×
132	{
133	NcHICosmoDEWSpline *wspline = NC_HICOSMO_DE_WSPLINE (object);	×
134	NcHICosmoDEWSplinePrivate * const self = wspline->priv;	×
135	NcmModel *model = NCM_MODEL (wspline);	×
136	NcmVector *orig_vec = ncm_model_orig_params_peek_vector (model);	×
137	NcmModelClass *model_class = NCM_MODEL_GET_CLASS (model);	×
138	guint wz_size = ncm_model_vparam_len (model, NC_HICOSMO_DE_WSPLINE_W);	×
139	const gdouble alpha1 = log1p (self->z_1);	×
140	const gdouble alphaf = log1p (self->z_f);	×
141	NcmVector alphav, wv;	×
142	guint i, wvi;	×
143
144	self->nknots = wz_size;	×
145	self->size = model_class->sparam_len + self->nknots;	×
146	self->alpha_f = alphaf * (1.0 - GSL_DBL_EPSILON);	×
147
148	g_assert_cmpuint (wz_size, >, 2);	×
149
150	wvi = ncm_model_vparam_index (model, NC_HICOSMO_DE_WSPLINE_W, 0);	×
151
152	alphav = ncm_vector_new (wz_size);	×
153	wv = ncm_vector_get_subvector (orig_vec, wvi, wz_size);	×
154
155	ncm_vector_set (alphav, 0, 0.0);	×
156	ncm_vector_set (alphav, 1, alpha1);	×
157
158	{
159	const gdouble dalpha = (log (alphaf) - log (alpha1)) / (wz_size - 2);	×
160
161	for (i = 0; i < wz_size - 2; i++)	×
162	{
163	const gdouble alpha = alpha1 * exp (dalpha * (i + 1.0));	×
164
165	ncm_vector_set (alphav, 2 + i, alpha);	×
166	}
167	}
168
169	{
170	NcmSpline *s;	×
171
172	if (self->nknots >= 6)	×
173	s = ncm_spline_cubic_notaknot_new ();	×
174	else
175	s = ncm_spline_gsl_new (gsl_interp_polynomial);	×
176
177	self->w_alpha = ncm_spline_new (s, alphav, wv, TRUE);	×
178
179	ncm_spline_free (s);	×
180	ncm_vector_free (alphav);	×
181	ncm_vector_free (wv);	×
182	}
183	}
184	}
185
186	static void
187	_nc_hicosmo_de_wspline_dispose (GObject *object)	×
188	{
189	NcHICosmoDEWSpline *wspline = NC_HICOSMO_DE_WSPLINE (object);	×
190	NcHICosmoDEWSplinePrivate * const self = wspline->priv;	×
191
192	ncm_spline_clear (&self->w_alpha);	×
193
194	/* Chain up : end */
195	G_OBJECT_CLASS (nc_hicosmo_de_wspline_parent_class)->dispose (object);	×
196	}
197
198	static void
199	_nc_hicosmo_de_wspline_finalize (GObject *object)	×
200	{
201	/* Chain up : end */
202	G_OBJECT_CLASS (nc_hicosmo_de_wspline_parent_class)->finalize (object);	×
203	}
204
205	static gdouble _nc_hicosmo_de_wspline_E2Omega_de (NcHICosmoDE *cosmo_de, gdouble z);
206	static gdouble _nc_hicosmo_de_wspline_dE2Omega_de_dz (NcHICosmoDE *cosmo_de, gdouble z);
207	static gdouble _nc_hicosmo_de_wspline_d2E2Omega_de_dz2 (NcHICosmoDE *cosmo_de, gdouble z);
208	static gdouble _nc_hicosmo_de_wspline_w_de (NcHICosmoDE *cosmo_de, gdouble z);
209
210	static void
211	nc_hicosmo_de_wspline_class_init (NcHICosmoDEWSplineClass *klass)	112✔
212	{
213	GObjectClass *object_class = G_OBJECT_CLASS (klass);	112✔
214	NcHICosmoDEClass *parent_class = NC_HICOSMO_DE_CLASS (klass);	112✔
215	NcmModelClass *model_class = NCM_MODEL_CLASS (klass);	112✔
216
217	model_class->set_property = &_nc_hicosmo_de_wspline_set_property;	112✔
218	model_class->get_property = &_nc_hicosmo_de_wspline_get_property;	112✔
219	object_class->constructed = &_nc_hicosmo_de_wspline_constructed;	112✔
220	object_class->dispose = &_nc_hicosmo_de_wspline_dispose;	112✔
221	object_class->finalize = &_nc_hicosmo_de_wspline_finalize;	112✔
222
223	ncm_model_class_set_name_nick (model_class, "XCDM - Constant EOS", "XCDM");	112✔
224	ncm_model_class_add_params (model_class, 0,	112✔
225	NC_HICOSMO_DE_WSPLINE_VPARAM_LEN - NC_HICOSMO_DE_VPARAM_LEN,
226	PROP_SIZE);
227
228	g_object_class_install_property (object_class,	112✔
229	PROP_Z_1,
230	g_param_spec_double ("z1",
231	NULL,
232	"second redshift knot",
233	1.0e-3, 0.5, 1.0e-2,
234	G_PARAM_READWRITE \| G_PARAM_CONSTRUCT_ONLY \| G_PARAM_STATIC_NAME \| G_PARAM_STATIC_BLURB));
235
236	g_object_class_install_property (object_class,	112✔
237	PROP_Z_F,
238	g_param_spec_double ("zf",
239	NULL,
240	"final redshift",
241	1.0, 1.0e10, 2.0,
242	G_PARAM_READWRITE \| G_PARAM_CONSTRUCT_ONLY \| G_PARAM_STATIC_NAME \| G_PARAM_STATIC_BLURB));
243
244	/* Set w_0 param info */
245	ncm_model_class_set_vparam (model_class, NC_HICOSMO_DE_WSPLINE_W, 6, "w", "w",	112✔
246	-5.0, 1.0, 1.0e-2,
247	NC_HICOSMO_DEFAULT_PARAMS_ABSTOL, NC_HICOSMO_DE_WSPLINE_DEFAULT_W0,
248	NCM_PARAM_TYPE_FREE);
249
250	/* Check for errors in parameters initialization */
251	ncm_model_class_check_params_info (model_class);	112✔
252
253	nc_hicosmo_de_set_E2Omega_de_impl (parent_class, &_nc_hicosmo_de_wspline_E2Omega_de);	112✔
254	nc_hicosmo_de_set_dE2Omega_de_dz_impl (parent_class, &_nc_hicosmo_de_wspline_dE2Omega_de_dz);	112✔
255	nc_hicosmo_de_set_d2E2Omega_de_dz2_impl (parent_class, &_nc_hicosmo_de_wspline_d2E2Omega_de_dz2);	112✔
256	nc_hicosmo_de_set_w_de_impl (parent_class, &_nc_hicosmo_de_wspline_w_de);	112✔
257	}	112✔
258
259	#define VECTOR (NCM_MODEL (cosmo_de))
260	#define OMEGA_X (ncm_model_orig_param_get (VECTOR, NC_HICOSMO_DE_OMEGA_X))
261
262	static void
263	_nc_hicosmo_de_wspline_prepare (NcHICosmoDEWSpline *wspline)	×
264	{
265	NcHICosmoDEWSplinePrivate * const self = wspline->priv;	×
266
267	if (!ncm_model_lstate_is_update (NCM_MODEL (wspline), 0))	×
268	{
269	ncm_spline_prepare (self->w_alpha);	×
270
271	self->w_f = ncm_spline_eval (self->w_alpha, self->alpha_f);	×
272	self->int_f = ncm_spline_eval_integ (self->w_alpha, 0.0, self->alpha_f);	×
273
274	ncm_model_lstate_set_update (NCM_MODEL (wspline), 0);	×
275	}
276	else
277	{
278	return;
279	}
280	}
281
282	static gdouble
283	_nc_hicosmo_de_wspline_E2Omega_de (NcHICosmoDE *cosmo_de, gdouble z)	×
284	{
285	NcHICosmoDEWSpline *wspline = NC_HICOSMO_DE_WSPLINE (cosmo_de);	×
286	NcHICosmoDEWSplinePrivate * const self = wspline->priv;	×
287
288	_nc_hicosmo_de_wspline_prepare (wspline);	×
289
290	if (z < self->z_f)	×
291	{
292	const gdouble alpha = log1p (z);	×
293
294	return OMEGA_X * exp (3.0 * (alpha + ncm_spline_eval_integ (self->w_alpha, 0.0, alpha)));	×
295	}
296	else
297	{
298	const gdouble alpha = log1p (z);	×
299
300	return OMEGA_X * exp (3.0 * (alpha + self->int_f + self->w_f * (alpha - self->alpha_f)));	×
301	}
302	}
303
304	static gdouble
305	_nc_hicosmo_de_wspline_dE2Omega_de_dz (NcHICosmoDE *cosmo_de, gdouble z)	×
306	{
307	NcHICosmoDEWSpline *wspline = NC_HICOSMO_DE_WSPLINE (cosmo_de);	×
308	NcHICosmoDEWSplinePrivate * const self = wspline->priv;	×
309
310	_nc_hicosmo_de_wspline_prepare (wspline);	×
311
312	if (z < self->z_f)	×
313	{
314	const gdouble alpha = log1p (z);	×
315	const gdouble w = ncm_spline_eval (self->w_alpha, alpha);	×
316	const gdouble int_w = ncm_spline_eval_integ (self->w_alpha, 0.0, alpha);	×
317	const gdouble exp_malpha_OmegaX = OMEGA_X * exp (2.0 * alpha + 3.0 * int_w);	×
318
319	return 3.0 * (1.0 + w) * exp_malpha_OmegaX;	×
320	}
321	else
322	{
323	const gdouble alpha = log1p (z);	×
324
325	return OMEGA_X * 3.0 * (1.0 + self->w_f) * exp (2.0 * alpha + 3.0 * (self->int_f + self->w_f * (alpha - self->alpha_f)));	×
326	}
327	}
328
329	static gdouble
330	_nc_hicosmo_de_wspline_d2E2Omega_de_dz2 (NcHICosmoDE *cosmo_de, gdouble z)	×
331	{
332	NcHICosmoDEWSpline *wspline = NC_HICOSMO_DE_WSPLINE (cosmo_de);	×
333	NcHICosmoDEWSplinePrivate * const self = wspline->priv;	×
334
335	_nc_hicosmo_de_wspline_prepare (wspline);	×
336
337	if (z < self->z_f)	×
338	{
339	const gdouble alpha = log1p (z);	×
340	const gdouble w = ncm_spline_eval (self->w_alpha, alpha);	×
341	const gdouble dw = ncm_spline_eval_deriv (self->w_alpha, alpha);	×
342	const gdouble int_w = ncm_spline_eval_integ (self->w_alpha, 0.0, alpha);	×
343	const gdouble exp_m2alpha_OmegaX = OMEGA_X * exp (1.0 * alpha + 3.0 * int_w);	×
344
345	return 3.0 * (2.0 + w * (5.0 + 3.0 * w) + dw) * exp_m2alpha_OmegaX;	×
346	}
347	else
348	{
349	const gdouble alpha = log1p (z);	×
350	const gdouble exp_m2alpha_OmegaX = OMEGA_X * exp (1.0 * alpha + 3.0 * (self->int_f + self->w_f * (alpha - self->alpha_f)));	×
351
352	return 3.0 * (2.0 + self->w_f * (5.0 + 3.0 * self->w_f)) * exp_m2alpha_OmegaX;	×
353	}
354	}
355
356	static gdouble
357	_nc_hicosmo_de_wspline_w_de (NcHICosmoDE *cosmo_de, gdouble z)	×
358	{
359	NcHICosmoDEWSpline *wspline = NC_HICOSMO_DE_WSPLINE (cosmo_de);	×
360	NcHICosmoDEWSplinePrivate * const self = wspline->priv;	×
361
362	_nc_hicosmo_de_wspline_prepare (wspline);	×
363
364	if (z < self->z_f)	×
365	{
366	const gdouble alpha = z < self->z_f ? log1p (z) : log1p (self->z_f);	×
367	const gdouble w = ncm_spline_eval (self->w_alpha, alpha);	×
368
369	return w;	×
370	}
371	else
372	{
373	return self->w_f;	×
374	}
375	}
376
377	/**
378	* nc_hicosmo_de_wspline_new:
379	* @nknots: number of knots in the $w(z)$ spline
380	* @z_f: redshift $z_f$ of the last knot.
381	*
382	* This function instantiates a new object of type #NcHICosmoDEWSpline.
383	*
384	* Returns: A new #NcHICosmoDEWSpline
385	*/
386	NcHICosmoDEWSpline *
387	nc_hicosmo_de_wspline_new (gsize nknots, const gdouble z_f)	×
388	{
389	NcHICosmoDEWSpline *wspline = g_object_new (NC_TYPE_HICOSMO_DE_WSPLINE,	×
390	"zf", z_f,
391	"w-length", nknots,
392	NULL);
393
394	return wspline;	×
395	}
396
397	/**
398	* nc_hicosmo_de_wspline_get_alpha:
399	* @wspline: a #NcHICosmoDEWSpline
400	*
401	* Gets vector with the current knots in $\alpha$.
402	*
403	* Returns: (transfer none): A new #NcmVector
404	*/
405	NcmVector *
406	nc_hicosmo_de_wspline_get_alpha (NcHICosmoDEWSpline *wspline)	×
407	{
408	NcHICosmoDEWSplinePrivate * const self = wspline->priv;	×
409
NEW 410	return ncm_spline_peek_xv (self->w_alpha);	×
411	}
412

NumCosmo / NumCosmo / 7270201403

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