static ProcessParamsTable *addCommandLineOption(ProcessParamsTable *ppt, char *oName, char *oValue) { ProcessParamsTable *current = NULL; current = calloc(1, sizeof(ProcessParamsTable)); XLALStringCopy(current->program, "OCamlLALInference", LIGOMETA_PROGRAM_MAX); XLALStringCopy(current->param, oName, LIGOMETA_PARAM_MAX); XLALStringCopy(current->type, "string", LIGOMETA_TYPE_MAX); if (oValue != NULL) { XLALStringCopy(current->value, oValue, LIGOMETA_VALUE_MAX); } current->next = ppt; return current; }
/** * Set the numreldata string within a LALSimInspiralWaveformFlags struct */ void XLALSimInspiralSetNumrelData( LALSimInspiralWaveformFlags *waveFlags, /**< Struct whose value will be set */ const char* numreldata /**< value to set numreldata to */ ) { XLALStringCopy(waveFlags->numreldata, numreldata, sizeof(waveFlags->numreldata)); return; }
/** * Returns a deepcopy of the pointer of the numeraldata attribute of the * waveFlags structure. If this is NULL then NULL will be returned. * The returned value is independent of the waveFlags structure and will * need to be LALFree-d. */ char* XLALSimInspiralGetNumrelData( LALSimInspiralWaveformFlags *waveFlags ) { char *ret_string; if ( waveFlags ) { ret_string = XLALMalloc(FILENAME_MAX * sizeof(char)); XLALStringCopy(ret_string, waveFlags->numreldata, sizeof(waveFlags->numreldata)); return ret_string; } else { return NULL; } }
/* * TestStatus () * * Routine to check that the status code status->statusCode agrees with one of * the codes specified in the space-delimited string ignored; if not, * exit to the system with code exitcode. * */ static void TestStatus (LALStatus *status, const char *ignored, int exitcode) { char str[64]; char *tok; if (verbose) { REPORTSTATUS (status); } if (XLALStringCopy(str, ignored, sizeof(str))) { if ((tok = strtok (str, " "))) { do { if (status->statusCode == atoi (tok)) { return; } } while ((tok = strtok (NULL, " "))); } else { if (status->statusCode == atoi (tok)) { return; } } } fprintf (stderr, "\nExiting to system with code %d\n", exitcode); exit (exitcode); }
/** * \brief Automatically set the solar system ephemeris file based on environment variables and data time span * * This function will attempt to find Earth and Sun ephemeris files based on LAL environment variables (as set up by * <code> lalpulsar-user-env.(c)sh </code>) and a given start and end GPS time (presumably taken from the data that is * to be analysed). It requires \c LALPULSAR is installed and the \c LALPULSAR_PREFIX variable is set, which should mean * that ephemeris files are installed in the directory \c ${LALPULSAR_PREFIX}/share/lalpulsar/. * * \param efile [in] a string that will return the Earth ephemeris file * \param sfile [in] a string that will return the Sun ephemeris file * \param tfile [in] a string that will return the time correction file * \param pulsar [in] the pulsar parameters read from a .par file * \param gpsstart [in] the GPS time of the start of the data * \param gpsend [in] the GPS time of the end of the data * * \return The TimeCorrectionType e.g. TDB or TCB */ TimeCorrectionType XLALAutoSetEphemerisFiles( CHAR *efile, CHAR *sfile, CHAR *tfile, BinaryPulsarParams pulsar, INT4 gpsstart, INT4 gpsend ){ /* set the times that the ephemeris files span */ INT4 ephemstart = 630720013; /* GPS time of Jan 1, 2000, 00:00:00 UTC */ INT4 ephemend = 1261872015; /* GPS time of Jan 1, 2020, 00:00:00 UTC */ CHAR *eftmp = NULL, *sftmp = NULL, *tftmp = NULL; TimeCorrectionType ttype = TIMECORRECTION_NONE; CHAR *lalpath = NULL, *lalpulsarpath = NULL; if( gpsstart < ephemstart || gpsend < ephemstart || gpsstart > ephemend || gpsend > ephemend ){ XLALPrintError("Start and end times are outside the ephemeris file ranges!\n"); XLAL_ERROR(XLAL_EFUNC); } /* first check that the path to the Ephemeris files is available in the environment variables */ if((lalpath = getenv("LALPULSAR_PREFIX")) == NULL){ XLALPrintError("LALPULSAR_PREFIX environment variable not set. Cannot automatically generate ephemeris files!\n"); XLAL_ERROR(XLAL_EFUNC); } lalpulsarpath = XLALStringDuplicate( lalpath ); if ( (lalpulsarpath = XLALStringAppend(lalpulsarpath, "/share/lalpulsar/")) == NULL ) { XLAL_ERROR(XLAL_EFUNC); } eftmp = XLALStringDuplicate(lalpulsarpath); sftmp = XLALStringDuplicate(lalpulsarpath); tftmp = XLALStringDuplicate(lalpulsarpath); eftmp = XLALStringAppend(eftmp, "earth00-19-"); sftmp = XLALStringAppend(sftmp, "sun00-19-"); if( pulsar.ephem == NULL ){ /* default to use DE405 */ eftmp = XLALStringAppend(eftmp, "DE405"); sftmp = XLALStringAppend(sftmp, "DE405"); } else{ if( !strcmp(pulsar.ephem, "DE405") || !strcmp(pulsar.ephem, "DE200") || !strcmp(pulsar.ephem, "DE414") ){ eftmp = XLALStringAppend(eftmp, pulsar.ephem); sftmp = XLALStringAppend(sftmp, pulsar.ephem); } else{ XLALPrintError("Unknown ephemeris %s in par file\n", pulsar.ephem); XLAL_ERROR(XLAL_EFUNC); } } /* add .dat extension */ eftmp = XLALStringAppend(eftmp, ".dat.gz"); sftmp = XLALStringAppend(sftmp, ".dat.gz"); if ( eftmp == NULL || sftmp == NULL ) { XLAL_ERROR(XLAL_EFUNC); } XLALStringCopy( efile, eftmp, strlen(eftmp)+1 ); XLALStringCopy( sfile, sftmp, strlen(sftmp)+1 ); /* double check that the files exist */ if( fopen(sfile, "r") == NULL || fopen(efile, "r") == NULL ){ XLALPrintError("Error... ephemeris files not, or incorrectly, defined!\n"); XLAL_ERROR(XLAL_EFUNC); } if( pulsar.units == NULL ){ /* default to using TCB units */ tftmp = XLALStringAppend(tftmp, "te405_2000-2019.dat.gz"); ttype = TIMECORRECTION_TCB; } else{ if ( !strcmp( pulsar.units, "TDB" ) ){ tftmp = XLALStringAppend(tftmp, "tdb_2000-2019.dat.gz"); ttype = TIMECORRECTION_TDB; } else{ XLALPrintError("Error... unknown units %s in par file!\n", pulsar.units); XLAL_ERROR(XLAL_EFUNC); } } if ( tftmp == NULL ) { XLAL_ERROR(XLAL_EFUNC); } XLALStringCopy( tfile, tftmp, strlen(tftmp)+1 ); if( fopen(tfile, "r") == NULL ){ XLALPrintError("Error... time ephemeris files not, or incorrectly, defined!\n"); XLAL_ERROR(XLAL_EFUNC); } return ttype; }
int XLALCalRefFileNameDescriptionParse( LALCalRefFileNameDescriptionFields *fields, const char *description ) { char dsc[FILENAME_MAX]; char *dsc_channel_start; char *dsc_version_start; char *dsc_run_start; char *dsc_ifo_start; int c; if ( ! fields || ! description ) XLAL_ERROR( XLAL_EFAULT ); if ( strlen( description ) > FILENAME_MAX ) { XLALPrintError( "XLAL Error - %s: Description string %s too long\n", __func__, description ); XLAL_ERROR( XLAL_EBADLEN ); } XLALStringCopy( dsc, description, sizeof( dsc ) ); dsc_ifo_start = dsc; /* find start of channel string */ dsc_channel_start = strchr( dsc, '_' ); if ( ! dsc_channel_start ) { XLALPrintError( "XLAL Error - %s: Could not parse description field %s\n\tinto <ifo>_CAL_REF_<channelpostfix>_<run>_<version> format\n", __func__, description ); XLAL_ERROR( XLAL_EINVAL ); } *dsc_channel_start++ = 0; /* now skip the CAL_REF_ */ if ( dsc_channel_start != strstr( dsc_channel_start, "CAL_REF_" ) ) { XLALPrintError( "XLAL Error - %s: Could not parse description field %s\n\tinto <ifo>_CAL_REF_<channelpostfix>_<run>_<version> format\n", __func__, description ); XLAL_ERROR( XLAL_EINVAL ); } dsc_channel_start += strlen( "CAL_REF" ); *dsc_channel_start++ = 0; /* find start of version string */ dsc_version_start = strrchr( dsc_channel_start, '_' ); if ( ! dsc_version_start ) { XLALPrintError( "XLAL Error - %s: Could not parse description field %s\n\tinto <ifo>_CAL_REF_<channelpostfix>_<run>_<version> format\n", __func__, description ); XLAL_ERROR( XLAL_EINVAL ); } *dsc_version_start++ = 0; /* find start of run string */ dsc_run_start = strrchr( dsc_channel_start, '_' ); if ( ! dsc_run_start ) { XLALPrintError( "XLAL Error - %s: Could not parse description field %s\n\tinto <ifo>_CAL_REF_<channelpostfix>_<run>_<version> format\n", __func__, description ); XLAL_ERROR( XLAL_EINVAL ); } *dsc_run_start++ = 0; XLALStringCopy( fields->ifo, dsc_ifo_start, sizeof( fields->ifo ) ); XLALStringCopy( fields->channelPostfix, dsc_channel_start, sizeof( fields->channelPostfix ) ); XLALStringCopy( fields->run, dsc_run_start, sizeof( fields->run ) ); c = sscanf( dsc_version_start, "V%d", &fields->version ); if ( c != 1 ) { if ( ! strcmp( dsc_version_start, "VU" ) ) fields->version = -1; /* means unity */ else { XLALPrintError( "XLAL Error - %s: Could not parse description field %s\n\tinto <ifo>_CAL_REF_<channelpostfix>_<run>_<version> format\n", __func__, description ); XLAL_ERROR( XLAL_EINVAL ); } } return 0; }
int XLALASCIIFileReadCalRef( COMPLEX8FrequencySeries **series, REAL8 *duration, const char *fname ) { const REAL8 fuzzfactor = 1e-3; /* fraction of a sample of fuzziness */ REAL8 fuzz; /* possible discrepancies in times */ LALDataFileNameFields fileFields; LALCalRefFileNameDescriptionFields descFields; REAL8VectorSequence *data; LIGOTimeGPS epoch; LALUnit unit; char channel[FILENAME_MAX]; REAL4 deltaF; REAL8 fstart; REAL8 fend; REAL8 df; int ndat; int nrow; int row; if ( ! series ) XLAL_ERROR( XLAL_EFAULT ); if ( *series ) XLAL_ERROR( XLAL_EINVAL ); if ( XLALDataFileNameParse( &fileFields, fname ) < 0 ) { XLALPrintError( "XLAL Error - %s: invalid file name %s\n", __func__, fname ); XLAL_ERROR( XLAL_EINVAL ); } *duration = fileFields.duration; if ( XLALCalRefFileNameDescriptionParse( &descFields, fileFields.description ) < 0 ) { XLALPrintError( "XLAL Error - %s: invalid description part of file name %s\n", __func__, fname ); XLAL_ERROR( XLAL_EINVAL ); } XLALPrintInfo( "XLAL Info - %s: Reading calibration factors from file %s\n", __func__, fname ); /* setup units */ if ( strstr( descFields.channelPostfix, "RESPONSE" ) ) XLALUnitDivide( &unit, &lalStrainUnit, &lalADCCountUnit ); else if ( strstr( descFields.channelPostfix, "CAV_GAIN" ) ) XLALUnitDivide( &unit, &lalADCCountUnit, &lalStrainUnit ); else if ( strstr( descFields.channelPostfix, "OLOOP_GAIN" ) ) unit = lalDimensionlessUnit; else if ( strstr( descFields.channelPostfix, "ACTUATION" ) ) XLALUnitDivide( &unit, &lalADCCountUnit, &lalStrainUnit ); else if ( strstr( descFields.channelPostfix, "DIGFLT" ) ) unit = lalDimensionlessUnit; else { XLALPrintError( "XLAL Error - %s: invalid channel %s\n", __func__, descFields.channelPostfix ); XLAL_ERROR( XLAL_EINVAL ); } /* setup channel names */ XLALStringCopy( channel, descFields.ifo, sizeof( channel ) ); XLALStringConcatenate( channel, ":CAL-", sizeof( channel ) ); XLALStringConcatenate( channel, descFields.channelPostfix, sizeof( channel ) ); /* read header */ deltaF = XLALASCIIFileReadCalRefHeader( fname ); if ( XLAL_IS_REAL4_FAIL_NAN( deltaF ) ) XLAL_ERROR( XLAL_EFUNC ); if ( deltaF <= 0 ) /* bad time step */ XLAL_ERROR( XLAL_EDATA ); /* read three columns */ data = XLALASCIIFileReadColumns( 3, fname ); if ( ! data ) XLAL_ERROR( XLAL_EFUNC ); if ( ! data->length ) { XLALPrintError( "XLAL Error - %s: no rows of data\n", __func__ ); XLAL_ERROR( XLAL_EFAILED ); } nrow = data->length; /* sanity checks on time stamps */ fstart = ELEM(data,0,1); fend = ELEM(data,nrow-1,1); ndat = 1 + (int)floor( (fend - fstart)/deltaF + 0.5 ); df = (fend - fstart) / (ndat - 1); if ( nrow != ndat ) /* this should be impossible */ { XLALDestroyREAL8VectorSequence( data ); XLAL_ERROR( XLAL_EDATA ); } XLALGPSSetREAL8( &epoch, fileFields.tstart ); *series = XLALCreateCOMPLEX8FrequencySeries( channel, &epoch, fstart, df, &unit, ndat ); if ( ! *series ) { XLALDestroyREAL8VectorSequence( data ); XLAL_ERROR( XLAL_EFUNC ); } fuzz = fuzzfactor * deltaF; for ( row = 0; row < nrow; ++row ) { int line = ELEM(data,row,0); REAL8 freq = ELEM(data,row,1); REAL8 mod = ELEM(data,row,2); REAL8 arg = ELEM(data,row,3); REAL8 fexp = fstart + row * df; if ( fabs( freq - fexp ) / fexp > fuzz ) { XLALPrintError( "XLAL Error - %s: error on line %d of file %s\n\tunexpected frequency\n", __func__, line, fname ); XLALDestroyCOMPLEX8FrequencySeries( *series ); XLALDestroyREAL8VectorSequence( data ); XLAL_ERROR( XLAL_EDATA ); } (*series)->data->data[row] = crectf( mod * cos( arg ), mod * sin( arg ) ); } XLALDestroyREAL8VectorSequence( data ); return 0; }