pint.models.stand_alone_psr_binaries.ELL1H_model.ELL1Hmodel

class pint.models.stand_alone_psr_binaries.ELL1H_model.ELL1Hmodel

Bases: ELL1BaseModel

ELL1H pulsar binary model using H3, H4 or STIGMA as shapiro delay parameters.

Note

Based on Freire and Wex (2010)

The BinaryELL1H model parameterizes the Shapiro delay differently compare to the BinaryELL1 model. A fourier series expansion is used for the Shapiro delay:

\[\Delta_S = -2r \left( \frac{a_0}{2} + \Sum_k (a_k \cos k\phi + b_k \sin k \phi) \right)\]

The first two harmonics are generlly absorbed by the ELL1 Roemer delay. Thus, BinaryELL1H uses the series from the third harmonic and higher.

Notes

Default value in pint for NHARMS is 7, while in tempo2 it is 4.

References

• Freire and Wex (2010), MNRAS, 409, 199 [1]

[1]

https://ui.adsabs.harvard.edu/abs/2010MNRAS.409..199F/abstract

Methods

Doppler()
Drep()	dDre/dPhi
Drepp()	d^2Dre/dPhi^2
E()	Eccentric Anomaly
ELL1H_shapiro_delay_fourier_harms(...[, ...])	Fourier series harms of shapiro delay.
ELL1Hdelay()
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_ELL1H_fourier_harms_d_par(selected_harms, ...)	This is an overall derivative function.
d_ELL1Hdelay_d_par(par)
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_STIGMA_d_H3()
d_STIGMA_d_H4()
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_delayS3p_H3_STIGMA_approximate_d_H3(H3, stigma)	derivative of delayS3p_H3_STIGMA with respect to H3
d_delayS3p_H3_STIGMA_approximate_d_Phi(H3, ...)	derivative of delayS3p_H3_STIGMA with respect to Phi
d_delayS3p_H3_STIGMA_approximate_d_STIGMA(H3, ...)	derivative of delayS3p_H3_STIGMA with respect to STIGMA
d_delayS3p_H3_STIGMA_exact_d_H3(H3, stigma)	derivative of exact Shapiro delay (3rd hamonic and higher) with respect to H3
d_delayS3p_H3_STIGMA_exact_d_Phi(H3, stigma)	derivative of exact Shapiro delay (3rd hamonic and higher) with respect to phase
d_delayS3p_H3_STIGMA_exact_d_STIGMA(H3, stigma)	derivative of exact Shapiro delay (3rd hamonic and higher) with respect to STIGMA
d_delayS_H3_STIGMA_exact_d_H3(H3, stigma[, ...])
d_delayS_H3_STIGMA_exact_d_Phi(H3, stigma[, ...])
d_delayS_H3_STIGMA_exact_d_STIGMA(H3, stigma)
d_delayS_d_par(par)
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_fourier_component_d_phi(stigma, k[, ...])
d_fourier_component_d_stigma(stigma, k[, ...])	This is a method to compute the derivative of a fourier component.
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.
delayS()
delayS3p_H3_STIGMA_approximate(H3, stigma[, ...])	Shapiro delay using third or higher harmonics, appropriate for medium inclinations.
delayS3p_H3_STIGMA_exact(H3, stigma[, end_harm])	Shapiro delay (3rd hamonic and higher) using the exact form for very high inclinations.
delayS_H3_STIGMA_exact(H3, stigma[, end_harm])	Shapiro delay (including all harmonics) using the exact form for very high inclinations.
delay_designmatrix(params)
ecc()	Calculate eccentricity with EDOT
eps1()
eps2()
fourier_component(stigma, k[, factor_out_power])	Freire and Wex (2010), Eq (13)
get_SINI_from_H3_H4()
get_SINI_from_STIGMA()
get_TM2_from_H3_H4()
get_TM2_from_H3_STIGMA()
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

fourier_component(stigma, k, factor_out_power=0)

Freire and Wex (2010), Eq (13)

Parameters:

• stigma (float) – Orthometric ratio

• k (positive integer) – Order of harmonics.

• factor_out_power (int) – The power factor out from the coefficient. For example, when factor_out_power = 1, for k = 3. we have: (-1) ^ ((k+1)/2) * 2 / k * stigma ^ 2, the one extra stigma is factored out to other terms.

Returns:

The coefficient of fourier component and the basis.

Return type:

float

d_fourier_component_d_stigma(stigma, k, factor_out_power=0)

This is a method to compute the derivative of a fourier component.

ELL1H_shapiro_delay_fourier_harms(selected_harms, phi, stigma, factor_out_power=0)

Fourier series harms of shapiro delay.

One can select the start term and end term. Freire and Wex (2010), Eq. (10)

Parameters:

• selected_harms (numpy.array or list of positive integers) – The selected harms for fourier harms

• phi (float) – Orbit phase in ELL1 model

• stigma (float) –

Returns:

The summation of harmonics

Return type:

np.ndarray

d_ELL1H_fourier_harms_d_par(selected_harms, phi, stigma, par, factor_out_power=0)

This is an overall derivative function.

delayS3p_H3_STIGMA_approximate(H3, stigma, end_harm=6)

Shapiro delay using third or higher harmonics, appropriate for medium inclinations.

defined in Freire and Wex (2010), Eq (19).

d_delayS3p_H3_STIGMA_approximate_d_H3(H3, stigma, end_harm=6)

derivative of delayS3p_H3_STIGMA with respect to H3

d_delayS3p_H3_STIGMA_approximate_d_STIGMA(H3, stigma, end_harm=6)

derivative of delayS3p_H3_STIGMA with respect to STIGMA

d_delayS3p_H3_STIGMA_approximate_d_Phi(H3, stigma, end_harm=6)

derivative of delayS3p_H3_STIGMA with respect to Phi

delayS3p_H3_STIGMA_exact(H3, stigma, end_harm=None)

Shapiro delay (3rd hamonic and higher) using the exact form for very high inclinations.

Defined in Freire and Wex (2010), Eq (28).

d_delayS3p_H3_STIGMA_exact_d_H3(H3, stigma, end_harm=None)

derivative of exact Shapiro delay (3rd hamonic and higher) with respect to H3

d_delayS3p_H3_STIGMA_exact_d_STIGMA(H3, stigma, end_harm=None)

derivative of exact Shapiro delay (3rd hamonic and higher) with respect to STIGMA

d_delayS3p_H3_STIGMA_exact_d_Phi(H3, stigma, end_harm=None)

derivative of exact Shapiro delay (3rd hamonic and higher) with respect to phase

delayS_H3_STIGMA_exact(H3, stigma, end_harm=None)

Shapiro delay (including all harmonics) using the exact form for very high inclinations.

Defined in Freire and Wex (2010), Eq (29).

Drep()

dDre/dPhi

Drepp()

d^2Dre/dPhi^2

E()

Eccentric Anomaly

M()

Orbit phase.

Phi()

Orbit phase in ELL1 model. Using TASC

a1()

ELL1 model a1 calculation.

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

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

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

d_Drepp_d_par(par)

Derivative computation

Computes:

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

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

d_binarydelay_d_par(par)

Get the binary delay derivatives respect to parameters.

Parameters:

par (str) – Parameter name.

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.

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

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)

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

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

ttasc()

ttasc = t - TASC

update_input(**updates)

Update the toas and parameters.