int XLALPsdFromFile(REAL8FrequencySeries **psd, /**< [out] The PSD */ const CHAR *filename) /**< [in] name of the file to be read */ { REAL8FrequencySeries *ret; LALParsedDataFile *cfgdata=NULL; LIGOTimeGPS stubEpoch; UINT4 length, k, r; REAL8 freq, value; REAL8 step1=0, deltaF=0; int retval; /* XLALParseDataFile checks that filename is not null for us */ retval = XLALParseDataFile(&cfgdata, filename); if ( retval != XLAL_SUCCESS ) { XLAL_ERROR ( retval ); } /*number of data points */ length = cfgdata->lines->nTokens; /* allocate memory */ ret = XLALCreateREAL8FrequencySeries("PSD", &stubEpoch, 0, 0, &lalHertzUnit, length); if (ret == NULL) { XLALDestroyParsedDataFile( cfgdata ); XLALPrintError ("%s: XLALPsdFromFile() failed.\n", __func__ ); XLAL_ERROR ( XLAL_ENOMEM ); } /* now get the data */ for (k = 0; k < length; k++) { r = sscanf(cfgdata->lines->tokens[k], "%lf%lf", &freq, &value); /* Check the data file format */ if ( r != 2 ) { XLALDestroyParsedDataFile( cfgdata ); XLALPrintError ("%s: XLALPsdFromFile() failed on bad line in psd file.\n", __func__ ); XLAL_ERROR ( XLAL_EFUNC ); } if (deltaF == 0) { if (step1 == 0) { step1 = freq; } else { deltaF = (freq - step1); ret->deltaF = deltaF; } } ret->data->data[k] = value; } (*psd) = ret; XLALDestroyParsedDataFile( cfgdata ); return XLAL_SUCCESS; }
/** * Function to determine the PulsarParamsVector input from a user-input defining CW sources. * * This option supports a dual-type feature: if any string in the list is of the form '{...}', then * it determines the *contents* of a config-file, otherwise the name-pattern of config-files to be parsed by XLALFindFiles(), * NOTE: when specifying file-contents, options can be separated by ';' and/or newlines) */ PulsarParamsVector * XLALPulsarParamsFromUserInput ( const LALStringVector *UserInput ///< [in] user-input CSV list defining 'CW sources' ) { XLAL_CHECK_NULL ( UserInput, XLAL_EINVAL ); XLAL_CHECK_NULL ( UserInput->length > 0, XLAL_EINVAL ); PulsarParamsVector *allSources = NULL; for ( UINT4 l = 0; l < UserInput->length; l ++ ) { const char *thisInput = UserInput->data[l]; if ( thisInput[0] != '{' ) // if it's an actual file-specification { LALStringVector *file_list; XLAL_CHECK_NULL ( ( file_list = XLALFindFiles ( &thisInput[0] )) != NULL, XLAL_EFUNC ); UINT4 numFiles = file_list->length; for ( UINT4 i = 0; i < numFiles; i ++ ) { PulsarParamsVector *sources_i; XLAL_CHECK_NULL ( (sources_i = XLALPulsarParamsFromFile ( file_list->data[i] )) != NULL, XLAL_EFUNC ); XLAL_CHECK_NULL ( (allSources = XLALPulsarParamsVectorAppend ( allSources, sources_i )) != NULL, XLAL_EFUNC ); XLALDestroyPulsarParamsVector ( sources_i ); } // for i < numFiles XLALDestroyStringVector ( file_list ); } // if file-pattern given else { UINT4 len = strlen(thisInput); XLAL_CHECK_NULL ( (thisInput[0] == '{') && (thisInput[len-1] == '}'), XLAL_EINVAL, "Invalid file-content input:\n%s\n", thisInput ); char *buf; XLAL_CHECK_NULL ( (buf = XLALStringDuplicate ( &thisInput[1] )) != NULL, XLAL_EFUNC ); len = strlen(buf); buf[len-1] = 0; // remove trailing '}' LALParsedDataFile *cfgdata = NULL; XLAL_CHECK_NULL ( XLALParseDataFileContent ( &cfgdata, buf ) == XLAL_SUCCESS, XLAL_EFUNC ); XLALFree ( buf ); PulsarParamsVector *addSource; XLAL_CHECK_NULL ( (addSource = XLALCreatePulsarParamsVector ( 1 )) != NULL, XLAL_EFUNC ); XLAL_CHECK_NULL ( XLALReadPulsarParams ( &addSource->data[0], cfgdata, NULL ) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK_NULL ( (addSource->data[0].name = XLALStringDuplicate ( "direct-string-input" )) != NULL, XLAL_EFUNC ); XLALDestroyParsedDataFile ( cfgdata ); XLAL_CHECK_NULL ( (allSources = XLALPulsarParamsVectorAppend ( allSources, addSource )) != NULL, XLAL_EFUNC ); XLALDestroyPulsarParamsVector ( addSource ); } // if direct config-string given } // for l < len(UserInput) return allSources; } // XLALPulsarParamsFromUserInput()
/** * Read config-variables from cfgfile and parse into input-structure. * An error is reported if the config-file reading fails, but the * individual variable-reads are treated as optional */ int XLALUserVarReadCfgfile ( const CHAR *cfgfile ) /**< [in] name of config-file */ { XLAL_CHECK ( cfgfile != NULL, XLAL_EINVAL ); XLAL_CHECK ( UVAR_vars.next != NULL, XLAL_EINVAL, "No memory allocated in UVAR_vars.next, did you register any user-variables?\n" ); LALParsedDataFile *cfg = NULL; XLAL_CHECK ( XLALParseDataFile ( &cfg, cfgfile ) == XLAL_SUCCESS, XLAL_EFUNC ); // step through all user-variable: read those with names from config-file LALUserVariable *ptr = &UVAR_vars; while ( (ptr=ptr->next) != NULL) { if (ptr->name == NULL) { // ignore name-less user-variable continue; } XLAL_CHECK ( (ptr->type > UVAR_TYPE_START) && (ptr->type < UVAR_TYPE_END), XLAL_EFAILED, "Invalid UVAR_TYPE '%d' outside of [%d,%d]\n", ptr->type, UVAR_TYPE_START+1, UVAR_TYPE_END-1 ); BOOLEAN wasRead; CHAR *valString = NULL; // first read the value as a string XLAL_CHECK ( XLALReadConfigSTRINGVariable ( &valString, cfg, NULL, ptr->name, &wasRead ) == XLAL_SUCCESS, XLAL_EFUNC ); if ( wasRead ) // if successful, parse this as the desired type { // destroy previous value, is applicable, then parse new one if ( UserVarTypeMap [ ptr->type ].destructor != NULL ) { UserVarTypeMap [ ptr->type ].destructor( *(char**)ptr->varp ); *(char**)ptr->varp = NULL; } // if a destructor was registered XLAL_CHECK ( UserVarTypeMap [ ptr->type ].parser( ptr->varp, valString ) == XLAL_SUCCESS, XLAL_EFUNC ); XLALFree (valString); check_and_mark_as_set ( ptr ); } // if wasRead } // while ptr->next // ok, that should be it: check if there were more definitions we did not read UINT4Vector *unread = XLALConfigFileGetUnreadEntries ( cfg ); XLAL_CHECK ( xlalErrno == 0, XLAL_EFUNC, "XLALConfigFileGetUnreadEntries() failed\n"); if ( unread != NULL ) { XLALPrintWarning ("The following entries in config-file '%s' have not been parsed:\n", cfgfile ); for ( UINT4 i = 0; i < unread->length; i ++ ) { XLALPrintWarning ("%s\n", cfg->lines->tokens[ unread->data[i] ] ); } XLALDestroyUINT4Vector ( unread ); } XLALDestroyParsedDataFile ( cfg ); return XLAL_SUCCESS; } // XLALUserVarReadCfgfile()
/** * Parse a given 'CWsources' config file for PulsarParams, return vector * of all pulsar definitions found [using sections] */ PulsarParamsVector * XLALPulsarParamsFromFile ( const char *fname ///< [in] 'CWsources' config file name ) { XLAL_CHECK_NULL ( fname != NULL, XLAL_EINVAL ); LALParsedDataFile *cfgdata = NULL; XLAL_CHECK_NULL ( XLALParseDataFile ( &cfgdata, fname ) == XLAL_SUCCESS, XLAL_EFUNC ); LALStringVector *sections; XLAL_CHECK_NULL ( (sections = XLALListConfigFileSections ( cfgdata )) != NULL, XLAL_EFUNC ); UINT4 numPulsars = sections->length; // currently only single-section defs supported! FIXME PulsarParamsVector *sources; XLAL_CHECK_NULL ( (sources = XLALCreatePulsarParamsVector ( numPulsars )) != NULL, XLAL_EFUNC ); for ( UINT4 i = 0; i < numPulsars; i ++ ) { const char *sec_i = sections->data[i]; if ( strcmp ( sec_i, "default" ) == 0 ) { // special handling of 'default' section sec_i = NULL; } XLAL_CHECK_NULL ( XLALReadPulsarParams ( &sources->data[i], cfgdata, sec_i ) == XLAL_SUCCESS, XLAL_EFUNC ); // ----- source naming convention: 'filename:section' char *name; size_t len = strlen(fname) + strlen(sections->data[i]) + 2; XLAL_CHECK_NULL ( (name = XLALCalloc(1, len)) != NULL, XLAL_ENOMEM ); sprintf ( name, "%s:%s", fname, sections->data[i] ); sources->data[i].name = name; } // for i < numPulsars XLALDestroyStringVector ( sections ); XLALDestroyParsedDataFile ( cfgdata ); return sources; } // XLALPulsarParamsFromFile()
/** * Function for reading a numerical relativity metadata file. * It returns a list of numrel wave parameters. It uses * XLALParseDataFile() for reading the data file. This automatically * takes care of removing comment lines starting with # and other details. */ void LALNRDataFind( LALStatus *status, /**< pointer to LALStatus structure */ NRWaveCatalog *out, /**< [out] list of numrel metadata */ const CHAR *dir, /**< [in] directory with data files */ const CHAR *filename /**< [in] File with metadata information */) { LALParsedDataFile *cfgdata=NULL; UINT4 k, numWaves; INITSTATUS(status); ATTATCHSTATUSPTR (status); ASSERT (filename != NULL, status, NRWAVEIO_ENULL, NRWAVEIO_MSGENULL ); ASSERT ( out != NULL, status, NRWAVEIO_ENULL, NRWAVEIO_MSGENULL ); ASSERT ( dir != NULL, status, NRWAVEIO_ENULL, NRWAVEIO_MSGENULL ); if ( XLALParseDataFile ( &cfgdata, filename ) != XLAL_SUCCESS ) { ABORT( status, NRWAVEIO_EFILE, NRWAVEIO_MSGEFILE ); } numWaves = cfgdata->lines->nTokens; /*number of waves */ /* allocate memory for output catalog */ out->length = numWaves; out->data = LALCalloc(1, out->length * sizeof(NRWaveMetaData)); if ( out->data == NULL) { ABORT( status, NRWAVEIO_ENOMEM, NRWAVEIO_MSGENOMEM ); } /* now get wave parameters from each line of data */ for (k = 0; k < numWaves; k++) { TRY(LALGetSingleNRMetaData( status->statusPtr, out->data + k, dir, cfgdata->lines->tokens[k]), status); } XLALDestroyParsedDataFile (cfgdata); DETATCHSTATUSPTR(status); RETURN(status); }
/** The main function of binary2sft.c * */ int main( int argc, char *argv[] ) { UserInput_t uvar = empty_UserInput; /* user input variables */ INT4 i,j; /* counter */ SFTVector *SFTvect = NULL; char *noisestr = XLALCalloc(1,sizeof(char)); /**********************************************************************************/ /* register and read all user-variables */ if (XLALReadUserVars(argc,argv,&uvar)) { LogPrintf(LOG_CRITICAL,"%s : XLALReadUserVars() failed with error = %d\n",__func__,xlalErrno); return 1; } LogPrintf(LOG_DEBUG,"%s : read in uservars\n",__func__); /**********************************************************************************/ /* read in the cache file */ LALParsedDataFile *cache = NULL; if ( XLALParseDataFile( &cache, uvar.cachefile ) != XLAL_SUCCESS ) { LogPrintf(LOG_CRITICAL,"%s : failed to parse cache file %s\n",__func__,uvar.cachefile); return 1; } INT4 Nfiles = cache->lines->nTokens; LogPrintf(LOG_DEBUG,"%s : counted %d files listed in the cache file.\n",__func__,Nfiles); /* allocate memory */ char **filenames = LALCalloc(Nfiles,sizeof(char*)); LIGOTimeGPSVector fileStart; fileStart.data = LALCalloc(Nfiles,sizeof(LIGOTimeGPS)); for (i=0;i<Nfiles;i++) filenames[i] = LALCalloc(512,sizeof(char)); for (i=0;i<Nfiles;i++) { sscanf(cache->lines->tokens[i],"%s %d %d",filenames[i],&(fileStart.data[i].gpsSeconds),&(fileStart.data[i].gpsNanoSeconds)); } XLALDestroyParsedDataFile( cache ); /* initialise the random number generator */ gsl_rng * r; if (XLALInitgslrand(&r,uvar.seed)) { LogPrintf(LOG_CRITICAL,"%s: XLALinitgslrand() failed with error = %d\n",__func__,xlalErrno); XLAL_ERROR(XLAL_EFAULT); } /* setup the binaryToSFT parameters */ BinaryToSFTparams par; par.tsft = uvar.tsft; par.freq = uvar.freq; par.freqband = uvar.freqband; par.tsamp = uvar.tsamp; par.highpassf = uvar.highpassf; par.amp_inj = uvar.amp_inj; par.f_inj = uvar.f_inj; par.asini_inj = uvar.asini_inj; XLALGPSSetREAL8(&(par.tasc_inj),uvar.tasc_inj); par.tref = fileStart.data[0]; par.P_inj = uvar.P_inj; par.phi_inj = uvar.phi_inj; par.r = r; /**********************************************************************************/ /* loop over the input files */ long int ntot = 0; for (j=0;j<Nfiles;j++) { UINT4 k = 0; INT8Vector *np = NULL; REAL8Vector *R = NULL; par.tstart = fileStart.data[j]; REAL8 norm1 = par.tsamp/par.tsft; REAL8 norm2 = 1.0/(par.tsamp*par.tsft); UINT4 oldlen; if (SFTvect==NULL) oldlen = 0; else oldlen = SFTvect->length; LogPrintf(LOG_DEBUG,"%s : working on file %s\n",__func__,filenames[j]); if (XLALBinaryToSFTVector(&SFTvect,filenames[j],&(fileStart.data[j]),&par,&np,&R)) { LogPrintf(LOG_CRITICAL,"%s : failed to convert binary input file %s to sfts\n",__func__,filenames[j]); return 1; } if ((np!=NULL) && (R!=NULL)) { for (k=0;k<np->length;k++) { ntot += np->data[k]; char temp[64]; sprintf(temp,"%d %e %e\n",SFTvect->data[oldlen+k].epoch.gpsSeconds,(REAL8)np->data[k]*norm1,R->data[k]*norm2); noisestr = (char *)XLALRealloc(noisestr,sizeof(char)*(1+strlen(noisestr)+strlen(temp))); strcat(noisestr,temp); } XLALDestroyINT8Vector(np); XLALDestroyREAL8Vector(R); } } /* end loop over input files */ /**********************************************************************************/ /* create a noise string */ /**********************************************************************************/ /* generate comment string */ char *VCSInfoString = XLALGetVersionString(0); XLAL_CHECK ( VCSInfoString != NULL, XLAL_EFUNC, "XLALGetVersionString(0) failed.\n" ); CHAR *logstr; size_t len; XLAL_CHECK ( (logstr = XLALUserVarGetLog ( UVAR_LOGFMT_CMDLINE )) != NULL, XLAL_EFUNC ); char *comment = XLALCalloc ( 1, len = strlen ( logstr ) + strlen(VCSInfoString) + strlen(noisestr) + 512 ); XLAL_CHECK ( comment != NULL, XLAL_ENOMEM, "XLALCalloc(1,%zd) failed.\n", len ); sprintf ( comment, "Generated by:\n%s\n%s\nTotal number of photons = %ld\n%s\n", logstr, VCSInfoString, ntot, noisestr ); /**********************************************************************************/ /* either write whole SFT-vector to single concatenated file */ if ( uvar.outSingleSFT ) { XLAL_CHECK ( XLALWriteSFTVector2File( SFTvect, uvar.outputdir, comment, uvar.outLabel ) == XLAL_SUCCESS, XLAL_EFUNC ); } else { /* or as individual SFT-files */ XLAL_CHECK ( XLALWriteSFTVector2Dir( SFTvect, uvar.outputdir, comment, uvar.outLabel ) == XLAL_SUCCESS, XLAL_EFUNC ); } /**********************************************************************************/ /* free memory */ XLALDestroySFTVector(SFTvect); XLALFree(logstr); XLALFree(comment); XLALFree(noisestr); LALCheckMemoryLeaks(); return 0; }
/** * basic initializations: deal with user input and return standardized 'ConfigVariables' */ int XLALInitCode ( ConfigVariables *cfg, const UserVariables_t *uvar, const char *app_name) { XLAL_CHECK ( cfg && uvar && app_name, XLAL_EINVAL, "Illegal NULL pointer input." ); /* init ephemeris data */ XLAL_CHECK ( ( cfg->edat = XLALInitBarycenter( uvar->ephemEarth, uvar->ephemSun ) ) != NULL, XLAL_EFUNC, "XLALInitBarycenter failed: could not load Earth ephemeris '%s' and Sun ephemeris '%s.", uvar->ephemEarth, uvar->ephemSun); cfg->numDetectors = uvar->IFOs->length; cfg->numTimeStamps = 0; XLAL_CHECK ( (cfg->numTimeStampsX = XLALCreateUINT4Vector ( cfg->numDetectors )) != NULL, XLAL_EFUNC, "XLALCreateREAL8Vector(%d) failed.", cfg->numDetectors ); BOOLEAN haveTimeGPS = XLALUserVarWasSet( &uvar->timeGPS ); BOOLEAN haveTimeStampsFile = XLALUserVarWasSet( &uvar->timeStampsFile ); BOOLEAN haveTimeStampsFiles = XLALUserVarWasSet( &uvar->timeStampsFiles ); XLAL_CHECK ( !(haveTimeStampsFiles && haveTimeStampsFile), XLAL_EINVAL, "Can't handle both timeStampsFiles and (deprecated) haveTimeStampsFiles input options." ); XLAL_CHECK ( !(haveTimeGPS && haveTimeStampsFile), XLAL_EINVAL, "Can't handle both (deprecated) timeStampsFile and timeGPS input options." ); XLAL_CHECK ( !(haveTimeGPS && haveTimeStampsFiles), XLAL_EINVAL, "Can't handle both timeStampsFiles and timeGPS input options." ); XLAL_CHECK ( haveTimeGPS || haveTimeStampsFiles || haveTimeStampsFile, XLAL_EINVAL, "Need either timeStampsFiles or timeGPS input option." ); if ( haveTimeStampsFiles ) { XLAL_CHECK ( (uvar->timeStampsFiles->length == 1 ) || ( uvar->timeStampsFiles->length == cfg->numDetectors ), XLAL_EINVAL, "Length of timeStampsFiles list is neither 1 (one file for all detectors) nor does it match the number of detectors. (%d != %d)", uvar->timeStampsFiles->length, cfg->numDetectors ); XLAL_CHECK ( (uvar->timeStampsFiles->length == 1 ) || !uvar->outab, XLAL_EINVAL, "At the moment, can't produce a(t), b(t) output (--outab) when given per-IFO --timeStampsFiles."); } if ( haveTimeStampsFiles && ( uvar->timeStampsFiles->length == cfg->numDetectors ) ) { XLAL_CHECK ( ( cfg->multiTimestamps = XLALReadMultiTimestampsFiles ( uvar->timeStampsFiles ) ) != NULL, XLAL_EFUNC ); XLAL_CHECK ( (cfg->multiTimestamps->length > 0) && (cfg->multiTimestamps->data != NULL), XLAL_EINVAL, "Got empty timestamps-list from '%s'.", uvar->timeStampsFiles ); } else { /* prepare multiTimestamps structure */ UINT4 nTS = 0; XLAL_CHECK ( ( cfg->multiTimestamps = XLALCalloc ( 1, sizeof(*cfg->multiTimestamps))) != NULL, XLAL_ENOMEM, "Allocating multiTimestamps failed." ); XLAL_CHECK ( ( cfg->multiTimestamps->data = XLALCalloc ( cfg->numDetectors, sizeof(cfg->multiTimestamps->data) )) != NULL, XLAL_ENOMEM, "Allocating multiTimestamps->data failed." ); cfg->multiTimestamps->length = cfg->numDetectors; if ( haveTimeGPS ) { /* set up timestamps vector from timeGPS, use same for all IFOs */ nTS = uvar->timeGPS->length; XLAL_CHECK ( (cfg->multiTimestamps->data[0] = XLALCreateTimestampVector ( nTS ) ) != NULL, XLAL_EFUNC, "XLALCreateTimestampVector( %d ) failed.", nTS ); /* convert input REAL8 times into LIGOTimeGPS for first detector */ for (UINT4 t = 0; t < nTS; t++) { REAL8 temp_real8_timestamp = 0; XLAL_CHECK ( 1 == sscanf ( uvar->timeGPS->data[t], "%" LAL_REAL8_FORMAT, &temp_real8_timestamp ), XLAL_EINVAL, "Illegal REAL8 commandline argument to --timeGPS[%d]: '%s'", t, uvar->timeGPS->data[t] ); XLAL_CHECK ( XLALGPSSetREAL8( &cfg->multiTimestamps->data[0]->data[t], temp_real8_timestamp ) != NULL, XLAL_EFUNC, "Failed to convert input GPS %g into LIGOTimeGPS", temp_real8_timestamp ); } // for (UINT4 t = 0; t < nTS; t++) } // if ( haveTimeGPS ) else { // haveTimeStampsFiles || haveTimeStampsFile CHAR *singleTimeStampsFile = NULL; if ( haveTimeStampsFiles ) { singleTimeStampsFile = uvar->timeStampsFiles->data[0]; } else if ( haveTimeStampsFile ) { singleTimeStampsFile = uvar->timeStampsFile; } XLAL_CHECK ( ( cfg->multiTimestamps->data[0] = XLALReadTimestampsFile ( singleTimeStampsFile ) ) != NULL, XLAL_EFUNC ); nTS = cfg->multiTimestamps->data[0]->length; } // else: haveTimeStampsFiles || haveTimeStampsFile /* copy timestamps from first detector to all others */ if ( cfg->numDetectors > 1 ) { for ( UINT4 X=1; X < cfg->numDetectors; X++ ) { XLAL_CHECK ( (cfg->multiTimestamps->data[X] = XLALCreateTimestampVector ( nTS ) ) != NULL, XLAL_EFUNC, "XLALCreateTimestampVector( %d ) failed.", nTS ); for (UINT4 t = 0; t < nTS; t++) { cfg->multiTimestamps->data[X]->data[t].gpsSeconds = cfg->multiTimestamps->data[0]->data[t].gpsSeconds; cfg->multiTimestamps->data[X]->data[t].gpsNanoSeconds = cfg->multiTimestamps->data[0]->data[t].gpsNanoSeconds; } // for (UINT4 t = 0; t < nTS; t++) } // for ( UINT4 X=1; X < cfg->numDetectors X++ ) } // if ( cfg->numDetectors > 1 ) } // if !( haveTimeStampsFiles && ( uvar->timeStampsFiles->length == cfg->numDetectors ) ) for ( UINT4 X=0; X < cfg->numDetectors; X++ ) { cfg->numTimeStampsX->data[X] = cfg->multiTimestamps->data[X]->length; cfg->numTimeStamps += cfg->numTimeStampsX->data[X]; } /* convert detector names into site-info */ MultiLALDetector multiDet; XLAL_CHECK ( XLALParseMultiLALDetector ( &multiDet, uvar->IFOs ) == XLAL_SUCCESS, XLAL_EFUNC ); /* get detector states */ XLAL_CHECK ( (cfg->multiDetStates = XLALGetMultiDetectorStates ( cfg->multiTimestamps, &multiDet, cfg->edat, 0.5 * uvar->Tsft )) != NULL, XLAL_EFUNC, "XLALGetDetectorStates() failed." ); BOOLEAN haveAlphaDelta = ( XLALUserVarWasSet(&uvar->Alpha) && XLALUserVarWasSet(&uvar->Delta) ); BOOLEAN haveSkyGrid = XLALUserVarWasSet( &uvar->skyGridFile ); XLAL_CHECK ( !(haveAlphaDelta && haveSkyGrid), XLAL_EINVAL, "Can't handle both Alpha/Delta and skyGridFile input options." ); XLAL_CHECK ( haveAlphaDelta || haveSkyGrid, XLAL_EINVAL, "Need either Alpha/Delta or skyGridFile input option." ); if (haveAlphaDelta) { /* parse this into one-element Alpha, Delta vectors */ XLAL_CHECK ( (cfg->Alpha = XLALCreateREAL8Vector ( 1 )) != NULL, XLAL_EFUNC, "XLALCreateREAL8Vector(1) failed." ); cfg->Alpha->data[0] = uvar->Alpha; XLAL_CHECK ( (cfg->Delta = XLALCreateREAL8Vector ( 1 )) != NULL, XLAL_EFUNC, "XLALCreateREAL8Vector(1) failed." ); cfg->Delta->data[0] = uvar->Delta; cfg->numSkyPoints = 1; } // if (haveAlphaDelta) else if ( haveSkyGrid ) { LALParsedDataFile *data = NULL; XLAL_CHECK ( XLALParseDataFile (&data, uvar->skyGridFile) == XLAL_SUCCESS, XLAL_EFUNC, "Failed to parse data file '%s'.", uvar->skyGridFile ); cfg->numSkyPoints = data->lines->nTokens; XLAL_CHECK ( (cfg->Alpha = XLALCreateREAL8Vector ( cfg->numSkyPoints )) != NULL, XLAL_EFUNC, "XLALCreateREAL8Vector( %d ) failed.", cfg->numSkyPoints ); XLAL_CHECK ( (cfg->Delta = XLALCreateREAL8Vector ( cfg->numSkyPoints )) != NULL, XLAL_EFUNC, "XLALCreateREAL8Vector( %d ) failed.", cfg->numSkyPoints ); for (UINT4 n=0; n < cfg->numSkyPoints; n++) { XLAL_CHECK ( 2 == sscanf( data->lines->tokens[n], "%" LAL_REAL8_FORMAT "%" LAL_REAL8_FORMAT, &cfg->Alpha->data[n], &cfg->Delta->data[n] ), XLAL_EDATA, "Could not parse 2 numbers from line %d in candidate-file '%s':\n'%s'", n, uvar->skyGridFile, data->lines->tokens[n] ); } // for (UINT4 n=0; n < cfg->numSkyPoints; n++) XLALDestroyParsedDataFile ( data ); } // else if ( haveSkyGrid ) if ( uvar->noiseSqrtShX ) { /* translate user-input PSD sqrt(SX) to noise-weights (this actually does not care whether they were normalized or not) */ if ( uvar->noiseSqrtShX->length != cfg->numDetectors ) { fprintf(stderr, "Length of noiseSqrtShX vector does not match number of detectors! (%d != %d)\n", uvar->noiseSqrtShX->length, cfg->numDetectors); XLAL_ERROR ( XLAL_EINVAL ); } REAL8Vector *noiseSqrtShX = NULL; if ( (noiseSqrtShX = XLALCreateREAL8Vector ( cfg->numDetectors )) == NULL ) { fprintf(stderr, "Failed call to XLALCreateREAL8Vector( %d )\n", cfg->numDetectors ); XLAL_ERROR ( XLAL_EFUNC ); } REAL8 psd_normalization = 0; for (UINT4 X = 0; X < cfg->numDetectors; X++) { if ( 1 != sscanf ( uvar->noiseSqrtShX->data[X], "%" LAL_REAL8_FORMAT, &noiseSqrtShX->data[X] ) ) { fprintf(stderr, "Illegal REAL8 commandline argument to --noiseSqrtShX[%d]: '%s'\n", X, uvar->noiseSqrtShX->data[X]); XLAL_ERROR ( XLAL_EINVAL ); } if ( noiseSqrtShX->data[X] <= 0.0 ) { fprintf(stderr, "Non-positive input PSD ratio for detector X=%d: noiseSqrtShX[X]=%f\n", X, noiseSqrtShX->data[X] ); XLAL_ERROR ( XLAL_EINVAL ); } psd_normalization += 1.0/SQ(noiseSqrtShX->data[X]); } /* for X < cfg->numDetectors */ psd_normalization = (REAL8)cfg->numDetectors/psd_normalization; /* S = NSFT / sum S_Xalpha^-1, no per-SFT variation here -> S = Ndet / sum S_X^-1 */ /* create multi noise weights */ if ( (cfg->multiNoiseWeights = XLALCalloc(1, sizeof(*cfg->multiNoiseWeights))) == NULL ) { XLALPrintError ("%s: failed to XLALCalloc ( 1, %d )\n", __func__, sizeof(*cfg->multiNoiseWeights) ); XLAL_ERROR ( XLAL_ENOMEM ); } if ( (cfg->multiNoiseWeights->data = XLALCalloc(cfg->numDetectors, sizeof(*cfg->multiNoiseWeights->data))) == NULL ) { XLALPrintError ("%s: failed to XLALCalloc ( %d, %d )\n", __func__, cfg->numDetectors, sizeof(*cfg->multiNoiseWeights->data) ); XLAL_ERROR ( XLAL_ENOMEM ); } cfg->multiNoiseWeights->length = cfg->numDetectors; for (UINT4 X = 0; X < cfg->numDetectors; X++) { REAL8 noise_weight_X = psd_normalization/SQ(noiseSqrtShX->data[X]); /* w_Xalpha = S_Xalpha^-1/S^-1 = S / S_Xalpha */ /* create k^th weights vector */ if( ( cfg->multiNoiseWeights->data[X] = XLALCreateREAL8Vector ( cfg->numTimeStampsX->data[X] ) ) == NULL ) { /* free weights vectors created previously in loop */ XLALDestroyMultiNoiseWeights ( cfg->multiNoiseWeights ); XLAL_ERROR ( XLAL_EFUNC, "Failed to allocate noiseweights for IFO X = %d\n", X ); } /* if XLALCreateREAL8Vector() failed */ /* loop over rngmeds and calculate weights -- one for each sft */ for ( UINT4 alpha = 0; alpha < cfg->numTimeStampsX->data[X]; alpha++) { cfg->multiNoiseWeights->data[X]->data[alpha] = noise_weight_X; } } /* for X < cfg->numDetectors */ XLALDestroyREAL8Vector ( noiseSqrtShX ); } /* if ( uvar->noiseSqrtShX ) */ else { cfg->multiNoiseWeights = NULL; } return XLAL_SUCCESS; } /* XLALInitCode() */
/** * An XLAL interface for reading a time correction file containing a table * of values for converting between Terrestrial Time TT (or TDT) to either * TDB (i.e. the file contains time corrections related to the Einstein delay) * or Teph (a time system from Irwin and Fukushima, 1999, closely related to * Coordinate Barycentric Time, TCB) depending on the file. * * The file contains a header with the GPS start time, GPS end time, time * interval between subsequent entries (seconds), and the number of entries. * * The rest of the file contains a list of the time delays (in seconds). * * The tables for the conversion to TDB and Teph are derived from the ephemeris * file TDB.1950.2050 and TIMEEPH_short.te405 within TEMPO2 * http://www.atnf.csiro.au/research/pulsar/tempo2/. They are created from the * Chebychev polynomials in these files using the conversion in the lalapps code * lalapps_create_time_correction_ephemeris * * \ingroup LALBarycenter_h */ TimeCorrectionData * XLALInitTimeCorrections ( const CHAR *timeCorrectionFile /**< File containing Earth's position. */ ) { REAL8 *tvec = NULL; /* create time vector */ LALParsedDataFile *flines = NULL; UINT4 numLines = 0, j = 0; REAL8 endtime = 0.; /* check user input consistency */ if ( !timeCorrectionFile ) XLAL_ERROR_NULL( XLAL_EINVAL, "Invalid NULL input for 'timeCorrectionFile'\n" ); char *fname_path; XLAL_CHECK_NULL ( (fname_path = XLALPulsarFileResolvePath ( timeCorrectionFile )) != NULL, XLAL_EINVAL ); /* read in file with XLALParseDataFile to ignore comment header lines */ if ( XLALParseDataFile ( &flines, fname_path ) != XLAL_SUCCESS ) { XLALFree ( fname_path ); XLAL_ERROR_NULL ( XLAL_EFUNC ); } XLALFree ( fname_path ); /* prepare output ephemeris struct for returning */ TimeCorrectionData *tdat; if ( ( tdat = XLALCalloc ( 1, sizeof(*tdat) ) ) == NULL ) XLAL_ERROR_NULL ( XLAL_ENOMEM, "XLALCalloc ( 1, %zu ) failed.\n", sizeof(*tdat) ); numLines = flines->lines->nTokens; /* read in info from first line (an uncommented header) */ if ( 4 != sscanf(flines->lines->tokens[0], "%lf %lf %lf %u", &tdat->timeCorrStart, &endtime, &tdat->dtTtable, &tdat->nentriesT) ) { XLALDestroyParsedDataFile ( flines ); XLALDestroyTimeCorrectionData( tdat ); XLAL_ERROR_NULL ( XLAL_EDOM, "Couldn't parse first line of %s\n", timeCorrectionFile ); } if( numLines - 1 != tdat->nentriesT ) { XLALDestroyParsedDataFile ( flines ); XLALDestroyTimeCorrectionData( tdat ); XLAL_ERROR_NULL ( XLAL_EDOM, "Header says file has '%d' data-lines, but found '%d'.\n", tdat->nentriesT, numLines -1 ); } /* allocate memory for table entries */ if ( (tvec = XLALCalloc( tdat->nentriesT, sizeof(REAL8) )) == NULL ) { XLALDestroyParsedDataFile ( flines ); XLALDestroyTimeCorrectionData( tdat ); XLAL_ERROR_NULL ( XLAL_ENOMEM, " XLALCalloc(%u, sizeof(REAL8))\n", tdat->nentriesT ); } /* read in table data */ int ret; for (j=1; j < numLines; j++) { if ( (ret = sscanf( flines->lines->tokens[j], "%lf", &tvec[j-1] )) != 1 ) { XLALFree( tvec ); XLALDestroyParsedDataFile ( flines ); XLALDestroyTimeCorrectionData( tdat ); XLAL_ERROR_NULL ( XLAL_EDOM, "Couldn't parse line %d of %s: read %d instead of 1\n", j+2, timeCorrectionFile, ret); } } // for j < numLines XLALDestroyParsedDataFile ( flines ); /* set output time delay vector */ tdat->timeCorrs = tvec; return tdat; } /* XLALInitTimeCorrections() */
/** * XLAL function to read ephemeris-data from one file, returning a EphemerisVector. * This is a helper-function to XLALInitBarycenter(). * * NOTE: This function tries to read ephemeris from "<fname>" first, if that fails it also tries * to read "<fname>.gz" instead. This allows us to handle gzip-compressed ephemeris-files without having * to worry about the detailed filename extension used in the case of compression. * * NOTE2: files are searches first locally, then in LAL_DATA_PATH, and finally in PKG_DATA_DIR * using XLALPulsarFileResolvePath() */ EphemerisVector * XLALReadEphemerisFile ( const CHAR *fname ) { /* check input consistency */ XLAL_CHECK_NULL ( fname != NULL, XLAL_EINVAL ); char *fname_path = NULL; // first check if "<fname>" can be resolved ... if ( (fname_path = XLALPulsarFileResolvePath ( fname )) == NULL ) { // if not, check if we can find "<fname>.gz" instead ... char *fname_gz; XLAL_CHECK_NULL ( (fname_gz = XLALMalloc ( strlen(fname) + strlen(".gz") + 1 )) != NULL, XLAL_ENOMEM ); sprintf ( fname_gz, "%s.gz", fname ); if ( (fname_path = XLALPulsarFileResolvePath ( fname_gz )) == NULL ) { XLALFree ( fname_gz ); XLAL_ERROR_NULL ( XLAL_EINVAL, "Failed to find ephemeris-file '%s[.gz]'\n", fname ); } // if 'fname_gz' could not be resolved XLALFree ( fname_gz ); } // if 'fname' couldn't be resolved // if we're here, it means we found it // read in whole file (compressed or not) with XLALParseDataFile(), which ignores comment header lines LALParsedDataFile *flines = NULL; XLAL_CHECK_NULL ( XLALParseDataFile ( &flines, fname_path ) == XLAL_SUCCESS, XLAL_EFUNC ); XLALFree ( fname_path ); UINT4 numLines = flines->lines->nTokens; INT4 gpsYr; /* gpsYr + leap is the time on the GPS clock * at first instant of new year, UTC; equivalently * leap is # of leap secs added between Jan.6, 1980 and * Jan. 2 of given year */ REAL8 dt; /* ephemeris-file time-step in seconds */ UINT4 nEntries; /* number of ephemeris-file entries */ /* read first line */ if ( 3 != sscanf(flines->lines->tokens[0],"%d %le %u\n", &gpsYr, &dt, &nEntries)) { XLALDestroyParsedDataFile( flines ); XLAL_ERROR_NULL ( XLAL_EDOM, "Couldn't parse first line of %s\n", fname ); } /* check that number of lines is correct */ if( nEntries != (numLines - 1)/4 ) { XLALDestroyParsedDataFile( flines ); XLAL_ERROR_NULL ( XLAL_EDOM, "Inconsistent number of data-lines (%d) in file '%s' compared to header information (%d)\n", (numLines - 1)/4, fname, nEntries); } /* prepare output ephemeris vector */ EphemerisVector *ephemV; if ( (ephemV = XLALCreateEphemerisVector ( nEntries )) == NULL ) XLAL_ERROR_NULL ( XLAL_EFUNC, "Failed to XLALCreateEphemerisVector(%d)\n", nEntries ); ephemV->dt = dt; /* first column in ephemeris-file is gps time--one long integer * giving the number of secs that have ticked since start of GPS epoch * + on 1980 Jan. 6 00:00:00 UTC */ /* the ephemeris files are created with each entry spanning 4 lines with the * format: * gps\tposX\tposY\n * posZ\tvelX\tvelY\n * velZ\taccX\taccY\n * accZ\n ***************************************************************************/ /* read the remaining lines */ for ( UINT4 j = 0; j < nEntries; j++ ) { UINT4 i_line; int ret; i_line = 1 + 4*j; ret = sscanf( flines->lines->tokens[ i_line ], "%le %le %le\n", &ephemV->data[j].gps, &ephemV->data[j].pos[0], &ephemV->data[j].pos[1] ); XLAL_CHECK_NULL ( ret == 3, XLAL_EDOM, "Couldn't parse line %d of %s: read %d items instead of 3\n", i_line, fname, ret ); i_line ++; ret = sscanf( flines->lines->tokens[ i_line ], "%le %le %le\n", &ephemV->data[j].pos[2], &ephemV->data[j].vel[0], &ephemV->data[j].vel[1] ); XLAL_CHECK_NULL ( ret == 3, XLAL_EDOM, "Couldn't parse line %d of %s: read %d items instead of 3\n", i_line, fname, ret ); i_line ++; ret = sscanf( flines->lines->tokens[ i_line ], "%le %le %le\n", &ephemV->data[j].vel[2], &ephemV->data[j].acc[0], &ephemV->data[j].acc[1] ); XLAL_CHECK_NULL ( ret == 3, XLAL_EDOM, "Couldn't parse line %d of %s: read %d items instead of 3\n", i_line, fname, ret ); i_line ++; ret = sscanf( flines->lines->tokens[ i_line ], "%le\n", &ephemV->data[j].acc[2] ); XLAL_CHECK_NULL ( ret == 1, XLAL_EDOM, "Couldn't parse line %d of %s: read %d items instead of 1\n", i_line, fname, ret ); /* check timestamps */ if(j == 0) { if (gpsYr - ephemV->data[j].gps > 3600 * 24 * 365 ) { XLALDestroyEphemerisVector ( ephemV ); XLALDestroyParsedDataFile( flines ); XLAL_ERROR_NULL ( XLAL_EDOM, "Wrong timestamp in line %d of %s: %d/%le\n", j+2, fname, gpsYr, ephemV->data[j].gps ); } } else { if (ephemV->data[j].gps != ephemV->data[j-1].gps + ephemV->dt ) { XLALDestroyEphemerisVector ( ephemV ); XLALDestroyParsedDataFile( flines ); XLAL_ERROR_NULL ( XLAL_EDOM, "Wrong timestamp in line %d of %s: %le/%le\n", j+2, fname, ephemV->data[j].gps, ephemV->data[j-1].gps + ephemV->dt ); } } } /* for j < nEntries */ XLALDestroyParsedDataFile( flines ); /* return result */ return ephemV; } /* XLALReadEphemerisFile() */
void LALReadNRWave_raw(LALStatus *status, /**< pointer to LALStatus structure */ REAL4TimeVectorSeries **out, /**< [out] output time series for h+ and hx */ const CHAR *filename /**< [in] File containing numrel waveform */) { UINT4 length, k, r; REAL4TimeVectorSeries *ret=NULL; REAL4VectorSequence *data=NULL; REAL4Vector *timeVec=NULL; LALParsedDataFile *cfgdata=NULL; REAL4 tmp1, tmp2, tmp3; INITSTATUS(status); ATTATCHSTATUSPTR (status); /* some consistency checks */ ASSERT (filename != NULL, status, NRWAVEIO_ENULL, NRWAVEIO_MSGENULL ); ASSERT ( out != NULL, status, NRWAVEIO_ENULL, NRWAVEIO_MSGENULL ); ASSERT ( *out == NULL, status, NRWAVEIO_ENONULL, NRWAVEIO_MSGENONULL ); if ( XLALParseDataFile ( &cfgdata, filename) != XLAL_SUCCESS ) { ABORT( status, NRWAVEIO_EFILE, NRWAVEIO_MSGEFILE ); } length = cfgdata->lines->nTokens; /*number of data points */ /* allocate memory */ ret = LALCalloc(1, sizeof(*ret)); if (!ret) { ABORT( status, NRWAVEIO_ENOMEM, NRWAVEIO_MSGENOMEM ); } strcpy(ret->name,filename); ret->f0 = 0; data = XLALCreateREAL4VectorSequence (2, length); if (!data) { ABORT( status, NRWAVEIO_ENOMEM, NRWAVEIO_MSGENOMEM ); } timeVec = XLALCreateREAL4Vector (length); if (!timeVec) { ABORT( status, NRWAVEIO_ENOMEM, NRWAVEIO_MSGENOMEM ); } /* now get the data */ for (k = 0; k < length; k++) { r = sscanf(cfgdata->lines->tokens[k], "%f%f%f", &tmp1, &tmp2, &tmp3); /* Check the data file format */ if ( r != 3) { /* there must be exactly 3 data entries -- time, h+, hx */ ABORT( status, NRWAVEIO_EFORMAT, NRWAVEIO_MSGEFORMAT ); } timeVec->data[k] = tmp1; data->data[k] = tmp2; data->data[data->vectorLength + k] = tmp3; } /* scale time */ ret->deltaT = timeVec->data[1] - timeVec->data[0]; /* might also want to go through timeVec to make sure it is evenly spaced */ ret->data = data; (*out) = ret; XLALDestroyREAL4Vector (timeVec); XLALDestroyParsedDataFile ( cfgdata); DETATCHSTATUSPTR(status); RETURN(status); } /* LALReadNRWave() */
/** * Read config-variables from cfgfile and parse into input-structure. * An error is reported if the config-file reading fails, but the * individual variable-reads are treated as optional * * If \p *should_exit is TRUE when this function returns, the * caller should exit immediately. */ int XLALUserVarReadCfgfile ( BOOLEAN *should_exit, const CHAR *cfgfile ) { XLAL_CHECK ( should_exit != NULL, XLAL_EFAULT ); XLAL_CHECK ( cfgfile != NULL, XLAL_EINVAL ); XLAL_CHECK ( UVAR_vars.next != NULL, XLAL_EINVAL, "No memory allocated in UVAR_vars.next, did you register any user-variables?\n" ); *should_exit = 0; LALParsedDataFile *cfg = NULL; XLAL_CHECK ( XLALParseDataFile ( &cfg, cfgfile ) == XLAL_SUCCESS, XLAL_EFUNC ); // step through all user-variable: read those with names from config-file LALUserVariable *ptr = &UVAR_vars; while ( (ptr=ptr->next) != NULL) { XLAL_CHECK ( (ptr->type > UVAR_TYPE_START) && (ptr->type < UVAR_TYPE_END), XLAL_EFAILED, "Invalid UVAR_TYPE '%d' outside of [%d,%d]\n", ptr->type, UVAR_TYPE_START+1, UVAR_TYPE_END-1 ); BOOLEAN wasRead; CHAR *valString = NULL; // first read the value as a string XLAL_CHECK ( XLALReadConfigSTRINGVariable ( &valString, cfg, NULL, ptr->name, &wasRead ) == XLAL_SUCCESS, XLAL_EFUNC ); if ( wasRead ) // if successful, parse this as the desired type { // destroy previous value, is applicable, then parse new one if ( UserVarTypeMap [ ptr->type ].destructor != NULL ) { UserVarTypeMap [ ptr->type ].destructor( *(char**)ptr->varp ); *(char**)ptr->varp = NULL; } // if a destructor was registered if ( UserVarTypeMap [ ptr->type ].parser( ptr->varp, valString ) != XLAL_SUCCESS ) { XLALPrintError( "\n%s: could not parse value given to option " UVAR_FMT "\n\n", program_name, ptr->name ); *should_exit = 1; return XLAL_SUCCESS; } XLALFree (valString); switch ( ptr->was_set ) { case 0: // this variable has not been set; mark as set in configuration file ptr->was_set = 1; break; default: // this variable has been set before; error XLALUserVarCheck( should_exit, 0, "configuration option `%s' was set more than once!", ptr->name ); return XLAL_SUCCESS; } } // if wasRead } // while ptr->next // ok, that should be it: check if there were more definitions we did not read UINT4Vector *unread = XLALConfigFileGetUnreadEntries ( cfg ); XLAL_CHECK ( xlalErrno == 0, XLAL_EFUNC, "XLALConfigFileGetUnreadEntries() failed\n"); if ( unread != NULL ) { XLALPrintWarning ("The following entries in config-file '%s' have not been parsed:\n", cfgfile ); for ( UINT4 i = 0; i < unread->length; i ++ ) { XLALPrintWarning ("%s\n", cfg->lines->tokens[ unread->data[i] ] ); } XLALDestroyUINT4Vector ( unread ); } XLALDestroyParsedDataFile ( cfg ); return XLAL_SUCCESS; } // XLALUserVarReadCfgfile()