/* 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(); }