static int test(struct tm *t, int correct_gps, int line)
{
int gps = XLALUTCToGPS(t);
if (XLALGetBaseErrno())
{
fprintf(stderr, "TestUTCtoGPS: error in XLALUTCToGPS(), line %i\n", line);
return -1;
}
if (lalDebugLevel > 0)
{
char buf[64];
strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", t);
fprintf(stderr, "Input = %s\tOutput = %d\n\tExpected = %d\n",
buf, gps, correct_gps);
}
if (gps != correct_gps)
{
if (lalDebugLevel > 0)
fprintf(stderr, "TestUTCtoGPS: error, line %i\n", line);
return -1;
}
return 0;
}
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;
}
/**
* 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;
}
