Loading [MathJax]/extensions/TeX/AMSsymbols.js
LALPulsar 7.1.1.1-8a6b96f
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
ppe_testing.c
Go to the documentation of this file.
1/*
2* Copyright (C) 2014 Matthew Pitkin
3*
4* This program is free software; you can redistribute it and/or modify
5* it under the terms of the GNU General Public License as published by
6* the Free Software Foundation; either version 2 of the License, or
7* (at your option) any later version.
8*
9* This program is distributed in the hope that it will be useful,
10* but WITHOUT ANY WARRANTY; without even the implied warranty of
11* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12* GNU General Public License for more details.
13*
14* You should have received a copy of the GNU General Public License
15* along with with program; see the file COPYING. If not, write to the
16* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
17* MA 02110-1301 USA
18*/
19
20/**
21 * \file
22 * \ingroup lalpulsar_bin_HeterodyneSearch
23 * \author Matthew Pitkin
24 *
25 * \brief Functions for use in testing the parameter estimation codes for
26 * targeted pulsar searches.
27 */
28
29#include "config.h"
30#include "ppe_testing.h"
31
32/* *****************************************************************************/
33/* TESTING FUNCTIONS */
34/* *****************************************************************************/
35
36/* upper limit calculation distribution helper function prototypes */
37static double ul_gauss_cdf_function( double x, void *params );
38static double ul_gauss_CDFRoot( double mu, double sigma, double min, double max );
39
40/**
41 * \brief A test function to calculate a 1D posterior on a grid
42 *
43 * This function is only to be used as a check/test of the code and will be run
44 * if the \c grid command line argument is present. It will calculate the
45 * posterior for one parameter (given by \c gridpar), between the ranges given
46 * by \c gridmin and \c gridmax (which default to 0 and 1) at a number of points
47 * given by \c gridsteps (which default to 100).
48 *
49 * \param runState [in] The analysis information structure
50 */
52{
53 LALInferenceThreadState *threadState = &runState->threads[0];
54 REAL8 h0min = 0.;
55 REAL8 h0max = 0.;
56 REAL8 h0range = 0, h0step = 0;
57 INT4 h0steps = 0, i = 0;
59
60 ProcessParamsTable *ppt;
61 REAL8 scale = 1., scalemin = 0., tmpscale = 0., tmpmin = 0., tmpgridval = 0.;
62
63 ProcessParamsTable *commandLine = runState->commandLine;
64
65 FILE *fp = NULL;
66 REAL8 minL = LAL_REAL8_MAX;
67 REAL8 sumPost = 0.;
68
69 REAL8Vector *logL = NULL;
70
71 CHAR *parname = NULL, parscale[256], parmin[256], outputgrid[256];
72
73 /*------------------------------------------------------------*/
74 /* test output on a h0 grid */
75 ppt = LALInferenceGetProcParamVal( commandLine, "--grid" );
76 if ( ppt ) {
77 ProcessParamsTable *ppt2;
78
79 /* parameters over which to perform the grid search */
80 ppt2 = LALInferenceGetProcParamVal( commandLine, "--gridpar" );
81
82 if ( ppt2 ) {
83 parname = XLALStringDuplicate( ppt2->value );
84
85 sprintf( parscale, "%s_scale", parname );
86 sprintf( parmin, "%s_scale_min", parname );
87 } else {
88 fprintf( stderr, USAGEGRID, commandLine->program );
89 exit( 0 );
90 }
91
92 ppt2 = LALInferenceGetProcParamVal( commandLine, "--gridmin" );
93
94 if ( ppt2 ) {
95 h0min = atof( ppt2->value );
96 } else {
97 h0min = 0.; /* default to zero */
98 }
99
100 ppt2 = LALInferenceGetProcParamVal( commandLine, "--gridmax" );
101
102 if ( ppt2 ) {
103 h0max = atof( ppt2->value );
104 } else {
105 h0max = 1.; /* default to 1 */
106 }
107
108 ppt2 = LALInferenceGetProcParamVal( commandLine, "--gridsteps" );
109
110 if ( ppt2 ) {
111 h0steps = atoi( ppt2->value );
112 } else {
113 h0steps = 100; /* default to 100 steps */
114 }
115 } else {
116 return;
117 }
118
119 if ( verbose ) {
120 fprintf( stderr, "Calculating posterior on %s over a grid from:\n", parname );
121 fprintf( stderr, "\t%le --> %le in %d steps.\n", h0min, h0max, h0steps );
122 }
123
124 h0range = h0max - h0min;
125 h0step = h0range / ( REAL8 )( h0steps - 1. );
126
127 logL = XLALCreateREAL8Vector( h0steps );
128
129 /* reset rescale value for h0 */
130 tmpscale = *( REAL8 * )LALInferenceGetVariable( threadState->model->ifo->params,
131 parscale );
132 tmpmin = *( REAL8 * )LALInferenceGetVariable( threadState->model->ifo->params,
133 parmin );
134 LALInferenceRemoveVariable( threadState->model->ifo->params, parscale );
135 LALInferenceAddVariable( threadState->model->ifo->params, parscale, &scale,
137 LALInferenceRemoveVariable( threadState->model->ifo->params, parmin );
138 LALInferenceAddVariable( threadState->model->ifo->params, parmin, &scalemin,
140
141 tmpgridval = *( REAL8 * )LALInferenceGetVariable( threadState->currentParams,
142 parname );
143
144 sprintf( outputgrid, "%s_grid_posterior.txt", parname );
145
146 if ( ( fp = fopen( outputgrid, "w" ) ) == NULL ) {
147 fprintf( stderr, "Error... cannot open grid posterior file %s.\n",
148 outputgrid );
149 exit( 0 );
150 }
151
152 for ( i = 0; i < h0steps; i++ ) {
153 REAL8 h0val = h0min + i * h0step;
154
155 LALInferenceSetVariable( threadState->currentParams, parname, &h0val );
156
157 logL->data[i] = runState->likelihood( threadState->currentParams,
158 runState->data, threadState->model );
159
160 if ( logL->data[i] < minL ) {
161 minL = logL->data[i];
162 }
163 }
164
165 /* integrate area under posterior - trapezium rule */
166 for ( i = 0; i < h0steps - 1; i++ ) {
167 sumPost += ( exp( logL->data[i] - minL ) + exp( logL->data[i + 1] - minL ) ) *
168 h0step / 2.;
169 }
170
171 /* output posterior */
172 for ( i = 0; i < h0steps; i++ ) {
173 REAL8 h0val = h0min + i * h0step;
174 fprintf( fp, "%le\t%le\n", h0val, exp( logL->data[i] - minL ) / sumPost );
175 }
176
177 fclose( fp );
178
180
181 /* reset scale value and parameter value in currentParams */
182 LALInferenceRemoveVariable( threadState->model->ifo->params, parscale );
183 LALInferenceAddVariable( threadState->model->ifo->params, parscale, &tmpscale,
185
186 LALInferenceRemoveVariable( threadState->model->ifo->params, parmin );
187 LALInferenceAddVariable( threadState->model->ifo->params, parmin, &tmpmin,
189
190 LALInferenceSetVariable( threadState->currentParams, parname, &tmpgridval );
191}
192
193/**
194 * \brief Test the sampler using a Gaussian likelihood
195 *
196 * This is a testing function that can be substituted for the standard
197 * likelihood function. It calculates only the \c h0 parameter posterior based
198 * on a Gaussian likelihood with mean of 0.0 and standard deviation of 0.025 -
199 * these values can be changed if required. It is just to be used to test the
200 * sampling routine (e.g. Nested Sampling) with a well defined likelihood
201 * function.
202 *
203 * \param vars [in] A set of pulsar parameters
204 * \param data [in] A data structure
205 * \param get_model UNDOCUMENTED
206 *
207 * \return Natural logarithm of the likelihood
208 */
211 LALInferenceModel *get_model )
212{
213 REAL8 loglike = 0.; /* the log likelihood */
214
215 REAL8 like_mean = LALInferenceGetREAL8Variable( vars, "H0MEAN" );
216 REAL8 like_sigma = LALInferenceGetREAL8Variable( vars, "H0SIGMA" );
217
218 if ( !LALInferenceCheckVariable( vars, "H0" ) ) {
219 fprintf( stderr, "Error... testing Gaussian likelihood required the \"H0\" parameter to be set in the prior file.\n" );
220 exit( 1 );
221 }
222
223 REAL8 h0 = LALInferenceGetREAL8Variable( vars, "H0" );
224
225 /* search over a simple 1D Gaussian with x defined by the h0 variable */
226 loglike = -log( sqrt( 2.*LAL_PI ) * like_sigma );
227 loglike -= 0.5 * ( h0 - like_mean ) * ( h0 - like_mean ) / ( like_sigma * like_sigma );
228 get_model->ifo_loglikelihoods[0] = loglike;
229
230 data->likeli_counter += 1;
231
232 return loglike;
233}
234
235
236/**
237 * \brief Output the analytic evidence for the test Gaussian likelihood and a 95% upper limit
238 *
239 * This function calculated the analytical evidence for a given test Gaussian likelihood and
240 * also a 95% upper limit on the likelihood. The values are output to the HDF5 file if given,
241 * but otherwise are just output to screen.
242 *
243 * \param runState [in] The LALInference run state variable
244 */
246{
247 ProcessParamsTable *ppt = NULL;
248 FILE *fp = NULL;
249
250 /* get the minimum and maximum ranges for the Gaussian */
251 REAL8 min = 0., max = INFINITY, Z;
252 if ( LALInferenceCheckMinMaxPrior( runState->priorArgs, "H0" ) ) {
253 LALInferenceGetMinMaxPrior( runState->priorArgs, "H0", &min, &max );
254 } else {
255 fprintf( stderr, "Error... no prior range set for the test Gaussian likelihood" );
256 exit( 1 );
257 }
258
259 /* get mean and standard deviation */
260 REAL8 h0mean = 0., h0sigma = 0., h0sigma2 = 0., h095 = 0.;
261 h0mean = LALInferenceGetREAL8Variable( runState->threads[0].currentParams, "H0MEAN" );
262 h0sigma = LALInferenceGetREAL8Variable( runState->threads[0].currentParams, "H0SIGMA" );
263 h0sigma2 = h0sigma * h0sigma;
264
265 /* calculate the log evidence */
266 Z = log( 0.5 * ( erf( LAL_SQRT1_2 * ( h0mean - min ) / h0sigma ) - erf( LAL_SQRT1_2 * ( h0mean - max ) / h0sigma ) ) );
267 Z -= log( max - min ); /* multiply by prior */
268
269 /* calculate the 95% upper limit */
270 h095 = ul_gauss_CDFRoot( h0mean, h0sigma, min, max );
271
272 /* calculate the KL divergence */
273 REAL8 lnC = -log( max - min ); /* log of prior */
274 REAL8 p_Z = exp( lnC - Z ); /* prior divided by the evidence */
275 REAL8 L = Z + 0.5 * log( LAL_TWOPI * h0sigma2 );
276 REAL8 D = ( 1. + 2.*L ) * ( erf( ( h0mean - min ) * LAL_SQRT1_2 / h0sigma ) - erf( ( h0mean - max ) * LAL_SQRT1_2 / h0sigma ) );
277 REAL8 G = ( 1. / ( sqrt( LAL_TWOPI ) * h0sigma ) ) * ( ( min - h0mean ) * exp( -0.5 * ( min - h0mean ) * ( min - h0mean ) / h0sigma2 ) - ( max - h0mean ) * exp( -0.5 * ( max - h0mean ) * ( max - h0mean ) / h0sigma2 ) );
278 REAL8 KLdiv = -0.25 * p_Z * ( D + 2.*G );
279
280 /* Open output file (called test_gauss.txt) using the path of the --outfile value */
281 ppt = LALInferenceGetProcParamVal( runState->commandLine, "--outfile" );
282 char *outfile = XLALStringDuplicate( ppt->value ), *loc = NULL;
283 /* find last '/' and replace with null termination character */
284 loc = strrchr( outfile, '/' );
285 if ( loc ) {
286 outfile[strlen( outfile ) - strlen( loc ) + 1] = '\0';
287 } else {
288 outfile = NULL;
289 }
290 outfile = XLALStringAppend( outfile, "test_gauss.txt" );
291
292 if ( ( fp = fopen( outfile, "w" ) ) != NULL ) {
293 fprintf( fp, "%.12le\t%.12le\t%.12le\n", Z, h095, KLdiv );
294 fclose( fp );
295 } else {
296 fprintf( stderr, "Warning... could not open test Gaussian output file '%s'.", outfile );
297 }
298}
299
300
301typedef struct tagul_params {
302 double mu;
303 double sigma;
304 double min;
305 double area;
306} ul_params;
307
308/* internal Gaussian CDF function for 95% upper limit finding */
309double ul_gauss_cdf_function( double x, void *params )
310{
311 ul_params *p = ( ul_params * )params;
312
313 double mu = p->mu;
314 double sigma = p->sigma;
315 double min = p->min;
316 double area = p->area;
317 double ul = 0.95; /* calculating 95% upper limit */
318 double C = 1. / ( sqrt( 2. ) * sigma );
319
320 return ( 0.5 * ( erf( C * ( mu - min ) ) - erf( C * ( mu - x ) ) ) / area ) - ul;
321}
322
323
324/** \brief Find the root of the Gaussian CDF to give a 95% upper limit
325 *
326 * Use the Steffenson method to find the root of the function defined in \c ul_gauss_function.
327 */
328static double ul_gauss_CDFRoot( double mu, double sigma, double min, double max )
329{
330 int gslstatus;
331 int iter = 0, max_iter = 100;
332 const gsl_root_fsolver_type *T;
333 gsl_root_fsolver *s;
334 double x_lo, x_hi;
335 double epsrel = 1e-4; /* relative error tolerance */
336
337 double C = 1. / ( sqrt( 2. ) * sigma );
338 double area = 0.5 * ( erf( C * ( mu - min ) ) - erf( C * ( mu - max ) ) );
339
340 gsl_function F;
341 ul_params params = {mu, sigma, min, area};
342
343 double x;
344 /* initial bounds of value */
345 x_lo = mu - 10.*sigma;
346 x_hi = mu + 10.*sigma;
347
348 F.function = &ul_gauss_cdf_function;
349 F.params = &params;
350
351 T = gsl_root_fsolver_brent; /* use Brent method */
352 s = gsl_root_fsolver_alloc( T );
353 gsl_root_fsolver_set( s, &F, x_lo, x_hi );
354
355 do {
356 iter++;
357 gslstatus = gsl_root_fsolver_iterate( s );
358 x = gsl_root_fsolver_root( s );
359 x_lo = gsl_root_fsolver_x_lower( s );
360 x_hi = gsl_root_fsolver_x_upper( s );
361
362 /* test relative error of bounds */
363 gslstatus = gsl_root_test_interval( x_lo, x_hi, 0., epsrel );
364 } while ( gslstatus == GSL_CONTINUE && iter < max_iter );
365
366 if ( gslstatus != GSL_SUCCESS ) {
367 XLALPrintError( "%s: Failed to converge when drawing from Fermi-Dirac distribution.", __func__ );
369 }
370
371 gsl_root_fsolver_free( s );
372
373 return x;
374}
375
376
377/**
378 * \brief Output a number of prior samples based on the initial live points
379 *
380 * This function will output prior samples for variable parameters (as create by
381 * the LALInferenceSetupLivePointsArray function).
382 *
383 * \param runState [in]
384 */
386{
387 ProcessParamsTable *ppt = LALInferenceGetProcParamVal( runState->commandLine,
388 "--output-prior" );
390 "Nlive" );
391
392 if ( ppt ) {
393 FILE *fp = NULL;
394
395 /* loop over the live points */
396 INT4 i = 0;
397
398 if ( ( fp = fopen( "prior_samples.txt", "w" ) ) == NULL ) {
399 fprintf( stderr, "Error... could not open prior samples file\n" );
400 exit( 1 );
401 }
402
403 for ( i = 0; i < Nlive; i++ ) {
404 /* output variable parameters, rescaled to their proper ranges */
405 LALInferenceVariableItem *item = runState->livePoints[i]->head;
406
407 /* print out variables names */
408 if ( i == 0 ) {
409 fprintf( fp, "%% " );
410
411 while ( item ) {
412 if ( item->vary == LALINFERENCE_PARAM_LINEAR ||
414 fprintf( fp, "%s\t", item->name );
415 }
416
417 item = item->next;
418 }
419
420 fprintf( fp, "\n" );
421 }
422
423 item = runState->livePoints[i]->head; /* reset */
424
425 while ( item ) {
426 if ( item->vary == LALINFERENCE_PARAM_LINEAR ||
428 REAL8 var = 0.;
429 var = *( REAL8 * )item->value;
430 fprintf( fp, "%.16le\t", var );
431 }
432
433 item = item->next;
434 }
435 fprintf( fp, "\n" );
436 }
437
438 fclose( fp );
439 }
440}
441
442
443/**
444 * \brief Read in an ascii text file of nested samples and compare the log likelihoods
445 *
446 * This function reads in a file containing nested samples, including their log likelihoods, recomputes
447 * the full likelihood and compares it to the previously output value. This is useful for comparing
448 * outputs using ROQ to outputs using the full likelihood.
449 */
451{
452 ProcessParamsTable *ppt = NULL;
453 CHAR *sampfile = NULL, *namefile = NULL;
454 CHAR *parambuf = NULL, *databuf = NULL;
455 LALInferenceVariables *curparams = NULL;
456 UINT4 j = 0, k = 0;
457 FILE *fp = NULL;
458 REAL8 logLnew = 0., logL = 0.;
459
460 /* allocate memory for nested samples */
461 curparams = XLALCalloc( 1, sizeof( LALInferenceVariables ) );
463
464 /* read in parameter names from header file */
465 ppt = LALInferenceGetProcParamVal( rs->commandLine, "--sample-file-header" );
466 if ( ppt != NULL ) {
467 namefile = ppt->value;
468 } else {
469 XLAL_ERROR_VOID( XLAL_EINVAL, "Error... no nested samples header file given.\n" );
470 }
471 parambuf = XLALFileLoad( namefile );
472 TokenList *paramNames = NULL;
473 /* seperate parameter names */
474 if ( XLALCreateTokenList( &paramNames, parambuf, " \t" ) != XLAL_SUCCESS ) {
475 XLAL_ERROR_VOID( XLAL_EINVAL, "Error... could not read in parameter names.\n" );
476 }
477
478 /* get names of nested sample file columns */
479 ppt = LALInferenceGetProcParamVal( rs->commandLine, "--sample-file" );
480 if ( ppt != NULL ) {
481 sampfile = ppt->value;
482 } else {
483 XLAL_ERROR_VOID( XLAL_EINVAL, "Error... no nested samples file given.\n" );
484 }
485 databuf = XLALFileLoad( sampfile );
486 TokenList *sampsList = NULL;
487 /* seperate samples */
488 if ( XLALCreateTokenList( &sampsList, databuf, "\n" ) != XLAL_SUCCESS ) {
489 XLAL_ERROR_VOID( XLAL_EINVAL, "Error... could not read in nested samples.\n" );
490 }
491
492 fp = fopen( "likelihoodComp.txt", "w" );
493
494 /* loop over samples and calculate likelihoods */
495 for ( k = 0; k < sampsList->nTokens; k++ ) {
496 /* remove "fixed variable" logL from curparams */
497 if ( LALInferenceCheckVariable( curparams, "logL" ) ) {
498 LALInferenceRemoveVariable( curparams, "logL" );
499 }
500
501 /* split line */
502 TokenList *paramVals = NULL;
503 if ( XLALCreateTokenList( &paramVals, sampsList->tokens[k], " \t" ) != XLAL_SUCCESS ) {
504 XLAL_ERROR_VOID( XLAL_EINVAL, "Error... could not separate parameter values.\n" );
505 }
506
507 /* copy parameters into LALInferenceVariables structure */
508 for ( j = 0; j < paramNames->nTokens; j++ ) {
509 REAL8 value = atof( paramVals->tokens[j] );
511 }
512
513 if ( !LALInferenceCheckVariable( curparams, "logL" ) ) {
514 XLAL_ERROR_VOID( XLAL_EINVAL, "Error... no log likelihood value present in nested samples file.\n" );
515 }
516
517 logL = LALInferenceGetREAL8Variable( curparams, "logL" );
518 logLnew = rs->likelihood( curparams, rs->data, rs->threads[0].model );
519 fprintf( stderr, "%.16le\t%.16le\t%.16le\n", logL, logLnew, logL - logLnew );
520 fprintf( fp, "%.16le\t%.16le\t%.16le\n", logL, logLnew, logL - logLnew );
521
522 XLALDestroyTokenList( paramVals );
523 }
524
525 fclose( fp );
526
527 XLALFree( parambuf );
528 XLALFree( databuf );
529 XLALDestroyTokenList( sampsList );
530 XLALDestroyTokenList( paramNames );
531}
532
533/*----------------------- END OF TESTING FUNCTIONS ---------------------------*/
#define __func__
log an I/O error, i.e.
#define min(a, b)
ProcessParamsTable * ppt
int j
int k
#define D(j)
#define L(i, j)
#define fprintf
void XLALDestroyTokenList(TokenList *list)
int XLALCreateTokenList(TokenList **list, const CHAR *string, const CHAR *delimiters)
const double scale
multiplicative scaling factor of the coordinate
double e
char * XLALFileLoad(const char *path)
#define LAL_PI
#define LAL_TWOPI
#define LAL_SQRT1_2
#define LAL_REAL8_MAX
double REAL8
char CHAR
uint32_t UINT4
int32_t INT4
void LALInferenceAddVariable(LALInferenceVariables *vars, const char *name, const void *value, LALInferenceVariableType type, LALInferenceParamVaryType vary)
REAL8 LALInferenceGetREAL8Variable(LALInferenceVariables *vars, const char *name)
void LALInferenceRemoveVariable(LALInferenceVariables *vars, const char *name)
void LALInferenceCopyVariables(LALInferenceVariables *origin, LALInferenceVariables *target)
void * LALInferenceGetVariable(const LALInferenceVariables *vars, const char *name)
ProcessParamsTable * LALInferenceGetProcParamVal(ProcessParamsTable *procparams, const char *name)
int LALInferenceCheckVariable(LALInferenceVariables *vars, const char *name)
void LALInferenceSetVariable(LALInferenceVariables *vars, const char *name, const void *value)
LALINFERENCE_PARAM_FIXED
LALINFERENCE_PARAM_CIRCULAR
LALINFERENCE_PARAM_LINEAR
LALINFERENCE_REAL8_t
int LALInferenceCheckMinMaxPrior(LALInferenceVariables *priorArgs, const char *name)
void LALInferenceGetMinMaxPrior(LALInferenceVariables *priorArgs, const char *name, REAL8 *min, REAL8 *max)
void * XLALCalloc(size_t m, size_t n)
void XLALFree(void *p)
char char * XLALStringDuplicate(const char *s)
int char * XLALStringAppend(char *s, const char *append)
REAL8Vector * XLALCreateREAL8Vector(UINT4 length)
void XLALDestroyREAL8Vector(REAL8Vector *vector)
#define XLAL_ERROR_VOID(...)
#define XLAL_ERROR_REAL8(...)
int XLALPrintError(const char *fmt,...) _LAL_GCC_PRINTF_FORMAT_(1
XLAL_SUCCESS
XLAL_EINVAL
XLAL_EFAILED
float data[BLOCKSIZE]
Definition: hwinject.c:360
list mu
T
void test_gaussian_output(LALInferenceRunState *runState)
Output the analytic evidence for the test Gaussian likelihood and a 95% upper limit.
Definition: ppe_testing.c:245
REAL8 test_gaussian_log_likelihood(LALInferenceVariables *vars, LALInferenceIFOData *data, LALInferenceModel *get_model)
Test the sampler using a Gaussian likelihood.
Definition: ppe_testing.c:209
void compare_likelihoods(LALInferenceRunState *rs)
Read in an ascii text file of nested samples and compare the log likelihoods.
Definition: ppe_testing.c:450
void outputPriorSamples(LALInferenceRunState *runState)
Output a number of prior samples based on the initial live points.
Definition: ppe_testing.c:385
static double ul_gauss_cdf_function(double x, void *params)
Definition: ppe_testing.c:309
void gridOutput(LALInferenceRunState *runState)
A test function to calculate a 1D posterior on a grid.
Definition: ppe_testing.c:51
static double ul_gauss_CDFRoot(double mu, double sigma, double min, double max)
Find the root of the Gaussian CDF to give a 95% upper limit.
Definition: ppe_testing.c:328
Header file for functions used in testing the parameter estimation code for known pulsar searches usi...
#define USAGEGRID
The usage format for the test case of performing the analysis on a one-dimensional grid.
Definition: ppe_testing.h:40
LALInferenceVariables * params
REAL8 * ifo_loglikelihoods
LALInferenceIFOModel * ifo
ProcessParamsTable * commandLine
LALInferenceVariables * algorithmParams
struct tagLALInferenceIFOData * data
LALInferenceVariables * priorArgs
LALInferenceThreadState * threads
LALInferenceVariables ** livePoints
LALInferenceLikelihoodFunction likelihood
LALInferenceVariables * currentParams
LALInferenceModel * model
char name[VARNAME_MAX]
struct tagVariableItem * next
LALInferenceParamVaryType vary
LALInferenceVariableItem * head
REAL8 * data
CHAR ** tokens
UINT4 nTokens
double mu
Definition: ppe_testing.c:302
double area
Definition: ppe_testing.c:305
double sigma
Definition: ppe_testing.c:303
double min
Definition: ppe_testing.c:304
#define max(a, b)