7232289401

Committed 16 Dec 2023 01:40PM UTC coverage: 55.108% (+0.1%) from 54.995%

Build # 7232289401

Build Type

Pull #126

github

Committed by

web-flow

Commit Message

Merge 59f71fc9e into bffca6a86

Pull Request Pull Request #126: More objects encapsulation

Run Details

7249 of 12512 branches covered (0.0%)

Branch coverage included in aggregate %.

161 of 628 new or added lines in 37 files covered. (25.64%)

25 existing lines in 8 files now uncovered.

47341 of 86548 relevant lines covered (54.7%)

2005997.26 hits per line

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

46.6

/numcosmo/math/ncm_mpi_job_mcmc.c

/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 2; tab-width: 2 -*-  */

/***************************************************************************
 *            ncm_mpi_job_mcmc.c
 *
 *  Fri April 27 16:32:14 2018
 *  Copyright  2018  Sandro Dias Pinto Vitenti
 *  <vitenti@uel.br>
 ****************************************************************************/
/*
 * ncm_mpi_job_mcmc.c
 * Copyright (C) 2018 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:ncm_mpi_job_mcmc
 * @title: NcmMPIJobMCMC
 * @short_description: MPI job object for running MCMC steps
 *
 * This object is a subclass of #NcmMPIJob, designed to implement an MPI job for
 * evaluating the posterior at the proposal points during an MCMC run. It is utilized
 * by #NcmFitESMCMC to parallelize the evaluation of the posterior function. The job
 * involves computing the posterior function and, if applicable, additional functions
 * (e.g., derived quantities) at a specified point within the parameter space. Notably,
 * the slave also receives the current point and the current value for the acceptance
 * probability. Consequently, it decides whether to accept or reject the proposal point
 * and only computes the additional functions if the proposal point is accepted.
 *
 * The MPI job is implemented as a function that takes a vector consisting of the set
 * parameters, the current value of the posterior function, the acceptance probability,
 * and the jump probability as input. The function returns a vector with the first
 * element being 1.0 if the proposal point is accepted and 0.0 otherwise. The next
 * value is the value of the posterior function at the proposal point. The remaining
 * values are the values of the additional functions at the proposal point.
 *
 */

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

#include "ncm_enum_types.h"
#include "math/ncm_mpi_job_mcmc.h"
#include "math/ncm_fit_esmcmc.h"
#include "math/ncm_timer.h"

#ifndef HAVE_MPI
#define MPI_DATATYPE_NULL (0)
#define MPI_DOUBLE (0)
#endif /* HAVE_MPI */

typedef struct _NcmMPIJobMCMCPrivate
{
  NcmFit *fit;
  NcmObjArray *func_oa;
  gint fparam_len;
  gint nadd_vals;
  NcmTimer *nt;
} NcmMPIJobMCMCPrivate;

enum
{
  PROP_0,
  PROP_FIT,
  PROP_FUNC_ARRAY,
  PROP_JOB_TYPE,
};

struct _NcmMPIJobMCMC
{
  NcmMPIJob parent_instance;
};

G_DEFINE_TYPE_WITH_PRIVATE (NcmMPIJobMCMC, ncm_mpi_job_mcmc, NCM_TYPE_MPI_JOB)

static void
ncm_mpi_job_mcmc_init (NcmMPIJobMCMC *mjmcmc)
{
  NcmMPIJobMCMCPrivate * const self = ncm_mpi_job_mcmc_get_instance_private (mjmcmc);

  self->fit     = NULL;
  self->func_oa = NULL;

  self->fparam_len = 0;
  self->nadd_vals  = 0;

  self->nt = ncm_timer_new ();
}

static void
_ncm_mpi_job_mcmc_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
{
  NcmMPIJobMCMC *mjmcmc             = NCM_MPI_JOB_MCMC (object);
  NcmMPIJobMCMCPrivate * const self = ncm_mpi_job_mcmc_get_instance_private (mjmcmc);

  g_return_if_fail (NCM_IS_MPI_JOB_MCMC (object));

  switch (prop_id)
  {
    case PROP_FIT:
      g_assert (self->fit == NULL);
      self->fit = g_value_dup_object (value);
      g_assert (self->fit != NULL);
      break;
    case PROP_FUNC_ARRAY:
    {
      ncm_obj_array_clear (&self->func_oa);
      self->func_oa = g_value_dup_boxed (value);

      if (self->func_oa != NULL)
      {
        guint i;

        for (i = 0; i < self->func_oa->len; i++)
        {
          NcmMSetFunc *func = NCM_MSET_FUNC (ncm_obj_array_peek (self->func_oa, i));

          g_assert (NCM_IS_MSET_FUNC (func));
          g_assert (ncm_mset_func_is_scalar (func));
          g_assert (ncm_mset_func_is_const (func));
        }
      }

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

static void
_ncm_mpi_job_mcmc_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
  NcmMPIJobMCMC *mjmcmc             = NCM_MPI_JOB_MCMC (object);
  NcmMPIJobMCMCPrivate * const self = ncm_mpi_job_mcmc_get_instance_private (mjmcmc);

  g_return_if_fail (NCM_IS_MPI_JOB_MCMC (object));

  switch (prop_id)
  {
    case PROP_FIT:
      g_value_set_object (value, self->fit);
      break;
    case PROP_FUNC_ARRAY:
      g_value_set_boxed (value, self->func_oa);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static void
_ncm_mpi_job_mcmc_constructed (GObject *object)
{
  NcmMPIJobMCMC *mjmcmc             = NCM_MPI_JOB_MCMC (object);
  NcmMPIJobMCMCPrivate * const self = ncm_mpi_job_mcmc_get_instance_private (mjmcmc);
  NcmMSet *mset                     = ncm_fit_peek_mset (self->fit);

  self->fparam_len = ncm_mset_fparam_len (mset);
  self->nadd_vals  = 1 + ((self->func_oa != NULL) ? self->func_oa->len : 0);

  /* Chain up : end */
  G_OBJECT_CLASS (ncm_mpi_job_mcmc_parent_class)->constructed (object);
}

static void
_ncm_mpi_job_mcmc_dispose (GObject *object)
{
  NcmMPIJobMCMC *mjmcmc             = NCM_MPI_JOB_MCMC (object);
  NcmMPIJobMCMCPrivate * const self = ncm_mpi_job_mcmc_get_instance_private (mjmcmc);

  ncm_fit_clear (&self->fit);
  ncm_obj_array_clear (&self->func_oa);
  ncm_timer_clear (&self->nt);


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

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

static NcmMPIDatatype _ncm_mpi_job_mcmc_input_datatype (NcmMPIJob *mpi_job, gint *len, gint *size);
static NcmMPIDatatype _ncm_mpi_job_mcmc_return_datatype (NcmMPIJob *mpi_job, gint *len, gint *size);

static gpointer _ncm_mpi_job_mcmc_create_input (NcmMPIJob *mpi_job);
static gpointer _ncm_mpi_job_mcmc_create_return (NcmMPIJob *mpi_job);

static void _ncm_mpi_job_mcmc_destroy_input (NcmMPIJob *mpi_job, gpointer input);
static void _ncm_mpi_job_mcmc_destroy_return (NcmMPIJob *mpi_job, gpointer ret);

static gpointer _ncm_mpi_job_mcmc_get_input_buffer (NcmMPIJob *mpi_job, gpointer input);
static gpointer _ncm_mpi_job_mcmc_get_return_buffer (NcmMPIJob *mpi_job, gpointer ret);

static void _ncm_mpi_job_mcmc_destroy_input_buffer (NcmMPIJob *mpi_job, gpointer input, gpointer buf);
static void _ncm_mpi_job_mcmc_destroy_return_buffer (NcmMPIJob *mpi_job, gpointer ret, gpointer buf);

static gpointer _ncm_mpi_job_mcmc_pack_input (NcmMPIJob *mpi_job, gpointer input);
static gpointer _ncm_mpi_job_mcmc_pack_return (NcmMPIJob *mpi_job, gpointer ret);

static void _ncm_mpi_job_mcmc_unpack_input (NcmMPIJob *mpi_job, gpointer buf, gpointer input);
static void _ncm_mpi_job_mcmc_unpack_return (NcmMPIJob *mpi_job, gpointer buf, gpointer ret);

static void _ncm_mpi_job_mcmc_run (NcmMPIJob *mpi_job, gpointer input, gpointer ret);

static void
ncm_mpi_job_mcmc_class_init (NcmMPIJobMCMCClass *klass)
{
  GObjectClass *object_class    = G_OBJECT_CLASS (klass);
  NcmMPIJobClass *mpi_job_class = NCM_MPI_JOB_CLASS (klass);

  object_class->set_property = &_ncm_mpi_job_mcmc_set_property;
  object_class->get_property = &_ncm_mpi_job_mcmc_get_property;
  object_class->constructed  = &_ncm_mpi_job_mcmc_constructed;
  object_class->dispose      = &_ncm_mpi_job_mcmc_dispose;
  object_class->finalize     = &_ncm_mpi_job_mcmc_finalize;

  g_object_class_install_property (object_class,
                                   PROP_FIT,
                                   g_param_spec_object ("fit",
                                                        NULL,
                                                        "Fit object",
                                                        NCM_TYPE_FIT,
                                                        G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB));
  g_object_class_install_property (object_class,
                                   PROP_FUNC_ARRAY,
                                   g_param_spec_boxed ("function-array",
                                                       NULL,
                                                       "Functions array",
                                                       NCM_TYPE_OBJ_ARRAY,
                                                       G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB));

  mpi_job_class->input_datatype  = &_ncm_mpi_job_mcmc_input_datatype;
  mpi_job_class->return_datatype = &_ncm_mpi_job_mcmc_return_datatype;

  mpi_job_class->create_input  = &_ncm_mpi_job_mcmc_create_input;
  mpi_job_class->create_return = &_ncm_mpi_job_mcmc_create_return;

  mpi_job_class->destroy_input  = &_ncm_mpi_job_mcmc_destroy_input;
  mpi_job_class->destroy_return = &_ncm_mpi_job_mcmc_destroy_return;

  mpi_job_class->get_input_buffer  = &_ncm_mpi_job_mcmc_get_input_buffer;
  mpi_job_class->get_return_buffer = &_ncm_mpi_job_mcmc_get_return_buffer;

  mpi_job_class->destroy_input_buffer  = &_ncm_mpi_job_mcmc_destroy_input_buffer;
  mpi_job_class->destroy_return_buffer = &_ncm_mpi_job_mcmc_destroy_return_buffer;

  mpi_job_class->pack_input  = &_ncm_mpi_job_mcmc_pack_input;
  mpi_job_class->pack_return = &_ncm_mpi_job_mcmc_pack_return;

  mpi_job_class->unpack_input  = &_ncm_mpi_job_mcmc_unpack_input;
  mpi_job_class->unpack_return = &_ncm_mpi_job_mcmc_unpack_return;

  mpi_job_class->run = &_ncm_mpi_job_mcmc_run;
}

static NcmMPIDatatype
_ncm_mpi_job_mcmc_input_datatype (NcmMPIJob *mpi_job, gint *len, gint *size)
{
  NcmMPIJobMCMC *mjmcmc             = NCM_MPI_JOB_MCMC (mpi_job);
  NcmMPIJobMCMCPrivate * const self = ncm_mpi_job_mcmc_get_instance_private (mjmcmc);

  len[0]  = self->fparam_len + NCM_FIT_ESMCMC_MPI_IN_LEN;
  size[0] = sizeof (gdouble) * len[0];

  return MPI_DOUBLE;
}

static NcmMPIDatatype
_ncm_mpi_job_mcmc_return_datatype (NcmMPIJob *mpi_job, gint *len, gint *size)
{
  NcmMPIJobMCMC *mjmcmc             = NCM_MPI_JOB_MCMC (mpi_job);
  NcmMPIJobMCMCPrivate * const self = ncm_mpi_job_mcmc_get_instance_private (mjmcmc);

  len[0]  = NCM_FIT_ESMCMC_MPI_OUT_LEN + self->nadd_vals;
  size[0] = sizeof (gdouble) * len[0];

  return MPI_DOUBLE;
}

static gpointer
_ncm_mpi_job_mcmc_create_input (NcmMPIJob *mpi_job)
{
  NcmMPIJobMCMC *mjmcmc             = NCM_MPI_JOB_MCMC (mpi_job);
  NcmMPIJobMCMCPrivate * const self = ncm_mpi_job_mcmc_get_instance_private (mjmcmc);

  return ncm_vector_new (self->fparam_len + NCM_FIT_ESMCMC_MPI_IN_LEN);
}

static gpointer
_ncm_mpi_job_mcmc_create_return (NcmMPIJob *mpi_job)
{
  NcmMPIJobMCMC *mjmcmc             = NCM_MPI_JOB_MCMC (mpi_job);
  NcmMPIJobMCMCPrivate * const self = ncm_mpi_job_mcmc_get_instance_private (mjmcmc);

  return ncm_vector_new (NCM_FIT_ESMCMC_MPI_OUT_LEN + self->nadd_vals);
}

static void
_ncm_mpi_job_mcmc_destroy_input (NcmMPIJob *mpi_job, gpointer input)
{
  ncm_vector_free (input);
}

static void
_ncm_mpi_job_mcmc_destroy_return (NcmMPIJob *mpi_job, gpointer ret)
{
  ncm_vector_free (ret);
}

static gpointer
_ncm_mpi_job_mcmc_get_input_buffer (NcmMPIJob *mpi_job, gpointer input)
{
  return ncm_vector_data (input);
}

static gpointer
_ncm_mpi_job_mcmc_get_return_buffer (NcmMPIJob *mpi_job, gpointer ret)
{
  return ncm_vector_data (ret);
}

static void
_ncm_mpi_job_mcmc_destroy_input_buffer (NcmMPIJob *mpi_job, gpointer input, gpointer buf)
{
  g_assert_cmphex (GPOINTER_TO_INT (ncm_vector_data (input)), ==, GPOINTER_TO_INT (buf));
}

static void
_ncm_mpi_job_mcmc_destroy_return_buffer (NcmMPIJob *mpi_job, gpointer ret, gpointer buf)
{
  g_assert_cmphex (GPOINTER_TO_INT (ncm_vector_data (ret)), ==, GPOINTER_TO_INT (buf));
}

static gpointer
_ncm_mpi_job_mcmc_pack_input (NcmMPIJob *mpi_job, gpointer input)
{
  return ncm_vector_data (input);
}

static gpointer
_ncm_mpi_job_mcmc_pack_return (NcmMPIJob *mpi_job, gpointer ret)
{
  return ncm_vector_data (ret);
}

static void
_ncm_mpi_job_mcmc_unpack_input (NcmMPIJob *mpi_job, gpointer buf, gpointer input)
{
  g_assert_cmphex (GPOINTER_TO_INT (ncm_vector_data (input)), ==, GPOINTER_TO_INT (buf));
}

static void
_ncm_mpi_job_mcmc_unpack_return (NcmMPIJob *mpi_job, gpointer buf, gpointer ret)
{
  g_assert_cmphex (GPOINTER_TO_INT (ncm_vector_data (ret)), ==, GPOINTER_TO_INT (buf));
}

static void
_ncm_mpi_job_mcmc_run (NcmMPIJob *mpi_job, gpointer input, gpointer ret)
{
  NcmMPIJobMCMC *mjmcmc             = NCM_MPI_JOB_MCMC (mpi_job);
  NcmMPIJobMCMCPrivate * const self = ncm_mpi_job_mcmc_get_instance_private (mjmcmc);
  NcmMSet *mset                     = ncm_fit_peek_mset (self->fit);
  const gdouble m2lnL_cur           = ncm_vector_get (input, self->fparam_len + 0);
  const gdouble norm                = ncm_vector_get (input, self->fparam_len + 1);
  const gdouble jump                = ncm_vector_get (input, self->fparam_len + 2);
  gdouble *m2lnL_star               = ncm_vector_ptr (ret, NCM_FIT_ESMCMC_MPI_OUT_LEN);
  gdouble prob                      = 0.0;
  gboolean accepted                 = FALSE;

  ncm_fit_params_set_vector (self->fit, input);

  if (!ncm_mset_params_valid (mset))
    m2lnL_star[0] = GSL_POSINF;
  else
    ncm_fit_m2lnL_val (self->fit, m2lnL_star);

  if (gsl_finite (m2lnL_star[0]))
  {
    if (jump >= 0.0)
    {
      prob     = exp ((m2lnL_cur - m2lnL_star[0]) * 0.5 + norm);
      prob     = MIN (prob, 1.0);
      accepted = (jump < prob);
    }
    else
    {
      accepted = TRUE;
    }
  }

  if (accepted)
  {
    ncm_vector_set (ret, 0, 1.0);

    /*printf ("# has oa?! %p\n", self->func_oa);*/
    if (self->func_oa != NULL)
    {
      guint i;

      for (i = 0; i < self->func_oa->len; i++)
      {
        NcmMSetFunc *func = NCM_MSET_FUNC (ncm_obj_array_peek (self->func_oa, i));
        const gdouble a_i = ncm_mset_func_eval0 (func, mset);

        /*printf ("### %d % 22.15g\n", i, a_i);*/
        ncm_vector_set (ret, i + 1 + NCM_FIT_ESMCMC_MPI_OUT_LEN, a_i);
      }
    }
  }
  else
  {
    ncm_vector_set (ret, 0, 0.0);
  }
}

/**
 * ncm_mpi_job_mcmc_new:
 * @fit: a #NcmFit
 * @func_oa: (array) (element-type NcmMSetFunc) (allow-none): a #NcmObjArray
 *
 * Creates a new #NcmMPIJobMCMC object.
 *
 * Returns: a new #NcmMPIJobMCMC.
 */
NcmMPIJobMCMC *
ncm_mpi_job_mcmc_new (NcmFit *fit, NcmObjArray *func_oa)
{
  NcmMPIJobMCMC *mjmcmc = g_object_new (NCM_TYPE_MPI_JOB_MCMC,
                                        "fit",            fit,
                                        "function-array", func_oa,
                                        NULL);

  return mjmcmc;
}

/**
 * ncm_mpi_job_mcmc_ref:
 * @mjmcmc: a #NcmMPIJobMCMC
 *
 * Increase the reference of @mjmcmc by one.
 *
 * Returns: (transfer full): @mjmcmc.
 */
NcmMPIJobMCMC *
ncm_mpi_job_mcmc_ref (NcmMPIJobMCMC *mjmcmc)
{
  return g_object_ref (mjmcmc);
}

/**
 * ncm_mpi_job_mcmc_free:
 * @mjmcmc: a #NcmMPIJobMCMC
 *
 * Decrease the reference count of @mjmcmc by one.
 *
 */
void
ncm_mpi_job_mcmc_free (NcmMPIJobMCMC *mjmcmc)
{
  g_object_unref (mjmcmc);
}

/**
 * ncm_mpi_job_mcmc_clear:
 * @mjmcmc: a #NcmMPIJobMCMC
 *
 * Decrease the reference count of @mjmcmc by one, and sets the pointer *@mjmcmc to
 * NULL.
 *
 */
void
ncm_mpi_job_mcmc_clear (NcmMPIJobMCMC **mjmcmc)
{
  g_clear_object (mjmcmc);
}


1	/* -- Mode: C; indent-tabs-mode: t; c-basic-offset: 2; tab-width: 2 -- */
2
3	/***************************************************************************
4	* ncm_mpi_job_mcmc.c
5	*
6	* Fri April 27 16:32:14 2018
7	* Copyright 2018 Sandro Dias Pinto Vitenti
8	* <vitenti@uel.br>
9	****************************************************************************/
10	/*
11	* ncm_mpi_job_mcmc.c
12	* Copyright (C) 2018 Sandro Dias Pinto Vitenti <vitenti@uel.br>
13	*
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:ncm_mpi_job_mcmc
30	* @title: NcmMPIJobMCMC
31	* @short_description: MPI job object for running MCMC steps
32	*
33	* This object is a subclass of #NcmMPIJob, designed to implement an MPI job for
34	* evaluating the posterior at the proposal points during an MCMC run. It is utilized
35	* by #NcmFitESMCMC to parallelize the evaluation of the posterior function. The job
36	* involves computing the posterior function and, if applicable, additional functions
37	* (e.g., derived quantities) at a specified point within the parameter space. Notably,
38	* the slave also receives the current point and the current value for the acceptance
39	* probability. Consequently, it decides whether to accept or reject the proposal point
40	* and only computes the additional functions if the proposal point is accepted.
41	*
42	* The MPI job is implemented as a function that takes a vector consisting of the set
43	* parameters, the current value of the posterior function, the acceptance probability,
44	* and the jump probability as input. The function returns a vector with the first
45	* element being 1.0 if the proposal point is accepted and 0.0 otherwise. The next
46	* value is the value of the posterior function at the proposal point. The remaining
47	* values are the values of the additional functions at the proposal point.
48	*
49	*/
50
51	#ifdef HAVE_CONFIG_H
52	# include "config.h"
53	#endif /* HAVE_CONFIG_H */
54	#include "build_cfg.h"
55
56	#include "ncm_enum_types.h"
57	#include "math/ncm_mpi_job_mcmc.h"
58	#include "math/ncm_fit_esmcmc.h"
59	#include "math/ncm_timer.h"
60
61	#ifndef HAVE_MPI
62	#define MPI_DATATYPE_NULL (0)
63	#define MPI_DOUBLE (0)
64	#endif /* HAVE_MPI */
65
66	typedef struct _NcmMPIJobMCMCPrivate
67	{
68	NcmFit *fit;
69	NcmObjArray *func_oa;
70	gint fparam_len;
71	gint nadd_vals;
72	NcmTimer *nt;
73	} NcmMPIJobMCMCPrivate;
74
75	enum
76	{
77	PROP_0,
78	PROP_FIT,
79	PROP_FUNC_ARRAY,
80	PROP_JOB_TYPE,
81	};
82
83	struct _NcmMPIJobMCMC
84	{
85	NcmMPIJob parent_instance;
86	};
87
88	G_DEFINE_TYPE_WITH_PRIVATE (NcmMPIJobMCMC, ncm_mpi_job_mcmc, NCM_TYPE_MPI_JOB)	1,303✔
89
90	static void
91	ncm_mpi_job_mcmc_init (NcmMPIJobMCMC *mjmcmc)	49✔
92	{
93	NcmMPIJobMCMCPrivate * const self = ncm_mpi_job_mcmc_get_instance_private (mjmcmc);	49✔
94
95	self->fit = NULL;	49✔
96	self->func_oa = NULL;	49✔
97
98	self->fparam_len = 0;	49✔
99	self->nadd_vals = 0;	49✔
100
101	self->nt = ncm_timer_new ();	49✔
102	}	49✔
103
104	static void
105	_ncm_mpi_job_mcmc_set_property (GObject object, guint prop_id, const GValue value, GParamSpec *pspec)	98✔
106	{
107	NcmMPIJobMCMC *mjmcmc = NCM_MPI_JOB_MCMC (object);	98✔
108	NcmMPIJobMCMCPrivate * const self = ncm_mpi_job_mcmc_get_instance_private (mjmcmc);	98✔
109
110	g_return_if_fail (NCM_IS_MPI_JOB_MCMC (object));	98✔
111
112	switch (prop_id)	98✔
113	{
114	case PROP_FIT:	49✔
115	g_assert (self->fit == NULL);	49✔
116	self->fit = g_value_dup_object (value);	49✔
117	g_assert (self->fit != NULL);	49✔
118	break;
119	case PROP_FUNC_ARRAY:	49✔
120	{
121	ncm_obj_array_clear (&self->func_oa);	49✔
122	self->func_oa = g_value_dup_boxed (value);	49✔
123
124	if (self->func_oa != NULL)	49✔
125	{
126	guint i;
127
128	for (i = 0; i < self->func_oa->len; i++)	×
129	{
130	NcmMSetFunc *func = NCM_MSET_FUNC (ncm_obj_array_peek (self->func_oa, i));	×
131
132	g_assert (NCM_IS_MSET_FUNC (func));	×
133	g_assert (ncm_mset_func_is_scalar (func));	×
134	g_assert (ncm_mset_func_is_const (func));	×
135	}
136	}
137
138	break;
139	}
140	default:	×
141	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);	×
142	break;	×
143	}
144	}
145
146	static void
147	_ncm_mpi_job_mcmc_get_property (GObject object, guint prop_id, GValue value, GParamSpec *pspec)	×
148	{
149	NcmMPIJobMCMC *mjmcmc = NCM_MPI_JOB_MCMC (object);	×
NEW 150	NcmMPIJobMCMCPrivate * const self = ncm_mpi_job_mcmc_get_instance_private (mjmcmc);	×
151
152	g_return_if_fail (NCM_IS_MPI_JOB_MCMC (object));	×
153
154	switch (prop_id)	×
155	{
156	case PROP_FIT:	×
157	g_value_set_object (value, self->fit);	×
158	break;	×
159	case PROP_FUNC_ARRAY:	×
160	g_value_set_boxed (value, self->func_oa);	×
161	break;	×
162	default:	×
163	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);	×
164	break;	×
165	}
166	}
167
168	static void
169	_ncm_mpi_job_mcmc_constructed (GObject *object)	49✔
170	{
171	NcmMPIJobMCMC *mjmcmc = NCM_MPI_JOB_MCMC (object);	49✔
172	NcmMPIJobMCMCPrivate * const self = ncm_mpi_job_mcmc_get_instance_private (mjmcmc);	49✔
173	NcmMSet *mset = ncm_fit_peek_mset (self->fit);	49✔
174
175	self->fparam_len = ncm_mset_fparam_len (mset);	49✔
176	self->nadd_vals = 1 + ((self->func_oa != NULL) ? self->func_oa->len : 0);	49✔
177
178	/* Chain up : end */
179	G_OBJECT_CLASS (ncm_mpi_job_mcmc_parent_class)->constructed (object);	49✔
180	}	49✔
181
182	static void
183	_ncm_mpi_job_mcmc_dispose (GObject *object)	49✔
184	{
185	NcmMPIJobMCMC *mjmcmc = NCM_MPI_JOB_MCMC (object);	49✔
186	NcmMPIJobMCMCPrivate * const self = ncm_mpi_job_mcmc_get_instance_private (mjmcmc);	49✔
187
188	ncm_fit_clear (&self->fit);	49✔
189	ncm_obj_array_clear (&self->func_oa);	49✔
190	ncm_timer_clear (&self->nt);	49✔
191
192
193	/* Chain up : end */
194	G_OBJECT_CLASS (ncm_mpi_job_mcmc_parent_class)->dispose (object);	49✔
195	}	49✔
196
197	static void
198	_ncm_mpi_job_mcmc_finalize (GObject *object)	49✔
199	{
200	/* Chain up : end */
201	G_OBJECT_CLASS (ncm_mpi_job_mcmc_parent_class)->finalize (object);	49✔
202	}	49✔
203
204	static NcmMPIDatatype _ncm_mpi_job_mcmc_input_datatype (NcmMPIJob mpi_job, gint len, gint *size);
205	static NcmMPIDatatype _ncm_mpi_job_mcmc_return_datatype (NcmMPIJob mpi_job, gint len, gint *size);
206
207	static gpointer _ncm_mpi_job_mcmc_create_input (NcmMPIJob *mpi_job);
208	static gpointer _ncm_mpi_job_mcmc_create_return (NcmMPIJob *mpi_job);
209
210	static void _ncm_mpi_job_mcmc_destroy_input (NcmMPIJob *mpi_job, gpointer input);
211	static void _ncm_mpi_job_mcmc_destroy_return (NcmMPIJob *mpi_job, gpointer ret);
212
213	static gpointer _ncm_mpi_job_mcmc_get_input_buffer (NcmMPIJob *mpi_job, gpointer input);
214	static gpointer _ncm_mpi_job_mcmc_get_return_buffer (NcmMPIJob *mpi_job, gpointer ret);
215
216	static void _ncm_mpi_job_mcmc_destroy_input_buffer (NcmMPIJob *mpi_job, gpointer input, gpointer buf);
217	static void _ncm_mpi_job_mcmc_destroy_return_buffer (NcmMPIJob *mpi_job, gpointer ret, gpointer buf);
218
219	static gpointer _ncm_mpi_job_mcmc_pack_input (NcmMPIJob *mpi_job, gpointer input);
220	static gpointer _ncm_mpi_job_mcmc_pack_return (NcmMPIJob *mpi_job, gpointer ret);
221
222	static void _ncm_mpi_job_mcmc_unpack_input (NcmMPIJob *mpi_job, gpointer buf, gpointer input);
223	static void _ncm_mpi_job_mcmc_unpack_return (NcmMPIJob *mpi_job, gpointer buf, gpointer ret);
224
225	static void _ncm_mpi_job_mcmc_run (NcmMPIJob *mpi_job, gpointer input, gpointer ret);
226
227	static void
228	ncm_mpi_job_mcmc_class_init (NcmMPIJobMCMCClass *klass)	111✔
229	{
230	GObjectClass *object_class = G_OBJECT_CLASS (klass);	111✔
231	NcmMPIJobClass *mpi_job_class = NCM_MPI_JOB_CLASS (klass);	111✔
232
233	object_class->set_property = &_ncm_mpi_job_mcmc_set_property;	111✔
234	object_class->get_property = &_ncm_mpi_job_mcmc_get_property;	111✔
235	object_class->constructed = &_ncm_mpi_job_mcmc_constructed;	111✔
236	object_class->dispose = &_ncm_mpi_job_mcmc_dispose;	111✔
237	object_class->finalize = &_ncm_mpi_job_mcmc_finalize;	111✔
238
239	g_object_class_install_property (object_class,	111✔
240	PROP_FIT,
241	g_param_spec_object ("fit",
242	NULL,
243	"Fit object",
244	NCM_TYPE_FIT,
245	G_PARAM_READWRITE \| G_PARAM_CONSTRUCT_ONLY \| G_PARAM_STATIC_NAME \| G_PARAM_STATIC_BLURB));
246	g_object_class_install_property (object_class,	111✔
247	PROP_FUNC_ARRAY,
248	g_param_spec_boxed ("function-array",
249	NULL,
250	"Functions array",
251	NCM_TYPE_OBJ_ARRAY,
252	G_PARAM_READWRITE \| G_PARAM_CONSTRUCT_ONLY \| G_PARAM_STATIC_NAME \| G_PARAM_STATIC_BLURB));
253
254	mpi_job_class->input_datatype = &_ncm_mpi_job_mcmc_input_datatype;	111✔
255	mpi_job_class->return_datatype = &_ncm_mpi_job_mcmc_return_datatype;	111✔
256
257	mpi_job_class->create_input = &_ncm_mpi_job_mcmc_create_input;	111✔
258	mpi_job_class->create_return = &_ncm_mpi_job_mcmc_create_return;	111✔
259
260	mpi_job_class->destroy_input = &_ncm_mpi_job_mcmc_destroy_input;	111✔
261	mpi_job_class->destroy_return = &_ncm_mpi_job_mcmc_destroy_return;	111✔
262
263	mpi_job_class->get_input_buffer = &_ncm_mpi_job_mcmc_get_input_buffer;	111✔
264	mpi_job_class->get_return_buffer = &_ncm_mpi_job_mcmc_get_return_buffer;	111✔
265
266	mpi_job_class->destroy_input_buffer = &_ncm_mpi_job_mcmc_destroy_input_buffer;	111✔
267	mpi_job_class->destroy_return_buffer = &_ncm_mpi_job_mcmc_destroy_return_buffer;	111✔
268
269	mpi_job_class->pack_input = &_ncm_mpi_job_mcmc_pack_input;	111✔
270	mpi_job_class->pack_return = &_ncm_mpi_job_mcmc_pack_return;	111✔
271
272	mpi_job_class->unpack_input = &_ncm_mpi_job_mcmc_unpack_input;	111✔
273	mpi_job_class->unpack_return = &_ncm_mpi_job_mcmc_unpack_return;	111✔
274
275	mpi_job_class->run = &_ncm_mpi_job_mcmc_run;	111✔
276	}	111✔
277
278	static NcmMPIDatatype
279	_ncm_mpi_job_mcmc_input_datatype (NcmMPIJob mpi_job, gint len, gint *size)	49✔
280	{
281	NcmMPIJobMCMC *mjmcmc = NCM_MPI_JOB_MCMC (mpi_job);	49✔
282	NcmMPIJobMCMCPrivate * const self = ncm_mpi_job_mcmc_get_instance_private (mjmcmc);	49✔
283
284	len[0] = self->fparam_len + NCM_FIT_ESMCMC_MPI_IN_LEN;	49✔
285	size[0] = sizeof (gdouble) * len[0];	49✔
286
287	return MPI_DOUBLE;	49✔
288	}
289
290	static NcmMPIDatatype
291	_ncm_mpi_job_mcmc_return_datatype (NcmMPIJob mpi_job, gint len, gint *size)	49✔
292	{
293	NcmMPIJobMCMC *mjmcmc = NCM_MPI_JOB_MCMC (mpi_job);	49✔
294	NcmMPIJobMCMCPrivate * const self = ncm_mpi_job_mcmc_get_instance_private (mjmcmc);	49✔
295
296	len[0] = NCM_FIT_ESMCMC_MPI_OUT_LEN + self->nadd_vals;	49✔
297	size[0] = sizeof (gdouble) * len[0];	49✔
298
299	return MPI_DOUBLE;	49✔
300	}
301
302	static gpointer
303	_ncm_mpi_job_mcmc_create_input (NcmMPIJob *mpi_job)	×
304	{
305	NcmMPIJobMCMC *mjmcmc = NCM_MPI_JOB_MCMC (mpi_job);	×
NEW 306	NcmMPIJobMCMCPrivate * const self = ncm_mpi_job_mcmc_get_instance_private (mjmcmc);	×
307
308	return ncm_vector_new (self->fparam_len + NCM_FIT_ESMCMC_MPI_IN_LEN);	×
309	}
310
311	static gpointer
312	_ncm_mpi_job_mcmc_create_return (NcmMPIJob *mpi_job)	×
313	{
314	NcmMPIJobMCMC *mjmcmc = NCM_MPI_JOB_MCMC (mpi_job);	×
NEW 315	NcmMPIJobMCMCPrivate * const self = ncm_mpi_job_mcmc_get_instance_private (mjmcmc);	×
316
317	return ncm_vector_new (NCM_FIT_ESMCMC_MPI_OUT_LEN + self->nadd_vals);	×
318	}
319
320	static void
321	_ncm_mpi_job_mcmc_destroy_input (NcmMPIJob *mpi_job, gpointer input)	×
322	{
323	ncm_vector_free (input);	×
324	}
325
326	static void
327	_ncm_mpi_job_mcmc_destroy_return (NcmMPIJob *mpi_job, gpointer ret)	×
328	{
329	ncm_vector_free (ret);	×
330	}
331
332	static gpointer
333	_ncm_mpi_job_mcmc_get_input_buffer (NcmMPIJob *mpi_job, gpointer input)	×
334	{
335	return ncm_vector_data (input);	×
336	}
337
338	static gpointer
339	_ncm_mpi_job_mcmc_get_return_buffer (NcmMPIJob *mpi_job, gpointer ret)	×
340	{
341	return ncm_vector_data (ret);	×
342	}
343
344	static void
345	_ncm_mpi_job_mcmc_destroy_input_buffer (NcmMPIJob *mpi_job, gpointer input, gpointer buf)	×
346	{
347	g_assert_cmphex (GPOINTER_TO_INT (ncm_vector_data (input)), ==, GPOINTER_TO_INT (buf));	×
348	}
349
350	static void
351	_ncm_mpi_job_mcmc_destroy_return_buffer (NcmMPIJob *mpi_job, gpointer ret, gpointer buf)	×
352	{
353	g_assert_cmphex (GPOINTER_TO_INT (ncm_vector_data (ret)), ==, GPOINTER_TO_INT (buf));	×
354	}
355
356	static gpointer
357	_ncm_mpi_job_mcmc_pack_input (NcmMPIJob *mpi_job, gpointer input)	×
358	{
359	return ncm_vector_data (input);	×
360	}
361
362	static gpointer
363	_ncm_mpi_job_mcmc_pack_return (NcmMPIJob *mpi_job, gpointer ret)	×
364	{
365	return ncm_vector_data (ret);	×
366	}
367
368	static void
369	_ncm_mpi_job_mcmc_unpack_input (NcmMPIJob *mpi_job, gpointer buf, gpointer input)	×
370	{
371	g_assert_cmphex (GPOINTER_TO_INT (ncm_vector_data (input)), ==, GPOINTER_TO_INT (buf));	×
372	}
373
374	static void
375	_ncm_mpi_job_mcmc_unpack_return (NcmMPIJob *mpi_job, gpointer buf, gpointer ret)	×
376	{
377	g_assert_cmphex (GPOINTER_TO_INT (ncm_vector_data (ret)), ==, GPOINTER_TO_INT (buf));	×
378	}
379
380	static void
381	_ncm_mpi_job_mcmc_run (NcmMPIJob *mpi_job, gpointer input, gpointer ret)	×
382	{
NEW 383	NcmMPIJobMCMC *mjmcmc = NCM_MPI_JOB_MCMC (mpi_job);	×
NEW 384	NcmMPIJobMCMCPrivate * const self = ncm_mpi_job_mcmc_get_instance_private (mjmcmc);	×
385	NcmMSet *mset = ncm_fit_peek_mset (self->fit);	×
386	const gdouble m2lnL_cur = ncm_vector_get (input, self->fparam_len + 0);	×
387	const gdouble norm = ncm_vector_get (input, self->fparam_len + 1);	×
388	const gdouble jump = ncm_vector_get (input, self->fparam_len + 2);	×
389	gdouble *m2lnL_star = ncm_vector_ptr (ret, NCM_FIT_ESMCMC_MPI_OUT_LEN);	×
390	gdouble prob = 0.0;	×
391	gboolean accepted = FALSE;	×
392
393	ncm_fit_params_set_vector (self->fit, input);	×
394
395	if (!ncm_mset_params_valid (mset))	×
396	m2lnL_star[0] = GSL_POSINF;	×
397	else
398	ncm_fit_m2lnL_val (self->fit, m2lnL_star);	×
399
400	if (gsl_finite (m2lnL_star[0]))	×
401	{
402	if (jump >= 0.0)	×
403	{
404	prob = exp ((m2lnL_cur - m2lnL_star[0]) * 0.5 + norm);	×
405	prob = MIN (prob, 1.0);	×
406	accepted = (jump < prob);	×
407	}
408	else
409	{
410	accepted = TRUE;
411	}
412	}
413
414	if (accepted)	×
415	{
416	ncm_vector_set (ret, 0, 1.0);	×
417
418	/printf ("# has oa?! %p\n", self->func_oa);/
419	if (self->func_oa != NULL)	×
420	{
421	guint i;
422
423	for (i = 0; i < self->func_oa->len; i++)	×
424	{
425	NcmMSetFunc *func = NCM_MSET_FUNC (ncm_obj_array_peek (self->func_oa, i));	×
426	const gdouble a_i = ncm_mset_func_eval0 (func, mset);	×
427
428	/printf ("### %d % 22.15g\n", i, a_i);/
429	ncm_vector_set (ret, i + 1 + NCM_FIT_ESMCMC_MPI_OUT_LEN, a_i);	×
430	}
431	}
432	}
433	else
434	{
435	ncm_vector_set (ret, 0, 0.0);	×
436	}
437	}
438
439	/**
440	* ncm_mpi_job_mcmc_new:
441	* @fit: a #NcmFit
442	* @func_oa: (array) (element-type NcmMSetFunc) (allow-none): a #NcmObjArray
443	*
444	* Creates a new #NcmMPIJobMCMC object.
445	*
446	* Returns: a new #NcmMPIJobMCMC.
447	*/
448	NcmMPIJobMCMC *
449	ncm_mpi_job_mcmc_new (NcmFit fit, NcmObjArray func_oa)	49✔
450	{
451	NcmMPIJobMCMC *mjmcmc = g_object_new (NCM_TYPE_MPI_JOB_MCMC,	49✔
452	"fit", fit,
453	"function-array", func_oa,
454	NULL);
455
456	return mjmcmc;	49✔
457	}
458
459	/**
460	* ncm_mpi_job_mcmc_ref:
461	* @mjmcmc: a #NcmMPIJobMCMC
462	*
463	* Increase the reference of @mjmcmc by one.
464	*
465	* Returns: (transfer full): @mjmcmc.
466	*/
467	NcmMPIJobMCMC *
468	ncm_mpi_job_mcmc_ref (NcmMPIJobMCMC *mjmcmc)	×
469	{
470	return g_object_ref (mjmcmc);	×
471	}
472
473	/**
474	* ncm_mpi_job_mcmc_free:
475	* @mjmcmc: a #NcmMPIJobMCMC
476	*
477	* Decrease the reference count of @mjmcmc by one.
478	*
479	*/
480	void
481	ncm_mpi_job_mcmc_free (NcmMPIJobMCMC *mjmcmc)	×
482	{
483	g_object_unref (mjmcmc);	×
484	}
485
486	/**
487	* ncm_mpi_job_mcmc_clear:
488	* @mjmcmc: a #NcmMPIJobMCMC
489	*
490	* Decrease the reference count of @mjmcmc by one, and sets the pointer *@mjmcmc to
491	* NULL.
492	*
493	*/
494	void
495	ncm_mpi_job_mcmc_clear (NcmMPIJobMCMC **mjmcmc)	×
496	{
497	g_clear_object (mjmcmc);	×
498	}
499

NumCosmo / NumCosmo / 7232289401

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