static int pyobject_to_ligotimegps(PyObject *obj, LIGOTimeGPS *gps) { if(pylal_LIGOTimeGPS_Check(obj)) { *gps = ((pylal_LIGOTimeGPS *) obj)->gps; } else if(PyInt_Check(obj)) { XLALGPSSet(gps, PyInt_AsLong(obj), 0); } else if(PyLong_Check(obj)) { XLALGPSSet(gps, PyLong_AsLongLong(obj), 0); } else if(PyFloat_Check(obj)) { XLALGPSSetREAL8(gps, PyFloat_AsDouble(obj)); } else if(PyComplex_Check(obj)) { if(PyComplex_ImagAsDouble(obj) != 0.0) { XLALGPSSet(gps, 0, 0); PyErr_SetObject(PyExc_ValueError, obj); return 0; } XLALGPSSetREAL8(gps, PyComplex_RealAsDouble(obj)); } else { PyObject *s_attr = PyObject_GetAttrString(obj, "seconds"); PyObject *n_attr = PyObject_GetAttrString(obj, "nanoseconds"); XLALGPSSet(gps, PyInt_AsLong(s_attr), PyInt_AsLong(n_attr)); Py_XDECREF(s_attr); Py_XDECREF(n_attr); if(PyErr_Occurred()) { PyErr_SetObject(PyExc_TypeError, obj); return 0; } } return 1; }
double XLALFrameUFrTOCQueryGTimeModf_FrameL_(double *iptr, const LALFrameUFrTOC * toc, size_t pos) { if (pos < (size_t) toc->nFrame) { LIGOTimeGPS epoch; XLALGPSSet(&epoch, toc->GTimeS[pos], toc->GTimeN[pos]); return XLALGPSModf(iptr, &epoch); } XLAL_ERROR_REAL8(XLAL_EINVAL); }
/* initialize and register user variables */ int XLALInitializeConfigVars (ConfigVariables *config, const UserInput_t *uvar) { static SFTConstraints constraints; LIGOTimeGPS startTime, endTime; /* set sft catalog constraints */ constraints.detector = NULL; constraints.timestamps = NULL; constraints.minStartTime = &startTime; constraints.maxStartTime = &endTime; XLALGPSSet( constraints.minStartTime, uvar->startTime, 0 ); XLALGPSSet( constraints.maxStartTime, uvar->endTime, 0 ); if (XLALUserVarWasSet(&(uvar->refTime))) config->refTime = uvar->refTime; else config->refTime = uvar->startTime + 0.5 * ( (REAL8) (uvar->endTime - uvar->startTime) ); /* This check doesn't seem to work, since XLALGPSSet doesn't set its first argument. if ( (constraints.minStartTime == NULL)&& (constraints.maxStartTime == NULL) ) { LogPrintf ( LOG_CRITICAL, "%s: XLALGPSSet() failed with errno=%d\n", __func__, xlalErrno ); XLAL_ERROR( XLAL_EFUNC ); } */ /* get catalog of SFTs */ if ((config->catalog = XLALSFTdataFind (uvar->sftLocation, &constraints)) == NULL){ LogPrintf ( LOG_CRITICAL, "%s: XLALSFTdataFind() failed with errno=%d\n", __func__, xlalErrno ); XLAL_ERROR( XLAL_EFUNC ); } /* initialize ephemeris data*/ XLAL_CHECK ( (config->edat = XLALInitBarycenter ( uvar->ephemEarth, uvar->ephemSun )) != NULL, XLAL_EFUNC ); return XLAL_SUCCESS; }
/** * Sets GPS time given GPS seconds as a REAL8. Returns epoch on success, * NULL on error. */ LIGOTimeGPS * XLALGPSSetREAL8( LIGOTimeGPS *epoch, REAL8 t ) { INT4 gpssec = floor(t); INT4 gpsnan = nearbyint((t - gpssec) * XLAL_BILLION_REAL8); if(isnan(t)) { XLALPrintError("%s(): NaN", __func__); XLAL_ERROR_NULL(XLAL_EFPINVAL); } if(fabs(t) > 0x7fffffff) { XLALPrintError("%s(): overflow %.17g", __func__, t); XLAL_ERROR_NULL(XLAL_EDOM); } /* use XLALGPSSet() to normalize the nanoseconds */ return XLALGPSSet(epoch, gpssec, gpsnan); }
/// /// Parse a string representing a GPS time into LIGOTimeGPS, without loss of (ns) accuracy /// /// int XLALParseStringValueAsGPS ( LIGOTimeGPS *gps, ///< [out] returned GPS time const char *valString ///< [in] input string representing MJD(TT) time ) { XLAL_CHECK ( (gps != NULL) && (valString != NULL), XLAL_EINVAL ); INT4 gpsInt; REAL8 gpsFrac; XLAL_CHECK ( XLALParseStringValueAsINT4PlusFrac ( &gpsInt, &gpsFrac, valString ) == XLAL_SUCCESS, XLAL_EFUNC ); INT8 gpsNs = (INT8) round ( gpsFrac * XLAL_BILLION_REAL8 ); XLALGPSSet ( gps, gpsInt, gpsNs ); return XLAL_SUCCESS; } // XLALParseStringValueAsGPS()
/** * Inverse of XLALGreenwichMeanSiderealTime(). The input is sidereal time * in radians since the Julian epoch (currently J2000 for LAL), and the * output is the corresponding GPS time. The algorithm uses a naive * iterative root-finder, so it's slow. */ LIGOTimeGPS *XLALGreenwichMeanSiderealTimeToGPS( REAL8 gmst, LIGOTimeGPS *gps ) { const double gps_seconds_per_sidereal_radian = 13713.44; /* approx */ const double precision = 1e-14; int iterations = 10; double error; XLALGPSSet(gps, 0, 0); do { error = gmst - XLALGreenwichMeanSiderealTime(gps); if(fabs(error / gmst) <= precision) return gps; XLALGPSAdd(gps, error * gps_seconds_per_sidereal_radian); } while(--iterations); XLAL_ERROR_NULL(XLAL_EMAXITER); }
static int runtest(const struct TESTCASE *testcase) { int retval; LIGOTimeGPS gps; LIGOTimeGPS gpsCorrect; char *endptr; int failure = 0; XLALGPSSet(&gpsCorrect, testcase->sec, testcase->ns); XLALClearErrno(); retval = XLALStrToGPS(&gps, testcase->string, &endptr); if(retval == 0 && testcase->xlal_errno == 0) { if(XLALGPSCmp(&gps, &gpsCorrect) || strcmp(endptr, testcase->remainder)) failure = 1; } else if(XLALGetBaseErrno() != testcase->xlal_errno) failure = 1; if(lalDebugLevel || failure) fprintf(stdout, "Input = \"%s\"\n\tOutput =\t%" LAL_INT8_FORMAT " ns with \"%s\" remainder, errno %d\n\tCorrect =\t%" LAL_INT8_FORMAT " ns with \"%s\" remainder, errno %d\n\t\t===> %s\n", testcase->string, XLALGPSToINT8NS(&gps), endptr, XLALGetBaseErrno(), XLALGPSToINT8NS(&gpsCorrect), testcase->remainder, testcase->xlal_errno, failure ? "*** FAIL ***" : "Pass"); return failure; }
/** * Parse an ASCII string into a LIGOTimeGPS structure. */ int XLALStrToGPS(LIGOTimeGPS *t, const char *nptr, char **endptr) { union { char *s; const char *cs; } pconv; /* this is bad */ int olderrno; int radix; char *digits; int len=0; int sign; int base; int radixpos; int exppart; /* save and clear C library errno so we can check for failures */ olderrno = errno; errno = 0; /* retrieve the radix character */ radix = localeconv()->decimal_point[0]; /* this is bad ... there is a reason for warnings! */ pconv.cs = nptr; /* consume leading white space */ while(isspace(*(pconv.cs))) (pconv.cs)++; if(endptr) *endptr = pconv.s; /* determine the sign */ if(*(pconv.cs) == '-') { sign = -1; (pconv.cs)++; } else if(*(pconv.cs) == '+') { sign = +1; (pconv.cs)++; } else sign = +1; /* determine the base */ if(isbase16((pconv.cs), radix)) { base = 16; (pconv.cs) += 2; } else if(isbase10((pconv.cs), radix)) { base = 10; } else { /* this isn't a recognized number */ XLALGPSSet(t, 0, 0); return 0; } /* count the number of digits including the radix but not including * the exponent. */ radixpos = -1; switch(base) { case 10: for(len = 0; 1; len++) { if(isdigit((pconv.cs)[len])) continue; if((pconv.cs)[len] == radix && radixpos < 0) { radixpos = len; continue; } break; } break; case 16: for(len = 0; 1; len++) { if(isxdigit((pconv.cs)[len])) continue; if((pconv.cs)[len] == radix && radixpos < 0) { radixpos = len; continue; } break; } break; } /* copy the digits into a scratch space, removing the radix character * if one was found */ if(radixpos >= 0) { digits = malloc(len + 1); memcpy(digits, (pconv.cs), radixpos); memcpy(digits + radixpos, (pconv.cs) + radixpos + 1, len - radixpos - 1); digits[len - 1] = '\0'; (pconv.cs) += len; len--; } else { digits = malloc(len + 2); memcpy(digits, (pconv.cs), len); digits[len] = '\0'; radixpos = len; (pconv.cs) += len; } /* check for and parse an exponent, performing an adjustment of the * radix position */ exppart = 1; switch(base) { case 10: /* exponent is the number of powers of 10 */ if(isdecimalexp((pconv.cs))) radixpos += strtol((pconv.cs) + 1, &pconv.s, 10); break; case 16: /* exponent is the number of powers of 2 */ if(isbinaryexp((pconv.cs))) { exppart = strtol((pconv.cs) + 1, &pconv.s, 10); radixpos += exppart / 4; exppart %= 4; if(exppart < 0) { radixpos--; exppart += 4; } exppart = 1 << exppart; } break; } /* save end of converted characters */ if(endptr) *endptr = pconv.s; /* insert the radix character, padding the scratch digits with zeroes * if needed */ if(radixpos < 2) { digits = realloc(digits, len + 2 + (2 - radixpos)); memmove(digits + (2 - radixpos) + 1, digits, len + 1); memset(digits, '0', (2 - radixpos) + 1); if(radixpos == 1) digits[1] = digits[2]; radixpos = 2; } else if(radixpos > len) { digits = realloc(digits, radixpos + 2); memset(digits + len, '0', radixpos - len); digits[radixpos + 1] = '\0'; } else { memmove(digits + radixpos + 1, digits + radixpos, len - radixpos + 1); } digits[radixpos] = radix; /* parse the integer part */ XLALINT8NSToGPS(t, sign * strtol(digits, NULL, base) * exppart * XLAL_BILLION_INT8); /* parse the fractional part */ if(errno != ERANGE) { switch(base) { case 10: break; case 16: digits[radixpos - 2] = '0'; digits[radixpos - 1] = 'x'; radixpos -= 2; break; } XLALGPSAdd(t, sign * strtod(digits + radixpos, NULL) * exppart); } /* free the scratch space */ free(digits); /* check for failures and restore errno if there weren't any */ if(errno == ERANGE) XLAL_ERROR(XLAL_ERANGE); errno = olderrno; /* success */ return 0; }
double XLALFrameUFrameHQueryGTimeModf_FrameL_(double *iptr, const LALFrameUFrameH * frame) { LIGOTimeGPS epoch; XLALGPSSet(&epoch, frame->GTimeS, frame->GTimeN); return XLALGPSModf(iptr, &epoch); }
/// /// test various string-value parser functions: /// XLALParseStringValueAsINT8(), XLALParseStringValueAsINT4(), XLALParseStringValueAsREAL8(), /// XLALParseStringValueAsINT4PlusFrac() /// int test_ParseStringValue ( void ) { const char *valString; // ---------- XLALParseStringValueAsINT8() ---------- INT8 valINT8, valINT8Ref; valString = "9223372036854775807"; // LAL_INT8_MAX valINT8Ref = 9223372036854775807; XLAL_CHECK ( XLALParseStringValueAsINT8 ( &valINT8, valString ) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( valINT8 == valINT8Ref, XLAL_ETOL, "XLALParseStringValueAsINT8(%s) failed, return = %" LAL_INT8_FORMAT "\n", valString, valINT8 ); valString = "4294967294"; // 2 * LAL_INT4_MAX valINT8Ref = 4294967294; XLAL_CHECK ( XLALParseStringValueAsINT8 ( &valINT8, valString ) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( valINT8 == valINT8Ref, XLAL_ETOL, "XLALParseStringValueAsINT8(%s) failed, return = %" LAL_INT8_FORMAT "\n", valString, valINT8 ); valString = "-4294967294"; // -2 * LAL_INT4_MAX valINT8Ref = -4294967294; XLAL_CHECK ( XLALParseStringValueAsINT8 ( &valINT8, valString ) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( valINT8 == valINT8Ref, XLAL_ETOL, "XLALParseStringValueAsINT8(%s) failed, return = %" LAL_INT8_FORMAT "\n", valString, valINT8 ); // this one needs to fail! //valString = "18446744073709551616"; // 2 * LAL_INT8_MAX //XLAL_CHECK ( XLAL_SUCCESS != XLALParseStringValueAsINT8 ( &valINT8, valString ), XLAL_EFAILED, "XLALParseStringValueAsINT8() failed to catch out-of-range conversion\n" ); //XLALPrintError ("---------- Not to worry, the above failure was on purpose: ----------\n\n"); // ---------- XLALParseStringValueAsINT4() ---------- INT4 valINT4, valINT4Ref; valString = "2147483647"; // LAL_INT4_MAX valINT4Ref = 2147483647; XLAL_CHECK ( XLALParseStringValueAsINT4 ( &valINT4, valString ) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( valINT4 == valINT4Ref, XLAL_ETOL, "XLALParseStringValueAsINT4(%s) failed, return = %d\n", valString, valINT4 ); valString = "-1000000"; valINT4Ref = -1000000; XLAL_CHECK ( XLALParseStringValueAsINT4 ( &valINT4, valString ) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( valINT4 == valINT4Ref, XLAL_ETOL, "XLALParseStringValueAsINT4(%s) failed, return = %d\n", valString, valINT4 ); // this one needs to fail! //valString = "4294967294"; // 2 * LAL_INT4_MAX //XLAL_CHECK ( XLAL_SUCCESS != XLALParseStringValueAsINT4 ( &valINT4, valString ), XLAL_EFAILED, "XLALParseStringValueAsINT4() failed to catch out-of-range conversion\n" ); //XLALPrintError ("---------- Not to worry, the above failure was on purpose: ----------\n\n"); // ---------- XLALParseStringValueAsREAL8() ---------- REAL8 valREAL8, valREAL8Ref; valString = "2147483647"; valREAL8Ref = 2147483647; XLAL_CHECK ( XLALParseStringValueAsREAL8 ( &valREAL8, valString ) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( valREAL8 == valREAL8Ref, XLAL_ETOL, "XLALParseStringValueAsREAL8(%s) failed, return = %.16g\n", valString, valREAL8 ); valString = "-1.1234e10"; valREAL8Ref = -1.1234e10; XLAL_CHECK ( XLALParseStringValueAsREAL8 ( &valREAL8, valString ) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( fabs ( (valREAL8 - valREAL8Ref) / valREAL8Ref ) <= LAL_REAL8_EPS, XLAL_ETOL, "XLALParseStringValueAsREAL8(%s) failed, return = %.16g\n", valString, valREAL8 ); // ---------- XLALParseStringValueAsREAL4() ---------- REAL4 valREAL4, valREAL4Ref; valString = "2147483647"; valREAL4Ref = 2147483647; XLAL_CHECK ( XLALParseStringValueAsREAL4 ( &valREAL4, valString ) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( valREAL4 == valREAL4Ref, XLAL_ETOL, "XLALParseStringValueAsREAL4(%s) failed, return = %.16g\n", valString, valREAL4 ); valString = "-1.1234e10"; valREAL4Ref = -1.1234e10; XLAL_CHECK ( XLALParseStringValueAsREAL4 ( &valREAL4, valString ) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( fabs ( (valREAL4 - valREAL4Ref) / valREAL4Ref ) <= LAL_REAL4_EPS, XLAL_ETOL, "XLALParseStringValueAsREAL4(%s) failed, return = %.16g\n", valString, valREAL4 ); // ---------- XLALParseStringValueAsINT4PlusFrac() ---------- INT4 valINT, valINTRef; REAL8 valFrac, valFracRef; valString = "123456789.12345678912345"; valINTRef = 123456789; valFracRef = 0.12345678912345; XLAL_CHECK ( XLALParseStringValueAsINT4PlusFrac ( &valINT, &valFrac, valString ) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( (valINT == valINTRef) && (fabs( (valFrac - valFracRef) / valFracRef ) <= LAL_REAL8_EPS), XLAL_ETOL, "XLALParseStringValueAsINT4PlusFrac(%s) failed, return = (%d, %.16g)\n", valString, valINT, valFrac ); valString = "-123456789.12345678912345"; valINTRef = -123456789; valFracRef = -0.12345678912345; XLAL_CHECK ( XLALParseStringValueAsINT4PlusFrac ( &valINT, &valFrac, valString ) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( (valINT == valINTRef) && (fabs( (valFrac - valFracRef) / valFracRef ) <= LAL_REAL8_EPS), XLAL_ETOL, "XLALParseStringValueAsINT4PlusFrac(%s) failed, return = (%d, %.16g)\n", valString, valINT, valFrac ); // ---------- XLALParseStringValueAsGPS() ---------- LIGOTimeGPS valGPS, valGPSRef = {987654321, 123456789 }; valString = "987654321.123456789"; XLAL_CHECK ( XLALParseStringValueAsGPS ( &valGPS, valString ) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( XLALGPSCmp ( &valGPS, &valGPSRef ) == 0, XLAL_ETOL, "XLALParseStringValueAsGPS(%s) failed, return = {%d,%d}\n", valString, valGPS.gpsSeconds, valGPS.gpsNanoSeconds ); // ---------- XLALParseStringValueAsEPOCH() ---------- XLAL_CHECK ( XLALParseStringValueAsEPOCH ( &valGPS, valString ) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( XLALGPSCmp ( &valGPS, &valGPSRef ) == 0, XLAL_ETOL, "XLALParseStringValueAsGPS(%s) failed, return = {%d,%d}\n", valString, valGPS.gpsSeconds, valGPS.gpsNanoSeconds ); valString = "987654321.123456789GPS"; XLAL_CHECK ( XLALParseStringValueAsEPOCH ( &valGPS, valString ) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( XLALGPSCmp ( &valGPS, &valGPSRef ) == 0, XLAL_ETOL, "XLALParseStringValueAsGPS(%s) failed, return = {%d,%d}\n", valString, valGPS.gpsSeconds, valGPS.gpsNanoSeconds ); valString = "55675.1848646696387616MJD"; XLAL_CHECK ( XLALParseStringValueAsEPOCH ( &valGPS, valString ) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( XLALGPSCmp ( &valGPS, &valGPSRef ) == 0, XLAL_ETOL, "XLALParseStringValueAsGPS(%s) failed, return = {%d,%d}\n", valString, valGPS.gpsSeconds, valGPS.gpsNanoSeconds ); valString = "987654321.12345"; valGPSRef.gpsNanoSeconds = 123450000; XLAL_CHECK ( XLALParseStringValueAsEPOCH ( &valGPS, valString ) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK ( XLALGPSCmp ( &valGPS, &valGPSRef ) == 0, XLAL_ETOL, "XLALParseStringValueAsGPS(%s) failed, return = {%d,%d}, correct = {%d,%d}\n", valString, valGPS.gpsSeconds, valGPS.gpsNanoSeconds, valGPSRef.gpsSeconds, valGPSRef.gpsNanoSeconds ); // ---------- XLALParseStringValueAsREAL8Range() ---------- REAL8Range real8Range, real8RangeRef; valString = "100"; real8RangeRef[0] = 100; real8RangeRef[1] = 100; XLAL_CHECK( XLALParseStringValueAsREAL8Range(&real8Range, valString) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK( fabs(real8Range[0] - real8RangeRef[0])/real8RangeRef[0] <= LAL_REAL8_EPS && fabs(real8Range[1] - real8RangeRef[1])/real8RangeRef[1] <= LAL_REAL8_EPS && real8Range[0] <= real8Range[1], XLAL_ETOL, "XLALParseStringValueAsREAL8Range(%s) failed, return = {%g,%g}\n", valString, real8Range[0], real8Range[1] ); valString = "150/0.5"; real8RangeRef[0] = 150; real8RangeRef[1] = 150.5; XLAL_CHECK( XLALParseStringValueAsREAL8Range(&real8Range, valString) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK( fabs(real8Range[0] - real8RangeRef[0])/real8RangeRef[0] <= LAL_REAL8_EPS && fabs(real8Range[1] - real8RangeRef[1])/real8RangeRef[1] <= LAL_REAL8_EPS && real8Range[0] <= real8Range[1], XLAL_ETOL, "XLALParseStringValueAsREAL8Range(%s) failed, return = {%g,%g}\n", valString, real8Range[0], real8Range[1] ); valString = "150/-0.5"; real8RangeRef[0] = 149.5; real8RangeRef[1] = 150; XLAL_CHECK( XLALParseStringValueAsREAL8Range(&real8Range, valString) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK( fabs(real8Range[0] - real8RangeRef[0])/real8RangeRef[0] <= LAL_REAL8_EPS && fabs(real8Range[1] - real8RangeRef[1])/real8RangeRef[1] <= LAL_REAL8_EPS && real8Range[0] <= real8Range[1], XLAL_ETOL, "XLALParseStringValueAsREAL8Range(%s) failed, return = {%g,%g}\n", valString, real8Range[0], real8Range[1] ); valString = "200,201"; real8RangeRef[0] = 200; real8RangeRef[1] = 201; XLAL_CHECK( XLALParseStringValueAsREAL8Range(&real8Range, valString) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK( fabs(real8Range[0] - real8RangeRef[0])/real8RangeRef[0] <= LAL_REAL8_EPS && fabs(real8Range[1] - real8RangeRef[1])/real8RangeRef[1] <= LAL_REAL8_EPS && real8Range[0] <= real8Range[1], XLAL_ETOL, "XLALParseStringValueAsREAL8Range(%s) failed, return = {%g,%g}\n", valString, real8Range[0], real8Range[1] ); valString = "203,202"; real8RangeRef[0] = 202; real8RangeRef[1] = 203; XLAL_CHECK( XLALParseStringValueAsREAL8Range(&real8Range, valString) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK( fabs(real8Range[0] - real8RangeRef[0])/real8RangeRef[0] <= LAL_REAL8_EPS && fabs(real8Range[1] - real8RangeRef[1])/real8RangeRef[1] <= LAL_REAL8_EPS && real8Range[0] <= real8Range[1], XLAL_ETOL, "XLALParseStringValueAsREAL8Range(%s) failed, return = {%g,%g}\n", valString, real8Range[0], real8Range[1] ); valString = "-203,-202"; real8RangeRef[0] = -203; real8RangeRef[1] = -202; XLAL_CHECK( XLALParseStringValueAsREAL8Range(&real8Range, valString) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK( fabs(real8Range[0] - real8RangeRef[0])/real8RangeRef[0] <= LAL_REAL8_EPS && fabs(real8Range[1] - real8RangeRef[1])/real8RangeRef[1] <= LAL_REAL8_EPS && real8Range[0] <= real8Range[1], XLAL_ETOL, "XLALParseStringValueAsREAL8Range(%s) failed, return = {%g,%g}\n", valString, real8Range[0], real8Range[1] ); valString = "250~5"; real8RangeRef[0] = 245; real8RangeRef[1] = 255; XLAL_CHECK( XLALParseStringValueAsREAL8Range(&real8Range, valString) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK( fabs(real8Range[0] - real8RangeRef[0])/real8RangeRef[0] <= LAL_REAL8_EPS && fabs(real8Range[1] - real8RangeRef[1])/real8RangeRef[1] <= LAL_REAL8_EPS && real8Range[0] <= real8Range[1], XLAL_ETOL, "XLALParseStringValueAsREAL8Range(%s) failed, return = {%g,%g}\n", valString, real8Range[0], real8Range[1] ); // ---------- XLALParseStringValueAsEPOCHRange() ---------- LIGOTimeGPSRange gpsRange, gpsRangeRef; valString = "100200300.4"; XLALGPSSet(&gpsRangeRef[0], 100200300, 400000000); XLALGPSSet(&gpsRangeRef[1], 100200300, 400000000); XLAL_CHECK( XLALParseStringValueAsEPOCHRange(&gpsRange, valString) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK( XLALGPSCmp(&gpsRange[0], &gpsRangeRef[0]) == 0 && XLALGPSCmp(&gpsRange[1], &gpsRangeRef[1]) == 0 && XLALGPSCmp(&gpsRange[0], &gpsRange[1]) <= 0, XLAL_ETOL, "XLALParseStringValueAsEPOCHRange(%s) failed, return = {{%d,%d},{%d,%d}}\n", valString, gpsRange[0].gpsSeconds, gpsRange[0].gpsNanoSeconds, gpsRange[1].gpsSeconds, gpsRange[1].gpsNanoSeconds ); valString = "100200300.4/800600400.2"; XLALGPSSet(&gpsRangeRef[0], 100200300, 400000000); XLALGPSSet(&gpsRangeRef[1], 900800700, 600000000); XLAL_CHECK( XLALParseStringValueAsEPOCHRange(&gpsRange, valString) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK( XLALGPSCmp(&gpsRange[0], &gpsRangeRef[0]) == 0 && XLALGPSCmp(&gpsRange[1], &gpsRangeRef[1]) == 0 && XLALGPSCmp(&gpsRange[0], &gpsRange[1]) <= 0, XLAL_ETOL, "XLALParseStringValueAsEPOCHRange(%s) failed, return = {{%d,%d},{%d,%d}}\n", valString, gpsRange[0].gpsSeconds, gpsRange[0].gpsNanoSeconds, gpsRange[1].gpsSeconds, gpsRange[1].gpsNanoSeconds ); valString = "100200300.4/-800600400.2"; XLALGPSSet(&gpsRangeRef[0], -700400099, -800000000); XLALGPSSet(&gpsRangeRef[1], 100200300, 400000000); XLAL_CHECK( XLALParseStringValueAsEPOCHRange(&gpsRange, valString) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK( XLALGPSCmp(&gpsRange[0], &gpsRangeRef[0]) == 0 && XLALGPSCmp(&gpsRange[1], &gpsRangeRef[1]) == 0 && XLALGPSCmp(&gpsRange[0], &gpsRange[1]) <= 0, XLAL_ETOL, "XLALParseStringValueAsEPOCHRange(%s) failed, return = {{%d,%d},{%d,%d}}\n", valString, gpsRange[0].gpsSeconds, gpsRange[0].gpsNanoSeconds, gpsRange[1].gpsSeconds, gpsRange[1].gpsNanoSeconds ); valString = "200300400.5,600700800.9"; XLALGPSSet(&gpsRangeRef[0], 200300400, 500000000); XLALGPSSet(&gpsRangeRef[1], 600700800, 900000000); XLAL_CHECK( XLALParseStringValueAsEPOCHRange(&gpsRange, valString) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK( XLALGPSCmp(&gpsRange[0], &gpsRangeRef[0]) == 0 && XLALGPSCmp(&gpsRange[1], &gpsRangeRef[1]) == 0 && XLALGPSCmp(&gpsRange[0], &gpsRange[1]) <= 0, XLAL_ETOL, "XLALParseStringValueAsEPOCHRange(%s) failed, return = {{%d,%d},{%d,%d}}\n", valString, gpsRange[0].gpsSeconds, gpsRange[0].gpsNanoSeconds, gpsRange[1].gpsSeconds, gpsRange[1].gpsNanoSeconds ); valString = "600700800.9,200300400.5"; XLALGPSSet(&gpsRangeRef[0], 200300400, 500000000); XLALGPSSet(&gpsRangeRef[1], 600700800, 900000000); XLAL_CHECK( XLALParseStringValueAsEPOCHRange(&gpsRange, valString) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK( XLALGPSCmp(&gpsRange[0], &gpsRangeRef[0]) == 0 && XLALGPSCmp(&gpsRange[1], &gpsRangeRef[1]) == 0 && XLALGPSCmp(&gpsRange[0], &gpsRange[1]) <= 0, XLAL_ETOL, "XLALParseStringValueAsEPOCHRange(%s) failed, return = {{%d,%d},{%d,%d}}\n", valString, gpsRange[0].gpsSeconds, gpsRange[0].gpsNanoSeconds, gpsRange[1].gpsSeconds, gpsRange[1].gpsNanoSeconds ); valString = "123456789~123456.789"; XLALGPSSet(&gpsRangeRef[0], 123333332, 211000000); XLALGPSSet(&gpsRangeRef[1], 123580245, 789000000); XLAL_CHECK( XLALParseStringValueAsEPOCHRange(&gpsRange, valString) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK( XLALGPSCmp(&gpsRange[0], &gpsRangeRef[0]) == 0 && XLALGPSCmp(&gpsRange[1], &gpsRangeRef[1]) == 0 && XLALGPSCmp(&gpsRange[0], &gpsRange[1]) <= 0, XLAL_ETOL, "XLALParseStringValueAsEPOCHRange(%s) failed, return = {{%d,%d},{%d,%d}}\n", valString, gpsRange[0].gpsSeconds, gpsRange[0].gpsNanoSeconds, gpsRange[1].gpsSeconds, gpsRange[1].gpsNanoSeconds ); // ---------- XLALParseStringValueAsRAJRange() ---------- REAL8Range rajRange, rajRangeRef; valString = "0.1"; rajRangeRef[0] = 0.1; rajRangeRef[1] = 0.1; XLAL_CHECK( XLALParseStringValueAsRAJRange(&rajRange, valString) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK( fabs(rajRange[0] - rajRangeRef[0])/rajRangeRef[0] <= LAL_REAL8_EPS && fabs(rajRange[1] - rajRangeRef[1])/rajRangeRef[1] <= LAL_REAL8_EPS && rajRange[0] <= rajRange[1], XLAL_ETOL, "XLALParseStringValueAsRAJRange(%s) failed, return = {%g,%g}\n", valString, rajRange[0], rajRange[1] ); valString = "10:20:30/0.5"; rajRangeRef[0] = 2.7074420021562036; rajRangeRef[1] = rajRangeRef[0] + 0.5; XLAL_CHECK( XLALParseStringValueAsRAJRange(&rajRange, valString) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK( fabs(rajRange[0] - rajRangeRef[0])/rajRangeRef[0] <= LAL_REAL8_EPS && fabs(rajRange[1] - rajRangeRef[1])/rajRangeRef[1] <= LAL_REAL8_EPS && rajRange[0] <= rajRange[1], XLAL_ETOL, "XLALParseStringValueAsRAJRange(%s) failed, return = {%g,%g}\n", valString, rajRange[0], rajRange[1] ); valString = "10:20:30/-0.5"; rajRangeRef[0] = 2.7074420021562036 - 0.5; rajRangeRef[1] = rajRangeRef[0] + 0.5; XLAL_CHECK( XLALParseStringValueAsRAJRange(&rajRange, valString) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK( fabs(rajRange[0] - rajRangeRef[0])/rajRangeRef[0] <= LAL_REAL8_EPS && fabs(rajRange[1] - rajRangeRef[1])/rajRangeRef[1] <= LAL_REAL8_EPS && rajRange[0] <= rajRange[1], XLAL_ETOL, "XLALParseStringValueAsRAJRange(%s) failed, return = {%g,%g}\n", valString, rajRange[0], rajRange[1] ); valString = "10:20:30,11:22:33"; rajRangeRef[0] = 2.7074420021562036; rajRangeRef[1] = 2.9781862023718242; XLAL_CHECK( XLALParseStringValueAsRAJRange(&rajRange, valString) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK( fabs(rajRange[0] - rajRangeRef[0])/rajRangeRef[0] <= LAL_REAL8_EPS && fabs(rajRange[1] - rajRangeRef[1])/rajRangeRef[1] <= LAL_REAL8_EPS && rajRange[0] <= rajRange[1], XLAL_ETOL, "XLALParseStringValueAsRAJRange(%s) failed, return = {%g,%g}\n", valString, rajRange[0], rajRange[1] ); valString = "11:22:33,10:20:30"; rajRangeRef[0] = 2.7074420021562036; rajRangeRef[1] = 2.9781862023718242; XLAL_CHECK( XLALParseStringValueAsRAJRange(&rajRange, valString) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK( fabs(rajRange[0] - rajRangeRef[0])/rajRangeRef[0] <= LAL_REAL8_EPS && fabs(rajRange[1] - rajRangeRef[1])/rajRangeRef[1] <= LAL_REAL8_EPS && rajRange[0] <= rajRange[1], XLAL_ETOL, "XLALParseStringValueAsRAJRange(%s) failed, return = {%g,%g}\n", valString, rajRange[0], rajRange[1] ); valString = "11:22:33~00:00:44.55"; rajRangeRef[0] = 2.9749464349478099; rajRangeRef[1] = 2.9814259697958385; XLAL_CHECK( XLALParseStringValueAsRAJRange(&rajRange, valString) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK( fabs(rajRange[0] - rajRangeRef[0])/rajRangeRef[0] <= LAL_REAL8_EPS && fabs(rajRange[1] - rajRangeRef[1])/rajRangeRef[1] <= LAL_REAL8_EPS && rajRange[0] <= rajRange[1], XLAL_ETOL, "XLALParseStringValueAsRAJRange(%s) failed, return = {%g,%g}\n", valString, rajRange[0], rajRange[1] ); // ---------- XLALParseStringValueAsDECJRange() ---------- REAL8Range decjRange, decjRangeRef; valString = "0.1"; decjRangeRef[0] = 0.1; decjRangeRef[1] = 0.1; XLAL_CHECK( XLALParseStringValueAsDECJRange(&decjRange, valString) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK( fabs(decjRange[0] - decjRangeRef[0])/decjRangeRef[0] <= LAL_REAL8_EPS && fabs(decjRange[1] - decjRangeRef[1])/decjRangeRef[1] <= LAL_REAL8_EPS && decjRange[0] <= decjRange[1], XLAL_ETOL, "XLALParseStringValueAsDECJRange(%s) failed, return = {%g,%g}\n", valString, decjRange[0], decjRange[1] ); valString = "10:20:30/0.5"; decjRangeRef[0] = (2.7074420021562036/15); decjRangeRef[1] = decjRangeRef[0] + 0.5; XLAL_CHECK( XLALParseStringValueAsDECJRange(&decjRange, valString) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK( fabs(decjRange[0] - decjRangeRef[0])/decjRangeRef[0] <= LAL_REAL8_EPS && fabs(decjRange[1] - decjRangeRef[1])/decjRangeRef[1] <= LAL_REAL8_EPS && decjRange[0] <= decjRange[1], XLAL_ETOL, "XLALParseStringValueAsDECJRange(%s) failed, return = {%g,%g}\n", valString, decjRange[0], decjRange[1] ); valString = "10:20:30/-0.5"; decjRangeRef[0] = (2.7074420021562036/15) - 0.5; decjRangeRef[1] = decjRangeRef[0] + 0.5; XLAL_CHECK( XLALParseStringValueAsDECJRange(&decjRange, valString) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK( fabs(decjRange[0] - decjRangeRef[0])/decjRangeRef[0] <= LAL_REAL8_EPS && fabs(decjRange[1] - decjRangeRef[1])/decjRangeRef[1] <= LAL_REAL8_EPS && decjRange[0] <= decjRange[1], XLAL_ETOL, "XLALParseStringValueAsDECJRange(%s) failed, return = {%g,%g}\n", valString, decjRange[0], decjRange[1] ); valString = "10:20:30,11:22:33"; decjRangeRef[0] = (2.7074420021562036/15); decjRangeRef[1] = (2.9781862023718242/15); XLAL_CHECK( XLALParseStringValueAsDECJRange(&decjRange, valString) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK( fabs(decjRange[0] - decjRangeRef[0])/decjRangeRef[0] <= LAL_REAL8_EPS && fabs(decjRange[1] - decjRangeRef[1])/decjRangeRef[1] <= LAL_REAL8_EPS && decjRange[0] <= decjRange[1], XLAL_ETOL, "XLALParseStringValueAsDECJRange(%s) failed, return = {%g,%g}\n", valString, decjRange[0], decjRange[1] ); valString = "11:22:33,10:20:30"; decjRangeRef[0] = (2.7074420021562036/15); decjRangeRef[1] = (2.9781862023718242/15); XLAL_CHECK( XLALParseStringValueAsDECJRange(&decjRange, valString) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK( fabs(decjRange[0] - decjRangeRef[0])/decjRangeRef[0] <= LAL_REAL8_EPS && fabs(decjRange[1] - decjRangeRef[1])/decjRangeRef[1] <= LAL_REAL8_EPS && decjRange[0] <= decjRange[1], XLAL_ETOL, "XLALParseStringValueAsDECJRange(%s) failed, return = {%g,%g}\n", valString, decjRange[0], decjRange[1] ); valString = "11:22:33~00:00:44.55"; decjRangeRef[0] = (2.9749464349478099/15); decjRangeRef[1] = (2.9814259697958385/15); XLAL_CHECK( XLALParseStringValueAsDECJRange(&decjRange, valString) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK( fabs(decjRange[0] - decjRangeRef[0])/decjRangeRef[0] <= LAL_REAL8_EPS && fabs(decjRange[1] - decjRangeRef[1])/decjRangeRef[1] <= LAL_REAL8_EPS && decjRange[0] <= decjRange[1], XLAL_ETOL, "XLALParseStringValueAsDECJRange(%s) failed, return = {%g,%g}\n", valString, decjRange[0], decjRange[1] ); return XLAL_SUCCESS; } // test_ParseStringValue()
/** * Read the sngl_burst table from a LIGO Light Weight XML file into a * linked list of SnglBurst structures. */ SnglBurst *XLALSnglBurstTableFromLIGOLw( const char *filename ) { static const char table_name[] = "sngl_burst"; int miostatus; SnglBurst *head = NULL; SnglBurst **next = &head; struct MetaioParseEnvironment env; struct { int process_id; int ifo; int search; int channel; int start_time; int start_time_ns; int peak_time; int peak_time_ns; int duration; int central_freq; int bandwidth; int amplitude; int snr; int confidence; int chisq; int chisq_dof; int event_id; } column_pos; /* open the file and find table */ if(MetaioOpenFile(&env, filename)) { XLALPrintError("%s(): error opening \"%s\": %s\n", __func__, filename, env.mierrmsg.data ? env.mierrmsg.data : "unknown reason"); XLAL_ERROR_NULL(XLAL_EIO); } if(MetaioOpenTableOnly(&env, table_name)) { MetaioAbort(&env); XLALPrintError("%s(): cannot find %s table: %s\n", __func__, table_name, env.mierrmsg.data ? env.mierrmsg.data : "unknown reason"); XLAL_ERROR_NULL(XLAL_EIO); } /* find columns */ XLALClearErrno(); column_pos.process_id = XLALLIGOLwFindColumn(&env, "process_id", METAIO_TYPE_ILWD_CHAR, 1); column_pos.ifo = XLALLIGOLwFindColumn(&env, "ifo", METAIO_TYPE_LSTRING, 1); column_pos.search = XLALLIGOLwFindColumn(&env, "search", METAIO_TYPE_LSTRING, 1); column_pos.channel = XLALLIGOLwFindColumn(&env, "channel", METAIO_TYPE_LSTRING, 1); column_pos.start_time = XLALLIGOLwFindColumn(&env, "start_time", METAIO_TYPE_INT_4S, 1); column_pos.start_time_ns = XLALLIGOLwFindColumn(&env, "start_time_ns", METAIO_TYPE_INT_4S, 1); column_pos.peak_time = XLALLIGOLwFindColumn(&env, "peak_time", METAIO_TYPE_INT_4S, 1); column_pos.peak_time_ns = XLALLIGOLwFindColumn(&env, "peak_time_ns", METAIO_TYPE_INT_4S, 1); column_pos.duration = XLALLIGOLwFindColumn(&env, "duration", METAIO_TYPE_REAL_4, 1); column_pos.central_freq = XLALLIGOLwFindColumn(&env, "central_freq", METAIO_TYPE_REAL_4, 1); column_pos.bandwidth = XLALLIGOLwFindColumn(&env, "bandwidth", METAIO_TYPE_REAL_4, 1); column_pos.amplitude = XLALLIGOLwFindColumn(&env, "amplitude", METAIO_TYPE_REAL_4, 1); column_pos.snr = XLALLIGOLwFindColumn(&env, "snr", METAIO_TYPE_REAL_4, 1); column_pos.confidence = XLALLIGOLwFindColumn(&env, "confidence", METAIO_TYPE_REAL_4, 1); column_pos.chisq = XLALLIGOLwFindColumn(&env, "chisq", METAIO_TYPE_REAL_8, 1); column_pos.chisq_dof = XLALLIGOLwFindColumn(&env, "chisq_dof", METAIO_TYPE_REAL_8, 1); column_pos.event_id = XLALLIGOLwFindColumn(&env, "event_id", METAIO_TYPE_ILWD_CHAR, 1); /* check for failure (== a required column is missing) */ if(XLALGetBaseErrno()) { MetaioAbort(&env); XLALPrintError("%s(): failure reading %s table: missing required column\n", __func__, table_name); XLAL_ERROR_NULL(XLAL_EFUNC); } /* loop over the rows in the file */ while((miostatus = MetaioGetRow(&env)) > 0) { /* create a new row */ SnglBurst *row = XLALCreateSnglBurst(); if(!row) { XLALDestroySnglBurstTable(head); MetaioAbort(&env); XLAL_ERROR_NULL(XLAL_EFUNC); } /* append to linked list */ *next = row; next = &(*next)->next; /* populate the columns */ if((row->process_id = XLALLIGOLwParseIlwdChar(&env, column_pos.process_id, "process", "process_id")) < 0) { XLALDestroySnglBurstTable(head); MetaioAbort(&env); XLAL_ERROR_NULL(XLAL_EFUNC); } if(strlen(env.ligo_lw.table.elt[column_pos.ifo].data.lstring.data) >= sizeof(row->ifo) || strlen(env.ligo_lw.table.elt[column_pos.search].data.lstring.data) >= sizeof(row->search) || strlen(env.ligo_lw.table.elt[column_pos.channel].data.lstring.data) >= sizeof(row->channel)) { XLALDestroySnglBurstTable(head); MetaioAbort(&env); XLALPrintError("%s(): failure reading %s table: string too long\n", __func__, table_name); XLAL_ERROR_NULL(XLAL_EIO); } strncpy(row->ifo, env.ligo_lw.table.elt[column_pos.ifo].data.lstring.data, sizeof(row->ifo) - 1); strncpy(row->search, env.ligo_lw.table.elt[column_pos.search].data.lstring.data, sizeof(row->search) - 1); strncpy(row->channel, env.ligo_lw.table.elt[column_pos.channel].data.lstring.data, sizeof(row->channel) - 1); XLALGPSSet(&row->start_time, env.ligo_lw.table.elt[column_pos.start_time].data.int_4s, env.ligo_lw.table.elt[column_pos.start_time_ns].data.int_4s); XLALGPSSet(&row->peak_time, env.ligo_lw.table.elt[column_pos.peak_time].data.int_4s, env.ligo_lw.table.elt[column_pos.peak_time_ns].data.int_4s); row->duration = env.ligo_lw.table.elt[column_pos.duration].data.real_4; row->central_freq = env.ligo_lw.table.elt[column_pos.central_freq].data.real_4; row->bandwidth = env.ligo_lw.table.elt[column_pos.bandwidth].data.real_4; row->amplitude = env.ligo_lw.table.elt[column_pos.amplitude].data.real_4; row->snr = env.ligo_lw.table.elt[column_pos.snr].data.real_4; row->confidence = env.ligo_lw.table.elt[column_pos.confidence].data.real_4; row->chisq = env.ligo_lw.table.elt[column_pos.chisq].data.real_8; row->chisq_dof = env.ligo_lw.table.elt[column_pos.chisq_dof].data.real_8; if((row->event_id = XLALLIGOLwParseIlwdChar(&env, column_pos.event_id, "sngl_burst", "event_id")) < 0) { XLALDestroySnglBurstTable(head); MetaioAbort(&env); XLAL_ERROR_NULL(XLAL_EFUNC); } } if(miostatus < 0) { XLALDestroySnglBurstTable(head); MetaioAbort(&env); XLALPrintError("%s(): I/O error parsing %s table: %s\n", __func__, table_name, env.mierrmsg.data ? env.mierrmsg.data : "unknown reason"); XLAL_ERROR_NULL(XLAL_EIO); } /* close file */ if(MetaioClose(&env)) { XLALDestroySnglBurstTable(head); XLALPrintError("%s(): error parsing document after %s table: %s\n", __func__, table_name, env.mierrmsg.data ? env.mierrmsg.data : "unknown reason"); XLAL_ERROR_NULL(XLAL_EIO); } /* done */ return head; }
/** * Read the sim_burst table from a LIGO Light Weight XML file into a linked * list of SimBurst structures. If start is not NULL, then only rows whose * geocentre peak times are \f$\ge\f$ the given GPS time will be loaded, similarly * if end is not NULL. */ SimBurst *XLALSimBurstTableFromLIGOLw( const char *filename, const LIGOTimeGPS *start, const LIGOTimeGPS *end ) { static const char table_name[] = "sim_burst"; int miostatus; SimBurst *head = NULL; SimBurst **next = &head; struct MetaioParseEnvironment env; struct { int process_id; int waveform; int ra; int dec; int psi; int time_geocent_gps; int time_geocent_gps_ns; int time_geocent_gmst; int duration; int frequency; int bandwidth; int q; int pol_ellipse_angle; int pol_ellipse_e; int amplitude; int hrss; int egw_over_rsquared; int waveform_number; int time_slide_id; int simulation_id; } column_pos; /* open the file and find table */ if(MetaioOpenFile(&env, filename)) { XLALPrintError("%s(): error opening \"%s\": %s\n", __func__, filename, env.mierrmsg.data ? env.mierrmsg.data : "unknown reason"); XLAL_ERROR_NULL(XLAL_EIO); } if(MetaioOpenTableOnly(&env, table_name)) { MetaioAbort(&env); XLALPrintError("%s(): cannot find %s table: %s\n", __func__, table_name, env.mierrmsg.data ? env.mierrmsg.data : "unknown reason"); XLAL_ERROR_NULL(XLAL_EIO); } /* find columns */ XLALClearErrno(); column_pos.process_id = XLALLIGOLwFindColumn(&env, "process_id", METAIO_TYPE_ILWD_CHAR, 1); column_pos.waveform = XLALLIGOLwFindColumn(&env, "waveform", METAIO_TYPE_LSTRING, 1); column_pos.ra = XLALLIGOLwFindColumn(&env, "ra", METAIO_TYPE_REAL_8, 0); column_pos.dec = XLALLIGOLwFindColumn(&env, "dec", METAIO_TYPE_REAL_8, 0); column_pos.psi = XLALLIGOLwFindColumn(&env, "psi", METAIO_TYPE_REAL_8, 0); column_pos.time_geocent_gps = XLALLIGOLwFindColumn(&env, "time_geocent_gps", METAIO_TYPE_INT_4S, 1); column_pos.time_geocent_gps_ns = XLALLIGOLwFindColumn(&env, "time_geocent_gps_ns", METAIO_TYPE_INT_4S, 1); column_pos.time_geocent_gmst = XLALLIGOLwFindColumn(&env, "time_geocent_gmst", METAIO_TYPE_REAL_8, 0); column_pos.duration = XLALLIGOLwFindColumn(&env, "duration", METAIO_TYPE_REAL_8, 0); column_pos.frequency = XLALLIGOLwFindColumn(&env, "frequency", METAIO_TYPE_REAL_8, 0); column_pos.bandwidth = XLALLIGOLwFindColumn(&env, "bandwidth", METAIO_TYPE_REAL_8, 0); column_pos.q = XLALLIGOLwFindColumn(&env, "q", METAIO_TYPE_REAL_8, 0); column_pos.pol_ellipse_angle = XLALLIGOLwFindColumn(&env, "pol_ellipse_angle", METAIO_TYPE_REAL_8, 0); column_pos.pol_ellipse_e = XLALLIGOLwFindColumn(&env, "pol_ellipse_e", METAIO_TYPE_REAL_8, 0); column_pos.amplitude = XLALLIGOLwFindColumn(&env, "amplitude", METAIO_TYPE_REAL_8, 0); column_pos.hrss = XLALLIGOLwFindColumn(&env, "hrss", METAIO_TYPE_REAL_8, 0); column_pos.egw_over_rsquared = XLALLIGOLwFindColumn(&env, "egw_over_rsquared", METAIO_TYPE_REAL_8, 0); column_pos.waveform_number = XLALLIGOLwFindColumn(&env, "waveform_number", METAIO_TYPE_INT_8U, 0); column_pos.time_slide_id = XLALLIGOLwFindColumn(&env, "time_slide_id", METAIO_TYPE_ILWD_CHAR, 1); column_pos.simulation_id = XLALLIGOLwFindColumn(&env, "simulation_id", METAIO_TYPE_ILWD_CHAR, 1); /* check for failure (== a required column is missing) */ if(XLALGetBaseErrno()) { MetaioAbort(&env); XLALPrintError("%s(): failure reading %s table: missing required column\n", __func__, table_name); XLAL_ERROR_NULL(XLAL_EFUNC); } /* loop over the rows in the file */ while((miostatus = MetaioGetRow(&env)) > 0) { /* create a new row */ SimBurst *row = XLALCreateSimBurst(); if(!row) { XLALDestroySimBurstTable(head); MetaioAbort(&env); XLAL_ERROR_NULL(XLAL_EFUNC); } /* populate the columns */ if((row->process_id = XLALLIGOLwParseIlwdChar(&env, column_pos.process_id, "process", "process_id")) < 0) { XLALDestroySimBurst(row); XLALDestroySimBurstTable(head); MetaioAbort(&env); XLAL_ERROR_NULL(XLAL_EFUNC); } if(strlen(env.ligo_lw.table.elt[column_pos.waveform].data.lstring.data) >= sizeof(row->waveform)) { XLALDestroySimBurst(row); XLALDestroySimBurstTable(head); MetaioAbort(&env); XLALPrintError("%s(): failure reading %s table: string too long\n", __func__, table_name); XLAL_ERROR_NULL(XLAL_EIO); } strncpy(row->waveform, env.ligo_lw.table.elt[column_pos.waveform].data.lstring.data, sizeof(row->waveform) - 1); if(column_pos.ra >= 0) row->ra = env.ligo_lw.table.elt[column_pos.ra].data.real_8; if(column_pos.dec >= 0) row->dec = env.ligo_lw.table.elt[column_pos.dec].data.real_8; if(column_pos.psi >= 0) row->psi = env.ligo_lw.table.elt[column_pos.psi].data.real_8; XLALGPSSet(&row->time_geocent_gps, env.ligo_lw.table.elt[column_pos.time_geocent_gps].data.int_4s, env.ligo_lw.table.elt[column_pos.time_geocent_gps_ns].data.int_4s); if(column_pos.time_geocent_gmst >= 0) row->time_geocent_gmst = env.ligo_lw.table.elt[column_pos.time_geocent_gmst].data.real_8; if((row->time_slide_id = XLALLIGOLwParseIlwdChar(&env, column_pos.time_slide_id, "time_slide", "time_slide_id")) < 0) { XLALDestroySimBurst(row); XLALDestroySimBurstTable(head); MetaioAbort(&env); XLAL_ERROR_NULL(XLAL_EFUNC); } if((row->simulation_id = XLALLIGOLwParseIlwdChar(&env, column_pos.simulation_id, "sim_burst", "simulation_id")) < 0) { XLALDestroySimBurst(row); XLALDestroySimBurstTable(head); MetaioAbort(&env); XLAL_ERROR_NULL(XLAL_EFUNC); } if(!strcmp(row->waveform, "StringCusp")) { if(column_pos.duration < 0 || column_pos.frequency < 0 || column_pos.amplitude < 0) { XLALDestroySimBurst(row); XLALDestroySimBurstTable(head); MetaioAbort(&env); XLALPrintError("%s(): failure reading %s table: missing required column\n", __func__, table_name); XLAL_ERROR_NULL(XLAL_EIO); } row->duration = env.ligo_lw.table.elt[column_pos.duration].data.real_8; row->frequency = env.ligo_lw.table.elt[column_pos.frequency].data.real_8; row->amplitude = env.ligo_lw.table.elt[column_pos.amplitude].data.real_8; } else if(!strcmp(row->waveform, "SineGaussian")) { if(column_pos.duration < 0 || column_pos.frequency < 0 || column_pos.bandwidth < 0 || column_pos.q < 0 || column_pos.pol_ellipse_angle < 0 || column_pos.pol_ellipse_e < 0 || column_pos.hrss < 0) { XLALDestroySimBurst(row); XLALDestroySimBurstTable(head); MetaioAbort(&env); XLALPrintError("%s(): failure reading %s table: missing required column\n", __func__, table_name); XLAL_ERROR_NULL(XLAL_EIO); } row->duration = env.ligo_lw.table.elt[column_pos.duration].data.real_8; row->frequency = env.ligo_lw.table.elt[column_pos.frequency].data.real_8; row->bandwidth = env.ligo_lw.table.elt[column_pos.bandwidth].data.real_8; row->q = env.ligo_lw.table.elt[column_pos.q].data.real_8; row->pol_ellipse_angle = env.ligo_lw.table.elt[column_pos.pol_ellipse_angle].data.real_8; row->pol_ellipse_e = env.ligo_lw.table.elt[column_pos.pol_ellipse_e].data.real_8; row->hrss = env.ligo_lw.table.elt[column_pos.hrss].data.real_8; } else if(!strcmp(row->waveform, "Gaussian")) { if(column_pos.duration < 0 || column_pos.hrss < 0) { XLALDestroySimBurst(row); XLALDestroySimBurstTable(head); MetaioAbort(&env); XLALPrintError("%s(): failure reading %s table: missing required column\n", __func__, table_name); XLAL_ERROR_NULL(XLAL_EIO); } row->duration = env.ligo_lw.table.elt[column_pos.duration].data.real_8; row->hrss = env.ligo_lw.table.elt[column_pos.hrss].data.real_8; } else if(!strcmp(row->waveform, "BTLWNB")) { if(column_pos.duration < 0 || column_pos.frequency < 0 || column_pos.bandwidth < 0 || column_pos.pol_ellipse_e < 0 || column_pos.egw_over_rsquared < 0 || column_pos.waveform_number < 0) { XLALDestroySimBurst(row); XLALDestroySimBurstTable(head); MetaioAbort(&env); XLALPrintError("%s(): failure reading %s table: missing required column\n", __func__, table_name); XLAL_ERROR_NULL(XLAL_EIO); } row->duration = env.ligo_lw.table.elt[column_pos.duration].data.real_8; row->frequency = env.ligo_lw.table.elt[column_pos.frequency].data.real_8; row->bandwidth = env.ligo_lw.table.elt[column_pos.bandwidth].data.real_8; row->pol_ellipse_e = env.ligo_lw.table.elt[column_pos.pol_ellipse_e].data.real_8; row->egw_over_rsquared = env.ligo_lw.table.elt[column_pos.egw_over_rsquared].data.real_8; row->waveform_number = env.ligo_lw.table.elt[column_pos.waveform_number].data.int_8u; } else if(!strcmp(row->waveform, "Impulse")) { if(column_pos.amplitude < 0) { XLALDestroySimBurst(row); XLALDestroySimBurstTable(head); MetaioAbort(&env); XLALPrintError("%s(): failure reading %s table: missing required column\n", __func__, table_name); XLAL_ERROR_NULL(XLAL_EIO); } row->amplitude = env.ligo_lw.table.elt[column_pos.amplitude].data.real_8; } else { /* unrecognized waveform */ XLALDestroySimBurst(row); XLALDestroySimBurstTable(head); MetaioAbort(&env); XLALPrintError("%s(): unrecognized waveform \"%s\" in %s table\n", __func__, row->waveform, table_name); XLAL_ERROR_NULL(XLAL_EIO); } /* if outside accepted time window, discard */ if((start && XLALGPSDiff(start, &row->time_geocent_gps) > 0) || (end && XLALGPSDiff(end, &row->time_geocent_gps) < 0)) { XLALDestroySimBurst(row); continue; } /* append to linked list */ *next = row; next = &(*next)->next; } if(miostatus < 0) { XLALDestroySimBurstTable(head); MetaioAbort(&env); XLALPrintError("%s(): I/O error parsing %s table: %s\n", __func__, table_name, env.mierrmsg.data ? env.mierrmsg.data : "unknown reason"); XLAL_ERROR_NULL(XLAL_EIO); } /* close file */ if(MetaioClose(&env)) { XLALDestroySimBurstTable(head); XLALPrintError("%s(): error parsing document after %s table: %s\n", __func__, table_name, env.mierrmsg.data ? env.mierrmsg.data : "unknown reason"); XLAL_ERROR_NULL(XLAL_EIO); } /* done */ return head; }