int main(int argc, char *argv[]) { FILE *fp = NULL; BarycenterInput XLAL_INIT_DECL(baryinput); INT4 leap0,leap; LIGOTimeGPS epoch; LIGOTimeGPS TstartSSB, TendSSB, TendGPS; INT4 n; LIGOTimeGPS *TSSB = NULL; MJDTime TstartUTCMJD; LIGOTimeGPS TDET; REAL8 temp; INT4 i; MJDTime tempTOA; REAL8 dt; LIGOTimeGPS TstartGPS; MJDTime *TOA = NULL; CHAR tempstr[18]; CHAR *tempstr2; CHAR TstartMJDstr[20],TfinishMJDstr[20],TOAstr[22]; PulsarSignalParams pulsarparams; CHAR parfile[256]; CHAR timfile[256]; CHAR detcode[16]; REAL8 TstartUTCMJDtest; REAL8 diff; MJDTime MJDdiff, MJDtest; MJDTime TrefTDBMJD; LIGOTimeGPS TrefSSB_TDB_GPS; // ---------------------------------------------------------------------- UserVariables_t XLAL_INIT_DECL(uvar); XLAL_CHECK ( initUserVars (argc, argv, &uvar) == XLAL_SUCCESS, XLAL_EFUNC ); unsigned int seed = uvar.randSeed; if ( uvar.randSeed == 0 ) { seed = clock(); } srand ( seed ); // ----- sky position: random or user-specified ---------- REAL8 alpha, delta; CHAR *RAJ = NULL, *DECJ = NULL; BOOLEAN have_RAJ = XLALUserVarWasSet ( &uvar.RAJ ); BOOLEAN have_DECJ = XLALUserVarWasSet ( &uvar.DECJ ); if ( have_RAJ ) { XLAL_CHECK ( XLALTranslateHMStoRAD ( &alpha, uvar.RAJ ) == XLAL_SUCCESS, XLAL_EFUNC ); RAJ = XLALStringDuplicate ( uvar.RAJ ); } else { // pick randomly alpha = LAL_TWOPI * (1.0 * rand() / ( RAND_MAX + 1.0 ) ); // alpha uniform in [0, 2pi) XLAL_CHECK ( (RAJ = XLALTranslateRADtoHMS ( alpha )) != NULL, XLAL_EFUNC ); } if ( have_DECJ ) { XLAL_CHECK ( XLALTranslateDMStoRAD ( &delta, uvar.DECJ ) == XLAL_SUCCESS, XLAL_EFUNC ); DECJ = XLALStringDuplicate ( uvar.DECJ ); } else { // pick randomly delta = LAL_PI_2 - acos ( 1 - 2.0 * rand()/RAND_MAX ); // sin(delta) uniform in [-1,1] XLAL_CHECK ( (DECJ = XLALTranslateRADtoDMS ( delta )) != NULL, XLAL_EFUNC ); } /* define start time in an MJD structure */ REAL8toMJD ( &TstartUTCMJD, uvar.TstartUTCMJD ); XLALPrintInfo ( "TstartUTCMJD=%f converted to MJD days = %d fracdays = %6.12f\n", uvar.TstartUTCMJD, TstartUTCMJD.days, TstartUTCMJD.fracdays ); /* convert back to test conversions */ TstartUTCMJDtest = MJDtoREAL8 (TstartUTCMJD); diff = uvar.TstartUTCMJD - TstartUTCMJDtest; if ( fabs(diff) > 1e-9) { fprintf(stderr,"ERROR : Time conversion gives discrepancy of %e sec. Exiting.\n",diff); return(-1); } XLALPrintInfo ( "MJD conversion gives discrepancies of %e sec\n", diff); /* use start time to define an epoch for the leap seconds */ /* Note that epochs are defined in TDB !!! but here we only need to be rough to get a leap second value */ TDBMJDtoGPS(&epoch,TstartUTCMJD); XLALPrintInfo ( "leap second epoch = %d %d\n",epoch.gpsSeconds,epoch.gpsNanoSeconds); /* deal with ephemeris files and compute leap seconds */ EphemerisData *edat; XLAL_CHECK ( (edat = XLALInitBarycenter( uvar.ephemEarth, uvar.ephemSun )) != NULL, XLAL_EFUNC ); leap0 = XLALGPSLeapSeconds (epoch.gpsSeconds); XLALPrintInfo ( "leap seconds = %d\n",leap0); /* select detector location */ if (strcmp(uvar.Observatory,"GBT")==0) { baryinput.site.location[0] = GBT_LOCATION_X; baryinput.site.location[1] = GBT_LOCATION_Y; baryinput.site.location[2] = GBT_LOCATION_Z; sprintf(detcode,"gbt"); } else if (strcmp(uvar.Observatory,"NARRABRI")==0) { baryinput.site.location[0] = NARRABRI_LOCATION_X; baryinput.site.location[1] = NARRABRI_LOCATION_Y; baryinput.site.location[2] = NARRABRI_LOCATION_Z; sprintf(detcode,"atca"); } else if (strcmp(uvar.Observatory,"ARECIBO")==0) { baryinput.site.location[0] = ARECIBO_LOCATION_X; baryinput.site.location[1] = ARECIBO_LOCATION_Y; baryinput.site.location[2] = ARECIBO_LOCATION_Z; sprintf(detcode,"ao"); } else if (strcmp(uvar.Observatory,"NANSHAN")==0) { baryinput.site.location[0] = NANSHAN_LOCATION_X; baryinput.site.location[1] = NANSHAN_LOCATION_Y; baryinput.site.location[2] = NANSHAN_LOCATION_Z; sprintf(detcode,"nanshan"); } else if (strcmp(uvar.Observatory,"DSS_43")==0) { baryinput.site.location[0] = DSS_43_LOCATION_X; baryinput.site.location[1] = DSS_43_LOCATION_Y; baryinput.site.location[2] = DSS_43_LOCATION_Z; sprintf(detcode,"tid43"); } else if (strcmp(uvar.Observatory,"PARKES")==0) { baryinput.site.location[0] = PARKES_LOCATION_X; baryinput.site.location[1] = PARKES_LOCATION_Y; baryinput.site.location[2] = PARKES_LOCATION_Z; sprintf(detcode,"pks"); } else if (strcmp(uvar.Observatory,"JODRELL")==0) { baryinput.site.location[0] = JODRELL_LOCATION_X; baryinput.site.location[1] = JODRELL_LOCATION_Y; baryinput.site.location[2] = JODRELL_LOCATION_Z; sprintf(detcode,"jb"); } else if (strcmp(uvar.Observatory,"VLA")==0) { baryinput.site.location[0] = VLA_LOCATION_X; baryinput.site.location[1] = VLA_LOCATION_Y; baryinput.site.location[2] = VLA_LOCATION_Z; sprintf(detcode,"vla"); } else if (strcmp(uvar.Observatory,"NANCAY")==0) { baryinput.site.location[0] = NANCAY_LOCATION_X; baryinput.site.location[1] = NANCAY_LOCATION_Y; baryinput.site.location[2] = NANCAY_LOCATION_Z; sprintf(detcode,"ncy"); } else if (strcmp(uvar.Observatory,"EFFELSBERG")==0) { baryinput.site.location[0] = EFFELSBERG_LOCATION_X; baryinput.site.location[1] = EFFELSBERG_LOCATION_Y; baryinput.site.location[2] = EFFELSBERG_LOCATION_Z; sprintf(detcode,"eff"); } else if (strcmp(uvar.Observatory,"JODRELLM4")==0) { baryinput.site.location[0] = JODRELLM4_LOCATION_X; baryinput.site.location[1] = JODRELLM4_LOCATION_Y; baryinput.site.location[2] = JODRELLM4_LOCATION_Z; sprintf(detcode,"jbm4"); } else if (strcmp(uvar.Observatory,"GB300")==0) { baryinput.site.location[0] = GB300_LOCATION_X; baryinput.site.location[1] = GB300_LOCATION_Y; baryinput.site.location[2] = GB300_LOCATION_Z; sprintf(detcode,"gb300"); } else if (strcmp(uvar.Observatory,"GB140")==0) { baryinput.site.location[0] = GB140_LOCATION_X; baryinput.site.location[1] = GB140_LOCATION_Y; baryinput.site.location[2] = GB140_LOCATION_Z; sprintf(detcode,"gb140"); } else if (strcmp(uvar.Observatory,"GB853")==0) { baryinput.site.location[0] = GB853_LOCATION_X; baryinput.site.location[1] = GB853_LOCATION_Y; baryinput.site.location[2] = GB853_LOCATION_Z; sprintf(detcode,"gb853"); } else if (strcmp(uvar.Observatory,"LA_PALMA")==0) { baryinput.site.location[0] = LA_PALMA_LOCATION_X; baryinput.site.location[1] = LA_PALMA_LOCATION_Y; baryinput.site.location[2] = LA_PALMA_LOCATION_Z; sprintf(detcode,"lap"); } else if (strcmp(uvar.Observatory,"Hobart")==0) { baryinput.site.location[0] = Hobart_LOCATION_X; baryinput.site.location[1] = Hobart_LOCATION_Y; baryinput.site.location[2] = Hobart_LOCATION_Z; sprintf(detcode,"hob"); } else if (strcmp(uvar.Observatory,"Hartebeesthoek")==0) { baryinput.site.location[0] = Hartebeesthoek_LOCATION_X; baryinput.site.location[1] = Hartebeesthoek_LOCATION_Y; baryinput.site.location[2] = Hartebeesthoek_LOCATION_Z; sprintf(detcode,"hart"); } else if (strcmp(uvar.Observatory,"WSRT")==0) { baryinput.site.location[0] = WSRT_LOCATION_X; baryinput.site.location[1] = WSRT_LOCATION_Y; baryinput.site.location[2] = WSRT_LOCATION_Z; sprintf(detcode,"wsrt"); } else if (strcmp(uvar.Observatory,"COE")==0) { baryinput.site.location[0] = COE_LOCATION_X; baryinput.site.location[1] = COE_LOCATION_Y; baryinput.site.location[2] = COE_LOCATION_Z; sprintf(detcode,"coe"); } else if (strcmp(uvar.Observatory,"SSB")!=0) { fprintf(stderr,"ERROR. Unknown Observatory %s. Exiting.\n",uvar.Observatory); return(-1); } XLALPrintInfo ( "selected observatory %s - observatoryt code = %s\n",uvar.Observatory,detcode); XLALPrintInfo ( "baryinput location = %6.12f %6.12f %6.12f\n",baryinput.site.location[0],baryinput.site.location[1],baryinput.site.location[2]); /* convert start time to UTC GPS */ UTCMJDtoGPS(&TstartGPS, TstartUTCMJD, leap0); XLALPrintInfo ( "TstartGPS = %d %d\n",TstartGPS.gpsSeconds,TstartGPS.gpsNanoSeconds); /* convert back to test conversion */ UTCGPStoMJD(&MJDtest,&TstartGPS,leap0); deltaMJD ( &MJDdiff, &MJDtest, &TstartUTCMJD ); diff = (MJDdiff.days+MJDdiff.fracdays)*86400; if ( fabs(diff) > 1e-9) { fprintf(stderr,"ERROR : Time conversion gives discrepancy of %e sec. Exiting.\n",diff); return(-1); } XLALPrintInfo ( "MJD conversion gives discrepancies of %e sec\n",diff); /* define reference time in an MJD structure */ REAL8toMJD ( &TrefTDBMJD, uvar.TrefTDBMJD ); XLALPrintInfo ( "TrefTDBMJD converted to MJD days = %d fracdays = %6.12f\n",TrefTDBMJD.days,TrefTDBMJD.fracdays); /* convert reference time to TDB GPS */ TDBMJDtoGPS(&TrefSSB_TDB_GPS,TrefTDBMJD); XLALPrintInfo ( "TrefSSB_TDB_GPS = %d %d\n",TrefSSB_TDB_GPS.gpsSeconds,TrefSSB_TDB_GPS.gpsNanoSeconds); /* convert back to test conversion */ TDBGPStoMJD ( &MJDtest, TrefSSB_TDB_GPS, leap0 ); deltaMJD ( &MJDdiff, &MJDtest, &TrefTDBMJD ); diff = (MJDdiff.days+MJDdiff.fracdays)*86400; if ( fabs(diff) > 1e-9) { fprintf(stderr,"ERROR : Time conversion gives discrepancy of %e sec. Exiting.\n",diff); return(-1); } XLALPrintInfo ( "MJD conversion gives discrepancies of %e sec\n",diff); /* fill in required pulsar params structure for Barycentering */ LALDetector *site = NULL; site = (LALDetector *)LALMalloc(sizeof(LALDetector)); site->location[0] = baryinput.site.location[0]; site->location[1] = baryinput.site.location[1]; site->location[2] = baryinput.site.location[2]; pulsarparams.site = site; pulsarparams.pulsar.position.longitude = alpha; pulsarparams.pulsar.position.latitude = delta; pulsarparams.pulsar.position.system = COORDINATESYSTEM_EQUATORIAL; pulsarparams.ephemerides = edat; /* generate SSB initial TOA in GPS */ XLALConvertGPS2SSB ( &TstartSSB, TstartGPS, &pulsarparams); XLALPrintInfo ( "TstartSSB = %d %d\n",TstartSSB.gpsSeconds,TstartSSB.gpsNanoSeconds); /* define TOA end time in GPS */ temp = uvar.DurationMJD*86400.0; TendGPS = TstartGPS; XLALGPSAdd(&TendGPS, temp); XLALPrintInfo ( "GPS end time of TOAs = %d %d\n",TendGPS.gpsSeconds,TendGPS.gpsNanoSeconds); /* generate SSB end time in GPS (force integer seconds) */ XLALConvertGPS2SSB (&TendSSB,TendGPS,&pulsarparams); XLALPrintInfo ( "TendSSB = %d %d\n",TendSSB.gpsSeconds,TendSSB.gpsNanoSeconds); /* define TOA seperation in the SSB */ dt = uvar.DeltaTMJD*86400.0; n = (INT4)ceil(uvar.DurationMJD/uvar.DeltaTMJD); XLALPrintInfo ( "TOA seperation at SSB = %g sec\n",dt); XLALPrintInfo ( "number of TOAs to generate = %d\n",n); /* allocate memory for artificial SSB TOAs */ TSSB = (LIGOTimeGPS *)LALMalloc(n*sizeof(LIGOTimeGPS)); TOA = (MJDTime *)LALMalloc(n*sizeof(MJDTime)); /* generate artificial SSB TOAs given the phase model phi = 2*pi*(f0*(t-tref) + 0.5*fdot*(t-tref)^2) */ for (i=0;i<n;i++) { REAL8 dtref,fnow,cyclefrac,dtcor; LIGOTimeGPS tnow; /* define current interval */ XLALPrintInfo ( "current (t-tstart) = %g sec\n", i * dt); /* define current t */ tnow = TstartSSB; XLALGPSAdd(&tnow, i * dt); XLALPrintInfo ( "current t = %d %d\n",tnow.gpsSeconds,tnow.gpsNanoSeconds); /* define current t-tref */ dtref = XLALGPSDiff(&tnow,&TrefSSB_TDB_GPS); XLALPrintInfo ( "current (t - tref) = %9.12f\n",dtref); dtcor = 1; while (dtcor>1e-9) { /* define actual cycle fraction at requested time */ cyclefrac = fmod(uvar.f0*dtref + 0.5*uvar.fdot*dtref*dtref,1.0); XLALPrintInfo ( "cyclefrac = %9.12f\n",cyclefrac); /* define instantaneous frequency */ fnow = uvar.f0 + uvar.fdot*dtref; XLALPrintInfo ( "instananeous frequency = %9.12f\n",fnow); /* add correction to time */ dtcor = cyclefrac/fnow; dtref -= dtcor; XLALPrintInfo ( "timing correction = %9.12f\n",dtcor); XLALPrintInfo ( "corrected dtref to = %9.12f\n",dtref); } // while dtcor>1e-9 /* define time of zero phase */ TSSB[i] = TrefSSB_TDB_GPS; XLALGPSAdd(&TSSB[i], dtref); XLALPrintInfo ( "TSSB[%d] = %d %d\n",i,TSSB[i].gpsSeconds,TSSB[i].gpsNanoSeconds); } // for i < n /* loop over SSB time of arrivals and compute detector time of arrivals */ for (i=0;i<n;i++) { LIGOTimeGPS TSSBtest; LIGOTimeGPS GPStest; /* convert SSB to Detector time */ int ret = XLALConvertSSB2GPS ( &TDET, TSSB[i], &pulsarparams); if ( ret != XLAL_SUCCESS ) { XLALPrintError ("XLALConvertSSB2GPS() failed with xlalErrno = %d\n", xlalErrno ); return(-1); } XLALPrintInfo ( "converted SSB TOA %d %d -> Detector TOA %d %d\n",TSSB[i].gpsSeconds,TSSB[i].gpsNanoSeconds,TDET.gpsSeconds,TDET.gpsNanoSeconds); /* convert back for testing conversion */ XLALConvertGPS2SSB (&TSSBtest,TDET,&pulsarparams); diff = XLALGPSDiff(&TSSBtest,&TSSB[i]); if ( fabs(diff) > 1e-9) { fprintf(stderr,"ERROR : Time conversion gives discrepancy of %e sec. Exiting.\n",diff); return(-1); } XLALPrintInfo ( "SSB -> detector conversion gives discrepancies of %e sec\n",diff); /* recompute leap seconds incase they've changed */ leap = XLALGPSLeapSeconds (TDET.gpsSeconds); /* must now convert to an MJD time for TEMPO */ /* Using UTC conversion as used by Matt in his successful comparison */ UTCGPStoMJD (&tempTOA,&TDET,leap); XLALPrintInfo ( "output MJD time = %d %6.12f\n",tempTOA.days,tempTOA.fracdays); /* convert back to test conversion */ UTCMJDtoGPS ( &GPStest, tempTOA, leap ); diff = XLALGPSDiff(&TDET,&GPStest); if ( fabs(diff) > 1e-9) { fprintf(stderr,"ERROR. Time conversion gives discrepancy of %e sec. Exiting.\n",diff); return(-1); } XLALPrintInfo ( "MJD time conversion gives discrepancies of %e sec\n",diff); /* fill in results */ TOA[i].days = tempTOA.days; TOA[i].fracdays = tempTOA.fracdays; } // for i < n snprintf(tempstr,15,"%1.13f",TOA[0].fracdays); tempstr2 = tempstr+2; snprintf(TstartMJDstr,19,"%d.%s",TOA[0].days,tempstr2); XLALPrintInfo ( "Converted initial TOA MJD %d %6.12f to the string %s\n",TOA[0].days,TOA[0].fracdays,TstartMJDstr); snprintf(tempstr,15,"%1.13f",TOA[n-1].fracdays); tempstr2 = tempstr+2; snprintf(TfinishMJDstr,19,"%d.%s",TOA[n-1].days,tempstr2); XLALPrintInfo ( "*** Converted MJD to a string %s\n",TfinishMJDstr); XLALPrintInfo ( "Converted final TOA MJD %d %6.12f to the string %s\n",TOA[n-1].days,TOA[n-1].fracdays,TfinishMJDstr); /* define output file names */ sprintf(parfile,"%s.par",uvar.PSRJ); sprintf(timfile,"%s.tim",uvar.PSRJ); /* output to par file in format required by TEMPO 2 */ if ((fp = fopen(parfile,"w")) == NULL) { fprintf(stderr,"ERROR. Could not open file %s. Exiting.\n",parfile); return(-1); } fprintf(fp,"PSRJ\t%s\n",uvar.PSRJ); fprintf(fp,"RAJ\t%s\t1\n",RAJ); fprintf(fp,"DECJ\t%s\t1\n",DECJ); fprintf(fp,"PEPOCH\t%6.12f\n",uvar.TrefTDBMJD); fprintf(fp,"POSEPOCH\t%6.12f\n",uvar.TrefTDBMJD); fprintf(fp,"DMEPOCH\t%6.12f\n",uvar.TrefTDBMJD); fprintf(fp,"DM\t0.0\n"); fprintf(fp,"F0\t%6.16f\t1\n",uvar.f0); fprintf(fp,"F1\t%6.16f\t0\n",uvar.fdot); fprintf(fp,"START\t%s\n",TstartMJDstr); fprintf(fp,"FINISH\t%s\n",TfinishMJDstr); fprintf(fp,"TZRSITE\t%s\n",detcode); fprintf(fp,"CLK\tUTC(NIST)\n"); fprintf(fp,"EPHEM\tDE405\n"); fprintf(fp,"UNITS\tTDB\n"); fprintf(fp,"MODE\t0\n"); /* close par file */ fclose(fp); /* output to tim file in format required by TEMPO 2 */ if ((fp = fopen(timfile,"w")) == NULL) { fprintf(stderr,"ERROR. Could not open file %s. Exiting.\n",timfile); return(-1); } fprintf(fp,"FORMAT 1\n"); for (i=0;i<n;i++) { /* convert each TOA to a string for output */ snprintf(tempstr,18,"%1.16f",TOA[i].fracdays); tempstr2 = tempstr+2; snprintf(TOAstr,22,"%d.%s",TOA[i].days,tempstr2); fprintf(fp,"blank.dat\t1000.0\t%s\t1.0\t%s\n",TOAstr,detcode); XLALPrintInfo ( "Converting MJD time %d %6.16f to string %s\n",TOA[i].days,TOA[i].fracdays,TOAstr); } // for i < n /* close tim file */ fclose(fp); /* free memory */ XLALFree ( TSSB ); XLALFree ( TOA ); XLALFree ( site ); XLALDestroyEphemerisData ( edat ); XLALDestroyUserVars (); LALCheckMemoryLeaks(); return XLAL_SUCCESS; } /* main() */
/* void RunGeneratePulsarSignalTest(LALStatus *status, int argc, char **argv) */ /* 02/02/05 gam */ void RunGeneratePulsarSignalTest(LALStatus *status) { INT4 i, j, k; /* all purpose indices */ INT4 iSky = 0; /* for loop over sky positions */ INT4 jDeriv = 0; /* for loop over spindowns */ INT4 testNumber = 0; /* which test is being run */ /* The input and output structs used by the functions being tested */ PulsarSignalParams *pPulsarSignalParams = NULL; REAL4TimeSeries *signalvec = NULL; SFTParams *pSFTParams = NULL; SkyConstAndZeroPsiAMResponse *pSkyConstAndZeroPsiAMResponse; SFTandSignalParams *pSFTandSignalParams; SFTVector *outputSFTs = NULL; SFTVector *fastOutputSFTs = NULL; REAL4 renorm; /* to renormalize SFTs to account for different effective sample rates */ /* containers for detector and ephemeris data */ LALDetector cachedDetector; CHAR IFO[6] = "LHO"; EphemerisData *edat = NULL; char earthFile[] = TEST_DATA_DIR "earth00-19-DE405.dat.gz"; char sunFile[] = TEST_DATA_DIR "sun00-19-DE405.dat.gz"; /* containers for sky position and spindown data */ REAL8 **skyPosData; REAL8 **freqDerivData; INT4 numSkyPosTotal = 8; INT4 numSpinDown = 1; INT4 numFreqDerivTotal = 2; INT4 numFreqDerivIncludingNoSpinDown; /* set below */ INT4 iFreq = 0; REAL8 cosTmpDEC; REAL8 tmpDeltaRA; REAL8 DeltaRA = 0.01; REAL8 DeltaDec = 0.01; REAL8 DeltaFDeriv1 = -1.0e-10; REAL8 DeltaFDeriv2 = 0.0; REAL8 DeltaFDeriv3 = 0.0; REAL8 DeltaFDeriv4 = 0.0; REAL8 DeltaFDeriv5 = 0.0; /* containers for number of SFTs, times to generate SFTs, reference time, and gap */ INT4 numSFTs = 4; REAL8 f0SFT = 943.12; REAL8 bandSFT = 0.5; UINT4 gpsStartTimeSec = 765432109; /* GPS start time of data requested seconds; example = Apr 08 2004 04:01:36 UTC */ UINT4 gpsStartTimeNan = 0; /* GPS start time of data requested nanoseconds */ LIGOTimeGPSVector *timeStamps; LIGOTimeGPS GPSin; /* holder for reference-time for pulsar parameters at the detector; will convert to SSB! */ REAL8 sftGap = 73.0; /* extra artificial gap between SFTs */ REAL8 tSFT = 1800.0; REAL8 duration = tSFT + (numSFTs - 1)*(tSFT + sftGap); INT4 nBinsSFT = (INT4)(bandSFT*tSFT + 0.5); /* additional parameters that determine what signals to test; note f0SGNL and bandSGNL must be compatible with f0SFT and bandSFT */ REAL8 f0SGNL = f0SFT + bandSFT/2.0; REAL8 dfSGNL = 1.0/tSFT; REAL8 bandSGNL = 0.005; INT4 nBinsSGNL = (INT4)(bandSGNL*tSFT + 0.5); INT4 nsamples = 18000; /* nsamples from SFT header; 2 x this would be the effective number of time samples used to create an SFT from raw data */ INT4 Dterms = 3; /* 09/07/05 gam; use Dterms to fill in SFT bins with fake data as per LALDemod else fill in bin with zero */ REAL8 h_0 = 7.0e-22; /* Source amplitude; use arbitrary small number for default */ REAL8 cosIota; /* cosine of inclination angle iota of the source */ /* variables for comparing differences */ REAL4 maxDiffSFTMod, diffAtMaxPower; REAL4 overallMaxDiffSFTMod; REAL4 maxMod, fastMaxMod; INT4 jMaxMod, jFastMaxMod; REAL4 tmpDiffSFTMod, sftMod, fastSFTMod; REAL4 smallMod = 1.e-30; REAL4 epsDiffMod; REAL4 epsBinErrorRate; /* 10/12/04 gam; Allowed bin error rate */ INT4 binErrorCount = 0; /* 10/12/04 gam; Count number of bin errors */ /* randval is always set to a default value or given a random value to generate certain signal parameters or mismatch */ REAL4 randval; #ifdef INCLUDE_RANDVAL_MISMATCH INT4 seed=0; INT4 rndCount; RandomParams *randPar=NULL; FILE *fpRandom; #endif INITSTATUS(status); ATTATCHSTATUSPTR(status); /* generate timeStamps */ timeStamps = (LIGOTimeGPSVector *)LALMalloc(sizeof(LIGOTimeGPSVector)); timeStamps->data =(LIGOTimeGPS *)LALMalloc (numSFTs*sizeof(LIGOTimeGPS)); timeStamps->length = numSFTs; for (i = 0; i < numSFTs; i++) { timeStamps->data[i].gpsSeconds = gpsStartTimeSec + (UINT4)(i*(tSFT + sftGap)); timeStamps->data[i].gpsNanoSeconds = 0; } /* for i < numSFTs */ /* generate skyPosData */ skyPosData=(REAL8 **)LALMalloc(numSkyPosTotal*sizeof(REAL8 *)); for(iSky=0;iSky<numSkyPosTotal;iSky++) { skyPosData[iSky] = (REAL8 *)LALMalloc(2*sizeof(REAL8)); /* Try fairly random sky positions skyPosData[iSky][0] = RA, skyPosData[iSky][1] = DEC */ if (iSky == 0) { skyPosData[iSky][0] = 0.02*LAL_TWOPI; skyPosData[iSky][1] = 0.03*LAL_PI/2.0; } else if (iSky == 1) { skyPosData[iSky][0] = 0.23*LAL_TWOPI; skyPosData[iSky][1] = -0.57*LAL_PI/2.0; } else if (iSky == 2) { skyPosData[iSky][0] = 0.47*LAL_TWOPI; skyPosData[iSky][1] = 0.86*LAL_PI/2.0; } else if (iSky == 3) { skyPosData[iSky][0] = 0.38*LAL_TWOPI; skyPosData[iSky][1] = -0.07*LAL_PI/2.0; } else if (iSky == 4) { skyPosData[iSky][0] = 0.65*LAL_TWOPI; skyPosData[iSky][1] = 0.99*LAL_PI/2.0; } else if (iSky == 5) { skyPosData[iSky][0] = 0.72*LAL_TWOPI; skyPosData[iSky][1] = -0.99*LAL_PI/2.0; } else if (iSky == 6) { skyPosData[iSky][0] = 0.81*LAL_TWOPI; skyPosData[iSky][1] = 0.19*LAL_PI/2.0; } else if (iSky == 7) { skyPosData[iSky][0] = 0.99*LAL_TWOPI; skyPosData[iSky][1] = 0.01*LAL_PI/2.0; } else { skyPosData[iSky][0] = 0.0; skyPosData[iSky][1] = 0.0; } /* END if (k == 0) ELSE ... */ } /* END for(iSky=0;iSky<numSkyPosTotal;iSky++) */ freqDerivData = NULL; /* 02/02/05 gam */ if (numSpinDown > 0) { freqDerivData=(REAL8 **)LALMalloc(numFreqDerivTotal*sizeof(REAL8 *)); for(jDeriv=0;jDeriv<numFreqDerivTotal;jDeriv++) { freqDerivData[jDeriv] = (REAL8 *)LALMalloc(numSpinDown*sizeof(REAL8)); if (jDeriv == 0) { for(k=0;k<numSpinDown;k++) { freqDerivData[jDeriv][k] = 0.0; } } else if (jDeriv == 1) { for(k=0;k<numSpinDown;k++) { freqDerivData[jDeriv][k] = 1.e-9; /* REALLY THIS IS ONLY GOOD FOR numSpinDown = 1; */ } } else { for(k=0;k<numSpinDown;k++) { freqDerivData[jDeriv][k] = 0.0; } } /* END if (k == 0) ELSE ... */ } /* END for(jDeriv=0;jDeriv<numFreqDerivTotal;jDeriv++) */ numFreqDerivIncludingNoSpinDown = numFreqDerivTotal; } else { numFreqDerivIncludingNoSpinDown = 1; /* Even if numSpinDown = 0 still need to count case of zero spindown. */ } /* END if (numSpinDown > 0) ELSE ... */ /* Initialize ephemeris data */ XLAL_CHECK_LAL (status, ( edat = XLALInitBarycenter( earthFile, sunFile ) ) != NULL, XLAL_EFUNC); /* Allocate memory for PulsarSignalParams and initialize */ pPulsarSignalParams = (PulsarSignalParams *)LALMalloc(sizeof(PulsarSignalParams)); pPulsarSignalParams->pulsar.position.system = COORDINATESYSTEM_EQUATORIAL; pPulsarSignalParams->pulsar.spindown = NULL; if (numSpinDown > 0) { LALDCreateVector(status->statusPtr, &(pPulsarSignalParams->pulsar.spindown),((UINT4)numSpinDown)); CHECKSTATUSPTR (status); } pPulsarSignalParams->orbit.asini = 0 /* isolated pulsar */; pPulsarSignalParams->transfer = NULL; pPulsarSignalParams->dtDelayBy2 = 0; pPulsarSignalParams->dtPolBy2 = 0; /* Set up pulsar site */ if (strstr(IFO, "LHO")) { cachedDetector = lalCachedDetectors[LALDetectorIndexLHODIFF]; } else if (strstr(IFO, "LLO")) { cachedDetector = lalCachedDetectors[LALDetectorIndexLLODIFF]; } else if (strstr(IFO, "GEO")) { cachedDetector = lalCachedDetectors[LALDetectorIndexGEO600DIFF]; } else if (strstr(IFO, "VIRGO")) { cachedDetector = lalCachedDetectors[LALDetectorIndexVIRGODIFF]; } else if (strstr(IFO, "TAMA")) { cachedDetector = lalCachedDetectors[LALDetectorIndexTAMA300DIFF]; } else { /* "Invalid or null IFO" */ ABORT( status, GENERATEPULSARSIGNALTESTC_EIFO, GENERATEPULSARSIGNALTESTC_MSGEIFO); } pPulsarSignalParams->site = &cachedDetector; pPulsarSignalParams->ephemerides = edat; pPulsarSignalParams->startTimeGPS.gpsSeconds = (INT4)gpsStartTimeSec; pPulsarSignalParams->startTimeGPS.gpsNanoSeconds = (INT4)gpsStartTimeNan; pPulsarSignalParams->duration = (UINT4)duration; pPulsarSignalParams->samplingRate = (REAL8)ceil(2.0*bandSFT); /* Make sampleRate an integer so that T*samplingRate = integer for integer T */ pPulsarSignalParams->fHeterodyne = f0SFT; GPSin.gpsSeconds = timeStamps->data[0].gpsSeconds; GPSin.gpsNanoSeconds = timeStamps->data[0].gpsNanoSeconds; /* Allocate memory for SFTParams and initialize */ pSFTParams = (SFTParams *)LALCalloc(1, sizeof(SFTParams)); pSFTParams->Tsft = tSFT; pSFTParams->timestamps = timeStamps; pSFTParams->noiseSFTs = NULL; #ifdef INCLUDE_RANDVAL_MISMATCH /* Initial seed and randPar to use LALUniformDeviate to generate random mismatch during Monte Carlo. */ fpRandom = fopen("/dev/urandom","r"); rndCount = fread(&seed, sizeof(INT4),1, fpRandom); fclose(fpRandom); /* seed = 1234; */ /* Test value */ LALCreateRandomParams(status->statusPtr, &randPar, seed); CHECKSTATUSPTR (status); #endif /* allocate memory for structs needed by LALComputeSkyAndZeroPsiAMResponse and LALFastGeneratePulsarSFTs */ pSkyConstAndZeroPsiAMResponse = (SkyConstAndZeroPsiAMResponse *)LALMalloc(sizeof(SkyConstAndZeroPsiAMResponse)); pSkyConstAndZeroPsiAMResponse->skyConst = (REAL8 *)LALMalloc((2*numSpinDown*(numSFTs+1)+2*numSFTs+3)*sizeof(REAL8)); pSkyConstAndZeroPsiAMResponse->fPlusZeroPsi = (REAL4 *)LALMalloc(numSFTs*sizeof(REAL4)); pSkyConstAndZeroPsiAMResponse->fCrossZeroPsi = (REAL4 *)LALMalloc(numSFTs*sizeof(REAL4)); pSFTandSignalParams = (SFTandSignalParams *)LALMalloc(sizeof(SFTandSignalParams)); /* create lookup table (LUT) values for doing trig */ /* pSFTandSignalParams->resTrig = 64; */ /* length sinVal and cosVal; resolution of trig functions = 2pi/resTrig */ /* pSFTandSignalParams->resTrig = 128; */ /* 10/08/04 gam; length sinVal and cosVal; domain = -2pi to 2pi inclusive; resolution = 4pi/resTrig */ pSFTandSignalParams->resTrig = 0; /* 10/12/04 gam; turn off using LUTs since this is more typical. */ /* 02/02/05 gam; if NOT pSFTandSignalParams->resTrig > 0 should not create trigArg etc... */ if (pSFTandSignalParams->resTrig > 0) { pSFTandSignalParams->trigArg = (REAL8 *)LALMalloc((pSFTandSignalParams->resTrig+1)*sizeof(REAL8)); pSFTandSignalParams->sinVal = (REAL8 *)LALMalloc((pSFTandSignalParams->resTrig+1)*sizeof(REAL8)); pSFTandSignalParams->cosVal = (REAL8 *)LALMalloc((pSFTandSignalParams->resTrig+1)*sizeof(REAL8)); for (k=0; k<=pSFTandSignalParams->resTrig; k++) { /* pSFTandSignalParams->trigArg[k]= ((REAL8)LAL_TWOPI) * ((REAL8)k) / ((REAL8)pSFTandSignalParams->resTrig); */ /* 10/08/04 gam */ pSFTandSignalParams->trigArg[k]= -1.0*((REAL8)LAL_TWOPI) + 2.0 * ((REAL8)LAL_TWOPI) * ((REAL8)k) / ((REAL8)pSFTandSignalParams->resTrig); pSFTandSignalParams->sinVal[k]=sin( pSFTandSignalParams->trigArg[k] ); pSFTandSignalParams->cosVal[k]=cos( pSFTandSignalParams->trigArg[k] ); } } pSFTandSignalParams->pSigParams = pPulsarSignalParams; pSFTandSignalParams->pSFTParams = pSFTParams; pSFTandSignalParams->nSamples = nsamples; pSFTandSignalParams->Dterms = Dterms; /* 09/07/05 gam */ /* ********************************************************/ /* */ /* START SECTION: LOOP OVER SKY POSITIONS */ /* */ /* ********************************************************/ for(iSky=0;iSky<numSkyPosTotal;iSky++) { /* set source sky position declination (DEC) */ randval = 0.5; /* Gives default value */ #ifdef INCLUDE_SEQUENTIAL_MISMATCH randval = ( (REAL4)(iSky) )/( (REAL4)(numSkyPosTotal) ); #endif #ifdef INCLUDE_RANDVAL_MISMATCH LALUniformDeviate(status->statusPtr, &randval, randPar); CHECKSTATUSPTR (status); #endif pPulsarSignalParams->pulsar.position.latitude = skyPosData[iSky][1] + (((REAL8)randval) - 0.5)*DeltaDec; cosTmpDEC = cos(skyPosData[iSky][1]); if (cosTmpDEC != 0.0) { tmpDeltaRA = DeltaRA/cosTmpDEC; } else { tmpDeltaRA = 0.0; /* We are at a celestial pole */ } /* set source sky position right ascension (RA) */ randval = 0.5; /* Gives default value */ #ifdef INCLUDE_SEQUENTIAL_MISMATCH randval = ( (REAL4)(iSky) )/( (REAL4)(numSkyPosTotal) ); #endif #ifdef INCLUDE_RANDVAL_MISMATCH LALUniformDeviate(status->statusPtr, &randval, randPar); CHECKSTATUSPTR (status); #endif pPulsarSignalParams->pulsar.position.longitude = skyPosData[iSky][0] + (((REAL8)randval) - 0.5)*tmpDeltaRA; /* Find reference time in SSB for this sky positions */ int ret = XLALConvertGPS2SSB ( &(pPulsarSignalParams->pulsar.refTime), GPSin, pPulsarSignalParams ); if ( ret != XLAL_SUCCESS ) { XLALPrintError ("XLALConvertGPS2SSB() failed with xlalErrno = %d\n", xlalErrno ); ABORTXLAL (status); } /* one per sky position fill in SkyConstAndZeroPsiAMResponse for use with LALFastGeneratePulsarSFTs */ LALComputeSkyAndZeroPsiAMResponse (status->statusPtr, pSkyConstAndZeroPsiAMResponse, pSFTandSignalParams); CHECKSTATUSPTR (status); /* ********************************************************/ /* */ /* START SECTION: LOOP OVER SPINDOWN */ /* */ /* ********************************************************/ for(jDeriv=0;jDeriv<numFreqDerivIncludingNoSpinDown;jDeriv++) { /* source spindown parameters */ if (numSpinDown > 0) { for(k=0;k<numSpinDown;k++) { randval = 0.5; /* Gives default value */ #ifdef INCLUDE_SEQUENTIAL_MISMATCH if (freqDerivData[jDeriv][k] < 0.0) { randval = ( (REAL4)(iSky) )/( (REAL4)(numSkyPosTotal) ); } else { randval = 0.5; /* If derivative is not negative (i.e., it is zero) then do not add in mismatch; keep it zero. */ } #endif #ifdef INCLUDE_RANDVAL_MISMATCH LALUniformDeviate(status->statusPtr, &randval, randPar); CHECKSTATUSPTR (status); #endif if (k == 0) { pPulsarSignalParams->pulsar.spindown->data[k] = freqDerivData[jDeriv][k] + (((REAL8)randval) - 0.5)*DeltaFDeriv1; } else if (k == 1) { pPulsarSignalParams->pulsar.spindown->data[k] = freqDerivData[jDeriv][k] + (((REAL8)randval) - 0.5)*DeltaFDeriv2; } else if (k == 2) { pPulsarSignalParams->pulsar.spindown->data[k] = freqDerivData[jDeriv][k] + (((REAL8)randval) - 0.5)*DeltaFDeriv3; } else if (k == 3) { pPulsarSignalParams->pulsar.spindown->data[k] = freqDerivData[jDeriv][k] + (((REAL8)randval) - 0.5)*DeltaFDeriv4; } else if (k == 4) { pPulsarSignalParams->pulsar.spindown->data[k] = freqDerivData[jDeriv][k] + (((REAL8)randval) - 0.5)*DeltaFDeriv5; } /* END if (k == 0) ELSE ... */ } } /* ***************************************************/ /* */ /* START SECTION: LOOP OVER FREQUENCIES */ /* */ /* ***************************************************/ for(iFreq=0;iFreq<nBinsSGNL;iFreq++) { /* set source orientation psi */ randval = 0.5; /* Gives default value */ #ifdef INCLUDE_SEQUENTIAL_MISMATCH randval = ( (REAL4)(iFreq) )/( (REAL4)(nBinsSGNL) ); #endif #ifdef INCLUDE_RANDVAL_MISMATCH LALUniformDeviate(status->statusPtr, &randval, randPar); CHECKSTATUSPTR (status); #endif pPulsarSignalParams->pulsar.psi = (randval - 0.5) * ((REAL4)LAL_PI_2); /* set angle between source spin axis and direction from source to SSB, cosIota */ randval = 1.0; /* Gives default value */ #ifdef INCLUDE_SEQUENTIAL_MISMATCH randval = ( (REAL4)(iFreq) )/( (REAL4)(nBinsSGNL) ); #endif #ifdef INCLUDE_RANDVAL_MISMATCH LALUniformDeviate(status->statusPtr, &randval, randPar); CHECKSTATUSPTR (status); #endif cosIota = 2.0*((REAL8)randval) - 1.0; /* h_0 is fixed above; get A_+ and A_x from h_0 and cosIota */ pPulsarSignalParams->pulsar.aPlus = (REAL4)(0.5*h_0*(1.0 + cosIota*cosIota)); pPulsarSignalParams->pulsar.aCross = (REAL4)(h_0*cosIota); /* get random value for phi0 */ randval = 0.125; /* Gives default value pi/4*/ #ifdef INCLUDE_SEQUENTIAL_MISMATCH randval = ( (REAL4)(iFreq) )/( (REAL4)(nBinsSGNL) ); #endif #ifdef INCLUDE_RANDVAL_MISMATCH LALUniformDeviate(status->statusPtr, &randval, randPar); CHECKSTATUSPTR (status); #endif pPulsarSignalParams->pulsar.phi0 = ((REAL8)randval) * ((REAL8)LAL_TWOPI); /* randval steps through various mismatches to frequencies centered on a bin */ /* Note that iFreq = nBinsSGNL/2 gives randval = 0.5 gives no mismatch from frequency centered on a bin */ randval = ( (REAL4)(iFreq) )/( (REAL4)(nBinsSGNL) ); #ifdef INCLUDE_RANDVAL_MISMATCH LALUniformDeviate(status->statusPtr, &randval, randPar); CHECKSTATUSPTR (status); #endif pPulsarSignalParams->pulsar.f0 = f0SGNL + iFreq*dfSGNL + (((REAL8)randval) - 0.5)*dfSGNL; testNumber++; /* Update count of which test we about to do. */ /* FIRST: Use LALGeneratePulsarSignal and LALSignalToSFTs to generate outputSFTs */ signalvec = NULL; LALGeneratePulsarSignal(status->statusPtr, &signalvec, pPulsarSignalParams); CHECKSTATUSPTR (status); outputSFTs = NULL; LALSignalToSFTs(status->statusPtr, &outputSFTs, signalvec, pSFTParams); CHECKSTATUSPTR (status); #ifdef PRINT_OUTPUTSFT if (testNumber == TESTNUMBER_TO_PRINT) { i=SFTINDEX_TO_PRINT; /* index of which outputSFT to output */ fprintf(stdout,"iFreq = %i, inject h_0 = %23.10e \n",iFreq,h_0); fprintf(stdout,"iFreq = %i, inject cosIota = %23.10e, A_+ = %23.10e, A_x = %23.10e \n",iFreq,cosIota,pPulsarSignalParams->pulsar.aPlus,pPulsarSignalParams->pulsar.aCross); fprintf(stdout,"iFreq = %i, inject psi = %23.10e \n",iFreq,pPulsarSignalParams->pulsar.psi); fprintf(stdout,"iFreq = %i, inject phi0 = %23.10e \n",iFreq,pPulsarSignalParams->pulsar.phi0); fprintf(stdout,"iFreq = %i, search f0 = %23.10e, inject f0 = %23.10e \n",iFreq,f0SGNL + iFreq*dfSGNL,pPulsarSignalParams->pulsar.f0); fprintf(stdout,"outputSFTs->data[%i].data->length = %i \n",i,outputSFTs->data[i].data->length); renorm = ((REAL4)nsamples)/((REAL4)(outputSFTs->data[i].data->length - 1)); for(j=0;j<nBinsSFT;j++) { /* fprintf(stdout,"%i %g %g \n", j, renorm*outputSFTs->data[i].data->data[j].re, renorm*outputSFTs->data[i].data->data[j].im); */ fprintf(stdout,"%i %g \n",j,renorm*renorm*outputSFTs->data[i].data->data[j].re*outputSFTs->data[i].data->data[j].re + renorm*renorm*outputSFTs->data[i].data->data[j].im*outputSFTs->data[i].data->data[j].im); fflush(stdout); } } #endif /* SECOND: Use LALComputeSkyAndZeroPsiAMResponse and LALFastGeneratePulsarSFTs to generate outputSFTs */ LALFastGeneratePulsarSFTs (status->statusPtr, &fastOutputSFTs, pSkyConstAndZeroPsiAMResponse, pSFTandSignalParams); CHECKSTATUSPTR (status); #ifdef PRINT_FASTOUTPUTSFT if (testNumber == TESTNUMBER_TO_PRINT) { REAL4 fPlus; REAL4 fCross; i=SFTINDEX_TO_PRINT; /* index of which outputSFT to output */ fPlus = pSkyConstAndZeroPsiAMResponse->fPlusZeroPsi[i]*cos(2.0*pPulsarSignalParams->pulsar.psi) + pSkyConstAndZeroPsiAMResponse->fCrossZeroPsi[i]*sin(2.0*pPulsarSignalParams->pulsar.psi); fCross = pSkyConstAndZeroPsiAMResponse->fCrossZeroPsi[i]*cos(2.0*pPulsarSignalParams->pulsar.psi) - pSkyConstAndZeroPsiAMResponse->fPlusZeroPsi[i]*sin(2.0*pPulsarSignalParams->pulsar.psi); fprintf(stdout,"iFreq = %i, inject h_0 = %23.10e \n",iFreq,h_0); fprintf(stdout,"iFreq = %i, inject cosIota = %23.10e, A_+ = %23.10e, A_x = %23.10e \n",iFreq,cosIota,pPulsarSignalParams->pulsar.aPlus,pPulsarSignalParams->pulsar.aCross); fprintf(stdout,"iFreq = %i, inject psi = %23.10e \n",iFreq,pPulsarSignalParams->pulsar.psi); fprintf(stdout,"iFreq = %i, fPlus, fCross = %23.10e, %23.10e \n",iFreq,fPlus,fCross); fprintf(stdout,"iFreq = %i, inject phi0 = %23.10e \n",iFreq,pPulsarSignalParams->pulsar.phi0); fprintf(stdout,"iFreq = %i, search f0 = %23.10e, inject f0 = %23.10e \n",iFreq,f0SGNL + iFreq*dfSGNL,pPulsarSignalParams->pulsar.f0); fprintf(stdout,"fastOutputSFTs->data[%i].data->length = %i \n",i,fastOutputSFTs->data[i].data->length); fflush(stdout); for(j=0;j<nBinsSFT;j++) { /* fprintf(stdout,"%i %g %g \n",j,fastOutputSFTs->data[i].data->data[j].re,fastOutputSFTs->data[i].data->data[j].im); */ fprintf(stdout,"%i %g \n",j,fastOutputSFTs->data[i].data->data[j].re*fastOutputSFTs->data[i].data->data[j].re + fastOutputSFTs->data[i].data->data[j].im*fastOutputSFTs->data[i].data->data[j].im); fflush(stdout); } } #endif /* find maximum difference in power */ epsDiffMod = 0.20; /* maximum allowed percent difference */ /* 10/12/04 gam */ overallMaxDiffSFTMod = 0.0; for (i = 0; i < numSFTs; i++) { renorm = ((REAL4)nsamples)/((REAL4)(outputSFTs->data[i].data->length - 1)); maxDiffSFTMod = 0.0; diffAtMaxPower = 0.0; maxMod = 0.0; fastMaxMod = 0.0; jMaxMod = -1; jFastMaxMod = -1; /* Since doppler shifts can move the signal by an unknown number of bins search the whole band for max modulus: */ for(j=0;j<nBinsSFT;j++) { sftMod = renorm*renorm*crealf(outputSFTs->data[i].data->data[j])*crealf(outputSFTs->data[i].data->data[j]) + renorm*renorm*cimagf(outputSFTs->data[i].data->data[j])*cimagf(outputSFTs->data[i].data->data[j]); sftMod = sqrt(sftMod); fastSFTMod = crealf(fastOutputSFTs->data[i].data->data[j])*crealf(fastOutputSFTs->data[i].data->data[j]) + cimagf(fastOutputSFTs->data[i].data->data[j])*cimagf(fastOutputSFTs->data[i].data->data[j]); fastSFTMod = sqrt(fastSFTMod); if (fabs(sftMod) > smallMod) { tmpDiffSFTMod = fabs((sftMod - fastSFTMod)/sftMod); if (tmpDiffSFTMod > maxDiffSFTMod) { maxDiffSFTMod = tmpDiffSFTMod; } if (tmpDiffSFTMod > overallMaxDiffSFTMod) { overallMaxDiffSFTMod = tmpDiffSFTMod; } if (sftMod > maxMod) { maxMod = sftMod; jMaxMod = j; } if (fastSFTMod > fastMaxMod) { fastMaxMod = fastSFTMod; jFastMaxMod = j; } } } if (fabs(maxMod) > smallMod) { diffAtMaxPower = fabs((maxMod - fastMaxMod)/maxMod); } #ifdef PRINT_MAXSFTPOWER fprintf(stdout,"maxSFTMod, testNumber %i, SFT %i, bin %i = %g \n",testNumber,i,jMaxMod,maxMod); fprintf(stdout,"maxFastSFTMod, testNumber %i, SFT %i, bin %i = %g \n",testNumber,i,jFastMaxMod,fastMaxMod); fflush(stdout); #endif #ifdef PRINT_MAXDIFFSFTPOWER fprintf(stdout,"maxDiffSFTMod, testNumber %i, SFT %i, bin %i = %g \n",testNumber,i,jMaxDiff,maxDiffSFTMod); fflush(stdout); #endif #ifdef PRINT_DIFFATMAXPOWER fprintf(stdout,"diffAtMaxPower, testNumber %i, SFT %i, bins %i and %i = %g \n",testNumber,i,jMaxMod,jFastMaxMod,diffAtMaxPower); fflush(stdout); #endif #ifdef PRINT_ERRORATMAXPOWER if (diffAtMaxPower > epsDiffMod) { fprintf(stdout,"diffAtMaxPower, testNumber %i, SFT %i, bins %i and %i = %g exceeded epsDiffMod = %g \n",testNumber,i,jMaxMod,jFastMaxMod,diffAtMaxPower,epsDiffMod); fflush(stdout); /* break; */ /* only report 1 error per test */ } if (jMaxMod != jFastMaxMod) { fprintf(stdout,"MaxPower occurred in different bins: testNumber %i, SFT %i, bins %i and %i\n",testNumber,i,jMaxMod,jFastMaxMod); fflush(stdout); /* break; */ /* only report 1 error per test */ } #endif if (jMaxMod != jFastMaxMod) { binErrorCount++; /* 10/12/04 gam; count up bin errors; if too ABORT at bottom of code */ } if ( diffAtMaxPower > epsDiffMod ) { ABORT( status, GENERATEPULSARSIGNALTESTC_EMOD, GENERATEPULSARSIGNALTESTC_MSGEMOD); } /* 10/12/04 gam; turn on test above and add test below */ if ( fabs(((REAL8)(jMaxMod - jFastMaxMod))) > 1.1 ) { ABORT( status, GENERATEPULSARSIGNALTESTC_EBIN, GENERATEPULSARSIGNALTESTC_MSGEBIN); } } /* END for(i = 0; i < numSFTs; i++) */ #ifdef PRINT_OVERALLMAXDIFFSFTPOWER fprintf(stdout,"overallMaxDiffSFTMod, testNumber = %i, SFT %i, bin %i = %g \n",testNumber,iOverallMaxDiffSFTMod,jOverallMaxDiff,overallMaxDiffSFTMod); fflush(stdout); #endif /* 09/07/05 gam; Initialize fastOutputSFTs since only 2*Dterms bins are changed by LALFastGeneratePulsarSFTs */ for (i = 0; i < numSFTs; i++) { for(j=0;j<nBinsSFT;j++) { fastOutputSFTs->data[i].data->data[j] = 0.0; } } XLALDestroySFTVector( outputSFTs); LALFree(signalvec->data->data); LALFree(signalvec->data); LALFree(signalvec); } /* END for(iFreq=0;iFreq<nBinsSGNL;iFreq++) */ /* ***************************************************/ /* */ /* END SECTION: LOOP OVER FREQUENCIES */ /* */ /* ***************************************************/ } /* END for(jDeriv=0;jDeriv<numFreqDerivIncludingNoSpinDown;jDeriv++) */ /* ********************************************************/ /* */ /* END SECTION: LOOP OVER SPINDOWN */ /* */ /* ********************************************************/ } /* END for(iSky=0;iSky<numSkyPosTotal;iSky++) */ /* ********************************************************/ /* */ /* END SECTION: LOOP OVER SKY POSITIONS */ /* */ /* ********************************************************/ /* 10/12/04 gam; check if too many bin errors */ epsBinErrorRate = 0.20; /* 10/12/04 gam; maximum allowed bin errors */ if ( (((REAL4)binErrorCount)/((REAL4)testNumber)) > epsBinErrorRate ) { ABORT( status, GENERATEPULSARSIGNALTESTC_EBINS, GENERATEPULSARSIGNALTESTC_MSGEBINS); } #ifdef INCLUDE_RANDVAL_MISMATCH LALDestroyRandomParams(status->statusPtr, &randPar); CHECKSTATUSPTR (status); #endif /* fprintf(stdout,"Total number of tests completed = %i. \n", testNumber); fflush(stdout); */ LALFree(pSFTParams); if (numSpinDown > 0) { LALDDestroyVector(status->statusPtr, &(pPulsarSignalParams->pulsar.spindown)); CHECKSTATUSPTR (status); } LALFree(pPulsarSignalParams); /* deallocate memory for structs needed by LALComputeSkyAndZeroPsiAMResponse and LALFastGeneratePulsarSFTs */ XLALDestroySFTVector( fastOutputSFTs); LALFree(pSkyConstAndZeroPsiAMResponse->fCrossZeroPsi); LALFree(pSkyConstAndZeroPsiAMResponse->fPlusZeroPsi); LALFree(pSkyConstAndZeroPsiAMResponse->skyConst); LALFree(pSkyConstAndZeroPsiAMResponse); /* 02/02/05 gam; if NOT pSFTandSignalParams->resTrig > 0 should not create trigArg etc... */ if (pSFTandSignalParams->resTrig > 0) { LALFree(pSFTandSignalParams->trigArg); LALFree(pSFTandSignalParams->sinVal); LALFree(pSFTandSignalParams->cosVal); } LALFree(pSFTandSignalParams); /* deallocate skyPosData */ for(i=0;i<numSkyPosTotal;i++) { LALFree(skyPosData[i]); } LALFree(skyPosData); if (numSpinDown > 0) { /* deallocate freqDerivData */ for(i=0;i<numFreqDerivTotal;i++) { LALFree(freqDerivData[i]); } LALFree(freqDerivData); } LALFree(timeStamps->data); LALFree(timeStamps); XLALDestroyEphemerisData(edat); CHECKSTATUSPTR (status); DETATCHSTATUSPTR (status); }