int SetupBaryInput()
{
FILE *fpE;
FILE *fpS;
/*allocate memory for the ephemeris*/
edat=(EphemerisData *)LALMalloc(sizeof(EphemerisData));
(*edat).ephiles.earthEphemeris="/home/re/data/LAL_tmp/earth00-04.dat";
(*edat).ephiles.sunEphemeris="/home/re/data/LAL_tmp/sun00-04.dat";
/*Check that the ephemeris files exist*/
fpE=fopen((*edat).ephiles.earthEphemeris,"r");
fpS=fopen((*edat).ephiles.sunEphemeris,"r");
if ((fpE==NULL) || (fpS==NULL))
{
fprintf(stdout,"impossible to find ephemeris files ");
} else
{
fprintf(stdout,"ephemeris file %s %s\n found!\n", (*edat).ephiles.sunEphemeris, (*edat).ephiles.earthEphemeris);
}
fscanf(fpS,"%d \t %le \t %d\n",&x, &y, &z);
/*fprintf(stdout,"x y z are %d \t %12.12le \t %d\n", x,y,z);*/
/*Read in ephemeris files*/
LALInitBarycenter(&status, edat);
#ifdef DEBUG_STACKSLIDE_FNC
fprintf(stdout,"first entry %f\n",(*edat).ephemE[0].gps);
#endif
printf("end of function SetupBaryInput\n");
return 3;
/* convert the observation start time at the detector into start time at the SSB */
}
/* vvvvvvvvvvvvvvvvvvvvvvvvvvvvvv------------------------------------ */
int main(int argc, char *argv[]){
static LALStatus status;
static VelocityPar velPar;
static REAL8 vel[3];
static REAL8 pos[3];
static EphemerisData *edat = NULL;
LIGOTimeGPS tGPS;
INT4 arg; /* Argument counter */
REAL8 vTol=0.01 ;
/* INT4 c, errflg=0;*/
/* optarg = NULL; */
/* ------------------------------------------------------- */
/* default values */
velPar.detector = lalCachedDetectors[LALDetectorIndexGEO600DIFF];
velPar.startTime.gpsSeconds = T0SEC;
velPar.startTime.gpsNanoSeconds = T0NSEC;
velPar.tBase = TBASE;
velPar.vTol = ACCURACY;
/********************************************************/
/* Parse argument list. i stores the current position. */
/********************************************************/
arg = 1;
while ( arg < argc ) {
/* Parse debuglevel option. */
if ( !strcmp( argv[arg], "-d" ) ) {
if ( argc > arg + 1 ) {
arg++;
} else {
ERROR( TESTVELOCITYC_EARG, TESTVELOCITYC_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return TESTVELOCITYC_EARG;
}
}
/* Parse accuracy option. */
else if ( !strcmp( argv[arg], "-a" ) ) {
if ( argc > arg + 1 ) {
arg++;
vTol= atof( argv[arg++]);
velPar.vTol= vTol;
} else {
ERROR( TESTVELOCITYC_EARG, TESTVELOCITYC_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return TESTVELOCITYC_EARG;
}
}
/* Unrecognized option. */
else {
ERROR( TESTVELOCITYC_EARG, TESTVELOCITYC_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return TESTVELOCITYC_EARG;
}
} /* End of argument parsing loop. */
/******************************************************************/
/* read ephemeris data */
/* ephemeris info */
edat = (EphemerisData *)LALMalloc(sizeof(EphemerisData));
(*edat).ephiles.earthEphemeris = EARTHDATA;
(*edat).ephiles.sunEphemeris = SUNDATA;
/* read in ephemeris data */
SUB( LALInitBarycenter( &status, edat), &status);
/* fill in ephemeris data in velPar */
velPar.edat = edat;
tGPS.gpsSeconds = T0SEC;
tGPS.gpsNanoSeconds = T0NSEC;
SUB( LALDetectorVel( &status, vel, &tGPS, velPar.detector, velPar.edat), &status);
printf("Detector velocity at %d = %g, %g, %g \n", T0SEC, vel[0],vel[1],vel[2]);
SUB( LALDetectorPos( &status, vel, &tGPS, velPar.detector, velPar.edat), &status);
printf("Detector position at %d = %g, %g, %g \n", T0SEC, vel[0],vel[1],vel[2]);
SUB( LALAvgDetectorVel ( &status, vel, &velPar), &status );
printf("Avg. detector velocity in a interval of %g from %d = %g, %g, %g \n", TBASE, T0SEC, vel[0],vel[1],vel[2]);
SUB( LALAvgDetectorPos ( &status, pos, &velPar), &status );
printf("Avg. detector position in a interval of %g from %d = %g, %g, %g \n", TBASE, T0SEC, pos[0],pos[1],pos[2]);
LALFree(edat->ephemE);
LALFree(edat->ephemS);
LALFree(edat);
LALCheckMemoryLeaks();
//INFO(TESTVELOCITYC_MSGENORM);
return TESTVELOCITYC_ENORM;
}
int main(int argc, char **argv)
{
FILE *fp = NULL;
FILE *fp2 = NULL;
FILE *fp3 = NULL;
FILE *fp4 = NULL;
LALStatus status = blank_status;
SFTCatalog *catalog = NULL;
SFTVector *sft_vect = NULL;
INT4 i,j,k,l;
INT4 numBins, nSFT;
SFTConstraints constraints=empty_SFTConstraints;
LIGOTimeGPS startTime, endTime;
REAL8 avg =0;
REAL4 *timeavg =NULL;
REAL4 PWR,SNR;
REAL8 f =0;
CHAR outbase[256],outfile[256],outfile2[256],outfile3[256], outfile4[256]; /*, outfile6[256]; */
REAL8 NumBinsAvg =0;
REAL8 timebaseline =0;
BOOLEAN help = 0;
CHAR *SFTpatt = NULL;
CHAR *IFO = NULL;
INT4 startGPS = 0;
INT4 endGPS = 0;
REAL8 f_min = 0.0;
REAL8 f_max = 0.0;
REAL8 freqres =0.0;
INT4 blocksRngMed = 101;
CHAR *outputBname = NULL;
INT4 cur_epoch = 0, next_epoch = 0;
/* these varibales are for converting GPS seconds into UTC time and date*/
struct tm date;
CHARVector *timestamp = NULL;
CHARVector *year_date = NULL;
REAL8Vector *timestamps=NULL;
CHAR *psrInput = NULL;
CHAR *psrEphemeris = NULL;
CHAR *earthFile = NULL;
CHAR *sunFile = NULL;
/*========================================================================================================================*/
LAL_CALL(LALRegisterBOOLUserVar (&status, "help", 'h', UVAR_HELP, "Print this help message", &help ), &status);
LAL_CALL(LALRegisterSTRINGUserVar(&status, "SFTs", 'p', UVAR_REQUIRED, "SFT location/pattern", &SFTpatt ), &status);
LAL_CALL(LALRegisterSTRINGUserVar(&status, "IFO", 'I', UVAR_REQUIRED, "Detector", &IFO ), &status);
LAL_CALL(LALRegisterINTUserVar (&status, "startGPS", 's', UVAR_REQUIRED, "Starting GPS time", &startGPS ), &status);
LAL_CALL(LALRegisterINTUserVar (&status, "endGPS", 'e', UVAR_REQUIRED, "Ending GPS time", &endGPS ), &status);
LAL_CALL(LALRegisterREALUserVar (&status, "fMin", 'f', UVAR_REQUIRED, "Minimum frequency", &f_min ), &status);
LAL_CALL(LALRegisterREALUserVar (&status, "fMax", 'F', UVAR_REQUIRED, "Maximum frequency", &f_max ), &status);
LAL_CALL(LALRegisterINTUserVar (&status, "blocksRngMed", 'w', UVAR_OPTIONAL, "Running Median window size", &blocksRngMed), &status);
LAL_CALL(LALRegisterSTRINGUserVar(&status, "outputBname", 'o', UVAR_OPTIONAL, "Base name of output files", &outputBname ), &status);
LAL_CALL(LALRegisterREALUserVar (&status, "freqRes", 'r', UVAR_REQUIRED, "Spectrogram freq resolution", &freqres ), &status);
LAL_CALL(LALRegisterREALUserVar (&status, "timeBaseline", 't', UVAR_REQUIRED, "The time baseline of sfts", &timebaseline), &status);
LAL_CALL(LALRegisterSTRINGUserVar(&status, "psrInput", 'P', UVAR_OPTIONAL, "name of tempo pulsar file", &psrInput ), &status);
LAL_CALL(LALRegisterSTRINGUserVar(&status, "psrEphemeris", 'S', UVAR_OPTIONAL, "pulsar ephemeris file", &psrEphemeris ), &status);
LAL_CALL(LALRegisterSTRINGUserVar(&status, "earthFile", 'y', UVAR_OPTIONAL, "earth .dat file", &earthFile ), &status);
LAL_CALL(LALRegisterSTRINGUserVar(&status, "sunFile", 'z', UVAR_OPTIONAL, "sun .dat file", &sunFile ), &status);
LAL_CALL(LALUserVarReadAllInput(&status, argc, argv), &status);
if (help)
return(0);
startTime.gpsSeconds = startGPS;/*cg; startTime is a structure, and gpsSeconds is a member of that structure*/
startTime.gpsNanoSeconds = 0;/*cg; gps NanoSeconds is also a member of the startTime structure */
constraints.minStartTime = &startTime; /*cg; & operator gets the address of variable, &a is a pointer to a. This line puts the startTime structure into the structure constraints*/
endTime.gpsSeconds = endGPS;
endTime.gpsNanoSeconds = 0;
constraints.maxEndTime = &endTime;/*cg; This line puts the end time into the structure constraints*/
constraints.detector = IFO;/*cg; this adds the interferometer into the contraints structure*/
LALSFTdataFind ( &status, &catalog, SFTpatt, &constraints );/*cg; creates SFT catalog, uses the constraints structure*/
if (catalog == NULL)/*need to check for a NULL pointer, and print info about circumstances if it is null*/
{
fprintf(stderr, "SFT catalog pointer is NULL! There has been an error with LALSFTdataFind\n");
fprintf(stderr, "LALStatus info.... status code: %d, message: %s, offending function: %s\n", status.statusCode, status.statusDescription, status.function);
exit(0);
}
if (catalog->length == 0)
{
fprintf(stderr, "No SFTs found, please exmanine start time, end time, frequency range etc\n");
exit(0);
}
LALLoadSFTs ( &status, &sft_vect, catalog, f_min,f_max);/*cg;reads the SFT data into the structure sft_vect*/
if (sft_vect == NULL)
{
fprintf(stderr, "SFT vector pointer is NULL! There has been an error with LALLoadSFTs\n");
fprintf(stderr, "LALStatus info.... status code: %d, message: %s, offending function: %s\n", status.statusCode, status.statusDescription, status.function);
exit(0);
}
LALDestroySFTCatalog( &status, &catalog);/*cg; desctroys the SFT catalogue*/
numBins = sft_vect->data->data->length;/*the number of bins in the freq_range*/
nSFT = sft_vect->length;/* the number of sfts.*/
fprintf(stderr, "nSFT = %d\tnumBins = %d\tf0 = %f\n", nSFT, numBins,sft_vect->data->f0);/*print->logs/spectrumAverage_testcg_0.err */
if (LALUserVarWasSet(&outputBname))
strcpy(outbase, outputBname);
else
sprintf(outbase, "spec_%.2f_%.2f_%s_%d_%d", f_min,f_max,constraints.detector,startTime.gpsSeconds,endTime.gpsSeconds);/*cg; this is the default name for producing the output files, the different suffixes are just added to this*/
sprintf(outfile, "%s", outbase);/*cg; name of first file to be output*/
sprintf(outfile2, "%s_timestamps", outbase);/*cg: name of second file to be output*/
sprintf(outfile3, "%s.txt", outbase);/*cg; name of third file to be output*/
sprintf(outfile4, "%s_date", outbase);/*cg;file for outputting the date, which is used in matlab plotting.*/
fp = fopen(outfile, "w");/*cg; open all three files for writing, if they don't exist create them, if they do exist overwrite them*/
fp2 = fopen(outfile2, "w");
fp3 = fopen(outfile3, "w");
fp4 = fopen(outfile4, "w");
/*----------------------------------------------------------------------------------------------------------------*/
/*cg; Create the first file called spec_blah_blah. This file outputs the power in each spectrogram bin. The number of bins depends on the frequency range, freq resolution, and number of SFTs.*/
/*cg; Create the second file, called blah_b;ah_blah_timestamps. This will simply contain the time in GPS seconds of each SFT.*/
NumBinsAvg = freqres*numBins/(f_max-f_min);/*this calcs the number of bins over which to average the sft data, this is worked out so it produces the same freq resolution as specified in the arguments passed to fscanDriver.py. numBins is the total number of bins in the raw sft data*/
l=0;/*l is used as a counter to count how many SFTs and fake zero SFTs (used for gaps) are output for specgram.*/
timestamps = XLALCreateREAL8Vector(l);/*test for getting rid of second loop*/
LALCHARCreateVector(&status, &year_date, (UINT4)128);
/*create output files and check for missing sfts*/
for (j=0;j<nSFT;j++)/*cg;nSFT is the numnber of SFT files used for the time specified. So process is repeated for each SFT*/
{
cur_epoch = sft_vect->data[j].epoch.gpsSeconds;/*finds the gps time of the current sft in the sequence with index j*/
fprintf(fp2, "%d.\t%d\n", l, cur_epoch);/*cg; this bit writes the second file, i.e. the timestamps*/
XLALResizeREAL8Vector(timestamps, l+1);/*resizes the vector timestamps, so cur_epoch can be added*/
timestamps->data[l]= cur_epoch;/*number of gaps is not know in advance, hence need for te resizing*/
XLALGPSToUTC(&date, cur_epoch);/*cg; gets the UTC date in struct tm format from the GPS seconds.*/
fprintf(fp4, "%d\t %i\t %i\t %i\t %i\t %i\t %i\n", l, (date.tm_year+1900), date.tm_mon+1, date.tm_mday, date.tm_hour, date.tm_min, date.tm_sec);
for ( i=0; i < (numBins-2); i+=NumBinsAvg)/*cg; this loop works out the powers and writes the first file.*/
{/*cg; each SFT is split up into a number of bins, the number of bins is read in from the SFT file*/
avg = 0.0;/*cg; the vairable avg is reset each time.*/
if (i+NumBinsAvg>numBins) {printf("Error\n");return(2);}/*cg; error is detected, to prevent referencing data past the end of sft_vect.*/
for (k=0;k<NumBinsAvg;k++)/*cg; for each bin, k goes trhough each entry from 0 to 180.*/
avg += sqrt(2*(crealf(sft_vect->data[j].data->data[i+k])*crealf(sft_vect->data[j].data->data[i+k]) +
cimagf(sft_vect->data[j].data->data[i+k])*cimagf(sft_vect->data[j].data->data[i+k]))/timebaseline);/*cg; re amd im are real and imaginary parts of SFT, duh!*/
fprintf(fp,"%e\t",avg/NumBinsAvg);
}
fprintf(fp,"\n");
/*------------------------------*/
/*Bit to check if there is a gap in the sfts*/
if ( j < (nSFT-1) )/*in all cases except when we are examining the last sft, check that there is no gap to the next sft*/
{
next_epoch = sft_vect->data[j+1].epoch.gpsSeconds;
/*test to see if SFT gap is longer than 3/2*timebaseline, if so create another entry in the matrix*/
while ((cur_epoch+((3/2)*timebaseline)) < next_epoch)
{
for ( i=0; i < (numBins-2); i+=NumBinsAvg)
{
avg = 0.0;
if (i+NumBinsAvg>numBins) {printf("Error\n");return(2);}
fprintf(fp,"%e\t",avg);
}
fprintf(fp,"\n");
l=l+1;
cur_epoch=cur_epoch+timebaseline;
fprintf(fp2, "%d.\t%d\n", l, cur_epoch );
XLALResizeREAL8Vector(timestamps, l+1);
timestamps->data[l]= cur_epoch;
XLALGPSToUTC(&date, cur_epoch);/*cg; gets the UTC date in struct tm format from the GPS seconds.*/
fprintf(fp4, "%d\t %i\t %i\t %i\t %i\t %i\t %i\n", l, (date.tm_year+1900), date.tm_mon+1, date.tm_mday, date.tm_hour, date.tm_min, date.tm_sec);
}
}
l=l+1;
}
fprintf(stderr,"finished checking for missing sfts, l=%d\n", l);
/*----------------------------------------------------------------------------------------------------------------*/
/*cg; Create the third and final file, called blah_blah_blah.txt. This file will contain the data used in the matlab plot script to plot the normalised average power vs the frequency.*/
/* Find time average of normalized SFTs */
LALNormalizeSFTVect(&status, sft_vect, blocksRngMed);
LALNormalizeSFTVect(&status, sft_vect, blocksRngMed);
timeavg = XLALMalloc(numBins*sizeof(REAL4));
if (timeavg == NULL) fprintf(stderr,"Timeavg memory not allocated\n");
for (j=0;j<nSFT;j++)
{
for ( i=0; i < numBins; i++)
{
if (j == 0)
{
timeavg[i] = crealf(sft_vect->data[j].data->data[i])*crealf(sft_vect->data[j].data->data[i]) +
cimagf(sft_vect->data[j].data->data[i])*cimagf(sft_vect->data[j].data->data[i]);
}
else
{
timeavg[i] += crealf(sft_vect->data[j].data->data[i])*crealf(sft_vect->data[j].data->data[i]) +
cimagf(sft_vect->data[j].data->data[i])*cimagf(sft_vect->data[j].data->data[i]);
}
}
}
/*timeavg records the power of each bin*/
for ( i=0; i < numBins; i++)
{
f = sft_vect->data->f0 + ((REAL4)i)*sft_vect->data->deltaF;
PWR=timeavg[i]/((REAL4)nSFT);
SNR=(PWR-1)*(sqrt(((REAL4)nSFT)));
fprintf(fp3,"%16.8f %g %g\n",f, PWR, SNR);
}
/*------------------------------------------------------------------------------------------------------------------------*/
/*End of normal spec_avg code, the remaining code is for crab freq calc.*/
/*================================================================================================================*/
/*================================================================================================================*/
/*This next block of code is for the crab specific changes to fscan*/
#define CRAB 0
/*change this to CRAB 0 to prevent this section of code from compiling, change to 1 to compile it.*/
#if CRAB
/*--------------------------------------------------------------------------------------------------------------*/
/*some header files for the crab*/
/*#include "../TDS_isolated/HeterodyneCrabPulsar.h"*/
/*#include "../TDS_isolated/heterodyne_pulsar.h"*/
#include<../TDS_isolated/HeterodyneCrabPulsar.h>
if (psrInput != NULL){
fprintf(stderr,"--------------------\n\n");
fprintf(stderr,"start of crab stuff\n");
LIGOTimeGPS dataEpoch;
/*below 4 structures are from HeterodyneCrabPulsar.h*/
GetCrabEphemerisInput input; /*this is needed to get the crab ephemeris*/
CrabSpindownParamsInput crabEphemerisData;
CrabSpindownParamsOutput crabOutput;
ParamsForHeterodyne hetParams;
/*CG; these lines allocate memory for the crab ephemeris and crab output variables...*/
crabEphemerisData.f1 = NULL;
LALDCreateVector( &status, &crabEphemerisData.f1, NUM);
crabEphemerisData.f0 = NULL;
LALDCreateVector( &status, &crabEphemerisData.f0, NUM);
crabEphemerisData.tArr = NULL;
LALDCreateVector( &status, &crabEphemerisData.tArr, NUM);
crabOutput.tArr = NULL;
LALDCreateVector( &status, &crabOutput.tArr, NUM);
crabOutput.f0 = NULL;
LALDCreateVector( &status, &crabOutput.f0, NUM);
crabOutput.f1 = NULL;
LALDCreateVector( &status, &crabOutput.f1, NUM);
crabOutput.f2 = NULL;
LALDCreateVector( &status, &crabOutput.f2, NUM);
crabOutput.f3 = NULL;
LALDCreateVector( &status, &crabOutput.f3, NUM);
crabOutput.f4 = NULL;
LALDCreateVector( &status, &crabOutput.f4, NUM);
/*This next set of variables are to do with the doppler shifts that are then applied to to the crab feq.*/
REAL8 t2=0., tdt=0.;
EphemerisData *edat=NULL;
BarycenterInput baryinput, baryinput2;
EarthState earth, earth2;
EmissionTime emit, emit2;
REAL8 df=0., freq, finalFreq, max_df, minf, maxf;
REAL8 dtpos=0.; /* time between position epoch and data timestamp */
BinaryPulsarParams pulsarParams; /*general pulsar params strcut, despite binary name*/
/*CHAR *psrInput = NULL;*/ /* pulsar input file containing params f0, f1 etc. */
LALDetector det;
CHAR detName[256];
REAL8 ecliptic_lat, e_tilt=0.409092627;/*the ecliptic latitude of the source, and hte earth's tilt in radians (23.439281 degrees)*/
char outfile5[256];
FILE *fp5 = NULL;
sprintf(outfile5, "%s_crab", outbase);
fp5 = fopen(outfile5, "w");
/*----------------------------------------------------------------------------------------------------------------*/
/*cg; calculating the crab freq, done in three steps. This is done for each sft*/
/*----------------------------------------------------------------------------------------------------------------*/
/* ---1--- */
/*Find rough guess of crabs freq from ephemeris*/
/*----------------------------------------------------------------------------------------------------------------*/
/*Get detector position, this is needed for barycentre calcs*/
det = *XLALGetSiteInfo( IFO );
/* read in tempo par file for pulsar, This is one of the optional command line arguments*/
/*fprintf(stderr,"%s\n",psrInput);*/
fprintf(stderr,"%s\n",psrInput);
XLALReadTEMPOParFile(&pulsarParams, psrInput);
/*Make sure that posepoch and pepoch are set*/
if(pulsarParams.pepoch == 0. && pulsarParams.posepoch != 0.)
pulsarParams.pepoch = pulsarParams.posepoch;
else if(pulsarParams.posepoch == 0. && pulsarParams.pepoch != 0.)
pulsarParams.posepoch = pulsarParams.pepoch;
fprintf(stderr,"Check on read tempo file, pepoch: %f\n", pulsarParams.pepoch);
/*input.filename=psrEphemeris;*/ /*/archive/home/colingill/lalsuite/lalapps/src/pulsar/fscan/ /archive/home/colingill/public_html/crab_ephemeris.txt*/
input.filename = XLALMalloc(sizeof(CHAR)*256);
if(input.filename == NULL) fprintf(stderr,"input.filename pointer memory not allocated\t");
strcpy(input.filename,psrEphemeris);
/*fprintf(stderr,"psrEphemeris:%s\n", input.filename);*/
/*The first stage is to read in f and fdot from the ephemeris, the crab_ephemeris.txt file is part of lalapps and is maintained by matt*/
LALGetCrabEphemeris( &status, &crabEphemerisData, &input );
/*check on the outputs, crabEphemerisData is a struct of type CrabSpindownParamsInput, and has members tArr, f0, f1*/
fprintf(stderr,"input crab ephemeris present, number of entries: %i\n", crabEphemerisData.numOfData);
fprintf(stderr,"crabEphemerisData: \ttarr= %f\tf0= %f\tf_dot= %e\n", crabEphemerisData.tArr->data[0], crabEphemerisData.f0->data[0], crabEphemerisData.f1->data[0]);
/*Now I have f and fdot, use function below to compute the higher order derrivatives of the crabs frequency*/
LALComputeFreqDerivatives( &status, &crabOutput, &crabEphemerisData );
/*check on this function, crabOutput is datatype CrabSpindownParamsOutput*/
fprintf(stderr,"crabOutput:\tf0= %f\tf1= %e\tf2= %e\n", crabOutput.f0->data[0], crabOutput.f1->data[0], crabOutput.f2->data[0]);/*need to change the type of printf for F1 and f2 to exponentials.*/
fprintf(stderr,"--------------------\n");
/*Allocate memory for edat, no need to do in the loop*/
edat = XLALMalloc(sizeof(*edat));
(*edat).ephiles.earthEphemeris = earthFile; /*"/archive/home/colingill/lalsuite/lal/packages/pulsar/test/earth05-09.dat";*/
(*edat).ephiles.sunEphemeris = sunFile;/*"/archive/home/colingill/lalsuite/lal/packages/pulsar/test/sun05-09.dat";*/
/*work out the eclitptic lattitude of the source, used in max freq calc.*/
ecliptic_lat=asin(cos(e_tilt)*sin(pulsarParams.dec)-sin(pulsarParams.ra)*cos(pulsarParams.dec)*sin(e_tilt));
fprintf(stderr,"eqcliptic_lat: %e\t", ecliptic_lat);
for (i=0;i<l;i++)
{
if (i == (l-1))/*catches the last iteration where there is no i+1 entry in timestamps*/
{
cur_epoch = timestamps->data[i]+(timebaseline/2);
}
else
{
cur_epoch = timestamps->data[i]+((timestamps->data[i+1] - timestamps->data[i])/2);
}
fprintf(stderr,"cur_epoch: %d\t", cur_epoch);
/*The time has to be set so that the nearest entry to that time in the ephemeris can be used*/
dataEpoch.gpsSeconds = cur_epoch; /*INT8)floor(time->data[j]);*/
dataEpoch.gpsNanoSeconds = 0;
/*prepare hetParams, which is then used to get the freq derrivatives out and also in the next sub-section for Bary functions*/
LALSetSpindownParams( &status, &hetParams, &crabOutput, dataEpoch );
fprintf(stderr,"hetparams epoch: %f\t f0= %f\tf1= %e\n", hetParams.epoch, hetParams.f0, hetParams.f1);
/*----------------------------------------------------------------------------------------------------------------*/
/* ---2--- */
/*Add corrections for timing noise to get a better guess at the freq*/
/*----------------------------------------------------------------------------------------------------------------*/
/*now I want to use these params to calc the freq at any point in time. Using the higher order derrivatives is how we adjust for timing noise.*/
/*Get the time difference between the current epoch and the epoch of the ephemeris entry*/
tdt= cur_epoch - hetParams.epoch;
fprintf(stderr,"dt: %f,\tf1= %e,\tf2= %e,\tf3= %e,\tf4=%e\n", tdt, hetParams.f1, hetParams.f2, hetParams.f3, hetParams.f4);
freq = 2.0*( hetParams.f0 + ((hetParams.f1)*tdt) + (((hetParams.f2)*tdt*tdt)/2) + (((hetParams.f3)*tdt*tdt*tdt)/6) + (((hetParams.f4)*tdt*tdt*tdt*tdt)/24) );
fprintf(stderr,"crab fcoarse: %f\t", freq);
/*freq = 2.0*(params->f0 + params->f1*t1 + (params->f2)*t1*t1+ (params->f3)*t1*t1*t1 + (params->f4)*t1*t1*t1*t1);*/ /*cg;line 486 from hetcrabpulsar, works out freq, this is with one order of t removed for each of the derrivatives of f, and also each term is divided by a factorial, 1!, 2!, 3!, but this starts one term along from the oroginal code as we have integrated the orginal code to get freq not phase*/
/*----------------------------------------------------------------------------------------------------------------*/
/* ---3--- */
/*Add doppler shifts for earth's motion back onto the freq to get actual observed freq at detectors.*/
/*----------------------------------------------------------------------------------------------------------------*/
/*now I have the freq, I need to add the doppler shift for the earths motion around the sun */
baryinput.dInv = 0.;/*I can always set this to zero, as Matt said so, I must ask him why*/
LAL_CALL( LALInitBarycenter(&status, edat), &status );/* */
/*this lines take position of detector which are in xyz coords in meters from earths centre and converts them into seconds (time)*/
baryinput.site.location[0] = det.location[0]/LAL_C_SI;
baryinput.site.location[1] = det.location[1]/LAL_C_SI;
baryinput.site.location[2] = det.location[2]/LAL_C_SI;
/*dtpos should be the time between the entry in the ephemeris and the point in time for which doppler shifts are being calc.ed*/
dtpos = cur_epoch - pulsarParams.posepoch;
/* set up RA, DEC, and distance variables for LALBarycenter*/
baryinput.delta = pulsarParams.dec + dtpos*pulsarParams.pmdec;
baryinput.alpha = pulsarParams.ra + dtpos*pulsarParams.pmra/cos(baryinput.delta);
t2=cur_epoch+1;
baryinput2 = baryinput;
baryinput.tgps.gpsSeconds = (INT4)floor(cur_epoch);
baryinput.tgps.gpsNanoSeconds = (INT4)floor((fmod(cur_epoch,1.0)*1.e9));
baryinput2.tgps.gpsSeconds = (INT4)floor(t2);
baryinput2.tgps.gpsNanoSeconds = (INT4)floor((fmod(t2,1.0)*1.e9));
/*the barycentre functions are needed to calc the inputs for the correction to fcoarse, namely emit, earth and baryinput*/
LAL_CALL( LALBarycenterEarth(&status, &earth, &baryinput.tgps, edat), &status );
LAL_CALL( LALBarycenter(&status, &emit, &baryinput, &earth), &status );
LAL_CALL( LALBarycenterEarth(&status, &earth2, &baryinput2.tgps, edat), &status );
LAL_CALL( LALBarycenter(&status, &emit2, &baryinput2, &earth2), &status );
/* I need to calc the correction to the freq for the doppler shifts, the correction is df, from line 1074 heterdyne_pulsar. deltaT is T_emission in TDB - T_arrrival in GPS + light travel time to SSB. we are working out delta(delatT) over 1 second, so do not bother with the divide by one bit.*/
df = freq*(emit2.deltaT - emit.deltaT);
fprintf(stderr,"df: %f,\t", df);
/*Calc maximum possible df and then subtract applied df from it, use the remaining df to plot range over which f will wander.*/
max_df=freq*(( (29.783e3*cos(ecliptic_lat))+(465*cos(pulsarParams.dec)) )/3.0e8);/*max doppler shift, from speed of earth in plane of direction to source over c.*/
fprintf(stderr,"max df: %f\tbeta: %e\n", max_df, ecliptic_lat);
maxf=freq+max_df;
minf=freq-max_df;
finalFreq=freq+df;
/*df = fcoarse*(emit2.deltaT - emit.deltaT + binOutput2.deltaT - binOutput.deltaT);*//*use when have binary calcs in here also.*/
fprintf(fp5,"%f\t%f\t%f\t%f\t%f\n", freq, df, minf, finalFreq, maxf);
fprintf(stderr,"crab freq calc, i:%d, minf:%f, f:%f, maxf:%f\n", i, minf, finalFreq, maxf);
/*----------------------------------------------------------------------------------------------------------------*/
}
fclose(fp5);
fprintf(stderr,"end of crab stuff\n");
/*Free up any memory allocated in crab section*/
XLALFree(edat);
}
#endif
/*fprintf(stderr,"end of spec_avg 1\n");*/
/*=======================================================================================================================*/
/*=======================================================================================================================*/
/*release a;; the allocaeted memory*/
LALCHARDestroyVector(&status, ×tamp);
LALCHARDestroyVector(&status, &year_date);
LALDestroySFTVector (&status, &sft_vect );
/*fprintf(stderr,"end of spec_avg 2\n");*/
if (timeavg != NULL) XLALFree(timeavg);
/*fprintf(stderr,"end of spec_avg 3\n");*/
LAL_CALL(LALDestroyUserVars(&status), &status);
/*fprintf(stderr,"end of spec_avg 4\n");*/
/*close all the files, spec_avg.c is done, all info written to the files.*/
fclose(fp);
fclose(fp2);
fclose(fp3);
fclose(fp4);
fprintf(stderr,"end of spec_avg\n");
return(0);
}
int
main( void )
{
static LALStatus status;
char eEphFileBad[] = TEST_DATA_DIR "earth47.dat";
char eEphFile[] = TEST_DATA_DIR "earth98.dat";
char sEphFile[] = TEST_DATA_DIR "sun98.dat";
/* Checking response if data files not present */
EphemerisData edat;
edat.ephiles.earthEphemeris = eEphFileBad;
edat.ephiles.sunEphemeris = sEphFile;
LALInitBarycenter(&status, &edat);
if ( status.statusCode != LALINITBARYCENTERH_EOPEN)
{
XLALPrintError( "Got error code %d and message '%s', but expected error code %d\n", status.statusCode, status.statusDescription, LALINITBARYCENTERH_EOPEN);
return LALBARYCENTERTESTC_EOPEN;
}
else
{
// XLALPrintError ("==================== this error is as expected and OK!! ==================== \n");
xlalErrno = 0;
}
/* Now inputting kosher ephemeris. files and leap sec, to illustrate
* proper usage. The real, serious TEST of the code is a script written
* by Rejean Dupuis comparing LALBarycenter to TEMPO for thousands
* of source positions and times.
*/
edat.ephiles.earthEphemeris = eEphFile;
edat.ephiles.sunEphemeris = sEphFile;
LALInitBarycenter(&status, &edat);
if ( status.statusCode ) {
XLALPrintError ("LALInitBarycenter() failed with code %d\n", status.statusCode);
return XLAL_EFAILED;
}
/* ===== now test equivalence of new XLALInitBarycenter() function ========== */
EphemerisData *edat_xlal;
if ( ( edat_xlal = XLALInitBarycenter ( eEphFile, sEphFile )) == NULL ) {
XLALPrintError ("Something failed in XLALInitBarycenter(), errno =%d\n", xlalErrno );
return XLAL_EFAILED;
}
if ( compare_ephemeris ( &edat, edat_xlal ) != XLAL_SUCCESS ) {
XLALPrintError ("Equivalence test failed between XLALInitEphemeris() and LALInitEphemeris()\n" );
return XLAL_EFAILED;
}
XLALDestroyEphemerisData ( edat_xlal );
/* ========================================================================== */
/* The routines using LALBarycenter package, the code above, leading
up LALInitBarycenter call, should be near top of main. The idea is
that ephemeris data is read into RAM once, at the beginning.
NOTE that the only part of the piece of the LALDetector structure
baryinput.site that has to be filled in by the driver code is
the 3-vector: baryinput.site.location[] .
NOTE that the driver code that calls LALInitBarycenter must
LALFree(edat->ephemE) and LALFree(edat->ephemS).
The driver code that calls LALBarycenter must LALFree(edat).
*/
/* Now getting coords for detector */
LALDetector cachedDetector;
cachedDetector = lalCachedDetectors[LALDetectorIndexGEO600DIFF];
BarycenterInput XLAL_INIT_DECL(baryinput);
baryinput.site.location[0]=cachedDetector.location[0]/LAL_C_SI;
baryinput.site.location[1]=cachedDetector.location[1]/LAL_C_SI;
baryinput.site.location[2]=cachedDetector.location[2]/LAL_C_SI;
EarthState earth;
EarthState earth_xlal;
EmissionTime emit, emit_xlal, emit_opt;
/* ----- Checking error messages when the timestamp is not within the 1-yr ephemeris files */
LIGOTimeGPS tGPS = {t1998+5e7, 0 };
LALBarycenterEarth ( &status, &earth, &tGPS, &edat );
if ( status.statusCode == 0 ) {
XLALPrintError ( "LALBarycenterEarth() succeeded but expected to get error\n");
return LALBARYCENTERTESTC_EOUTOFRANGEE;
} else {
XLALPrintError ("==================== this error is as expected and OK!! ==================== \n");
xlalErrno = 0;
}
/* next try calling for bad choice of RA,DEC (e.g., something sensible in degrees, but radians)*/
tGPS.gpsSeconds = t1998+3600;
LALBarycenterEarth ( &status, &earth, &tGPS, &edat );
baryinput.alpha= 120;
baryinput.delta = 60;
baryinput.dInv = 0;
LALBarycenter ( &status, &emit, &baryinput, &earth );
if ( status.statusCode == 0 ) {
XLALPrintError( "LALBarycenter() succeeded but expected to get error\n" );
return LALBARYCENTERTESTC_EBADSOURCEPOS;
} else {
XLALPrintError ("==================== this error is as expected and OK!! ==================== \n");
xlalErrno = 0;
}
/* ---------- Now running program w/o errors, to illustrate proper use. ---------- */
EmissionTime XLAL_INIT_DECL(maxDiff);
EmissionTime XLAL_INIT_DECL(maxDiffOpt);
REAL8 tic, toc;
UINT4 NRepeat = 1;
UINT4 counter = 0;
REAL8 tau_lal = 0, tau_xlal = 0, tau_opt = 0;
BarycenterBuffer *buffer = NULL;
unsigned int seed = XLALGetTimeOfDay();
srand ( seed );
/* Outer loop over different sky positions */
for ( UINT4 k=0; k < 300; k++)
{
baryinput.alpha = ( 1.0 * rand() / RAND_MAX ) * LAL_TWOPI; // in [0, 2pi]
baryinput.delta = ( 1.0 * rand() / RAND_MAX ) * LAL_PI - LAL_PI_2;// in [-pi/2, pi/2]
baryinput.dInv = 0.e0;
/* inner loop over pulse arrival times */
for ( UINT4 i=0; i < 100; i++ )
{
REAL8 tPulse = t1998 + ( 1.0 * rand() / RAND_MAX ) * LAL_YRSID_SI; // t in [1998, 1999]
XLALGPSSetREAL8( &tGPS, tPulse );
baryinput.tgps = tGPS;
/* ----- old LAL interface ---------- */
LALBarycenterEarth ( &status, &earth, &tGPS, &edat);
if ( status.statusCode ) {
XLALPrintError ("LALBarycenterEarth() failed with code %d\n", status.statusCode);
return XLAL_EFAILED;
}
tic = XLALGetTimeOfDay();
for ( UINT4 l = 0; l < NRepeat; l++ )
LALBarycenter ( &status, &emit, &baryinput, &earth );
toc = XLALGetTimeOfDay();
tau_lal += ( toc - tic ) / NRepeat;
if ( status.statusCode ) {
XLALPrintError ("LALBarycenter() failed with code %d\n", status.statusCode);
return XLAL_EFAILED;
}
/* ----- new XLAL interface ---------- */
XLAL_CHECK ( XLALBarycenterEarth ( &earth_xlal, &tGPS, &edat ) == XLAL_SUCCESS, XLAL_EFAILED );
tic = XLALGetTimeOfDay();
for ( UINT4 l = 0; l < NRepeat; l ++ )
XLAL_CHECK ( XLALBarycenter ( &emit_xlal, &baryinput, &earth_xlal ) == XLAL_SUCCESS, XLAL_EFAILED );
toc = XLALGetTimeOfDay();
tau_xlal += ( toc - tic ) / NRepeat;
/* collect maximal deviations over all struct-fields of 'emit' */
EmissionTime thisDiff;
diffEmissionTime ( &thisDiff, &emit, &emit_xlal );
absmaxEmissionTime ( &maxDiff, &maxDiff, &thisDiff );
/* ----- optimized XLAL version with buffering ---------- */
tic = XLALGetTimeOfDay();
for ( UINT4 l = 0; l < NRepeat; l ++ )
XLAL_CHECK ( XLALBarycenterOpt ( &emit_opt, &baryinput, &earth_xlal, &buffer ) == XLAL_SUCCESS, XLAL_EFAILED );
toc = XLALGetTimeOfDay();
tau_opt += ( toc - tic ) / NRepeat;
/* collect maximal deviations over all struct-fields of 'emit' */
diffEmissionTime ( &thisDiff, &emit, &emit_opt );
absmaxEmissionTime ( &maxDiffOpt, &maxDiffOpt, &thisDiff );
counter ++;
} /* for i */
} /* for k */
XLALFree ( buffer );
buffer = NULL;
/* ----- check differences in results ---------- */
REAL8 tolerance = 1e-9; // in seconds: can't go beyond nanosecond precision due to GPS limitation
REAL8 maxEmitDiff = maxErrInEmissionTime ( &maxDiff );
REAL8 maxEmitDiffOpt = maxErrInEmissionTime ( &maxDiffOpt );
XLALPrintInfo ( "Max error (in seconds) between LALBarycenter() and XLALBarycenter() = %g s (tolerance = %g s)\n", maxEmitDiff, tolerance );
XLAL_CHECK ( maxEmitDiff < tolerance, XLAL_EFAILED,
"Max error (in seconds) between LALBarycenter() and XLALBarycenter() = %g s, exceeding tolerance of %g s\n", maxEmitDiff, tolerance );
XLALPrintInfo ( "Max error (in seconds) between LALBarycenter() and XLALBarycenterOpt() = %g s (tolerance = %g s)\n", maxEmitDiffOpt, tolerance );
XLAL_CHECK ( maxEmitDiffOpt < tolerance, XLAL_EFAILED,
"Max error (in seconds) between LALBarycenter() and XLALBarycenterOpt() = %g s, exceeding tolerance of %g s\n",
maxEmitDiffOpt, tolerance );
printf ( "%g %g %d %d %g %g %g %g %g %g %g\n",
maxEmitDiffOpt,
maxDiffOpt.deltaT, maxDiffOpt.te.gpsSeconds, maxDiffOpt.te.gpsNanoSeconds, maxDiffOpt.tDot,
maxDiffOpt.rDetector[0], maxDiffOpt.rDetector[1], maxDiffOpt.rDetector[2],
maxDiffOpt.vDetector[0], maxDiffOpt.vDetector[1], maxDiffOpt.vDetector[2]
);
/* ----- output runtimes ---------- */
XLALPrintError ("Runtimes per function-call, averaged over %g calls\n", 1.0 * NRepeat * counter );
XLALPrintError ("LALBarycenter() %g s\n", tau_lal / counter );
XLALPrintError ("XLALBarycenter() %g s (= %.1f %%)\n", tau_xlal / counter, - 100 * (tau_lal - tau_xlal ) / tau_lal );
XLALPrintError ("XLALBarycenterOpt() %g s (= %.1f %%)\n", tau_opt / counter, - 100 * (tau_lal - tau_opt ) / tau_lal );
/* ===== test XLALRestrictEphemerisData() ===== */
XLALPrintInfo("\n\nTesting XLALRestrictEphemerisData() ... ");
{
XLAL_CHECK( edat.nentriesS >= 100, XLAL_EFAILED );
const INT4 orig_nentriesS = edat.nentriesS;
for (INT4 i = 1; i <= 4; ++i) {
REAL8 start, end;
LIGOTimeGPS startGPS, endGPS;
INT4 diff_nentriesS;
start = edat.ephemS[2*i].gps;
end = edat.ephemS[edat.nentriesS - 1 - 3*i].gps;
XLAL_CHECK( XLALGPSSetREAL8(&startGPS, start) != NULL, XLAL_EFUNC );
XLAL_CHECK( XLALGPSSetREAL8(&endGPS, end) != NULL, XLAL_EFUNC );
XLAL_CHECK( XLALRestrictEphemerisData(&edat, &startGPS, &endGPS) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK( edat.ephemS[0].gps == start, XLAL_EFAILED, "\nTest S%dA FAILED: %0.9f != start %0.9f\n", i, edat.ephemS[0].gps, start );
XLAL_CHECK( edat.ephemS[edat.nentriesS - 1].gps == end, XLAL_EFAILED, "\nTest S%dA FAILED: end %0.9f != %0.9f\n", i, edat.ephemS[edat.nentriesS - 1].gps, end );
diff_nentriesS = ((i*i + i) * 5) / 2 + 2*(i-1);
XLAL_CHECK( orig_nentriesS - edat.nentriesS == diff_nentriesS, XLAL_EFAILED, "\nTest S%dA FAILED: nentries %d != %d\n", i, orig_nentriesS - edat.nentriesS, diff_nentriesS );
XLAL_CHECK( XLALGPSSetREAL8(&startGPS, start + 0.5*edat.dtStable) != NULL, XLAL_EFUNC );
XLAL_CHECK( XLALGPSSetREAL8(&endGPS, end - 0.5*edat.dtStable) != NULL, XLAL_EFUNC );
start = edat.ephemS[0].gps;
end = edat.ephemS[edat.nentriesS - 1].gps;
XLAL_CHECK( XLALRestrictEphemerisData(&edat, &startGPS, &endGPS) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK( edat.ephemS[0].gps == start, XLAL_EFAILED, "\nTest S%dB FAILED: start %0.9f != %0.9f\n", i, edat.ephemS[0].gps, start );
XLAL_CHECK( edat.ephemS[edat.nentriesS - 1].gps == end, XLAL_EFAILED, "\nTest S%dB FAILED: end %0.9f != %0.9f\n", i, edat.ephemS[edat.nentriesS - 1].gps, end );
diff_nentriesS = ((i*i + i) * 5) / 2 + 2*(i-1);
XLAL_CHECK( orig_nentriesS - edat.nentriesS == diff_nentriesS, XLAL_EFAILED, "\nTest S%dB FAILED: nentries %d != %d\n", i, orig_nentriesS - edat.nentriesS, diff_nentriesS );
XLAL_CHECK( XLALGPSSetREAL8(&startGPS, start + 1.5*edat.dtStable) != NULL, XLAL_EFUNC );
XLAL_CHECK( XLALGPSSetREAL8(&endGPS, end - 1.5*edat.dtStable) != NULL, XLAL_EFUNC );
start = edat.ephemS[1].gps;
end = edat.ephemS[edat.nentriesS - 2].gps;
XLAL_CHECK( XLALRestrictEphemerisData(&edat, &startGPS, &endGPS) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK( edat.ephemS[0].gps == start, XLAL_EFAILED, "\nTest S%dC FAILED: start %0.9f != %0.9f\n", i, edat.ephemS[0].gps, start );
XLAL_CHECK( edat.ephemS[edat.nentriesS - 1].gps == end, XLAL_EFAILED, "\nTest S%dC FAILED: end %0.9f != %0.9f\n", i, edat.ephemS[edat.nentriesS - 1].gps, end );
diff_nentriesS = ((i*i + i) * 5) / 2 + 2*i;
XLAL_CHECK( orig_nentriesS - edat.nentriesS == diff_nentriesS, XLAL_EFAILED, "\nTest S%dC FAILED: nentries %d != %d\n", i, orig_nentriesS - edat.nentriesS, diff_nentriesS );
}
XLAL_CHECK( edat.nentriesE >= 100, XLAL_EFAILED );
const INT4 orig_nentriesE = edat.nentriesE;
for (INT4 i = 1; i <= 4; ++i) {
REAL8 start, end;
LIGOTimeGPS startGPS, endGPS;
INT4 diff_nentriesE;
start = edat.ephemE[2*i].gps;
end = edat.ephemE[edat.nentriesE - 1 - 3*i].gps;
XLAL_CHECK( XLALGPSSetREAL8(&startGPS, start) != NULL, XLAL_EFUNC );
XLAL_CHECK( XLALGPSSetREAL8(&endGPS, end) != NULL, XLAL_EFUNC );
XLAL_CHECK( XLALRestrictEphemerisData(&edat, &startGPS, &endGPS) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK( edat.ephemE[0].gps == start, XLAL_EFAILED, "\nTest E%dA FAILED: %0.9f != start %0.9f\n", i, edat.ephemE[0].gps, start );
XLAL_CHECK( edat.ephemE[edat.nentriesE - 1].gps == end, XLAL_EFAILED, "\nTest E%dA FAILED: end %0.9f != %0.9f\n", i, edat.ephemE[edat.nentriesE - 1].gps, end );
diff_nentriesE = ((i*i + i) * 5) / 2 + 2*(i-1);
XLAL_CHECK( orig_nentriesE - edat.nentriesE == diff_nentriesE, XLAL_EFAILED, "\nTest E%dA FAILED: nentries %d != %d\n", i, orig_nentriesE - edat.nentriesE, diff_nentriesE );
XLAL_CHECK( XLALGPSSetREAL8(&startGPS, start + 0.5*edat.dtEtable) != NULL, XLAL_EFUNC );
XLAL_CHECK( XLALGPSSetREAL8(&endGPS, end - 0.5*edat.dtEtable) != NULL, XLAL_EFUNC );
start = edat.ephemE[0].gps;
end = edat.ephemE[edat.nentriesE - 1].gps;
XLAL_CHECK( XLALRestrictEphemerisData(&edat, &startGPS, &endGPS) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK( edat.ephemE[0].gps == start, XLAL_EFAILED, "\nTest E%dB FAILED: start %0.9f != %0.9f\n", i, edat.ephemE[0].gps, start );
XLAL_CHECK( edat.ephemE[edat.nentriesE - 1].gps == end, XLAL_EFAILED, "\nTest E%dB FAILED: end %0.9f != %0.9f\n", i, edat.ephemE[edat.nentriesE - 1].gps, end );
diff_nentriesE = ((i*i + i) * 5) / 2 + 2*(i-1);
XLAL_CHECK( orig_nentriesE - edat.nentriesE == diff_nentriesE, XLAL_EFAILED, "\nTest E%dB FAILED: nentries %d != %d\n", i, orig_nentriesE - edat.nentriesE, diff_nentriesE );
XLAL_CHECK( XLALGPSSetREAL8(&startGPS, start + 1.5*edat.dtEtable) != NULL, XLAL_EFUNC );
XLAL_CHECK( XLALGPSSetREAL8(&endGPS, end - 1.5*edat.dtEtable) != NULL, XLAL_EFUNC );
start = edat.ephemE[1].gps;
end = edat.ephemE[edat.nentriesE - 2].gps;
XLAL_CHECK( XLALRestrictEphemerisData(&edat, &startGPS, &endGPS) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK( edat.ephemE[0].gps == start, XLAL_EFAILED, "\nTest E%dC FAILED: start %0.9f != %0.9f\n", i, edat.ephemE[0].gps, start );
XLAL_CHECK( edat.ephemE[edat.nentriesE - 1].gps == end, XLAL_EFAILED, "\nTest E%dC FAILED: end %0.9f != %0.9f\n", i, edat.ephemE[edat.nentriesE - 1].gps, end );
diff_nentriesE = ((i*i + i) * 5) / 2 + 2*i;
XLAL_CHECK( orig_nentriesE - edat.nentriesE == diff_nentriesE, XLAL_EFAILED, "\nTest E%dC FAILED: nentries %d != %d\n", i, orig_nentriesE - edat.nentriesE, diff_nentriesE );
}
}
XLALPrintInfo("PASSED\n\n");
LALFree(edat.ephemE);
LALFree(edat.ephemS);
LALCheckMemoryLeaks();
XLALPrintError ("==> OK. All tests successful!\n\n");
return 0;
} /* main() */
/* vvvvvvvvvvvvvvvvvvvvvvvvvvvvvv------------------------------------ */
int main(int argc, char *argv[]){
static LALStatus status; /* LALStatus pointer */
static LALDetector detector;
static LIGOTimeGPSVector timeV;
static REAL8Cart3CoorVector velV;
static HOUGHptfLUTVector lutV; /* the Look Up Table vector*/
static HOUGHPeakGramVector pgV;
static PHMDVectorSequence phmdVS; /* the partial Hough map derivatives */
static UINT8FrequencyIndexVector freqInd;
static HOUGHResolutionPar parRes;
static HOUGHPatchGrid patch; /* Patch description */
static HOUGHParamPLUT parLut; /* parameters needed to build lut */
static HOUGHDemodPar parDem; /* demodulation parameters or */
static HOUGHSizePar parSize;
static VelocityPar velPar;
static HOUGHMapTotal ht; /* the total Hough map */
/* ------------------------------------------------------- */
CHAR *earthEphemeris = NULL;
CHAR *sunEphemeris = NULL;
INT4 ifo;
REAL8 vel[3];
INT4 mObsCoh;
UINT2 maxNBins, maxNBorders;
INT8 f0Bin; /* freq. bin to construct LUT */
INT8 fBin;
UINT2 xSide, ySide;
CHAR *fname = NULL; /* The output filename */
FILE *fp=NULL; /* Output file */
INT4 arg; /* Argument counter */
UINT4 i,j; /* Index counter, etc */
INT4 k;
REAL8 f0, alpha, delta;
REAL8 patchSizeX, patchSizeY;
REAL8 Xx,Xy,Xz;
/******************************************************************/
/* Set up the default parameters. */
/* ****************************************************************/
detector = lalCachedDetectors[LALDetectorIndexGEO600DIFF]; /* default */
ifo = IFO;
if (ifo ==1) detector=lalCachedDetectors[LALDetectorIndexGEO600DIFF];
if (ifo ==2) detector=lalCachedDetectors[LALDetectorIndexLLODIFF];
if (ifo ==3) detector=lalCachedDetectors[LALDetectorIndexLHODIFF];
earthEphemeris = EARTHEPHEMERIS;
sunEphemeris = SUNEPHEMERIS;
mObsCoh = MOBSCOH;
timeV.length = mObsCoh;
velV.length = mObsCoh;
lutV.length = mObsCoh;
pgV.length = mObsCoh;
phmdVS.length = mObsCoh;
freqInd.length = mObsCoh;
phmdVS.nfSize = NFSIZE;
freqInd.deltaF = DF;
phmdVS.deltaF = DF;
timeV.time = NULL;
velV.data = NULL;
lutV.lut = NULL;
pgV.pg = NULL;
phmdVS.phmd = NULL;
freqInd.data = NULL;
ht.map = NULL;
f0 = F0;
f0Bin = F0*TCOH;
parRes.f0Bin = f0Bin;
parRes.deltaF = DF;
/*
* parRes.patchSkySizeX = patchSizeX = 1.0/(TCOH*F0*VEPI);
* parRes.patchSkySizeY = patchSizeY = 1.0/(TCOH*F0*VEPI);
*/
parRes.patchSkySizeX = patchSizeX = PATCHSIZEX;
parRes.patchSkySizeY = patchSizeY = PATCHSIZEY;
parRes.pixelFactor = PIXELFACTOR;
parRes.pixErr = PIXERR;
parRes.linErr = LINERR;
parRes.vTotC = VTOT;
/* Case: no spins & Non demodulation */
parDem.deltaF = DF;
parDem.skyPatch.alpha = ALPHA;
parDem.skyPatch.delta = DELTA;
parDem.timeDiff = 0.0;
parDem.spin.length = 0;
parDem.spin.data = NULL;
parDem.positC.x = 0.0;
parDem.positC.y = 0.0;
parDem.positC.z = 0.0;
velPar.detector = detector;
velPar.tBase = TCOH;
velPar.vTol = ACCURACY;
alpha = ALPHA;
delta = DELTA;
/*****************************************************************/
/*****************************************************************/
/* Parse argument list. i stores the current position. */
/*****************************************************************/
arg = 1;
while ( arg < argc ) {
/* Parse debuglevel option. */
if ( !strcmp( argv[arg], "-d" ) ) {
if ( argc > arg + 1 ) {
arg++;
} else {
ERROR( VALIDATION1_EARG, VALIDATION1_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return VALIDATION1_EARG;
}
}
/* Parse interferometer option. */
else if ( !strcmp( argv[arg], "-i" ) ) {
if ( argc > arg + 1 ) {
arg++;
ifo = atoi( argv[arg++] );
if (ifo ==1) detector=lalCachedDetectors[LALDetectorIndexGEO600DIFF];
if (ifo ==2) detector=lalCachedDetectors[LALDetectorIndexLLODIFF];
if (ifo ==3) detector=lalCachedDetectors[LALDetectorIndexLHODIFF];
velPar.detector = detector;
} else {
ERROR( VALIDATION1_EARG, VALIDATION1_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return VALIDATION1_EARG;
}
}
/* Parse filename of earth ephemeris data option. */
else if ( !strcmp( argv[arg], "-E" ) ) {
if ( argc > arg + 1 ) {
arg++;
earthEphemeris = argv[arg++];
} else {
ERROR( VALIDATION1_EARG, VALIDATION1_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return VALIDATION1_EARG;
}
}
/* Parse filename of sun ephemeris data option. */
else if ( !strcmp( argv[arg], "-S" ) ) {
if ( argc > arg + 1 ) {
arg++;
sunEphemeris = argv[arg++];
} else {
ERROR( VALIDATION1_EARG, VALIDATION1_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return VALIDATION1_EARG;
}
}
/* Parse output file option. */
else if ( !strcmp( argv[arg], "-o" ) ) {
if ( argc > arg + 1 ) {
arg++;
fname = argv[arg++];
} else {
ERROR( VALIDATION1_EARG, VALIDATION1_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return VALIDATION1_EARG;
}
}
/* Parse frequency option. */
else if ( !strcmp( argv[arg], "-f" ) ) {
if ( argc > arg + 1 ) {
arg++;
f0 = atof(argv[arg++]);
f0Bin = f0*TCOH;
parRes.f0Bin = f0Bin;
} else {
ERROR( VALIDATION1_EARG, VALIDATION1_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return VALIDATION1_EARG;
}
}
/* Parse sky position options. */
else if ( !strcmp( argv[arg], "-p" ) ) {
if ( argc > arg + 2 ) {
arg++;
alpha = atof(argv[arg++]);
delta = atof(argv[arg++]);
parDem.skyPatch.alpha = alpha;
parDem.skyPatch.delta = delta;
} else {
ERROR( VALIDATION1_EARG, VALIDATION1_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return VALIDATION1_EARG;
}
}
/* Parse patch size option. */
else if ( !strcmp( argv[arg], "-s" ) ) {
if ( argc > arg + 2 ) {
arg++;
parRes.patchSkySizeX = patchSizeX = atof(argv[arg++]);
parRes.patchSkySizeY = patchSizeY = atof(argv[arg++]);
} else {
ERROR( VALIDATION1_EARG, VALIDATION1_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return VALIDATION1_EARG;
}
}
/* Unrecognized option. */
else {
ERROR( VALIDATION1_EARG, VALIDATION1_MSGEARG, 0 );
XLALPrintError( USAGE, *argv );
return VALIDATION1_EARG;
}
} /* End of argument parsing loop. */
/******************************************************************/
if ( f0 < 0 ) {
ERROR( VALIDATION1_EBAD, VALIDATION1_MSGEBAD, "freq<0:" );
XLALPrintError( USAGE, *argv );
return VALIDATION1_EBAD;
}
/******************************************************************/
/******************************************************************/
/* create time stamps (for a test) */
/******************************************************************/
timeV.time = (LIGOTimeGPS *)LALMalloc(mObsCoh*sizeof(LIGOTimeGPS));
timeV.time[0].gpsSeconds = T0SEC;
timeV.time[0].gpsNanoSeconds = T0NSEC;
for(j=1; j<timeV.length; ++j){
timeV.time[j].gpsSeconds = timeV.time[j-1].gpsSeconds + TCOH + JUMPTIME;
timeV.time[j].gpsNanoSeconds = T0NSEC;
}
/******************************************************************/
/* compute detector velocity for those time stamps (for a test) */
/******************************************************************/
velV.data = (REAL8Cart3Coor *)LALMalloc(mObsCoh*sizeof(REAL8Cart3Coor));
velPar.edat = NULL;
{
EphemerisData *edat=NULL;
/* ephemeris info */
edat = (EphemerisData *)LALMalloc(sizeof(EphemerisData));
(*edat).ephiles.earthEphemeris = earthEphemeris;
(*edat).ephiles.sunEphemeris = sunEphemeris;
/* read in ephemeris data */
SUB( LALInitBarycenter( &status, edat), &status);
velPar.edat = edat;
for(j=0; j<velV.length; ++j){
velPar.startTime.gpsSeconds = timeV.time[j].gpsSeconds;
velPar.startTime.gpsNanoSeconds = timeV.time[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];
}
LALFree(edat->ephemE);
LALFree(edat->ephemS);
LALFree(edat);
}
/******************************************************************/
/******************************************************************/
/* create patch grid */
/******************************************************************/
SUB( LALHOUGHComputeNDSizePar( &status, &parSize, &parRes ), &status );
xSide = parSize.xSide;
ySide = parSize.ySide;
maxNBins = parSize.maxNBins;
maxNBorders = parSize.maxNBorders;
/* allocate memory based on xSide and ySide */
patch.xSide = xSide;
patch.ySide = ySide;
/* allocate memory based on xSide and ySide */
patch.xCoor = NULL;
patch.yCoor = NULL;
patch.xCoor = (REAL8 *)LALMalloc(xSide*sizeof(REAL8));
patch.yCoor = (REAL8 *)LALMalloc(ySide*sizeof(REAL8));
SUB( LALHOUGHFillPatchGrid( &status, &patch, &parSize ), &status );
/******************************************************************/
/******************************************************************/
/* memory allocation and settings */
/******************************************************************/
lutV.lut = (HOUGHptfLUT *)LALMalloc(mObsCoh*sizeof(HOUGHptfLUT));
pgV.pg = (HOUGHPeakGram *)LALMalloc(mObsCoh*sizeof(HOUGHPeakGram));
phmdVS.phmd =(HOUGHphmd *)LALMalloc(mObsCoh*NFSIZE*sizeof(HOUGHphmd));
freqInd.data = ( UINT8 *)LALMalloc(mObsCoh*sizeof(UINT8));
for(j=0; j<lutV.length; ++j){
lutV.lut[j].maxNBins = maxNBins;
lutV.lut[j].maxNBorders = maxNBorders;
lutV.lut[j].border =
(HOUGHBorder *)LALMalloc(maxNBorders*sizeof(HOUGHBorder));
lutV.lut[j].bin =
(HOUGHBin2Border *)LALMalloc(maxNBins*sizeof(HOUGHBin2Border));
}
for(j=0; j<phmdVS.length * phmdVS.nfSize; ++j){
phmdVS.phmd[j].maxNBorders = maxNBorders;
phmdVS.phmd[j].leftBorderP =
(HOUGHBorder **)LALMalloc(maxNBorders*sizeof(HOUGHBorder *));
phmdVS.phmd[j].rightBorderP =
(HOUGHBorder **)LALMalloc(maxNBorders*sizeof(HOUGHBorder *));
}
ht.xSide = xSide;
ht.ySide = ySide;
ht.map = NULL;
ht.map = (HoughTT *)LALMalloc(xSide*ySide*sizeof(HoughTT));
for(j=0; j<phmdVS.length * phmdVS.nfSize; ++j){
phmdVS.phmd[j].ySide = ySide;
phmdVS.phmd[j].firstColumn = NULL;
phmdVS.phmd[j].firstColumn = (UCHAR *)LALMalloc(ySide*sizeof(UCHAR));
}
for (j=0; j<lutV.length ; ++j){
for (i=0; i<maxNBorders; ++i){
lutV.lut[j].border[i].ySide = ySide;
lutV.lut[j].border[i].xPixel =
(COORType *)LALMalloc(ySide*sizeof(COORType));
}
}
/******************************************************************/
/******************************************************************/
/* create Peakgrams for testing */
/******************************************************************/
/* let us fix a source at a given position
(not at the center of the patch, but a pixel center) */
{
UINT2 xPos, yPos;
REAL8Cart2Coor sourceProjected;
REAL8UnitPolarCoor sourceRotated;
REAL8UnitPolarCoor skyPatchCenter;
REAL8UnitPolarCoor sourceLocation;
xPos = xSide/2;
yPos = ySide/2;
sourceProjected.x = patch.xCoor[xPos];
sourceProjected.y = patch.yCoor[yPos];
skyPatchCenter.alpha = parDem.skyPatch.alpha;
skyPatchCenter.delta = parDem.skyPatch.delta;
/* invert the stereographic projection for a point on the projected plane */
SUB( LALStereoInvProjectCart( &status, &sourceRotated, &sourceProjected ), &status );
/* undo roation in case the patch is not centered at the south pole */
SUB( LALInvRotatePolarU( &status, &sourceLocation, &sourceRotated, &skyPatchCenter ), &status );
Xx= cos(sourceLocation.delta)* cos(sourceLocation.alpha);
Xy= cos(sourceLocation.delta)* sin(sourceLocation.alpha);
Xz= sin(sourceLocation.delta);
}
for (j=0;j< mObsCoh; ++j) { /* create all the peakgrams */
REAL8 veldotX;
pgV.pg[j].deltaF = DF;
/*
* pgV.pg[j].fBinIni = f0Bin/2;
* pgV.pg[j].fBinFin = f0Bin*2;
*/
pgV.pg[j].fBinIni = f0Bin-maxNBins;
pgV.pg[j].fBinFin = f0Bin+3*maxNBins;
/* pgV.pg[j].length = 2; */
pgV.pg[j].length = 1;
pgV.pg[j].peak = NULL;
pgV.pg[j].peak = (INT4 *)LALMalloc( ( pgV.pg[j].length) * sizeof(INT4));
veldotX = Xx*velV.data[j].x + Xy*velV.data[j].y + Xz*velV.data[j].z;
/* fBin = [ f0Bin * ( 1 + veldotX ) ] */
pgV.pg[j].peak[0]= floor( f0Bin*(1.0+veldotX) +0.5) - pgV.pg[j].fBinIni;
/* pgV.pg[j].peak[1]= pgV.pg[j].peak[0]+2; */
}
/******************************************************************/
/******************************************************************/
/* create all the LUTs */
/******************************************************************/
for (j=0;j< mObsCoh;++j){ /* create all the LUTs */
parDem.veloC.x = velV.data[j].x;
parDem.veloC.y = velV.data[j].y;
parDem.veloC.z = velV.data[j].z;
/* calculate parameters needed for buiding the LUT */
SUB( LALNDHOUGHParamPLUT( &status, &parLut, &parSize, &parDem ), &status );
/* build the LUT */
SUB( LALHOUGHConstructPLUT( &status, &(lutV.lut[j]), &patch, &parLut ),
&status );
}
/******************************************************************/
/* starting the search (A very simple case for only 1 frequency) */
/******************************************************************/
/* build the set of PHMD starting at f0Bin*/
/******************************************************************/
fBin = f0Bin;
phmdVS.fBinMin = fBin;
SUB( LALHOUGHConstructSpacePHMD(&status, &phmdVS, &pgV, &lutV), &status );
/* shift the structure one frequency bin */
/* SUB( LALHOUGHupdateSpacePHMDup(&status, &phmdVS, &pgV, &lutV), &status );*/
/******************************************************************/
/* initializing the Hough map space */
/******************************************************************/
SUB( LALHOUGHInitializeHT( &status, &ht, &patch ), &status );
/******************************************************************/
/* construction of a total Hough map */
/******************************************************************/
for (j=0;j< mObsCoh;++j){
freqInd.data[j]= fBin;
}
SUB( LALHOUGHConstructHMT( &status, &ht, &freqInd, &phmdVS ), &status );
/******************************************************************/
/* printing the results into a particular file */
/* if the -o option was given, or into FILEOUT */
/******************************************************************/
if ( fname ) {
fp = fopen( fname, "w" );
} else {
fp = fopen( FILEOUT , "w" );
}
if ( !fp ){
ERROR( VALIDATION1_EFILE, VALIDATION1_MSGEFILE, 0 );
return VALIDATION1_EFILE;
}
for(k=ySide-1; k>=0; --k){
for(i=0;i<xSide;++i){
fprintf( fp ," %d", ht.map[k*xSide +i]);
fflush( fp );
}
fprintf( fp ," \n");
fflush( fp );
}
fclose( fp );
/******************************************************************/
/* Free memory and exit */
/******************************************************************/
for (j=0;j< mObsCoh;++j){
LALFree( pgV.pg[j].peak); /* All of them */
}
for (j=0; j<lutV.length ; ++j){
for (i=0; i<maxNBorders; ++i){
LALFree( lutV.lut[j].border[i].xPixel);
}
LALFree( lutV.lut[j].border);
LALFree( lutV.lut[j].bin);
}
for(j=0; j<phmdVS.length * phmdVS.nfSize; ++j){
LALFree( phmdVS.phmd[j].leftBorderP);
LALFree( phmdVS.phmd[j].rightBorderP);
LALFree( phmdVS.phmd[j].firstColumn);
}
LALFree(timeV.time);
LALFree(velV.data);
LALFree(lutV.lut);
LALFree(pgV.pg);
LALFree(phmdVS.phmd);
LALFree(freqInd.data);
LALFree(ht.map);
LALFree(patch.xCoor);
LALFree(patch.yCoor);
LALCheckMemoryLeaks();
INFO( VALIDATION1_MSGENORM );
return VALIDATION1_ENORM;
}
/**
* Very simple test: pick random skyposition, compute a_i, b_i using
* once LALComputeAM() and once LALNewGetAMCoeffs(), and look at the errors
* sum_i (a_i - a_i')^2
*/
int main(int argc, char *argv[])
{
LALStatus XLAL_INIT_DECL(status);
int opt; /* Command-line option. */
LIGOTimeGPS startTime = {714180733, 0};
REAL8 duration = 180000; /* 50 hours */
REAL8 Tsft = 1800; /* assume 30min SFTs */
LIGOTimeGPSVector *timestamps = NULL;
DetectorStateSeries *detStates = NULL;
SkyPosition XLAL_INIT_DECL(skypos);
EphemerisData XLAL_INIT_DECL(edat);
BarycenterInput XLAL_INIT_DECL(baryinput);
LALDetector *det = NULL;
AMCoeffs XLAL_INIT_DECL(AMold);
AMCoeffs XLAL_INIT_DECL(AMnew1);
AMCoeffs XLAL_INIT_DECL(AMnew2);
REAL8 alpha, delta;
AMCoeffsParams XLAL_INIT_DECL(amParams);
EarthState earth;
UINT4 i;
REAL8 maxerr01, maxerr02, maxerr12, averr01, averr02, averr12;
REAL8 tolerance = 1e-2; /* be generous: allow 1% error */
struct tms buf;
const CHAR *sites[] = {"H1", "L1", "V2", "G1", "T1" };
REAL8 sinzeta; /* zeta = IFO opening angle */
UINT4 pickedSite;
BOOLEAN ignoreErrors = 0; /* Don't fail if tolerance exceeded */
UINT4 numChecks = 1; /* Number of times to check */
char earthEphem[] = TEST_DATA_DIR "earth00-19-DE405.dat.gz";
char sunEphem[] = TEST_DATA_DIR "sun00-19-DE405.dat.gz";
/* ----- old testing code to use 9 degree earth rotations ----- */
/* startTime.gpsSeconds = 714275242;
duration = 86164;
Tsft = 2154.1; */
while ((opt = LALgetopt( argc, argv, "n:qv:" )) != -1) {
switch (opt) {
case 'v': /* set lalDebugLevel */
break;
case 'q': /* don't fail if tolerance exceeded */
ignoreErrors = 1;
break;
case 'n': /* number of times to check */
numChecks = atoi( LALoptarg );
break;
}
}
/* init random-generator */
srand ( times(&buf) );
/* ----- init ephemeris ----- */
edat.ephiles.earthEphemeris = earthEphem;
edat.ephiles.sunEphemeris = sunEphem;
SUB ( LALInitBarycenter(&status, &edat), &status);
/* ----- get timestamps ----- */
SUB ( LALMakeTimestamps ( &status, ×tamps, startTime, duration, Tsft ), &status );
/* ----- allocate memory for AM-coeffs ----- */
AMold.a = XLALCreateREAL4Vector ( timestamps->length );
AMold.b = XLALCreateREAL4Vector ( timestamps->length );
AMnew1.a = XLALCreateREAL4Vector ( timestamps->length );
AMnew1.b = XLALCreateREAL4Vector ( timestamps->length );
AMnew2.a = XLALCreateREAL4Vector ( timestamps->length );
AMnew2.b = XLALCreateREAL4Vector ( timestamps->length );
while ( numChecks-- )
{
/* ----- pick detector-site at random ----- */
pickedSite = floor( 5 * (1.0 * rand() / (RAND_MAX + 1.0) ) ); /* int in [0,5) */
/* NOTE: contrary to ComputeAM() and LALGetAMCoffs(), the new function LALNewGetAMCoeffs()
* computes 'a * sinzeta' and 'b * sinzeta': for the comparison we therefore need to correct
* for GEO's opening-angle of 94.33degrees [JKS98]: */
if ( ! strcmp ( sites[pickedSite], "G1" ) )
sinzeta = 0.997146;
else
sinzeta = 1;
if ( ( det = XLALGetSiteInfo ( sites[pickedSite] )) == NULL )
{
XLALPrintError ("\nCall to XLALGetSiteInfo() has failed for site = '%s'... \n\n",
sites[pickedSite]);
return NEWGETAMCOEFFSTEST_ESUB;
}
/* ----- pick skyposition at random ----- */
alpha = LAL_TWOPI * (1.0 * rand() / ( RAND_MAX + 1.0 ) ); /* uniform in [0, 2pi) */
delta = LAL_PI_2 - acos ( 1 - 2.0 * rand()/RAND_MAX ); /* sin(delta) uniform in [-1,1] */
/* ----- old testing code to put source overhead ----- */
/* alpha = det->frDetector.vertexLongitudeRadians;
delta = det->frDetector.vertexLatitudeRadians; */
/* ===== compute AM-coeffs the 'old way': ===== */
baryinput.site.location[0] = det->location[0]/LAL_C_SI;
baryinput.site.location[1] = det->location[1]/LAL_C_SI;
baryinput.site.location[2] = det->location[2]/LAL_C_SI;
baryinput.alpha = alpha;
baryinput.delta = delta;
baryinput.dInv = 0.e0;
/* amParams structure to compute a(t) and b(t) */
amParams.das = (LALDetAndSource *)LALMalloc(sizeof(LALDetAndSource));
amParams.das->pSource = (LALSource *)LALMalloc(sizeof(LALSource));
amParams.baryinput = &baryinput;
amParams.earth = &earth;
amParams.edat = &edat;
amParams.das->pDetector = det;
amParams.das->pSource->equatorialCoords.longitude = alpha;
amParams.das->pSource->equatorialCoords.latitude = delta;
amParams.das->pSource->orientation = 0.0;
amParams.das->pSource->equatorialCoords.system = COORDINATESYSTEM_EQUATORIAL;
amParams.polAngle = 0;
SUB (LALComputeAM ( &status, &AMold, timestamps->data, &amParams), &status);
/* ===== compute AM-coeffs the 'new way' using LALNewGetAMCoeffs() */
/* ----- get detector-state series ----- */
SUB ( LALGetDetectorStates (&status, &detStates, timestamps, det, &edat, 0 ), &status );
skypos.system = COORDINATESYSTEM_EQUATORIAL;
skypos.longitude = alpha;
skypos.latitude = delta;
/* the 'new' and the 'newer' way ... */
SUB ( LALGetAMCoeffs ( &status, &AMnew1, detStates, skypos ), &status ); /* 'new1' */
SUB ( LALNewGetAMCoeffs ( &status, &AMnew2, detStates, skypos ), &status ); /* 'new2' */
/* ===== analyse relative errors ===== */
maxerr01 = maxerr02 = maxerr12 = 0; /* errors between 0='old', 1='new1', 2='new2' */
averr01 = averr02 = averr12 = 0;
for ( i=0; i < timestamps->length; i ++ )
{
/* printf("GPS time: %d s %d ns; GMST in radians: %f\n",
detStates->data[i].tGPS.gpsSeconds,
detStates->data[i].tGPS.gpsNanoSeconds,
fmod(detStates->data[i].earthState.gmstRad,LAL_TWOPI));
printf("Old AM coeffs: a=%f, b=%f\nNew AM coeffs: a=%f, b=%f\nNEWER AM coeffs: a=%f b=%f",
AMold.a->data[i], AMold.b->data[i],
AMnew.a->data[i], AMnew.b->data[i],
AMnewer.a->data[i], AMnewer.b->data[i]); */
REAL8 thisErr;
/* compare 0-1 */
thisErr = sqrt( SQ ( AMold.a->data[i] - AMnew1.a->data[i] ) / AMold.A );
averr01 += thisErr;
maxerr01 = MYMAX( thisErr, maxerr01 );
thisErr = sqrt( SQ ( AMold.b->data[i] - AMnew1.b->data[i] ) / AMold.B );
averr01 += thisErr;
maxerr01 = MYMAX( thisErr, maxerr01 );
/* compare 0-2 */
thisErr = sqrt( SQ ( AMold.a->data[i] - AMnew2.a->data[i]/sinzeta ) / AMold.A );
averr02 += thisErr;
maxerr02 = MYMAX( thisErr, maxerr02 );
thisErr = sqrt( SQ ( AMold.b->data[i] - AMnew2.b->data[i]/sinzeta ) / AMold.B );
averr02 += thisErr;
maxerr02 = MYMAX( thisErr, maxerr02 );
/* compare 1-2 */
thisErr = sqrt( SQ ( AMnew1.a->data[i] - AMnew2.a->data[i]/sinzeta ) / AMold.A );
averr12 += thisErr;
maxerr12 = MYMAX( thisErr, maxerr12 );
thisErr = sqrt( SQ ( AMnew1.b->data[i] - AMnew2.b->data[i]/sinzeta ) / AMold.B );
averr12 += thisErr;
maxerr12 = MYMAX( thisErr, maxerr12 );
}
averr01 /= 2.0 * timestamps->length;
averr02 /= 2.0 * timestamps->length;
averr12 /= 2.0 * timestamps->length;
if ( lalDebugLevel )
{
printf ("Parameters: IFO = %s, skypos = [%g, %g]\n", sites[pickedSite], alpha, delta );
printf ("Maximal relative errors: maxerr(0-1) = %g %%, maxerr(0-2) = %g %% maxerr(1-2) = %g %%\n",
100.0 * maxerr01, 100.0 * maxerr02, 100.0 * maxerr12 );
printf ("Average relative errors: averr(0-1) = %g %%, averr(0-2) = %g %% averr(1-2) = %g %%\n",
100.0 * averr01, 100.0 * averr02, 100.0 * averr12 );
}
else
printf ("%d %g %g \t %g %g %g \t %g %g %g\n", pickedSite, alpha, delta, averr01, averr02, averr12, maxerr01, maxerr02, maxerr12);
if ( (averr01 > tolerance) || (averr02 > tolerance) || (averr12 > tolerance)
|| (maxerr01 > tolerance) ||(maxerr02 > tolerance) || (maxerr12 > tolerance) )
{
XLALPrintError ("Maximal error-tolerance of %g %% was exceeded!\n", 100.0 * tolerance );
if (!ignoreErrors)
return 1;
}
if ( lalDebugLevel )
printf("%d checks left\n", numChecks);
/* ---- Clean up things that were created in this loop ---- */
XLALDestroyDetectorStateSeries ( detStates );
detStates = NULL;
LALFree ( det );
LALFree ( amParams.das->pSource );
LALFree ( amParams.das );
}
/* ----- free memory ----- */
XLALDestroyTimestampVector ( timestamps );
XLALDestroyREAL4Vector ( AMold.a );
XLALDestroyREAL4Vector ( AMold.b );
XLALDestroyREAL4Vector ( AMnew1.a );
XLALDestroyREAL4Vector ( AMnew1.b );
XLALDestroyREAL4Vector ( AMnew2.a );
XLALDestroyREAL4Vector ( AMnew2.b );
LALFree(edat.ephemE);
LALFree(edat.ephemS);
LALCheckMemoryLeaks();
return 0; /* OK */
} /* main() */
int main( int argc, char *argv[] ) {
static LALStatus status; /* Status structure */
PtoleMetricIn in; /* PtoleMetric() input structure */
REAL8 mismatch; /* mismatch threshold of mesh */
REAL8Vector *metric; /* Parameter-space metric */
int j, k; /* Parameter-space indices */
int opt; /* Command-line option. */
BOOLEAN grace; /* Whether or not we use xmgrace */
BOOLEAN nongrace; /* Whether or not to output data to file*/
int ra, dec, i; /* Loop variables for xmgrace option */
FILE *pvc = NULL; /* Temporary file for xmgrace option */
FILE *fnongrace = NULL;/* File contaning ellipse coordinates */
int metric_code; /* Which metric code to use: */
/* 1 = Ptolemetric */
/* 2 = CoherentMetric + DTBarycenter */
/* 3 = CoherentMetric + DTEphemeris */
REAL8Vector *tevlambda; /* (f, a, d, ...) for CoherentMetric */
MetricParamStruc tevparam; /* Input structure for CoherentMetric */
PulsarTimesParamStruc tevpulse; /* Input structure for CoherentMetric */
/* (this is a member of tevparam) */
EphemerisData *eph; /* To store ephemeris data */
int detector; /* Which detector to use: */
/* 1 = Hanford, 2 = Livingston, */
/* 3 = Virgo, 4 = GEO, 5 = TAMA */
REAL8 ra_point; /* RA at which metric is evaluated */
REAL8 dec_point; /* dec at which metric is evaluated */
float a,b,c,d,e,f; /* To input point in standard format */
int ra_min, ra_max; /* Min and max RA for ellipse plot */
int dec_min, dec_max; /* Min and max dec for ellipse plot */
float c_ellipse; /* Centers of ellipses */
float r_ellipse; /* Radii of ellipses */
REAL8 determinant; /* Determinant of projected metric */
REAL4 f0; /* carrier frequency */
UINT2 numSpindown; /* Number of spindowns */
char earth[] = TEST_DATA_DIR "earth00-19-DE405.dat.gz";
char sun[] = TEST_DATA_DIR "sun00-19-DE405.dat.gz";
/* Defaults that can be overwritten: */
metric_code = 1;
in.epoch.gpsSeconds = tevpulse.epoch.gpsSeconds = 731265908;
in.epoch.gpsNanoSeconds = tevpulse.epoch.gpsNanoSeconds = 0.0;
mismatch = 0.02;
nongrace = 0;
in.duration = tevparam.deltaT = DEFAULT_DURATION;
grace = 0;
detector = 4;
ra_point = (24.1/60)*LAL_PI_180; /* 47 Tuc */
dec_point = -(72+5./60)*LAL_PI_180;
ra_min = 0;
ra_max = 90;
dec_min = 0;
dec_max = 85;
f0 = 1000;
numSpindown = 0;
/* Parse options. */
while ((opt = LALgetopt( argc, argv, "a:b:c:d:ef:l:m:n:pt:s:x" )) != -1) {
switch (opt) {
case 'a':
metric_code = atoi( LALoptarg );
break;
case 'b':
in.epoch.gpsSeconds = tevpulse.epoch.gpsSeconds = atoi( LALoptarg );
break;
case 'c':
if( sscanf( LALoptarg, "%f:%f:%f:%f:%f:%f", &a, &b, &c, &d, &e, &f ) != 6)
{
fprintf( stderr, "coordinates should be hh:mm:ss:dd:mm:ss\n" );
}
ra_point = (15*a+b/4+c/240)*LAL_PI_180;
dec_point = (d+e/60+f/3600)*LAL_PI_180;
break;
case 'd':
detector = atoi( LALoptarg );
break;
case 'e':
break;
case 'f':
f0 = atof( LALoptarg );
break;
case 'l':
if( sscanf( LALoptarg, "%d:%d:%d:%d",
&ra_min, &ra_max, &dec_min, &dec_max) != 4)
{
fprintf( stderr, "coordinates should be ra_min, ra_max, dec_min, dec_max all in degrees" );
}
break;
case 'm':
mismatch = atof( LALoptarg );
break;
case 'n':
numSpindown = atoi( LALoptarg );
break;
case 'p':
nongrace = 1;
break;
case 's':
break;
case 't':
in.duration = tevparam.deltaT = atof( LALoptarg );
break;
case 'x':
grace = 1;
break;
}
}
/* Allocate storage. */
metric = NULL;
LALDCreateVector( &status, &metric, (3+numSpindown)*(4+numSpindown)/2 );
if( status.statusCode )
{
printf( "%s line %d: %s\n", __FILE__, __LINE__,
GENERALMETRICTESTC_MSGEMEM );
return GENERALMETRICTESTC_EMEM;
}
tevlambda = NULL;
LALDCreateVector( &status, &tevlambda, 3+numSpindown );
if( status.statusCode )
{
printf( "%s line %d: %s\n", __FILE__, __LINE__,
GENERALMETRICTESTC_MSGEMEM );
return GENERALMETRICTESTC_EMEM;
}
/* Position in parameter space (sky, frequency, spindowns) */
in.position.system = COORDINATESYSTEM_EQUATORIAL;
in.position.longitude = tevlambda->data[1] = ra_point;
in.position.latitude = tevlambda->data[2] = dec_point;
in.maxFreq = tevlambda->data[0] = f0;
in.spindown = NULL;
if( numSpindown > 0 ) {
LALCreateVector( &status, &(in.spindown), numSpindown );
if( status.statusCode ) {
printf( "%s line %d: %s\n", __FILE__, __LINE__,
GENERALMETRICTESTC_MSGEMEM );
return GENERALMETRICTESTC_EMEM;
}
for( i=0; i<numSpindown; i++ ) {
in.spindown->data[i] = 0;
tevlambda->data[i+3] = 0;
}
}
/* Detector site */
if(detector==1)
tevpulse.site = &lalCachedDetectors[LALDetectorIndexLHODIFF];
if(detector==2)
tevpulse.site = &lalCachedDetectors[LALDetectorIndexLLODIFF];
if(detector==3)
tevpulse.site = &lalCachedDetectors[LALDetectorIndexVIRGODIFF];
if(detector==4)
tevpulse.site = &lalCachedDetectors[LALDetectorIndexGEO600DIFF];
if(detector==5)
tevpulse.site = &lalCachedDetectors[LALDetectorIndexTAMA300DIFF];
in.site = tevpulse.site;
tevpulse.latitude = in.site->frDetector.vertexLatitudeRadians;
tevpulse.longitude = in.site->frDetector.vertexLongitudeRadians;
/* CoherentMetric constants */
tevparam.constants = &tevpulse;
tevparam.n = 1;
tevparam.errors = 0;
tevparam.start = 0; /* start time relative to epoch */
tevpulse.t0 = 0.0; /* spindown definition time relative to epoch */
/* Fill in the fields tevpulse.tMidnight & tevpulse.tAutumn: */
LALGetEarthTimes( &status, &tevpulse );
if( status.statusCode )
{
printf( "%s line %d: %s\n", __FILE__, __LINE__,
GENERALMETRICTESTC_MSGESUB );
return GENERALMETRICTESTC_ESUB;
}
/* Read in ephemeris data from files: */
eph = (EphemerisData *)LALMalloc(sizeof(EphemerisData));
eph->ephiles.earthEphemeris = earth;
eph->ephiles.sunEphemeris = sun;
LALInitBarycenter( &status, eph );
if( status.statusCode )
{
printf( "%s line %d: %s\n", __FILE__, __LINE__,
GENERALMETRICTESTC_MSGESUB );
return GENERALMETRICTESTC_ESUB;
}
tevpulse.ephemeris = eph;
/* Choose CoherentMetric timing function */
if( metric_code == 2 ) {
tevpulse.t1 = LALTBaryPtolemaic;
tevpulse.dt1 = LALDTBaryPtolemaic;
}
if( metric_code == 3 ) {
tevpulse.t1 = LALTEphemeris;
tevpulse.dt1 = LALDTEphemeris;
}
tevpulse.t2 = LALTSpin;
tevpulse.dt2 = LALDTSpin;
tevpulse.constants1 = &tevpulse;
tevpulse.constants2 = &tevpulse;
tevpulse.nArgs = 2;
if( numSpindown > 0 ) {
tevparam.dtCanon = LALDTComp;
}
else {
if( metric_code == 2 )
tevparam.dtCanon = LALDTBaryPtolemaic;
if( metric_code == 3 )
tevparam.dtCanon = LALDTEphemeris;
}
/* Evaluate metric components. */
if(metric_code==1)
{
LALPtoleMetric( &status, metric, &in );
if( status.statusCode )
{
printf( "%s line %d: %s\n", __FILE__, __LINE__,
GENERALMETRICTESTC_MSGESUB );
return GENERALMETRICTESTC_ESUB;
}
}
if(metric_code==2 || metric_code==3)
{
LALCoherentMetric( &status, metric, tevlambda, &tevparam );
if( status.statusCode )
{
printf( "%s line %d: %s\n", __FILE__, __LINE__,
GENERALMETRICTESTC_MSGESUB );
return GENERALMETRICTESTC_ESUB;
}
}
/* Print metric. */
printf("\nmetric (f0, alpha, delta, ...) at the requested point\n");
for (j=0; j<=2+numSpindown; j++) {
for (k=0; k<=j; k++)
printf( " %+.4e", metric->data[k+j*(j+1)/2] );
printf("\n");
}
/* Print determinants. */
determinant = metric->data[5]*metric->data[2] - pow(metric->data[4],2);
printf( "\nSky-determinant %e\n", determinant );
if( numSpindown == 1 ) {
determinant = metric->data[2] * metric->data[5] * metric->data[9]
- metric->data[2] * metric->data[8] * metric->data[8]
+ metric->data[4] * metric->data[8] * metric->data[7]
- metric->data[4] * metric->data[4] * metric->data[9]
+ metric->data[7] * metric->data[4] * metric->data[8]
- metric->data[7] * metric->data[7] * metric->data[5];
printf( "S&S determinant %e\n", determinant );
}
/* Project carrier frequency out of metric. */
LALProjectMetric( &status, metric, 0 );
if( status.statusCode )
{
printf( "%s line %d: %s\n", __FILE__, __LINE__,
GENERALMETRICTESTC_MSGESUB );
return GENERALMETRICTESTC_ESUB;
}
/* Print projected metric. */
printf("\nf-projected metric (alpha, delta, ...) at the requested point\n");
for (j=1; j<=2+numSpindown; j++) {
for (k=1; k<=j; k++)
printf( " %+.4e", metric->data[k+j*(j+1)/2] );
printf( "\n" );
}
/* Print determinants. */
determinant = metric->data[5]*metric->data[2] - pow(metric->data[4],2);
printf( "\nSky-determinant %e\n", determinant );
if( numSpindown == 1 ) {
determinant = metric->data[2] * metric->data[5] * metric->data[9]
- metric->data[2] * metric->data[8] * metric->data[8]
+ metric->data[4] * metric->data[8] * metric->data[7]
- metric->data[4] * metric->data[4] * metric->data[9]
+ metric->data[7] * metric->data[4] * metric->data[8]
- metric->data[7] * metric->data[7] * metric->data[5];
printf( "S&S determinant %e\n", determinant );
}
/* Here is the code that uses xmgrace with the -x option, */
/* and outputs data to a file with the -t option. */
if (grace || nongrace) {
/* Take care of preliminaries. */
if(grace)
{
pvc = popen( "xmgrace -pipe", "w" );
if( !pvc )
{
printf( "%s line %d: %s\n", __FILE__, __LINE__,
GENERALMETRICTESTC_MSGESYS );
return GENERALMETRICTESTC_ESYS;
}
fprintf( pvc, "@xaxis label \"Right ascension (degrees)\"\n" );
fprintf( pvc, "@yaxis label \"Declination (degrees)\"\n" );
}
if(nongrace)
{
fnongrace = fopen( "nongrace.data", "w" );
if( !fnongrace )
{
printf( "%s line %d: %s\n", __FILE__, __LINE__,
GENERALMETRICTESTC_MSGESYS );
return GENERALMETRICTESTC_ESYS;
}
}
/* Step around the sky: a grid in ra and dec. */
j = 0;
for (dec=dec_max; dec>=dec_min; dec-=10) {
for (ra=ra_min; ra<=ra_max; ra+=15) {
REAL8 gaa, gad, gdd, angle, smaj, smin;
/* Get the metric at this ra, dec. */
in.position.longitude = tevlambda->data[1] = ra*LAL_PI_180;
in.position.latitude = tevlambda->data[2] = dec*LAL_PI_180;
/* Evaluate metric: */
if(metric_code==1)
{
LALPtoleMetric( &status, metric, &in );
if( status.statusCode )
{
printf( "%s line %d: %s\n", __FILE__, __LINE__,
GENERALMETRICTESTC_MSGESUB );
return GENERALMETRICTESTC_ESUB;
}
}
if(metric_code==2 || metric_code==3)
{
LALCoherentMetric( &status, metric, tevlambda, &tevparam );
if( status.statusCode )
{
printf( "%s line %d: %s\n", __FILE__, __LINE__,
GENERALMETRICTESTC_MSGESUB );
return GENERALMETRICTESTC_ESUB;
}
}
/* Project metric: */
LALProjectMetric( &status, metric, 0 );
if( status.statusCode )
{
printf( "%s line %d: %s\n", __FILE__, __LINE__,
GENERALMETRICTESTC_MSGESUB );
return GENERALMETRICTESTC_ESUB;
}
determinant = metric->data[5]*metric->data[2]-pow(metric->data[4],2.0);
if(determinant < 0.0)
{
printf( "%s line %d: %s\n", __FILE__, __LINE__,
GENERALMETRICTESTC_MSGEMET );
return GENERALMETRICTESTC_EMET;
}
/* Rename \gamma_{\alpha\alpha}. */
gaa = metric->data[2];
/* Rename \gamma_{\alpha\delta}. */
gad = metric->data[4];
/* Rename \gamma_{\delta\delta}. */
gdd = metric->data[5];
/* Semiminor axis from larger eigenvalue of metric. */
smin = gaa+gdd + sqrt( pow(gaa-gdd,2) + pow(2*gad,2) );
smin = sqrt(2*mismatch/smin);
/* Semiminor axis from smaller eigenvalue of metric. */
smaj = gaa+gdd - sqrt( pow(gaa-gdd,2) + pow(2*gad,2) );
/*printf("ra = %d, dec = %d, temp = %g\n", ra, dec, smaj);*/
smaj = sqrt(2*mismatch/smaj);
/* Angle of semimajor axis with "horizontal" (equator). */
angle = atan2( gad, mismatch/smaj/smaj-gdd );
if (angle <= -LAL_PI_2) angle += LAL_PI;
if (angle > LAL_PI_2) angle -= LAL_PI;
if(grace)
{
/* Print set header. */
fprintf( pvc, "@s%d color (0,0,0)\n", j );
fprintf( pvc, "@target G0.S%d\n@type xy\n", j++ );
/* Print center of patch. */
fprintf( pvc, "%16.8g %16.8g\n", (float)ra, (float)dec );
}
if(nongrace)
/* Print center of patch. */
fprintf( fnongrace, "%16.8g %16.8g\n", (float)ra, (float)dec );
/* Loop around patch ellipse. */
for (i=0; i<=SPOKES; i++) {
c_ellipse = LAL_TWOPI*i/SPOKES;
r_ellipse = MAGNIFY*LAL_180_PI*smaj*smin /
sqrt( pow(smaj*sin(c_ellipse),2) + pow(smin*cos(c_ellipse),2) );
if(grace)
fprintf( pvc, "%e %e\n", ra+r_ellipse*cos(angle-c_ellipse),
dec+r_ellipse*sin(angle-c_ellipse) );
if(nongrace)
fprintf( fnongrace, "%e %e\n", ra+r_ellipse*cos(angle-c_ellipse),
dec+r_ellipse*sin(angle-c_ellipse) );
} /* for (a...) */
} /* for (ra...) */
} /* for (dec...) */
if(grace)
fclose( pvc );
if(nongrace)
fclose( fnongrace );
} /* if (grace || nongrace) */
printf("\nCleaning up and leaving...\n");
LALFree( eph->ephemE );
if( status.statusCode )
{
printf( "%s line %d: %s\n", __FILE__, __LINE__,
GENERALMETRICTESTC_MSGEMEM );
return GENERALMETRICTESTC_EMEM;
}
LALFree( eph->ephemS );
if( status.statusCode )
{
printf( "%s line %d: %s\n", __FILE__, __LINE__,
GENERALMETRICTESTC_MSGEMEM );
return GENERALMETRICTESTC_EMEM;
}
LALFree( eph );
if( status.statusCode )
{
printf( "%s line %d: %s\n", __FILE__, __LINE__,
GENERALMETRICTESTC_MSGEMEM );
return GENERALMETRICTESTC_EMEM;
}
LALDDestroyVector( &status, &metric );
if( status.statusCode )
{
printf( "%s line %d: %s\n", __FILE__, __LINE__,
GENERALMETRICTESTC_MSGEMEM );
return GENERALMETRICTESTC_EMEM;
}
LALDDestroyVector( &status, &tevlambda );
if( status.statusCode )
{
printf( "%s line %d: %s\n", __FILE__, __LINE__,
GENERALMETRICTESTC_MSGEMEM );
return GENERALMETRICTESTC_EMEM;
}
if( in.spindown )
LALDestroyVector( &status, &(in.spindown) );
if( status.statusCode )
{
printf( "%s line %d: %s\n", __FILE__, __LINE__,
GENERALMETRICTESTC_MSGEMEM );
return GENERALMETRICTESTC_EMEM;
}
LALCheckMemoryLeaks();
return 0;
} /* main() */
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;
BOOLEAN uvar_help;
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_help = FALSE;
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 */
LAL_CALL( LALRegisterBOOLUserVar( &status, "help", 'h', UVAR_HELP, "Print this message", &uvar_help), &status);
LAL_CALL( LALRegisterSTRINGUserVar( &status, "ifo", 'i', UVAR_OPTIONAL, "Detector GEO(1) LLO(2) LHO(3)", &uvar_ifo ), &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_OPTIONAL, "SFT Directory", &uvar_sftDir), &status);
LAL_CALL( LALRegisterSTRINGUserVar( &status, "fnameIn", 'T', UVAR_OPTIONAL, "Input template file", &uvar_fnameIn), &status);
LAL_CALL( LALRegisterSTRINGUserVar( &status, "fnameOut", 'o', UVAR_OPTIONAL, "Output filename", &uvar_fnameOut), &status);
LAL_CALL( LALRegisterINTUserVar( &status, "blocksRngMed", 'w', UVAR_OPTIONAL, "RngMed block size", &uvar_blocksRngMed), &status);
LAL_CALL( LALRegisterREALUserVar( &status, "peakThreshold", 't', UVAR_OPTIONAL, "Peak selection threshold", &uvar_peakThreshold), &status);
/* read all command line variables */
LAL_CALL( LALUserVarReadAllInput(&status, argc, argv), &status);
/* exit if help was required */
if (uvar_help)
exit(0);
/* 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 */
LAL_CALL( LALUserVarGetLog(&status, &logstr, UVAR_LOGFMT_CFGFILE), &status);
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 ( LALUserVarWasSet( &uvar_ifo ) )
constraints.detector = XLALGetChannelPrefix ( uvar_ifo );
/* get sft catalog */
tempDir = (CHAR *)LALCalloc(512, sizeof(CHAR));
strcpy(tempDir, uvar_sftDir);
strcat(tempDir, "/*SFT*.*");
LAL_CALL( LALSFTdataFind( &status, &catalog, tempDir, &constraints), &status);
detector = XLALGetSiteInfo( catalog->data[0].header.name);
mObsCoh = catalog->length;
timeBase = 1.0 / catalog->data->header.deltaF;
LAL_CALL( LALLoadSFTs ( &status, &inputSFTs, catalog, f_min, f_max), &status);
LAL_CALL( LALNormalizeSFTVect (&status, inputSFTs, uvar_blocksRngMed), &status);
if ( LALUserVarWasSet( &uvar_ifo ) )
LALFree( constraints.detector );
LALFree( tempDir);
LAL_CALL( LALDestroySFTCatalog( &status, &catalog ), &status);
}
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 */
LAL_CALL(LALDestroySFTVector(&status, &inputSFTs),&status );
/* ****************************************************************/
/* 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;
}
}
/******************************************************************/
/* setting of ephemeris info */
/******************************************************************/
edat = (EphemerisData *)LALMalloc(sizeof(EphemerisData));
(*edat).ephiles.earthEphemeris = uvar_earthEphemeris;
(*edat).ephiles.sunEphemeris = uvar_sunEphemeris;
/******************************************************************/
/* 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 */
LAL_CALL( LALInitBarycenter( &status, edat), &status);
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 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);
LALFree(edat->ephemE);
LALFree(edat->ephemS);
LALFree(edat);
LAL_CALL (LALDestroyUserVars(&status), &status);
LALCheckMemoryLeaks();
return DRIVEHOUGHCOLOR_ENORM;
}
/**
* Very simple test: pick random skyposition, compute a_i, b_i using
* once LALComputeAM() and once LALGetAMCoeffs(), and look at the errors
* sum_i (a_i - a_i')^2
*/
int main(int argc, char *argv[])
{
LALStatus XLAL_INIT_DECL(status);
LIGOTimeGPS startTime = {714180733, 0};
REAL8 duration = 180000; /* 50 hours */
REAL8 Tsft = 1800; /* assume 30min SFTs */
LIGOTimeGPSVector *timestamps = NULL;
DetectorStateSeries *detStates = NULL;
SkyPosition XLAL_INIT_DECL(skypos);
EphemerisData XLAL_INIT_DECL(edat);
BarycenterInput XLAL_INIT_DECL(baryinput);
LALDetector *det = NULL;
AMCoeffs XLAL_INIT_DECL(AMold);
AMCoeffs XLAL_INIT_DECL(AMnew);
REAL8 alpha, delta;
AMCoeffsParams XLAL_INIT_DECL(amParams);
EarthState earth;
UINT4 i;
REAL8 maxerr_a, maxerr_b, averr_a, averr_b;
REAL8 tolerance = 1e-2; /* be generous: allow 1% error */
struct tms buf;
const CHAR *sites[] = {"H1", "L1", "V2", "G1", "T1" };
UINT4 pickedSite;
char earthEphem[] = TEST_DATA_DIR "earth00-19-DE405.dat.gz";
char sunEphem[] = TEST_DATA_DIR "sun00-19-DE405.dat.gz";
if ( argc == 2 && !strcmp(argv[1], "-v1") )
/* init random-generator */
srand ( times(&buf) );
/* ----- init ephemeris ----- */
edat.ephiles.earthEphemeris = earthEphem;
edat.ephiles.sunEphemeris = sunEphem;
SUB ( LALInitBarycenter(&status, &edat), &status);
/* ----- get timestamps ----- */
SUB ( LALMakeTimestamps ( &status, ×tamps, startTime, duration, Tsft ), &status );
/* ----- allocate memory for AM-coeffs ----- */
AMold.a = XLALCreateREAL4Vector ( timestamps->length );
AMold.b = XLALCreateREAL4Vector ( timestamps->length );
AMnew.a = XLALCreateREAL4Vector ( timestamps->length );
AMnew.b = XLALCreateREAL4Vector ( timestamps->length );
/* ----- pick detector-site at random ----- */
pickedSite = floor( 5 * (1.0 * rand() / (RAND_MAX + 1.0) ) ); /* int in [0,5) */
if ( ( det = XLALGetSiteInfo ( sites[pickedSite] )) == NULL )
{
XLALPrintError ("\nCall to XLALGetSiteInfo() has failed for site = '%s'... \n\n",
sites[pickedSite]);
return GETAMCOEFFSTEST_ESUB;
}
/* ----- pick skyposition at random ----- */
alpha = LAL_TWOPI * (1.0 * rand() / ( RAND_MAX + 1.0 ) ); /* uniform in [0, 2pi) */
delta = LAL_PI_2 - acos ( 1 - 2.0 * rand()/RAND_MAX ); /* sin(delta) uniform in [-1,1] */
/* ===== compute AM-coeffs the 'old way': ===== */
baryinput.site.location[0] = det->location[0]/LAL_C_SI;
baryinput.site.location[1] = det->location[1]/LAL_C_SI;
baryinput.site.location[2] = det->location[2]/LAL_C_SI;
baryinput.alpha = alpha;
baryinput.delta = delta;
baryinput.dInv = 0.e0;
/* amParams structure to compute a(t) and b(t) */
amParams.das = (LALDetAndSource *)LALMalloc(sizeof(LALDetAndSource));
amParams.das->pSource = (LALSource *)LALMalloc(sizeof(LALSource));
amParams.baryinput = &baryinput;
amParams.earth = &earth;
amParams.edat = &edat;
amParams.das->pDetector = det;
amParams.das->pSource->equatorialCoords.longitude = alpha;
amParams.das->pSource->equatorialCoords.latitude = delta;
amParams.das->pSource->orientation = 0.0;
amParams.das->pSource->equatorialCoords.system = COORDINATESYSTEM_EQUATORIAL;
amParams.polAngle = 0;
SUB (LALComputeAM ( &status, &AMold, timestamps->data, &amParams), &status);
/* ===== compute AM-coeffs the 'new way' using LALGetAMCoeffs() */
/* ----- get detector-state series ----- */
SUB ( LALGetDetectorStates (&status, &detStates, timestamps, det, &edat, 0 ), &status );
skypos.system = COORDINATESYSTEM_EQUATORIAL;
skypos.longitude = alpha;
skypos.latitude = delta;
SUB ( LALGetAMCoeffs ( &status, &AMnew, detStates, skypos ), &status );
/* ===== analyse relative error ===== */
maxerr_a = maxerr_b = averr_a = averr_b = 0;
for ( i=0; i < timestamps->length; i ++ )
{
REAL8 thisErr;
thisErr = sqrt( SQ ( AMold.a->data[i] - AMnew.a->data[i] ) / AMold.A );
averr_a += thisErr;
maxerr_a = MYMAX( thisErr, maxerr_a );
thisErr = sqrt( SQ ( AMold.b->data[i] - AMnew.b->data[i] ) / AMold.B );
averr_b += thisErr;
maxerr_b = MYMAX( thisErr, maxerr_b );
}
averr_a /= timestamps->length;
averr_b /= timestamps->length;
if ( lalDebugLevel )
{
printf ("Parameters: IFO = %s, skypos = [%g, %g]\n", sites[pickedSite], alpha, delta );
printf ("Maximal relative errors: maxerr(a) = %g %%, maxerr(b) = %g %% \n",
100.0 * maxerr_a, 100.0 * maxerr_b);
printf ("Average relative errors: averr(a) = %g %%, averr(b) = %g %% \n",
100.0 * averr_a, 100.0 * averr_b );
}
else
printf ("%d %g %g %g %g %g %g \n", pickedSite, alpha, delta, averr_a, averr_b, maxerr_a, maxerr_b);
if ( (averr_a > tolerance) || (averr_b > tolerance) || (maxerr_a > tolerance) ||(maxerr_b > tolerance))
{
XLALPrintError ("Maximal error-tolerance of %g %% was exceeded!\n", 100.0 * tolerance );
return 1;
}
/* ----- free memory ----- */
XLALDestroyTimestampVector ( timestamps );
XLALDestroyREAL4Vector ( AMold.a );
XLALDestroyREAL4Vector ( AMold.b );
XLALDestroyREAL4Vector ( AMnew.a );
XLALDestroyREAL4Vector ( AMnew.b );
LALFree ( det );
XLALDestroyDetectorStateSeries ( detStates );
LALFree ( amParams.das->pSource );
LALFree ( amParams.das );
LALFree(edat.ephemE);
LALFree(edat.ephemS);
LALCheckMemoryLeaks();
return 0; /* OK */
} /* main() */
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[]){
/* LALStatus pointer */
static LALStatus status;
/* time and velocity */
static LIGOTimeGPSVector timeV;
REAL8 timeBase;
LALDetector *det;
DetectorStateSeries *detStates=NULL;
/* ephemeris */
EphemerisData *edat=NULL;
/* user input variables */
BOOLEAN uvar_help;
CHAR *uvar_earthEphemeris=NULL;
CHAR *uvar_sunEphemeris=NULL;
CHAR *uvar_sftDir=NULL;
/* Set up the default parameters */
/* LAL error-handler */
lal_errhandler = LAL_ERR_EXIT;
uvar_help = FALSE;
uvar_earthEphemeris = (CHAR *)LALCalloc( 512 , sizeof(CHAR));
strcpy(uvar_earthEphemeris,EARTHEPHEMERIS);
uvar_sunEphemeris = (CHAR *)LALCalloc( 512 , sizeof(CHAR));
strcpy(uvar_sunEphemeris,SUNEPHEMERIS);
/* register user input variables */
LAL_CALL( LALRegisterBOOLUserVar( &status, "help", 'h', UVAR_HELP, "Print this message", &uvar_help), &status);
LAL_CALL( LALRegisterSTRINGUserVar( &status, "earthEphemeris", 'E', UVAR_REQUIRED, "Earth Ephemeris file", &uvar_earthEphemeris), &status);
LAL_CALL( LALRegisterSTRINGUserVar( &status, "sunEphemeris", 'S', UVAR_REQUIRED, "Sun Ephemeris file", &uvar_sunEphemeris), &status);
LAL_CALL( LALRegisterSTRINGUserVar( &status, "sftDir", 'D', UVAR_REQUIRED, "SFT filename pattern", &uvar_sftDir), &status);
/* read all command line variables */
LAL_CALL( LALUserVarReadAllInput(&status, argc, argv), &status);
/* exit if help was required */
if (uvar_help)
exit(0);
/* get ephemeris */
edat = (EphemerisData *)LALCalloc(1, sizeof(EphemerisData));
(*edat).ephiles.earthEphemeris = uvar_earthEphemeris;
(*edat).ephiles.sunEphemeris = uvar_sunEphemeris;
LAL_CALL( LALInitBarycenter( &status, edat), &status);
/* read sft Files and set up weights and nstar vector */
{
/* new SFT I/O data types */
SFTCatalog *catalog = NULL;
static SFTConstraints constraints;
UINT4 k;
/* set detector constraint */
constraints.detector = NULL;
/* 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);
}
for (k = 0; k < catalog->length; k++) {
det = XLALGetSiteInfo ( catalog->data[k].header.name);
timeBase = 1./catalog->data[k].header.deltaF;
timeV.length = 1;
timeV.deltaT = timeBase;
timeV.data = &(catalog->data[k].header.epoch);
LAL_CALL( LALGetDetectorStates ( &status, &detStates, &timeV, det, edat, 0.5*timeBase), &status);
fprintf(stdout, "%g %g %g\n", detStates->data[0].vDetector[0], detStates->data[0].vDetector[1],
detStates->data[0].vDetector[2]);
LALDestroyDetectorStateSeries (&status, &detStates );
LALFree (det);
} /* end loop over sfts */
LAL_CALL( LALDestroySFTCatalog( &status, &catalog ), &status);
} /* end of sft reading block */
LALFree(edat->ephemE);
LALFree(edat->ephemS);
LALFree(edat);
LAL_CALL (LALDestroyUserVars(&status), &status);
LALCheckMemoryLeaks();
if ( lalDebugLevel )
REPORTSTATUS ( &status);
return status.statusCode;
}
