pint.models.stand_alone_psr_binaries.DDS_model.DDSmodel

class pint.models.stand_alone_psr_binaries.DDS_model.DDSmodel(t=None, input_params=None)[source]

Bases: DDmodel

Damour and Deruelle model with alternate Shapiro delay parameterization.

This extends the pint.models.binary_dd.BinaryDD model with \(SHAPMAX = -\log(1-s)\) instead of just \(s=\sin i\), which behaves better for \(\sin i\) near 1. It does not (yet) implement the higher-order delays and lensing correction.

It supports all the parameters defined in pint.models.pulsar_binary.PulsarBinary and pint.models.binary_dd.BinaryDD plus:

SHAPMAX
\(-\log(1-\sin i)\)

It also removes:

SINI
use SHAPMAX instead

Parameters supported:

Name / Aliases	Description	Kind
PB	Orbital period	d
PBDOT	Orbital period derivative respect to time	number
A1	Projected semi-major axis of pulsar orbit, ap*sin(i)	ls
A1DOT / XDOT	Derivative of projected semi-major axis, d[ap*sin(i)]/dt	ls / s
ECC / E	Eccentricity	number
EDOT	Eccentricity derivative respect to time	1 / s
T0	Epoch of periastron passage	d
OM	Longitude of periastron	deg
OMDOT	Rate of advance of periastron	deg / yr
M2	Companion mass	solMass
FB{number}	0th time derivative of frequency of orbit	1 / s
A0	DD model aberration parameter A0	s
B0	DD model aberration parameter B0	s
GAMMA	Time dilation & gravitational redshift	s
DR	Relativistic deformation of the orbit	number
DTH / DTHETA	Relativistic deformation of the orbit	number
SHAPMAX	Function of inclination angle	number
SINI	Sine of inclination angle	number

References

Kramer et al. (2006), Science, 314, 97 [klm+06]
Rafikov and Lai (2006), PRD, 73, 063003 [rl06]

[klm+06]

https://ui.adsabs.harvard.edu/abs/2006Sci…314…97K/abstract

[rl06]

https://ui.adsabs.harvard.edu/abs/2006PhRvD..73f3003R/abstract

Methods

`DDdelay`()	Full DD model delay
`Doppler`()
`Dre`()	Dre defined in T.
`Drep`()	Derivative of Dre respect to T.
`Drepp`()	Derivative of Drep respect to T.
`E`()	Eccentric Anomaly
`M`()	Orbit phase.
`P`()
`Pobs_designmatrix`(params)
`TM2`()
`a1`()
`add_binary_params`(parameter, defaultValue[, ...])	Add one parameter to the binary class.
`add_inter_vars`(interVars)
`alpha`()	Alpha defined in T.
`beta`()	Beta defined in T.
`binary_delay`()	Returns total pulsar binary delay.
`compute_eccentric_anomaly`(eccentricity, ...)	Solve the Kepler Equation, E - e * sin(E) = M
`d_DDdelay_d_par`(par)	Full DD model delay derivative
`d_Dre_d_par`(par)	Derivative.
`d_Drep_d_par`(par)	Derivative.
`d_Drepp_d_par`(par)	Derivative.
`d_E_d_ECC`()
`d_E_d_EDOT`()
`d_E_d_T0`()	Analytic derivative
`d_E_d_par`(par)	derivative for E respect to binary parameter.
`d_M_d_par`(par)	derivative for M respect to binary parameter.
`d_Pobs_d_A1`()
`d_Pobs_d_A1DOT`()
`d_Pobs_d_ECC`()
`d_Pobs_d_EDOT`()
`d_Pobs_d_OM`()
`d_Pobs_d_OMDOT`()
`d_Pobs_d_P0`()
`d_Pobs_d_P1`()
`d_Pobs_d_PB`()
`d_Pobs_d_PBDOT`()
`d_Pobs_d_T0`()
`d_SINI_d_SHAPMAX`()
`d_SINI_d_par`(par)
`d_TM2_d_M2`()
`d_a1_d_A1`()
`d_a1_d_A1DOT`()
`d_a1_d_T0`()
`d_a1_d_par`(par)
`d_alpha_d_par`(par)	Damour and N. Deruelle (1986) equation [46]
`d_beta_d_A1`()	Derivative.
`d_beta_d_A1DOT`()	Derivative.
`d_beta_d_DTH`()	Derivative.
`d_beta_d_ECC`()	Derivative.
`d_beta_d_EDOT`()	Derivative.
`d_beta_d_T0`()	Derivative.
`d_beta_d_par`(par)	Derivative.
`d_binarydelay_d_par`(par)	Get the binary delay derivatives respect to parameters.
`d_delayA_d_par`(par)	Derivative.
`d_delayI_d_par`(par)	Derivative on delay inverse.
`d_delayS_d_par`(par)	Derivative.
`d_eTheta_d_DTH`()
`d_eTheta_d_par`(par)
`d_ecc_d_ECC`()
`d_ecc_d_EDOT`()
`d_ecc_d_T0`()
`d_er_d_DR`()
`d_er_d_par`(par)
`d_nhat_d_par`(par)	Derivative.
`d_nu_d_E`()
`d_nu_d_ECC`()	Analytic calculation.
`d_nu_d_EDOT`()
`d_nu_d_T0`()	Analytic calculation.
`d_nu_d_ecc`()
`d_nu_d_par`(par)	derivative for nu respect to binary parameter.
`d_omega_d_OM`()	dOmega/dOM = 1
`d_omega_d_OMDOT`()	Derivative.
`d_omega_d_T0`()	dOmega/dPB = dnu/dPBk+dk/dPBnu
`d_omega_d_par`(par)	derivative for omega respect to user input Parameter.
`d_pb_d_par`(par)	derivative for pbprime respect to binary parameter.
`delayA`()	Binary Aberration delay
`delayE`()	Binary Einstein delay
`delayInverse`()	DD model Inverse timing delay.
`delayR`()	Roemer delay defined in T.
`delayS`()	Binary shapiro delay
`delay_designmatrix`(params)
`eTheta`()
`ecc`()	Calculate eccentricity with EDOT
`er`()
`get_tt0`(barycentricTOA)	tt0 = barycentricTOA - T0
`nhat`()	nhat defined as T.
`nu`()	True anomaly (Ae)
`omega`()	Damour and N. Deruelle (1986) equation [25]
`orbits`()
`pb`()
`pbdot`()
`pbprime`()
`prtl_der`(y, x)	Find the partial derivatives in binary model pdy/pdx
`search_alias`(parname)
`set_param_values`([valDict])	Set the parameters and assign values,
`t0`()
`update_input`(**updates)	Update the toas and parameters.

Attributes

`SINI`
`T0`
`k`
`t`
`tt0`

DDdelay(): Full DD model delay

Dre()

Dre defined in T. Damour and N. Deruelle (1986) equation [48]

Computes:

delayR = alpha*(cos(E)-er) + beta*sin(E)
delayE = gamma*sin(E)
Dre = delayR + delayE

Drep()

Derivative of Dre respect to T. Damour and N. Deruelle (1986) equation [49]

Computes:

Drep = -alpha*sin(E)+(beta+gamma)*cos(E)

Drepp()

Derivative of Drep respect to T. Damour and N. Deruelle (1986) equation [50]

Computes:

Drepp = -alpha*cos(E)-(beta+GAMMA)*sin(E)

E(): Eccentric Anomaly

M(): Orbit phase.

add_binary_params(parameter, defaultValue, unit=False): Add one parameter to the binary class.

alpha()

Alpha defined in T. Damour and N. Deruelle (1986) equation [46]

Computes:

alpha = A1/c*sin(omega)

beta()

Beta defined in T. Damour and N. Deruelle (1986) equation [47]

Computes:

beta = A1/c*(1-eTheta**2)**0.5*cos(omega)

binary_delay()

Returns total pulsar binary delay.

Returns:: Pulsar binary delay in the units of second
Return type:: float

compute_eccentric_anomaly(eccentricity, mean_anomaly)

Solve the Kepler Equation, E - e * sin(E) = M

Parameters:

eccentricity (array_like) – Eccentricity of binary system
mean_anomaly (array_like) – Mean anomaly of the binary system

Returns:

The eccentric anomaly in radians, given a set of mean_anomalies in radians.

Return type:

array_like

d_DDdelay_d_par(par): Full DD model delay derivative

d_Dre_d_par(par)

Derivative.

Computes:

Dre = alpha*(cos(E)-er)+(beta+gamma)*sin(E)
dDre = alpha*(-der-dE*sin(E)) + (cos[E]-er)*dalpha +
       (dBeta+dGamma)*sin(E) + (beta+gamma)*cos(E)*dE
dDre/dpar = alpha*(-der/dpar-dE/dpar*sin(E)) +
            (cos[E]-er)*dalpha/dpar +
            (dBeta/dpar+dGamma/dpar)*sin(E) +
            (beta+gamma)*cos(E)*dE/dpar
 er = e + Dr

d_Drep_d_par(par)

Derivative.

Computes:

Drep = -alpha*sin(E)+(beta+gamma)*cos(E)
dDrep = -alpha*cos(E)*dE + cos(E)*(dbeta+dgamma)
        -(beta+gamma)*dE*sin(E)-dalpha*sin(E)
dDrep/dPar = -sin(E)*dalpha/dPar
             -(alpha*cos(E)+(beta+gamma)*sin(E))*dE/dPar
             + cos(E)(dbeta/dPar+dgamma/dPar)

d_Drepp_d_par(par)

Derivative.

Computes:

Drepp = -alpha*cos(E)-(beta+GAMMA)*sin(E)
dDrepp = -(beta+gamma)*cos(E)*dE - cos(E)*dalpha
         +alpha*sin(E)*dE - (dbeta+dgamma)*sin(E)
dDrepp/dPar = -cos(E)*dalpha/dPar
              +(alpha*sin(E)-(beta+gamma)*cos(E))*dE/dPar
              -(dbeta/dPar+dgamma/dPar)*sin(E)

d_E_d_T0()

Analytic derivative

d(E-e*sinE)/dT0 = dM/dT0 dE/dT0(1-cosE*e)-de/dT0*sinE = dM/dT0 dE/dT0(1-cosE*e)+eDot*sinE = dM/dT0

d_E_d_par(par)

derivative for E respect to binary parameter.

Parameters:: par (string) – parameter name
Return type:: Derivative of E respect to par

d_M_d_par(par)

derivative for M respect to binary parameter.

Parameters:: par (string) – parameter name
Return type:: Derivative of M respect to par

d_alpha_d_par(par)

Damour and N. Deruelle (1986) equation [46]

Computes:

alpha = a1/c*sin(omega)
dAlpha/dpar = d_a1_d_par /c * sin(omega) + a1/c*cos(omega)*dOmega/dPar

d_beta_d_A1()

Derivative.

Computes:

dBeta/dA1 = 1.0/c*(1-eTheta**2)**0.5*cos(omega) * d_a1_d_A1

d_beta_d_A1DOT()

Derivative.

Computes:

dBeta/dA1DOT = * d_a1_d_A1DOT/c*(1-eTheta**2)**0.5*cos(omega)

d_beta_d_DTH()

Derivative.

Computes:

dBeta/dDth = a1/c*((-(e+dr)/sqrt(1-(e+dr)**2)*cos(omega)

d_beta_d_ECC()

Derivative.

Computes:

dBeta/dECC = A1/c*((-(e+dtheta)/sqrt(1-(e+dtheta)**2)*cos(omega)*de/dECC-
             (1-eTheta**2)**0.5*sin(omega)*domega/dECC
de/dECC = 1

d_beta_d_EDOT()

Derivative.

Computes::: dBeta/dEDOT = A1/c*((-(e+dtheta)/sqrt(1-(e+dtheta)**2)*cos(omega)*de/dEDOT- (1-eTheta**2)**0.5*sin(omega)*domega/dEDOT de/dEDOT = tt0

d_beta_d_T0()

Derivative.

Computes:

dBeta/dT0 = * d_a1_d_T0/c*(1-eTheta**2)**0.5*cos(omega)

d_beta_d_par(par)

Derivative.

Computes:

beta = A1/c*(1-eTheta**2)**0.5*cos(omega)
eTheta = ecc+Dth  ??
dBeta/dA1 = 1.0/c*(1-eTheta**2)**0.5*cos(omega)
dBeta/dECC = A1/c*((-(e+dr)/sqrt(1-(e+dr)**2)*cos(omega)*de/dECC-
             (1-eTheta**2)**0.5*sin(omega)*domega/dECC
dBeta/dEDOT = A1/c*((-(e+dr)/sqrt(1-(e+dr)**2)*cos(omega)*de/dEDOT-
             (1-eTheta**2)**0.5*sin(omega)*domega/dEDOT
dBeta/dDth = A1/c*(-(e+dr)/sqrt(1-(e+dr)**2)*cos(omega)
Other parameters
dBeta/dPar = -A1/c*(1-eTheta**2)**0.5*sin(omega)*dOmega/dPar

d_binarydelay_d_par(par)

Get the binary delay derivatives respect to parameters.

Parameters:: par (str) – Parameter name.

d_delayA_d_par(par)

Derivative.

Computes:

aDelay = A0*(sin(omega+E)+e*sin(omega))+B0*(cos(omega+E)+e*cos(omega))
daDelay/dpar = daDelay/dA0*dA0/dPar+     (1)
               daDelay/dB0*dB0/dPar+     (2)
               daDelay/domega*domega/dPar+    (3)
               daDelay/dnu*dnu/dPar+        (4)
               daDelay/decc*decc/dPar        (5)

d_delayI_d_par(par): Derivative on delay inverse.

d_delayS_d_par(par)

Derivative.

Computes:

dsDelay/dPar = dsDelay/dTM2*dTM2/dPar+
               dsDelay/decc*decc/dPar+
               dsDelay/dE*dE/dPar+
               dsDelay/domega*domega/dPar+
               dsDelay/dSINI*dSINI/dPar

d_nhat_d_par(par)

Derivative.

Computes:

nhat = n/(1-ecc*cos(E))
n = 2*pi/PB # should here be M()?
dnhat = -2*pi*dPB/PB^2*(1-ecc*cos(E))
        -2*pi*(-cos(E)*decc+ecc*sin(E)*dE)/PB*(1-ecc*cos(E))^2
dnhat/dPar = -2*pi/(PB*(1-ecc*cos(E))*((dPB/dPar)/PB -
             (-cos(E)*decc/dPar+ecc*sin(E)*dE/dpar)/(1-e*cos(E)))

d_nu_d_ECC()

Analytic calculation.

dnu(e,E)/dECC = dnu/de*de/dECC+dnu/dE*dE/dECC de/dECC = 1 dnu/dPBDOT = dnu/dE*dE/dECC+dnu/de

d_nu_d_T0()

Analytic calculation.

dnu/dT0 = dnu/de*de/dT0+dnu/dE*dE/dT0 de/dT0 = -EDOT

d_nu_d_par(par)

derivative for nu respect to binary parameter.

Parameters:: par (string) – parameter name
Return type:: Derivative of nu respect to par

d_omega_d_OM(): dOmega/dOM = 1

d_omega_d_OMDOT()

Derivative.

Calculates:

dOmega/dOMDOT = 1/n*nu
n = 2*pi/PB
dOmega/dOMDOT = PB/2*pi*nu

d_omega_d_T0(): dOmega/dPB = dnu/dPB*k+dk/dPB*nu

d_omega_d_par(par)

derivative for omega respect to user input Parameter.

Calculates:

if par is not 'OM','OMDOT','PB'
dOmega/dPar =  k*dAe/dPar
k = OMDOT/n

Parameters:: par (string) – parameter name
Return type:: Derivative of omega respect to par

d_pb_d_par(par)

derivative for pbprime respect to binary parameter.

Parameters:: par (string) – parameter name
Return type:: Derivative of M respect to par

delayA()

Binary Aberration delay

Damour and N. Deruelle (1986) equation [27]

delayE()

Binary Einstein delay

Damour and N. Deruelle (1986) equation [25]

delayInverse()

DD model Inverse timing delay.

Damour and N. Deruelle (1986) equation [46-52]

This part is convert the delay argument from proper time to coordinate time. The Roemer delay and Einstein are included in the calculation. It uses there iterations to approximate the Roemer delay and Einstein delay.

T. Damour and N. Deruelle (1986) equation [43]. The equation [52] gives a taylor expansion of equation [43].

Computes:

u - e*sin(u) = n(t-T0)
nhat = du/dt
nhatp  = d^2u/dt^2
Drep = dDre/du
Drepp = d^2Dre/du^2
Dre(t-Dre(t-Dre(t)))  =  Dre(u) - Drep(u)*nhat*Dre(t-Dre(t))
                      =  Dre(u) - Drep(u)*nhat*(Dre(u)-Drep(u)*nhat*Dre(t))
                         + 1/2 (Drepp(u)*nhat^2 + Drep(u) * nhat * nhatp) * (Dre(t)-...)^2
                      = Dre(t)*(1 - nhat * Drep(u) + (nhat*Drep)^2 +
                        1/2*nhat^2* Dre*Drepp - 1/2*e*sin(u)/(1-e*cos(u)*nhat^2*Drep*Drep))

Here u is equivalent to E in the function.

delayR()

Roemer delay defined in T. Damour and N. Deruelle (1986)

Computes:

delayR = alpha*(cos(E)-er) + beta*sin(E)

delayS()

Binary shapiro delay

Damour and N. Deruelle (1986) equation [26]

ecc(): Calculate eccentricity with EDOT

get_tt0(barycentricTOA): tt0 = barycentricTOA - T0

nhat()

nhat defined as T. Damour and N. Deruelle (1986) equation [51]

Computes:

nhat = n/(1-ecc*cos(E))
n = 2*pi/PB # should here be M()

nu(): True anomaly (Ae)

omega()

Damour and N. Deruelle (1986) equation [25]

Calculates:

omega = OM+nu*k
k = OMDOT/n

(T. Damour and N. Deruelle (1986) equation between Eq 16 Eq 17)

prtl_der(y, x)

Find the partial derivatives in binary model pdy/pdx

Parameters:

y (str) – Name of variable to be differentiated
x (str) – Name of variable the derivative respect to

Returns:

The derivatives pdy/pdx

Return type:

np.array

set_param_values(valDict=None)

Set the parameters and assign values,

If the valDict is not provided, it will set parameter as default value

update_input(**updates): Update the toas and parameters.