Trajectory¤
This module implements functions for computing the trajectory of the source star
in the source plane. For now, only the annual parallax trajectory is implemented
(caustics.trajectory.AnnualParallaxTrajectory
).
Annual parallax¤
If one were to observe a source star from a barycentric frame of reference, in absence of acceleration of the source star (due to the source star being in a binary system), the apparent motion of the source star on the plane of the sky would be rectilinear. However, we do not observe the stars from a barycentric frame of reference, we observe them from a non-intertial geocentric frame (Earth). \emph{Annual parallax} is the apparent motion of star due to the Earth's motion around the Sun. It is important for longer timescale events when the event timescale is equal to some non-negligible fraction of the Earth's orbital period.
In a barycentric frame of reference we can write down the position of the source star \(\mathbf w_S(t)\) and the lens star \(\mathbf w_L(t)\) as
where \(\mu_S\) and \(\mu_L\) are the proper motion vectors of the source and lens stars, respectively and \(t_0\) is the time of closest approach of the source to the lens. The relative position vector with respect to the source in units of Einstein radii is
where \(\mathbf{w}_{L S, 0} \equiv \mathbf{w}_{L, 0}-\mathbf{w}_{S, 0}\) and \(\boldsymbol{\mu}_{L S} \equiv \boldsymbol{\mu}_L-\boldsymbol{\mu}_S\). When observing the source star from Earth, the from Earth the apparent position of the star is shifted by the position vector of the Sun relative to the Earth \(\mathbf s\) onto a Geocentric coordinate system on the plane of the sky which is defined at some reference time \(t_0^\prime\) by the unit vector \(\hat{\mathbf n}\) normal to the plane of the sky at the source star (a function of the celestial coordinates of the source star) and the unit vectors \(\hat{\mathbf e}_n\) and \(\hat{\mathbf e}_e\), pointing in the direction of the celestial north and east, respectively. The coordinate system is defined to be right-handed. The unit vectors \(\hat{\mathbf e}_n\) and \(\hat{\mathbf e}_e\) are thus
where \(\hat{\mathbf n}\) is the 3D unit vector pointing the direction of the source star
and \(\hat{\mathbf z}=(0,0,1)\). We can compute the 3D position vector of the Sun
\(\mathbf s(t)\) (and its time derivative) using the astropy
function
astropy.coordinates.get_body_barycentric_posvel
at arbitrary times \(t\) and obtain its projection on the plane of the sky by dotting it
into the unit vectors:
The sky positions of the source and lens stars in the geocentric frame of reference defined at time \(t_0^\prime\) are then given by
where \(\pi_S \equiv 1 \mathrm{au} / D_S\) is the source parallax and \(\pi_L \equiv 1 \mathrm{au} / D_L\) is the lens parallax. The relative separation vector is
where \(\pi_E\equiv \pi_{LS}/\theta_E\). Because parallax is usually a small effect, it makes sense to decompose the trajectory as a sum of rectilinear motion plus a deviation due to parallax (see An et al. 2002 for example). Mathematically,
It then follows that
where
is the position offset of the Sun on the plane of the sky relative to its position at the reference time \(t_0^\prime\). By construction, we have \(\delta\boldsymbol \zeta (t_0')=0\) and \(\delta\dot{\boldsymbol \zeta} (t_0')=0\). At the reference time \(t_0^\prime\), the vectors \(\mathbf{u}(t_0^\prime)\) and \(\dot{\mathbf u}(t_0^\prime)\) are perpendicular to each other.
To evaluate this expression for the trajectory we need to choose a coordinate system. A natural coordinate system for describing the trajectory of the source relative to the lens is one defined by unit vectors \((\mathbf{\hat e}_\bot,\mathbf{\hat e}_\parallel)\) where \(\mathbf{\hat e}_\parallel\) is parallel to the trajectory \(\mathbf{u}(t)\) at time \(t_0^\prime\). We define the unit vectors as
The coordinate system \((\mathbf{\hat e}_\bot,\mathbf{\hat e}_\parallel)\) is related to ecliptic coordinates by a simple rotation through an angle \(\psi\).
By construction, at time \(t_0^\prime\) we have \(\mathbf{u}_0\,\bot\,\dot{\mathbf{u}}_0\) and the two components of \(\mathbf{u}(t)\) are then
using the definitions of the unit vectors and \(\delta\boldsymbol \zeta(t)= \delta \zeta_e(t)\,\mathbf{\hat e}_e+\delta \zeta_n(t)\,\mathbf{\hat e}_n\), we obtain
where
The model parameters which determine the magnification \(A(t)\) are then \(\left(u_0,t_0^\prime,t'_E,\pi_E,\psi\right)\). Notice that \(u_0\) in this case can also be negative.
An alternative parametrization which is more commonly used in the literature is obtained by defining components of a ``microlensing parallax vector'' as
in which case we have
and the model parameters are \(\left(u_0,t_0^\prime,t_E^\prime,\pi_{E,E},\pi_{E,N}\right)\).
Finally, we can also write down the expression for the trajectory vector in equatorial coordinates by applying a rotation matrix to the above vector, the result is
This last expression is what is computed in the AnnualMicrolensingParallax
via the
compute()
method. One can either pass the parameters \(\pi_{E,E}\) and \(\pi_{E,N}\) or
the angle \(\psi\) and the magnitude \(\pi_E\). The vector
\((\delta\zeta_e(t), \delta\zeta_n(t))^\intercal\) is precomputed on a grid in time
which spans the time interval of the light curve with a timestep of 1 day. It is then
interpolated at arbitrary times when the compute()
method is called. This operation
is very cheap.
caustics.trajectory
¤
AnnualParallaxTrajectory
¤
Compute the trajectory of the source star on the plane of the sky while taking into account the annual parallax effect -- the fact that the apparent position of the source star on the plane of the sky is shifted by the projected position vector of the Sun relative to the Earth.
Example usage:
trajectory = AnnualParallaxTrajectory(t, coords)
w_points = trajectory.compute(t, t0=t0, tE=tE, u0=u0, piEE=piEE, piEN=piEN)
t = t
instance-attribute
¤
t_jpl = np.arange(t[0], t[-1] + 1, 1)
instance-attribute
¤
coords = coords
instance-attribute
¤
s_e = None
instance-attribute
¤
s_n = None
instance-attribute
¤
s_e_dot = None
instance-attribute
¤
s_n_dot = None
instance-attribute
¤
__init__(t, coords)
¤
Parameters:
Name | Type | Description | Default |
---|---|---|---|
t |
ndarray
|
Array containing the observation times in HJD format. |
required |
coords |
astropy.coordinates.SkyCoord
|
The coordinates of the source star. |
required |
compute(t, parametrization = 'cartesian', **params)
¤
Compute the trajectory of the source star in a Geocentric Equatorial coordinate system centered on the source star.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
t |
array_like
|
An array of times at which to evaluate the trajectory. |
required |
parametrization |
str
|
If "cartesian" |
'cartesian'
|
Returns:
Name | Type | Description |
---|---|---|
array_like | A complex array of shape (len(t),) where the real part is the East component and the imaginary part is the North component of the source trajectory in the source plane. |