pint.models.stand_alone_psr_binaries.DDGR_model.DDGRmodel

class pint.models.stand_alone_psr_binaries.DDGR_model.DDGRmodel(t=None, input_params=None)[source]

Bases: DDmodel

Damour and Deruelle model assuming GR to be correct

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

MTOT

Total mass

XPBDOT

Excess PBDOT beyond what GR predicts

XOMDOT

Excess OMDOT beyond what GR predicts

It also reads but ignores:

SINI PBDOT OMDOT GAMMA DR DTH

Parameters supported:

Name / Aliases

Description

Kind

PB

Orbital period

d

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

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

MTOT

Total system mass in units of Solar mass

solMass

XOMDOT

Excess longitude of periastron advance compared to GR

deg / yr

XPBDOT

Excess Orbital period derivative respect to time compared to GR

number

MP

Pulsar mass

solMass

OMDOT

Rate of advance of periastron

deg / yr

SINI

Sine of inclination angle

number

PBDOT

Orbital period derivative respect to time

number

GAMMA

Time dilation & gravitational redshift

s

DR

Relativistic deformation of the orbit

number

DTH / DTHETA

Relativistic deformation of the orbit

number

References

  • Taylor and Weisberg (1989), ApJ, 345, 434 [tw89]

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

d_DR_d_MTOT()

d_DR_d_PB()

d_DR_d_par(par)

d_DTH_d_M2()

d_DTH_d_MTOT()

d_DTH_d_PB()

d_DTH_d_par(par)

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

Eccentric anomaly has MTOT dependence through PBDOT and Kepler's equation

d_E_d_T0()

Analytic derivative

d_E_d_par(par)

derivative for E respect to binary parameter.

d_GAMMA_d_ECC()

d_GAMMA_d_M2()

d_GAMMA_d_MTOT()

d_GAMMA_d_PB()

d_GAMMA_d_par(par)

d_M_d_par(par)

derivative for M respect to binary parameter.

d_OMDOT_d_par(par)

d_PBDOT_d_ECC()

d_PBDOT_d_M2()

d_PBDOT_d_MTOT()

d_PBDOT_d_PB()

d_PBDOT_d_XPBDOT()

d_PBDOT_d_par(par)

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

d_SINI_d_M2()

d_SINI_d_MTOT()

d_SINI_d_PB()

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)

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

d_arr_d_M2()

d_arr_d_MTOT()

d_arr_d_PB()

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

d_beta_d_MTOT()

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

d_eTheta_d_MTOT()

d_eTheta_d_par(par)

d_ecc_d_ECC()

d_ecc_d_EDOT()

d_ecc_d_T0()

d_er_d_DR()

d_er_d_M2()

d_er_d_MTOT()

d_er_d_par(par)

d_k_d_ECC()

d_k_d_M2()

d_k_d_MTOT()

d_k_d_PB()

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

True anomaly nu has MTOT dependence through PBDOT

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

d_omega_d_MTOT()

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

Derivative.

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

Longitude of periastron

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

A1

A1DOT

DR

DTH

ECC

EDOT

GAMMA

M2

MTOT

OMDOT

PB

PBDOT

SINI

T0

arr

fe

k

Precessing rate assuming GR

t

tt0

property k

Precessing rate assuming GR

Taylor and Weisberg (1989), Eqn. 16

omega()[source]

Longitude of periastron

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

Like DD model, but add in any excess OMDOT from the XOMDOT term

d_omega_d_par(par)[source]

derivative for omega respect to user input Parameter.

Calculates:

if par is not 'OM','XOMDOT','MTOT','M2'
dOmega/dPar =  k*dAe/dPar
k = OMDOT/n
Parameters:

par (string) – parameter name

Return type:

Derivative of omega respect to par

d_omega_d_XOMDOT()[source]

Derivative.

Calculates:

dOmega/dXOMDOT = 1/n*nu
n = 2*pi/PB
dOmega/dXOMDOT = PB/2*pi*nu
d_E_d_MTOT()[source]

Eccentric anomaly has MTOT dependence through PBDOT and Kepler’s equation

d_nu_d_MTOT()[source]

True anomaly nu has MTOT dependence through PBDOT

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)

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

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

delayE()

Binary Einstein delay

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

delayInverse()

DD model Inverse timing delay.

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

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

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.