int main(int argc, char *argv[]){
static LALStatus status;
static LALDetector *detector;
static LIGOTimeGPSVector timeV;
static REAL8Cart3CoorVector velV;
static REAL8Vector timeDiffV;
static REAL8 foft;
static HoughPulsarTemplate pulsarTemplate;
EphemerisData *edat = NULL;
CHAR *uvar_earthEphemeris = NULL;
CHAR *uvar_sunEphemeris = NULL;
SFTVector *inputSFTs = NULL;
REAL8 *alphaVec=NULL;
REAL8 *deltaVec=NULL;
REAL8 *freqVec=NULL;
REAL8 *spndnVec=NULL;
/* pgV is vector of peakgrams and pg1 is onepeakgram */
static UCHARPeakGram *pg1, **pgV;
UINT4 msp; /*number of spin-down parameters */
CHAR *uvar_ifo = NULL;
CHAR *uvar_sftDir = NULL; /* the directory where the SFT could be */
CHAR *uvar_fnameOut = NULL; /* The output prefix filename */
CHAR *uvar_fnameIn = NULL;
INT4 numberCount, ind;
UINT8 nTemplates;
UINT4 mObsCoh;
REAL8 uvar_peakThreshold;
REAL8 f_min, f_max, fWings, timeBase;
INT4 uvar_blocksRngMed;
UINT4 sftlength;
INT4 sftFminBin;
UINT4 loopId, tempLoopId;
FILE *fpOut = NULL;
CHAR *fnameLog=NULL;
FILE *fpLog = NULL;
CHAR *logstr=NULL;
/*REAL8 asq, bsq;*/ /* square of amplitude modulation functions a and b */
/******************************************************************/
/* Set up the default parameters. */
/* ****************************************************************/
/* LAL error-handler */
lal_errhandler = LAL_ERR_EXIT;
msp = 1; /*only one spin-down */
/* memory allocation for spindown */
pulsarTemplate.spindown.length = msp;
pulsarTemplate.spindown.data = NULL;
pulsarTemplate.spindown.data = (REAL8 *)LALMalloc(msp*sizeof(REAL8));
uvar_peakThreshold = THRESHOLD;
uvar_earthEphemeris = (CHAR *)LALMalloc(1024*sizeof(CHAR));
strcpy(uvar_earthEphemeris,EARTHEPHEMERIS);
uvar_sunEphemeris = (CHAR *)LALMalloc(1024*sizeof(CHAR));
strcpy(uvar_sunEphemeris,SUNEPHEMERIS);
uvar_sftDir = (CHAR *)LALMalloc(1024*sizeof(CHAR));
strcpy(uvar_sftDir,SFTDIRECTORY);
uvar_fnameOut = (CHAR *)LALMalloc(1024*sizeof(CHAR));
strcpy(uvar_fnameOut,VALIDATEOUT);
uvar_fnameIn = (CHAR *)LALMalloc(1024*sizeof(CHAR));
strcpy(uvar_fnameIn,VALIDATEIN);
uvar_blocksRngMed = BLOCKSRNGMED;
/* register user input variables */
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_ifo, "ifo", STRING, 'i', OPTIONAL, "Detector GEO(1) LLO(2) LHO(3)" ) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_earthEphemeris, "earthEphemeris", STRING, 'E', OPTIONAL, "Earth Ephemeris file") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_sunEphemeris, "sunEphemeris", STRING, 'S', OPTIONAL, "Sun Ephemeris file") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_sftDir, "sftDir", STRING, 'D', OPTIONAL, "SFT Directory") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_fnameIn, "fnameIn", STRING, 'T', OPTIONAL, "Input template file") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_fnameOut, "fnameOut", STRING, 'o', OPTIONAL, "Output filename") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_blocksRngMed, "blocksRngMed", INT4, 'w', OPTIONAL, "RngMed block size") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_peakThreshold, "peakThreshold", REAL8, 't', OPTIONAL, "Peak selection threshold") == XLAL_SUCCESS, XLAL_EFUNC);
/* read all command line variables */
BOOLEAN should_exit = 0;
XLAL_CHECK_MAIN( XLALUserVarReadAllInput(&should_exit, argc, argv, lalAppsVCSInfoList) == XLAL_SUCCESS, XLAL_EFUNC);
if (should_exit)
exit(1);
/* open log file for writing */
fnameLog = LALCalloc( (strlen(uvar_fnameOut) + strlen(".log") + 10),1);
strcpy(fnameLog,uvar_fnameOut);
strcat(fnameLog,".log");
if ((fpLog = fopen(fnameLog, "w")) == NULL) {
fprintf(stderr, "Unable to open file %s for writing\n", fnameLog);
LALFree(fnameLog);
exit(1);
}
/* get the log string */
XLAL_CHECK_MAIN( ( logstr = XLALUserVarGetLog(UVAR_LOGFMT_CFGFILE) ) != NULL, XLAL_EFUNC);
fprintf( fpLog, "## Log file for HoughValidate\n\n");
fprintf( fpLog, "# User Input:\n");
fprintf( fpLog, "#-------------------------------------------\n");
fprintf( fpLog, "%s", logstr);
LALFree(logstr);
/* append an ident-string defining the exact CVS-version of the code used */
{
CHAR command[1024] = "";
fprintf (fpLog, "\n\n# CVS-versions of executable:\n");
fprintf (fpLog, "# -----------------------------------------\n");
fclose (fpLog);
sprintf (command, "ident %s | sort -u >> %s", argv[0], fnameLog);
/* we don't check this. If it fails, we assume that */
/* one of the system-commands was not available, and */
/* therefore the CVS-versions will not be logged */
if ( system(command) ) fprintf (stderr, "\nsystem('%s') returned non-zero status!\n\n", command );
LALFree(fnameLog);
}
/* open output file for writing */
fpOut= fopen(uvar_fnameOut, "w");
/*setlinebuf(fpOut);*/ /* line buffered on */
setvbuf(fpOut, (char *)NULL, _IOLBF, 0);
/*****************************************************************/
/* read template file */
/*****************************************************************/
{
FILE *fpIn = NULL;
INT4 r;
REAL8 temp1, temp2, temp3, temp4, temp5;
UINT8 templateCounter;
fpIn = fopen(uvar_fnameIn, "r");
if ( !fpIn )
{
fprintf(stderr, "Unable to fine file %s\n", uvar_fnameIn);
return DRIVEHOUGHCOLOR_EFILE;
}
nTemplates = 0;
do
{
r=fscanf(fpIn,"%lf%lf%lf%lf%lf\n", &temp1, &temp2, &temp3, &temp4, &temp5);
/* make sure the line has the right number of entries or is EOF */
if (r==5) nTemplates++;
} while ( r != EOF);
rewind(fpIn);
alphaVec = (REAL8 *)LALMalloc(nTemplates*sizeof(REAL8));
deltaVec = (REAL8 *)LALMalloc(nTemplates*sizeof(REAL8));
freqVec = (REAL8 *)LALMalloc(nTemplates*sizeof(REAL8));
spndnVec = (REAL8 *)LALMalloc(nTemplates*sizeof(REAL8));
for (templateCounter = 0; templateCounter < nTemplates; templateCounter++)
{
r=fscanf(fpIn,"%lf%lf%lf%lf%lf\n", &temp1, alphaVec + templateCounter, deltaVec + templateCounter,
freqVec + templateCounter, spndnVec + templateCounter);
}
fclose(fpIn);
}
/**************************************************/
/* read sfts */
/*************************************************/
f_min = freqVec[0]; /* initial frequency to be analyzed */
/* assume that the last frequency in the templates file is also the highest frequency */
f_max = freqVec[nTemplates-1] ;
/* we need to add wings to fmin and fmax to account for
the Doppler shift, the size of the rngmed block size
and also nfsizecylinder. The block size and nfsizecylinder are
specified in terms of frequency bins...this goes as one of the arguments of
LALReadSFTfiles */
/* first correct for Doppler shift */
fWings = f_max * VTOT;
f_min -= fWings;
f_max += fWings;
/* create pattern to look for in SFT directory */
{
CHAR *tempDir = NULL;
SFTCatalog *catalog = NULL;
static SFTConstraints constraints;
/* set detector constraint */
constraints.detector = NULL;
if ( XLALUserVarWasSet( &uvar_ifo ) )
constraints.detector = XLALGetChannelPrefix ( uvar_ifo );
/* get sft catalog */
tempDir = (CHAR *)LALCalloc(512, sizeof(CHAR));
strcpy(tempDir, uvar_sftDir);
strcat(tempDir, "/*SFT*.*");
XLAL_CHECK_MAIN( ( catalog = XLALSFTdataFind( tempDir, &constraints) ) != NULL, XLAL_EFUNC);
detector = XLALGetSiteInfo( catalog->data[0].header.name);
mObsCoh = catalog->length;
timeBase = 1.0 / catalog->data->header.deltaF;
XLAL_CHECK_MAIN( ( inputSFTs = XLALLoadSFTs ( catalog, f_min, f_max) ) != NULL, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALNormalizeSFTVect( inputSFTs, uvar_blocksRngMed, 0.0 ) == XLAL_SUCCESS, XLAL_EFUNC);
if ( XLALUserVarWasSet( &uvar_ifo ) )
LALFree( constraints.detector );
LALFree( tempDir);
XLALDestroySFTCatalog(catalog );
}
sftlength = inputSFTs->data->data->length;
{
INT4 tempFbin;
sftFminBin = floor( (REAL4)(timeBase * inputSFTs->data->f0) + (REAL4)(0.5));
tempFbin = floor( timeBase * inputSFTs->data->f0 + 0.5);
if (tempFbin - sftFminBin)
{
fprintf(stderr, "Rounding error in calculating fminbin....be careful! \n");
}
}
/* loop over sfts and select peaks */
/* first the memory allocation for the peakgramvector */
pgV = NULL;
pgV = (UCHARPeakGram **)LALMalloc(mObsCoh*sizeof(UCHARPeakGram *));
/* memory for peakgrams */
for (tempLoopId=0; tempLoopId < mObsCoh; tempLoopId++)
{
pgV[tempLoopId] = (UCHARPeakGram *)LALMalloc(sizeof(UCHARPeakGram));
pgV[tempLoopId]->length = sftlength;
pgV[tempLoopId]->data = NULL;
pgV[tempLoopId]->data = (UCHAR *)LALMalloc(sftlength* sizeof(UCHAR));
LAL_CALL (SFTtoUCHARPeakGram( &status, pgV[tempLoopId], inputSFTs->data + tempLoopId, uvar_peakThreshold), &status);
}
/* having calculated the peakgrams we don't need the sfts anymore */
XLALDestroySFTVector( inputSFTs);
/* ****************************************************************/
/* setting timestamps vector */
/* ****************************************************************/
timeV.length = mObsCoh;
timeV.data = NULL;
timeV.data = (LIGOTimeGPS *)LALMalloc(mObsCoh*sizeof(LIGOTimeGPS));
{
UINT4 j;
for (j=0; j < mObsCoh; j++){
timeV.data[j].gpsSeconds = pgV[j]->epoch.gpsSeconds;
timeV.data[j].gpsNanoSeconds = pgV[j]->epoch.gpsNanoSeconds;
}
}
/******************************************************************/
/* compute the time difference relative to startTime for all SFTs */
/******************************************************************/
timeDiffV.length = mObsCoh;
timeDiffV.data = NULL;
timeDiffV.data = (REAL8 *)LALMalloc(mObsCoh*sizeof(REAL8));
{
REAL8 t0, ts, tn, midTimeBase;
UINT4 j;
midTimeBase=0.5*timeBase;
ts = timeV.data[0].gpsSeconds;
tn = timeV.data[0].gpsNanoSeconds * 1.00E-9;
t0=ts+tn;
timeDiffV.data[0] = midTimeBase;
for (j=1; j< mObsCoh; ++j){
ts = timeV.data[j].gpsSeconds;
tn = timeV.data[j].gpsNanoSeconds * 1.00E-9;
timeDiffV.data[j] = ts + tn -t0 + midTimeBase;
}
}
/******************************************************************/
/* compute detector velocity for those time stamps */
/******************************************************************/
velV.length = mObsCoh;
velV.data = NULL;
velV.data = (REAL8Cart3Coor *)LALMalloc(mObsCoh*sizeof(REAL8Cart3Coor));
{
VelocityPar velPar;
REAL8 vel[3];
UINT4 j;
velPar.detector = *detector;
velPar.tBase = timeBase;
velPar.vTol = ACCURACY;
velPar.edat = NULL;
/* read in ephemeris data */
XLAL_CHECK_MAIN( ( edat = XLALInitBarycenter( uvar_earthEphemeris, uvar_sunEphemeris ) ) != NULL, XLAL_EFUNC);
velPar.edat = edat;
/* now calculate average velocity */
for(j=0; j< velV.length; ++j){
velPar.startTime.gpsSeconds = timeV.data[j].gpsSeconds;
velPar.startTime.gpsNanoSeconds = timeV.data[j].gpsNanoSeconds;
LAL_CALL( LALAvgDetectorVel ( &status, vel, &velPar), &status );
velV.data[j].x= vel[0];
velV.data[j].y= vel[1];
velV.data[j].z= vel[2];
}
}
/* amplitude modulation stuff */
{
AMCoeffs XLAL_INIT_DECL(amc);
AMCoeffsParams *amParams;
EarthState earth;
BarycenterInput baryinput; /* Stores detector location and other barycentering data */
/* detector location */
baryinput.site.location[0] = detector->location[0]/LAL_C_SI;
baryinput.site.location[1] = detector->location[1]/LAL_C_SI;
baryinput.site.location[2] = detector->location[2]/LAL_C_SI;
baryinput.dInv = 0.e0;
/* alpha and delta must come from the skypatch */
/* for now set it to something arbitrary */
baryinput.alpha = 0.0;
baryinput.delta = 0.0;
/* Allocate space for amParams stucture */
/* Here, amParams->das is the Detector and Source info */
amParams = (AMCoeffsParams *)LALMalloc(sizeof(AMCoeffsParams));
amParams->das = (LALDetAndSource *)LALMalloc(sizeof(LALDetAndSource));
amParams->das->pSource = (LALSource *)LALMalloc(sizeof(LALSource));
/* Fill up AMCoeffsParams structure */
amParams->baryinput = &baryinput;
amParams->earth = &earth;
amParams->edat = edat;
amParams->das->pDetector = detector;
/* make sure alpha and delta are correct */
amParams->das->pSource->equatorialCoords.latitude = baryinput.delta;
amParams->das->pSource->equatorialCoords.longitude = baryinput.alpha;
amParams->das->pSource->orientation = 0.0;
amParams->das->pSource->equatorialCoords.system = COORDINATESYSTEM_EQUATORIAL;
amParams->polAngle = amParams->das->pSource->orientation ; /* These two have to be the same!!*/
/* timeV is start time ---> change to mid time */
LAL_CALL (LALComputeAM(&status, &amc, timeV.data, amParams), &status);
/* calculate a^2 and b^2 */
/* for (ii=0, asq=0.0, bsq=0.0; ii<mObsCoh; ii++) */
/* { */
/* REAL8 *a, *b; */
/* a = amc.a + ii; */
/* b = amc.b + ii; */
/* asq += (*a) * (*a); */
/* bsq += (*b) * (*b); */
/* } */
/* free amParams */
LALFree(amParams->das->pSource);
LALFree(amParams->das);
LALFree(amParams);
}
/* loop over templates */
for(loopId=0; loopId < nTemplates; ++loopId){
/* set template parameters */
pulsarTemplate.f0 = freqVec[loopId];
pulsarTemplate.longitude = alphaVec[loopId];
pulsarTemplate.latitude = deltaVec[loopId];
pulsarTemplate.spindown.data[0] = spndnVec[loopId];
{
REAL8 f0new, vcProdn, timeDiffN;
REAL8 sourceDelta, sourceAlpha, cosDelta, factorialN;
UINT4 j, i, f0newBin;
REAL8Cart3Coor sourceLocation;
sourceDelta = pulsarTemplate.latitude;
sourceAlpha = pulsarTemplate.longitude;
cosDelta = cos(sourceDelta);
sourceLocation.x = cosDelta* cos(sourceAlpha);
sourceLocation.y = cosDelta* sin(sourceAlpha);
sourceLocation.z = sin(sourceDelta);
/* loop for all different time stamps,calculate frequency and produce number count*/
/* first initialize number count */
numberCount=0;
for (j=0; j<mObsCoh; ++j)
{
/* calculate v/c.n */
vcProdn = velV.data[j].x * sourceLocation.x
+ velV.data[j].y * sourceLocation.y
+ velV.data[j].z * sourceLocation.z;
/* loop over spindown values to find f_0 */
f0new = pulsarTemplate.f0;
factorialN = 1.0;
timeDiffN = timeDiffV.data[j];
for (i=0; i<msp;++i)
{
factorialN *=(i+1.0);
f0new += pulsarTemplate.spindown.data[i]*timeDiffN / factorialN;
timeDiffN *= timeDiffN;
}
f0newBin = floor(f0new*timeBase + 0.5);
foft = f0newBin * (1.0 +vcProdn) / timeBase;
/* get the right peakgram */
pg1 = pgV[j];
/* calculate frequency bin for template */
ind = floor( foft * timeBase + 0.5 ) - sftFminBin;
/* update the number count */
numberCount+=pg1->data[ind];
}
} /* end of block calculating frequency path and number count */
/******************************************************************/
/* printing result in the output file */
/******************************************************************/
fprintf(fpOut,"%d %f %f %f %g \n",
numberCount, pulsarTemplate.longitude, pulsarTemplate.latitude, pulsarTemplate.f0,
pulsarTemplate.spindown.data[0] );
} /* end of loop over templates */
/******************************************************************/
/* Closing files */
/******************************************************************/
fclose(fpOut);
/******************************************************************/
/* Free memory and exit */
/******************************************************************/
LALFree(alphaVec);
LALFree(deltaVec);
LALFree(freqVec);
LALFree(spndnVec);
for (tempLoopId = 0; tempLoopId < mObsCoh; tempLoopId++){
pg1 = pgV[tempLoopId];
LALFree(pg1->data);
LALFree(pg1);
}
LALFree(pgV);
LALFree(timeV.data);
LALFree(timeDiffV.data);
LALFree(velV.data);
LALFree(pulsarTemplate.spindown.data);
XLALDestroyEphemerisData(edat);
XLALDestroyUserVars();
LALCheckMemoryLeaks();
return DRIVEHOUGHCOLOR_ENORM;
}
/**
* 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() */
/**
* 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 status = blank_status;
ConfigVariables XLAL_INIT_DECL(config);
UserVariables_t XLAL_INIT_DECL(uvar);
/* register user-variables */
XLAL_CHECK ( XLALInitUserVars ( &uvar ) == XLAL_SUCCESS, XLAL_EFUNC );
/* read cmdline & cfgfile */
BOOLEAN should_exit = 0;
XLAL_CHECK( XLALUserVarReadAllInput( &should_exit, argc, argv ) == XLAL_SUCCESS, XLAL_EFUNC );
if ( should_exit ) {
exit(1);
}
if ( uvar.version )
{
XLALOutputVersionString ( stdout, lalDebugLevel );
exit(0);
}
/* basic setup and initializations */
XLAL_CHECK ( XLALInitCode( &config, &uvar, argv[0] ) == XLAL_SUCCESS, XLAL_EFUNC );
/* ----- allocate memory for AM-coeffs ----- */
AMCoeffs AMold, AMnew1, AMnew2; /**< containers holding AM-coefs computed by 3 different AM functions */
AMold.a = XLALCreateREAL4Vector ( 1 );
AMold.b = XLALCreateREAL4Vector ( 1 );
AMnew1.a = XLALCreateREAL4Vector ( 1 );
AMnew1.b = XLALCreateREAL4Vector ( 1 );
AMnew2.a = XLALCreateREAL4Vector ( 1 );
AMnew2.b = XLALCreateREAL4Vector ( 1 );
XLAL_CHECK ( AMold.a && AMold.b && AMnew1.a && AMnew1.b && AMnew2.a && AMnew2.a, XLAL_ENOMEM, "Failed to XLALCreateREAL4Vector ( 1 )\n" );
/* ----- get detector-state series ----- */
DetectorStateSeries *detStates = NULL;
XLAL_CHECK ( (detStates = XLALGetDetectorStates ( config.timestamps, config.det, config.edat, 0 )) != NULL, XLAL_EFUNC );
/* ----- compute associated SSB timing info ----- */
SSBtimes *tSSB = XLALGetSSBtimes ( detStates, config.skypos, config.timeGPS, SSBPREC_RELATIVISTIC );
XLAL_CHECK ( tSSB != NULL, XLAL_EFUNC, "XLALGetSSBtimes() failed with xlalErrno = %d\n", xlalErrno );
/* ===== 1) compute AM-coeffs the 'old way': [used in CFSv1] ===== */
BarycenterInput XLAL_INIT_DECL(baryinput);
AMCoeffsParams XLAL_INIT_DECL(amParams);
EarthState earth;
baryinput.site.location[0] = config.det->location[0]/LAL_C_SI;
baryinput.site.location[1] = config.det->location[1]/LAL_C_SI;
baryinput.site.location[2] = config.det->location[2]/LAL_C_SI;
baryinput.alpha = config.skypos.longitude;
baryinput.delta = config.skypos.latitude;
baryinput.dInv = 0.e0;
/* amParams structure to compute a(t) and b(t) */
amParams.das = XLALMalloc(sizeof(*amParams.das));
amParams.das->pSource = XLALMalloc(sizeof(*amParams.das->pSource));
amParams.baryinput = &baryinput;
amParams.earth = &earth;
amParams.edat = config.edat;
amParams.das->pDetector = config.det;
amParams.das->pSource->equatorialCoords.longitude = config.skypos.longitude;
amParams.das->pSource->equatorialCoords.latitude = config.skypos.latitude;
amParams.das->pSource->orientation = 0.0;
amParams.das->pSource->equatorialCoords.system = COORDINATESYSTEM_EQUATORIAL;
amParams.polAngle = 0;
LAL_CALL ( LALComputeAM ( &status, &AMold, config.timestamps->data, &amParams), &status);
XLALFree ( amParams.das->pSource );
XLALFree ( amParams.das );
/* ===== 2) compute AM-coeffs the 'new way' using LALNewGetAMCoeffs() */
LALGetAMCoeffs ( &status, &AMnew1, detStates, config.skypos );
if ( status.statusCode ) {
XLALPrintError ("%s: call to LALGetAMCoeffs() failed, status = %d\n\n", __func__, status.statusCode );
XLAL_ERROR ( status.statusCode & XLAL_EFUNC );
}
/* ===== 3) compute AM-coeffs the 'newer way' using LALNewGetAMCoeffs() [used in CFSv2] */
LALNewGetAMCoeffs ( &status, &AMnew2, detStates, config.skypos );
if ( status.statusCode ) {
XLALPrintError ("%s: call to LALNewGetAMCoeffs() failed, status = %d\n\n", __func__, status.statusCode );
XLAL_ERROR ( status.statusCode & XLAL_EFUNC );
}
/* ===== 4) use standalone version of the above [used in FstatMetric_v2] */
REAL8 a0,b0;
if ( XLALComputeAntennaPatternCoeffs ( &a0, &b0, &config.skypos, &config.timeGPS, config.det, config.edat ) != XLAL_SUCCESS ) {
XLALPrintError ("%s: XLALComputeAntennaPatternCoeffs() failed.\n", __func__ );
XLAL_ERROR ( XLAL_EFUNC );
}
/* ==================== output the results ==================== */
printf ("\n");
printf ("----- Input parameters:\n");
printf ("tGPS = { %d, %d }\n", config.timeGPS.gpsSeconds, config.timeGPS.gpsNanoSeconds );
printf ("Detector = %s\n", config.det->frDetector.name );
printf ("Sky position: longitude = %g rad, latitude = %g rad [equatorial coordinates]\n", config.skypos.longitude, config.skypos.latitude );
printf ("\n");
printf ("----- Antenna pattern functions (a,b):\n");
printf ("LALComputeAM: ( %-12.8g, %-12.8g) [REAL4]\n", AMold.a->data[0], AMold.b->data[0] );
printf ("LALGetAMCoeffs: ( %-12.8g, %-12.8g) [REAL4]\n", AMnew1.a->data[0], AMnew1.b->data[0] );
printf ("LALNewGetAMCoeffs: ( %-12.8g, %-12.8g) [REAL4]\n", AMnew2.a->data[0]/config.sinzeta, AMnew2.b->data[0]/config.sinzeta );
printf ("XLALComputeAntennaPatternCoeffs: ( %-12.8g, %-12.8g) [REAL8]\n", a0/config.sinzeta, b0/config.sinzeta );
printf ("\n");
printf ("----- Detector & Earth state:\n");
REAL8 *pos = detStates->data[0].rDetector;
printf ("Detector position [ICRS J2000. Units=sec]: rDet = {%g, %g, %g}\n", pos[0], pos[1], pos[2] );
REAL8 *vel = detStates->data[0].vDetector;
printf ("Detector velocity [ICRS J2000. Units=c]: vDet = {%g, %g, %g}\n", vel[0], vel[1], vel[2] );
printf ("Local mean sideral time: LMST = %g rad\n", detStates->data[0].LMST);
printf ("\n");
printf ("----- SSB timing data:\n");
printf ("TOA difference tSSB - tDet = %g s\n", tSSB->DeltaT->data[0] );
printf ("TOA rate of change dtSSB/dtDet - 1 = %g\n", tSSB->Tdot->data[0] - 1.0 );
printf ("\n\n");
/* ----- done: free all memory */
XLAL_CHECK ( XLALDestroyConfig( &config ) == XLAL_SUCCESS, XLAL_EFUNC );
XLALDestroyDetectorStateSeries ( detStates );
XLALDestroyREAL4Vector ( AMold.a );
XLALDestroyREAL4Vector ( AMold.b );
XLALDestroyREAL4Vector ( AMnew1.a );
XLALDestroyREAL4Vector ( AMnew1.b );
XLALDestroyREAL4Vector ( AMnew2.a );
XLALDestroyREAL4Vector ( AMnew2.b );
XLALDestroyREAL8Vector ( tSSB->DeltaT );
XLALDestroyREAL8Vector ( tSSB->Tdot );
XLALFree (tSSB);
LALCheckMemoryLeaks();
return 0;
} /* main */
/**
* Handle user-input and check its validity.
* Load ephemeris and calculate AM-coefficients (stored globally)
*/
void
Initialize (LALStatus *status, struct CommandLineArgsTag *CLA)
{
EphemerisData *edat=NULL; /* Stores earth/sun ephemeris data for barycentering */
BarycenterInput baryinput; /* Stores detector location and other barycentering data */
EarthState earth;
AMCoeffsParams *amParams;
LIGOTimeGPS *midTS=NULL; /* Time stamps for amplitude modulation coefficients */
LALDetector *Detector; /* Our detector*/
INT4 k;
INITSTATUS(status);
ATTATCHSTATUSPTR (status);
if ( XLALUserVarWasSet ( &(CLA->nTsft) ) )
CLA->duration = 1.0 * CLA->nTsft * CLA->Tsft;
/* read or generate SFT timestamps */
if ( XLALUserVarWasSet(&(CLA->timestamps)) )
{
XLAL_CHECK_LAL ( status, ( timestamps = XLALReadTimestampsFile ( CLA->timestamps ) ) != NULL, XLAL_EFUNC );
if ( (CLA->nTsft > 0) && ( (UINT4)CLA->nTsft < timestamps->length ) ) /* truncate if required */
timestamps->length = CLA->nTsft;
CLA->nTsft = timestamps->length;
} /* if have_timestamps */
else
{
LIGOTimeGPS tStart;
tStart.gpsSeconds = CLA->gpsStart;
tStart.gpsNanoSeconds = 0;
XLAL_CHECK_LAL ( status, ( timestamps = XLALMakeTimestamps( tStart, CLA->duration, CLA->Tsft, 0 ) ) != NULL, XLAL_EFUNC );
CLA->nTsft = timestamps->length;
} /* no timestamps */
/*---------- initialize detector ---------- */
{
BOOLEAN have_IFO = XLALUserVarWasSet ( &CLA->IFO );
BOOLEAN have_detector = XLALUserVarWasSet ( &CLA->detector );
CHAR *IFO;
if ( !have_IFO && !have_detector ) {
fprintf (stderr, "\nNeed to specify the detector (--IFO) !\n\n");
ABORT (status, SEMIANALYTIC_EINPUT, SEMIANALYTIC_MSGEINPUT);
}
if ( have_IFO )
IFO = CLA->IFO;
else
IFO = CLA->detector;
if ( ( Detector = XLALGetSiteInfo ( IFO ) ) == NULL ) {
ABORT (status, SEMIANALYTIC_EINPUT, SEMIANALYTIC_MSGEINPUT);
}
}
/* ---------- load ephemeris-files ---------- */
{
edat = XLALInitBarycenter( CLA->ephemEarth, CLA->ephemSun );
if ( !edat ) {
XLALPrintError("XLALInitBarycenter failed: could not load Earth ephemeris '%s' and Sun ephemeris '%s'\n", CLA->ephemEarth, CLA->ephemSun);
ABORT (status, SEMIANALYTIC_EINPUT, SEMIANALYTIC_MSGEINPUT);
}
} /* ephemeris-reading */
/* ---------- calculate AM-coefficients ---------- */
/* prepare call to barycentering routing */
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.alpha = CLA->Alpha;
baryinput.delta = CLA->Delta;
baryinput.dInv = 0.e0;
/* amParams structure to compute a(t) and b(t) */
/* 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;
amParams->das->pSource->equatorialCoords.system = COORDINATESYSTEM_EQUATORIAL;
amParams->das->pSource->equatorialCoords.longitude = CLA->Alpha;
amParams->das->pSource->equatorialCoords.latitude = CLA->Delta;
amParams->das->pSource->orientation = 0.0;
amParams->polAngle = amParams->das->pSource->orientation ; /* These two have to be the same!!!!!!!!!*/
/* Allocate space for AMCoeffs */
XLAL_INIT_MEM(amc);
TRY ( LALSCreateVector(status->statusPtr, &(amc.a), (UINT4) CLA->nTsft), status);
TRY ( LALSCreateVector(status->statusPtr, &(amc.b), (UINT4) CLA->nTsft), status);
/* Mid point of each SFT */
midTS = (LIGOTimeGPS *)LALCalloc(CLA->nTsft,sizeof(LIGOTimeGPS));
for(k=0; k < CLA->nTsft; k++)
{
/* FIXME: loss of precision; consider
midTS[k] = timestamps->data[k];
XLALGPSAdd(&midTS[k], 0.5*CLA->Tsft);
*/
REAL8 teemp=0.0;
teemp = XLALGPSGetREAL8(&(timestamps->data[k]));
teemp += 0.5*CLA->Tsft;
XLALGPSSetREAL8(&(midTS[k]), teemp);
}
TRY ( LALComputeAM(status->statusPtr, &amc, midTS, amParams), status);
/* Free memory */
XLALDestroyTimestampVector ( timestamps);
LALFree(midTS);
LALFree(Detector);
XLALDestroyEphemerisData(edat);
LALFree(amParams->das->pSource);
LALFree(amParams->das);
LALFree(amParams);
DETATCHSTATUSPTR (status);
RETURN(status);
} /* ParseUserInput() */
