pint.models.stand_alone_psr_binaries.DD_model.DDmodel

class pint.models.stand_alone_psr_binaries.DD_model.DDmodel(t=None, input_params=None)

Bases: PSR_BINARY

DD binary model.

This is a class independent from PINT platform for pulsar DD binary model. Reference: T. Damour and N. Deruelle (1986) It is a subclass of PSR_BINARY class defined in file binary_generic.py in the same directory. This class is designed for PINT platform but can be used as an independent module for binary delay calculation. To interact with PINT platform, a pulsar_binary wrapper is needed. See the source file pint/models/pulsar_binary_dd.py

Example

>>> import numpy as np
>>> t = np.linspace(54200.0,55000.0,800)
>>> binary_model = DDmodel()
>>> parameters_dict = {'A0':0.5,'ECC':0.01}
>>> binary_model.update_input(t, parameters_dict)

Here the binary has time input and parameters input, the delay can be calculated.

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_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/dPB*k+dk/dPB*nu
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

T0
k
t
tt0

omega()

20. 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)

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_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

alpha()

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

Computes:

alpha = A1/c*sin(omega)

d_alpha_d_par(par)

20. 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

beta()

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

Computes:

beta = A1/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_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_T0()

Derivative.

Computes:

dBeta/dT0 = * d_a1_d_T0/c*(1-eTheta**2)**0.5*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_DTH()

Derivative.

Computes:

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

delayR()

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

Computes:

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

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

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

Drep()

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

Computes:

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

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)

Drepp()

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

Computes:

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

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)

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()

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)))

delayInverse()

DD model Inverse timing delay.

20. 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.

d_delayI_d_par(par)

Derivative on delay inverse.

delayS()

Binary shapiro delay

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

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

delayE()

Binary Einstein delay

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

delayA()

Binary Aberration delay

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

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)

DDdelay()

Full DD model delay

d_DDdelay_d_par(par)

Full DD model delay derivative

E()

Eccentric Anomaly

M()

Orbit phase.

add_binary_params(parameter, defaultValue, unit=False)

Add one parameter to the binary class.

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_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_binarydelay_d_par(par)

Get the binary delay derivatives respect to parameters.

Parameters:

par (str) – Parameter name.

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_T0()

dOmega/dPB = dnu/dPB*k+dk/dPB*nu

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

ecc()

Calculate eccentricity with EDOT

get_tt0(barycentricTOA)

tt0 = barycentricTOA - T0

nu()

True anomaly (Ae)

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.