int main(int argc, char *argv[]){ /* LALStatus pointer */ static LALStatus status; /* time and velocity */ static LIGOTimeGPSVector timeV; static REAL8Cart3CoorVector velV; static REAL8Vector timeDiffV; LIGOTimeGPS firstTimeStamp; /* standard pulsar sft types */ MultiSFTVector *inputSFTs = NULL; UINT4 binsSFT; UINT4 sftFminBin; UINT4 numsft; INT4 k; FILE *fp=NULL; /* information about all the ifos */ MultiDetectorStateSeries *mdetStates = NULL; UINT4 numifo; /* vector of weights */ REAL8Vector weightsV; /* ephemeris */ EphemerisData *edat=NULL; static UCHARPeakGram pg1; static HoughTemplate pulsarTemplate; static REAL8Vector foft; /* miscellaneous */ UINT4 mObsCoh; REAL8 timeBase, deltaF; REAL8 numberCount; /* Chi2Test parameters */ HoughParamsTest chi2Params; REAL8Vector numberCountV; /* Vector with the number count of each block inside */ REAL8 numberCountTotal; /* Sum over all the numberCounts */ REAL8 chi2; /* sft constraint variables */ LIGOTimeGPS startTimeGPS, endTimeGPS; LIGOTimeGPSVector *inputTimeStampsVector=NULL; REAL8 alphaPeak, meanN, sigmaN; /* user input variables */ BOOLEAN uvar_help, uvar_weighAM, uvar_weighNoise; INT4 uvar_blocksRngMed, uvar_nfSizeCylinder, uvar_maxBinsClean; REAL8 uvar_startTime, uvar_endTime; REAL8 uvar_fStart, uvar_peakThreshold, uvar_fSearchBand; REAL8 uvar_Alpha, uvar_Delta, uvar_Freq, uvar_fdot; REAL8 uvar_AlphaWeight, uvar_DeltaWeight; CHAR *uvar_earthEphemeris=NULL; CHAR *uvar_sunEphemeris=NULL; CHAR *uvar_sftDir=NULL; CHAR *uvar_timeStampsFile=NULL; CHAR *uvar_outfile=NULL; LALStringVector *uvar_linefiles=NULL; INT4 uvar_p; /* Set up the default parameters */ /* LAL error-handler */ lal_errhandler = LAL_ERR_EXIT; uvar_help = FALSE; uvar_weighAM = TRUE; uvar_weighNoise = TRUE; uvar_blocksRngMed = BLOCKSRNGMED; uvar_nfSizeCylinder = NFSIZE; uvar_fStart = F0; uvar_fSearchBand = FBAND; uvar_peakThreshold = THRESHOLD; uvar_maxBinsClean = 100; uvar_startTime= 0; uvar_endTime = LAL_INT4_MAX; uvar_Alpha = 1.0; uvar_Delta = 1.0; uvar_Freq = 310.0; uvar_fdot = 0.0; uvar_AlphaWeight = uvar_Alpha; uvar_DeltaWeight = uvar_Delta; uvar_p = NBLOCKSTEST; chi2Params.length=uvar_p; chi2Params.numberSFTp=NULL; chi2Params.sumWeight=NULL; chi2Params.sumWeightSquare=NULL; uvar_outfile = (CHAR *)LALCalloc( MAXFILENAMELENGTH , sizeof(CHAR)); strcpy(uvar_outfile, "./tempout"); uvar_earthEphemeris = (CHAR *)LALCalloc( MAXFILENAMELENGTH , sizeof(CHAR)); strcpy(uvar_earthEphemeris,EARTHEPHEMERIS); uvar_sunEphemeris = (CHAR *)LALCalloc( MAXFILENAMELENGTH , sizeof(CHAR)); strcpy(uvar_sunEphemeris,SUNEPHEMERIS); uvar_sftDir = (CHAR *)LALCalloc( MAXFILENAMELENGTH , sizeof(CHAR)); strcpy(uvar_sftDir,SFTDIRECTORY); /* register user input variables */ LAL_CALL( LALRegisterBOOLUserVar( &status, "help", 'h', UVAR_HELP, "Print this message", &uvar_help), &status); LAL_CALL( LALRegisterREALUserVar( &status, "fStart", 'f', UVAR_OPTIONAL, "Start search frequency", &uvar_fStart), &status); LAL_CALL( LALRegisterREALUserVar( &status, "fSearchBand", 'b', UVAR_OPTIONAL, "Search frequency band", &uvar_fSearchBand), &status); LAL_CALL( LALRegisterREALUserVar( &status, "startTime", 0, UVAR_OPTIONAL, "GPS start time of observation", &uvar_startTime), &status); LAL_CALL( LALRegisterREALUserVar( &status, "endTime", 0, UVAR_OPTIONAL, "GPS end time of observation", &uvar_endTime), &status); LAL_CALL( LALRegisterSTRINGUserVar( &status, "timeStampsFile", 0, UVAR_OPTIONAL, "Input time-stamps file", &uvar_timeStampsFile), &status); LAL_CALL( LALRegisterREALUserVar( &status, "peakThreshold", 0, UVAR_OPTIONAL, "Peak selection threshold", &uvar_peakThreshold), &status); LAL_CALL( LALRegisterBOOLUserVar( &status, "weighAM", 0, UVAR_OPTIONAL, "Use amplitude modulation weights", &uvar_weighAM), &status); LAL_CALL( LALRegisterBOOLUserVar( &status, "weighNoise", 0, UVAR_OPTIONAL, "Use SFT noise weights", &uvar_weighNoise), &status); LAL_CALL( LALRegisterSTRINGUserVar( &status, "earthEphemeris", 'E', UVAR_OPTIONAL, "Earth Ephemeris file", &uvar_earthEphemeris), &status); LAL_CALL( LALRegisterSTRINGUserVar( &status, "sunEphemeris", 'S', UVAR_OPTIONAL, "Sun Ephemeris file", &uvar_sunEphemeris), &status); LAL_CALL( LALRegisterSTRINGUserVar( &status, "sftDir", 'D', UVAR_REQUIRED, "SFT filename pattern", &uvar_sftDir), &status); LAL_CALL( LALRegisterLISTUserVar( &status, "linefiles", 0, UVAR_OPTIONAL, "Comma separated List of linefiles (filenames must contain IFO name)", &uvar_linefiles), &status); LAL_CALL( LALRegisterREALUserVar( &status, "Alpha", 0, UVAR_OPTIONAL, "Sky location (longitude)", &uvar_Alpha), &status); LAL_CALL( LALRegisterREALUserVar( &status, "Delta", 0, UVAR_OPTIONAL, "Sky location (latitude)", &uvar_Delta), &status); LAL_CALL( LALRegisterREALUserVar( &status, "Freq", 0, UVAR_OPTIONAL, "Template frequency", &uvar_Freq), &status); LAL_CALL( LALRegisterREALUserVar( &status, "fdot", 0, UVAR_OPTIONAL, "First spindown", &uvar_fdot), &status); LAL_CALL( LALRegisterREALUserVar( &status, "AlphaWeight", 0, UVAR_OPTIONAL, "sky Alpha for weight calculation", &uvar_AlphaWeight), &status); LAL_CALL( LALRegisterREALUserVar( &status, "DeltaWeight", 0, UVAR_OPTIONAL, "sky Delta for weight calculation", &uvar_DeltaWeight), &status); LAL_CALL( LALRegisterINTUserVar( &status, "nfSizeCylinder", 0, UVAR_OPTIONAL, "Size of cylinder of PHMDs", &uvar_nfSizeCylinder), &status); LAL_CALL( LALRegisterINTUserVar( &status, "blocksRngMed", 0, UVAR_OPTIONAL, "Running Median block size", &uvar_blocksRngMed), &status); LAL_CALL( LALRegisterINTUserVar( &status, "maxBinsClean", 0, UVAR_OPTIONAL, "Maximum number of bins in cleaning", &uvar_maxBinsClean), &status); LAL_CALL( LALRegisterSTRINGUserVar( &status, "outfile", 0, UVAR_OPTIONAL, "output file name", &uvar_outfile), &status); LAL_CALL( LALRegisterINTUserVar( &status, "pdatablock", 'p', UVAR_OPTIONAL, "Number of data blocks for veto tests", &uvar_p), &status); /* read all command line variables */ LAL_CALL( LALUserVarReadAllInput(&status, argc, argv), &status); /* exit if help was required */ if (uvar_help) exit(0); /* very basic consistency checks on user input */ if ( uvar_fStart < 0 ) { fprintf(stderr, "start frequency must be positive\n"); exit(1); } if ( uvar_fSearchBand < 0 ) { fprintf(stderr, "search frequency band must be positive\n"); exit(1); } if ( uvar_peakThreshold < 0 ) { fprintf(stderr, "peak selection threshold must be positive\n"); exit(1); } /***** start main calculations *****/ chi2Params.length=uvar_p; chi2Params.numberSFTp = (UINT4 *)LALMalloc( uvar_p*sizeof(UINT4)); chi2Params.sumWeight = (REAL8 *)LALMalloc( uvar_p*sizeof(REAL8)); chi2Params.sumWeightSquare = (REAL8 *)LALMalloc( uvar_p*sizeof(REAL8)); /* read sft Files and set up weights */ { /* new SFT I/O data types */ SFTCatalog *catalog = NULL; static SFTConstraints constraints; REAL8 doppWings, f_min, f_max; /* set detector constraint */ constraints.detector = NULL; if ( LALUserVarWasSet( &uvar_startTime ) ) { XLALGPSSetREAL8(&startTimeGPS, uvar_startTime); constraints.minStartTime = &startTimeGPS; } if ( LALUserVarWasSet( &uvar_endTime ) ) { XLALGPSSetREAL8(&endTimeGPS, uvar_endTime); constraints.maxEndTime = &endTimeGPS; } if ( LALUserVarWasSet( &uvar_timeStampsFile ) ) { LAL_CALL ( LALReadTimestampsFile ( &status, &inputTimeStampsVector, uvar_timeStampsFile), &status); constraints.timestamps = inputTimeStampsVector; } /* get sft catalog */ LAL_CALL( LALSFTdataFind( &status, &catalog, uvar_sftDir, &constraints), &status); if ( (catalog == NULL) || (catalog->length == 0) ) { fprintf (stderr,"Unable to match any SFTs with pattern '%s'\n", uvar_sftDir ); exit(1); } /* now we can free the inputTimeStampsVector */ if ( LALUserVarWasSet( &uvar_timeStampsFile ) ) { LALDestroyTimestampVector ( &status, &inputTimeStampsVector); } /* get some sft parameters */ mObsCoh = catalog->length; /* number of sfts */ deltaF = catalog->data->header.deltaF; /* frequency resolution */ timeBase= 1.0/deltaF; /* coherent integration time */ // unused: UINT8 f0Bin = floor( uvar_fStart * timeBase + 0.5); /* initial search frequency */ // unused: INT4 length = uvar_fSearchBand * timeBase; /* total number of search bins - 1 */ /* catalog is ordered in time so we can get start, end time and tObs*/ firstTimeStamp = catalog->data[0].header.epoch; // unused: LIGOTimeGPS lastTimeStamp = catalog->data[mObsCoh - 1].header.epoch; /* allocate memory for velocity vector */ velV.length = mObsCoh; velV.data = NULL; velV.data = (REAL8Cart3Coor *)LALCalloc(mObsCoh, sizeof(REAL8Cart3Coor)); /* allocate memory for timestamps vector */ timeV.length = mObsCoh; timeV.data = NULL; timeV.data = (LIGOTimeGPS *)LALCalloc( mObsCoh, sizeof(LIGOTimeGPS)); /* allocate memory for vector of time differences from start */ timeDiffV.length = mObsCoh; timeDiffV.data = NULL; timeDiffV.data = (REAL8 *)LALCalloc(mObsCoh, sizeof(REAL8)); /* add wings for Doppler modulation and running median block size*/ doppWings = (uvar_fStart + uvar_fSearchBand) * VTOT; f_min = uvar_fStart - doppWings - (uvar_blocksRngMed + uvar_nfSizeCylinder) * deltaF; f_max = uvar_fStart + uvar_fSearchBand + doppWings + (uvar_blocksRngMed + uvar_nfSizeCylinder) * deltaF; /* read sft files making sure to add extra bins for running median */ /* read the sfts */ LAL_CALL( LALLoadMultiSFTs ( &status, &inputSFTs, catalog, f_min, f_max), &status); /* clean sfts if required */ if ( LALUserVarWasSet( &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" ); exit(1); } if ( (ranCount = fread(&seed, sizeof(seed), 1, fpRand)) != 1 ) { fprintf(stderr,"Error in getting random seed" ); exit(1); } 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 */ /* SFT info -- assume all SFTs have same length */ numifo = inputSFTs->length; binsSFT = inputSFTs->data[0]->data->data->length; sftFminBin = (INT4) floor(inputSFTs->data[0]->data[0].f0 * timeBase + 0.5); LAL_CALL( LALDestroySFTCatalog( &status, &catalog ), &status); } /* end of sft reading block */ /* get detector velocities weights vector, and timestamps */ { MultiNoiseWeights *multweight = NULL; MultiPSDVector *multPSD = NULL; UINT4 iIFO, iSFT, j; /* get ephemeris */ edat = (EphemerisData *)LALCalloc(1, sizeof(EphemerisData)); (*edat).ephiles.earthEphemeris = uvar_earthEphemeris; (*edat).ephiles.sunEphemeris = uvar_sunEphemeris; LAL_CALL( LALInitBarycenter( &status, edat), &status); /* normalize sfts */ LAL_CALL( LALNormalizeMultiSFTVect (&status, &multPSD, inputSFTs, uvar_blocksRngMed), &status); /* set up weights */ weightsV.length = mObsCoh; weightsV.data = (REAL8 *)LALCalloc(1, mObsCoh * sizeof(REAL8)); /* initialize all weights to unity */ LAL_CALL( LALHOUGHInitializeWeights( &status, &weightsV), &status); /* compute multi noise weights if required */ if ( uvar_weighNoise ) { LAL_CALL ( LALComputeMultiNoiseWeights ( &status, &multweight, multPSD, uvar_blocksRngMed, 0), &status); } /* we are now done with the psd */ LAL_CALL ( LALDestroyMultiPSDVector ( &status, &multPSD), &status); /* get information about all detectors including velocity and timestamps */ /* note that this function returns the velocity at the mid-time of the SFTs -- should not make any difference */ LAL_CALL ( LALGetMultiDetectorStates ( &status, &mdetStates, inputSFTs, edat), &status); /* copy the timestamps, weights, and velocity vector */ for (j = 0, iIFO = 0; iIFO < numifo; iIFO++ ) { numsft = mdetStates->data[iIFO]->length; for ( iSFT = 0; iSFT < numsft; iSFT++, j++) { velV.data[j].x = mdetStates->data[iIFO]->data[iSFT].vDetector[0]; velV.data[j].y = mdetStates->data[iIFO]->data[iSFT].vDetector[1]; velV.data[j].z = mdetStates->data[iIFO]->data[iSFT].vDetector[2]; if ( uvar_weighNoise ) weightsV.data[j] = multweight->data[iIFO]->data[iSFT]; /* mid time of sfts */ timeV.data[j] = mdetStates->data[iIFO]->data[iSFT].tGPS; } /* loop over SFTs */ } /* loop over IFOs */ if ( uvar_weighNoise ) { LAL_CALL( LALHOUGHNormalizeWeights( &status, &weightsV), &status); } /* compute the time difference relative to startTime for all SFTs */ for(j = 0; j < mObsCoh; j++) timeDiffV.data[j] = XLALGPSDiff( timeV.data + j, &firstTimeStamp ); if ( uvar_weighNoise ) { LAL_CALL ( LALDestroyMultiNoiseWeights ( &status, &multweight), &status); } } /* end block for noise weights, velocity and time */ /* calculate amplitude modulation weights if required */ if (uvar_weighAM) { MultiAMCoeffs *multiAMcoef = NULL; UINT4 iIFO, iSFT; SkyPosition skypos; /* get the amplitude modulation coefficients */ skypos.longitude = uvar_AlphaWeight; skypos.latitude = uvar_DeltaWeight; skypos.system = COORDINATESYSTEM_EQUATORIAL; LAL_CALL ( LALGetMultiAMCoeffs ( &status, &multiAMcoef, mdetStates, skypos), &status); /* loop over the weights and multiply them by the appropriate AM coefficients */ for ( k = 0, iIFO = 0; iIFO < numifo; iIFO++) { numsft = mdetStates->data[iIFO]->length; for ( iSFT = 0; iSFT < numsft; iSFT++, k++) { REAL8 a, b; a = multiAMcoef->data[iIFO]->a->data[iSFT]; b = multiAMcoef->data[iIFO]->b->data[iSFT]; weightsV.data[k] *= (a*a + b*b); } /* loop over SFTs */ } /* loop over IFOs */ LAL_CALL( LALHOUGHNormalizeWeights( &status, &weightsV), &status); XLALDestroyMultiAMCoeffs ( multiAMcoef ); } /* end AM weights calculation */ /* misc. memory allocations */ /* memory for one spindown */ pulsarTemplate.spindown.length = 1; pulsarTemplate.spindown.data = NULL; pulsarTemplate.spindown.data = (REAL8 *)LALMalloc(sizeof(REAL8)); /* copy template parameters */ pulsarTemplate.spindown.data[0] = uvar_fdot; pulsarTemplate.f0 = uvar_Freq; pulsarTemplate.latitude = uvar_Delta; pulsarTemplate.longitude = uvar_Alpha; /* memory for f(t) vector */ foft.length = mObsCoh; foft.data = NULL; foft.data = (REAL8 *)LALMalloc(mObsCoh*sizeof(REAL8)); /* memory for peakgram */ pg1.length = binsSFT; pg1.data = NULL; pg1.data = (UCHAR *)LALCalloc( binsSFT, sizeof(UCHAR)); /* memory for number Count Vector */ numberCountV.length = uvar_p; numberCountV.data = NULL; numberCountV.data = (REAL8 *)LALMalloc( uvar_p*sizeof(REAL8)); /* block for calculating peakgram and number count */ { UINT4 iIFO, iSFT, ii, numberSFTp; INT4 ind; REAL8 sumWeightSquare; SFTtype *sft; /* compute mean and sigma for noise only */ /* first calculate the sum of the weights squared */ sumWeightSquare = 0.0; for ( k = 0; k < (INT4)mObsCoh; k++) sumWeightSquare += weightsV.data[k] * weightsV.data[k]; /* probability of selecting a peak expected mean and standard deviation for noise only */ alphaPeak = exp( - uvar_peakThreshold); meanN = mObsCoh* alphaPeak; sigmaN = sqrt(sumWeightSquare * alphaPeak * (1.0 - alphaPeak)); /* the received frequency as a function of time */ LAL_CALL( ComputeFoft(&status, &foft, &pulsarTemplate, &timeDiffV, &velV, timeBase), &status); LAL_CALL(SplitSFTs(&status, &weightsV, &chi2Params), &status); /* loop over SFT, generate peakgram and get number count */ UINT4 j; j=0; iIFO=0; iSFT=0; numsft = mdetStates->data[iIFO]->length; for (k=0 ; k<uvar_p ; k++ ){ numberSFTp=chi2Params.numberSFTp[k]; numberCount = 0; for (ii=0 ; (ii < numberSFTp)&&(iIFO<numifo) ; ii++) { sft = inputSFTs->data[iIFO]->data + iSFT; LAL_CALL (SFTtoUCHARPeakGram( &status, &pg1, sft, uvar_peakThreshold), &status); ind = floor( foft.data[j]*timeBase - sftFminBin + 0.5); numberCount += pg1.data[ind]*weightsV.data[j]; j++; iSFT++; if (iSFT >= numsft){ iIFO++; iSFT=0; if (iIFO<numifo){ numsft = mdetStates->data[iIFO]->length; } } } /* loop over SFTs */ numberCountV.data[k]=numberCount; } /* loop over blocks */ } /* Chi2 Test */ { REAL8 eta; /* Auxiliar variable */ REAL8 nj, sumWeightj, sumWeightSquarej; numberCountTotal=0; chi2=0; for(k=0; k<uvar_p ; k++){ numberCountTotal += numberCountV.data[k]; } eta=numberCountTotal/mObsCoh; INT4 j; for(j=0 ; j<(uvar_p) ; j++){ nj=numberCountV.data[j]; sumWeightj=chi2Params.sumWeight[j]; sumWeightSquarej=chi2Params.sumWeightSquare[j]; chi2 += (nj-sumWeightj*eta)*(nj-sumWeightj*eta)/(sumWeightSquarej*eta*(1-eta)); } } fp = fopen(uvar_outfile , "w"); setvbuf(fp, (char *)NULL, _IOLBF, 0); fprintf(fp, "%g %g %g %g %g %g %g %g \n", (numberCountTotal - meanN)/sigmaN, meanN ,sigmaN, chi2, uvar_Freq, uvar_Alpha, uvar_Delta, uvar_fdot); /* fprintf(stdout, "%g %g %g %g %g %g %g %g \n", (numberCountTotal - meanN)/sigmaN, meanN ,sigmaN, chi2, uvar_Freq, uvar_Alpha, uvar_Delta, uvar_fdot);*/ fclose(fp); /* free memory */ LALFree(pulsarTemplate.spindown.data); LALFree(timeV.data); LALFree(timeDiffV.data); LALFree(foft.data); LALFree(velV.data); LALFree(weightsV.data); XLALDestroyMultiDetectorStateSeries ( mdetStates ); LALFree(edat->ephemE); LALFree(edat->ephemS); LALFree(edat); LAL_CALL (LALDestroyMultiSFTVector(&status, &inputSFTs), &status ); LALFree(pg1.data); LALFree(numberCountV.data); LALFree(chi2Params.numberSFTp); LALFree(chi2Params.sumWeight); LALFree(chi2Params.sumWeightSquare); LAL_CALL (LALDestroyUserVars(&status), &status); LALCheckMemoryLeaks(); if ( lalDebugLevel ) REPORTSTATUS ( &status); return status.statusCode; }
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; }