// ==================== function definitions ==================== int main(void) { // ---------- test angle conversions ---------- XLAL_CHECK_MAIN ( test_HMS_RAD() == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK_MAIN ( test_DMS_RAD() == XLAL_SUCCESS, XLAL_EFUNC ); // check for memory leaks LALCheckMemoryLeaks(); return EXIT_SUCCESS; } // main()
// ==================== function definitions ==================== int main(void) { // ---------- test various string-value parser functions ---------- XLAL_CHECK_MAIN ( test_ParseStringValue() == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK_MAIN ( test_ParseStringVector() == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK_MAIN ( test_ParseREAL8Vector() == XLAL_SUCCESS, XLAL_EFUNC ); // check for memory leaks LALCheckMemoryLeaks(); return EXIT_SUCCESS; } // main()
/*---------- function definitions ---------- */ int main(int argc,char *argv[]) { LALStatus status = blank_status; /* initialize status */ vrbflg = 1; /* verbose error-messages */ /* set LAL error-handler */ lal_errhandler = LAL_ERR_EXIT; /* exit with returned status-code on error */ /* register all user-variables */ LAL_CALL (InitUserVars(&status, &CommandLineArgs), &status); /* read cmdline & cfgfile */ BOOLEAN should_exit = 0; XLAL_CHECK_MAIN (XLALUserVarReadAllInput(&should_exit, argc, argv, lalAppsVCSInfoList) == XLAL_SUCCESS, XLAL_EFUNC); if (should_exit) return EXIT_FAILURE; LAL_CALL ( CheckUserInput (&status, &CommandLineArgs), &status); LAL_CALL ( Initialize (&status, &CommandLineArgs), &status); /*---------- central function: compute F-statistic ---------- */ LAL_CALL ( ComputeF(&status, CommandLineArgs), &status); /* Free remaining memory */ LAL_CALL ( LALSDestroyVector(&status, &(amc.a) ), &status); LAL_CALL ( LALSDestroyVector(&status, &(amc.b) ), &status); XLALDestroyUserVars(); LALCheckMemoryLeaks(); return 0; } /* main() */
int main(void) { /* Test XLALPearsonHash() */ XLAL_CHECK_MAIN(test_XLALPearsonHash(sizeof(UINT2), 1024, 8) == XLAL_SUCCESS, XLAL_EFAILED); XLAL_CHECK_MAIN(test_XLALPearsonHash(sizeof(UINT4), 1024, 0) == XLAL_SUCCESS, XLAL_EFAILED); XLAL_CHECK_MAIN(test_XLALPearsonHash(sizeof(UINT8), 1024, 0) == XLAL_SUCCESS, XLAL_EFAILED); /* Test XLALCityHash() */ XLAL_CHECK_MAIN(test_XLALCityHash(5, 0) == XLAL_SUCCESS, XLAL_EFAILED); XLAL_CHECK_MAIN(test_XLALCityHash(7, 0) == XLAL_SUCCESS, XLAL_EFAILED); /* Check for memory leaks */ LALCheckMemoryLeaks(); return EXIT_SUCCESS; }
int main( void ) { /* Create hash table */ LALBitset *bs = XLALBitsetCreate(); XLAL_CHECK_MAIN( bs != NULL, XLAL_EFUNC ); /* Create some random bits */ BOOLEAN XLAL_INIT_DECL( bits, [4096] ); gsl_rng *r = gsl_rng_alloc( gsl_rng_mt19937 ); XLAL_CHECK_MAIN( r != NULL, XLAL_ESYS ); int nbits = 0; for ( size_t n = 0; n < XLAL_NUM_ELEM( bits ); ++n ) { bits[n] = ( gsl_rng_uniform( r ) > 0.44 ); nbits += bits[n] ? 1 : 0; } /* Create random index offset into bitset */ const UINT8 n0 = gsl_rng_get( r ) % 65536; /* Print information */ printf("nbits = %i, n0 = %"LAL_UINT8_FORMAT"\n", nbits, n0); /* Set bits */ for ( size_t n = 0; n < XLAL_NUM_ELEM( bits ); ++n ) { XLAL_CHECK_MAIN( XLALBitsetSet( bs, n0 + n, bits[n] ) == XLAL_SUCCESS, XLAL_EFUNC ); } /* Get bits */ for ( size_t n = 0; n < XLAL_NUM_ELEM( bits ); ++n ) { BOOLEAN is_set = 0; XLAL_CHECK_MAIN( XLALBitsetGet( bs, n0 + n, &is_set ) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK_MAIN( !is_set == !bits[n], XLAL_EFAILED, "Inconsistent bit at index %"LAL_UINT8_FORMAT": LALBitset=%i, reference=%i", n0 + n, is_set, bits[n] ); } /* Clear bitset */ XLAL_CHECK_MAIN( XLALBitsetClear( bs ) == XLAL_SUCCESS, XLAL_EFUNC ); for ( size_t n = 0; n < XLAL_NUM_ELEM( bits ); ++n ) { BOOLEAN is_set = 0; XLAL_CHECK_MAIN( XLALBitsetGet( bs, n0 + n, &is_set ) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK_MAIN( !is_set, XLAL_EFAILED, "Bit still set at index %"LAL_UINT8_FORMAT, n0 + n ); } /* Cleanup */ gsl_rng_free( r ); XLALBitsetDestroy( bs ); /* Check for memory leaks */ LALCheckMemoryLeaks(); return EXIT_SUCCESS; }
int main(int argc, char *argv[]){ static LALStatus status; static LALDetector *detector; static LIGOTimeGPSVector timeV; static REAL8Cart3CoorVector velV; static REAL8Vector timeDiffV; static REAL8 foft; static HoughPulsarTemplate pulsarTemplate; EphemerisData *edat = NULL; CHAR *uvar_earthEphemeris = NULL; CHAR *uvar_sunEphemeris = NULL; SFTVector *inputSFTs = NULL; REAL8 *alphaVec=NULL; REAL8 *deltaVec=NULL; REAL8 *freqVec=NULL; REAL8 *spndnVec=NULL; /* pgV is vector of peakgrams and pg1 is onepeakgram */ static UCHARPeakGram *pg1, **pgV; UINT4 msp; /*number of spin-down parameters */ CHAR *uvar_ifo = NULL; CHAR *uvar_sftDir = NULL; /* the directory where the SFT could be */ CHAR *uvar_fnameOut = NULL; /* The output prefix filename */ CHAR *uvar_fnameIn = NULL; INT4 numberCount, ind; UINT8 nTemplates; UINT4 mObsCoh; REAL8 uvar_peakThreshold; REAL8 f_min, f_max, fWings, timeBase; INT4 uvar_blocksRngMed; UINT4 sftlength; INT4 sftFminBin; UINT4 loopId, tempLoopId; FILE *fpOut = NULL; CHAR *fnameLog=NULL; FILE *fpLog = NULL; CHAR *logstr=NULL; /*REAL8 asq, bsq;*/ /* square of amplitude modulation functions a and b */ /******************************************************************/ /* Set up the default parameters. */ /* ****************************************************************/ /* LAL error-handler */ lal_errhandler = LAL_ERR_EXIT; msp = 1; /*only one spin-down */ /* memory allocation for spindown */ pulsarTemplate.spindown.length = msp; pulsarTemplate.spindown.data = NULL; pulsarTemplate.spindown.data = (REAL8 *)LALMalloc(msp*sizeof(REAL8)); uvar_peakThreshold = THRESHOLD; uvar_earthEphemeris = (CHAR *)LALMalloc(1024*sizeof(CHAR)); strcpy(uvar_earthEphemeris,EARTHEPHEMERIS); uvar_sunEphemeris = (CHAR *)LALMalloc(1024*sizeof(CHAR)); strcpy(uvar_sunEphemeris,SUNEPHEMERIS); uvar_sftDir = (CHAR *)LALMalloc(1024*sizeof(CHAR)); strcpy(uvar_sftDir,SFTDIRECTORY); uvar_fnameOut = (CHAR *)LALMalloc(1024*sizeof(CHAR)); strcpy(uvar_fnameOut,VALIDATEOUT); uvar_fnameIn = (CHAR *)LALMalloc(1024*sizeof(CHAR)); strcpy(uvar_fnameIn,VALIDATEIN); uvar_blocksRngMed = BLOCKSRNGMED; /* register user input variables */ XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_ifo, "ifo", STRING, 'i', OPTIONAL, "Detector GEO(1) LLO(2) LHO(3)" ) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_earthEphemeris, "earthEphemeris", STRING, 'E', OPTIONAL, "Earth Ephemeris file") == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_sunEphemeris, "sunEphemeris", STRING, 'S', OPTIONAL, "Sun Ephemeris file") == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_sftDir, "sftDir", STRING, 'D', OPTIONAL, "SFT Directory") == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_fnameIn, "fnameIn", STRING, 'T', OPTIONAL, "Input template file") == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_fnameOut, "fnameOut", STRING, 'o', OPTIONAL, "Output filename") == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_blocksRngMed, "blocksRngMed", INT4, 'w', OPTIONAL, "RngMed block size") == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_peakThreshold, "peakThreshold", REAL8, 't', OPTIONAL, "Peak selection threshold") == XLAL_SUCCESS, XLAL_EFUNC); /* read all command line variables */ BOOLEAN should_exit = 0; XLAL_CHECK_MAIN( XLALUserVarReadAllInput(&should_exit, argc, argv, lalAppsVCSInfoList) == XLAL_SUCCESS, XLAL_EFUNC); if (should_exit) exit(1); /* open log file for writing */ fnameLog = LALCalloc( (strlen(uvar_fnameOut) + strlen(".log") + 10),1); strcpy(fnameLog,uvar_fnameOut); strcat(fnameLog,".log"); if ((fpLog = fopen(fnameLog, "w")) == NULL) { fprintf(stderr, "Unable to open file %s for writing\n", fnameLog); LALFree(fnameLog); exit(1); } /* get the log string */ XLAL_CHECK_MAIN( ( logstr = XLALUserVarGetLog(UVAR_LOGFMT_CFGFILE) ) != NULL, XLAL_EFUNC); fprintf( fpLog, "## Log file for HoughValidate\n\n"); fprintf( fpLog, "# User Input:\n"); fprintf( fpLog, "#-------------------------------------------\n"); fprintf( fpLog, "%s", logstr); LALFree(logstr); /* append an ident-string defining the exact CVS-version of the code used */ { CHAR command[1024] = ""; fprintf (fpLog, "\n\n# CVS-versions of executable:\n"); fprintf (fpLog, "# -----------------------------------------\n"); fclose (fpLog); sprintf (command, "ident %s | sort -u >> %s", argv[0], fnameLog); /* we don't check this. If it fails, we assume that */ /* one of the system-commands was not available, and */ /* therefore the CVS-versions will not be logged */ if ( system(command) ) fprintf (stderr, "\nsystem('%s') returned non-zero status!\n\n", command ); LALFree(fnameLog); } /* open output file for writing */ fpOut= fopen(uvar_fnameOut, "w"); /*setlinebuf(fpOut);*/ /* line buffered on */ setvbuf(fpOut, (char *)NULL, _IOLBF, 0); /*****************************************************************/ /* read template file */ /*****************************************************************/ { FILE *fpIn = NULL; INT4 r; REAL8 temp1, temp2, temp3, temp4, temp5; UINT8 templateCounter; fpIn = fopen(uvar_fnameIn, "r"); if ( !fpIn ) { fprintf(stderr, "Unable to fine file %s\n", uvar_fnameIn); return DRIVEHOUGHCOLOR_EFILE; } nTemplates = 0; do { r=fscanf(fpIn,"%lf%lf%lf%lf%lf\n", &temp1, &temp2, &temp3, &temp4, &temp5); /* make sure the line has the right number of entries or is EOF */ if (r==5) nTemplates++; } while ( r != EOF); rewind(fpIn); alphaVec = (REAL8 *)LALMalloc(nTemplates*sizeof(REAL8)); deltaVec = (REAL8 *)LALMalloc(nTemplates*sizeof(REAL8)); freqVec = (REAL8 *)LALMalloc(nTemplates*sizeof(REAL8)); spndnVec = (REAL8 *)LALMalloc(nTemplates*sizeof(REAL8)); for (templateCounter = 0; templateCounter < nTemplates; templateCounter++) { r=fscanf(fpIn,"%lf%lf%lf%lf%lf\n", &temp1, alphaVec + templateCounter, deltaVec + templateCounter, freqVec + templateCounter, spndnVec + templateCounter); } fclose(fpIn); } /**************************************************/ /* read sfts */ /*************************************************/ f_min = freqVec[0]; /* initial frequency to be analyzed */ /* assume that the last frequency in the templates file is also the highest frequency */ f_max = freqVec[nTemplates-1] ; /* we need to add wings to fmin and fmax to account for the Doppler shift, the size of the rngmed block size and also nfsizecylinder. The block size and nfsizecylinder are specified in terms of frequency bins...this goes as one of the arguments of LALReadSFTfiles */ /* first correct for Doppler shift */ fWings = f_max * VTOT; f_min -= fWings; f_max += fWings; /* create pattern to look for in SFT directory */ { CHAR *tempDir = NULL; SFTCatalog *catalog = NULL; static SFTConstraints constraints; /* set detector constraint */ constraints.detector = NULL; if ( XLALUserVarWasSet( &uvar_ifo ) ) constraints.detector = XLALGetChannelPrefix ( uvar_ifo ); /* get sft catalog */ tempDir = (CHAR *)LALCalloc(512, sizeof(CHAR)); strcpy(tempDir, uvar_sftDir); strcat(tempDir, "/*SFT*.*"); XLAL_CHECK_MAIN( ( catalog = XLALSFTdataFind( tempDir, &constraints) ) != NULL, XLAL_EFUNC); detector = XLALGetSiteInfo( catalog->data[0].header.name); mObsCoh = catalog->length; timeBase = 1.0 / catalog->data->header.deltaF; XLAL_CHECK_MAIN( ( inputSFTs = XLALLoadSFTs ( catalog, f_min, f_max) ) != NULL, XLAL_EFUNC); XLAL_CHECK_MAIN( XLALNormalizeSFTVect( inputSFTs, uvar_blocksRngMed, 0.0 ) == XLAL_SUCCESS, XLAL_EFUNC); if ( XLALUserVarWasSet( &uvar_ifo ) ) LALFree( constraints.detector ); LALFree( tempDir); XLALDestroySFTCatalog(catalog ); } sftlength = inputSFTs->data->data->length; { INT4 tempFbin; sftFminBin = floor( (REAL4)(timeBase * inputSFTs->data->f0) + (REAL4)(0.5)); tempFbin = floor( timeBase * inputSFTs->data->f0 + 0.5); if (tempFbin - sftFminBin) { fprintf(stderr, "Rounding error in calculating fminbin....be careful! \n"); } } /* loop over sfts and select peaks */ /* first the memory allocation for the peakgramvector */ pgV = NULL; pgV = (UCHARPeakGram **)LALMalloc(mObsCoh*sizeof(UCHARPeakGram *)); /* memory for peakgrams */ for (tempLoopId=0; tempLoopId < mObsCoh; tempLoopId++) { pgV[tempLoopId] = (UCHARPeakGram *)LALMalloc(sizeof(UCHARPeakGram)); pgV[tempLoopId]->length = sftlength; pgV[tempLoopId]->data = NULL; pgV[tempLoopId]->data = (UCHAR *)LALMalloc(sftlength* sizeof(UCHAR)); LAL_CALL (SFTtoUCHARPeakGram( &status, pgV[tempLoopId], inputSFTs->data + tempLoopId, uvar_peakThreshold), &status); } /* having calculated the peakgrams we don't need the sfts anymore */ XLALDestroySFTVector( inputSFTs); /* ****************************************************************/ /* setting timestamps vector */ /* ****************************************************************/ timeV.length = mObsCoh; timeV.data = NULL; timeV.data = (LIGOTimeGPS *)LALMalloc(mObsCoh*sizeof(LIGOTimeGPS)); { UINT4 j; for (j=0; j < mObsCoh; j++){ timeV.data[j].gpsSeconds = pgV[j]->epoch.gpsSeconds; timeV.data[j].gpsNanoSeconds = pgV[j]->epoch.gpsNanoSeconds; } } /******************************************************************/ /* compute the time difference relative to startTime for all SFTs */ /******************************************************************/ timeDiffV.length = mObsCoh; timeDiffV.data = NULL; timeDiffV.data = (REAL8 *)LALMalloc(mObsCoh*sizeof(REAL8)); { REAL8 t0, ts, tn, midTimeBase; UINT4 j; midTimeBase=0.5*timeBase; ts = timeV.data[0].gpsSeconds; tn = timeV.data[0].gpsNanoSeconds * 1.00E-9; t0=ts+tn; timeDiffV.data[0] = midTimeBase; for (j=1; j< mObsCoh; ++j){ ts = timeV.data[j].gpsSeconds; tn = timeV.data[j].gpsNanoSeconds * 1.00E-9; timeDiffV.data[j] = ts + tn -t0 + midTimeBase; } } /******************************************************************/ /* compute detector velocity for those time stamps */ /******************************************************************/ velV.length = mObsCoh; velV.data = NULL; velV.data = (REAL8Cart3Coor *)LALMalloc(mObsCoh*sizeof(REAL8Cart3Coor)); { VelocityPar velPar; REAL8 vel[3]; UINT4 j; velPar.detector = *detector; velPar.tBase = timeBase; velPar.vTol = ACCURACY; velPar.edat = NULL; /* read in ephemeris data */ XLAL_CHECK_MAIN( ( edat = XLALInitBarycenter( uvar_earthEphemeris, uvar_sunEphemeris ) ) != NULL, XLAL_EFUNC); velPar.edat = edat; /* now calculate average velocity */ for(j=0; j< velV.length; ++j){ velPar.startTime.gpsSeconds = timeV.data[j].gpsSeconds; velPar.startTime.gpsNanoSeconds = timeV.data[j].gpsNanoSeconds; LAL_CALL( LALAvgDetectorVel ( &status, vel, &velPar), &status ); velV.data[j].x= vel[0]; velV.data[j].y= vel[1]; velV.data[j].z= vel[2]; } } /* amplitude modulation stuff */ { AMCoeffs XLAL_INIT_DECL(amc); AMCoeffsParams *amParams; EarthState earth; BarycenterInput baryinput; /* Stores detector location and other barycentering data */ /* detector location */ baryinput.site.location[0] = detector->location[0]/LAL_C_SI; baryinput.site.location[1] = detector->location[1]/LAL_C_SI; baryinput.site.location[2] = detector->location[2]/LAL_C_SI; baryinput.dInv = 0.e0; /* alpha and delta must come from the skypatch */ /* for now set it to something arbitrary */ baryinput.alpha = 0.0; baryinput.delta = 0.0; /* Allocate space for amParams stucture */ /* Here, amParams->das is the Detector and Source info */ amParams = (AMCoeffsParams *)LALMalloc(sizeof(AMCoeffsParams)); amParams->das = (LALDetAndSource *)LALMalloc(sizeof(LALDetAndSource)); amParams->das->pSource = (LALSource *)LALMalloc(sizeof(LALSource)); /* Fill up AMCoeffsParams structure */ amParams->baryinput = &baryinput; amParams->earth = &earth; amParams->edat = edat; amParams->das->pDetector = detector; /* make sure alpha and delta are correct */ amParams->das->pSource->equatorialCoords.latitude = baryinput.delta; amParams->das->pSource->equatorialCoords.longitude = baryinput.alpha; amParams->das->pSource->orientation = 0.0; amParams->das->pSource->equatorialCoords.system = COORDINATESYSTEM_EQUATORIAL; amParams->polAngle = amParams->das->pSource->orientation ; /* These two have to be the same!!*/ /* timeV is start time ---> change to mid time */ LAL_CALL (LALComputeAM(&status, &amc, timeV.data, amParams), &status); /* calculate a^2 and b^2 */ /* for (ii=0, asq=0.0, bsq=0.0; ii<mObsCoh; ii++) */ /* { */ /* REAL8 *a, *b; */ /* a = amc.a + ii; */ /* b = amc.b + ii; */ /* asq += (*a) * (*a); */ /* bsq += (*b) * (*b); */ /* } */ /* free amParams */ LALFree(amParams->das->pSource); LALFree(amParams->das); LALFree(amParams); } /* loop over templates */ for(loopId=0; loopId < nTemplates; ++loopId){ /* set template parameters */ pulsarTemplate.f0 = freqVec[loopId]; pulsarTemplate.longitude = alphaVec[loopId]; pulsarTemplate.latitude = deltaVec[loopId]; pulsarTemplate.spindown.data[0] = spndnVec[loopId]; { REAL8 f0new, vcProdn, timeDiffN; REAL8 sourceDelta, sourceAlpha, cosDelta, factorialN; UINT4 j, i, f0newBin; REAL8Cart3Coor sourceLocation; sourceDelta = pulsarTemplate.latitude; sourceAlpha = pulsarTemplate.longitude; cosDelta = cos(sourceDelta); sourceLocation.x = cosDelta* cos(sourceAlpha); sourceLocation.y = cosDelta* sin(sourceAlpha); sourceLocation.z = sin(sourceDelta); /* loop for all different time stamps,calculate frequency and produce number count*/ /* first initialize number count */ numberCount=0; for (j=0; j<mObsCoh; ++j) { /* calculate v/c.n */ vcProdn = velV.data[j].x * sourceLocation.x + velV.data[j].y * sourceLocation.y + velV.data[j].z * sourceLocation.z; /* loop over spindown values to find f_0 */ f0new = pulsarTemplate.f0; factorialN = 1.0; timeDiffN = timeDiffV.data[j]; for (i=0; i<msp;++i) { factorialN *=(i+1.0); f0new += pulsarTemplate.spindown.data[i]*timeDiffN / factorialN; timeDiffN *= timeDiffN; } f0newBin = floor(f0new*timeBase + 0.5); foft = f0newBin * (1.0 +vcProdn) / timeBase; /* get the right peakgram */ pg1 = pgV[j]; /* calculate frequency bin for template */ ind = floor( foft * timeBase + 0.5 ) - sftFminBin; /* update the number count */ numberCount+=pg1->data[ind]; } } /* end of block calculating frequency path and number count */ /******************************************************************/ /* printing result in the output file */ /******************************************************************/ fprintf(fpOut,"%d %f %f %f %g \n", numberCount, pulsarTemplate.longitude, pulsarTemplate.latitude, pulsarTemplate.f0, pulsarTemplate.spindown.data[0] ); } /* end of loop over templates */ /******************************************************************/ /* Closing files */ /******************************************************************/ fclose(fpOut); /******************************************************************/ /* Free memory and exit */ /******************************************************************/ LALFree(alphaVec); LALFree(deltaVec); LALFree(freqVec); LALFree(spndnVec); for (tempLoopId = 0; tempLoopId < mObsCoh; tempLoopId++){ pg1 = pgV[tempLoopId]; LALFree(pg1->data); LALFree(pg1); } LALFree(pgV); LALFree(timeV.data); LALFree(timeDiffV.data); LALFree(velV.data); LALFree(pulsarTemplate.spindown.data); XLALDestroyEphemerisData(edat); XLALDestroyUserVars(); LALCheckMemoryLeaks(); return DRIVEHOUGHCOLOR_ENORM; }
/*============================================================ * FUNCTION definitions *============================================================*/ int main(int argc, char *argv[]) { static LALStatus status; /* LALStatus pointer */ UserVariables_t XLAL_INIT_DECL(uvar); ConfigVariables_t XLAL_INIT_DECL(cfg); UINT4 k, numBins, numIFOs, maxNumSFTs, X, alpha; REAL8 Freq0, dFreq, normPSD; UINT4 finalBinSize, finalBinStep, finalNumBins; REAL8Vector *overSFTs = NULL; /* one frequency bin over SFTs */ REAL8Vector *overIFOs = NULL; /* one frequency bin over IFOs */ REAL8Vector *finalPSD = NULL; /* math. operation PSD over SFTs and IFOs */ REAL8Vector *finalNormSFT = NULL; /* normalised SFT power */ vrbflg = 1; /* verbose error-messages */ /* set LAL error-handler */ lal_errhandler = LAL_ERR_EXIT; /* register and read user variables */ if (initUserVars(argc, argv, &uvar) != XLAL_SUCCESS) return EXIT_FAILURE; MultiSFTVector *inputSFTs = NULL; if ( ( inputSFTs = XLALReadSFTs ( &cfg, &uvar ) ) == NULL ) { XLALPrintError ("Call to XLALReadSFTs() failed with xlalErrno = %d\n", xlalErrno ); return EXIT_FAILURE; } /* clean sfts if required */ if ( XLALUserVarWasSet( &uvar.linefiles ) ) { RandomParams *randPar=NULL; FILE *fpRand=NULL; INT4 seed, ranCount; if ( (fpRand = fopen("/dev/urandom", "r")) == NULL ) { fprintf(stderr,"Error in opening /dev/urandom" ); return EXIT_FAILURE; } if ( (ranCount = fread(&seed, sizeof(seed), 1, fpRand)) != 1 ) { fprintf(stderr,"Error in getting random seed" ); return EXIT_FAILURE; } LAL_CALL ( LALCreateRandomParams (&status, &randPar, seed), &status ); LAL_CALL( LALRemoveKnownLinesInMultiSFTVector ( &status, inputSFTs, uvar.maxBinsClean, uvar.blocksRngMed, uvar.linefiles, randPar), &status); LAL_CALL ( LALDestroyRandomParams (&status, &randPar), &status); fclose(fpRand); } /* end cleaning */ LogPrintf (LOG_DEBUG, "Computing spectrogram and PSD ... "); /* get power running-median rngmed[ |data|^2 ] from SFTs */ MultiPSDVector *multiPSD = NULL; XLAL_CHECK_MAIN( ( multiPSD = XLALNormalizeMultiSFTVect ( inputSFTs, uvar.blocksRngMed, NULL ) ) != NULL, XLAL_EFUNC); /* restrict this PSD to just the "physical" band if requested using {--Freq, --FreqBand} */ if ( ( XLALCropMultiPSDandSFTVectors ( multiPSD, inputSFTs, cfg.firstBin, cfg.lastBin )) != XLAL_SUCCESS ) { XLALPrintError ("%s: XLALCropMultiPSDandSFTVectors (inputPSD, inputSFTs, %d, %d) failed with xlalErrno = %d\n", __func__, cfg.firstBin, cfg.lastBin, xlalErrno ); return EXIT_FAILURE; } /* start frequency and frequency spacing */ Freq0 = multiPSD->data[0]->data[0].f0; dFreq = multiPSD->data[0]->data[0].deltaF; /* number of raw bins in final PSD */ numBins = multiPSD->data[0]->data[0].data->length; if ( (finalPSD = XLALCreateREAL8Vector ( numBins )) == NULL ) { LogPrintf (LOG_CRITICAL, "Out of memory!\n"); return EXIT_FAILURE; } /* number of IFOs */ numIFOs = multiPSD->length; if ( (overIFOs = XLALCreateREAL8Vector ( numIFOs )) == NULL ) { LogPrintf (LOG_CRITICAL, "Out of memory!\n"); return EXIT_FAILURE; } /* maximum number of SFTs */ maxNumSFTs = 0; for (X = 0; X < numIFOs; ++X) { maxNumSFTs = GSL_MAX(maxNumSFTs, multiPSD->data[X]->length); } if ( (overSFTs = XLALCreateREAL8Vector ( maxNumSFTs )) == NULL ) { LogPrintf (LOG_CRITICAL, "Out of memory!\n"); return EXIT_FAILURE; } /* normalize rngmd(power) to get proper *single-sided* PSD: Sn = (2/Tsft) rngmed[|data|^2]] */ normPSD = 2.0 * dFreq; /* loop over frequency bins in final PSD */ for (k = 0; k < numBins; ++k) { /* loop over IFOs */ for (X = 0; X < numIFOs; ++X) { /* number of SFTs for this IFO */ UINT4 numSFTs = multiPSD->data[X]->length; /* copy PSD frequency bins and normalise multiPSD for later use */ for (alpha = 0; alpha < numSFTs; ++alpha) { multiPSD->data[X]->data[alpha].data->data[k] *= normPSD; overSFTs->data[alpha] = multiPSD->data[X]->data[alpha].data->data[k]; } /* compute math. operation over SFTs for this IFO */ overIFOs->data[X] = math_op(overSFTs->data, numSFTs, uvar.PSDmthopSFTs); if ( isnan( overIFOs->data[X] ) ) XLAL_ERROR ( EXIT_FAILURE, "Found Not-A-Number in overIFOs->data[X=%d] = NAN ... exiting\n", X ); } /* for IFOs X */ /* compute math. operation over IFOs for this frequency */ finalPSD->data[k] = math_op(overIFOs->data, numIFOs, uvar.PSDmthopIFOs); if ( isnan ( finalPSD->data[k] ) ) XLAL_ERROR ( EXIT_FAILURE, "Found Not-A-Number in finalPSD->data[k=%d] = NAN ... exiting\n", k ); } /* for freq bins k */ LogPrintfVerbatim ( LOG_DEBUG, "done.\n"); /* compute normalised SFT power */ if (uvar.outputNormSFT) { LogPrintf (LOG_DEBUG, "Computing normalised SFT power ... "); if ( (finalNormSFT = XLALCreateREAL8Vector ( numBins )) == NULL ) { LogPrintf (LOG_CRITICAL, "Out of memory!\n"); return EXIT_FAILURE; } /* loop over frequency bins in SFTs */ for (k = 0; k < numBins; ++k) { /* loop over IFOs */ for (X = 0; X < numIFOs; ++X) { /* number of SFTs for this IFO */ UINT4 numSFTs = inputSFTs->data[X]->length; /* compute SFT power */ for (alpha = 0; alpha < numSFTs; ++alpha) { COMPLEX8 bin = inputSFTs->data[X]->data[alpha].data->data[k]; overSFTs->data[alpha] = crealf(bin)*crealf(bin) + cimagf(bin)*cimagf(bin); } /* compute math. operation over SFTs for this IFO */ overIFOs->data[X] = math_op(overSFTs->data, numSFTs, uvar.nSFTmthopSFTs); if ( isnan ( overIFOs->data[X] )) XLAL_ERROR ( EXIT_FAILURE, "Found Not-A-Number in overIFOs->data[X=%d] = NAN ... exiting\n", X ); } /* over IFOs */ /* compute math. operation over IFOs for this frequency */ finalNormSFT->data[k] = math_op(overIFOs->data, numIFOs, uvar.nSFTmthopIFOs); if ( isnan( finalNormSFT->data[k] ) ) XLAL_ERROR ( EXIT_FAILURE, "Found Not-A-Number in bin finalNormSFT->data[k=%d] = NAN ... exiting\n", k ); } /* over freq bins */ LogPrintfVerbatim ( LOG_DEBUG, "done.\n"); } /* output spectrograms */ if ( uvar.outputSpectBname ) { LAL_CALL ( LALfwriteSpectrograms ( &status, uvar.outputSpectBname, multiPSD ), &status ); } /* ---------- if user requested it, output complete MultiPSDVector over IFOs X, timestamps and freq-bins into ASCI file(s) */ if ( uvar.dumpMultiPSDVector ) { if ( XLALDumpMultiPSDVector ( uvar.outputPSD, multiPSD ) != XLAL_SUCCESS ) { XLALPrintError ("%s: XLALDumpMultiPSDVector() failed, xlalErrnor = %d\n", __func__, xlalErrno ); return EXIT_FAILURE; } } /* if uvar.dumpMultiPSDVector */ /* ----- if requested, compute data-quality factor 'Q' -------------------- */ if ( uvar.outputQ ) { REAL8FrequencySeries *Q; if ( (Q = XLALComputeSegmentDataQ ( multiPSD, cfg.dataSegment )) == NULL ) { XLALPrintError ("%s: XLALComputeSegmentDataQ() failed with xlalErrno = %d\n", __func__, xlalErrno ); return EXIT_FAILURE; } if ( XLAL_SUCCESS != XLALWriteREAL8FrequencySeries_to_file ( Q, uvar.outputQ ) ) { return EXIT_FAILURE; } XLALDestroyREAL8FrequencySeries ( Q ); } /* if outputQ */ /* ---------- BINNING if requested ---------- */ /* work out bin size */ if (XLALUserVarWasSet(&uvar.binSize)) { finalBinSize = uvar.binSize; } else if (XLALUserVarWasSet(&uvar.binSizeHz)) { finalBinSize = (UINT4)floor(uvar.binSizeHz / dFreq + 0.5); /* round to nearest bin */ } else { finalBinSize = 1; } /* work out bin step */ if (XLALUserVarWasSet(&uvar.binStep)) { finalBinStep = uvar.binStep; } else if (XLALUserVarWasSet(&uvar.binStepHz)) { finalBinStep = (UINT4)floor(uvar.binStepHz / dFreq + 0.5); /* round to nearest bin */ } else { finalBinStep = finalBinSize; } /* work out total number of bins */ finalNumBins = (UINT4)floor((numBins - finalBinSize) / finalBinStep) + 1; /* write final PSD to file */ if (XLALUserVarWasSet(&uvar.outputPSD)) { FILE *fpOut = NULL; if ((fpOut = fopen(uvar.outputPSD, "wb")) == NULL) { LogPrintf ( LOG_CRITICAL, "Unable to open output file %s for writing...exiting \n", uvar.outputPSD ); return EXIT_FAILURE; } /* write header info in comments */ if ( XLAL_SUCCESS != XLALOutputVersionString ( fpOut, 0 ) ) XLAL_ERROR ( XLAL_EFUNC ); /* write the command-line */ for (int a = 0; a < argc; a++) fprintf(fpOut,"%%%% argv[%d]: '%s'\n", a, argv[a]); /* write column headings */ fprintf(fpOut,"%%%% columns:\n%%%% FreqBinStart"); if (uvar.outFreqBinEnd) fprintf(fpOut," FreqBinEnd"); fprintf(fpOut," PSD"); if (uvar.outputNormSFT) fprintf(fpOut," normSFTpower"); fprintf(fpOut,"\n"); LogPrintf(LOG_DEBUG, "Printing PSD to file ... "); for (k = 0; k < finalNumBins; ++k) { UINT4 b = k * finalBinStep; REAL8 f0 = Freq0 + b * dFreq; REAL8 f1 = f0 + finalBinStep * dFreq; fprintf(fpOut, "%f", f0); if (uvar.outFreqBinEnd) fprintf(fpOut, " %f", f1); REAL8 psd = math_op(&(finalPSD->data[b]), finalBinSize, uvar.PSDmthopBins); if ( isnan ( psd )) XLAL_ERROR ( EXIT_FAILURE, "Found Not-A-Number in psd[k=%d] = NAN ... exiting\n", k ); fprintf(fpOut, " %e", psd); if (uvar.outputNormSFT) { REAL8 nsft = math_op(&(finalNormSFT->data[b]), finalBinSize, uvar.nSFTmthopBins); if ( isnan ( nsft )) XLAL_ERROR ( EXIT_FAILURE, "Found Not-A-Number in nsft[k=%d] = NAN ... exiting\n", k ); fprintf(fpOut, " %f", nsft); } fprintf(fpOut, "\n"); } // k < finalNumBins LogPrintfVerbatim ( LOG_DEBUG, "done.\n"); fclose(fpOut); } /* we are now done with the psd */ XLALDestroyMultiPSDVector ( multiPSD); XLALDestroyMultiSFTVector ( inputSFTs); XLALDestroyUserVars(); XLALDestroyREAL8Vector ( overSFTs ); XLALDestroyREAL8Vector ( overIFOs ); XLALDestroyREAL8Vector ( finalPSD ); XLALDestroyREAL8Vector ( finalNormSFT ); LALCheckMemoryLeaks(); return EXIT_SUCCESS; } /* main() */
static int SuperskyTest( const double T, const double max_mismatch, const char *lattice_name, const UINT8 patch_count, const double freq, const double freqband, const UINT8 total_ref, const double mism_hist_ref[MISM_HIST_BINS] ) { // Create lattice tiling LatticeTiling *tiling = XLALCreateLatticeTiling(3); XLAL_CHECK(tiling != NULL, XLAL_EFUNC); // Compute reduced supersky metric const double Tspan = T * 86400; LIGOTimeGPS ref_time; XLALGPSSetREAL8(&ref_time, 900100100); LALSegList segments; { XLAL_CHECK(XLALSegListInit(&segments) == XLAL_SUCCESS, XLAL_EFUNC); LALSeg segment; LIGOTimeGPS start_time = ref_time, end_time = ref_time; XLALGPSAdd(&start_time, -0.5 * Tspan); XLALGPSAdd(&end_time, 0.5 * Tspan); XLAL_CHECK(XLALSegSet(&segment, &start_time, &end_time, 0) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK(XLALSegListAppend(&segments, &segment) == XLAL_SUCCESS, XLAL_EFUNC); } MultiLALDetector detectors = { .length = 1, .sites = { lalCachedDetectors[LAL_LLO_4K_DETECTOR] } }; EphemerisData *edat = XLALInitBarycenter(TEST_DATA_DIR "earth00-19-DE405.dat.gz", TEST_DATA_DIR "sun00-19-DE405.dat.gz"); XLAL_CHECK(edat != NULL, XLAL_EFUNC); SuperskyMetrics *metrics = XLALComputeSuperskyMetrics(0, &ref_time, &segments, freq, &detectors, NULL, DETMOTION_SPIN | DETMOTION_PTOLEORBIT, edat); XLAL_CHECK(metrics != NULL, XLAL_EFUNC); gsl_matrix *rssky_metric = metrics->semi_rssky_metric, *rssky_transf = metrics->semi_rssky_transf; metrics->semi_rssky_metric = metrics->semi_rssky_transf = NULL; XLALDestroySuperskyMetrics(metrics); XLALSegListClear(&segments); XLALDestroyEphemerisData(edat); // Add bounds printf("Bounds: supersky, sky patch 0/%" LAL_UINT8_FORMAT ", freq=%0.3g, freqband=%0.3g\n", patch_count, freq, freqband); XLAL_CHECK(XLALSetSuperskyLatticeTilingPhysicalSkyPatch(tiling, rssky_metric, rssky_transf, patch_count, 0) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK(XLALSetSuperskyLatticeTilingPhysicalSpinBound(tiling, rssky_transf, 0, freq, freq + freqband) == XLAL_SUCCESS, XLAL_EFUNC); GFMAT(rssky_transf); // Set metric printf("Lattice type: %s\n", lattice_name); XLAL_CHECK(XLALSetTilingLatticeAndMetric(tiling, lattice_name, rssky_metric, max_mismatch) == XLAL_SUCCESS, XLAL_EFUNC); // Perform mismatch test XLAL_CHECK(MismatchTest(tiling, rssky_metric, max_mismatch, total_ref, mism_hist_ref) == XLAL_SUCCESS, XLAL_EFUNC); return XLAL_SUCCESS; } static int MultiSegSuperskyTest(void) { printf("Performing multiple-segment tests ...\n"); // Compute reduced supersky metrics const double Tspan = 86400; LIGOTimeGPS ref_time; XLALGPSSetREAL8(&ref_time, 900100100); LALSegList segments; { XLAL_CHECK(XLALSegListInit(&segments) == XLAL_SUCCESS, XLAL_EFUNC); LALSeg segment; { LIGOTimeGPS start_time = ref_time, end_time = ref_time; XLALGPSAdd(&start_time, -4 * Tspan); XLALGPSAdd(&end_time, -3 * Tspan); XLAL_CHECK(XLALSegSet(&segment, &start_time, &end_time, 0) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK(XLALSegListAppend(&segments, &segment) == XLAL_SUCCESS, XLAL_EFUNC); } { LIGOTimeGPS start_time = ref_time, end_time = ref_time; XLALGPSAdd(&start_time, -0.5 * Tspan); XLALGPSAdd(&end_time, 0.5 * Tspan); XLAL_CHECK(XLALSegSet(&segment, &start_time, &end_time, 0) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK(XLALSegListAppend(&segments, &segment) == XLAL_SUCCESS, XLAL_EFUNC); } { LIGOTimeGPS start_time = ref_time, end_time = ref_time; XLALGPSAdd(&start_time, 3.5 * Tspan); XLALGPSAdd(&end_time, 4.5 * Tspan); XLAL_CHECK(XLALSegSet(&segment, &start_time, &end_time, 0) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK(XLALSegListAppend(&segments, &segment) == XLAL_SUCCESS, XLAL_EFUNC); } } MultiLALDetector detectors = { .length = 1, .sites = { lalCachedDetectors[LAL_LLO_4K_DETECTOR] } }; EphemerisData *edat = XLALInitBarycenter(TEST_DATA_DIR "earth00-19-DE405.dat.gz", TEST_DATA_DIR "sun00-19-DE405.dat.gz"); XLAL_CHECK(edat != NULL, XLAL_EFUNC); SuperskyMetrics *metrics = XLALComputeSuperskyMetrics(1, &ref_time, &segments, 50, &detectors, NULL, DETMOTION_SPIN | DETMOTION_PTOLEORBIT, edat); XLAL_CHECK(metrics != NULL, XLAL_EFUNC); // Project and rescale semicoherent metric to give equal frequency spacings const double coh_max_mismatch = 0.2, semi_max_mismatch = 0.4; XLAL_CHECK(XLALEqualizeReducedSuperskyMetricsFreqSpacing(metrics, coh_max_mismatch, semi_max_mismatch) == XLAL_SUCCESS, XLAL_EFUNC); // Create lattice tilings LatticeTiling *coh_tiling[metrics->num_segments]; for (size_t n = 0; n < metrics->num_segments; ++n) { coh_tiling[n] = XLALCreateLatticeTiling(4); XLAL_CHECK(coh_tiling[n] != NULL, XLAL_EFUNC); } LatticeTiling *semi_tiling = XLALCreateLatticeTiling(4); XLAL_CHECK(semi_tiling != NULL, XLAL_EFUNC); // Add bounds for (size_t n = 0; n < metrics->num_segments; ++n) { XLAL_CHECK(XLALSetSuperskyLatticeTilingPhysicalSkyPatch(coh_tiling[n], metrics->coh_rssky_metric[n], metrics->coh_rssky_transf[n], 1, 0) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK(XLALSetSuperskyLatticeTilingPhysicalSpinBound(coh_tiling[n], metrics->coh_rssky_transf[n], 0, 50, 50 + 1e-4) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK(XLALSetSuperskyLatticeTilingPhysicalSpinBound(coh_tiling[n], metrics->coh_rssky_transf[n], 1, 0, -5e-10) == XLAL_SUCCESS, XLAL_EFUNC); } XLAL_CHECK(XLALSetSuperskyLatticeTilingPhysicalSkyPatch(semi_tiling, metrics->semi_rssky_metric, metrics->semi_rssky_transf, 1, 0) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK(XLALSetSuperskyLatticeTilingPhysicalSpinBound(semi_tiling, metrics->semi_rssky_transf, 0, 50, 50 + 1e-4) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK(XLALSetSuperskyLatticeTilingPhysicalSpinBound(semi_tiling, metrics->semi_rssky_transf, 1, 0, -5e-10) == XLAL_SUCCESS, XLAL_EFUNC); // Set metric for (size_t n = 0; n < metrics->num_segments; ++n) { XLAL_CHECK(XLALSetTilingLatticeAndMetric(coh_tiling[n], "Ans", metrics->coh_rssky_metric[n], coh_max_mismatch) == XLAL_SUCCESS, XLAL_EFUNC); } XLAL_CHECK(XLALSetTilingLatticeAndMetric(semi_tiling, "Ans", metrics->semi_rssky_metric, semi_max_mismatch) == XLAL_SUCCESS, XLAL_EFUNC); // Check lattice step sizes in frequency const size_t ifreq = 3; const double semi_dfreq = XLALLatticeTilingStepSizes(semi_tiling, ifreq); for (size_t n = 0; n < metrics->num_segments; ++n) { const double coh_dfreq = XLALLatticeTilingStepSizes(coh_tiling[n], ifreq); const double tol = 1e-8; XLAL_CHECK(fabs(coh_dfreq - semi_dfreq) < tol * semi_dfreq, XLAL_EFAILED, " ERROR: semi_dfreq=%0.15e, coh_dfreq[%zu]=%0.15e, |coh_dfreq - semi_dfreq| >= %g * semi_dfreq", semi_dfreq, n, coh_dfreq, tol); } // Check computation of spindown range for coherent tilings for (size_t n = 0; n < metrics->num_segments; ++n) { PulsarSpinRange spin_range; XLAL_CHECK(XLALSuperskyLatticePulsarSpinRange(&spin_range, coh_tiling[n], metrics->coh_rssky_transf[n]) == XLAL_SUCCESS, XLAL_EFUNC); } // Cleanup for (size_t n = 0; n < metrics->num_segments; ++n) { XLALDestroyLatticeTiling(coh_tiling[n]); } XLALDestroyLatticeTiling(semi_tiling); XLALDestroySuperskyMetrics(metrics); XLALSegListClear(&segments); XLALDestroyEphemerisData(edat); LALCheckMemoryLeaks(); printf("\n"); fflush(stdout); return XLAL_SUCCESS; } int main(void) { // Perform basic tests XLAL_CHECK_MAIN(BasicTest(1, 0, 0, 0, 0, "Zn" , 1, 1, 1, 1) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(BasicTest(1, 1, 1, 1, 1, "Ans", 93, 0, 0, 0) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(BasicTest(1, 1, 1, 1, 1, "Zn" , 93, 0, 0, 0) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(BasicTest(2, 0, 0, 0, 0, "Ans", 1, 1, 1, 1) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(BasicTest(2, 1, 1, 1, 1, "Ans", 12, 144, 0, 0) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(BasicTest(2, 1, 1, 1, 1, "Zn" , 13, 190, 0, 0) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(BasicTest(3, 0, 0, 0, 0, "Zn" , 1, 1, 1, 1) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(BasicTest(3, 1, 1, 1, 1, "Ans", 8, 46, 332, 0) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(BasicTest(3, 1, 1, 1, 1, "Zn" , 8, 60, 583, 0) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(BasicTest(4, 0, 0, 0, 0, "Ans", 1, 1, 1, 1) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(BasicTest(4, 0, 0, 0, 1, "Ans", 1, 1, 1, 4) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(BasicTest(4, 0, 0, 1, 0, "Ans", 1, 1, 4, 4) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(BasicTest(4, 0, 0, 1, 1, "Ans", 1, 1, 4, 20) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(BasicTest(4, 0, 1, 0, 0, "Ans", 1, 4, 4, 4) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(BasicTest(4, 0, 1, 0, 1, "Ans", 1, 5, 5, 25) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(BasicTest(4, 0, 1, 1, 0, "Ans", 1, 5, 24, 24) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(BasicTest(4, 0, 1, 1, 1, "Ans", 1, 5, 20, 115) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(BasicTest(4, 1, 0, 0, 0, "Ans", 4, 4, 4, 4) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(BasicTest(4, 1, 0, 0, 1, "Ans", 5, 5, 5, 23) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(BasicTest(4, 1, 0, 1, 0, "Ans", 5, 5, 23, 23) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(BasicTest(4, 1, 0, 1, 1, "Ans", 6, 6, 24, 139) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(BasicTest(4, 1, 1, 0, 0, "Ans", 5, 25, 25, 25) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(BasicTest(4, 1, 1, 0, 1, "Ans", 6, 30, 30, 162) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(BasicTest(4, 1, 1, 1, 0, "Ans", 6, 27, 151, 151) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(BasicTest(4, 1, 1, 1, 1, "Ans", 6, 30, 145, 897) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(BasicTest(4, 1, 1, 1, 1, "Zn" , 7, 46, 287, 2543) == XLAL_SUCCESS, XLAL_EFUNC); // Perform mismatch tests with a square parameter space XLAL_CHECK_MAIN(MismatchSquareTest("Zn", 0.03, 0, 0, 21460, Z1_mism_hist) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(MismatchSquareTest("Zn", 2e-4, -2e-9, 0, 23763, Z2_mism_hist) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(MismatchSquareTest("Zn", 1e-4, -1e-9, 1e-17, 19550, Z3_mism_hist) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(MismatchSquareTest("Ans", 0.03, 0, 0, 21460, A1s_mism_hist) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(MismatchSquareTest("Ans", 2e-4, -2e-9, 0, 18283, A2s_mism_hist) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(MismatchSquareTest("Ans", 1e-4, -2e-9, 2e-17, 20268, A3s_mism_hist) == XLAL_SUCCESS, XLAL_EFUNC); // Perform mismatch tests with an age--braking index parameter space XLAL_CHECK_MAIN(MismatchAgeBrakeTest("Ans", 100, 4.0e-5, 37872, A3s_mism_hist) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(MismatchAgeBrakeTest("Ans", 200, 1.5e-5, 37232, A3s_mism_hist) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(MismatchAgeBrakeTest("Ans", 300, 1.0e-5, 37022, A3s_mism_hist) == XLAL_SUCCESS, XLAL_EFUNC); // Perform mismatch tests with the reduced supersky parameter space and metric XLAL_CHECK_MAIN(SuperskyTest(1.1, 0.8, "Ans", 1, 50, 2.0e-5, 20548, A3s_mism_hist) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(SuperskyTest(1.5, 0.8, "Ans", 3, 50, 2.0e-5, 20202, A3s_mism_hist) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN(SuperskyTest(2.5, 0.8, "Ans", 17, 50, 2.0e-5, 29147, A3s_mism_hist) == XLAL_SUCCESS, XLAL_EFUNC); // Perform tests with the reduced supersky parameter space metric and multiple segments XLAL_CHECK_MAIN(MultiSegSuperskyTest() == XLAL_SUCCESS, XLAL_EFUNC); return EXIT_SUCCESS; }
/// /// Write various information from coherent input data to a FITS file /// int XLALWeaveCohInputWriteInfo( FITSFile *file, const size_t ncoh_input, WeaveCohInput *const *coh_input ) { // Check input XLAL_CHECK( file != NULL, XLAL_EFAULT ); XLAL_CHECK( ncoh_input > 0, XLAL_ESIZE ); XLAL_CHECK( coh_input != NULL, XLAL_EFAULT ); // Write total number of SFTs used by search { UINT4 nsfts = 0; for ( size_t i = 0; i < ncoh_input; ++i ) { for ( size_t j = 0; j < PULSAR_MAX_DETECTORS; ++j ) { nsfts += coh_input[i]->seg_info.sft_count[j]; } } XLAL_CHECK_MAIN( XLALFITSHeaderWriteUINT4( file, "nsfts", nsfts, "number of SFTs used by search" ) == XLAL_SUCCESS, XLAL_EFUNC ); } // Return now if simulating search if ( coh_input[0]->simulation_level & WEAVE_SIMULATE ) { return XLAL_SUCCESS; } // Write F-statistic method name { const char *method_name = XLALGetFstatInputMethodName( coh_input[0]->Fstat_input ); XLAL_CHECK( method_name != NULL, XLAL_EFUNC ); XLAL_CHECK( XLALFITSHeaderWriteString( file, "fstat method", method_name, "name of F-statistic method" ) == XLAL_SUCCESS, XLAL_EFUNC ); } // Write F-statistic timing information if ( coh_input[0]->Fstat_collect_timing ) { // Get timing information from F-statistic input data REAL4 tauF_eff = 0, tauF_core = 0, tauF_buffer = 0, NCalls = 0, NBufferMisses = 0; UINT4 nmodel = 0; const char *XLAL_INIT_DECL( model_names, [TIMING_MODEL_MAX_VARS] ); REAL4 XLAL_INIT_DECL( model_values, [TIMING_MODEL_MAX_VARS] ); for ( size_t i = 0; i < ncoh_input; ++i ) { // Get timing data FstatTimingGeneric XLAL_INIT_DECL( timing_generic ); FstatTimingModel XLAL_INIT_DECL( timing_model ); XLAL_CHECK( XLALGetFstatTiming( coh_input[i]->Fstat_input, &timing_generic, &timing_model ) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK( timing_generic.NCalls > 0, XLAL_EFAILED ); // Accumulate generic timing constants tauF_eff += timing_generic.tauF_eff; tauF_core += timing_generic.tauF_core; tauF_buffer += timing_generic.tauF_buffer; NCalls += timing_generic.NCalls; NBufferMisses += timing_generic.NBufferMisses; // Get names of method-specific timing constants if ( nmodel == 0 ) { nmodel = timing_model.numVariables; for ( size_t j = 0; j < nmodel; ++j ) { model_names[j] = timing_model.names[j]; } } else { XLAL_CHECK( nmodel == timing_model.numVariables, XLAL_EFAILED ); for ( size_t j = 0; j < nmodel; ++j ) { XLAL_CHECK( strcmp( model_names[j], timing_model.names[j] ) == 0, XLAL_EFAILED ); } } // Accumulate method-specific timing constants for ( size_t j = 0; j < nmodel; ++j ) { model_values[j] += timing_model.values[j]; } } // Write generic timing constants XLAL_CHECK( XLALFITSHeaderWriteREAL4( file, "fstat tauF_eff", tauF_eff / ncoh_input, "F-statistic generic timing constant" ) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK( XLALFITSHeaderWriteREAL4( file, "fstat tauF_core", tauF_core / ncoh_input, "F-statistic generic timing constant" ) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK( XLALFITSHeaderWriteREAL4( file, "fstat tauF_buffer", tauF_buffer / ncoh_input, "F-statistic generic timing constant" ) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK( XLALFITSHeaderWriteREAL4( file, "fstat b", NBufferMisses / NCalls, "F-statistic generic timing constant" ) == XLAL_SUCCESS, XLAL_EFUNC ); // Write method-specific timing constants for ( size_t j = 0; j < nmodel; ++j ) { char keyword[64]; snprintf( keyword, sizeof( keyword ), "fstat %s", model_names[j] ); XLAL_CHECK( XLALFITSHeaderWriteREAL4( file, keyword, model_values[j] / ncoh_input, "F-statistic method-specific timing constant" ) == XLAL_SUCCESS, XLAL_EFUNC ); } }
/*---------------------------------------------------------------------- * main function *----------------------------------------------------------------------*/ int main(int argc, char *argv[]) { SFTConstraints XLAL_INIT_DECL(constraints); LIGOTimeGPS XLAL_INIT_DECL(minStartTimeGPS); LIGOTimeGPS XLAL_INIT_DECL(maxStartTimeGPS); SFTCatalog *FullCatalog = NULL; CHAR *add_comment = NULL; UINT4 i; REAL8 fMin, fMax; UserInput_t XLAL_INIT_DECL(uvar); /* register all user-variables */ XLAL_CHECK_MAIN ( initUserVars ( &uvar ) == XLAL_SUCCESS, XLAL_EFUNC ); /* read cmdline & cfgfile */ XLAL_CHECK_MAIN ( XLALUserVarReadAllInput (argc, argv) == XLAL_SUCCESS, XLAL_EFUNC ); if (uvar.help) { /* help requested: we're done */ exit (0); } /* ----- make sure output directory exists ---------- */ if ( uvar.outputDir ) { int ret; ret = mkdir ( uvar.outputDir, 0777); if ( (ret == -1) && ( errno != EEXIST ) ) { int errsv = errno; LogPrintf (LOG_CRITICAL, "Failed to create directory '%s': %s\n", uvar.outputDir, strerror(errsv) ); return -1; } } LIGOTimeGPSVector *timestamps = NULL; if ( uvar.timestampsFile ) { if ( (timestamps = XLALReadTimestampsFile ( uvar.timestampsFile )) == NULL ) { XLALPrintError ("XLALReadTimestampsFile() failed to load timestamps from file '%s'\n", uvar.timestampsFile ); return -1; } } /* use IFO-contraint if one given by the user */ if ( LALUserVarWasSet ( &uvar.IFO ) ) { XLAL_CHECK_MAIN ( (constraints.detector = XLALGetChannelPrefix ( uvar.IFO )) != NULL, XLAL_EINVAL ); } minStartTimeGPS.gpsSeconds = uvar.minStartTime; maxStartTimeGPS.gpsSeconds = uvar.maxStartTime; constraints.minStartTime = &minStartTimeGPS; constraints.maxStartTime = &maxStartTimeGPS; constraints.timestamps = timestamps; /* get full SFT-catalog of all matching (multi-IFO) SFTs */ XLAL_CHECK_MAIN ( (FullCatalog = XLALSFTdataFind ( uvar.inputSFTs, &constraints )) != NULL, XLAL_EFUNC ); if ( constraints.detector ) { XLALFree ( constraints.detector ); } XLAL_CHECK_MAIN ( (FullCatalog != NULL) && (FullCatalog->length > 0), XLAL_EINVAL, "\nSorry, didn't find any matching SFTs with pattern '%s'!\n\n", uvar.inputSFTs ); /* build up full comment-string to be added to SFTs: 1) converted by ConvertToSFTv2, VCS ID 2) user extraComment */ { UINT4 len = 128; len += strlen ( uvar.inputSFTs ); if ( uvar.extraComment ) len += strlen ( uvar.extraComment ); XLAL_CHECK_MAIN ( ( add_comment = LALCalloc ( 1, len )) != NULL, XLAL_ENOMEM ); /** \deprecated FIXME: the following code uses obsolete CVS ID tags. * It should be modified to use git version information. */ sprintf ( add_comment, "Converted by $Id$, inputSFTs = '%s';", uvar.inputSFTs ); if ( uvar.extraComment ) { strcat ( add_comment, "\n"); strcat ( add_comment, uvar.extraComment ); } } /* construct comment-string */ /* which frequency-band to extract? */ fMin = -1; /* default: all */ fMax = -1; if ( LALUserVarWasSet ( &uvar.fmin ) ) fMin = uvar.fmin; if ( LALUserVarWasSet ( &uvar.fmax ) ) fMax = uvar.fmax; FILE *fpSingleSFT = NULL; if ( uvar.outputSingleSFT ) XLAL_CHECK ( ( fpSingleSFT = fopen ( uvar.outputSingleSFT, "wb" )) != NULL, XLAL_EIO, "Failed to open singleSFT file '%s' for writing\n", uvar.outputSingleSFT ); /* loop over all SFTs in SFTCatalog */ for ( i=0; i < FullCatalog->length; i ++ ) { SFTCatalog oneSFTCatalog; SFTVector *thisSFT = NULL; const CHAR *sft_comment; CHAR *new_comment; UINT4 comment_len = 0; /* set catalog containing only one SFT */ oneSFTCatalog.length = 1; oneSFTCatalog.data = &(FullCatalog->data[i]); comment_len = strlen ( add_comment ) + 10; sft_comment = oneSFTCatalog.data->comment; if ( sft_comment ) comment_len += strlen ( sft_comment ); XLAL_CHECK_MAIN ( ( new_comment = LALCalloc (1, comment_len )) != NULL, XLAL_ENOMEM ); if ( sft_comment ) { strcpy ( new_comment, sft_comment ); strcat ( new_comment, ";\n"); } strcat ( new_comment, add_comment ); XLAL_CHECK_MAIN ( (thisSFT = XLALLoadSFTs ( &oneSFTCatalog, fMin, fMax )) != NULL, XLAL_EFUNC ); if ( uvar.mysteryFactor != 1.0 ) { XLAL_CHECK_MAIN ( applyFactor2SFTs ( thisSFT, uvar.mysteryFactor ) == XLAL_SUCCESS, XLAL_EFUNC ); } // if user asked for single-SFT output, add this SFT to the open file if ( uvar.outputSingleSFT ) XLAL_CHECK ( XLAL_SUCCESS == XLALWriteSFT2fp( &(thisSFT->data[0]), fpSingleSFT, new_comment ), XLAL_EFUNC, "XLALWriteSFT2fp() failed to write SFT to '%s'!\n", uvar.outputSingleSFT ); // if user asked for directory output, write this SFT into that directory if ( uvar.outputDir ) { XLAL_CHECK_MAIN ( XLALWriteSFTVector2Dir ( thisSFT, uvar.outputDir, new_comment, uvar.descriptionMisc ) == XLAL_SUCCESS, XLAL_EFUNC ); } XLALDestroySFTVector ( thisSFT ); XLALFree ( new_comment ); } /* for i < numSFTs */ if ( fpSingleSFT ) { fclose ( fpSingleSFT ); } /* free memory */ XLALFree ( add_comment ); XLALDestroySFTCatalog ( FullCatalog ); XLALDestroyUserVars(); XLALDestroyTimestampVector ( timestamps ); LALCheckMemoryLeaks(); return 0; } /* main */
/*---------------------------------------------------------------------- * main function *----------------------------------------------------------------------*/ int main(int argc, char *argv[]) { SFTConstraints XLAL_INIT_DECL(constraints); CHAR detector[2] = "??"; /* allow reading v1-SFTs without detector-info */ SFTVector *diffs = NULL; REAL8 maxd = 0; /* register all user-variables */ UserInput_t XLAL_INIT_DECL(uvar); XLAL_CHECK_MAIN ( initUserVars ( &uvar ) == XLAL_SUCCESS, XLAL_EFUNC ); /* read cmdline & cfgfile */ XLAL_CHECK_MAIN ( XLALUserVarReadAllInput ( argc, argv ) == XLAL_SUCCESS, XLAL_EFUNC ); if (uvar.help) { /* help requested: we're done */ exit (0); } /* now read in the two complete sft-vectors */ constraints.detector = detector; SFTCatalog *catalog; XLAL_CHECK_MAIN ( (catalog = XLALSFTdataFind ( uvar.sftBname1, &constraints )) != NULL, XLAL_EFUNC ); SFTVector *SFTs1; XLAL_CHECK_MAIN ( (SFTs1 = XLALLoadSFTs( catalog, -1, -1 )) != NULL, XLAL_EFUNC ); XLALDestroySFTCatalog ( catalog ); XLAL_CHECK_MAIN ( (catalog = XLALSFTdataFind ( uvar.sftBname2, &constraints )) != NULL, XLAL_EFUNC ); SFTVector *SFTs2; XLAL_CHECK_MAIN ( (SFTs2 = XLALLoadSFTs( catalog, -1, -1 )) != NULL, XLAL_EFUNC ); XLALDestroySFTCatalog ( catalog ); /* ---------- do some sanity checks of consistency of SFTs ----------*/ XLAL_CHECK_MAIN ( SFTs1->length == SFTs2->length, XLAL_EINVAL, "Number of SFTs differ for SFTbname1 and SFTbname2!\n"); for ( UINT4 i=0; i < SFTs1->length; i++ ) { SFTtype *sft1 = &(SFTs1->data[i]); SFTtype *sft2 = &(SFTs2->data[i]); if( strcmp( sft1->name, sft2->name ) ) { if ( lalDebugLevel ) { XLALPrintError("WARNING SFT %d: detector-prefix differ! '%s' != '%s'\n", i, sft1->name, sft2->name ); } /* exit (1); */ /* can't be too strict here, as we also allow v1-SFTs, which don't have detector-name */ } XLAL_CHECK_MAIN ( sft1->data->length == sft2->data->length, XLAL_EINVAL, "\nERROR SFT %d: lengths differ! %d != %d\n", i, sft1->data->length, sft2->data->length ); REAL8 Tdiff = XLALGPSDiff(&(sft1->epoch), &(sft2->epoch)); CHAR buf1[32], buf2[32];; XLAL_CHECK_MAIN ( Tdiff == 0.0, XLAL_EINVAL, "SFT %d: epochs differ: %s vs %s\n", i, XLALGPSToStr(buf1,&sft1->epoch), XLALGPSToStr(buf2,&sft2->epoch) ); XLAL_CHECK_MAIN ( sft1->f0 == sft2->f0, XLAL_EINVAL, "ERROR SFT %d: fmin differ: %fHz vs %fHz\n", i, sft1->f0, sft2->f0 ); XLAL_CHECK_MAIN ( sft1->deltaF == sft2->deltaF, XLAL_EINVAL, "ERROR SFT %d: deltaF differs: %fHz vs %fHz\n", i, sft1->deltaF, sft2->deltaF ); } /* for i < numSFTs */ /*---------- now do some actual comparisons ----------*/ XLAL_CHECK_MAIN ( (diffs = subtractSFTVectors ( SFTs1, SFTs2)) != NULL, XLAL_EFUNC ); if ( uvar.verbose) { for ( UINT4 i=0; i < SFTs1->length; i++) { SFTtype *sft1 = &(SFTs1->data[i]); SFTtype *sft2 = &(SFTs2->data[i]); XLALPrintInfo ("i=%02d: ", i); REAL4 norm1 = scalarProductSFT ( sft1, sft1 ); norm1 = sqrt(norm1); REAL4 norm2 = scalarProductSFT ( sft2, sft2 ); norm2 = sqrt(norm2); REAL4 scalar = scalarProductSFT ( sft1, sft2 ); REAL4 normdiff = scalarProductSFT ( &(diffs->data[i]), &(diffs->data[i]) ); REAL4 d1 = (norm1 - norm2)/norm1; REAL4 d2 = 1.0 - scalar / (norm1*norm2); REAL4 d3 = normdiff / (norm1*norm1 + norm2*norm2 ); REAL4 d4 = getMaxErrSFT (sft1, sft2); XLALPrintInfo ("(|x|-|y|)/|x|=%10.3e, 1-x.y/(|x||y|)=%10.3e, |x-y|^2/(|x|^2+|y|^2))=%10.3e, maxErr=%10.3e\n", d1, d2, d3, d4); } /* for i < SFTs->length */ } /* if verbose */ /* ---------- COMBINED measures ---------- */ { REAL4 ret; ret = scalarProductSFTVector ( SFTs1, SFTs1 ); REAL8 norm1 = sqrt( (REAL8)ret ); ret = scalarProductSFTVector ( SFTs2, SFTs2 ); REAL8 norm2 = sqrt( (REAL8)ret ); ret = scalarProductSFTVector ( SFTs1, SFTs2 ); REAL8 scalar = (REAL8) ret; ret = scalarProductSFTVector ( diffs, diffs ); REAL8 normdiff = (REAL8) ret; REAL8 d1 = (norm1 - norm2)/norm1; maxd = fmax ( maxd, d1 ); REAL8 d2 = 1.0 - scalar / (norm1*norm2); maxd = fmax ( maxd, d2 ); REAL8 d3 = normdiff / ( norm1*norm1 + norm2*norm2); maxd = fmax ( maxd, d3 ); REAL8 d4 = getMaxErrSFTVector (SFTs1, SFTs2); maxd = fmax ( maxd, d4 ); if ( uvar.verbose ) { printf ("\nTOTAL:(|x|-|y|)/|x|=%10.3e, 1-x.y/(|x||y|)=%10.3e, |x-y|^2/(|x|^2+|y|^2)=%10.3e, maxErr=%10.3e\n", d1, d2, d3, d4); } else { printf ("%10.3e %10.3e\n", d3, d4); } } /* combined total measures */ /* free memory */ XLALDestroySFTVector ( SFTs1 ); XLALDestroySFTVector ( SFTs2 ); XLALDestroySFTVector ( diffs ); XLALDestroyUserVars(); LALCheckMemoryLeaks(); if ( maxd <= uvar.relErrorMax ) { return 0; } else { return 1; } } /* main */
int main( void ) { // Load ephemeris data EphemerisData *edat = XLALInitBarycenter( TEST_DATA_DIR "earth00-19-DE405.dat.gz", TEST_DATA_DIR "sun00-19-DE405.dat.gz" ); XLAL_CHECK_MAIN( edat != NULL, XLAL_EFUNC ); // Create segment list LALSegList segments; XLAL_CHECK_MAIN( XLALSegListInit( &segments ) == XLAL_SUCCESS, XLAL_EFUNC ); for ( size_t n = 0; n < NUM_SEGS; ++n ) { const double Tspan = 3 * 86400; const double deltat[NUM_SEGS] = { -8 * 86400, 0, 8 * 86400 }; LALSeg segment; LIGOTimeGPS start_time = REF_TIME, end_time = REF_TIME; XLALGPSAdd( &start_time, deltat[n] - 0.5 * Tspan ); XLALGPSAdd( &end_time, deltat[n] + 0.5 * Tspan ); XLAL_CHECK_MAIN( XLALSegSet( &segment, &start_time, &end_time, 0 ) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK_MAIN( XLALSegListAppend( &segments, &segment ) == XLAL_SUCCESS, XLAL_EFUNC ); } // Compute supersky metrics SuperskyMetrics *metrics = NULL; { const LIGOTimeGPS ref_time = REF_TIME; const MultiLALDetector detectors = { .length = 1, .sites = { lalCachedDetectors[LAL_LLO_4K_DETECTOR] } }; metrics = XLALComputeSuperskyMetrics( 1, &ref_time, &segments, FIDUCIAL_FREQ, &detectors, NULL, DETMOTION_SPIN | DETMOTION_PTOLEORBIT, edat ); } XLAL_CHECK_MAIN( metrics != NULL, XLAL_EFUNC ); // Check coherent metrics for ( size_t n = 0; n < NUM_SEGS; ++n ) { XLAL_CHECK_MAIN( CheckSuperskyMetrics( metrics->coh_rssky_metric[n], coh_rssky_metric_refs[n], metrics->coh_rssky_transf[n], coh_rssky_transf_refs[n], coh_phys_mismatches[n], 1e-2 ) == XLAL_SUCCESS, XLAL_EFUNC ); } // Check semicoherent metric XLAL_CHECK_MAIN( CheckSuperskyMetrics( metrics->semi_rssky_metric, semi_rssky_metric_ref, metrics->semi_rssky_transf, semi_rssky_transf_ref, semi_phys_mismatch, 3e-2 ) == XLAL_SUCCESS, XLAL_EFUNC ); // Check semicoherent metric after round-trip frequency rescaling XLAL_CHECK_MAIN( XLALScaleSuperskyMetricsFiducialFreq( metrics, 257.52 ) == XLAL_SUCCESS, XLAL_EFUNC ); { double semi_rssky_metric_rescale[4][4]; memcpy( semi_rssky_metric_rescale, semi_rssky_metric_ref, sizeof( semi_rssky_metric_ref ) ); gsl_matrix_view semi_rssky_metric_rescale_view = gsl_matrix_view_array( ( double * )semi_rssky_metric_rescale, 4, 4 ); gsl_matrix_view sky_sky = gsl_matrix_submatrix( &semi_rssky_metric_rescale_view.matrix, 0, 0, 2, 2 ); gsl_matrix_scale( &sky_sky.matrix, ( 257.52 / FIDUCIAL_FREQ ) * ( 257.52 / FIDUCIAL_FREQ ) ); const double err = XLALCompareMetrics( metrics->semi_rssky_metric, &semi_rssky_metric_rescale_view.matrix ), err_tol = 1e-6; XLAL_CHECK( err <= err_tol, XLAL_ETOL, "'rssky_metric' check failed: err = %0.3e > %0.3e = err_tol", err, err_tol ); } XLAL_CHECK_MAIN( XLALScaleSuperskyMetricsFiducialFreq( metrics, FIDUCIAL_FREQ ) == XLAL_SUCCESS, XLAL_EFUNC ); XLAL_CHECK_MAIN( CheckSuperskyMetrics( metrics->semi_rssky_metric, semi_rssky_metric_ref, metrics->semi_rssky_transf, semi_rssky_transf_ref, semi_phys_mismatch, 3e-2 ) == XLAL_SUCCESS, XLAL_EFUNC ); // Cleanup XLALDestroyEphemerisData( edat ); XLALSegListClear( &segments ); XLALDestroySuperskyMetrics( metrics ); LALCheckMemoryLeaks(); return EXIT_SUCCESS; }
/* vvvvvvvvvvvvvvvvvvvvvvvvvvvvvv------------------------------------ */ int main(int argc, char *argv[]){ static LALStatus status; /* LALStatus pointer */ static LineNoiseInfo lines, lines2; static LineHarmonicsInfo harmonics; INT4 nLines=0, count1, nHarmonicSets; INT4 j, r; FILE *fpNstar=NULL; FILE *fpOut=NULL; INT4 *nstarVec=NULL; REAL8 *freqVec=NULL; INT4 nstarNum=0, minBin, maxBin; REAL8 timeBase=1800.0, minFreq, maxFreq; INT4 flag= 0; /* user input variables */ CHAR *uvar_nstarfile=NULL; CHAR *uvar_harmonicsfile=NULL; CHAR *uvar_cleannstar=NULL; /* set defaults */ uvar_nstarfile = (CHAR *)LALMalloc(512*sizeof(CHAR)); strcpy(uvar_nstarfile, NSTARFILE); uvar_harmonicsfile = (CHAR *)LALMalloc(512*sizeof(CHAR)); strcpy(uvar_harmonicsfile, HARMONICSFILE); uvar_cleannstar = (CHAR *)LALMalloc(512*sizeof(CHAR)); strcpy(uvar_cleannstar, CLEANNSTARFILE); /* register user input variables */ XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_nstarfile, "nstarfile", STRING, 'n', OPTIONAL, "File with max number counts") == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_harmonicsfile, "harmonicsfile", STRING, 'l', OPTIONAL, "File with line information") == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_cleannstar, "cleannstarfile", STRING, 'o', OPTIONAL, "Output file") == XLAL_SUCCESS, XLAL_EFUNC); /* read all command line variables */ BOOLEAN should_exit = 0; XLAL_CHECK_MAIN( XLALUserVarReadAllInput(&should_exit, argc, argv) == XLAL_SUCCESS, XLAL_EFUNC); if (should_exit) exit(1); /* find number of harmonics */ SUB( LALFindNumberHarmonics (&status, &harmonics, uvar_harmonicsfile), &status); nHarmonicSets = harmonics.nHarmonicSets; /* convert harmonics to explicit lines */ if (nHarmonicSets > 0) { harmonics.startFreq = (REAL8 *)LALMalloc(harmonics.nHarmonicSets * sizeof(REAL8)); harmonics.gapFreq = (REAL8 *)LALMalloc(harmonics.nHarmonicSets * sizeof(REAL8)); harmonics.numHarmonics = (INT4 *)LALMalloc(harmonics.nHarmonicSets * sizeof(INT4)); harmonics.leftWing = (REAL8 *)LALMalloc(harmonics.nHarmonicSets * sizeof(REAL8)); harmonics.rightWing = (REAL8 *)LALMalloc(harmonics.nHarmonicSets * sizeof(REAL8)); SUB( LALReadHarmonicsInfo( &status, &harmonics, uvar_harmonicsfile ), &status); nLines = 0; for (count1=0; count1 < nHarmonicSets; count1++) { nLines += *(harmonics.numHarmonics + count1); } lines.nLines = nLines; lines.lineFreq = (REAL8 *)LALMalloc(nLines * sizeof(REAL8)); lines.leftWing = (REAL8 *)LALMalloc(nLines * sizeof(REAL8)); lines.rightWing = (REAL8 *)LALMalloc(nLines * sizeof(REAL8)); SUB( LALHarmonics2Lines( &status, &lines, &harmonics), &status); } /* read file with nstar information */ fpNstar = fopen( uvar_nstarfile, "r"); if (fpNstar == NULL) { fprintf(stderr, "nstar file %s not found\n", uvar_nstarfile); exit(0); } /* first find number of nstar values */ nstarNum = 0; do { REAL8 temp1, temp2, temp3, temp4, temp5; r=fscanf(fpNstar,"%lf%lf%lf%lf%lf\n", &temp1, &temp2, &temp3, &temp4, &temp5); /* make sure the line has the right number of entries or is EOF */ if (r==5) nstarNum++; } while ( r != EOF); rewind(fpNstar); /* allocate memory for vector of nstar and freqstar */ nstarVec = (INT4 *)LALMalloc(nstarNum*sizeof(INT4)); freqVec = (REAL8 *)LALMalloc(nstarNum*sizeof(REAL8)); /* read nstarfile again */ for (j=0; j<nstarNum; j++) { REAL8 temp1, temp2, temp3, temp4, temp5; r=fscanf(fpNstar,"%lf%lf%lf%lf%lf\n", &temp1, &temp2, &temp3, &temp4, &temp5); if (r==5) { nstarVec[j] = temp1; freqVec[j] = temp2; } } /* now we are done with nstarfile */ fclose(fpNstar); /* calculate min and max frequency bins in nstarfile */ /* this assumes frequencies are ordered */ minBin = floor(freqVec[0]*timeBase + 0.5); maxBin = floor(freqVec[nstarNum-1]*timeBase + 0.5); minFreq = freqVec[0]; maxFreq = freqVec[nstarNum-1]; /* choose lines affecting frequency range */ lines2.nLines = nLines; lines2.lineFreq = (REAL8 *)LALMalloc(nLines * sizeof(REAL8)); lines2.leftWing = (REAL8 *)LALMalloc(nLines * sizeof(REAL8)); lines2.rightWing = (REAL8 *)LALMalloc(nLines * sizeof(REAL8)); SUB( LALChooseLines (&status, &lines2, &lines, minFreq, maxFreq), &status); SUB( LALCheckLines (&status, &flag, &lines2, 202.0), &status); /* clean the nstarVec */ if ( nstarNum > 0 ) { /* loop over lines and clean nstarVec*/ for (j=0; j<nLines; j++) { REAL8 lineFreq, leftWing, rightWing; INT4 lineBin, leftWingBins, rightWingBins; INT4 leftCount, rightCount; lineFreq = lines.lineFreq[j]; leftWing = lines.leftWing[j] + lineFreq*VTOT; rightWing = lines.rightWing[j] + lineFreq*VTOT; lineBin = floor( lineFreq*timeBase + 0.5); leftWingBins = floor( leftWing*timeBase + 0.5); rightWingBins = floor( rightWing*timeBase + 0.5); if ( (lineBin >= minBin) && (lineBin <= maxBin) ) { /* clean lineBin */ nstarVec[lineBin-minBin] = 0; /* now go left */ for (leftCount=0; leftCount < leftWingBins; leftCount++) { if (lineBin-minBin-leftCount > 0) { nstarVec[lineBin-minBin-leftCount-1] = 0; } } /* end of loop over leftwing */ /* now go right */ for (rightCount = 0; rightCount < rightWingBins; rightCount++) { if (maxBin - lineBin - rightCount > 0) { nstarVec[lineBin-minBin+rightCount+1]=0; } } /* end of loop over rightwing */ } /* end of if statement */ } /* end of loop over lines */ } /* end of cleaning */ /* now write the result */ fpOut = fopen(uvar_cleannstar, "w"); if (fpOut == NULL) { fprintf(stderr, "unable to open file %s for writing \n", uvar_cleannstar); exit(0); } for (j=0; j<nstarNum; j++) { fprintf(fpOut, "%d %f \n", nstarVec[j], freqVec[j]); } fclose(fpOut); /* Free memory */ LALFree(nstarVec); LALFree(freqVec); if (nLines > 0) { LALFree(lines.lineFreq); LALFree(lines.leftWing); LALFree(lines.rightWing); LALFree(lines2.lineFreq); LALFree(lines2.leftWing); LALFree(lines2.rightWing); } if (nHarmonicSets > 0) { LALFree(harmonics.startFreq); LALFree(harmonics.gapFreq); LALFree(harmonics.numHarmonics); LALFree(harmonics.leftWing); LALFree(harmonics.rightWing); } XLALDestroyUserVars(); LALCheckMemoryLeaks(); INFO( SFTCLEANC_MSGENORM ); return SFTCLEANC_ENORM; }
int main( int argc, char *argv[]){ static LALStatus status; static LALDetector detector; static LIGOTimeGPSVector timeV; static REAL8Cart3CoorVector velV; static REAL8Vector timeDiffV; static REAL8Vector foft; static PulsarSignalParams params; static SFTParams sftParams; static UCHARPeakGram pg1; static COMPLEX8SFTData1 sft1; static REAL8PeriodoPSD periPSD; REAL4TimeSeries *signalTseries = NULL; SFTVector *inputSFTs = NULL; SFTVector *outputSFTs = NULL; /* data about injected signal */ static PulsarData pulsarInject; /* the template */ static HoughTemplate pulsarTemplate, pulsarTemplate1; /*FILE *fpOUT = NULL; output file pointer */ FILE *fpLog = NULL; /* log file pointer */ CHAR *logstr=NULL; /* log string containing user input variables */ CHAR *fnamelog=NULL; /* name of log file */ INT4 nfSizeCylinder; EphemerisData *edat = NULL; INT4 mObsCoh, numberCount; REAL8 sftBand; REAL8 timeBase, deltaF, normalizeThr, threshold; UINT4 sftlength; INT4 sftFminBin; REAL8 fHeterodyne; REAL8 tSamplingRate; /* grid spacings */ REAL8 deltaTheta; INT4 mmP, mmT; /* for loop over mismatched templates */ /* user input variables */ INT4 uvar_ifo, uvar_blocksRngMed; REAL8 uvar_peakThreshold; REAL8 uvar_alpha, uvar_delta, uvar_h0, uvar_f0; REAL8 uvar_psi, uvar_phi0, uvar_fdot, uvar_cosiota; CHAR *uvar_earthEphemeris=NULL; CHAR *uvar_sunEphemeris=NULL; CHAR *uvar_sftDir=NULL; CHAR *uvar_fnameout=NULL; /* set up the default parameters */ nfSizeCylinder = NFSIZE; /* set other user input variables */ uvar_peakThreshold = THRESHOLD; uvar_ifo = IFO; uvar_blocksRngMed = BLOCKSRNGMED; /* set default pulsar parameters */ uvar_h0 = H0; uvar_alpha = ALPHA; uvar_delta = DELTA; uvar_f0 = F0; uvar_fdot = FDOT; uvar_psi = PSI; uvar_cosiota = COSIOTA; uvar_phi0 = PHI0; /* now set the default filenames */ uvar_earthEphemeris = (CHAR *)LALMalloc(512*sizeof(CHAR)); strcpy(uvar_earthEphemeris,EARTHEPHEMERIS); uvar_sunEphemeris = (CHAR *)LALMalloc(512*sizeof(CHAR)); strcpy(uvar_sunEphemeris,SUNEPHEMERIS); uvar_sftDir = (CHAR *)LALMalloc(512*sizeof(CHAR)); strcpy(uvar_sftDir,SFTDIRECTORY); uvar_fnameout = (CHAR *)LALMalloc(512*sizeof(CHAR)); strcpy(uvar_fnameout, FILEOUT); /* register user input variables */ XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_ifo, "ifo", INT4, 'i', OPTIONAL, "Detector GEO(1) LLO(2) LHO(3)" ) == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_blocksRngMed, "blocksRngMed", INT4, 'w', OPTIONAL, "RngMed block size") == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_peakThreshold, "peakThreshold", REAL8, 't', OPTIONAL, "Peak selection threshold") == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_earthEphemeris, "earthEphemeris", STRING, 'E', OPTIONAL, "Earth Ephemeris file") == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_sunEphemeris, "sunEphemeris", STRING, 'S', OPTIONAL, "Sun Ephemeris file") == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_sftDir, "sftDir", STRING, 'D', OPTIONAL, "SFT Directory") == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_fnameout, "fnameout", STRING, 'o', OPTIONAL, "Output file prefix") == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_alpha, "alpha", REAL8, 'r', OPTIONAL, "Right ascension") == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_delta, "delta", REAL8, 'l', OPTIONAL, "Declination") == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_h0, "h0", REAL8, 'm', OPTIONAL, "h0 to inject") == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_f0, "f0", REAL8, 'f', OPTIONAL, "Start search frequency") == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_psi, "psi", REAL8, 'p', OPTIONAL, "Polarization angle") == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_phi0, "phi0", REAL8, 'P', OPTIONAL, "Initial phase") == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_cosiota, "cosiota", REAL8, 'c', OPTIONAL, "Cosine of iota") == XLAL_SUCCESS, XLAL_EFUNC); XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_fdot, "fdot", REAL8, 'd', OPTIONAL, "Spindown parameter") == XLAL_SUCCESS, XLAL_EFUNC); /* read all command line variables */ BOOLEAN should_exit = 0; XLAL_CHECK_MAIN( XLALUserVarReadAllInput(&should_exit, argc, argv, lalAppsVCSInfoList) == XLAL_SUCCESS, XLAL_EFUNC); if (should_exit) exit(1); /* write the log file */ fnamelog = (CHAR *)LALMalloc( 512*sizeof(CHAR)); strcpy(fnamelog, uvar_fnameout); strcat(fnamelog, "_log"); /* open the log file for writing */ if ((fpLog = fopen(fnamelog, "w")) == NULL) { fprintf(stderr, "Unable to open file %s for writing\n", fnamelog); LALFree(fnamelog); exit(1); } /* get the log string */ XLAL_CHECK_MAIN( ( logstr = XLALUserVarGetLog(UVAR_LOGFMT_CFGFILE) ) != NULL, XLAL_EFUNC); fprintf( fpLog, "## Log file for HoughMismatch\n\n"); fprintf( fpLog, "# User Input:\n"); fprintf( fpLog, "#-------------------------------------------\n"); fprintf( fpLog, "%s", logstr); LALFree(logstr); /* append an ident-string defining the exact CVS-version of the code used */ { CHAR command[1024] = ""; fprintf (fpLog, "\n\n# CVS-versions of executable:\n"); fprintf (fpLog, "# -----------------------------------------\n"); fclose (fpLog); sprintf (command, "ident %s | sort -u >> %s", argv[0], fnamelog); /* we don't check this. If it fails, we assume that */ /* one of the system-commands was not available, and */ /* therefore the CVS-versions will not be logged */ if ( system(command) ) fprintf (stderr, "\nsystem('%s') returned non-zero status!\n\n", command ); LALFree(fnamelog); } /* set peak selection threshold */ SUB( LALRngMedBias( &status, &normalizeThr, uvar_blocksRngMed ), &status ); threshold = uvar_peakThreshold/normalizeThr; /* set detector */ if (uvar_ifo ==1) detector=lalCachedDetectors[LALDetectorIndexGEO600DIFF]; if (uvar_ifo ==2) detector=lalCachedDetectors[LALDetectorIndexLLODIFF]; if (uvar_ifo ==3) detector=lalCachedDetectors[LALDetectorIndexLHODIFF]; /* copy user input values */ pulsarInject.f0 = uvar_f0; pulsarInject.latitude = uvar_delta; pulsarInject.longitude = uvar_alpha; pulsarInject.aPlus = 0.5 * uvar_h0 * ( 1.0 + uvar_cosiota * uvar_cosiota ); pulsarInject.aCross = uvar_h0 * uvar_cosiota; pulsarInject.psi = uvar_psi; pulsarInject.phi0 = uvar_phi0; pulsarInject.spindown.length = 1; pulsarInject.spindown.data = NULL; pulsarInject.spindown.data = (REAL8 *)LALMalloc(sizeof(REAL8)); pulsarInject.spindown.data[0] = uvar_fdot; /* copy these values also to the pulsar template */ /* template is complately matched at this point */ pulsarTemplate.f0 = uvar_f0; pulsarTemplate.latitude = uvar_delta; pulsarTemplate.longitude = uvar_alpha; pulsarTemplate.spindown.length = 1; pulsarTemplate.spindown.data = NULL; pulsarTemplate.spindown.data = (REAL8 *)LALMalloc(sizeof(REAL8)); pulsarTemplate.spindown.data[0] = uvar_fdot; /* allocate memory for mismatched spindown template */ pulsarTemplate1.spindown.length = 1; pulsarTemplate1.spindown.data = NULL; pulsarTemplate1.spindown.data = (REAL8 *)LALMalloc(sizeof(REAL8)); /* read sfts */ { CHAR *tempDir; tempDir = (CHAR *)LALMalloc(512*sizeof(CHAR)); strcpy(tempDir, uvar_sftDir); strcat(tempDir, "/*SFT*.*"); sftBand = 0.5; SUB( LALReadSFTfiles ( &status, &inputSFTs, uvar_f0 - sftBand, uvar_f0 + sftBand, nfSizeCylinder + uvar_blocksRngMed , tempDir), &status); LALFree(tempDir); } /* get sft parameters */ mObsCoh = inputSFTs->length; sftlength = inputSFTs->data->data->length; deltaF = inputSFTs->data->deltaF; timeBase = 1.0/deltaF; sftFminBin = floor( timeBase * inputSFTs->data->f0 + 0.5); fHeterodyne = sftFminBin*deltaF; tSamplingRate = 2.0*deltaF*(sftlength -1.); /* create timestamp vector */ timeV.length = mObsCoh; timeV.data = NULL; timeV.data = (LIGOTimeGPS *)LALMalloc(mObsCoh*sizeof(LIGOTimeGPS)); /* read timestamps */ { INT4 i; SFTtype *sft= NULL; sft = inputSFTs->data; for (i=0; i < mObsCoh; i++){ timeV.data[i].gpsSeconds = sft->epoch.gpsSeconds; timeV.data[i].gpsNanoSeconds = sft->epoch.gpsNanoSeconds; ++sft; } } /* compute the time difference relative to startTime for all SFT */ timeDiffV.length = mObsCoh; timeDiffV.data = NULL; timeDiffV.data = (REAL8 *)LALMalloc(mObsCoh*sizeof(REAL8)); { REAL8 t0, ts, tn, midTimeBase; INT4 j; midTimeBase=0.5*timeBase; ts = timeV.data[0].gpsSeconds; tn = timeV.data[0].gpsNanoSeconds * 1.00E-9; t0=ts+tn; timeDiffV.data[0] = midTimeBase; for (j=1; j< mObsCoh; ++j){ ts = timeV.data[j].gpsSeconds; tn = timeV.data[j].gpsNanoSeconds * 1.00E-9; timeDiffV.data[j] = ts+tn -t0+midTimeBase; } } /* compute detector velocity for those time stamps */ velV.length = mObsCoh; velV.data = NULL; velV.data = (REAL8Cart3Coor *)LALMalloc(mObsCoh*sizeof(REAL8Cart3Coor)); { VelocityPar velPar; REAL8 vel[3]; UINT4 j; velPar.detector = detector; velPar.tBase = timeBase; velPar.vTol = 0.0; /* irrelevant */ velPar.edat = NULL; /* read in ephemeris data */ XLAL_CHECK_MAIN( ( edat = XLALInitBarycenter( uvar_earthEphemeris, uvar_sunEphemeris ) ) != NULL, XLAL_EFUNC); velPar.edat = edat; /* calculate detector velocity */ for(j=0; j< velV.length; ++j){ velPar.startTime.gpsSeconds = timeV.data[j].gpsSeconds; velPar.startTime.gpsNanoSeconds = timeV.data[j].gpsNanoSeconds; SUB( LALAvgDetectorVel ( &status, vel, &velPar), &status ); velV.data[j].x= vel[0]; velV.data[j].y= vel[1]; velV.data[j].z= vel[2]; } } /* set grid spacings */ { deltaTheta = 1.0 / ( VTOT * uvar_f0 * timeBase ); /* currently unused: REAL8 deltaFdot = deltaF / timeBase; */ } /* allocate memory for f(t) pattern */ foft.length = mObsCoh; foft.data = NULL; foft.data = (REAL8 *)LALMalloc(mObsCoh*sizeof(REAL8)); /* allocate memory for Hough peripsd structure */ periPSD.periodogram.length = sftlength; periPSD.periodogram.data = NULL; periPSD.periodogram.data = (REAL8 *)LALMalloc(sftlength* sizeof(REAL8)); periPSD.psd.length = sftlength; periPSD.psd.data = NULL; periPSD.psd.data = (REAL8 *)LALMalloc(sftlength* sizeof(REAL8)); /* allocate memory for peakgram */ pg1.length = sftlength; pg1.data = NULL; pg1.data = (UCHAR *)LALMalloc(sftlength* sizeof(UCHAR)); /* generate signal and add to input sfts */ /* parameters for output sfts */ sftParams.Tsft = timeBase; sftParams.timestamps = &(timeV); sftParams.noiseSFTs = inputSFTs; /* signal generation parameters */ params.orbit.asini = 0 /* isolated pulsar */; /* params.transferFunction = NULL; */ params.site = &(detector); params.ephemerides = edat; params.startTimeGPS.gpsSeconds = timeV.data[0].gpsSeconds; /* start time of output time series */ params.startTimeGPS.gpsNanoSeconds = timeV.data[0].gpsNanoSeconds; /* start time of output time series */ params.duration = timeDiffV.data[mObsCoh-1] + 0.5 * timeBase; /* length of time series in seconds */ params.samplingRate = tSamplingRate; params.fHeterodyne = fHeterodyne; /* reference time for frequency and spindown is first timestamp */ params.pulsar.refTime.gpsSeconds = timeV.data[0].gpsSeconds; params.pulsar.refTime.gpsNanoSeconds = timeV.data[0].gpsNanoSeconds; params.pulsar.position.longitude = pulsarInject.longitude; params.pulsar.position.latitude = pulsarInject.latitude ; params.pulsar.position.system = COORDINATESYSTEM_EQUATORIAL; params.pulsar.psi = pulsarInject.psi; params.pulsar.aPlus = pulsarInject.aPlus; params.pulsar.aCross = pulsarInject.aCross; params.pulsar.phi0 = pulsarInject.phi0; params.pulsar.f0 = pulsarInject.f0; params.pulsar.spindown = &pulsarInject.spindown ; SUB( LALGeneratePulsarSignal(&status, &signalTseries, ¶ms ), &status); SUB( LALSignalToSFTs(&status, &outputSFTs, signalTseries, &sftParams), &status); /* fill in elements of sft structure sft1 used in peak selection */ sft1.length = sftlength; sft1.fminBinIndex = sftFminBin; sft1.timeBase = timeBase; /* loop over mismatched templates */ for (mmT = -2; mmT <= 2; mmT++) { for (mmP = -2; mmP <= 2; mmP++) { INT4 mmFactor; /* displace the template */ mmFactor = 1.0; pulsarTemplate1.f0 = pulsarTemplate.f0 /*+ mmFactor * mm * deltaF*/; pulsarTemplate1.latitude = pulsarTemplate.latitude + mmFactor * mmT * deltaTheta; pulsarTemplate1.longitude = pulsarTemplate.longitude + mmFactor * mmP * deltaTheta; pulsarTemplate1.spindown.data[0] = pulsarTemplate.spindown.data[0] /*+ mmFactor * mm * deltaFdot*/; numberCount = 0; /* now calculate the number count for the template */ INT4 j; for (j=0; j < mObsCoh; j++) { INT4 ind; sft1.epoch.gpsSeconds = timeV.data[j].gpsSeconds; sft1.epoch.gpsNanoSeconds = timeV.data[j].gpsNanoSeconds; sft1.data = outputSFTs->data[j].data->data; SUB( COMPLEX8SFT2Periodogram1(&status, &periPSD.periodogram, &sft1), &status ); SUB( LALPeriodo2PSDrng( &status, &periPSD.psd, &periPSD.periodogram, &uvar_blocksRngMed), &status ); SUB( LALSelectPeakColorNoise(&status,&pg1,&threshold,&periPSD), &status); SUB( ComputeFoft(&status, &foft, &pulsarTemplate1, &timeDiffV, &velV, timeBase), &status); ind = floor( foft.data[j]*timeBase - sftFminBin + 0.5); numberCount += pg1.data[ind]; } /* print the number count */ fprintf(stdout, "%d %d %d\n", mmT, mmP, numberCount); } } /* free structures created by signal generation routines */ LALFree(signalTseries->data->data); LALFree(signalTseries->data); LALFree(signalTseries); signalTseries =NULL; XLALDestroySFTVector( outputSFTs); /* destroy input sfts */ XLALDestroySFTVector( inputSFTs); /* free other structures */ LALFree(foft.data); LALFree(pulsarInject.spindown.data); LALFree(pulsarTemplate.spindown.data); LALFree(pulsarTemplate1.spindown.data); LALFree(timeV.data); LALFree(timeDiffV.data); LALFree(velV.data); XLALDestroyEphemerisData(edat); LALFree(periPSD.periodogram.data); LALFree(periPSD.psd.data); LALFree(pg1.data); XLALDestroyUserVars(); LALCheckMemoryLeaks(); INFO( DRIVEHOUGHCOLOR_MSGENORM ); return DRIVEHOUGHCOLOR_ENORM; }