/** * 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; }