COMPLEX16FrequencySeries *XLALFrStreamInputCOMPLEX16FrequencySeries(LALFrStream * stream, const char *chname, const LIGOTimeGPS * epoch) { COMPLEX16FrequencySeries *series; LALTYPECODE typecode; if (XLALFrStreamSeek(stream, epoch)) XLAL_ERROR_NULL(XLAL_EFUNC); typecode = XLALFrFileQueryChanType(stream->file, chname, stream->pos); switch (typecode) { case LAL_S_TYPE_CODE: INPUTFS(series, COMPLEX16, REAL4, S2S, stream, chname, epoch); break; case LAL_D_TYPE_CODE: INPUTFS(series, COMPLEX16, REAL8, S2S, stream, chname, epoch); break; case LAL_C_TYPE_CODE: INPUTFS(series, COMPLEX16, COMPLEX8, S2S, stream, chname, epoch); case LAL_Z_TYPE_CODE: series = XLALFrStreamReadCOMPLEX16FrequencySeries(stream, chname, epoch); if (!series) XLAL_ERROR_NULL(XLAL_EFUNC); default: XLAL_ERROR_NULL(XLAL_ETYPE); } return series; }
STYPE *STREAMREADSERIES(LALFrStream * stream, const char *chname, const LIGOTimeGPS * start, double duration, size_t lengthlimit) { STYPE *series; size_t length; /* create and initialize a zero-length time series vector */ series = CREATESERIES(chname, start, 0.0, 0.0, &lalADCCountUnit, 0); if (!series) XLAL_ERROR_NULL(XLAL_EFUNC); /* get the time series meta-data */ if (STREAMGETSERIES(series, stream)) { DESTROYSERIES(series); XLAL_ERROR_NULL(XLAL_EFUNC); } /* resize the time series to the correct number of samples */ length = duration / series->deltaT; if (lengthlimit && (lengthlimit < length)) length = lengthlimit; if (!RESIZESERIES(series, 0, length)) { DESTROYSERIES(series); XLAL_ERROR_NULL(XLAL_EFUNC); } /* read the data */ if (XLALFrStreamSeek(stream, start) || STREAMGETSERIES(series, stream)) { DESTROYSERIES(series); XLAL_ERROR_NULL(XLAL_EFUNC); } return series; }
/** * @brief Seeks a LALFrStream stream by a time offset * @details * The position of a LALFrStream is set so that the net read will * be at the specified time offset. The offset @p dt is a number of * seconds relative to the @p whence postion, which can be * @p SEEK_SET to seek relative to the beginning of the stream, * @p SEEK_CUR to seek relative to the current position of the stream, * or @p SEEK_END to seek relative to the end of the stream. * The return codes and conditions are the same as XLALFrStreamSeek(). * @param stream Pointer to a #LALFrStream structure. * @param dt The offset time in seconds. * @param whence The position whence to seek: one of @p SEEK_SET, @p SEEK_CUR, * or @p SEEK_END. * @retval 3 Time requested is in a gap in the data. * @retval 2 Time requested is after the end of the stream. * @retval 1 Time requested is before the beginning of the stream. * @retval 0 Normal success. * @retval <0 Failure. */ int XLALFrStreamSeekO(LALFrStream * stream, double dt, int whence) { LIGOTimeGPS epoch; switch (whence) { case SEEK_SET: if (XLALFrStreamRewind(stream) < 0) XLAL_ERROR(XLAL_EFUNC); /* FALL THROUGH */ case SEEK_CUR: epoch = stream->epoch; break; case SEEK_END: /* go to the last frame */ XLALFrStreamFileClose(stream); if (XLALFrStreamFileOpen(stream, stream->cache->length - 1) < 0) XLAL_ERROR(XLAL_EFUNC); if ((stream->pos = XLALFrFileQueryNFrame(stream->file) - 1) < 0) XLAL_ERROR(XLAL_EFUNC); if (XLALFrFileQueryGTime(&epoch, stream->file, stream->pos) == NULL) XLAL_ERROR(XLAL_EFUNC); /* add duration of last frame to dt */ dt += XLALFrFileQueryDt(stream->file, stream->pos); break; default: XLAL_ERROR(XLAL_EINVAL, "Invalid whence value: use SEEK_SET, SEEK_CUR, or SEEK_END"); } XLALGPSAdd(&epoch, dt); if (XLALFrStreamSeek(stream, &epoch) < 0) XLAL_ERROR(XLAL_EFUNC); return 0; }
REAL8FrequencySeries *XLALFrStreamInputREAL8FrequencySeries(LALFrStream * stream, const char *chname, const LIGOTimeGPS * epoch) { REAL8FrequencySeries *series; LALTYPECODE typecode; if (XLALFrStreamSeek(stream, epoch)) XLAL_ERROR_NULL(XLAL_EFUNC); typecode = XLALFrFileQueryChanType(stream->file, chname, stream->pos); switch (typecode) { case LAL_S_TYPE_CODE: INPUTFS(series, REAL8, REAL4, S2S, stream, chname, epoch); break; case LAL_D_TYPE_CODE: series = XLALFrStreamReadREAL8FrequencySeries(stream, chname, epoch); if (!series) XLAL_ERROR_NULL(XLAL_EFUNC); break; case LAL_C_TYPE_CODE: case LAL_Z_TYPE_CODE: XLAL_PRINT_ERROR("Cannot convert complex type to float type"); default: XLAL_ERROR_NULL(XLAL_ETYPE); } return series; }
COMPLEX16TimeSeries *XLALFrStreamInputCOMPLEX16TimeSeries(LALFrStream * stream, const char *chname, const LIGOTimeGPS * start, double duration, size_t lengthlimit) { COMPLEX16TimeSeries *series; LALTYPECODE typecode; if (XLALFrStreamSeek(stream, start)) XLAL_ERROR_NULL(XLAL_EFUNC); typecode = XLALFrFileQueryChanType(stream->file, chname, stream->pos); switch (typecode) { case LAL_I2_TYPE_CODE: INPUTTS(series, COMPLEX16, INT2, S2S, stream, chname, start, duration, lengthlimit); break; case LAL_I4_TYPE_CODE: INPUTTS(series, COMPLEX16, INT4, S2S, stream, chname, start, duration, lengthlimit); break; case LAL_I8_TYPE_CODE: INPUTTS(series, COMPLEX16, INT8, S2S, stream, chname, start, duration, lengthlimit); break; case LAL_U2_TYPE_CODE: INPUTTS(series, COMPLEX16, UINT2, S2S, stream, chname, start, duration, lengthlimit); break; case LAL_U4_TYPE_CODE: INPUTTS(series, COMPLEX16, UINT4, S2S, stream, chname, start, duration, lengthlimit); break; case LAL_U8_TYPE_CODE: INPUTTS(series, COMPLEX16, UINT8, S2S, stream, chname, start, duration, lengthlimit); break; case LAL_S_TYPE_CODE: INPUTTS(series, COMPLEX16, REAL4, S2S, stream, chname, start, duration, lengthlimit); break; case LAL_D_TYPE_CODE: INPUTTS(series, COMPLEX16, REAL8, S2S, stream, chname, start, duration, lengthlimit); break; case LAL_C_TYPE_CODE: INPUTTS(series, COMPLEX16, COMPLEX8, S2S, stream, chname, start, duration, lengthlimit); case LAL_Z_TYPE_CODE: series = XLALFrStreamReadCOMPLEX16TimeSeries(stream, chname, start, duration, lengthlimit); if (!series) XLAL_ERROR_NULL(XLAL_EFUNC); default: XLAL_ERROR_NULL(XLAL_ETYPE); } return series; }
STYPE *STREAMREADSERIES(LALFrStream * stream, const char *chname, const LIGOTimeGPS * epoch) { STYPE *series; /* seek to the relevant point in the stream */ if (XLALFrStreamSeek(stream, epoch)) XLAL_ERROR_NULL(XLAL_EFUNC); series = READSERIES(stream->file, chname, stream->pos); if (!series) XLAL_ERROR_NULL(XLAL_EFUNC); return series; }
int STREAMGETSERIES(STYPE * series, LALFrStream * stream) { STYPE *tmpser; /* seek to the relevant point in the stream */ if (XLALFrStreamSeek(stream, &series->epoch)) XLAL_ERROR(XLAL_EFUNC); tmpser = READSERIES(stream->file, series->name, stream->pos); if (!tmpser) XLAL_ERROR(XLAL_EFUNC); *series = *tmpser; LALFree(tmpser); return 0; }
/* read a LIGO time series */ REAL4TimeSeries *get_ligo_data(LALFrStream *stream, CHAR *channel, LIGOTimeGPS start, LIGOTimeGPS end) { /* variables */ REAL4TimeSeries *series; size_t length; if (vrbflg) fprintf(stdout, "Allocating memory for \"%s\" series...\n", channel); /* create and initialise time series */ series = XLALCreateREAL4TimeSeries(channel, &start, 0, 0, \ &lalADCCountUnit, 0); if (vrbflg) fprintf(stdout, "Reading \"%s\" series metadata...\n", channel); /* get the series meta data */ XLALFrStreamGetREAL4TimeSeriesMetadata(series, stream); if (vrbflg) fprintf(stdout, "Resizing \"%s\" series...\n", channel); /* resize series to the correct number of samples */ length = floor((XLALGPSDiff(&end, &start) / series->deltaT) + 0.5); XLALResizeREAL4TimeSeries(series, 0, length); if (vrbflg) fprintf(stdout, "Reading channel \"%s\"...\n", channel); /* seek to and read data */ XLALFrStreamSeek(stream, &start); XLALFrStreamGetREAL4TimeSeries(series, stream); return(series); }
/* read and high pass filter a GEO time series */ REAL4TimeSeries *get_geo_data(LALFrStream *stream, CHAR *channel, LIGOTimeGPS start, LIGOTimeGPS end, INT4 hpf_order, REAL8 hpf_frequency, REAL8 hpf_attenuation) { /* variables */ PassBandParamStruc high_pass_params; REAL4TimeSeries *series; REAL8TimeSeries *geo; size_t length; size_t i; if (vrbflg) fprintf(stdout, "Allocating memory for \"%s\" series...\n", channel); /* create and initialise time series */ geo = XLALCreateREAL8TimeSeries(channel, &start, 0, 0, \ &lalADCCountUnit, 0); if (vrbflg) fprintf(stdout, "Reading \"%s\" series metadata...\n", channel); /* get the series meta data */ XLALFrStreamGetREAL8TimeSeriesMetadata(geo, stream); if (vrbflg) fprintf(stdout, "Resizing \"%s\" series...\n", channel); /* resize series to the correct number of samples */ length = floor((XLALGPSDiff(&end, &start) / geo->deltaT) + 0.5); XLALResizeREAL8TimeSeries(geo, 0, length); if (vrbflg) fprintf(stdout, "Reading channel \"%s\"...\n", channel); /* seek to and read data */ XLALFrStreamSeek(stream, &start); XLALFrStreamGetREAL8TimeSeries(geo, stream); if (vrbflg) fprintf(stdout, "High pass filtering \"%s\"...\n", channel); /* high pass filter before casting to a REAL4 */ high_pass_params.nMax = hpf_order; high_pass_params.f1 = -1; high_pass_params.f2 = hpf_frequency; high_pass_params.a1 = -1; high_pass_params.a2 = hpf_attenuation; XLALButterworthREAL8TimeSeries(geo, &high_pass_params); if (vrbflg) fprintf(stdout, "Casting \"%s\" as a REAL4...\n", channel); /* cast as a REAL4 */ series = XLALCreateREAL4TimeSeries(geo->name, &geo->epoch, geo->f0, \ geo->deltaT, &geo->sampleUnits, geo->data->length); for (i = 0; i < series->data->length; i++) series->data->data[i] = (REAL4)geo->data->data[i]; /* destroy geo series */ XLALDestroyREAL8TimeSeries(geo); return(series); }