void
LALFreqTimeRealFFT(
LALStatus *status,
REAL4TimeSeries *time,
COMPLEX8FrequencySeries *freq,
RealFFTPlan *plan
)
{
INITSTATUS(status);
XLAL_PRINT_DEPRECATION_WARNING("XLALREAL4FreqTimeFFT");
ATTATCHSTATUSPTR( status );
ASSERT( plan, status, TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( freq, status, TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( time, status, TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( time->data, status, TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( time->data->length, status,
TIMEFREQFFTH_ESIZE, TIMEFREQFFTH_MSGESIZE );
ASSERT( freq->deltaF > 0, status, TIMEFREQFFTH_ERATE, TIMEFREQFFTH_MSGERATE );
/* call the XLAL function */
if ( XLALREAL4FreqTimeFFT( time, freq, plan ) == XLAL_FAILURE )
{
XLALClearErrno();
ABORTXLAL( status );
}
DETATCHSTATUSPTR( status );
RETURN( status );
}
static PyObject *pylal_XLALCalculateEThincaParameter(PyObject *self, PyObject *args)
{
static InspiralAccuracyList accuracyparams;
static int accuracyparams_set = 0;
pylal_SnglInspiralTable *row1, *row2;
double result;
if(!PyArg_ParseTuple(args, "O!O!", &pylal_SnglInspiralTable_Type, &row1, &pylal_SnglInspiralTable_Type, &row2))
return NULL;
if(!accuracyparams_set) {
memset(&accuracyparams, 0, sizeof(accuracyparams));
XLALPopulateAccuracyParams(&accuracyparams);
accuracyparams_set = 1;
}
result = XLALCalculateEThincaParameter(&row1->sngl_inspiral, &row2->sngl_inspiral, &accuracyparams);
if(XLAL_IS_REAL8_FAIL_NAN(result)) {
XLALClearErrno();
PyErr_SetString(PyExc_ValueError, "not coincident");
return NULL;
}
return PyFloat_FromDouble(result);
}
void
LALTimeFreqComplexFFT(
LALStatus *status,
COMPLEX8FrequencySeries *freq,
COMPLEX8TimeSeries *time,
ComplexFFTPlan *plan
)
{
INITSTATUS(status);
XLAL_PRINT_DEPRECATION_WARNING("XLALCOMPLEX8TimeFreqFFT");
ASSERT( plan, status, TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( freq, status, TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( time, status, TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( time->data, status, TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( time->data->length, status, TIMEFREQFFTH_ESIZE, TIMEFREQFFTH_MSGESIZE );
ASSERT( time->deltaT > 0, status, TIMEFREQFFTH_ERATE, TIMEFREQFFTH_MSGERATE );
ASSERT( plan->sign == -1, status, TIMEFREQFFTH_ESIGN, TIMEFREQFFTH_MSGESIGN );
if ( XLALCOMPLEX8TimeFreqFFT( freq, time, plan ) == XLAL_FAILURE )
{
XLALClearErrno();
ABORTXLAL( status );
}
RETURN( status );
}
void
LALNormalDeviates (
LALStatus *status,
REAL4Vector *deviates,
RandomParams *params
)
{
INITSTATUS(status);
ASSERT (params, status, RANDOMH_ENULL, RANDOMH_MSGENULL);
ASSERT (deviates, status, RANDOMH_ENULL, RANDOMH_MSGENULL);
ASSERT (deviates->data, status, RANDOMH_ENULL, RANDOMH_MSGENULL);
ASSERT (deviates->length > 0, status, RANDOMH_ESIZE, RANDOMH_MSGESIZE);
if ( XLALNormalDeviates( deviates, params ) != XLAL_SUCCESS )
{
int errnum = xlalErrno;
XLALClearErrno();
switch ( errnum )
{
case XLAL_EFAULT:
ABORT( status, RANDOMH_ENULL, RANDOMH_MSGENULL );
case XLAL_EBADLEN:
ABORT( status, RANDOMH_ESIZE, RANDOMH_MSGESIZE );
default:
ABORTXLAL( status );
}
}
RETURN (status);
}
/**
* DEPRECATED.
* \deprecated Use XLALCreateDetector() instead.
*/
void LALCreateDetector( LALStatus *status,
LALDetector *output,
const LALFrDetector *input,
const LALDetectorType type )
{
INITSTATUS(status);
ASSERT( input != NULL, status, LALDETECTORSH_ENULLP,
LALDETECTORSH_MSGENULLP );
ASSERT( output != NULL, status, LALDETECTORSH_ENULLP,
LALDETECTORSH_MSGENULLP );
output = XLALCreateDetector( output, input, type );
if ( ! output )
switch ( XLALClearErrno() )
{
case XLAL_EINVAL:
ABORT( status, LALDETECTORSH_ETYPE, LALDETECTORSH_MSGETYPE );
break;
default:
ABORTXLAL( status );
}
RETURN(status);
}
static PyObject *pylal_XLAL3DRinca(PyObject *self, PyObject *args)
{
pylal_SnglRingdownTable *row1, *row2;
double result;
if(!PyArg_ParseTuple(args, "O!O!", &pylal_SnglRingdownTable_Type, &row1, &pylal_SnglRingdownTable_Type, &row2))
return NULL;
result = XLAL3DRinca(&row1->sngl_ringdown, &row2->sngl_ringdown);
if(XLAL_IS_REAL8_FAIL_NAN(result)) {
XLALClearErrno();
PyErr_SetString(PyExc_ValueError, "not coincident");
return NULL;
}
return PyFloat_FromDouble(result);
}
void
LALUniformDeviate (
LALStatus *status,
REAL4 *deviate,
RandomParams *params
)
{
INITSTATUS(status);
ASSERT (deviate, status, RANDOMH_ENULL, RANDOMH_MSGENULL);
ASSERT (params, status, RANDOMH_ENULL, RANDOMH_MSGENULL);
*deviate = XLALUniformDeviate( params );
if ( XLAL_IS_REAL4_FAIL_NAN( *deviate ) )
{
XLALClearErrno();
ABORT( status, RANDOMH_ENULL, RANDOMH_MSGENULL );
}
RETURN (status);
}
void
LALCreateRandomParams (
LALStatus *status,
RandomParams **params,
INT4 seed
)
{
INITSTATUS(status);
ASSERT (params, status, RANDOMH_ENULL, RANDOMH_MSGENULL);
ASSERT (!*params, status, RANDOMH_ENNUL, RANDOMH_MSGENNUL);
*params = XLALCreateRandomParams( seed );
if ( ! params )
{
XLALClearErrno();
ABORT( status, RANDOMH_ENULL, RANDOMH_MSGENULL );
}
RETURN (status);
}
/**
* Deprecated.
* \deprecated Use XLALWToZCOMPLEX16ZPGFilter() instead
*/
void
LALWToZCOMPLEX16ZPGFilter( LALStatus *stat,
COMPLEX16ZPGFilter *filter )
{
INITSTATUS(stat);
if(XLALWToZCOMPLEX16ZPGFilter(filter)<0)
{
int code=xlalErrno;
XLALClearErrno();
switch(code){
case XLAL_EFAULT:
ABORT(stat,ZPGFILTERH_ENUL,ZPGFILTERH_MSGENUL);
case XLAL_EINVAL:
ABORT(stat,ZPGFILTERH_EBAD,ZPGFILTERH_MSGEBAD);
default:
ABORTXLAL(stat);
}
}
RETURN(stat);
}
void FUNC ( LALStatus *status, ATYPE **array, UINT4Vector *dimLength )
{
INITSTATUS(status);
/* make sure arguments are sane */
ASSERT (array, status, AVFACTORIESH_EVPTR, AVFACTORIESH_MSGEVPTR);
ASSERT (!*array, status, AVFACTORIESH_EUPTR, AVFACTORIESH_MSGEUPTR);
ASSERT (dimLength, status, AVFACTORIESH_EVPTR, AVFACTORIESH_MSGEVPTR);
ASSERT (dimLength->data, status, AVFACTORIESH_EVPTR, AVFACTORIESH_MSGEVPTR);
ASSERT (dimLength->length, status,
AVFACTORIESH_ELENGTH, AVFACTORIESH_MSGELENGTH);
*array = XFUNC ( dimLength );
if ( ! *array )
{
int code = xlalErrno & ~XLAL_EFUNC; /* turn off subfunction error bit */
XLALClearErrno();
if ( code & XLAL_EFAULT )
{
ABORT (status, AVFACTORIESH_EVPTR, AVFACTORIESH_MSGEVPTR);
}
if ( code == XLAL_EBADLEN )
{
ABORT (status, AVFACTORIESH_ELENGTH, AVFACTORIESH_MSGELENGTH);
}
if ( code == XLAL_EINVAL )
{
ABORT (status, AVFACTORIESH_EVPTR, AVFACTORIESH_MSGEVPTR);
}
if ( code == XLAL_ENOMEM )
{
ABORT (status, AVFACTORIESH_EMALLOC, AVFACTORIESH_MSGEMALLOC);
}
}
RETURN (status);
}
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;
}
static struct options parse_command_line(int *argc, char **argv[], const ProcessTable *process, ProcessParamsTable **paramaddpoint)
{
struct options options = options_defaults();
int c;
int option_index;
struct LALoption long_options[] = {
{"gps-end-time", required_argument, NULL, 'A'},
{"gps-start-time", required_argument, NULL, 'B'},
{"help", no_argument, NULL, 'C'},
{"max-amplitude", required_argument, NULL, 'D'},
{"min-amplitude", required_argument, NULL, 'E'},
{"max-bandwidth", required_argument, NULL, 'F'},
{"min-bandwidth", required_argument, NULL, 'G'},
{"max-duration", required_argument, NULL, 'H'},
{"min-duration", required_argument, NULL, 'I'},
{"max-e-over-r2", required_argument, NULL, 'S'},
{"min-e-over-r2", required_argument, NULL, 'T'},
{"max-frequency", required_argument, NULL, 'J'},
{"min-frequency", required_argument, NULL, 'K'},
{"max-hrss", required_argument, NULL, 'L'},
{"min-hrss", required_argument, NULL, 'M'},
{"output", required_argument, NULL, 'V'},
{"population", required_argument, NULL, 'N'},
{"q", required_argument, NULL, 'O'},
{"ra-dec", required_argument, NULL, 'U'},
{"seed", required_argument, NULL, 'P'},
{"time-step", required_argument, NULL, 'Q'},
{"time-slide-file", required_argument, NULL, 'W'},
{"jitter", required_argument, NULL, 'X'},
{"user-tag", required_argument, NULL, 'R'},
{NULL, 0, NULL, 0}
};
do switch(c = LALgetopt_long(*argc, *argv, "", long_options, &option_index)) {
case 'A':
XLALClearErrno();
{
LIGOTimeGPS tmp;
XLALStrToGPS(&tmp, LALoptarg, NULL);
options.gps_end_time = XLALGPSToINT8NS(&tmp);
}
if(xlalErrno) {
fprintf(stderr, "invalid --%s (%s specified)\n", long_options[option_index].name, LALoptarg);
exit(1);
}
ADD_PROCESS_PARAM(process, "lstring");
break;
case 'B':
XLALClearErrno();
{
LIGOTimeGPS tmp;
XLALStrToGPS(&tmp, LALoptarg, NULL);
options.gps_start_time = XLALGPSToINT8NS(&tmp);
}
if(xlalErrno) {
fprintf(stderr, "invalid --%s (%s specified)\n", long_options[option_index].name, LALoptarg);
exit(1);
}
ADD_PROCESS_PARAM(process, "lstring");
break;
case 'C':
print_usage();
exit(0);
case 'D':
options.maxA = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "real_8");
break;
case 'E':
options.minA = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "real_8");
break;
case 'F':
options.maxbandwidth = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "real_8");
break;
case 'G':
options.minbandwidth = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "real_8");
break;
case 'H':
options.maxduration = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "real_8");
break;
case 'I':
options.minduration = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "real_8");
break;
case 'J':
options.maxf = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "real_8");
break;
case 'K':
options.minf = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "real_8");
break;
case 'L':
options.maxhrss = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "real_8");
break;
case 'M':
options.minhrss = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "real_8");
break;
case 'N':
if(!strcmp(LALoptarg, "targeted"))
options.population = POPULATION_TARGETED;
else if(!strcmp(LALoptarg, "string_cusp"))
options.population = POPULATION_STRING_CUSP;
else if(!strcmp(LALoptarg, "all_sky_sinegaussian"))
options.population = POPULATION_ALL_SKY_SINEGAUSSIAN;
else if(!strcmp(LALoptarg, "all_sky_btlwnb"))
options.population = POPULATION_ALL_SKY_BTLWNB;
else {
fprintf(stderr, "error: unrecognized population \"%s\"", LALoptarg);
exit(1);
}
ADD_PROCESS_PARAM(process, "lstring");
break;
case 'O':
options.q = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "real_8");
break;
case 'P':
options.seed = atol(LALoptarg);
ADD_PROCESS_PARAM(process, "int_8u");
break;
case 'Q':
options.time_step = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "real_8");
break;
case 'R':
options.user_tag = LALoptarg;
ADD_PROCESS_PARAM(process, "lstring");
break;
case 'S':
options.maxEoverr2 = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "real_8");
break;
case 'T':
options.minEoverr2 = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "real_8");
break;
case 'U':
{
char *end;
options.ra = strtod(LALoptarg, &end);
while(isspace(*end))
end++;
if(*end != ',') {
fprintf(stderr, "error: cannot parse --ra-dec \"%s\"\n", LALoptarg);
exit(1);
}
options.dec = strtod(end + 1, &end);
while(isspace(*end))
end++;
if(*end != '\0') {
fprintf(stderr, "error: cannot parse --ra-dec \"%s\"\n", LALoptarg);
exit(1);
}
}
ADD_PROCESS_PARAM(process, "lstring");
break;
case 'V':
options.output = LALoptarg;
break;
case 'W':
options.time_slide_file = LALoptarg;
ADD_PROCESS_PARAM(process, "lstring");
break;
case 'X':
options.jitter = atof(LALoptarg);
ADD_PROCESS_PARAM(process, "lstring");
break;
case 0:
/* option sets a flag */
break;
case -1:
/* end of arguments */
break;
case '?':
/* unrecognized option */
print_usage();
exit(1);
case ':':
/* missing argument for an option */
print_usage();
exit(1);
} while(c != -1);
/* check some of the input parameters for consistency */
if(options.maxA < options.minA) {
fprintf(stderr, "error: --max-amplitude < --min-amplitude\n");
exit(1);
}
if(options.maxbandwidth < options.minbandwidth) {
fprintf(stderr, "error: --max-bandwidth < --min-bandwidth\n");
exit(1);
}
if(options.maxduration < options.minduration) {
fprintf(stderr, "error: --max-duration < --min-duration\n");
exit(1);
}
if(options.maxf < options.minf) {
fprintf(stderr, "error: --max-frequency < --min-frequency\n");
exit(1);
}
if(options.maxhrss < options.minhrss) {
fprintf(stderr, "error: --max-hrss < --min-hrss\n");
exit(1);
}
if(options.gps_start_time == -1 || options.gps_end_time == -1) {
fprintf(stderr, "--gps-start-time and --gps-end-time are both required\n");
exit(1);
}
if(options.gps_end_time < options.gps_start_time) {
fprintf(stderr, "error: --gps-end-time < --gps-start-time\n");
exit(1);
}
if(!options.time_slide_file) {
fprintf(stderr, "--time-slide-file is required\n");
exit(1);
}
switch(options.population) {
case POPULATION_TARGETED:
case POPULATION_ALL_SKY_SINEGAUSSIAN:
case POPULATION_ALL_SKY_BTLWNB:
case POPULATION_STRING_CUSP:
break;
default:
fprintf(stderr, "error: --population is required\n");
exit(1);
}
if(!options.output) {
int max_length = 100; /* ARGH: ugly */
options.output = calloc(max_length + 1, sizeof(*options.output));
if(options.user_tag)
snprintf(options.output, max_length, "HL-INJECTIONS_%s-%d-%d.xml", options.user_tag, (int) (options.gps_start_time / LAL_INT8_C(1000000000)), (int) ((options.gps_end_time - options.gps_start_time) / LAL_INT8_C(1000000000)));
else
snprintf(options.output, max_length, "HL-INJECTIONS-%d-%d.xml", (int) (options.gps_start_time / LAL_INT8_C(1000000000)), (int) ((options.gps_end_time - options.gps_start_time) / LAL_INT8_C(1000000000)));
}
return options;
}
void AddNumRelStrainModes( LALStatus *status, /**< pointer to LALStatus structure */
REAL4TimeVectorSeries **outStrain, /**< [out] h+, hx data */
SimInspiralTable *thisinj /**< [in] injection data */)
{
INT4 modeL, modeM, modeLlo, modeLhi;
INT4 len, lenPlus, lenCross, k;
CHAR *channel_name_plus;
CHAR *channel_name_cross;
LALFrStream *frStream = NULL;
LALCache frCache;
LIGOTimeGPS epoch;
REAL4TimeSeries *seriesPlus=NULL;
REAL4TimeSeries *seriesCross=NULL;
REAL8 massMpc;
REAL4TimeVectorSeries *sumStrain=NULL;
REAL4TimeVectorSeries *tempStrain=NULL;
/* NRWaveMetaData thisMetaData; */
INITSTATUS(status);
ATTATCHSTATUSPTR (status);
modeLlo = thisinj->numrel_mode_min;
modeLhi = thisinj->numrel_mode_max;
/* create a frame cache and open the frame stream */
frCache.length = 1;
frCache.list = LALCalloc(1, sizeof(frCache.list[0]));
frCache.list[0].url = thisinj->numrel_data;
frStream = XLALFrStreamCacheOpen( &frCache );
/* the total mass of the binary in Mpc */
massMpc = (thisinj->mass1 + thisinj->mass2) * LAL_MRSUN_SI / ( LAL_PC_SI * 1.0e6);
/* start time of waveform -- set it to something */
epoch.gpsSeconds = 0;
epoch.gpsNanoSeconds = 0;
/* loop over l values */
for ( modeL = modeLlo; modeL <= modeLhi; modeL++ ) {
/* loop over m values */
for ( modeM = -modeL; modeM <= modeL; modeM++ ) {
/* read numrel waveform */
/* first the plus polarization */
channel_name_plus = XLALGetNinjaChannelName("plus", modeL, modeM);
/*get number of data points */
lenPlus = XLALFrStreamGetVectorLength ( channel_name_plus, frStream );
/* now the cross polarization */
channel_name_cross = XLALGetNinjaChannelName("cross", modeL, modeM);
/*get number of data points */
lenCross = XLALFrStreamGetVectorLength ( channel_name_cross, frStream );
/* skip on to next mode if mode doesn't exist */
if ( (lenPlus <= 0) || (lenCross <= 0) || (lenPlus != lenCross) ) {
XLALClearErrno();
LALFree(channel_name_plus);
LALFree(channel_name_cross);
continue;
}
/* note: lenPlus and lenCross must be equal if we got this far*/
/* len = lenPlus; */
len = lenPlus;
/* allocate and read the plus/cross time series */
seriesPlus = XLALCreateREAL4TimeSeries ( channel_name_plus, &epoch, 0, 0, &lalDimensionlessUnit, len);
memset(seriesPlus->data->data, 0, seriesPlus->data->length*sizeof(REAL4));
XLALFrStreamGetREAL4TimeSeries ( seriesPlus, frStream );
XLALFrStreamRewind( frStream );
LALFree(channel_name_plus);
seriesCross = XLALCreateREAL4TimeSeries ( channel_name_cross, &epoch, 0, 0, &lalDimensionlessUnit, len);
memset(seriesCross->data->data, 0, seriesCross->data->length*sizeof(REAL4));
XLALFrStreamGetREAL4TimeSeries ( seriesCross, frStream );
XLALFrStreamRewind( frStream );
LALFree(channel_name_cross);
/* allocate memory for tempStrain */
tempStrain = LALCalloc(1, sizeof(*tempStrain));
tempStrain->data = XLALCreateREAL4VectorSequence(2, len);
tempStrain->deltaT = LAL_MTSUN_SI * (thisinj->mass1 + thisinj->mass2) * seriesPlus->deltaT ;
tempStrain->f0 = seriesPlus->f0;
tempStrain->sampleUnits = seriesPlus->sampleUnits;
memset(tempStrain->data->data, 0, tempStrain->data->length * tempStrain->data->vectorLength*sizeof(REAL4));
/* now copy the data and scale amplitude corresponding to distance of 1Mpc*/
for (k = 0; k < len; k++) {
tempStrain->data->data[k] = massMpc * seriesPlus->data->data[k];
tempStrain->data->data[len + k] = massMpc * seriesCross->data->data[k]; }
/* we are done with seriesPlus and Cross for this iteration */
XLALDestroyREAL4TimeSeries (seriesPlus);
XLALDestroyREAL4TimeSeries (seriesCross);
seriesPlus = NULL;
seriesCross = NULL;
/* compute the h+ and hx for given inclination and coalescence phase*/
XLALOrientNRWave( tempStrain, modeL, modeM, thisinj->inclination, thisinj->coa_phase );
if (sumStrain == NULL) {
sumStrain = LALCalloc(1, sizeof(*sumStrain));
sumStrain->data = XLALCreateREAL4VectorSequence(2, tempStrain->data->vectorLength);
sumStrain->deltaT = tempStrain->deltaT;
sumStrain->f0 = tempStrain->f0;
sumStrain->sampleUnits = tempStrain->sampleUnits;
memset(sumStrain->data->data,0.0,2*tempStrain->data->vectorLength*sizeof(REAL4));
sumStrain = XLALSumStrain( sumStrain, tempStrain );
} else {
sumStrain = XLALSumStrain( sumStrain, tempStrain );
}
/* clear memory for strain */
if (tempStrain->data != NULL) {
XLALDestroyREAL4VectorSequence ( tempStrain->data );
LALFree( tempStrain );
tempStrain = NULL;
}
} /* end loop over modeM values */
} /* end loop over modeL values */
XLALFrStreamClose( frStream );
LALFree(frCache.list);
*outStrain = sumStrain;
DETATCHSTATUSPTR(status);
RETURN(status);
}
/**
* 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;
}
/**
* 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;
}
int main( int argc, char *argv[] )
{
/* lal initialization variables */
LALStatus status = blank_status;
/* program option variables */
CHAR *userTag = NULL;
CHAR comment[LIGOMETA_COMMENT_MAX];
char *ifoName = NULL;
char *inputGlob = NULL;
char *inputFileName = NULL;
char *outputFileName = NULL;
char *tamaFileName = NULL;
char *summFileName = NULL;
REAL4 snrStar = -1;
SnglInspiralClusterChoice clusterchoice = none;
INT8 cluster_dt = -1;
char *injectFileName = NULL;
INT8 inject_dt = -1;
char *missedFileName = NULL;
INT4 hardware = 0;
int enableTrigStartTime = 1;
int j;
FILE *fp = NULL;
glob_t globbedFiles;
int numInFiles = 0;
char **inFileNameList;
char line[MAX_PATH];
int errnum;
UINT8 triggerInputTimeNS = 0;
MetadataTable proctable;
MetadataTable procparams;
ProcessParamsTable *this_proc_param;
UINT4 numSimEvents = 0;
UINT4 numSimInData = 0;
UINT4 numSimFound = 0;
UINT4 numSimMissed = 0;
UINT4 numSimDiscard = 0;
UINT4 numSimProcessed = 0;
SimRingdownTable *simEventHead = NULL;
SimRingdownTable *thisSimEvent = NULL;
SimRingdownTable *missedSimHead = NULL;
SimRingdownTable *thisMissedSim = NULL;
SimRingdownTable *tmpSimEvent = NULL;
SimRingdownTable *prevSimEvent = NULL;
SearchSummaryTable *searchSummaryTable = NULL;
UINT4 numEvents = 0;
UINT4 numEventsKept = 0;
UINT4 numEventsInIFO = 0;
UINT4 numEventsCoinc = 0;
UINT4 numEventsDiscard = 0;
UINT4 numEventsProcessed = 0;
UINT4 numClusteredEvents = 0;
SnglRingdownTable **eventHandle = NULL;
SnglRingdownTable *eventHead = NULL;
SnglRingdownTable *thisEvent = NULL;
SnglRingdownTable *tmpEvent = NULL;
SnglRingdownTable *prevEvent = NULL;
LIGOLwXMLStream xmlStream;
MetadataTable outputTable;
/*
*
* initialization
*
*/
/* set up inital debugging values */
lal_errhandler = LAL_ERR_EXIT;
/* create the process and process params tables */
proctable.processTable = (ProcessTable *)
calloc( 1, sizeof(ProcessTable) );
XLALGPSTimeNow(&(proctable.processTable->start_time));
XLALPopulateProcessTable(proctable.processTable, PROGRAM_NAME,
lalAppsVCSIdentId, lalAppsVCSIdentStatus, lalAppsVCSIdentDate, 0);
this_proc_param = procparams.processParamsTable = (ProcessParamsTable *)
calloc( 1, sizeof(ProcessParamsTable) );
memset( comment, 0, LIGOMETA_COMMENT_MAX * sizeof(CHAR) );
/*
*
* parse command line arguments
*
*/
while (1)
{
/* LALgetopt arguments */
static struct LALoption long_options[] =
{
{"verbose", no_argument, &vrbflg, 1 },
{"sort-triggers", no_argument, &sortTriggers, 1 },
{"help", no_argument, 0, 'h'},
{"user-tag", required_argument, 0, 'Z'},
{"userTag", required_argument, 0, 'Z'},
{"comment", required_argument, 0, 'c'},
{"version", no_argument, 0, 'V'},
{"glob", required_argument, 0, 'g'},
{"input", required_argument, 0, 'i'},
{"output", required_argument, 0, 'o'},
{"data-type", required_argument, 0, 'k'},
{"tama-output", required_argument, 0, 'j'},
{"summary-file", required_argument, 0, 'S'},
{"snr-threshold", required_argument, 0, 's'},
{"cluster-algorithm", required_argument, 0, 'C'},
{"cluster-time", required_argument, 0, 't'},
{"ifo-cut", required_argument, 0, 'd'},
{"injection-file", required_argument, 0, 'I'},
{"injection-coincidence", required_argument, 0, 'T'},
{"missed-injections", required_argument, 0, 'm'},
{"hardware-injections", required_argument, 0, 'H'},
{"disable-trig-start-time", no_argument, 0, 'D'},
{0, 0, 0, 0}
};
int c;
/* LALgetopt_long stores the option index here. */
int option_index = 0;
size_t LALoptarg_len;
c = LALgetopt_long_only ( argc, argv, "hZ:c:d:g:i:o:j:S:s:C:Vt:I:T:m:H:D",
long_options, &option_index );
/* detect the end of the options */
if ( c == - 1 )
break;
switch ( c )
{
case 0:
/* if this option set a flag, do nothing else now */
if ( long_options[option_index].flag != 0 )
{
break;
}
else
{
fprintf( stderr, "error parsing option %s with argument %s\n",
long_options[option_index].name, LALoptarg );
exit( 1 );
}
break;
case 'h':
fprintf( stdout, USAGE );
exit( 0 );
break;
case 'Z':
/* create storage for the usertag */
LALoptarg_len = strlen( LALoptarg ) + 1;
userTag = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR) );
memcpy( userTag, LALoptarg, LALoptarg_len );
this_proc_param = this_proc_param->next = (ProcessParamsTable *)
calloc( 1, sizeof(ProcessParamsTable) );
snprintf( this_proc_param->program, LIGOMETA_PROGRAM_MAX, "%s",
PROGRAM_NAME );
snprintf( this_proc_param->param, LIGOMETA_PARAM_MAX, "-userTag" );
snprintf( this_proc_param->type, LIGOMETA_TYPE_MAX, "string" );
snprintf( this_proc_param->value, LIGOMETA_VALUE_MAX, "%s",
LALoptarg );
break;
case 'c':
if ( strlen( LALoptarg ) > LIGOMETA_COMMENT_MAX - 1 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"comment must be less than %d characters\n",
long_options[option_index].name, LIGOMETA_COMMENT_MAX );
exit( 1 );
}
else
{
snprintf( comment, LIGOMETA_COMMENT_MAX, "%s", LALoptarg);
}
break;
case 'V':
fprintf( stdout, "Single Ringdown Reader and Injection Analysis\n"
"Patrick Brady, Duncan Brown and Steve Fairhurst\n");
XLALOutputVersionString(stderr, 0);
exit( 0 );
break;
case 'g':
/* create storage for the input file glob */
LALoptarg_len = strlen( LALoptarg ) + 1;
inputGlob = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR));
memcpy( inputGlob, LALoptarg, LALoptarg_len );
ADD_PROCESS_PARAM( "string", "'%s'", LALoptarg );
break;
case 'i':
/* create storage for the input file name */
LALoptarg_len = strlen( LALoptarg ) + 1;
inputFileName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR));
memcpy( inputFileName, LALoptarg, LALoptarg_len );
ADD_PROCESS_PARAM( "string", "%s", LALoptarg );
break;
case 'o':
/* create storage for the output file name */
LALoptarg_len = strlen( LALoptarg ) + 1;
outputFileName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR));
memcpy( outputFileName, LALoptarg, LALoptarg_len );
ADD_PROCESS_PARAM( "string", "%s", LALoptarg );
break;
case 'j':
/* create storage of the TAMA file name */
LALoptarg_len = strlen( LALoptarg ) + 1;
tamaFileName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR));
memcpy( tamaFileName, LALoptarg, LALoptarg_len );
ADD_PROCESS_PARAM( "string", "%s", LALoptarg );
break;
case 'S':
/* create storage for the summ file name */
LALoptarg_len = strlen( LALoptarg ) + 1;
summFileName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR));
memcpy( summFileName, LALoptarg, LALoptarg_len );
ADD_PROCESS_PARAM( "string", "%s", LALoptarg );
break;
case 's':
snrStar = (REAL4) atof( LALoptarg );
if ( snrStar < 0 )
{
fprintf( stdout, "invalid argument to --%s:\n"
"threshold must be >= 0: "
"(%f specified)\n",
long_options[option_index].name, snrStar );
exit( 1 );
}
ADD_PROCESS_PARAM( "float", "%e", snrStar );
break;
case 'k':
/* type of data to analyze */
if ( ! strcmp( "playground_only", LALoptarg ) )
{
dataType = playground_only;
}
else if ( ! strcmp( "exclude_play", LALoptarg ) )
{
dataType = exclude_play;
}
else if ( ! strcmp( "all_data", LALoptarg ) )
{
dataType = all_data;
}
else
{
fprintf( stderr, "invalid argument to --%s:\n"
"unknown data type, %s, specified: "
"(must be playground_only, exclude_play or all_data)\n",
long_options[option_index].name, LALoptarg );
exit( 1 );
}
ADD_PROCESS_PARAM( "string", "%s", LALoptarg );
break;
case 'C':
/* choose the clustering algorithm */
{
if ( ! strcmp( "snr_and_chisq", LALoptarg ) )
{
clusterchoice = snr_and_chisq;
}
else if ( ! strcmp( "snrsq_over_chisq", LALoptarg) )
{
clusterchoice = snrsq_over_chisq;
}
else if ( ! strcmp( "snr", LALoptarg) )
{
clusterchoice = snr;
}
else
{
fprintf( stderr, "invalid argument to --%s:\n"
"unknown clustering specified:\n "
"%s (must be one of: snr_and_chisq, \n"
" snrsq_over_chisq or snr)\n",
long_options[option_index].name, LALoptarg);
exit( 1 );
}
ADD_PROCESS_PARAM( "string", "%s", LALoptarg );
}
break;
case 't':
/* cluster time is specified on command line in ms */
cluster_dt = (INT8) atoi( LALoptarg );
if ( cluster_dt <= 0 )
{
fprintf( stdout, "invalid argument to --%s:\n"
"custer window must be > 0: "
"(%" LAL_INT8_FORMAT " specified)\n",
long_options[option_index].name, cluster_dt );
exit( 1 );
}
ADD_PROCESS_PARAM( "int", "%" LAL_INT8_FORMAT "", cluster_dt );
/* convert cluster time from ms to ns */
cluster_dt *= LAL_INT8_C(1000000);
break;
case 'I':
/* create storage for the injection file name */
LALoptarg_len = strlen( LALoptarg ) + 1;
injectFileName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR));
memcpy( injectFileName, LALoptarg, LALoptarg_len );
ADD_PROCESS_PARAM( "string", "%s", LALoptarg );
break;
case 'd':
LALoptarg_len = strlen( LALoptarg ) + 1;
ifoName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR));
memcpy( ifoName, LALoptarg, LALoptarg_len );
ADD_PROCESS_PARAM( "string", "%s", LALoptarg );
break;
case 'T':
/* injection coincidence time is specified on command line in ms */
inject_dt = (INT8) atoi( LALoptarg );
if ( inject_dt < 0 )
{
fprintf( stdout, "invalid argument to --%s:\n"
"injection coincidence window must be >= 0: "
"(%" LAL_INT8_FORMAT " specified)\n",
long_options[option_index].name, inject_dt );
exit( 1 );
}
ADD_PROCESS_PARAM( "int", "%" LAL_INT8_FORMAT " ", inject_dt );
/* convert inject time from ms to ns */
inject_dt *= LAL_INT8_C(1000000);
break;
case 'm':
/* create storage for the missed injection file name */
LALoptarg_len = strlen( LALoptarg ) + 1;
missedFileName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR));
memcpy( missedFileName, LALoptarg, LALoptarg_len );
ADD_PROCESS_PARAM( "string", "%s", LALoptarg );
break;
case 'H':
hardware = (INT4) atoi( LALoptarg );
if ( hardware <= 0 )
{
fprintf( stdout, "invalid argument to --%s:\n"
"GPS start time of hardware injections must be > 0: "
"(%d specified)\n",
long_options[option_index].name, hardware );
exit( 1 );
}
ADD_PROCESS_PARAM( "int", "%" LAL_INT4_FORMAT " ", hardware );
break;
case 'D':
enableTrigStartTime = 0;
ADD_PROCESS_PARAM( "string", "%s", " " );
break;
case '?':
exit( 1 );
break;
default:
fprintf( stderr, "unknown error while parsing options\n" );
exit( 1 );
}
}
if ( LALoptind < argc )
{
fprintf( stderr, "extraneous command line arguments:\n" );
while ( LALoptind < argc )
{
fprintf ( stderr, "%s\n", argv[LALoptind++] );
}
exit( 1 );
}
/*
*
* can use LALCalloc() / LALMalloc() from here
*
*/
/* don't buffer stdout if we are in verbose mode */
if ( vrbflg ) setvbuf( stdout, NULL, _IONBF, 0 );
/* fill the comment, if a user has specified it, or leave it blank */
if ( ! *comment )
{
snprintf( proctable.processTable->comment, LIGOMETA_COMMENT_MAX, " " );
}
else
{
snprintf( proctable.processTable->comment, LIGOMETA_COMMENT_MAX,
"%s", comment );
}
/* check that the input and output file names have been specified */
if ( (! inputGlob && ! inputFileName) || (inputGlob && inputFileName) )
{
fprintf( stderr, "exactly one of --glob or --input must be specified\n" );
exit( 1 );
}
if ( ! outputFileName )
{
fprintf( stderr, "--output must be specified\n" );
exit( 1 );
}
/* check that Data Type has been specified */
if ( dataType == unspecified_data_type )
{
fprintf( stderr, "Error: --data-type must be specified\n");
exit(1);
}
/* check that if clustering is being done that we have all the options */
if ( clusterchoice && cluster_dt < 0 )
{
fprintf( stderr, "--cluster-time must be specified if --cluster-algorithm "
"is given\n" );
exit( 1 );
}
else if ( ! clusterchoice && cluster_dt >= 0 )
{
fprintf( stderr, "--cluster-algorithm must be specified if --cluster-time "
"is given\n" );
exit( 1 );
}
/* check that we have all the options to do injections */
if ( injectFileName && inject_dt < 0 )
{
fprintf( stderr, "--injection-coincidence must be specified if "
"--injection-file is given\n" );
exit( 1 );
}
else if ( ! injectFileName && inject_dt >= 0 )
{
fprintf( stderr, "--injection-file must be specified if "
"--injection-coincidence is given\n" );
exit( 1 );
}
/* save the sort triggers flag */
if ( sortTriggers )
{
this_proc_param = this_proc_param->next = (ProcessParamsTable *)
calloc( 1, sizeof(ProcessParamsTable) );
snprintf( this_proc_param->program, LIGOMETA_PROGRAM_MAX, "%s",
PROGRAM_NAME );
snprintf( this_proc_param->param, LIGOMETA_PARAM_MAX,
"--sort-triggers" );
snprintf( this_proc_param->type, LIGOMETA_TYPE_MAX, "string" );
snprintf( this_proc_param->value, LIGOMETA_VALUE_MAX, " " );
}
switch ( dataType )
{
case playground_only:
if ( vrbflg )
fprintf( stdout, "using data from playground times only\n" );
snprintf( procparams.processParamsTable->program,
LIGOMETA_PROGRAM_MAX, "%s", PROGRAM_NAME );
snprintf( procparams.processParamsTable->param,
LIGOMETA_PARAM_MAX, "--playground-only" );
snprintf( procparams.processParamsTable->type,
LIGOMETA_TYPE_MAX, "string" );
snprintf( procparams.processParamsTable->value,
LIGOMETA_TYPE_MAX, " " );
break;
case exclude_play:
if ( vrbflg )
fprintf( stdout, "excluding all triggers in playground times\n" );
snprintf( procparams.processParamsTable->program,
LIGOMETA_PROGRAM_MAX, "%s", PROGRAM_NAME );
snprintf( procparams.processParamsTable->param,
LIGOMETA_PARAM_MAX, "--exclude-play" );
snprintf( procparams.processParamsTable->type,
LIGOMETA_TYPE_MAX, "string" );
snprintf( procparams.processParamsTable->value,
LIGOMETA_TYPE_MAX, " " );
break;
case all_data:
if ( vrbflg )
fprintf( stdout, "using all input data\n" );
snprintf( procparams.processParamsTable->program,
LIGOMETA_PROGRAM_MAX, "%s", PROGRAM_NAME );
snprintf( procparams.processParamsTable->param,
LIGOMETA_PARAM_MAX, "--all-data" );
snprintf( procparams.processParamsTable->type,
LIGOMETA_TYPE_MAX, "string" );
snprintf( procparams.processParamsTable->value,
LIGOMETA_TYPE_MAX, " " );
break;
default:
fprintf( stderr, "data set not defined\n" );
exit( 1 );
}
/*
*
* read in the injection XML file, if we are doing an injection analysis
*
*/
if ( injectFileName )
{
if ( vrbflg )
fprintf( stdout, "reading injections from %s... ", injectFileName );
simEventHead = XLALSimRingdownTableFromLIGOLw( injectFileName, 0, 0 );
if ( vrbflg ) fprintf( stdout, "got %d injections\n", numSimEvents );
if ( ! simEventHead )
{
fprintf( stderr, "error: unable to read sim_ringdown table from %s\n",
injectFileName );
exit( 1 );
}
/* if we are doing hardware injections, increment all the start times */
if ( hardware )
{
if ( vrbflg ) fprintf( stdout,
"incrementing GPS times of injections by %d seconds\n", hardware );
for ( thisSimEvent = simEventHead;
thisSimEvent; thisSimEvent = thisSimEvent->next )
{
thisSimEvent->geocent_start_time.gpsSeconds += hardware;
thisSimEvent->h_start_time.gpsSeconds += hardware;
thisSimEvent->l_start_time.gpsSeconds += hardware;
}
}
/* discard all injection events that are not in the data we want */
if ( dataType != all_data )
{
numSimDiscard = 0;
thisSimEvent = simEventHead;
simEventHead = NULL;
prevSimEvent = NULL;
if ( vrbflg ) fprintf( stdout, "discarding injections not in data\n" );
while ( thisSimEvent )
{
INT4 isPlayground = XLALINT8NanoSecIsPlayground(XLALGPSToINT8NS(&(thisSimEvent->geocent_start_time)));
if ( (dataType == playground_only && isPlayground) ||
(dataType == exclude_play && ! isPlayground) )
{
/* store the head of the linked list */
if ( ! simEventHead ) simEventHead = thisSimEvent;
/* keep this event */
prevSimEvent = thisSimEvent;
thisSimEvent = thisSimEvent->next;
++numSimInData;
if ( vrbflg ) fprintf( stdout, "+" );
}
else
{
/* throw this event away */
tmpSimEvent = thisSimEvent;
if ( prevSimEvent ) prevSimEvent->next = thisSimEvent->next;
thisSimEvent = thisSimEvent->next;
LALFree( tmpSimEvent );
++numSimDiscard;
if ( vrbflg ) fprintf( stdout, "-" );
}
}
if ( vrbflg )
fprintf( stdout, "\nusing %d (discarded %d) of %d injections\n",
numSimInData, numSimDiscard, numSimEvents );
}
else
{
if ( vrbflg )
fprintf( stdout, "using all %d injections\n", numSimInData );
numSimInData = numSimEvents;
}
}
/*
*
* read in the input triggers from the xml files
*
*/
if ( inputGlob )
{
/* use glob() to get a list of the input file names */
if ( glob( inputGlob, GLOB_ERR, NULL, &globbedFiles ) )
{
fprintf( stderr, "error globbing files from %s\n", inputGlob );
perror( "error:" );
exit( 1 );
}
numInFiles = globbedFiles.gl_pathc;
inFileNameList = (char **) LALCalloc( numInFiles, sizeof(char *) );
for ( j = 0; j < numInFiles; ++j )
{
inFileNameList[j] = globbedFiles.gl_pathv[j];
}
}
else if ( inputFileName )
{
/* read the list of input filenames from a file */
fp = fopen( inputFileName, "r" );
if ( ! fp )
{
fprintf( stderr, "could not open file containing list of xml files\n" );
perror( "error:" );
exit( 1 );
}
/* count the number of lines in the file */
while ( get_next_line( line, sizeof(line), fp ) )
{
++numInFiles;
}
rewind( fp );
/* allocate memory to store the input file names */
inFileNameList = (char **) LALCalloc( numInFiles, sizeof(char *) );
/* read in the input file names */
for ( j = 0; j < numInFiles; ++j )
{
inFileNameList[j] = (char *) LALCalloc( MAX_PATH, sizeof(char) );
get_next_line( line, sizeof(line), fp );
strncpy( inFileNameList[j], line, strlen(line) - 1);
}
fclose( fp );
}
else
{
fprintf( stderr, "no input file mechanism specified\n" );
exit( 1 );
}
if ( vrbflg )
{
fprintf( stdout, "reading input triggers from:\n" );
for ( j = 0; j < numInFiles; ++j )
{
fprintf( stdout, "%s\n", inFileNameList[j] );
}
}
/*
*
* read in the triggers from the input xml files
*
*/
if ( injectFileName )
{
thisSimEvent = simEventHead;
simEventHead = NULL;
prevSimEvent = NULL;
numSimDiscard = 0;
numSimInData = 0;
if ( vrbflg )
fprintf( stdout, "discarding injections not in input data\n" );
}
for ( j = 0; j < numInFiles; ++j )
{
LIGOTimeGPS inPlay, outPlay;
UINT8 outPlayNS, outStartNS, outEndNS, triggerTimeNS;
INT4 trigStartTimeArg = 0;
searchSummaryTable = XLALSearchSummaryTableFromLIGOLw( inFileNameList[j] );
if ( ( ! searchSummaryTable ) || searchSummaryTable->next )
{
fprintf( stderr,
"error: zero or multiple search_summary tables in %s\n",
inFileNameList[j] );
exit( 1 );
}
if ( enableTrigStartTime )
{
/* override the value of out_start_time if there is a non-zero */
/* --trig-start-time option in the process_params table */
/* this is necessary to get round a bug in early versions of */
/* the ringdown code */
int mioStatus;
int pParParam;
int pParValue;
struct MetaioParseEnvironment parseEnv;
const MetaioParseEnv env = &parseEnv;
/* open the procress_params table from the input file */
mioStatus = MetaioOpenTable( env, inFileNameList[j], "process_params" );
if ( mioStatus )
{
fprintf( stderr, "error opening process_params table from file %s\n",
inFileNameList[j] );
exit( 1 );
}
/* figure out where the param and value columns are */
if ( (pParParam = MetaioFindColumn( env, "param" )) < 0 )
{
fprintf( stderr, "unable to find column param in process_params\n" );
MetaioClose(env);
exit( 1 );
}
if ( (pParValue = MetaioFindColumn( env, "value" )) < 0 )
{
fprintf( stderr, "unable to find column value in process_params\n" );
MetaioClose(env);
exit( 1 );
}
/* get the trigger start time from the process params */
while ( (mioStatus = MetaioGetRow(env)) == 1 )
{
if ( ! strcmp( env->ligo_lw.table.elt[pParParam].data.lstring.data,
"--trig-start-time" ) )
{
trigStartTimeArg = (INT4)
atoi( env->ligo_lw.table.elt[pParValue].data.lstring.data );
}
}
MetaioClose( env );
if ( trigStartTimeArg )
{
searchSummaryTable->out_start_time.gpsSeconds = trigStartTimeArg;
searchSummaryTable->out_start_time.gpsNanoSeconds = 0;
if ( vrbflg ) fprintf( stdout, "file %s has --trig-start-time %d\n",
inFileNameList[j], trigStartTimeArg );
}
}
/* compute the out time from the search summary table */
outStartNS = XLALGPSToINT8NS ( &(searchSummaryTable->out_start_time) );
outEndNS = XLALGPSToINT8NS ( &(searchSummaryTable->out_end_time) );
triggerTimeNS = outEndNS - outStartNS;
/* check for events and playground */
if ( dataType != all_data )
{
LAL_CALL( LALPlaygroundInSearchSummary( &status, searchSummaryTable,
&inPlay, &outPlay ), &status );
outPlayNS = XLALGPSToINT8NS ( &outPlay );
if ( dataType == playground_only )
{
if ( outPlayNS )
{
/* increment the total trigger time by the amount of playground */
triggerInputTimeNS += outPlayNS;
}
else
{
/* skip this file as it does not contain any playground data */
if ( vrbflg )
{
fprintf( stdout, "file %s not in playground, continuing\n",
inFileNameList[j] );
}
LALFree( searchSummaryTable );
searchSummaryTable = NULL;
continue;
}
}
else if ( dataType == exclude_play )
{
/* increment the total trigger time by the out time minus */
/* the time that is in the playground */
triggerInputTimeNS += triggerTimeNS - outPlayNS;
}
}
else
{
/* increment the total trigger time by the out time minus */
triggerInputTimeNS += triggerTimeNS;
}
if ( injectFileName )
{
if ( vrbflg ) fprintf( stdout, "discarding injections not in file: " );
/* throw away injections that are outside analyzed times */
while ( thisSimEvent && thisSimEvent->geocent_start_time.gpsSeconds <
searchSummaryTable->out_end_time.gpsSeconds )
{
/* check if injection is before file start time */
if ( thisSimEvent->geocent_start_time.gpsSeconds <
searchSummaryTable->out_start_time.gpsSeconds )
{
/* discard the current injection */
if ( prevSimEvent ) prevSimEvent->next = thisSimEvent->next;
tmpSimEvent = thisSimEvent;
thisSimEvent = thisSimEvent->next;
LALFree( tmpSimEvent );
++numSimDiscard;
if ( vrbflg ) fprintf( stdout, "-" );
}
else
{
/* store the head of the linked list */
if ( ! simEventHead ) simEventHead = thisSimEvent;
/* keep this injection */
prevSimEvent = thisSimEvent;
thisSimEvent = thisSimEvent->next;
++numSimInData;
if ( vrbflg ) fprintf( stdout, "+" );
}
}
if ( vrbflg ) fprintf( stdout, "\n" );
}
/*
*
* if there are any events in the file, read them in
*
*/
if ( searchSummaryTable->nevents )
{
INT4 isPlay;
if ( vrbflg ) fprintf( stdout, "file %s contains %d events, processing\n",
inFileNameList[j], searchSummaryTable->nevents );
if ( ! prevEvent )
{
eventHandle = &thisEvent;
}
else
{
eventHandle = &(prevEvent->next);
}
/* read the events from the file into a temporary list */
XLAL_TRY( *eventHandle = XLALSnglRingdownTableFromLIGOLw( inFileNameList[j] ), errnum);
if ( ! *eventHandle )
switch ( errnum )
{
case XLAL_EDATA:
XLALPrintError("Unable to read sngl_ringdown table from %s\n", inFileNameList[j] );
/*LALFree(thisInputFile);*/
XLALClearErrno();
break;
default:
XLALSetErrno( errnum );
XLAL_ERROR(XLAL_EFUNC );
}
/* only keep triggers from the data that we want to analyze */
thisEvent = *eventHandle;
while ( thisEvent )
{
numEvents++;
isPlay = XLALINT8NanoSecIsPlayground( XLALGPSToINT8NS( &(thisEvent->start_time) ) );
if ( (dataType == all_data ||
(dataType == playground_only && isPlay) ||
(dataType == exclude_play && ! isPlay))
&& ( snrStar < 0 || thisEvent->snr > snrStar) )
{
/* keep the trigger and increment the count of triggers */
if ( ! eventHead ) eventHead = thisEvent;
prevEvent = thisEvent;
thisEvent = thisEvent->next;
++numEventsKept;
}
else
{
/* discard the trigger and move to the next one */
if ( prevEvent ) prevEvent->next = thisEvent->next;
tmpEvent = thisEvent;
thisEvent = thisEvent->next;
LAL_CALL ( LALFreeSnglRingdown ( &status, &tmpEvent ), &status);
}
}
/* make sure that the linked list is properly terminated */
if ( prevEvent && prevEvent->next ) prevEvent->next->next = NULL;
}
else
{
if ( vrbflg ) fprintf( stdout, "file %s contains no events, skipping\n",
inFileNameList[j] );
}
LALFree( searchSummaryTable );
searchSummaryTable = NULL;
}
/* discard the remaining injections which occured after the last file */
if ( injectFileName )
{
if ( vrbflg ) fprintf( stdout, "kept %d injections, discarded %d\n",
numSimInData, numSimDiscard );
if ( prevSimEvent ) prevSimEvent->next = NULL;
numSimDiscard = 0;
while ( thisSimEvent )
{
tmpSimEvent = thisSimEvent;
thisSimEvent = thisSimEvent->next;
LALFree( tmpSimEvent );
++numSimDiscard;
if ( vrbflg ) fprintf( stdout, "-" );
}
if ( vrbflg ) fprintf( stdout, "\ndiscarded %d injections at end of list\n",
numSimDiscard );
}
/*
*
* sort the ringdown events by time
*
*/
if ( injectFileName || sortTriggers )
{
if ( vrbflg ) fprintf( stdout, "sorting ringdown trigger list..." );
LAL_CALL( LALSortSnglRingdown( &status, &eventHead,
*LALCompareSnglRingdownByTime ), &status );
if ( vrbflg ) fprintf( stdout, "done\n" );
}
/*
*
* keep only event from requested ifo
*
*/
if ( ifoName )
{
if ( vrbflg ) fprintf( stdout,
"keeping only triggers from %s, discarding others...", ifoName );
LAL_CALL( LALIfoCutSingleRingdown( &status, &eventHead, ifoName ), &status );
LALIfoCountSingleRingdown( &status, &numEventsInIFO, eventHead,
XLALIFONumber(ifoName) );
if ( vrbflg ) fprintf( stdout, "done\n" );
}
/*
*
* check for events that are coincident with injections
*
*/
if ( injectFileName )
{
int coincidence = 0;
UINT8 simTime, ringdownTime;
if ( vrbflg ) fprintf( stdout,
"checking for events that are coincident with injections\n" );
/* Note: we are assuming that both the ringdown and */
/* injection events are time sorted */
thisSimEvent = simEventHead;
thisEvent = eventHead;
simEventHead = NULL;
eventHead = NULL;
prevSimEvent = NULL;
prevEvent = NULL;
numSimFound = 0;
numSimDiscard = 0;
numEventsDiscard = 0;
numEventsCoinc = 0;
if ( ! thisEvent )
{
/* no triggers in the input data, so all injections are missed */
if ( vrbflg ) fprintf( stdout, "no triggers in input data\n" );
thisMissedSim = missedSimHead = thisSimEvent;
while ( thisMissedSim )
{
/* count the number of injections just stuck in the missed list */
if ( vrbflg ) fprintf( stdout, "M" );
++numSimMissed;
++numSimProcessed;
thisMissedSim = thisMissedSim->next;
}
}
else
{
/* begin loop over the sim_ringdown events */
while ( thisSimEvent )
{
/* compute the end time in nanosec for the injection */
/* at the relevant detector */
if ( ! strcmp( "L1", thisEvent->ifo ) )
{
simTime = XLALGPSToINT8NS ( &(thisSimEvent->l_start_time) );
}
else if ( ! strcmp( "H1", thisEvent->ifo ) ||
! strcmp( "H2", thisEvent->ifo ) )
{
simTime = XLALGPSToINT8NS ( &(thisSimEvent->h_start_time) );
}
else
{
fprintf( stderr, "unknown detector found in event list: %s\n",
thisEvent->ifo );
fprintf( stderr, "Detector must be one of (G1|H1|H2|L1|T1|V1)\n");
exit( 1 );
}
/* find the first ringdown event after the current sim event */
while ( thisEvent )
{
coincidence = 0;
/* compute the time in nanosec for the ringdown */
ringdownTime = XLALGPSToINT8NS ( &(thisEvent->start_time) );
if ( ringdownTime < (simTime - inject_dt) )
{
/* discard this event and move on to the next one */
if ( prevEvent ) prevEvent->next = thisEvent->next;
tmpEvent = thisEvent;
thisEvent = thisEvent->next;
LAL_CALL ( LALFreeSnglRingdown ( &status, &tmpEvent ), &status);
++numEventsProcessed;
++numEventsDiscard;
if ( vrbflg ) fprintf( stdout, "-" );
}
else
{
/* we have reached the negative coincincidence window */
break;
}
}
while ( thisEvent )
{
/* compute the time in nanosec for the ringdown */
ringdownTime = XLALGPSToINT8NS ( &(thisEvent->start_time) );
if ( ringdownTime < (simTime + inject_dt) )
{
/* this event is within the coincidence window */
/* store this event and move on to the next one */
if ( ! eventHead ) eventHead = thisEvent;
prevEvent = thisEvent;
thisEvent = thisEvent->next;
coincidence = 1;
++numEventsProcessed;
++numEventsCoinc;
if ( vrbflg ) fprintf( stdout, "+" );
}
else
{
/* we have reached the end of the positive coincincidence window */
break;
}
}
if ( coincidence )
{
/* keep this event in the list and move to the next sim event */
if ( ! simEventHead ) simEventHead = thisSimEvent;
prevSimEvent = thisSimEvent;
++numSimFound;
++numSimProcessed;
thisSimEvent = thisSimEvent->next;
if ( vrbflg ) fprintf( stdout, "F" );
}
else
{
/* save this sim event in the list of missed events... */
if ( ! missedSimHead )
{
missedSimHead = thisMissedSim = thisSimEvent;
}
else
{
thisMissedSim = thisMissedSim->next = thisSimEvent;
}
/* ...and remove it from the list of found events */
if ( prevSimEvent ) prevSimEvent->next = thisSimEvent->next;
++numSimMissed;
if ( vrbflg ) fprintf( stdout, "M" );
/* move to the next sim in the list */
++numSimProcessed;
thisSimEvent = thisSimEvent->next;
/* make sure the missed sim list is terminated */
thisMissedSim->next = NULL;
}
if ( ! thisEvent )
{
/* these are no more events to process so all the rest of the */
/* injections must be put in the missed injections list */
if ( ! missedSimHead )
{
/* this and any subsequent events are in the missed sim list */
if ( thisSimEvent ) thisMissedSim = missedSimHead = thisSimEvent;
}
else
{
if ( thisSimEvent )
{
/* append the rest of the list to the list of missed injections */
thisMissedSim = thisMissedSim->next = thisSimEvent;
}
else
{
/* there are no injections after this one */
thisMissedSim = thisMissedSim->next = NULL;
}
}
/* terminate the list of found injections correctly */
if ( prevSimEvent ) prevSimEvent->next = NULL;
while ( thisMissedSim )
{
/* count the number of injections just stuck in the missed list */
if ( vrbflg ) fprintf( stdout, "M" );
++numSimMissed;
++numSimProcessed;
thisMissedSim = thisMissedSim->next;
}
thisSimEvent = NULL;
break;
}
}
if ( thisEvent )
{
/* discard any remaining ringdown triggers -- including thisEvent */
/* as we have run out of injections */
tmpEvent = thisEvent;
if ( prevEvent ) prevEvent->next = NULL;
while ( tmpEvent )
{
thisEvent = tmpEvent;
tmpEvent = tmpEvent->next;
LAL_CALL ( LALFreeSnglRingdown ( &status, &thisEvent ), &status);
++numEventsDiscard;
++numEventsProcessed;
if ( vrbflg ) fprintf( stdout, "-" );
}
}
}
if ( vrbflg )
{
fprintf( stdout, "\nfound %d injections, missed %d injections "
"(%d injections processed)\n",
numSimFound, numSimMissed, numSimProcessed );
fprintf( stdout, "found %d coincident events, %d events discarded "
"(%d events processed)\n",
numEventsCoinc, numEventsDiscard, numEventsProcessed );
}
} /* end if ( injectFileName ) */
/*
*
* cluster the remaining events
*
*/
if ( eventHead && clusterchoice )
{
if ( vrbflg ) fprintf( stdout, "clustering remaining triggers... " );
LAL_CALL( LALClusterSnglRingdownTable( &status, eventHead,
cluster_dt, clusterchoice ), &status );
if ( vrbflg ) fprintf( stdout, "done\n" );
/* count the number of triggers surviving the clustering */
thisEvent = eventHead;
numClusteredEvents = 0;
while ( thisEvent )
{
++numClusteredEvents;
thisEvent = thisEvent->next;
}
}
/*
*
* write output data
*
*/
/* write the main output file containing found injections */
if ( vrbflg ) fprintf( stdout, "writing output xml files... " );
memset( &xmlStream, 0, sizeof(LIGOLwXMLStream) );
LAL_CALL( LALOpenLIGOLwXMLFile( &status, &xmlStream, outputFileName ), &status );
/* write out the process and process params tables */
if ( vrbflg ) fprintf( stdout, "process... " );
XLALGPSTimeNow(&(proctable.processTable->start_time));
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, process_table ),
&status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, proctable,
process_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream ), &status );
free( proctable.processTable );
/* write the process params table */
if ( vrbflg ) fprintf( stdout, "process_params... " );
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream,
process_params_table ), &status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, procparams,
process_params_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream ), &status );
/* Write the found injections to the sim table */
if ( simEventHead )
{
if ( vrbflg ) fprintf( stdout, "sim_ringdown... " );
outputTable.simRingdownTable = simEventHead;
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream,
sim_ringdown_table ), &status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, outputTable,
sim_ringdown_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable( &status, &xmlStream ), &status );
}
/* Write the results to the ringdown table */
if ( eventHead )
{
if ( vrbflg ) fprintf( stdout, "sngl_ringdown... " );
outputTable.snglRingdownTable = eventHead;
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream,
sngl_ringdown_table ), &status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, outputTable,
sngl_ringdown_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable( &status, &xmlStream ), &status);
}
/* close the output file */
LAL_CALL( LALCloseLIGOLwXMLFile(&status, &xmlStream), &status);
if ( vrbflg ) fprintf( stdout, "done\n" );
/* write out the TAMA file if it is requested */
if ( tamaFileName )
{
/* FIXME */
REAL8 UNUSED trigtime;
fp = fopen( tamaFileName, "w" );
if ( ! fp )
{
perror( "TAMA file" );
exit( 1 );
}
fprintf( fp, "IFO trigger time snr chisq "
" total mass eta eff dist (kpc)\n" );
for ( thisEvent = eventHead; thisEvent; thisEvent = thisEvent->next )
{
trigtime = XLALGPSGetREAL8(&(thisEvent->start_time));
}
fclose( fp );
}
if ( missedFileName )
{
/* open the missed injections file and write the missed injections to it */
if ( vrbflg ) fprintf( stdout, "writing missed injections... " );
memset( &xmlStream, 0, sizeof(LIGOLwXMLStream) );
LAL_CALL( LALOpenLIGOLwXMLFile( &status, &xmlStream, missedFileName ),
&status );
if ( missedSimHead )
{
outputTable.simRingdownTable = missedSimHead;
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, sim_ringdown_table ),
&status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, outputTable,
sim_ringdown_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable( &status, &xmlStream ), &status );
}
LAL_CALL( LALCloseLIGOLwXMLFile( &status, &xmlStream ), &status );
if ( vrbflg ) fprintf( stdout, "done\n" );
}
if ( summFileName )
{
LIGOTimeGPS triggerTime;
/* write out a summary file */
fp = fopen( summFileName, "w" );
switch ( dataType )
{
case playground_only:
fprintf( fp, "using data from playground times only\n" );
break;
case exclude_play:
fprintf( fp, "excluding all triggers in playground times\n" );
break;
case all_data:
fprintf( fp, "using all input data\n" );
break;
default:
fprintf( stderr, "data set not defined\n" );
exit( 1 );
}
fprintf( fp, "read triggers from %d files\n", numInFiles );
fprintf( fp, "number of triggers in input files: %d \n", numEvents );
if ( snrStar >= 0 )
{
fprintf( fp, "number of triggers in input data with snr above %f: %d \n",
snrStar, numEventsKept );
}
else
{
fprintf( fp, "number of triggers in input data %d \n", numEventsKept );
}
if ( ifoName )
{
fprintf( fp, "number of triggers from %s ifo %d \n", ifoName,
numEventsInIFO );
}
XLALINT8NSToGPS( &triggerTime, triggerInputTimeNS );
fprintf( fp, "amount of time analysed for triggers %d sec %d ns\n",
triggerTime.gpsSeconds, triggerTime.gpsNanoSeconds );
if ( injectFileName )
{
fprintf( fp, "read %d injections from file %s\n",
numSimEvents, injectFileName );
fprintf( fp, "number of injections in input data: %d\n", numSimInData );
fprintf( fp, "number of injections found in input data: %d\n",
numSimFound );
fprintf( fp,
"number of triggers found within %" LAL_INT8_FORMAT "msec of injection: %d\n",
(inject_dt / LAL_INT8_C(1000000) ), numEventsCoinc );
fprintf( fp, "efficiency: %f \n",
(REAL4) numSimFound / (REAL4) numSimInData );
}
if ( clusterchoice )
{
fprintf( fp, "number of event clusters with %" LAL_INT8_FORMAT " msec window: %d\n",
cluster_dt/ LAL_INT8_C(1000000), numClusteredEvents );
}
fclose( fp );
}
/*
*
* free memory and exit
*
*/
/* free the ringdown events we saved */
while ( eventHead )
{
thisEvent = eventHead;
eventHead = eventHead->next;
LAL_CALL ( LALFreeSnglRingdown ( &status, &thisEvent ), &status);
}
/* free the process params */
while( procparams.processParamsTable )
{
this_proc_param = procparams.processParamsTable;
procparams.processParamsTable = this_proc_param->next;
free( this_proc_param );
}
/* free the found injections */
while ( simEventHead )
{
thisSimEvent = simEventHead;
simEventHead = simEventHead->next;
LALFree( thisSimEvent );
}
/* free the temporary memory containing the missed injections */
while ( missedSimHead )
{
tmpSimEvent = missedSimHead;
missedSimHead = missedSimHead->next;
LALFree( tmpSimEvent );
}
/* free the input file name data */
if ( inputGlob )
{
LALFree( inFileNameList );
globfree( &globbedFiles );
}
else
{
for ( j = 0; j < numInFiles; ++j )
{
LALFree( inFileNameList[j] );
}
LALFree( inFileNameList );
}
if ( vrbflg ) fprintf( stdout, "checking memory leaks and exiting\n" );
LALCheckMemoryLeaks();
exit( 0 );
}
void
LALInspiralEccentricityEngine(
LALStatus *status,
REAL4Vector *signalvec1,
REAL4Vector *signalvec2,
REAL4Vector *a,
REAL4Vector UNUSED *ff,
REAL8Vector UNUSED *phi,
INT4 *countback,
InspiralTemplate *params)
{
INT4 number_of_diff_equations = 3;
INT4 count = 0;
ecc_CBC_ODE_Input in3;
REAL8 phase;
REAL8 orbital_element_p,orbital_element_e_squared;
REAL8 orbital_element_e;
REAL8 twoPhim2Beta = 0;
REAL8 threePhim2Beta = 0;
REAL8 phim2Beta = 0;
REAL8 twoBeta;
REAL8 rbyM=1e6, rbyMFlso=6.;
REAL8 sin2Beta,cos2Beta,iota,onepCosSqI, SinSqI, cosI, e0, f_min, beta, p0;
REAL8 amp, m, dt, t, h1, h2, f, fHigh, piM, fu;
REAL8Vector dummy, values, dvalues, valuesNew, yt, dym, dyt;
INT4 done=0;
rk4In in4;
rk4GSLIntegrator *integrator;
void *funcParams;
expnCoeffs ak;
expnFunc func;
#if 0
REAL8 mTot = 0;
REAL8 unitHz = 0;
REAL8 f2a = 0;
REAL8 mu = 0;
REAL8 etab = 0;
REAL8 fFac = 0; /* SI normalization for f and t */
REAL8 f2aFac = 0;/* factor multiplying f in amplitude function */
REAL8 apFac = 0, acFac = 0;/* extra factor in plus and cross amplitudes */
#endif
INITSTATUS(status);
ATTATCHSTATUSPTR(status);
ASSERT (params, status, LALINSPIRALH_ENULL, LALINSPIRALH_MSGENULL);
ASSERT (params->nStartPad >= 0, status, LALINSPIRALH_ESIZE, LALINSPIRALH_MSGESIZE);
ASSERT (params->nEndPad >= 0, status, LALINSPIRALH_ESIZE, LALINSPIRALH_MSGESIZE);
ASSERT (params->fLower > 0, status, LALINSPIRALH_ESIZE, LALINSPIRALH_MSGESIZE);
ASSERT (params->tSampling > 0, status, LALINSPIRALH_ESIZE, LALINSPIRALH_MSGESIZE);
LALInspiralSetup (status->statusPtr, &ak, params);
CHECKSTATUSPTR(status);
LALInspiralChooseModel(status->statusPtr, &func, &ak, params);
CHECKSTATUSPTR(status);
m = ak.totalmass = params->mass1+params->mass2;
values.length = dvalues.length = valuesNew.length =
yt.length = dym.length = dyt.length = number_of_diff_equations;
dummy.length = number_of_diff_equations * 6;
if (!(dummy.data = (REAL8 * ) LALMalloc(sizeof(REAL8) * number_of_diff_equations * 6))) {
ABORT(status, LALINSPIRALH_EMEM, LALINSPIRALH_MSGEMEM);
}
values.data = &dummy.data[0];
dvalues.data = &dummy.data[number_of_diff_equations];
valuesNew.data = &dummy.data[2*number_of_diff_equations];
yt.data = &dummy.data[3*number_of_diff_equations];
dym.data = &dummy.data[4*number_of_diff_equations];
dyt.data = &dummy.data[5*number_of_diff_equations];
/* m = ak.totalmass;*/
dt = 1./params->tSampling;
if (a)
{
/*to be implemented. */
/* mTot = params->mass1 + params->mass2;
etab = params->mass1 * params->mass2;
etab /= mTot;
etab /= mTot;
unitHz = mTot *LAL_MTSUN_SI*(REAL8)LAL_PI;
cosI = cos( params->inclination );
mu = etab * mTot;
fFac = 1.0 / ( 4.0*LAL_TWOPI*LAL_MTSUN_SI*mTot );
f2aFac = LAL_PI*LAL_MTSUN_SI*mTot*fFac;
apFac = acFac = -2.0 * mu * LAL_MRSUN_SI/params->distance;
apFac *= 1.0 + cosI*cosI;
acFac *= 2.0*cosI;
params->nStartPad = 0;
*/
}
ASSERT(ak.totalmass > 0, status, LALINSPIRALH_ESIZE, LALINSPIRALH_MSGESIZE);
t = 0.0;
in3.totalMass = (params->mass1 + params->mass2) * LAL_MTSUN_SI ;
in3.eta = (params->mass1 * params->mass2) /(params->mass1 + params->mass2) / (params->mass1 + params->mass2);
funcParams = (void *) &in3;
piM = LAL_PI * m * LAL_MTSUN_SI;
/* f = (v*v*v)/piM;
fu = params->fCutoff;
if (fu)
fHigh = (fu < ak.flso) ? fu : ak.flso;
else
fHigh = ak.flso;
f = (v*v*v)/(LAL_PI*m);
ASSERT(fHigh < 0.5/dt, status, LALINSPIRALH_ESIZE, LALINSPIRALH_MSGESIZE);
ASSERT(fHigh > params->fLower, status, LALINSPIRALH_ESIZE, LALINSPIRALH_MSGESIZE);
*/
/* e0 is set at f_min */
e0 = params->eccentricity;
/* the second harmonic will start at fLower*2/3 */
f_min = params->fLower;
iota = params->inclination; /*overwritten later */
beta = 0.;
twoBeta = 2.* beta;
cos2Beta = cos(twoBeta);
sin2Beta = sin(twoBeta);
iota = LAL_PI/4.;
onepCosSqI = 1. + cos(iota) * cos(iota);
SinSqI = sin(iota) * sin(iota);
cosI = cos(iota);
p0 = (1. - e0*e0)/pow(2. * LAL_PI * m * LAL_MTSUN_SI* f_min/3. , 2./3.);
*(values.data) = orbital_element_p = p0;
*(values.data+1) = phase = params->startPhase;
*(values.data+2) = orbital_element_e = e0;
in4.function = LALInspiralEccentricityDerivatives;
in4.x = t;
in4.y = &values;
in4.h = dt;
in4.n = number_of_diff_equations;
in4.yt = &yt;
in4.dym = &dym;
in4.dyt = &dyt;
xlalErrno = 0;
/* Initialize GSL integrator */
if (!(integrator = XLALRungeKutta4Init(number_of_diff_equations, &in4)))
{
INT4 errNum = XLALClearErrno();
LALFree(dummy.data);
if (errNum == XLAL_ENOMEM)
ABORT(status, LALINSPIRALH_EMEM, LALINSPIRALH_MSGEMEM);
else
ABORTXLAL( status );
}
count = 0;
if (signalvec2) {
params->nStartPad = 0;} /* for template generation, that value must be zero*/
else if (signalvec1) {
count = params->nStartPad;
}
t = 0.0;
fu = params->fCutoff;
if (fu)
fHigh = (fu < ak.flso) ? fu : ak.flso;
else
fHigh = ak.flso;
f = 1./(pow(orbital_element_p, 3./2.))/piM;
/*fprintf(stderr, "fFinal = %f %f %f %f\n", fu,fHigh,f,ak.flso);*/
done = 0;
do {
/* Free up memory and abort if writing beyond the end of vector*/
/*if ((signalvec1 && (UINT4)count >= signalvec1->length) || (ff && (UINT4)count >= ff->length))*/
if ((signalvec1 && (UINT4)count >= signalvec1->length))
{
XLALRungeKutta4Free( integrator );
LALFree(dummy.data);
ABORT(status, LALINSPIRALH_EVECTOR, LALINSPIRALH_MSGEVECTOR);
}
/* Non-injection case */
if (signalvec1)
{
twoPhim2Beta = 2.* phase - twoBeta;
phim2Beta = phase - twoBeta;
threePhim2Beta = 3.* phase - twoBeta;
orbital_element_e_squared = orbital_element_e * orbital_element_e;
amp = params->signalAmplitude / orbital_element_p;
/* fprintf(stderr, "%e %e %e %e %e\n", twoBeta, twoPhim2Beta, phim2Beta, threePhim2Beta, orbital_element_e_squared);*/
h1 = amp * ( ( 2. * cos(twoPhim2Beta) + 2.5 * orbital_element_e * cos(phim2Beta)
+ 0.5 * orbital_element_e * cos(threePhim2Beta) + orbital_element_e_squared * cos2Beta) * onepCosSqI +
+ ( orbital_element_e * cos(orbital_element_p) + orbital_element_e_squared) * SinSqI);
if ((f >= params->fLower) && (done == 0))
{
/*fprintf(stderr, "freq=%e p=%e, e=%e, phase = %e\n", f,orbital_element_p, orbital_element_e, phase);fflush(stderr);
*/
params->alpha1 = orbital_element_e;
done = 1;
}
/*if (f>=params->fLower)*/
{
*(signalvec1->data + count) = (REAL4) h1;
}
if (signalvec2)
{
h2 = amp * ( ( 4. * sin(twoPhim2Beta) + 5 * orbital_element_e * sin(phim2Beta)
+ orbital_element_e * sin(threePhim2Beta) - 2. * orbital_element_e_squared * sin2Beta) * cosI);
/* if (f>=params->fLower)*/
{
*(signalvec2->data + count) = (REAL4) h2;
}
}
}
/* Injection case */
else if (a)
{
/*to be done*/
/*
omega = v*v*v;
ff->data[count] = (REAL4)(omega/unitHz);
f2a = pow (f2aFac * omega, 2./3.);
a->data[2*count] = (REAL4)(4.*apFac * f2a);
a->data[2*count+1] = (REAL4)(4.*acFac * f2a);
phi->data[count] = (REAL8)(p);
*/
}
LALInspiralEccentricityDerivatives(&values, &dvalues,funcParams);
CHECKSTATUSPTR(status);
in4.dydx = &dvalues;
in4.x=t;
LALRungeKutta4(status->statusPtr, &valuesNew, integrator, funcParams);
CHECKSTATUSPTR(status);
*(values.data) = orbital_element_p = *(valuesNew.data);
*(values.data+1) = phase = *(valuesNew.data+1);
*(values.data+2) = orbital_element_e = *(valuesNew.data+2);
t = (++count-params->nStartPad) * dt;
/* v^3 is equal to p^(3/2)*/
f = 1./(pow(orbital_element_p, 3./2.))/piM;
/* fprintf(stderr, "p=%e, e=%e, phase = %e\n", orbital_element_p, orbital_element_e, phase);
fflush(stderr);*/
rbyM = orbital_element_p/(1.+orbital_element_e * cos(phase));
/*fprintf(stderr, "rbyM=%e rbyMFlso=%e t=%e, ak.tn=%e f=%e e=%e\n",rbyM, rbyMFlso, t, ak.tn,f,orbital_element_e);
fflush(stderr);*/
} while ( (t < ak.tn) && (rbyM>rbyMFlso) && (f<fHigh));
/*fprintf(stderr, "t=%e ak.tn=%e rbyM=%e rbyMFlso=%e f=%f fHigh=%f", t, ak.tn, rbyM, rbyMFlso, f, fHigh);*/
/*also need to add for the fupper nyquist frequency**/
params->vFinal = orbital_element_p;
params->fFinal = f;
params->tC = t;
*countback = count;
XLALRungeKutta4Free( integrator );
LALFree(dummy.data);
DETATCHSTATUSPTR(status);
RETURN (status);
}
void
LALSTPNAdaptiveWaveformEngine( LALStatus *status,
REAL4Vector *signalvec1,REAL4Vector *signalvec2,
REAL4Vector *a,REAL4Vector *ff,REAL8Vector *phi,REAL4Vector *shift,
UINT4 *countback,
InspiralTemplate *params,InspiralInit *paramsInit
)
{
/* PN parameters */
LALSTPNparams mparams;
/* needed for integration */
LALAdaptiveRungeKutta4Integrator *integrator;
unsigned int len;
int intreturn;
REAL8 yinit[11];
REAL8Array *yout;
/* other computed values */
REAL8 unitHz, dt, m, lengths, norm;
INITSTATUS(status);
ATTATCHSTATUSPTR(status);
/* Make sure parameter and waveform structures exist. */
ASSERT(params, status, LALINSPIRALH_ENULL, LALINSPIRALH_MSGENULL);
ASSERT(paramsInit, status, LALINSPIRALH_ENULL, LALINSPIRALH_MSGENULL);
/* units */
unitHz = params->totalMass * LAL_MTSUN_SI * (REAL8)LAL_PI;
dt = 1.0/params->tSampling; /* tSampling is in Hz, so dt is in seconds */
m = params->totalMass * LAL_MTSUN_SI;
/* length estimation (Newtonian); since integration is adaptive, we could use a better estimate */
lengths = (5.0/256.0) * pow(LAL_PI,-8.0/3.0) * pow(params->chirpMass * LAL_MTSUN_SI * params->fLower,-5.0/3.0) / params->fLower;
/* setup coefficients for PN equations */
XLALSTPNAdaptiveSetParams(&mparams,params,paramsInit);
/* initialize the coordinates */
yinit[0] = 0.0; /* vphi */
yinit[1] = params->fLower * unitHz; /* omega (really pi M f) */
yinit[2] = sin(params->inclination); /* LNh(x,y,z) */
yinit[3] = 0.0;
yinit[4] = cos(params->inclination);
norm = pow(params->mass1/params->totalMass,2.0);
yinit[5] = norm * params->spin1[0]; /* S1(x,y,z) */
yinit[6] = norm * params->spin1[1];
yinit[7] = norm * params->spin1[2];
norm = pow(params->mass2/params->totalMass,2.0); /* S2(x,y,z) */
yinit[8] = norm * params->spin2[0];
yinit[9] = norm * params->spin2[1];
yinit[10]= norm * params->spin2[2];
xlalErrno = 0;
/* allocate the integrator */
integrator = XLALAdaptiveRungeKutta4Init(11,XLALSTPNAdaptiveDerivatives,XLALSTPNAdaptiveTest,1.0e-6,1.0e-6);
if (!integrator) {
fprintf(stderr,"LALSTPNWaveform2: Cannot allocate integrator.\n");
if (XLALClearErrno() == XLAL_ENOMEM)
ABORT(status, LALINSPIRALH_EMEM, LALINSPIRALH_MSGEMEM);
else
ABORTXLAL(status);
}
/* stop the integration only when the test is true */
integrator->stopontestonly = 1;
/* run the integration; note: time is measured in units of total mass */
len = XLALAdaptiveRungeKutta4(integrator,(void *)&mparams,yinit,0.0,lengths/m,dt/m,&yout);
intreturn = integrator->returncode;
XLALAdaptiveRungeKutta4Free(integrator);
if (!len) {
if (XLALClearErrno() == XLAL_ENOMEM) {
ABORT(status, LALINSPIRALH_EMEM, LALINSPIRALH_MSGEMEM);
} else {
fprintf(stderr,"LALSTPNWaveform2: integration failed with errorcode %d.\n",intreturn);
ABORTXLAL(status);
}
}
/* report on abnormal termination (TO DO: throw some kind of LAL error?) */
if (intreturn != 0 && intreturn != LALSTPN_TEST_ENERGY && intreturn != LALSTPN_TEST_OMEGADOT) {
fprintf(stderr,"LALSTPNWaveform2 WARNING: integration terminated with code %d.\n",intreturn);
fprintf(stderr," Waveform parameters were m1 = %e, m2 = %e, s1 = (%e,%e,%e), s2 = (%e,%e,%e), inc = %e.",
params->mass1, params->mass2,
params->spin1[0], params->spin1[1], params->spin1[2],
params->spin2[0], params->spin2[1], params->spin2[2],
params->inclination);
}
/* check that we're not above Nyquist */
if (yinit[1]/unitHz > 0.5 * params->tSampling) {
fprintf(stderr,"LALSTPNWaveform2 WARNING: final frequency above Nyquist.\n");
}
/* if we have enough space, compute the waveform components; otherwise abort */
if ((signalvec1 && len >= signalvec1->length) || (ff && len >= ff->length)) {
if (signalvec1) {
fprintf(stderr,"LALSTPNWaveform2: no space to write in signalvec1: %d vs. %d\n",len,signalvec1->length);
} else if (ff) {
fprintf(stderr,"LALSTPNWaveform2: no space to write in ff: %d vs. %d\n",len,ff->length);
} else {
fprintf(stderr,"LALSTPNWaveform2: no space to write anywhere!\n");
}
ABORT(status, LALINSPIRALH_ESIZE, LALINSPIRALH_MSGESIZE);
} else {
/* set up some aliases for the returned arrays; note vector 0 is time */
// REAL8 *thet = yout->data;
REAL8 *vphi = &yout->data[1*len]; REAL8 *omega = &yout->data[2*len];
REAL8 *LNhx = &yout->data[3*len]; REAL8 *LNhy = &yout->data[4*len]; REAL8 *LNhz = &yout->data[5*len];
/* these are not needed for the waveforms:
REAL8 *S1x = &yout->data[6*len]; REAL8 *S1y = &yout->data[7*len]; REAL8 *S1z = &yout->data[8*len];
REAL8 *S2x = &yout->data[9*len]; REAL8 *S2y = &yout->data[10*len]; REAL8 *S2z = &yout->data[11*len]; */
*countback = len;
if (signalvec1) { /* return polarizations */
REAL8 v=0, amp=0, alpha=0, alpha0 = atan2(LNhy[0],LNhx[0]);
for(unsigned int i=0;i<len;i++) {
v = pow(omega[i],(1./3.));
amp = params->signalAmplitude * (v*v);
if(LNhx[i]*LNhx[i] + LNhy[i]*LNhy[i] > 0.0) {
alpha = atan2(LNhy[i],LNhx[i]); alpha0 = alpha;
} else {
alpha = alpha0;
}
signalvec1->data[i] = (REAL4)(-0.5 * amp * cos(2*vphi[i]) * cos(2*alpha) * (1.0 + LNhz[i]*LNhz[i]) \
+ amp * sin(2*vphi[i]) * sin(2*alpha) * LNhz[i]);
if (signalvec2) {
signalvec2->data[i] = (REAL4)(-0.5 * amp * cos(2*vphi[i]) * sin(2*alpha) * (1.0 + LNhz[i]*LNhz[i]) \
- amp * sin(2*vphi[i]) * cos(2*alpha) * LNhz[i]);
}
}
params->fFinal = pow(v,3.0)/(LAL_PI*m);
if (!signalvec2) params->tC = yout->data[len-1]; /* TO DO: why only in this case? */
} else if (a) { /* return coherentGW components */
REAL8 apcommon, f2a, alpha, alpha0 = atan2(LNhy[0],LNhx[0]);
/* (minus) amplitude for distance in m; should be (1e6 * LAL_PC_SI * params->distance) for distance in Mpc */
apcommon = -4.0 * params->mu * LAL_MRSUN_SI/(params->distance);
for(unsigned int i=0;i<len;i++) {
f2a = pow(omega[i],(2./3.));
if(LNhx[i]*LNhx[i] + LNhy[i]*LNhy[i] > 0.0) {
alpha = atan2(LNhy[i],LNhx[i]); alpha0 = alpha;
} else {
alpha = alpha0;
}
ff ->data[i] = (REAL4)(omega[i]/unitHz);
a ->data[2*i] = (REAL4)(apcommon * f2a * 0.5 * (1 + LNhz[i]*LNhz[i]));
a ->data[2*i+1] = (REAL4)(apcommon * f2a * LNhz[i]);
phi ->data[i] = (REAL8)(2.0 * vphi[i]);
shift->data[i] = (REAL4)(2.0 * alpha);
}
params->fFinal = ff->data[len-1];
}
}
if (yout) XLALDestroyREAL8Array(yout);
DETATCHSTATUSPTR(status);
RETURN(status);
}
REAL8 XLALCalculateEThincaParameter(
SnglInspiralTable *table1,
SnglInspiralTable *table2,
InspiralAccuracyList* accuracyParams
)
{
TriggerErrorList * errorList[2];
REAL8 travelTime;
INT4 i;
INT4 ifoANum, ifoBNum;
fContactWorkSpace *workSpace;
REAL8 ethinca;
EThincaMinimizer *minimizer = NULL;
#ifndef LAL_NDEBUG
if ( !table1 || !table2 || !accuracyParams)
XLAL_ERROR_REAL8( XLAL_EFAULT );
#endif
memset( errorList, 0, 2 * sizeof(TriggerErrorList *) );
/* Before we do anything, check we have triggers from different ifos */
if ( !strcmp(table1->ifo, table2->ifo) )
{
XLALPrintError("%s: Triggers provided are from the same ifo!\n", __func__ );
XLAL_ERROR_REAL8( XLAL_EINVAL );
}
/* Allocate memory */
errorList[0] = LALCalloc( 1, sizeof( TriggerErrorList ));
if (errorList[0])
{
errorList[1] = errorList[0]->next = LALCalloc( 1, sizeof( TriggerErrorList ));
}
if (!errorList[0] || !errorList[1] )
{
if (errorList[0])
XLALDestroyTriggerErrorList( errorList[0] );
XLAL_ERROR_REAL8( XLAL_ENOMEM );
}
workSpace = XLALInitFContactWorkSpace( 3, NULL, NULL, gsl_min_fminimizer_brent, 1.0e-5 );
if (!workSpace)
{
XLALDestroyTriggerErrorList( errorList[0] );
XLAL_ERROR_REAL8( XLAL_EFUNC | XLALClearErrno() );
}
/* Set up the trigger lists */
if ( XLALGPSToINT8NS( &(table1->end_time) ) < XLALGPSToINT8NS( &(table2->end_time )) )
{
errorList[0]->trigger = table1;
errorList[1]->trigger = table2;
}
else
{
errorList[0]->trigger = table2;
errorList[1]->trigger = table1;
}
for (i = 0; i < 2; i++ )
{
errorList[i]->position = XLALGetPositionFromSnglInspiral( errorList[i]->trigger );
errorList[i]->err_matrix = XLALGetErrorMatrixFromSnglInspiral( errorList[i]->trigger,
1.0 );
if ( !errorList[i]->position || !errorList[i]->err_matrix )
{
XLALDestroyTriggerErrorList( errorList[0] );
XLALFreeFContactWorkSpace( workSpace );
XLAL_ERROR_REAL8( XLAL_ENOMEM );
}
}
/* Set the travel time */
ifoANum = XLALIFONumber( errorList[0]->trigger->ifo );
ifoBNum = XLALIFONumber( errorList[1]->trigger->ifo );
travelTime = accuracyParams->lightTravelTime[ifoANum][ifoBNum] * 1.0e-9;
/* Create the e-thinca minimizer */
minimizer = LALCalloc( 1, sizeof(EThincaMinimizer) );
if ( !minimizer )
{
XLALDestroyTriggerErrorList( errorList[0] );
XLALFreeFContactWorkSpace( workSpace );
XLAL_ERROR_REAL8( XLAL_ENOMEM );
}
minimizer->workSpace = workSpace;
minimizer->aPtr = errorList[0];
minimizer->bPtr = errorList[1];
ethinca = XLALMinimizeEThincaParameterOverTravelTime( travelTime, minimizer, accuracyParams->exttrig );
if ( XLAL_IS_REAL8_FAIL_NAN( ethinca ) )
{
LALFree( minimizer );
XLALDestroyTriggerErrorList( errorList[0] );
XLALFreeFContactWorkSpace( workSpace );
XLAL_ERROR_REAL8( XLAL_EFUNC );
}
LALFree ( minimizer );
XLALDestroyTriggerErrorList( errorList[0] );
XLALFreeFContactWorkSpace( workSpace );
XLALPrintInfo( " I leave here and return an ethinca of %e.\n", ethinca );
return ethinca;
}
/**
* Deprecated.
* \deprecated Use XLALButterworthREAL4TimeSeries() instead.
*/
void
LALButterworthREAL4TimeSeries( LALStatus *stat,
REAL4TimeSeries *series,
PassBandParamStruc *params )
{
INT4 n; /* The filter order. */
INT4 type; /* The pass-band type: high, low, or undeterminable. */
INT4 i; /* An index. */
INT4 j; /* Another index. */
REAL8 wc; /* The filter's transformed frequency. */
INITSTATUS(stat);
ATTATCHSTATUSPTR(stat);
/* Make sure the input pointers are non-null. */
ASSERT(params,stat,BANDPASSTIMESERIESH_ENUL,
BANDPASSTIMESERIESH_MSGENUL);
ASSERT(series,stat,BANDPASSTIMESERIESH_ENUL,
BANDPASSTIMESERIESH_MSGENUL);
ASSERT(series->data,stat,BANDPASSTIMESERIESH_ENUL,
BANDPASSTIMESERIESH_MSGENUL);
ASSERT(series->data->data,stat,BANDPASSTIMESERIESH_ENUL,
BANDPASSTIMESERIESH_MSGENUL);
/* Parse the pass-band parameter structure. I separate this into a
local static subroutine because it's an icky mess of conditionals
that would clutter the logic of the main routine. */
type=XLALParsePassBandParamStruc(params,&n,&wc,series->deltaT);
if(type<0) {
XLALClearErrno();
ABORT(stat,BANDPASSTIMESERIESH_EBAD,BANDPASSTIMESERIESH_MSGEBAD);
}
/* An order n Butterworth filter has n poles spaced evenly along a
semicircle in the upper complex w-plane. By pairing up poles
symmetric across the imaginary axis, the filter gan be decomposed
into [n/2] filters of order 2, plus perhaps an additional order 1
filter. The following loop pairs up poles and applies the
filters with order 2. */
for(i=0,j=n-1;i<j;i++,j--){
REAL4 theta=LAL_PI*(i+0.5)/n;
REAL4 ar=wc*cos(theta);
REAL4 ai=wc*sin(theta);
REAL4IIRFilter *iirFilter=NULL;
COMPLEX8ZPGFilter *zpgFilter=NULL;
/* Generate the filter in the w-plane. */
if(type==2){
TRY(LALCreateCOMPLEX8ZPGFilter(stat->statusPtr,&zpgFilter,2,2),
stat);
zpgFilter->zeros->data[0]=0.0;
zpgFilter->zeros->data[1]=0.0;
zpgFilter->gain=1.0;
}else{
TRY(LALCreateCOMPLEX8ZPGFilter(stat->statusPtr,&zpgFilter,0,2),
stat);
zpgFilter->gain=-wc*wc;
}
zpgFilter->poles->data[0]=ar;
zpgFilter->poles->data[0]+=ai*I;
zpgFilter->poles->data[1]=-ar;
zpgFilter->poles->data[1]+=ai*I;
/* Transform to the z-plane and create the IIR filter. */
LALWToZCOMPLEX8ZPGFilter(stat->statusPtr,zpgFilter);
BEGINFAIL(stat)
TRY(LALDestroyCOMPLEX8ZPGFilter(stat->statusPtr,&zpgFilter),
stat);
ENDFAIL(stat);
LALCreateREAL4IIRFilter(stat->statusPtr,&iirFilter,zpgFilter);
BEGINFAIL(stat)
TRY(LALDestroyCOMPLEX8ZPGFilter(stat->statusPtr,&zpgFilter),
stat);
ENDFAIL(stat);
/* Filter the data, once each way. */
LALIIRFilterREAL4Vector(stat->statusPtr,series->data,iirFilter);
BEGINFAIL(stat) {
TRY(LALDestroyCOMPLEX8ZPGFilter(stat->statusPtr,&zpgFilter),
stat);
TRY(LALDestroyREAL4IIRFilter(stat->statusPtr,&iirFilter),stat);
} ENDFAIL(stat);
LALIIRFilterREAL4VectorR(stat->statusPtr,series->data,iirFilter);
BEGINFAIL(stat) {
TRY(LALDestroyCOMPLEX8ZPGFilter(stat->statusPtr,&zpgFilter),
stat);
TRY(LALDestroyREAL4IIRFilter(stat->statusPtr,&iirFilter),stat);
} ENDFAIL(stat);
/* Free the filters. */
TRY(LALDestroyREAL4IIRFilter(stat->statusPtr,&iirFilter),stat);
TRY(LALDestroyCOMPLEX8ZPGFilter(stat->statusPtr,&zpgFilter),stat);
}
/* Next, this conditional applies the possible order 1 filter
corresponding to an unpaired pole on the imaginary w axis. */
if(i==j){
REAL4IIRFilter *iirFilter=NULL;
COMPLEX8ZPGFilter *zpgFilter=NULL;
/* Generate the filter in the w-plane. */
if(type==2){
TRY(LALCreateCOMPLEX8ZPGFilter(stat->statusPtr,&zpgFilter,1,1),
stat);
*zpgFilter->zeros->data=0.0;
zpgFilter->gain=1.0;
}else{
TRY(LALCreateCOMPLEX8ZPGFilter(stat->statusPtr,&zpgFilter,0,1),
stat);
zpgFilter->gain=-wc*I;
}
*zpgFilter->poles->data=wc*I;
/* Transform to the z-plane and create the IIR filter. */
LALWToZCOMPLEX8ZPGFilter(stat->statusPtr,zpgFilter);
BEGINFAIL(stat)
TRY(LALDestroyCOMPLEX8ZPGFilter(stat->statusPtr,&zpgFilter),
stat);
ENDFAIL(stat);
LALCreateREAL4IIRFilter(stat->statusPtr,&iirFilter,zpgFilter);
BEGINFAIL(stat)
TRY(LALDestroyCOMPLEX8ZPGFilter(stat->statusPtr,&zpgFilter),
stat);
ENDFAIL(stat);
/* Filter the data, once each way. */
LALIIRFilterREAL4Vector(stat->statusPtr,series->data,iirFilter);
BEGINFAIL(stat) {
TRY(LALDestroyCOMPLEX8ZPGFilter(stat->statusPtr,&zpgFilter),
stat);
TRY(LALDestroyREAL4IIRFilter(stat->statusPtr,&iirFilter),stat);
} ENDFAIL(stat);
LALIIRFilterREAL4VectorR(stat->statusPtr,series->data,iirFilter);
BEGINFAIL(stat) {
TRY(LALDestroyCOMPLEX8ZPGFilter(stat->statusPtr,&zpgFilter),
stat);
TRY(LALDestroyREAL4IIRFilter(stat->statusPtr,&iirFilter),stat);
} ENDFAIL(stat);
/* Free the filters. */
TRY(LALDestroyREAL4IIRFilter(stat->statusPtr,&iirFilter),stat);
TRY(LALDestroyCOMPLEX8ZPGFilter(stat->statusPtr,&zpgFilter),stat);
}
int
XLALAddNumRelStrainModesREAL8(
REAL8TimeSeries **seriesPlus, /**< [out] h+, hx data */
REAL8TimeSeries **seriesCross, /**< [out] h+, hx data */
SimInspiralTable *thisinj /**< [in] injection data */
)
{
INT4 modeL, modeM, modeLlo, modeLhi;
INT4 len, lenPlus, lenCross, k;
CHAR *channel_name_plus;
CHAR *channel_name_cross;
LALFrStream *frStream = NULL;
LALCache frCache;
LIGOTimeGPS epoch;
REAL8TimeSeries *modePlus=NULL;
REAL8TimeSeries *modeCross=NULL;
REAL8 massMpc, timeStep;
modeLlo = thisinj->numrel_mode_min;
modeLhi = thisinj->numrel_mode_max;
/* create a frame cache and open the frame stream */
frCache.length = 1;
frCache.list = LALCalloc(1, sizeof(frCache.list[0]));
frCache.list[0].url = thisinj->numrel_data;
frStream = XLALFrStreamCacheOpen( &frCache );
/* the total mass of the binary in Mpc */
massMpc = (thisinj->mass1 + thisinj->mass2) * LAL_MRSUN_SI / ( LAL_PC_SI * 1.0e6);
/* Time step in dimensionful units */
timeStep = (thisinj->mass1 + thisinj->mass2) * LAL_MTSUN_SI;
/* start time of waveform -- set it to something */
epoch.gpsSeconds = thisinj->geocent_end_time.gpsSeconds;
epoch.gpsNanoSeconds = thisinj->geocent_end_time.gpsNanoSeconds;
/* loop over l values */
for ( modeL = modeLlo; modeL <= modeLhi; modeL++ ) {
/* loop over m values */
for ( modeM = -modeL; modeM <= modeL; modeM++ ) {
/* read numrel waveform */
/* first the plus polarization */
channel_name_plus = XLALGetNinjaChannelName("plus", modeL, modeM);
/*get number of data points */
if (XLALCheckFrameHasChannel(channel_name_plus, frStream ) )
{
lenPlus = XLALFrStreamGetVectorLength ( channel_name_plus, frStream );
}
else
{
lenPlus = -1;
}
/* now the cross polarization */
channel_name_cross = XLALGetNinjaChannelName("cross", modeL, modeM);
/*get number of data points */
if (XLALCheckFrameHasChannel(channel_name_cross, frStream ) )
{
lenCross = XLALFrStreamGetVectorLength ( channel_name_cross, frStream );
}
else
{
lenCross = -1;
}
/* skip on to next mode if mode doesn't exist */
if ( (lenPlus <= 0) || (lenCross <= 0) || (lenPlus != lenCross) ) {
XLALClearErrno();
LALFree(channel_name_plus);
LALFree(channel_name_cross);
continue;
}
/* note: lenPlus and lenCross must be equal if we got this far*/
len = lenPlus;
/* allocate and read the plus/cross time series */
modePlus = XLALCreateREAL8TimeSeries ( channel_name_plus, &epoch, 0, 0, &lalDimensionlessUnit, len);
memset(modePlus->data->data, 0, modePlus->data->length*sizeof(REAL8));
XLALFrStreamGetREAL8TimeSeries ( modePlus, frStream );
XLALFrStreamRewind( frStream );
LALFree(channel_name_plus);
modeCross = XLALCreateREAL8TimeSeries ( channel_name_cross, &epoch, 0, 0, &lalDimensionlessUnit, len);
memset(modeCross->data->data, 0, modeCross->data->length*sizeof(REAL8));
XLALFrStreamGetREAL8TimeSeries ( modeCross, frStream );
XLALFrStreamRewind( frStream );
LALFree(channel_name_cross);
/* scale and add */
if (*seriesPlus == NULL) {
*seriesPlus = XLALCreateREAL8TimeSeries ( "hplus", &epoch, 0, 0, &lalDimensionlessUnit, len);
memset((*seriesPlus)->data->data, 0, (*seriesPlus)->data->length*sizeof(REAL8));
(*seriesPlus)->deltaT = modePlus->deltaT;
}
if (*seriesCross == NULL) {
*seriesCross = XLALCreateREAL8TimeSeries ( "hcross", &epoch, 0, 0, &lalDimensionlessUnit, len);
memset((*seriesCross)->data->data, 0, (*seriesCross)->data->length*sizeof(REAL8));
(*seriesCross)->deltaT = modeCross->deltaT;
}
XLALOrientNRWaveTimeSeriesREAL8( modePlus, modeCross, modeL, modeM, thisinj->inclination, thisinj->coa_phase );
for (k = 0; k < len; k++) {
(*seriesPlus)->data->data[k] += massMpc * modePlus->data->data[k];
(*seriesCross)->data->data[k] += massMpc * modeCross->data->data[k];
}
/* we are done with seriesPlus and Cross for this iteration */
XLALDestroyREAL8TimeSeries (modePlus);
XLALDestroyREAL8TimeSeries (modeCross);
} /* end loop over modeM values */
} /* end loop over modeL values */
(*seriesPlus)->deltaT *= timeStep;
(*seriesCross)->deltaT *= timeStep;
XLALFrStreamClose( frStream );
LALFree(frCache.list);
return XLAL_SUCCESS;
}
void FUNC ( LALStatus *status, STYPE **vseq, CreateVectorSequenceIn *in )
{
/*
* Initialize status
*/
INITSTATUS(status);
/* Check input structure: report if NULL */
ASSERT (in != NULL, status, SEQFACTORIESH_EINPTR, SEQFACTORIESH_MSGEINPTR);
/* Check sequence length: report error if 0
* Use of unsigned for length means we can't check if negative
* length was passed
*/
ASSERT (in->length > 0, status,
SEQFACTORIESH_ESLENGTH, SEQFACTORIESH_MSGESLENGTH);
/* Check vector length: report error if 0
* Use of unsigned for length means we can't check if negative
* length was passed
*/
ASSERT (in->vectorLength > 0, status,
SEQFACTORIESH_EVLENGTH, SEQFACTORIESH_MSGEVLENGTH);
/*
* Check return structure: If return pointer does not point to a
* valid pointer then report an error
*/
ASSERT (vseq != NULL, status, SEQFACTORIESH_EVPTR, SEQFACTORIESH_MSGEVPTR);
ASSERT (*vseq == NULL, status, SEQFACTORIESH_EUPTR, SEQFACTORIESH_MSGEUPTR);
*vseq = XFUNC ( in->length, in->vectorLength );
if ( ! vseq )
{
int code = xlalErrno;
XLALClearErrno();
if ( code == XLAL_EBADLEN )
{
if ( ! in->length )
{
ABORT (status, SEQFACTORIESH_ESLENGTH, SEQFACTORIESH_MSGESLENGTH);
}
else
{
ABORT (status, SEQFACTORIESH_EVLENGTH, SEQFACTORIESH_MSGEVLENGTH);
}
}
if ( code == XLAL_ENOMEM )
{
ABORT( status, SEQFACTORIESH_EMALLOC, SEQFACTORIESH_MSGEMALLOC );
}
}
/* We be done: Normal exit */
RETURN (status);
}
