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