/**
* For a given OrbitalParams, calculate the time-differences
* \f$\Delta T_\alpha\equiv T(t_\alpha) - T_0\f$, and their
* derivatives \f$Tdot_\alpha \equiv d T / d t (t_\alpha)\f$.
*
* \note The return-vectors \a DeltaT and \a Tdot must be allocated already
* and have the same length as the input time-series \a DetStates.
*
*/
void
LALGetBinarytimes (LALStatus *status, /**< pointer to LALStatus structure */
SSBtimes *tBinary, /**< [out] DeltaT_alpha = T(t_alpha) - T_0; and Tdot(t_alpha) */
const SSBtimes *tSSB, /**< [in] DeltaT_alpha = T(t_alpha) - T_0; and Tdot(t_alpha) */
const DetectorStateSeries *DetectorStates, /**< [in] detector-states at timestamps t_i */
const BinaryOrbitParams *binaryparams, /**< [in] source binary orbit parameters */
LIGOTimeGPS refTime /**< SSB reference-time T_0 of pulsar-parameters */
)
{
UINT4 numSteps, i;
REAL8 refTimeREAL8;
REAL8 Porb; /* binary orbital period */
REAL8 asini; /* the projected orbital semimajor axis */
REAL8 e,ome ; /* the eccentricity, one minus eccentricity */
REAL8 sinw,cosw; /* the sin and cos of the argument of periapsis */
REAL8 tSSB_now; /* the SSB time at the midpoint of each SFT in REAL8 form */
REAL8 fracorb; /* the fraction of orbits completed since current SSB time */
REAL8 E; /* the eccentric anomoly */
DFindRootIn input; /* the input structure for the root finding procedure */
REAL8 acc; /* the accuracy in radians of the eccentric anomoly computation */
INITSTATUS(status);
ATTATCHSTATUSPTR (status);
ASSERT (DetectorStates, status, COMPUTEFSTATC_ENULL, COMPUTEFSTATC_MSGENULL);
numSteps = DetectorStates->length; /* number of timestamps */
ASSERT (tSSB, status,COMPUTEFSTATC_ENULL, COMPUTEFSTATC_MSGENULL);
ASSERT (tSSB->DeltaT, status,COMPUTEFSTATC_ENULL, COMPUTEFSTATC_MSGENULL);
ASSERT (tSSB->Tdot, status, COMPUTEFSTATC_ENULL, COMPUTEFSTATC_MSGENULL);
ASSERT (tBinary, status,COMPUTEFSTATC_ENULL, COMPUTEFSTATC_MSGENULL);
ASSERT (tBinary->DeltaT, status,COMPUTEFSTATC_ENULL, COMPUTEFSTATC_MSGENULL);
ASSERT (tBinary->Tdot, status, COMPUTEFSTATC_ENULL, COMPUTEFSTATC_MSGENULL);
ASSERT (tSSB->DeltaT->length == numSteps, status, COMPUTEFSTATC_EINPUT, COMPUTEFSTATC_MSGEINPUT);
ASSERT (tSSB->Tdot->length == numSteps, status, COMPUTEFSTATC_EINPUT, COMPUTEFSTATC_MSGEINPUT);
ASSERT (tBinary->DeltaT->length == numSteps, status, COMPUTEFSTATC_EINPUT, COMPUTEFSTATC_MSGEINPUT);
ASSERT (tBinary->Tdot->length == numSteps, status, COMPUTEFSTATC_EINPUT, COMPUTEFSTATC_MSGEINPUT);
/* convenience variables */
Porb = binaryparams->period;
e = binaryparams->ecc;
asini = binaryparams->asini;
sinw = sin(binaryparams->argp);
cosw = cos(binaryparams->argp);
ome = 1.0 - e;
refTimeREAL8 = GPS2REAL8(refTime);
/* compute p, q and r coeeficients */
A = (LAL_TWOPI/Porb)*cosw*asini*sqrt(1.0-e*e) - e;
B = (LAL_TWOPI/Porb)*sinw*asini;
REAL8 tp = GPS2REAL8(binaryparams->tp);
REAL8 Tp = tp + asini*sinw*ome;
/* Calculate the required accuracy for the root finding procedure in the main loop */
acc = LAL_TWOPI*(REAL8)EA_ACC/Porb; /* EA_ACC is defined above and represents the required timing precision in seconds (roughly) */
/* loop over the SFTs */
for (i=0; i < numSteps; i++ )
{
/* define SSB time for the current SFT midpoint */
tSSB_now = refTimeREAL8 + (tSSB->DeltaT->data[i]);
/* define fractional orbit in SSB frame since periapsis (enforce result 0->1) */
/* the result of fmod uses the dividend sign hence the second procedure */
REAL8 temp = fmod((tSSB_now - Tp),Porb)/(REAL8)Porb;
fracorb = temp - (REAL8)floor(temp);
REAL8 x0 = fracorb * LAL_TWOPI;
/* compute eccentric anomaly using a root finding procedure */
input.function = EccentricAnomoly; /* This is the name of the function we must solve to find E */
input.xmin = 0.0; /* We know that E will be found between 0 and 2PI */
input.xmax = LAL_TWOPI;
input.xacc = acc; /* The accuracy of the root finding procedure */
/* expand domain until a root is bracketed */
LALDBracketRoot(status->statusPtr,&input,&x0);
/* bisect domain to find eccentric anomoly E corresponding to the SSB time of the midpoint of this SFT */
LALDBisectionFindRoot(status->statusPtr,&E,&input,&x0);
/* use our value of E to compute the additional binary time delay */
tBinary->DeltaT->data[i] = tSSB->DeltaT->data[i] - ( asini*sinw*(cos(E)-e) + asini*cosw*sqrt(1.0-e*e)*sin(E) );
/* combine with Tdot (dtSSB_by_dtdet) -> dtbin_by_dtdet */
tBinary->Tdot->data[i] = tSSB->Tdot->data[i] * ( (1.0 - e*cos(E))/(1.0 + A*cos(E) - B*sin(E)) );
} /* for i < numSteps */
DETATCHSTATUSPTR (status);
RETURN(status);
} /* LALGetBinarytimes() */
/**
* Given a set of input parameters defining a source location in the sky and
* the binary system in which the source resides, this routine returns the phase
* model coefficients \f$A_{s\alpha}\f$ and \f$B_{s\alpha}\f$ which are needed to
* correctly account for the phase variance of a signal over time. The
* \c CSBParams parameter structure contains relevant information
* for this routine to properly run. In particular, it contains an array of
* timestamps in \c LIGOTimeGPS format, which are the GPS times of the first
* data from each SFT. The \c input is an \c INT4 variable
* \c iSkyCoh, which is the index of the sky location under consideration. For
* each sky location and set of orbital parameters, this code needs to be run
* once; the necessary phase model
* coefficients are calculated, and can then be applied to the relevant spindown
* parameter sets one is using in their search.
*
* ### Algorithm ###
*
* The routine uses a simplistic nested for-loop structure. The outer loop is
* over the number of SFTs in the observation timescale; this accounts for the
* temporal variability of the phase model coefficients. The inner loop is over
* the number of spindown parameters in one set. Inside the inner loop, the
* values are calculated using the analytical formulae given in the
* \ref ComputeSkyBinary.h documentation.
*/
void LALComputeSkyBinary (LALStatus *status,
REAL8 *skyConst,
INT8 iSkyCoh,
CSBParams *params)
{
INT4 m, n, nP;
REAL8 dTbary;
REAL8 dTbarySP;
REAL8 dTperi;
REAL8 dTcoord;
REAL8 Tdotbin;
REAL8 basedTperi;
DFindRootIn input;
REAL8 tr0;
REAL8 acc;
INITSTATUS(status);
ATTATCHSTATUSPTR(status);
/* Check for non-negativity of sky positions in SkyCoh[] */
ASSERT(iSkyCoh>=0, status, COMPUTESKYBINARYH_ENEGA, COMPUTESKYBINARYH_MSGENEGA);
/* Check to make sure sky positions are loaded */
ASSERT(params->skyPos!=NULL, status, COMPUTESKYBINARYH_ENULL, COMPUTESKYBINARYH_MSGENULL);
ASSERT(params->skyPos!=NULL, status, COMPUTESKYBINARYH_ENULL, COMPUTESKYBINARYH_MSGENULL);
/* Check to make sure parameters are loaded and reasonable */
ASSERT(params->spinDwnOrder>=0, status, COMPUTESKYBINARYH_ENEGA, COMPUTESKYBINARYH_MSGENEGA);
ASSERT(params->mObsSFT>=0, status, COMPUTESKYBINARYH_ENEGA, COMPUTESKYBINARYH_MSGENEGA);
ASSERT(params->tSFT>=0, status, COMPUTESKYBINARYH_ENEGA, COMPUTESKYBINARYH_MSGENEGA);
/* Check to make sure orbital parameters are loaded and reasonable */
ASSERT(params->SemiMajorAxis>=0, status, COMPUTESKYBINARYH_ENEGA, COMPUTESKYBINARYH_MSGENEGA);
ASSERT(params->OrbitalPeriod>0, status, COMPUTESKYBINARYH_ENEGA, COMPUTESKYBINARYH_MSGENEGA);
ASSERT(params->OrbitalEccentricity>=0, status, COMPUTESKYBINARYH_ENEGA, COMPUTESKYBINARYH_MSGENEGA);
ASSERT((params->ArgPeriapse>=0)&&(params->ArgPeriapse<=LAL_TWOPI), status, COMPUTESKYBINARYH_ENEGA, COMPUTESKYBINARYH_MSGENEGA);
ASSERT(params->TperiapseSSB.gpsSeconds>=0, status, COMPUTESKYBINARYH_ENEGA, COMPUTESKYBINARYH_MSGENEGA);
ASSERT((params->TperiapseSSB.gpsNanoSeconds>=0)&&(params->TperiapseSSB.gpsNanoSeconds<1e9), status, COMPUTESKYBINARYH_ENEGA, COMPUTESKYBINARYH_MSGENEGA);
/* Here we redefine the orbital variables for ease of use */
a=params->SemiMajorAxis; /* This is the projected semi-major axis of the orbit normalised by the speed of light */
Period=params->OrbitalPeriod; /* This is the period of the orbit in seconds */
ecc=params->OrbitalEccentricity; /* This is the eccentricity of the orbit */
parg=params->ArgPeriapse; /* This is the argument of periapse defining the angular location of the source at periapsis */
/* measured relative to the ascending node */
Tperi.gpsSeconds=params->TperiapseSSB.gpsSeconds; /* This is the GPS time as measured in the SSB of the observed */
Tperi.gpsNanoSeconds=params->TperiapseSSB.gpsNanoSeconds; /* periapse passage of the source */
/* Here we check that the GPS timestamps are greater than zero */
for(n=0;n<params->mObsSFT;n++)
{
ASSERT(params->tGPS[n].gpsSeconds>=0, status, COMPUTESKYBINARYH_ENEGA, COMPUTESKYBINARYH_MSGENEGA);
}
/* Check to make sure pointer to output is not NULL */
ASSERT(skyConst!=NULL, status, COMPUTESKYBINARYH_ENNUL, COMPUTESKYBINARYH_MSGENNUL);
/* prepare params input sky position structure */
params->baryinput->alpha=params->skyPos[iSkyCoh];
params->baryinput->delta=params->skyPos[iSkyCoh+1];
/* calculate phase model coefficients p and q which are defined in the ComputeSkyBinary header LAL documentation */
p=((LAL_TWOPI/(Period*1.0))*a*sqrt(1-(ecc*ecc))*cos(parg))-ecc;
q=(LAL_TWOPI/(Period*1.0))*a*sin(parg);
/* Calculate the required accuracy for the root finding procedure in the main loop */
acc=LAL_TWOPI*(REAL8)ACC/Period; /* ACC is defined in ComputeSkyBinary.h and represents the required */
/* timing precision in seconds (roughly)*/
/* begin loop over SFT's */
for (n=0; n<params->mObsSFT; n++)
{
/* Calculate the detector time at the mid point of current SFT ( T(i)+(tsft/2) ) using LAL functions */
params->baryinput->tgps = params->tGPS[n];
XLALGPSAdd(&(params->baryinput->tgps), params->tSFT / 2.0);
/* Convert this mid point detector time into barycentric time (SSB) */
LALBarycenterEarth(status->statusPtr, params->earth, &(params->baryinput->tgps), params->edat);
LALBarycenter(status->statusPtr, params->emit, params->baryinput, params->earth);
/* Calculate the time difference since the observed periapse passage in barycentric time (SSB). */
/* This time difference, when converted to REAL8, should lose no precision unless we are dealing */
/* with periods >~ 1 Year */
dTbary = XLALGPSDiff(&(params->emit->te),&Tperi);
/* Calculate the time since the last periapse passage ( < Single Period (SP) ) */
dTbarySP=Period*((dTbary/(1.0*Period))-(REAL8)floor(dTbary/(1.0*Period)));
/* Calculate number of full orbits completed since the input observed periapse passage */
nP=(INT4)floor(dTbary/(1.0*Period));
/* begin root finding procedure */
tr0 = dTbarySP; /* we wish to find the value of the eccentric amomoly E coresponding to the time */
/* since the last periapse passage */
input.function = Ft; /* This is the name of the function we must solve to find E */
input.xmin = 0.0; /* We know that E will be found between 0 and 2PI */
input.xmax = LAL_TWOPI;
input.xacc = acc; /* The accuracy of the root finding procedure */
/* expand domain until a root is bracketed */
LALDBracketRoot(status->statusPtr,&input,&tr0);
/* bisect domain to find eccentric anomoly E corresponding to the current midpoint timestamp */
LALDBisectionFindRoot(status->statusPtr,&E,&input,&tr0);
/* Now we calculate the time interval since the input periapse passage as measured at the source */
dTperi=(Period/LAL_TWOPI)*(E-(ecc*sin(E)))+((REAL8)nP*Period);
/* The following quantity is the derivative of the time coordinate measured at the source with */
/* respect to the time coordinate measured in the SSB */
dTcoord=(1.0-(ecc*cos(E)))/(1.0+(p*cos(E))-(q*sin(E)));
/* The following quantity is the derivitive of the time coordinate measured in the SSB with */
/* respect to the time coordinate measured at the chosen detector. It was calculated via the */
/* last call to LALBarycenter. */
Tdotbin = params->emit->tDot*dTcoord;
/* Loop over all spin down orders plus 0th order (f0) */
/* In this loop we calculate the SkyConstants defined in the documentation as A_{s,alpha} and B_{s,alpha} */
for (m=0; m<params->spinDwnOrder+1; m++)
{
/* raise the quantity dTperi to the power m */
basedTperi = pow(dTperi, (REAL8)m);
/* Calculate A coefficients */
skyConst[2*n*(params->spinDwnOrder+1)+2*(INT4)m]=1.0/((REAL8)m+1.0)*basedTperi*dTperi-0.5*params->tSFT*basedTperi*Tdotbin;
/* Calculate B coefficients */
skyConst[2*n*(params->spinDwnOrder+1)+2*(INT4)m+1]= params->tSFT*basedTperi*Tdotbin;
}
}
/* Normal Exit */
DETATCHSTATUSPTR(status);
RETURN(status);
}
void StackSlideComputeSkyBinary( LALStatus *status,
TdotsAndDeltaTs *pTdotsAndDeltaTs,
INT8 iSkyCoh,
/*StackSlideBinarySkyParams *params*/
StackSlideSkyParams *params
)
{
INT4 m, n, nP;
REAL8 dTbary;
LALTimeInterval dTBaryInterval;
LALTimeInterval HalfSFT;
REAL8 HalfSFTfloat;
REAL8 dTbarySP;
REAL8 dTperi;
REAL8 dTcoord;
REAL8 Tdotbin;
REAL8 basedTperi;
DFindRootIn input;
REAL8 tr0;
REAL8 acc;
#ifdef DEBUG_STACKSLIDECOMPUTESKYBINARY_FNC
fprintf(stdout,"start function ComputeSkyBinary\n");
fflush(stdout);
#endif
INITSTATUS(status);
ATTATCHSTATUSPTR(status);
/*for (i=0;i< SSparams->numSTKs; i++)
{
tGPS[i].gpsSeconds=SSparams->gpsStartTimeSec +(UINT4)(i*(SSparams->tSTK));
tGPS[i].gpsNanoSeconds=SSparams->gpsStartTimeNan;
}*/
/*is this SSparams or params?*/
/*#ifdef 0 */
/* Check for non-negativity of sky positions in SkyCoh[] */
ASSERT(iSkyCoh>=0, status, COMPUTESKYBINARYH_ENEGA, COMPUTESKYBINARYH_MSGENEGA);
/* Check to make sure sky positions are loaded */
ASSERT(params->skyPos!=NULL, status, COMPUTESKYBINARYH_ENULL, COMPUTESKYBINARYH_MSGENULL);
ASSERT(params->skyPos!=NULL, status, COMPUTESKYBINARYH_ENULL, COMPUTESKYBINARYH_MSGENULL);
/* Check to make sure parameters are loaded and reasonable */
ASSERT(params->spinDwnOrder>=0, status, COMPUTESKYBINARYH_ENEGA, COMPUTESKYBINARYH_MSGENEGA);
ASSERT(params->mObsSFT>=0, status, COMPUTESKYBINARYH_ENEGA, COMPUTESKYBINARYH_MSGENEGA);
ASSERT(params->tSFT>=0, status, COMPUTESKYBINARYH_ENEGA, COMPUTESKYBINARYH_MSGENEGA);
/* Check to make sure orbital parameters are loaded and reasonable */
ASSERT(params->SemiMajorAxis>=0, status, COMPUTESKYBINARYH_ENEGA, COMPUTESKYBINARYH_MSGENEGA);
ASSERT(params->OrbitalPeriod>0, status, COMPUTESKYBINARYH_ENEGA, COMPUTESKYBINARYH_MSGENEGA);
ASSERT(params->OrbitalEccentricity>=0, status, COMPUTESKYBINARYH_ENEGA, COMPUTESKYBINARYH_MSGENEGA);
ASSERT((params->ArgPeriapse>=0)&&(params->ArgPeriapse<=LAL_TWOPI), status, COMPUTESKYBINARYH_ENEGA, COMPUTESKYBINARYH_MSGENEGA);
ASSERT(params->TperiapseSSB.gpsSeconds>=0, status, COMPUTESKYBINARYH_ENEGA, COMPUTESKYBINARYH_MSGENEGA);
ASSERT((params->TperiapseSSB.gpsNanoSeconds>=0)&&(params->TperiapseSSB.gpsNanoSeconds<1e9), status, COMPUTESKYBINARYH_ENEGA, COMPUTESKYBINARYH_MSGENEGA);
/*#endif*/
/* Here we redefine the orbital variables for ease of use */
#ifdef DEBUG_STACKSLIDECOMPUTESKYBINARY_FNC
fprintf(stdout,"leap %d\n",params->edat->leap);
fflush(stdout);
#endif
a=params->SemiMajorAxis; /* This is the projected semi-major axis of the orbit normalised by the speed of light */
Period=params->OrbitalPeriod; /* This is the period of the orbit in seconds */
ecc=params->OrbitalEccentricity; /* This is the eccentricity of the orbit */
parg=params->ArgPeriapse; /* This is the argument of periapse defining the angular location of the source at periapsis */
/* measured relative to the ascending node */
Tperi.gpsSeconds=params->TperiapseSSB.gpsSeconds; /* This is the GPS time as measured in the SSB of the observed */
Tperi.gpsNanoSeconds=params->TperiapseSSB.gpsNanoSeconds; /* periapse passage of the source */
/* Convert half the SFT length to a LALTimeInterval for later use */
HalfSFTfloat=params->tSFT/2.0;
#ifdef DEBUG_STACKSLIDECOMPUTESKYBINARY_FNC
fprintf(stdout,"HalfSFTfl %f\n",HalfSFTfloat);
fflush(stdout);
#endif
LALFloatToInterval(status->statusPtr,&HalfSFT,&HalfSFTfloat);
/* Here we check that the GPS timestamps are greater than zero */
for(n=0;n<params->mObsSFT;n++)
{
ASSERT(params->tGPS[n].gpsSeconds>=0, status, COMPUTESKYBINARYH_ENEGA, COMPUTESKYBINARYH_MSGENEGA);
/*ASSERT(tGPS[n].gpsSeconds>=0, status, COMPUTESKYBINARYH_ENEGA, COMPUTESKYBINARYH_MSGENEGA);*/
}
/* Check to make sure pointer to output is not NULL */
/*ASSERT(skyConst!=NULL, status, COMPUTESKYBINARYH_ENNUL, COMPUTESKYBINARYH_MSGENNUL);*/
ASSERT(pTdotsAndDeltaTs!=NULL, status, COMPUTESKYBINARYH_ENNUL, COMPUTESKYBINARYH_MSGENNUL);
/* prepare params input sky position structure */
/* params->baryinput->alpha=params->skyPos[iSkyCoh];
params->baryinput->delta=params->skyPos[iSkyCoh+1];*/
/* params->baryinput->alpha=SSparams->skyPosData[iSky][iSkyCoh];
params->baryinput->delta=SSparams->skyPosData[iSky][iSkyCoh+1]; maybe put it back*/
/* calculate phase model coefficients p and q which are defined in the ComputeSkyBinary header LAL documentation */
p=((LAL_TWOPI/(Period*1.0))*a*sqrt(1-(ecc*ecc))*cos(parg))-ecc;
q=(LAL_TWOPI/(Period*1.0))*a*sin(parg);
/* Calculate the required accuracy for the root finding procedure in the main loop */
acc=LAL_TWOPI*(REAL8)ACC/Period; /* ACC is defined in ComputeSkyBinary.h and represents the required */
/* timing precision in seconds (roughly)*/
/* begin loop over SFT's */
for (n=0; n<params->mObsSFT; n++)
{
/* Calculate the detector time at the mid point of current SFT ( T(i)+(tsft/2) ) using LAL functions */
/*!*/ /* LALIncrementGPS(status->statusPtr,&(params->baryinput->tgps),¶ms->tGPS[n],&HalfSFT);*/
/* LALIncrementGPS(status->statusPtr,&(params->baryinput->tgps),&tGPS[n],&HalfSFT);*/
LALIncrementGPS(status->statusPtr, &(params->baryinput->tgps),¶ms->tGPS[n],&HalfSFT);
#ifdef DEBUG_STACKSLIDECOMPUTESKYBINARY_FNC
fprintf(stdout,"tgps %d\n",params->baryinput->tgps.gpsSeconds);
fprintf(stdout,"leap %d\n",params->edat->leap);
fflush(stdout);
#endif
/* Convert this mid point detector time into barycentric time (SSB) */
/* GetSSBTime(&(baryinput.tgps), &TmidSSB) ;*/
LALBarycenterEarth(status->statusPtr, params->earth, &(params->baryinput->tgps), params->edat);
LALBarycenter(status->statusPtr, params->emit, params->baryinput, params->earth);
CHECKSTATUSPTR(status);
#ifdef DEBUG_STACKSLIDECOMPUTESKYBINARY_FNC
fprintf(stdout,"status %d\n",status->statusCode);
fflush(stdout);
#endif
/* LALBarycenterEarth(status->statusPtr, csParams->earth, &(csParams->baryinput->tgps), csParams->edat);
LALBarycenter(status->statusPtr, csParams->emit, csParams->baryinput, csParams->earth);*/
/* Calculate the time difference since the observed periapse passage in barycentric time (SSB). */
/* This time difference, when converted to REAL8, should lose no precision unless we are dealing */
/* with periods >~ 1 Year */
LALDeltaGPS(status->statusPtr,&dTBaryInterval,&(params->emit->te),&Tperi);
LALIntervalToFloat(status->statusPtr,&dTbary,&dTBaryInterval);
/* LALDeltaGPS(status->statusPtr,&dTBaryInterval,&(csParams->emit->te),&Tperi);
LALIntervalToFloat(status->statusPtr,&dTbary,&dTBaryInterval);*/
/* Calculate the time since the last periapse passage ( < Single Period (SP) ) */
dTbarySP=Period*((dTbary/(1.0*Period))-(REAL8)floor(dTbary/(1.0*Period)));
/* Calculate number of full orbits completed since the input observed periapse passage */
nP=(INT4)floor(dTbary/(1.0*Period));
#ifdef DEBUG_STACKSLIDECOMPUTESKYBINARY_FNC
fprintf(stdout,"dTbary is %f\n",dTbary);
fprintf(stdout,"dTbarySP is %f\n",dTbarySP);
fprintf(stdout,"nP is %i\n",nP);
fflush(stdout);
#endif
/* begin root finding procedure */
tr0 = dTbarySP; /* we wish to find the value of the eccentric anomaly E corresponding to the time */
/* since the last periapse passage */
input.function = Ft; /* This is the name of the function we must solve to find E */
input.xmin = 0.0; /* We know that E will be found between 0 and 2PI */
input.xmax = LAL_TWOPI;
input.xacc = acc; /* The accuracy of the root finding procedure */
/* expand domain until a root is bracketed */
LALDBracketRoot(status->statusPtr,&input,&tr0);
/* bisect domain to find eccentric anomoly E corresponding to the current midpoint timestamp */
LALDBisectionFindRoot(status->statusPtr,&E,&input,&tr0);
/* Now we calculate the time interval since the input periapse passage as measured at the source */
dTperi=(Period/LAL_TWOPI)*(E-(ecc*sin(E)))+((REAL8)nP*Period);
#ifdef DEBUG_STACKSLIDECOMPUTESKYBINARY_FNC
fprintf(stdout,"dTperi is %f\n",dTperi);
fflush(stdout);
#endif
/* The following quantity is the derivative of the time coordinate measured at the source with */
/* respect to the time coordinate measured in the SSB : dt_(source)/dt_(SSB) */
dTcoord=(1.0-(ecc*cos(E)))/(1.0+(p*cos(E))-(q*sin(E)));
/* The following quantity is the derivitive of the time coordinate measured in the SSB with */
/* respect to the time coordinate measured at the chosen detector. It was calculated via the */
/* last call to LALBarycenter : dt_(SSB)/dt_(detector) */
Tdotbin = params->emit->tDot*dTcoord; /*=dt_source/dt_detector puts you back into the source*/
/*fprintf(stdout,"%g %g\n", params->emit->tDot, dTcoord);*/
#ifdef DEBUG_STACKSLIDECOMPUTESKYBINARY_FNC
fprintf(stdout,"tDot is %f\n",params->emit->tDot);
fprintf(stdout,"dTcoord is %f\n",dTcoord);
fprintf(stdout,"Tdotbin is %f\n",Tdotbin);
fflush(stdout);
#endif
/* Tdotbin = csParams->emit->tDot*dTcoord; */
/* Loop over all spin down orders plus 0th order (f0) */
/* In this loop we calculate the SkyConstants defined in the documentation as A_{s,alpha} and B_{s,alpha} */
/*!*/ pTdotsAndDeltaTs->vecTDots[n]= Tdotbin;
#ifdef DEBUG_STACKSLIDECOMPUTESKYBINARY_FNC
fprintf(stdout,"pTdotsAndDeltaTs->vecTDots is %f\n",pTdotsAndDeltaTs->vecTDots[n]);
fflush(stdout);
#endif
for (m=0; m<params->spinDwnOrder; m++)
{
/* raise the quantity dTperi to the power m */
basedTperi = pow(dTperi, (REAL8)m+1);
#ifdef DEBUG_STACKSLIDECOMPUTESKYBINARY_FNC
fprintf(stdout,"basedTperi %f\n",basedTperi);
fflush(stdout);
#endif
/*!*/ /*the 2 lines below must be changed */
/* Calculate A coefficients */
/* skyConst[2*n*(params->spinDwnOrder+1)+2*(INT4)m]=1.0/((REAL8)m+1.0)*basedTperi*dTperi-0.5*params->tSFT*basedTperi*Tdotbin;*/
/* Calculate B coefficients */
/* skyConst[2*n*(params->spinDwnOrder+1)+2*(INT4)m+1]= params->tSFT*basedTperi*Tdotbin;*/
/*expressing the time difference in the SSB */
/*!*/ /*pTdotsAndDeltaTs->vecDeltaTs[m][n]= basedTperi*pTdotsAndDeltaTs->vecTDots[n]; */
pTdotsAndDeltaTs->vecDeltaTs[n][m]= basedTperi; /*in the Source*/
#ifdef DEBUG_STACKSLIDECOMPUTESKYBINARY_FNC
fprintf(stdout,"vecDeltaTs %f\n", pTdotsAndDeltaTs->vecDeltaTs[n][m]);
fflush(stdout);
#endif
} /* END for (m=0; m<params->spinDwnOrder; m++) */
#ifdef DEBUG_STACKSLIDECOMPUTESKYBINARY_FNC
fprintf(stdout,"end function StackSlideComputeSkyBinary\n");
fflush(stdout);
#endif
} /* for (n=0; n<params->mObsSFT; n++) */
/*LALFree(params->edat->ephemE);
LALFree(params->edat->ephemS);
LALFree(params->edat);*/
/* Normal Exit */
DETATCHSTATUSPTR(status);
RETURN(status);
}
int
main (int argc, char *argv[])
{
static LALStatus status;
SFindRootIn sinput;
DFindRootIn dinput;
REAL4 y_0;
REAL4 sroot;
REAL8 yy0;
REAL8 droot;
/*
*
* Parse the command line options
*
*/
ParseOptions (argc, argv);
/*
*
* Set up input structure and function parameter y_0.
*
*/
y_0 = -1;
sinput.function = F;
sinput.xmin = 1e-3;
sinput.xmax = 2e-3;
sinput.xacc = 1e-6;
yy0 = -1;
dinput.function = FF;
dinput.xmin = 1e-3;
dinput.xmax = 2e-3;
dinput.xacc = 1e-15;
/*
*
* Check to see if bracketing and root finding work.
*
*/
if (verbose)
{
printf ("\n===== Check Root Finding =====\n\n");
}
if (verbose)
{
printf ("Initial domain: [%e,%e]\n", dinput.xmin, dinput.xmax);
}
LALSBracketRoot (&status, &sinput, &y_0);
TestStatus (&status, CODES(0), 1);
if (verbose)
{
printf ("Bracket domain: [%e,%e]\n", sinput.xmin, sinput.xmax);
}
if (sinput.xmin > 1 || sinput.xmax < 1)
{
fprintf (stderr, "Root not bracketed correctly\n");
return 1;
}
LALDBracketRoot (&status, &dinput, &yy0);
TestStatus (&status, CODES(0), 1);
if (verbose)
{
printf ("Bracket domain: [%e,%e]\n", dinput.xmin, dinput.xmax);
}
if (dinput.xmin > 1 || dinput.xmax < 1)
{
fprintf (stderr, "Root not bracketed correctly\n");
return 1;
}
LALSBisectionFindRoot (&status, &sroot, &sinput, &y_0);
TestStatus (&status, CODES(0), 1);
if (verbose)
{
printf ("Root = %e (acc = %e)\n", sroot, sinput.xacc);
}
if (fabs(sroot - 1) > sinput.xacc)
{
fprintf (stderr, "Root not found to correct accuracy\n");
return 1;
}
LALDBisectionFindRoot (&status, &droot, &dinput, &yy0);
TestStatus (&status, CODES(0), 1);
if (verbose)
{
printf ("Root = %.15e (acc = %e)\n", droot, dinput.xacc);
}
if (fabs(droot - 1) > dinput.xacc)
{
fprintf (stderr, "Root not found to correct accuracy\n");
return 1;
}
/*
*
* Check to make sure that correct error codes are generated.
*
*/
#ifndef LAL_NDEBUG
if ( ! lalNoDebug )
{
if (verbose || lalDebugLevel)
{
printf ("\n===== Check Errors =====\n");
}
/* recursive error from an error occurring in the function */
if (verbose)
{
printf ("\n----- Recursive Error: Code -1 (2 times)\n");
}
LALSBracketRoot (&status, &sinput, NULL);
TestStatus (&status, CODES(-1), 1);
ClearStatus (&status);
LALDBracketRoot (&status, &dinput, NULL);
TestStatus (&status, CODES(-1), 1);
ClearStatus (&status);
/* one of the arguments is a null pointer */
if (verbose)
{
printf ("\n----- Null Pointer Error: Code 1 (10 times)\n");
}
LALSBracketRoot (&status, NULL, &y_0);
TestStatus (&status, CODES(FINDROOTH_ENULL), 1);
LALDBracketRoot (&status, NULL, &yy0);
TestStatus (&status, CODES(FINDROOTH_ENULL), 1);
LALSBisectionFindRoot (&status, NULL, &sinput, &y_0);
TestStatus (&status, CODES(FINDROOTH_ENULL), 1);
LALDBisectionFindRoot (&status, NULL, &dinput, &yy0);
TestStatus (&status, CODES(FINDROOTH_ENULL), 1);
LALSBisectionFindRoot (&status, &sroot, NULL, &y_0);
TestStatus (&status, CODES(FINDROOTH_ENULL), 1);
LALDBisectionFindRoot (&status, &droot, NULL, &yy0);
TestStatus (&status, CODES(FINDROOTH_ENULL), 1);
sinput.function = NULL;
dinput.function = NULL;
LALSBracketRoot (&status, &sinput, &y_0);
TestStatus (&status, CODES(FINDROOTH_ENULL), 1);
LALDBracketRoot (&status, &dinput, &yy0);
TestStatus (&status, CODES(FINDROOTH_ENULL), 1);
LALSBisectionFindRoot (&status, &sroot, &sinput, &y_0);
TestStatus (&status, CODES(FINDROOTH_ENULL), 1);
LALDBisectionFindRoot (&status, &droot, &dinput, &yy0);
TestStatus (&status, CODES(FINDROOTH_ENULL), 1);
/* invalid initial domain error for BracketRoot() */
if (verbose)
{
printf ("\n----- Invalid Initial Domain: Code 2 (2 times)\n");
}
sinput.function = F;
sinput.xmin = 5;
sinput.xmax = 5;
dinput.function = FF;
dinput.xmin = 5;
dinput.xmax = 5;
LALSBracketRoot (&status, &sinput, &y_0);
TestStatus (&status, CODES(FINDROOTH_EIDOM), 1);
LALDBracketRoot (&status, &dinput, &yy0);
TestStatus (&status, CODES(FINDROOTH_EIDOM), 1);
/* maximum iterations exceeded error */
if (verbose)
{
printf ("\n----- Maximum Iteration Exceeded: Code 4 (4 times)\n");
}
y_0 = 1; /* there is no root when y_0 > 0 */
sinput.xmin = -1e-18;
sinput.xmax = 1e-18;
yy0 = 1; /* there is no root when y_0 > 0 */
dinput.xmin = -1e-18;
dinput.xmax = 1e-18;
LALSBracketRoot (&status, &sinput, &y_0);
TestStatus (&status, CODES(FINDROOTH_EMXIT), 1);
LALDBracketRoot (&status, &dinput, &yy0);
TestStatus (&status, CODES(FINDROOTH_EMXIT), 1);
y_0 = -1;
sinput.xmin = 0;
sinput.xmax = 1e19;
sinput.xacc = 2e-38;
yy0 = -1;
dinput.xmin = 0;
dinput.xmax = 1e19;
dinput.xacc = 2e-38;
LALSBisectionFindRoot (&status, &sroot, &sinput, &y_0);
TestStatus (&status, CODES(FINDROOTH_EMXIT), 1);
LALDBisectionFindRoot (&status, &droot, &dinput, &yy0);
TestStatus (&status, CODES(FINDROOTH_EMXIT), 1);
/* root not bracketed error in BisectionFindRoot() */
if (verbose)
{
printf ("\n----- Root Not Bracketed: Code 8 (2 times)\n");
}
sinput.xmin = -5;
sinput.xmax = -3;
sinput.xacc = 1e-6;
dinput.xmin = -5;
dinput.xmax = -3;
dinput.xacc = 1e-6;
LALSBisectionFindRoot (&status, &sroot, &sinput, &y_0);
TestStatus (&status, CODES(FINDROOTH_EBRKT), 1);
LALDBisectionFindRoot (&status, &droot, &dinput, &yy0);
TestStatus (&status, CODES(FINDROOTH_EBRKT), 1);
}
#endif
return 0;
}
