/** 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 */
FILE *cachefp = NULL;
if ((cachefp = fopen(uvar.cachefile,"r")) == NULL) {
LogPrintf(LOG_CRITICAL,"%s : failed to open binary input file %s\n",__func__,uvar.cachefile);
return 1;
}
i = 0;
while (fscanf(cachefp,"%*s %*d %*d")!=EOF) i++;
INT4 Nfiles = i;
fclose(cachefp);
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));
if ((cachefp = fopen(uvar.cachefile,"r")) == NULL) {
LogPrintf(LOG_CRITICAL,"%s : failed to open binary input file %s\n",__func__,uvar.cachefile);
return 1;
}
for (i=0;i<Nfiles;i++) {
fscanf(cachefp,"%s %d %d %*d",filenames[i],&(fileStart.data[i].gpsSeconds),&(fileStart.data[i].gpsNanoSeconds));
}
fclose(cachefp);
/* 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;
}
/** The main function of Intermittent.c
*
*/
int main( int argc, char *argv[] )
{
UserInput_t uvar = empty_UserInput; /* user input variables */
INT4 i, k, m; /* counter */
CHAR newtemp[LONGSTRINGLENGTH];
FILE *ifp = NULL;
CHAR *clargs = NULL; /* store the command line args */
/**********************************************************************************/
/* 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;
}
if ( uvar.verbose ) {
fprintf( stdout, "%s : read in uservars\n", __func__ );
}
/**********************************************************************************/
/* make temporary directory */
if ( uvar.tempdir ) {
/* initialise the random number generator - use the clock */
gsl_rng *q;
if ( XLALInitgslrand( &q, 0 ) ) {
LogPrintf( LOG_CRITICAL, "%s: XLALinitgslrand() failed with error = %d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFAULT );
}
INT4 id = ( INT4 )( 1e9 * gsl_rng_uniform( q ) );
sprintf( newtemp, "%s/%09d", uvar.tempdir, id );
fprintf( stdout, "temp dir = %s\n", newtemp );
if ( mkdir( newtemp, 0755 ) ) {
if ( uvar.verbose ) {
fprintf( stdout, "%s : Unable to make temporary directory %s. Might be a problem.\n", __func__, newtemp );
}
return 1;
}
}
/**********************************************************************************/
/* read in the cache file and find the correct entry for the binary file */
FILE *cachefp = NULL;
if ( ( cachefp = fopen( uvar.cachefile, "r" ) ) == NULL ) {
LogPrintf( LOG_CRITICAL, "%s : failed to open binary input file %s\n", __func__, uvar.cachefile );
return 1;
}
i = 0;
INT4 idx = -1;
CHAR filename[LONGSTRINGLENGTH];
CHAR dummy[LONGSTRINGLENGTH];
LIGOTimeGPS fileStart;
INT4 dummysec = 0;
INT4 dummynan = 0;
while ( fscanf( cachefp, "%s %d %d", dummy, &dummysec, &dummynan ) != EOF ) {
if ( strstr( dummy, uvar.binfile ) ) {
idx = i;
strcpy( filename, dummy );
fileStart.gpsSeconds = dummysec;
fileStart.gpsNanoSeconds = ( INT4 )1e9 * ( floor( 1e-9 * dummynan / uvar.tsamp + 0.5 ) * uvar.tsamp ); /* round to make sure we get samples at GPS seconds */
}
i++;
}
if ( idx < 0 ) {
LogPrintf( LOG_CRITICAL, "%s : failed to find binary input file %s in cache file %s\n", __func__, filename, uvar.cachefile );
return 1;
}
fclose( cachefp );
if ( uvar.verbose ) {
fprintf( stdout, "%s : found the requested binary file entry in the cache file.\n", __func__ );
}
/***********************************************************************************/
/* setup the fixed binaryToSFT parameters */
BinaryToSFTparams par;
par.tsamp = uvar.tsamp;
par.highpassf = uvar.highpassf;
par.amp_inj = 0.0;
par.f_inj = 0.0;
par.asini_inj = 0.0;
XLALGPSSetREAL8( &( par.tasc_inj ), 0 );
par.tref = fileStart;
par.P_inj = 0;
par.phi_inj = 0;
par.r = NULL;
/* setup the gridding over coherent times - which we make sure are integers */
INT4 dummyT = uvar.Tmin;
INT4 NT = 0;
while ( dummyT < uvar.Tmax ) {
dummyT = ( INT4 )( ( REAL8 )dummyT * ( 1.0 + uvar.mismatch ) );
NT++;
}
if ( uvar.verbose ) {
fprintf( stdout, "%s : Going to do %d different coherent lengths.\n", __func__, NT );
}
/**********************************************************************************/
/* OPEN INTERMEDIATE RESULTS FILE */
/**********************************************************************************/
CHAR intname[LONGSTRINGLENGTH];
if ( XLALOpenIntermittentResultsFile( &ifp, intname, newtemp, clargs, &uvar, &fileStart ) ) {
LogPrintf( LOG_CRITICAL, "%s : XLALOpenCoherentResultsFile() failed with error = %d\n", __func__, xlalErrno );
return 1;
}
if ( uvar.verbose ) {
fprintf( stdout, "%s : opened coherent results file %s.\n", __func__, intname );
}
/**********************************************************************************/
/* loop over the different coherent lengths */
INT4 currentT = uvar.Tmin;
for ( i = 0; i < NT; i++ ) {
if ( uvar.verbose ) {
fprintf( stdout, "%s : working on segment length %d/%d using a segment time of %d sec\n", __func__, i, NT, currentT );
}
/* define SFT frequency bounds */
REAL8 wings = LAL_TWOPI * uvar.maxasini / uvar.minorbperiod;
REAL8 fmin_read = MINBAND * floor( ( uvar.freq - WINGS_FACTOR * uvar.freq * wings - ( REAL8 )uvar.blocksize / ( REAL8 )uvar.Tmin ) / MINBAND );
REAL8 fmax_read = MINBAND * ceil( ( uvar.freq + ( REAL8 )uvar.blocksize / ( REAL8 )uvar.Tmin + uvar.freqband + WINGS_FACTOR * ( uvar.freq + uvar.freqband ) * wings ) / MINBAND );
REAL8 fband_read = fmax_read - fmin_read;
if ( uvar.verbose ) {
fprintf( stdout, "%s : reading in SFT frequency band [%f -> %f]\n", __func__, fmin_read, fmax_read );
}
/* define the number of different start times */
INT4 Ns = ceil( 1.0 / uvar.mismatch );
INT4 Tstep = ( INT4 )floor( currentT / ( REAL8 )Ns );
if ( Tstep == 0 ) {
Ns = 1;
} else {
Ns = ( INT4 )ceil( ( REAL8 )currentT / ( REAL8 )Tstep );
}
if ( uvar.verbose ) {
fprintf( stdout, "%s : number of start times is %d and time step is %d sec\n", __func__, Ns, Tstep );
}
par.tsft = currentT;
par.freq = fmin_read;
par.freqband = fband_read;
/* loop over different start times - make sure they are integer GPS time for simplicity */
LIGOTimeGPS currentStart;
currentStart.gpsSeconds = ( INT4 )ceil( ( REAL8 )fileStart.gpsSeconds + 1e-9 * ( REAL8 )fileStart.gpsNanoSeconds );
currentStart.gpsNanoSeconds = 0;
for ( k = 0; k < Ns; k++ ) {
if ( uvar.verbose ) {
fprintf( stdout, "%s : working on offset start %d/%d using a start time of %d %d sec\n", __func__, k, Ns, currentStart.gpsSeconds, currentStart.gpsNanoSeconds );
}
memcpy( &( par.tstart ), ¤tStart, sizeof( LIGOTimeGPS ) );
ParameterSpace pspace = empty_ParameterSpace; /* the search parameter space */
COMPLEX8TimeSeriesArray *dstimevec = NULL; /* contains the downsampled inverse FFT'd SFTs */
REAL4DemodulatedPowerVector *dmpower = NULL; /* contains the demodulated power for all SFTs */
GridParametersVector *freqgridparams = NULL; /* the coherent grid on the frequency derivitive parameter space */
SFTVector *sftvec = NULL;
INT8Vector *np = NULL;
REAL8Vector *R = NULL;
/**********************************************************************************/
/* GENERATE SFTS FROM BINARY INPUT FILE */
/**********************************************************************************/
/* converts a binary input file into sfts */
if ( XLALBinaryToSFTVector( &sftvec, filename, &fileStart, &par, &np, &R ) ) {
LogPrintf( LOG_CRITICAL, "%s : failed to convert binary input file %s to sfts\n", __func__, uvar.binfile );
return 1;
}
XLALDestroyINT8Vector( np );
XLALDestroyREAL8Vector( R );
if ( uvar.verbose ) {
fprintf( stdout, "%s : generated SFTs for file %s\n", __func__, filename );
}
/* if we have any SFTs */
if ( sftvec->length > 0 ) {
/* define SFT length and the start and span of the observations plus the definitive segment time */
pspace.tseg = 1.0 / sftvec->data[0].deltaF;
memcpy( &( pspace.epoch ), &( sftvec->data[0].epoch ), sizeof( LIGOTimeGPS ) );
pspace.span = XLALGPSDiff( &( sftvec->data[sftvec->length - 1].epoch ), &( sftvec->data[0].epoch ) ) + pspace.tseg;
if ( uvar.verbose ) {
fprintf( stdout, "%s : SFT length = %f seconds\n", __func__, pspace.tseg );
fprintf( stdout, "%s : entire dataset starts at GPS time %d contains %d SFTS and spans %.0f seconds\n", __func__, pspace.epoch.gpsSeconds, sftvec->length, pspace.span );
}
/**********************************************************************************/
/* NORMALISE THE SFTS */
/**********************************************************************************/
/* compute the background noise using the sfts - this routine uses the running median at the edges to normalise the wings */
if ( XLALNormalizeSFTVect( sftvec, uvar.blocksize, 0 ) ) {
LogPrintf( LOG_CRITICAL, "%s : XLALNormaliseSFTVect() failed with error = %d\n", __func__, xlalErrno );
return 1;
}
if ( uvar.verbose ) {
fprintf( stdout, "%s : normalised the SFTs\n", __func__ );
}
/**********************************************************************************/
/* DEFINE THE BINARY PARAMETER SPACE */
/**********************************************************************************/
/* define the binary parameter space */
if ( XLALDefineBinaryParameterSpace( &( pspace.space ), pspace.epoch, pspace.span, &uvar ) ) {
LogPrintf( LOG_CRITICAL, "%s : XLALDefineBinaryParameterSpace() failed with error = %d\n", __func__, xlalErrno );
return 1;
}
if ( uvar.verbose ) {
fprintf( stdout, "%s : defined binary parameter prior space\n", __func__ );
}
/**********************************************************************************/
/* COMPUTE THE COARSE GRID ON FREQUENCY DERIVITIVES */
/**********************************************************************************/
/* compute the grid parameters for all SFTs */
INT4 ndim = -1;
if ( XLALComputeFreqGridParamsVector( &freqgridparams, pspace.space, sftvec, uvar.mismatch, &ndim, BINS_FACTOR ) ) {
LogPrintf( LOG_CRITICAL, "%s : XLALComputeFreqGridParams() failed with error = %d\n", __func__, xlalErrno );
return 1;
}
if ( uvar.verbose ) {
fprintf( stdout, "%s : computed the grid parameters for the sfts\n", __func__ );
}
/**********************************************************************************/
/* CONVERT ALL SFTS TO DOWNSAMPLED TIMESERIES */
/**********************************************************************************/
if ( XLALSFTVectorToCOMPLEX8TimeSeriesArray( &dstimevec, sftvec ) ) {
LogPrintf( LOG_CRITICAL, "%s : XLALSFTVectorToCOMPLEX8TimeSeriesArray() failed with error = %d\n", __func__, xlalErrno );
return 1;
}
if ( uvar.verbose ) {
fprintf( stdout, "%s : converted SFTs to downsampled timeseries\n", __func__ );
}
/**********************************************************************************/
/* COMPUTE THE STATISTICS ON THE COARSE GRID */
/**********************************************************************************/
/* compute the demodulated power on the frequency derivitive grid */
if ( XLALCOMPLEX8TimeSeriesArrayToDemodPowerVector( &dmpower, dstimevec, freqgridparams, ifp ) ) {
LogPrintf( LOG_CRITICAL, "%s : XLALCOMPLEX8TimeSeriesArrayToDemodPowerVector() failed with error = %d\n", __func__, xlalErrno );
return 1;
}
if ( uvar.verbose ) {
fprintf( stdout, "%s : computed the demodulated power\n", __func__ );
}
/**********************************************************************************/
/* FREE MEMORY */
/**********************************************************************************/
/* free memory inside the loop */
XLALFreeParameterSpace( &pspace );
XLALFreeREAL4DemodulatedPowerVector( dmpower );
for ( m = 0; m < ( INT4 )dstimevec->length; m++ ) {
XLALDestroyCOMPLEX8TimeSeries( dstimevec->data[m] );
}
XLALFree( dstimevec->data );
XLALFree( dstimevec );
for ( m = 0; m < ( INT4 )freqgridparams->length; m++ ) {
XLALFree( freqgridparams->segment[m]->grid );
XLALFree( freqgridparams->segment[m]->prod );
XLALFree( freqgridparams->segment[m] );
}
XLALFree( freqgridparams->segment );
XLALFree( freqgridparams );
if ( uvar.verbose ) {
fprintf( stdout, "%s : freed memory\n", __func__ );
}
XLALDestroySFTVector( sftvec );
} /* end if statement on whether we have SFTs */
/* update the start time of the segment */
XLALGPSAdd( ¤tStart, ( REAL8 )Tstep );
} /* end loop over start times */
/* update segment length */
currentT = ( INT4 )( ( REAL8 )currentT * ( 1.0 + uvar.mismatch ) );
} /* end loop over segment lengths */
/* move the temporary directory to the final location */
if ( uvar.tempdir ) {
CHAR newoutputfile[LONGSTRINGLENGTH];
snprintf( newoutputfile, LONGSTRINGLENGTH, "%s/IntermittentResults-%s-%d.txt", uvar.outputdir, uvar.outLabel, fileStart.gpsSeconds );
if ( rename( intname, newoutputfile ) ) {
LogPrintf( LOG_CRITICAL, "%s : unable to move final results file %s -> %s. Exiting.\n", __func__, intname, newoutputfile );
return 1;
}
}
/**********************************************************************************/
/* FREE MEMORY */
/**********************************************************************************/
fclose( ifp );
LALCheckMemoryLeaks();
return 0;
}