pint.models.stand_alone_psr_binaries.ELL1_model.ELL1BaseModel

class pint.models.stand_alone_psr_binaries.ELL1_model.ELL1BaseModel

Bases: PSR_BINARY

This is a class for base ELL1 pulsar binary model.

ELL1 model is BT model in the small eccentricity case. The shapiro delay is computed differently by different subclass of ELL1Base.

Methods

Doppler()
Drep()	dDre/dPhi
Drepp()	d^2Dre/dPhi^2
E()	Eccentric Anomaly
ELL1_T0()
ELL1_ecc()
ELL1_om()
M()	Orbit phase.
P()
Phi()	Orbit phase in ELL1 model.
Pobs_designmatrix(params)
TM2()
a1()	ELL1 model a1 calculation.
add_binary_params(parameter, defaultValue[, ...])	Add one parameter to the binary class.
add_inter_vars(interVars)
binary_delay()	Returns total pulsar binary delay.
compute_eccentric_anomaly(eccentricity, ...)	Solve the Kepler Equation, E - e * sin(E) = M
d_Dre_d_par(par)	Derivative computation.
d_Drep_d_par(par)	Derivative computation.
d_Drepp_d_par(par)	Derivative computation
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_Phi_d_TASC()	dPhi/dTASC
d_Phi_d_par(par)	The derivative of Phi with respect to 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_binarydelay_d_par(par)	Get the binary delay derivatives respect to parameters.
d_d_delayR_dPhi_da1()	d (ELL1 Roemer delay)/dPhi in proper time divided by a1/c
d_dd_delayR_dPhi_da1()	d^2 (ELL1 Roemer delay)/dPhi^2 in proper time divided by a1/c
d_delayI_d_par(par)	Delay derivative.
d_delayR_da1()	ELL1 Roemer delay in proper time divided by a1/c, including third order corrections
d_ecc_d_ECC()
d_ecc_d_EDOT()
d_ecc_d_T0()
d_eps1_d_EPS1()
d_eps1_d_EPS1DOT()
d_eps1_d_TASC()
d_eps2_d_EPS2()
d_eps2_d_EPS2DOT()
d_eps2_d_TASC()
d_nhat_d_par(par)
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()	dOmega/dOMDOT = tt0
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.
delayI()	Inverse time delay formula.
delayR()	ELL1 Roemer delay in proper time.
delay_designmatrix(params)
ecc()	Calculate eccentricity with EDOT
eps1()
eps2()
get_tt0(barycentricTOA)	tt0 = barycentricTOA - T0
nhat()
nu()	True anomaly (Ae)
omega()
orbits()
orbits_ELL1()
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()
ttasc()	ttasc = t - TASC
update_input(**updates)	Update the toas and parameters.

Attributes

T0
t
tt0

ttasc()

ttasc = t - TASC

a1()

ELL1 model a1 calculation.

This method overrides the a1() method in pulsar_binary.py. Instead of tt0, it uses ttasc.

Phi()

Orbit phase in ELL1 model. Using TASC

d_Phi_d_TASC()

dPhi/dTASC

d_Phi_d_par(par)

The derivative of Phi with respect to parameter

Parameters:

par (string) – parameter name

Return type:

Derivative of Phi respect to par

delayI()

Inverse time delay formula.

The treatment is similar to the one in DD model (T. Damour & N. Deruelle (1986) equation [46-52]):

Dre = a1*(sin(Phi)+eps1/2*sin(2*Phi)+eps1/2*cos(2*Phi))
Drep = dDre/dt
Drepp = d^2 Dre/dt^2
nhat = dPhi/dt = 2pi/pb
nhatp = d^2Phi/dt^2 = 0
Dre(t-Dre(t-Dre(t)))  = Dre(Phi) - Drep(Phi)*nhat*Dre(t-Dre(t))
                      = Dre(Phi) - Drep(Phi)*nhat*(Dre(Phi)-Drep(Phi)*nhat*Dre(t))
                        + 1/2 (Drepp(u)*nhat^2 + Drep(u) * nhat * nhatp) * (Dre(t)-...)^2
                      = Dre(Phi)(1 - nhat*Drep(Phi) + (nhat*Drep(Phi))^2
                        + 1/2*nhat^2* Dre*Drepp)

d_delayI_d_par(par)

Delay derivative.

Computes:

delayI = Dre*(1 - nhat*Drep + (nhat*Drep)**2 + 1.0/2*nhat**2*Dre*Drepp)
d_delayI_d_par = d_delayI_d_Dre * d_Dre_d_par + d_delayI_d_Drep * d_Drep_d_par +
                 d_delayI_d_Drepp * d_Drepp_d_par + d_delayI_d_nhat * d_nhat_d_par

d_delayR_da1()

ELL1 Roemer delay in proper time divided by a1/c, including third order corrections

typo corrected from Zhu et al., following: https://github.com/nanograv/tempo/blob/master/src/bnryell1.f

d_d_delayR_dPhi_da1()

d (ELL1 Roemer delay)/dPhi in proper time divided by a1/c

d_dd_delayR_dPhi_da1()

d^2 (ELL1 Roemer delay)/dPhi^2 in proper time divided by a1/c

delayR()

ELL1 Roemer delay in proper time. Include terms up to third order in eccentricity Zhu et al. (2019), Eqn. 1 Fiore et al. (2023), Eqn. 4

d_Dre_d_par(par)

Derivative computation.

Computes:

Dre = delayR = a1/c.c*(sin(phi) - 0.5* eps1*cos(2*phi) +  0.5* eps2*sin(2*phi) + ...)
d_Dre_d_par = d_a1_d_par /c.c*(sin(phi) - 0.5* eps1*cos(2*phi) +  0.5* eps2*sin(2*phi)) +
              d_Dre_d_Phi * d_Phi_d_par + d_Dre_d_eps1*d_eps1_d_par + d_Dre_d_eps2*d_eps2_d_par

Drep()

dDre/dPhi

d_Drep_d_par(par)

Derivative computation.

Computes:

Drep = d_Dre_d_Phi = a1/c.c*(cos(Phi) + eps1 * sin(Phi) + eps2 * cos(Phi) + ...)
d_Drep_d_par = ...

Drepp()

d^2Dre/dPhi^2

d_Drepp_d_par(par)

Derivative computation

Computes:

Drepp = d_Drep_d_Phi = ...
d_Drepp_d_par = ...

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

dOmega/dOM = 1

d_omega_d_OMDOT()

dOmega/dOMDOT = tt0

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.

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

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.