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;
}
