/* Set the XLAL error number to errnum. */
int XLALSetErrno(int errnum)
{
if (errnum == 0) {
xlalErrno = 0;
return xlalErrno;
}
/*
* if this is an error indicating an internal error then set the bit
* that indicates this; otherwise, xlalErrno should presumably be zero
*/
if (errnum & XLAL_EFUNC) {
xlalErrno |= XLAL_EFUNC; /* make sure XLAL_EFUNC bit is set */
return xlalErrno;
}
/*
* if xlalErrno is not zero, probably forgot to deal with previous
* error
*/
if (xlalErrno)
XLAL_PRINT_WARNING("Ignoring previous error (xlalErrno=%d) %s\n",
xlalErrno, XLALErrorString(xlalErrno));
xlalErrno = errnum;
return xlalErrno;
}
/* Print an error message associated with an error number or return code. */
void XLALPerror(const char *func, const char *file, int line, int code)
{
if (code > 0)
XLALPrintError("XLAL Error");
else
XLALPrintError("XLAL Result");
if (func && *func)
XLALPrintError(" - %s", func);
if (file && *file)
XLALPrintError(" (%s:%d)", file, line);
XLALPrintError(": %s\n", XLALErrorString(code));
return;
}
int LALInferenceInspiralPriorTest(void)
{
TEST_HEADER();
int errnum;
REAL8 result;
LALInferenceRunState *runState = XLALCalloc(1, sizeof(LALInferenceRunState));
LALInferenceThreadState *thread = XLALCalloc(1, sizeof(LALInferenceThreadState));
runState->threads = XLALCalloc(1, sizeof(LALInferenceThreadState*));
runState->threads[0] = thread;
LALInferenceVariables *params = XLALCalloc(1, sizeof(LALInferenceVariables));
LALInferenceVariables *priorArgs = XLALCalloc(1, sizeof(LALInferenceVariables));
// Standard null reference check.
int failed = 1;
runState->priorArgs = NULL;
thread->model = NULL;
XLAL_TRY(result = LALInferenceInspiralPrior(runState, params, thread->model), errnum);
failed &= !XLAL_IS_REAL8_FAIL_NAN(result) || errnum != XLAL_EFAULT;
runState->priorArgs = priorArgs;
XLAL_TRY(result = LALInferenceInspiralPrior(NULL, params, thread->model), errnum);
failed &= !XLAL_IS_REAL8_FAIL_NAN(result) || errnum != XLAL_EFAULT;
XLAL_TRY(result = LALInferenceInspiralPrior(runState, NULL, thread->model), errnum);
failed &= !XLAL_IS_REAL8_FAIL_NAN(result) || errnum != XLAL_EFAULT;
if (failed)
TEST_FAIL("Null reference check failed.");
// Set up parameters.
REAL8 value = 0;
LALInferenceAddVariable(params, "logdistance", &value, LALINFERENCE_REAL8_t, LALINFERENCE_PARAM_LINEAR);
LALInferenceAddVariable(params, "distance", &value, LALINFERENCE_REAL8_t, LALINFERENCE_PARAM_LINEAR);
LALInferenceAddVariable(params, "inclination", &value, LALINFERENCE_REAL8_t, LALINFERENCE_PARAM_CIRCULAR);
LALInferenceAddVariable(params, "rightascension", &value, LALINFERENCE_REAL8_t, LALINFERENCE_PARAM_CIRCULAR);
LALInferenceAddVariable(params, "declination", &value, LALINFERENCE_REAL8_t, LALINFERENCE_PARAM_CIRCULAR);
LALInferenceAddVariable(params, "theta_spin1", &value, LALINFERENCE_REAL8_t, LALINFERENCE_PARAM_CIRCULAR);
LALInferenceAddVariable(params, "theta_spin2", &value, LALINFERENCE_REAL8_t, LALINFERENCE_PARAM_CIRCULAR);
LALInferenceAddVariable(params, "logmc", &value, LALINFERENCE_REAL8_t, LALINFERENCE_PARAM_LINEAR);
LALInferenceAddVariable(params, "chirpmass", &value, LALINFERENCE_REAL8_t, LALINFERENCE_PARAM_LINEAR);
/*LALInferenceAddVariable(params, "q", &value, LALINFERENCE_REAL8_t, LALINFERENCE_PARAM_LINEAR);*/
LALInferenceAddVariable(params, "eta", &value, LALINFERENCE_REAL8_t, LALINFERENCE_PARAM_LINEAR);
REAL8 min, max;
min = 1.0; max = 100.0;
LALInferenceAddMinMaxPrior(priorArgs, "distance", &min, &max, LALINFERENCE_REAL8_t);
min = log(min); max = log(max);
LALInferenceAddMinMaxPrior(priorArgs, "logdistance", &min, &max, LALINFERENCE_REAL8_t);
min = 1.0; max = 20.5;
LALInferenceAddMinMaxPrior(priorArgs, "chirpmass", &min, &max, LALINFERENCE_REAL8_t);
min = log(min); max = log(max);
LALInferenceAddMinMaxPrior(priorArgs, "logmc", &min, &max, LALINFERENCE_REAL8_t);
min = 1.0; max = 30.0;
LALInferenceAddMinMaxPrior(priorArgs, "mass1", &min, &max, LALINFERENCE_REAL8_t);
LALInferenceAddMinMaxPrior(priorArgs, "mass2", &min, &max, LALINFERENCE_REAL8_t);
/*max *= 2;*/
/*LALInferenceAddVariable(priorArgs, "MTotMax", &max, LALINFERENCE_REAL8_t, LALINFERENCE_PARAM_FIXED);*/
min = -LAL_PI; max = LAL_PI;
LALInferenceAddMinMaxPrior(priorArgs, "inclination", &min, &max, LALINFERENCE_REAL8_t);
min = 0; max = LAL_TWOPI;
LALInferenceAddMinMaxPrior(priorArgs, "rightascension", &min, &max, LALINFERENCE_REAL8_t);
min = -LAL_PI / 2.0; max = LAL_PI / 2.0;
LALInferenceAddMinMaxPrior(priorArgs, "declination", &min, &max, LALINFERENCE_REAL8_t);
min = -LAL_PI / 2.0; max = LAL_PI / 2.0;
LALInferenceAddMinMaxPrior(priorArgs, "theta_spin1", &min, &max, LALINFERENCE_REAL8_t);
min = -LAL_PI / 2.0; max = LAL_PI / 2.0;
LALInferenceAddMinMaxPrior(priorArgs, "theta_spin2", &min, &max, LALINFERENCE_REAL8_t);
min = 0.01; max = 0.25;
LALInferenceAddMinMaxPrior(priorArgs, "eta", &min, &max, LALINFERENCE_REAL8_t);
// Pick a random point in the non-zero region of the parameter space.
gsl_rng *rng = gsl_rng_alloc(gsl_rng_default);
gsl_rng_set(rng, 0);
LALInferenceDrawFromPrior(params, priorArgs, rng);
// Check that we get a finite log prior.
XLAL_TRY(result = LALInferenceInspiralPrior(runState, params, thread->model), errnum);
if (XLAL_IS_REAL8_FAIL_NAN(result) || errnum != XLAL_SUCCESS)
{
TEST_FAIL("Could not generate inspiral prior; XLAL error: %s", XLALErrorString(errnum));
}
else if (result == -DBL_MAX)
{
TEST_FAIL("Parameter configuration within specified min/max bounds for each parameter gave zero prior.");
}
// Now set a parameter outside its bounds and see what happens.
LALInferenceGetMinMaxPrior(priorArgs, "distance", &min, &max);
value = max + (max - min) / 2;
LALInferenceSetVariable(params, "distance", &value);
XLAL_TRY(result = LALInferenceInspiralPrior(runState, params, thread->model), errnum);
if (XLAL_IS_REAL8_FAIL_NAN(result) || errnum != XLAL_SUCCESS)
{
TEST_FAIL("Could not generate inspiral prior; XLAL error: %s", XLALErrorString(errnum));
}
else if (result != -DBL_MAX)
{
TEST_FAIL("Distance %f is outside [%f,%f] but prior is non-zero.", value, min, max);
}
// Try another configuration; this time set m1 and m2 such that one is *outside* its bounds,
// but the chirp mass and symmetric mass ratio are still OK; this should be picked up and a
// zero prior returned.
LALInferenceDrawFromPrior(params, priorArgs, rng);
LALInferenceGetMinMaxPrior(priorArgs, "mass1", &min, &max);
REAL8 m2 = 0.5;
REAL8 m1 = 3.82;
REAL8 eta = m1 * m2 / pow(m1 + m2, 2);
LALInferenceSetVariable(params, "eta", &eta);
REAL8 Mc = pow(m1 * m2, 3.0 / 5.0) / pow(m1 + m2, 1.0 / 5.0);
LALInferenceSetVariable(params, "chirpmass", &Mc);
REAL8 logMc = log(Mc);
LALInferenceSetVariable(params, "logmc", &logMc);
XLAL_TRY(result = LALInferenceInspiralPrior(runState, params, thread->model), errnum);
if (XLAL_IS_REAL8_FAIL_NAN(result) || errnum != XLAL_SUCCESS)
{
TEST_FAIL("Could not generate inspiral prior; XLAL error: %s", XLALErrorString(errnum));
}
else if (result != -DBL_MAX)
{
TEST_FAIL("Mass ratio %f and chirp mass %f define masses outside bounds [%f,%f], but prior is non-zero.", eta, Mc, min, max);
}
TEST_FOOTER();
}
int LALInferenceDrawFromPriorTest(void)
{
TEST_HEADER();
int errnum;
const char *name;
gsl_rng *rng = gsl_rng_alloc(gsl_rng_default);
gsl_rng_set(rng, 0);
LALInferenceVariables *output = XLALCalloc(1, sizeof(LALInferenceVariables));
LALInferenceVariables *priorArgs = XLALCalloc(1, sizeof(LALInferenceVariables));
// Null reference checks.
int outcome = 1;
XLAL_TRY(LALInferenceDrawFromPrior(NULL, priorArgs, rng), errnum);
outcome &= errnum == XLAL_EFAULT;
XLAL_TRY(LALInferenceDrawFromPrior(output, NULL, rng), errnum);
outcome &= errnum == XLAL_EFAULT;
XLAL_TRY(LALInferenceDrawFromPrior(output, priorArgs, NULL), errnum);
outcome &= errnum == XLAL_EFAULT;
if (!outcome)
TEST_FAIL("Null reference check failed.");
int i;
const char *varyName=NULL;
char caseTag[VARNAME_MAX];
LALInferenceVariableType type = LALINFERENCE_REAL8_t;
LALInferenceParamVaryType vary=-1;
for (i = 0; i < 2; i++)
{
switch (i)
{
case 0:
vary = LALINFERENCE_PARAM_LINEAR;
varyName = "linear";
break;
case 1:
vary = LALINFERENCE_PARAM_CIRCULAR;
varyName = "circular";
break;
}
sprintf(caseTag, "[%s] ", varyName);
// Try and generate some normally distributed variables for various mu and sigma.
REAL8 gaussian = 0;
REAL8 mu;
REAL8 sigma;
name = "gaussian";
LALInferenceAddVariable(output, name, &gaussian, type, vary);
// Zero standard deviation; should always equal mean.
mu = -50;
sigma = 0;
LALInferenceRemoveGaussianPrior(priorArgs, name);
LALInferenceAddGaussianPrior(priorArgs, name, &mu, &sigma, type);
XLAL_TRY(LALInferenceDrawFromPrior(output, priorArgs, rng), errnum);
gaussian = *(REAL8*)LALInferenceGetVariable(output, name);
if (errnum != XLAL_SUCCESS)
{
TEST_FAIL("%sFailed to generate Gaussian variable; XLAL error: %s.", caseTag, XLALErrorString(errnum));
}
else if (!compareFloats(gaussian, mu, EPSILON))
{
TEST_FAIL("%sGaussian variable with zero standard deviation did not match the mean; X = %f, mu = %f.", caseTag, gaussian, mu);
}
LALInferenceRemoveVariable(output, name);
LALInferenceRemoveGaussianPrior(priorArgs, name);
// Try a uniform variable!
REAL8 uniform = 0;
REAL8 min;
REAL8 max;
name = "uniform";
LALInferenceAddVariable(output, name, &uniform, type, vary);
min = -1;
max = 1;
LALInferenceRemoveMinMaxPrior(priorArgs, name);
LALInferenceAddMinMaxPrior(priorArgs, name, &min, &max, type);
XLAL_TRY(LALInferenceDrawFromPrior(output, priorArgs, rng), errnum);
if (errnum != XLAL_SUCCESS)
TEST_FAIL("%sFailed to generate uniform variable; XLAL error: %s.", caseTag, XLALErrorString(errnum));
LALInferenceRemoveVariable(output, name);
LALInferenceRemoveMinMaxPrior(priorArgs, name);
// Try a correlated variable!
REAL8 correlated = 0;
UINT4 idx = 0;
name = "correlated";
gsl_matrix *covariance = gsl_matrix_calloc(3, 3);
LALInferenceAddVariable(output, name, &correlated, type, vary);
LALInferenceRemoveCorrelatedPrior(priorArgs);
// See what happens when we try to add a non-positive-definite covariance matrix
gsl_matrix_set(covariance, 0, 0, -1);
XLAL_TRY(LALInferenceAddCorrelatedPrior(priorArgs, name, &covariance, &mu, &sigma, &idx), errnum);
if (errnum == XLAL_SUCCESS)
TEST_FAIL("%sNon-positive-definite covariance matrix was not rejected.", caseTag);
LALInferenceRemoveCorrelatedPrior(priorArgs);
// Now try a positive-semi-definite matrix; this should be accepted
covariance = gsl_matrix_calloc(3, 3);
gsl_matrix_set(covariance, 0, 0, 1);
XLAL_TRY(LALInferenceAddCorrelatedPrior(priorArgs, name, &covariance, &mu, &sigma, &idx), errnum);
if (errnum != XLAL_SUCCESS)
TEST_FAIL("%sCould not add semi-positive-definite covariance matrix.", caseTag);
LALInferenceRemoveCorrelatedPrior(priorArgs);
// Try a legitimate positive-definite covariance matrix.
covariance = gsl_matrix_calloc(3, 3);
gsl_matrix_set(covariance, 0, 0, 2);
gsl_matrix_set(covariance, 0, 1, 1);
gsl_matrix_set(covariance, 0, 2, 0);
gsl_matrix_set(covariance, 1, 0, 1);
gsl_matrix_set(covariance, 1, 1, 5);
gsl_matrix_set(covariance, 1, 2, 1);
gsl_matrix_set(covariance, 2, 0, 0);
gsl_matrix_set(covariance, 2, 1, 1);
gsl_matrix_set(covariance, 2, 2, 1);
XLAL_TRY(LALInferenceAddCorrelatedPrior(priorArgs, name, &covariance, &mu, &sigma, &idx), errnum);
if (errnum != XLAL_SUCCESS)
TEST_FAIL("%sCould not add correlated prior.", caseTag);
XLAL_TRY(LALInferenceDrawFromPrior(output, priorArgs, rng), errnum);
if (errnum != XLAL_SUCCESS)
TEST_FAIL("%sCould not generate correlated variable from positive-definite matrix; XLAL error: %s.", caseTag, XLALErrorString(errnum));
LALInferenceRemoveVariable(output, name);
LALInferenceRemoveCorrelatedPrior(priorArgs);
//gsl_matrix_free(covariance);
LALInferenceRemoveVariable(output, "gaussian");
LALInferenceRemoveVariable(output, "uniform");
LALInferenceRemoveVariable(output, "correlated");
}
XLALFree(output);
XLALFree(priorArgs);
TEST_FOOTER();
}
