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 */
/**
* 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() */
/**
* Multi-IFO version of LALGetAMCoeffs().
* Get all antenna-pattern coefficients for all input detector-series.
*
* NOTE: contrary to LALGetAMCoeffs(), this functions *allocates* the output-vector,
* use XLALDestroyMultiAMCoeffs() to free this.
*/
void
LALGetMultiAMCoeffs (LALStatus *status, /**< [in/out] LAL status structure pointer */
MultiAMCoeffs **multiAMcoef, /**< [out] AM-coefficients for all input detector-state series */
const MultiDetectorStateSeries *multiDetStates, /**< [in] detector-states at timestamps t_i */
SkyPosition skypos /**< source sky-position [in equatorial coords!] */
)
{
UINT4 X, numDetectors;
MultiAMCoeffs *ret = NULL;
INITSTATUS(status);
ATTATCHSTATUSPTR (status);
/* check input */
ASSERT (multiDetStates, status,LALCOMPUTEAMH_ENULL, LALCOMPUTEAMH_MSGENULL);
ASSERT (multiDetStates->length, status,LALCOMPUTEAMH_ENULL, LALCOMPUTEAMH_MSGENULL);
ASSERT (multiAMcoef, status,LALCOMPUTEAMH_ENULL, LALCOMPUTEAMH_MSGENULL);
ASSERT ( *multiAMcoef == NULL, status,LALCOMPUTEAMH_ENONULL, LALCOMPUTEAMH_MSGENONULL);
ASSERT ( skypos.system == COORDINATESYSTEM_EQUATORIAL, status, LALCOMPUTEAMH_EINPUT, LALCOMPUTEAMH_MSGEINPUT );
numDetectors = multiDetStates->length;
if ( ( ret = LALCalloc( 1, sizeof( *ret ) )) == NULL ) {
ABORT (status, LALCOMPUTEAMH_EMEM, LALCOMPUTEAMH_MSGEMEM);
}
ret->length = numDetectors;
if ( ( ret->data = LALCalloc ( numDetectors, sizeof ( *ret->data ) )) == NULL ) {
LALFree ( ret );
ABORT (status, LALCOMPUTEAMH_EMEM, LALCOMPUTEAMH_MSGEMEM);
}
for ( X=0; X < numDetectors; X ++ )
{
AMCoeffs *amcoeX = NULL;
UINT4 numStepsX = multiDetStates->data[X]->length;
ret->data[X] = LALCalloc ( 1, sizeof ( *(ret->data[X]) ) );
amcoeX = ret->data[X];
amcoeX->a = XLALCreateREAL4Vector ( numStepsX );
if ( (amcoeX->b = XLALCreateREAL4Vector ( numStepsX )) == NULL ) {
LALPrintError ("\nOut of memory!\n\n");
goto failed;
}
/* LALGetAMCoeffs (status->statusPtr, amcoeX, multiDetStates->data[X], skypos ); */
LALNewGetAMCoeffs (status->statusPtr, amcoeX, multiDetStates->data[X], skypos );
if ( status->statusPtr->statusCode )
{
LALPrintError ( "\nCall to LALNewGetAMCoeffs() has failed ... \n\n");
goto failed;
}
} /* for X < numDetectors */
goto success;
failed:
/* free all memory allocated so far */
XLALDestroyMultiAMCoeffs ( ret );
ABORT ( status, -1, "LALGetMultiAMCoeffs() failed" );
success:
(*multiAMcoef) = ret;
DETATCHSTATUSPTR (status);
RETURN(status);
} /* LALGetMultiAMCoeffs() */