use std::f64::consts::TAU;
use erfa::constants::{ERFA_CMPS, ERFA_DAU, ERFA_DAYSEC, ERFA_DJM0};
use hifitime::{Duration, Epoch};
use crate::{convention::UvwFrame, pal, HADec, RADec, XyzGeodetic};
#[derive(Debug, Clone, Copy)]
pub struct PrecessionInfo {
rotation_matrix: [[f64; 3]; 3],
pub hadec_j2000: HADec,
pub lmst: f64,
pub lmst_j2000: f64,
pub array_latitude_j2000: f64,
}
impl PrecessionInfo {
pub fn precess_xyz(&self, xyzs: &[XyzGeodetic]) -> Vec<XyzGeodetic> {
let (sep, cep) = self.lmst.sin_cos();
let (s2000, c2000) = self.lmst_j2000.sin_cos();
xyzs.iter()
.map(|xyz| {
let xpr = cep * xyz.x - sep * xyz.y;
let ypr = sep * xyz.x + cep * xyz.y;
let zpr = xyz.z;
let rmat = &self.rotation_matrix;
let xpr2 = (rmat[0][0]) * xpr + (rmat[0][1]) * ypr + (rmat[0][2]) * zpr;
let ypr2 = (rmat[1][0]) * xpr + (rmat[1][1]) * ypr + (rmat[1][2]) * zpr;
let zpr2 = (rmat[2][0]) * xpr + (rmat[2][1]) * ypr + (rmat[2][2]) * zpr;
XyzGeodetic {
x: c2000 * xpr2 + s2000 * ypr2,
y: -s2000 * xpr2 + c2000 * ypr2,
z: zpr2,
}
})
.collect()
}
#[deprecated = "use `PrecessionInfo::precess_xyz` instead"]
pub fn precess_xyz_parallel(&self, xyzs: &[XyzGeodetic]) -> Vec<XyzGeodetic> {
self.precess_xyz(xyzs)
}
}
pub fn get_lmst(array_longitude_rad: f64, time: Epoch, dut1: Duration) -> f64 {
let ut1 = (time + dut1).to_mjd_utc_days();
let gmst = pal::palGmst(ut1);
(gmst + array_longitude_rad) % TAU
}
pub fn get_last(array_longitude_rad: f64, time: Epoch, dut1: Duration) -> f64 {
let ut1 = (time + dut1).to_mjd_utc_days();
let tt = time.to_mjd_tt_days();
let gast = erfa::time::gst06a(ERFA_DJM0, ut1, ERFA_DJM0, tt);
(gast + array_longitude_rad).rem_euclid(TAU)
}
fn equation_of_the_equinoxes(time: Epoch, dut1: Duration) -> f64 {
let ut1 = (time + dut1).to_mjd_utc_days();
let tt = time.to_mjd_tt_days();
erfa::time::gst06a(ERFA_DJM0, ut1, ERFA_DJM0, tt)
- erfa::time::gmst06(ERFA_DJM0, ut1, ERFA_DJM0, tt)
}
pub fn precess_time(
array_longitude_rad: f64,
array_latitude_rad: f64,
phase_centre: RADec,
time: Epoch,
dut1: Duration,
) -> PrecessionInfo {
let lmst = get_lmst(array_longitude_rad, time, dut1);
let eqeq = equation_of_the_equinoxes(time, dut1);
let last = lmst + eqeq;
let j2000 = 2000.0;
let mjd = (time + dut1).to_mjd_utc_days();
let mut rotation_matrix = [[0.0; 3]; 3];
unsafe { pal::palPrenut(j2000, mjd, rotation_matrix.as_mut_ptr()) };
let mut rotation_matrix = {
let mut new = [[0.0; 3]; 3];
let old = rotation_matrix;
for (i, old) in old.iter().enumerate() {
for (j, new) in new.iter_mut().enumerate() {
new[i] = old[j];
}
}
new
};
let (lmst_j2000, array_latitude_j2000) =
rotate_radec(&mut rotation_matrix, last, array_latitude_rad);
let (s, c) = eqeq.sin_cos();
let eqeq_rotation = [[c, -s, 0.0], [s, c, 0.0], [0.0, 0.0, 1.0]];
let rotation_matrix = erfa::vectors_and_matrices::multiply_matrices(
deaberration(phase_centre, time),
erfa::vectors_and_matrices::multiply_matrices(rotation_matrix, eqeq_rotation),
);
PrecessionInfo {
rotation_matrix,
hadec_j2000: phase_centre.to_hadec(lmst_j2000),
lmst,
lmst_j2000,
array_latitude_j2000,
}
}
fn deaberration(phase_centre: RADec, time: Epoch) -> [[f64; 3]; 3] {
let tt = time.to_mjd_tt_days();
let (_, _, pvb) = erfa::earth::position_velocity_00(ERFA_DJM0, tt);
let v_over_c = pvb[1].map(|v| v * ERFA_DAU / ERFA_DAYSEC / ERFA_CMPS);
let p_cat = erfa::transform::spherical_to_cartesian(phase_centre.ra, phase_centre.dec);
let p_geo = deaberrate(p_cat, v_over_c);
rotation_taking(p_cat, p_geo)
}
pub fn precess_time_in_frame(
frame: UvwFrame,
array_longitude_rad: f64,
array_latitude_rad: f64,
phase_centre: RADec,
time: Epoch,
dut1: Duration,
) -> PrecessionInfo {
match frame {
UvwFrame::Hyperdrive => precess_time(
array_longitude_rad,
array_latitude_rad,
phase_centre,
time,
dut1,
),
UvwFrame::Casacore => precess_time_casacore(
array_longitude_rad,
array_latitude_rad,
phase_centre,
time,
dut1,
),
UvwFrame::Cotter => precess_time_cotter(
array_longitude_rad,
array_latitude_rad,
phase_centre,
time,
dut1,
),
UvwFrame::Oskar => {
let last = get_last(array_longitude_rad, time, dut1);
PrecessionInfo {
rotation_matrix: [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]],
hadec_j2000: phase_centre.to_hadec(last),
lmst: last,
lmst_j2000: last,
array_latitude_j2000: array_latitude_rad,
}
}
}
}
pub fn precess_time_cotter(
array_longitude_rad: f64,
array_latitude_rad: f64,
phase_centre: RADec,
time: Epoch,
dut1: Duration,
) -> PrecessionInfo {
let lmst = get_lmst(array_longitude_rad, time, dut1);
let j2000 = 2000.0;
let mjd = (time + dut1).to_mjd_utc_days();
let radec_aber = aber_radec_rad(j2000, mjd, phase_centre);
let mut rotation_matrix = [[0.0; 3]; 3];
unsafe { pal::palPrenut(j2000, mjd, rotation_matrix.as_mut_ptr()) };
let mut rotation_matrix = transpose(rotation_matrix);
let precessed = hadec_j2000(&mut rotation_matrix, lmst, array_latitude_rad, radec_aber);
PrecessionInfo {
rotation_matrix,
hadec_j2000: precessed.hadec,
lmst,
lmst_j2000: precessed.lmst,
array_latitude_j2000: precessed.latitude,
}
}
fn aber_radec_rad(eq: f64, mjd: f64, radec: RADec) -> RADec {
let mut v1 = [0.0; 3];
let mut v2 = [0.0; 3];
unsafe {
pal::palDcs2c(radec.ra, radec.dec, v1.as_mut_ptr());
stelaber(eq, mjd, &mut v1, &mut v2);
let mut ra2 = 0.0;
let mut dec2 = 0.0;
pal::palDcc2s(v2.as_mut_ptr(), &mut ra2, &mut dec2);
ra2 = pal::palDranrm(ra2);
RADec::from_radians(ra2, dec2)
}
}
fn stelaber(eq: f64, mjd: f64, v1: &mut [f64; 3], v2: &mut [f64; 3]) {
let mut amprms = [0.0; 21];
let mut v1n = [0.0; 3];
let mut v2un = [0.0; 3];
let mut abv = [0.0; 3];
unsafe {
pal::palMappa(eq, mjd, amprms.as_mut_ptr());
let ab1 = &rms[11];
abv[0] = amprms[8];
abv[1] = amprms[9];
abv[2] = amprms[10];
let mut w = 0.0;
pal::palDvn(v1.as_mut_ptr(), v1n.as_mut_ptr(), &mut w);
let p1dv = pal::palDvdv(v1n.as_mut_ptr(), abv.as_mut_ptr());
w = 1.0 + p1dv / (ab1 + 1.0);
v2un[0] = ab1 * v1n[0] + w * abv[0];
v2un[1] = ab1 * v1n[1] + w * abv[1];
v2un[2] = ab1 * v1n[2] + w * abv[2];
pal::palDvn(v2un.as_mut_ptr(), v2.as_mut_ptr(), &mut w);
}
}
struct HADecJ2000 {
hadec: HADec,
latitude: f64,
lmst: f64,
}
fn hadec_j2000(
rotation_matrix: &mut [[f64; 3]; 3],
lmst: f64,
lat_rad: f64,
radec: RADec,
) -> HADecJ2000 {
let (new_lmst, new_lat) = rotate_radec(rotation_matrix, lmst, lat_rad);
HADecJ2000 {
hadec: HADec::from_radians(pal::palDranrm(new_lmst - radec.ra), radec.dec),
latitude: new_lat,
lmst: new_lmst,
}
}
pub fn precess_time_casacore(
array_longitude_rad: f64,
array_latitude_rad: f64,
phase_centre: RADec,
time: Epoch,
dut1: Duration,
) -> PrecessionInfo {
let tt = time.to_mjd_tt_days();
let last = get_last(array_longitude_rad, time, dut1);
let to_j2000 = transpose(erfa::prenut::pn_matrix_06a(ERFA_DJM0, tt));
let mut zenith_rotation = to_j2000;
let (lmst_j2000, array_latitude_j2000) =
rotate_radec(&mut zenith_rotation, last, array_latitude_rad);
let aberration = deaberration(phase_centre, time);
let rotation_matrix = erfa::vectors_and_matrices::multiply_matrices(aberration, to_j2000)
.map(|row| row.map(|e| -e));
PrecessionInfo {
rotation_matrix,
hadec_j2000: phase_centre.to_hadec(lmst_j2000),
lmst: last,
lmst_j2000,
array_latitude_j2000,
}
}
fn aberrate(p: [f64; 3], v: [f64; 3]) -> [f64; 3] {
let g1 = (1.0 - dot(v, v)).sqrt();
let g2 = dot(p, v);
let a = (g1 - 1.0 - g2) / (1.0 + g2);
let b = (1.0 + g2 / (1.0 + g1)) / (1.0 + g2);
normalise([
p[0] + a * p[0] + b * v[0],
p[1] + a * p[1] + b * v[1],
p[2] + a * p[2] + b * v[2],
])
}
fn deaberrate(p_app: [f64; 3], v: [f64; 3]) -> [f64; 3] {
let mut p = normalise([p_app[0] - v[0], p_app[1] - v[1], p_app[2] - v[2]]);
for _ in 0..50 {
let q = aberrate(p, v);
let delta = [q[0] - p_app[0], q[1] - p_app[1], q[2] - p_app[2]];
if delta.iter().all(|d| d.abs() < 1e-14) {
break;
}
p = normalise([p[0] - delta[0], p[1] - delta[1], p[2] - delta[2]]);
}
p
}
fn rotation_taking(a: [f64; 3], b: [f64; 3]) -> [[f64; 3]; 3] {
let axis = [
a[1] * b[2] - a[2] * b[1],
a[2] * b[0] - a[0] * b[2],
a[0] * b[1] - a[1] * b[0],
];
let s = dot(axis, axis).sqrt();
let c = dot(a, b);
let mut r = [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]];
if s < 1e-18 {
return r;
}
let k = [axis[0] / s, axis[1] / s, axis[2] / s];
let kx = [[0.0, -k[2], k[1]], [k[2], 0.0, -k[0]], [-k[1], k[0], 0.0]];
let kx2 = erfa::vectors_and_matrices::multiply_matrices(kx, kx);
for (i, row) in r.iter_mut().enumerate() {
for (j, e) in row.iter_mut().enumerate() {
*e += s * kx[i][j] + (1.0 - c) * kx2[i][j];
}
}
r
}
fn transpose(m: [[f64; 3]; 3]) -> [[f64; 3]; 3] {
let mut t = [[0.0; 3]; 3];
for (i, row) in m.iter().enumerate() {
for (j, e) in row.iter().enumerate() {
t[j][i] = *e;
}
}
t
}
fn dot(a: [f64; 3], b: [f64; 3]) -> f64 {
a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
}
fn normalise(v: [f64; 3]) -> [f64; 3] {
let n = dot(v, v).sqrt();
[v[0] / n, v[1] / n, v[2] / n]
}
fn rotate_radec(rotation_matrix: &mut [[f64; 3]; 3], ra: f64, dec: f64) -> (f64, f64) {
let mut v1 = [0.0; 3];
let mut v2 = [0.0; 3];
unsafe {
pal::palDcs2c(ra, dec, v1.as_mut_ptr());
pal::palDmxv(
rotation_matrix.as_mut_ptr(),
v1.as_mut_ptr(),
v2.as_mut_ptr(),
);
let mut ra2 = 0.0;
let mut dec2 = 0.0;
pal::palDcc2s(v2.as_mut_ptr(), &mut ra2, &mut dec2);
ra2 = pal::palDranrm(ra2);
(ra2, dec2)
}
}
#[cfg(test)]
mod tests {
use approx::{assert_abs_diff_eq, assert_abs_diff_ne};
use std::str::FromStr;
use super::*;
use crate::constants::{MWA_LAT_RAD, MWA_LONG_RAD};
const ITRF: [[f64; 3]; 4] = [
[3825505.749148041, 460929.50837565673, 5065711.816207074],
[3826864.998909839, 462413.2298572394, 5064554.645748515],
[3826675.9506614394, 462024.98904948845, 5064729.318786148],
[3826143.3875317494, 459543.0372013342, 5065350.071420448],
];
const PHASE_CENTRE_RAD: (f64, f64) = (3.1503192998497647, 0.788888821901437);
const GPS_TIMES: [f64; 2] = [1394532020.0, 1394532036.0];
const DUT1: f64 = -0.00913543626666069;
const CASACORE_UVWS: [(usize, usize, usize, [f64; 3]); 12] = [
(
0,
0,
1,
[-356.32614760098073, 584.5534686278635, -2217.96342144549],
),
(
0,
0,
2,
[-162.09543607335297, 434.92894640284055, -1821.8980630127026],
),
(
0,
0,
3,
[1489.3081452906438, -491.1982519522817, -20.732629029234147],
),
(
0,
1,
2,
[194.23071152762782, -149.62452222502256, 396.06535843278766],
),
(
0,
1,
3,
[1845.6342928916245, -1075.751720580145, 2197.230792416257],
),
(
0,
2,
3,
[1651.4035813639957, -926.1271983551219, 1801.1654339834677],
),
(
1,
0,
1,
[-358.63650557936217, 584.257998403976, -2217.6688815479215],
),
(
1,
0,
2,
[-163.9559537541119, 434.7941209749316, -1821.7637575763079],
),
(
1,
0,
3,
[1489.6957396031169, -489.9680348492685, -21.96006581880269],
),
(
1,
1,
2,
[194.6805518252503, -149.4638774290441, 395.9051239716141],
),
(
1,
1,
3,
[1848.3322451824788, -1074.2260332532444, 2195.70881572912],
),
(
1,
2,
3,
[1653.6516933572284, -924.7621558242004, 1799.8036917575055],
),
];
fn worst_uvw_error(frame: UvwFrame) -> f64 {
use crate::{pos::xyz::xyzs_to_cross_uvws, XyzGeocentric};
let centre = XyzGeocentric {
x: ITRF.iter().map(|p| p[0]).sum::<f64>() / 4.0,
y: ITRF.iter().map(|p| p[1]).sum::<f64>() / 4.0,
z: ITRF.iter().map(|p| p[2]).sum::<f64>() / 4.0,
};
let array_pos = centre.to_earth_wgs84();
let xyzs: Vec<XyzGeodetic> = ITRF
.iter()
.map(|p| {
XyzGeocentric {
x: p[0],
y: p[1],
z: p[2],
}
.to_geodetic(array_pos)
})
.collect();
let phase_centre = RADec::from_radians(PHASE_CENTRE_RAD.0, PHASE_CENTRE_RAD.1);
let sign = frame.baseline_sign() * UvwFrame::Casacore.baseline_sign();
let mut worst: f64 = 0.0;
for (i_time, gps) in GPS_TIMES.iter().enumerate() {
let p = precess_time_in_frame(
frame,
array_pos.longitude_rad,
array_pos.latitude_rad,
phase_centre,
Epoch::from_gpst_seconds(*gps),
Duration::from_seconds(DUT1),
);
let uvws =
xyzs_to_cross_uvws(&p.precess_xyz(&xyzs), phase_centre.to_hadec(p.lmst_j2000));
let mut i_bl = 0;
for a1 in 0..4 {
for a2 in a1 + 1..4 {
let expected = CASACORE_UVWS
.iter()
.find(|(t, x, y, _)| *t == i_time && *x == a1 && *y == a2)
.unwrap()
.3;
let got = uvws[i_bl];
worst = worst
.max((sign * got.u - expected[0]).abs())
.max((sign * got.v - expected[1]).abs())
.max((sign * got.w - expected[2]).abs());
i_bl += 1;
}
}
}
worst
}
#[test]
fn casacore_frame_matches_casacore_uvws() {
let casacore = worst_uvw_error(UvwFrame::Casacore);
let hyperdrive = worst_uvw_error(UvwFrame::Hyperdrive);
assert!(casacore < 0.01, "casacore frame off by {casacore} m");
assert!(hyperdrive < 0.01, "hyperdrive frame off by {hyperdrive} m");
}
#[test]
fn oskar_frame_is_unprecessed_with_apparent_sidereal_time() {
let t = Epoch::from_gpst_seconds(1394532020.0);
let pc = RADec::from_degrees(180.5, 45.2);
let xyzs = [XyzGeodetic {
x: 100.0,
y: 200.0,
z: 300.0,
}];
let p = precess_time_in_frame(UvwFrame::Oskar, 0.12, 0.92, pc, t, Duration::default());
assert_abs_diff_eq!(p.lmst, get_last(0.12, t, Duration::default()));
assert_abs_diff_eq!(p.lmst_j2000, p.lmst);
assert_abs_diff_eq!(p.array_latitude_j2000, 0.92);
let out = p.precess_xyz(&xyzs);
assert_abs_diff_eq!(out[0].x, 100.0, epsilon = 1e-9);
assert_abs_diff_eq!(out[0].y, 200.0, epsilon = 1e-9);
assert_abs_diff_eq!(out[0].z, 300.0, epsilon = 1e-9);
}
#[test]
fn last_differs_from_lmst_by_the_equation_of_the_equinoxes() {
let t = Epoch::from_gpst_seconds(1394532020.0);
let diff = get_last(0.0, t, Duration::default()) - get_lmst(0.0, t, Duration::default());
assert!(
diff.abs() < 100.0 / 206265.0 && diff.abs() > 0.1 / 206265.0,
"{diff}"
);
}
#[test]
fn aberration_round_trip() {
let v = [1e-4, -5e-5, 2e-5];
let p = normalise([0.3, -0.5, 0.8]);
let q = aberrate(p, v);
let back = deaberrate(q, v);
for i in 0..3 {
assert_abs_diff_eq!(back[i], p[i], epsilon = 1e-13);
}
let moved = erfa::vectors_and_matrices::mat_mul_pvec(rotation_taking(p, q), p);
for i in 0..3 {
assert_abs_diff_eq!(moved[i], q[i], epsilon = 1e-13);
}
}
#[test]
fn uvws_are_projected_onto_the_catalogue_phase_centre() {
use crate::pos::xyz::xyzs_to_cross_uvws;
let phase_centre = RADec::from_degrees(0.0, -27.0);
let time = Epoch::from_gpst_seconds(1254670392.0);
let p = precess_time(
MWA_LONG_RAD,
MWA_LAT_RAD,
phase_centre,
time,
Duration::default(),
);
let pc_hadec = phase_centre.to_hadec(p.lmst_j2000);
assert_abs_diff_eq!(p.hadec_j2000.ha, pc_hadec.ha);
assert_abs_diff_eq!(p.hadec_j2000.dec, pc_hadec.dec);
let cotter = PrecessionInfo {
rotation_matrix: erfa::vectors_and_matrices::multiply_matrices(
transpose(deaberration(phase_centre, time)),
p.rotation_matrix,
),
..p
};
let (_, _, pvb) = erfa::earth::position_velocity_00(ERFA_DJM0, time.to_mjd_tt_days());
let v = pvb[1].map(|v| v * ERFA_DAU / ERFA_DAYSEC / ERFA_CMPS);
let (ra_aber, dec_aber) = erfa::transform::cartesian_to_spherical(aberrate(
erfa::transform::spherical_to_cartesian(phase_centre.ra, phase_centre.dec),
v,
));
let cotter_hadec = HADec::from_radians(p.lmst_j2000 - ra_aber, dec_aber);
let xyzs = [
XyzGeodetic::default(),
XyzGeodetic {
x: 3000.0,
y: 0.0,
z: 0.0,
},
XyzGeodetic {
x: 0.0,
y: 3000.0,
z: 0.0,
},
XyzGeodetic {
x: 0.0,
y: 0.0,
z: 3000.0,
},
XyzGeodetic {
x: 1500.0,
y: -2000.0,
z: 800.0,
},
];
let new = xyzs_to_cross_uvws(&p.precess_xyz(&xyzs), p.hadec_j2000);
let old = xyzs_to_cross_uvws(&cotter.precess_xyz(&xyzs), cotter_hadec);
let d_ra = (ra_aber - phase_centre.ra + std::f64::consts::PI).rem_euclid(TAU)
- std::f64::consts::PI;
let expected_roll = d_ra * phase_centre.dec.sin();
assert!(expected_roll.abs().to_degrees() * 3600.0 > 5.0);
for (n, o) in new.iter().zip(old.iter()) {
assert_abs_diff_eq!(n.w, o.w, epsilon = 1e-4);
assert_abs_diff_eq!(n.u.hypot(n.v), o.u.hypot(o.v), epsilon = 1e-4);
let roll = (o.u * n.v - o.v * n.u).atan2(o.u * n.u + o.v * n.v);
assert_abs_diff_eq!(roll, expected_roll, epsilon = 0.02 * expected_roll.abs());
}
}
const CALC_ITRF: [[f64; 3]; 4] = [
[-2559454.0790495784, 5095372.143311582, -2849057.185786278],
[-2562134.8794759056, 5094025.551660707, -2849057.185786278],
[-2560059.1979564168, 5096576.81662318, -2846377.149719187],
[-2588279.1463356433, 5085921.804508169, -2840123.732229308],
];
const CALC_GPS_TIMES: [f64; 2] = [1254670338.0, 1254670578.0];
const CALC_UVWS: [(usize, usize, usize, [f64; 3]); 12] = [
(
0,
0,
1,
[2975.2923784119776, -174.31783798732067, -343.5356172900647],
),
(
0,
0,
2,
[173.1940623857081, 2995.060250000395, -19.76255600526929],
),
(
0,
0,
3,
[30330.23786973243, 8240.354734546112, -3501.2349972864613],
),
(
0,
1,
2,
[-2802.0983160262695, 3169.378087987716, 323.7730612847954],
),
(
0,
1,
3,
[27354.945491320454, 8414.672572533433, -3157.6993799963966],
),
(
0,
2,
3,
[30157.043807346723, 5245.294484545717, -3481.472441281192],
),
(
1,
0,
1,
[2968.095101361163, -197.84090606482278, -389.91919966600835],
),
(
1,
0,
2,
[196.56548183760606, 2993.5968511652736, -22.64675517939031],
),
(
1,
0,
3,
[30336.169577636523, 8000.246257009172, -3974.684804080054],
),
(
1,
1,
2,
[-2771.529619523557, 3191.4377572300964, 367.27244448661804],
),
(
1,
1,
3,
[27368.07447627536, 8198.087163073995, -3584.765604414046],
),
(
1,
2,
3,
[30139.604095798917, 5006.649405843898, -3952.038048900664],
),
];
#[test]
fn uvws_match_calc() {
use crate::{pos::xyz::xyzs_to_cross_uvws, XyzGeocentric};
let centre = XyzGeocentric {
x: CALC_ITRF.iter().map(|p| p[0]).sum::<f64>() / 4.0,
y: CALC_ITRF.iter().map(|p| p[1]).sum::<f64>() / 4.0,
z: CALC_ITRF.iter().map(|p| p[2]).sum::<f64>() / 4.0,
};
let array_pos = centre.to_earth_wgs84();
let xyzs: Vec<XyzGeodetic> = CALC_ITRF
.iter()
.map(|p| {
XyzGeocentric {
x: p[0],
y: p[1],
z: p[2],
}
.to_geodetic(array_pos)
})
.collect();
let phase_centre = RADec::from_degrees(0.0, -27.0);
for (i_time, gps) in CALC_GPS_TIMES.iter().enumerate() {
let time = Epoch::from_gpst_seconds(*gps);
let p = precess_time(
array_pos.longitude_rad,
array_pos.latitude_rad,
phase_centre,
time,
Duration::from_seconds(-0.151522),
);
let uvws = xyzs_to_cross_uvws(&p.precess_xyz(&xyzs), p.hadec_j2000);
let (_, _, pvb) = erfa::earth::position_velocity_00(ERFA_DJM0, time.to_mjd_tt_days());
let v = pvb[1].map(|v| v * ERFA_DAU / ERFA_DAYSEC / ERFA_CMPS);
let s = erfa::transform::spherical_to_cartesian(phase_centre.ra, phase_centre.dec);
let scale = 1.0 - dot(v, s);
let mut i_bl = 0;
for a1 in 0..4 {
for a2 in a1 + 1..4 {
let expected = CALC_UVWS
.iter()
.find(|(t, x, y, _)| *t == i_time && *x == a1 && *y == a2)
.unwrap()
.3;
let got = uvws[i_bl] * -1.0;
let km = (expected[0].powi(2) + expected[1].powi(2) + expected[2].powi(2))
.sqrt()
/ 1e3;
let duv = (scale * got.u - expected[0]).hypot(scale * got.v - expected[1]);
assert!(duv < 2e-3 * km, "baseline {a1}-{a2}: uv off by {duv} m");
let dw = (got.w - expected[2]).abs();
assert!(dw < 4e-3 * km, "baseline {a1}-{a2}: w off by {dw} m");
i_bl += 1;
}
}
}
}
#[test]
fn test_get_lst() {
let epoch = Epoch::from_gpst_seconds(1090008642.0);
let dut1 = Duration::from_seconds(-0.31295757);
assert_abs_diff_eq!(
get_lmst(MWA_LONG_RAD, epoch, dut1),
6.262065126600022,
epsilon = 1e-9
);
let epoch = Epoch::from_gpst_seconds(1090008643.0);
let dut1 = Duration::from_seconds(-0.31295757);
assert_abs_diff_eq!(
get_lmst(MWA_LONG_RAD, epoch, dut1),
6.26213804775838,
epsilon = 1e-9
);
let epoch = Epoch::from_gpst_seconds(1090008647.0);
let dut1 = Duration::from_seconds(-0.31295758);
assert_abs_diff_eq!(
get_lmst(MWA_LONG_RAD, epoch, dut1),
6.262429732391841,
epsilon = 1e-9
);
let epoch = Epoch::from_gpst_seconds(1090008644.0);
let dut1 = Duration::from_seconds(-0.31295757);
assert_abs_diff_eq!(
get_lmst(MWA_LONG_RAD, epoch, dut1),
6.262210968916753,
epsilon = 1e-9
);
}
#[test]
fn test_get_last() {
for (gps, dut1, expected) in [
(1090008642.0, -0.31295757, 6.262100753245431),
(1196175296.0, 0.2478, 0.8898287888471533),
(1320409688.0, -0.1, 6.135556501912982),
] {
let epoch = Epoch::from_gpst_seconds(gps);
let dut1 = Duration::from_seconds(dut1);
let last = get_last(MWA_LONG_RAD, epoch, dut1);
assert_abs_diff_eq!(last, expected, epsilon = 1e-8);
let eqeq = last - get_lmst(MWA_LONG_RAD, epoch, dut1);
assert!(eqeq.abs() < 1e-4, "{eqeq}");
}
}
fn precession_matrix(p: &PrecessionInfo, phase_centre: RADec, time: Epoch) -> [[f64; 3]; 3] {
erfa::vectors_and_matrices::multiply_matrices(
transpose(deaberration(phase_centre, time)),
p.rotation_matrix,
)
}
#[test]
#[allow(clippy::cognitive_complexity)]
fn test_no_precession_at_j2000() {
let j2000_epoch = Epoch::from_str("2000-01-01T11:58:55.816 UTC").unwrap();
let phase_centre = RADec::from_degrees(0.0, -27.0);
let eor0 = precess_time(
MWA_LONG_RAD,
MWA_LAT_RAD,
phase_centre,
j2000_epoch,
Duration::from_total_nanoseconds(0),
);
let rm0 = precession_matrix(&eor0, phase_centre, j2000_epoch);
assert_abs_diff_eq!(rm0[0][0], 1.0, epsilon = 1e-8);
assert_abs_diff_eq!(rm0[1][1], 1.0, epsilon = 1e-8);
assert_abs_diff_eq!(rm0[2][2], 1.0, epsilon = 1e-8);
assert_abs_diff_eq!(rm0[0][1], 0.0, epsilon = 7e-5);
assert_abs_diff_eq!(rm0[0][2], 0.0, epsilon = 3e-5);
assert_abs_diff_eq!(rm0[1][0], 0.0, epsilon = 7e-5);
assert_abs_diff_eq!(rm0[1][2], 0.0, epsilon = 3e-5);
assert_abs_diff_eq!(rm0[2][0], 0.0, epsilon = 3e-5);
assert_abs_diff_eq!(rm0[2][1], 0.0, epsilon = 3e-5);
assert_abs_diff_eq!(eor0.lmst_j2000 - eor0.hadec_j2000.ha, 0.0, epsilon = 1e-4);
assert_abs_diff_eq!(eor0.array_latitude_j2000, MWA_LAT_RAD, epsilon = 1e-4);
assert_abs_diff_eq!(eor0.lmst, eor0.lmst_j2000, epsilon = 1e-4);
assert_abs_diff_eq!(eor0.lmst, 0.6433259676052971, epsilon = 1e-4);
let phase_centre = RADec::from_degrees(60.0, -30.0);
let eor1 = precess_time(
MWA_LONG_RAD,
MWA_LAT_RAD,
phase_centre,
j2000_epoch,
Duration::from_total_nanoseconds(0),
);
let rm1 = precession_matrix(&eor1, phase_centre, j2000_epoch);
assert_abs_diff_eq!(rm1[0][0], 1.0, epsilon = 1e-8);
assert_abs_diff_eq!(rm1[1][1], 1.0, epsilon = 1e-8);
assert_abs_diff_eq!(rm1[2][2], 1.0, epsilon = 1e-8);
assert_abs_diff_eq!(rm1[0][1], 0.0, epsilon = 7e-5);
assert_abs_diff_eq!(rm1[0][2], 0.0, epsilon = 3e-5);
assert_abs_diff_eq!(rm1[1][0], 0.0, epsilon = 7e-5);
assert_abs_diff_eq!(rm1[1][2], 0.0, epsilon = 3e-5);
assert_abs_diff_eq!(rm1[2][0], 0.0, epsilon = 3e-5);
assert_abs_diff_eq!(rm1[2][1], 0.0, epsilon = 3e-5);
assert_abs_diff_eq!(
eor1.lmst_j2000 - eor1.hadec_j2000.ha,
1.0471975511965976,
epsilon = 1e-4
);
assert_abs_diff_eq!(eor1.array_latitude_j2000, MWA_LAT_RAD, epsilon = 1e-4);
assert_abs_diff_eq!(eor1.lmst, eor1.lmst_j2000, epsilon = 1e-4);
assert_abs_diff_eq!(eor1.lmst, 0.6433259676052971, epsilon = 1e-4);
}
#[test]
#[allow(clippy::cognitive_complexity)]
fn test_no_precession_at_j2000_with_dut1() {
let j2000_epoch = Epoch::from_str("2000-01-01T11:58:55.816 UTC").unwrap();
let phase_centre = RADec::from_degrees(0.0, -27.0);
let eor0 = precess_time(
MWA_LONG_RAD,
MWA_LAT_RAD,
phase_centre,
j2000_epoch,
Duration::from_seconds(0.35494706),
);
let rm0 = precession_matrix(&eor0, phase_centre, j2000_epoch);
assert_abs_diff_eq!(rm0[0][0], 1.0, epsilon = 1e-8);
assert_abs_diff_eq!(rm0[1][1], 1.0, epsilon = 1e-8);
assert_abs_diff_eq!(rm0[2][2], 1.0, epsilon = 1e-8);
assert_abs_diff_eq!(rm0[0][1], 0.0, epsilon = 7e-5);
assert_abs_diff_eq!(rm0[0][2], 0.0, epsilon = 3e-5);
assert_abs_diff_eq!(rm0[1][0], 0.0, epsilon = 7e-5);
assert_abs_diff_eq!(rm0[1][2], 0.0, epsilon = 3e-5);
assert_abs_diff_eq!(rm0[2][0], 0.0, epsilon = 3e-5);
assert_abs_diff_eq!(rm0[2][1], 0.0, epsilon = 3e-5);
assert_abs_diff_eq!(eor0.lmst_j2000 - eor0.hadec_j2000.ha, 0.0, epsilon = 1e-4);
assert_abs_diff_eq!(eor0.array_latitude_j2000, MWA_LAT_RAD, epsilon = 1e-4);
assert_abs_diff_eq!(eor0.lmst, eor0.lmst_j2000, epsilon = 1e-4);
assert_abs_diff_eq!(eor0.lmst, 0.6433259676052971, epsilon = 1e-4);
let phase_centre = RADec::from_degrees(60.0, -30.0);
let eor1 = precess_time(
MWA_LONG_RAD,
MWA_LAT_RAD,
phase_centre,
j2000_epoch,
Duration::from_seconds(0.35494706),
);
let rm1 = precession_matrix(&eor1, phase_centre, j2000_epoch);
assert_abs_diff_eq!(rm1[0][0], 1.0, epsilon = 1e-8);
assert_abs_diff_eq!(rm1[1][1], 1.0, epsilon = 1e-8);
assert_abs_diff_eq!(rm1[2][2], 1.0, epsilon = 1e-8);
assert_abs_diff_eq!(rm1[0][1], 0.0, epsilon = 7e-5);
assert_abs_diff_eq!(rm1[0][2], 0.0, epsilon = 3e-5);
assert_abs_diff_eq!(rm1[1][0], 0.0, epsilon = 7e-5);
assert_abs_diff_eq!(rm1[1][2], 0.0, epsilon = 3e-5);
assert_abs_diff_eq!(rm1[2][0], 0.0, epsilon = 3e-5);
assert_abs_diff_eq!(rm1[2][1], 0.0, epsilon = 3e-5);
assert_abs_diff_eq!(
eor1.lmst_j2000 - eor1.hadec_j2000.ha,
1.0471975511965976,
epsilon = 1e-4
);
assert_abs_diff_eq!(eor1.array_latitude_j2000, MWA_LAT_RAD, epsilon = 1e-4);
assert_abs_diff_eq!(eor1.lmst, eor1.lmst_j2000, epsilon = 1e-4);
assert_abs_diff_eq!(eor1.lmst, 0.6433259676052971, epsilon = 1e-4);
}
#[test]
fn test_precess_1065880128_to_j2000() {
let epoch = Epoch::from_gpst_seconds(1065880128.0);
let phase_centre = RADec::from_degrees(0.0, -27.0);
let p = precess_time(
MWA_LONG_RAD,
MWA_LAT_RAD,
phase_centre,
epoch,
Duration::from_total_nanoseconds(0),
);
let rm = precession_matrix(&p, phase_centre, epoch);
assert_abs_diff_eq!(rm[0][0], 1.0, epsilon = 1e-5);
assert_abs_diff_eq!(rm[1][1], 1.0, epsilon = 1e-5);
assert_abs_diff_eq!(rm[2][2], 1.0, epsilon = 1e-5);
assert_abs_diff_ne!(rm[0][1], 0.0, epsilon = 1e-5);
assert_abs_diff_ne!(rm[0][2], 0.0, epsilon = 1e-5);
assert_abs_diff_ne!(rm[1][0], 0.0, epsilon = 1e-5);
assert_abs_diff_ne!(rm[1][2], 0.0, epsilon = 1e-5);
assert_abs_diff_ne!(rm[2][0], 0.0, epsilon = 1e-5);
assert_abs_diff_ne!(rm[2][1], 0.0, epsilon = 1e-5);
assert_abs_diff_eq!(p.hadec_j2000.ha, 6.071569090772114, epsilon = 1e-8);
assert_abs_diff_eq!(p.hadec_j2000.dec, -0.47123889803846897, epsilon = 1e-10);
assert_abs_diff_eq!(p.lmst, 6.0747789094260245, epsilon = 1e-10);
assert_abs_diff_eq!(p.lmst_j2000, 6.071569090772114, epsilon = 1e-8);
assert_abs_diff_eq!(p.array_latitude_j2000, -0.46739656091984, epsilon = 1e-8);
assert_abs_diff_ne!(p.array_latitude_j2000, MWA_LAT_RAD, epsilon = 1e-5);
let pc_hadec = phase_centre.to_hadec(p.lmst);
let ha_diff_arcmin = (pc_hadec.ha - p.hadec_j2000.ha).to_degrees() * 60.0;
let dec_diff_arcmin = (pc_hadec.dec - p.hadec_j2000.dec).to_degrees() * 60.0;
assert_abs_diff_eq!(ha_diff_arcmin, 11.034544, epsilon = 1e-4);
assert_abs_diff_eq!(dec_diff_arcmin, 0.0, epsilon = 1e-10);
}
#[test]
fn test_precess_1099334672_to_j2000() {
let epoch = Epoch::from_gpst_seconds(1099334672.0);
let phase_centre = RADec::from_degrees(60.0, -30.0);
let p = precess_time(
MWA_LONG_RAD,
MWA_LAT_RAD,
phase_centre,
epoch,
Duration::from_total_nanoseconds(0),
);
let rm = precession_matrix(&p, phase_centre, epoch);
assert_abs_diff_eq!(rm[0][0], 1.0, epsilon = 1e-5);
assert_abs_diff_eq!(rm[1][1], 1.0, epsilon = 1e-5);
assert_abs_diff_eq!(rm[2][2], 1.0, epsilon = 1e-5);
assert_abs_diff_ne!(rm[0][1], 0.0, epsilon = 1e-5);
assert_abs_diff_ne!(rm[0][2], 0.0, epsilon = 1e-5);
assert_abs_diff_ne!(rm[1][0], 0.0, epsilon = 1e-5);
assert_abs_diff_ne!(rm[1][2], 0.0, epsilon = 1e-5);
assert_abs_diff_ne!(rm[2][0], 0.0, epsilon = 1e-5);
assert_abs_diff_ne!(rm[2][1], 0.0, epsilon = 1e-5);
assert_abs_diff_eq!(p.hadec_j2000.ha, 0.4100110770434626, epsilon = 1e-8);
assert_abs_diff_eq!(p.hadec_j2000.dec, -0.5235987755982988, epsilon = 1e-10);
assert_abs_diff_eq!(p.lmst, 1.4598017673520172, epsilon = 1e-10);
assert_abs_diff_eq!(p.lmst_j2000, 1.4572086282400603, epsilon = 1e-8);
assert_abs_diff_eq!(p.array_latitude_j2000, -0.46618075917013235, epsilon = 1e-8);
assert_abs_diff_ne!(p.array_latitude_j2000, MWA_LAT_RAD, epsilon = 1e-5);
let pc_hadec = phase_centre.to_hadec(p.lmst);
let ha_diff_arcmin = (pc_hadec.ha - p.hadec_j2000.ha).to_degrees() * 60.0;
let dec_diff_arcmin = (pc_hadec.dec - p.hadec_j2000.dec).to_degrees() * 60.0;
assert_abs_diff_eq!(ha_diff_arcmin, 8.914556, epsilon = 1e-4);
assert_abs_diff_eq!(dec_diff_arcmin, 0.0, epsilon = 1e-10);
}
#[test]
fn test_precess_1099334672_to_j2000_with_dut1() {
let epoch = Epoch::from_gpst_seconds(1099334672.0);
let phase_centre = RADec::from_degrees(60.0, -30.0);
let p = precess_time(
MWA_LONG_RAD,
MWA_LAT_RAD,
phase_centre,
epoch,
Duration::from_seconds(-0.39623459),
);
let rm = precession_matrix(&p, phase_centre, epoch);
assert_abs_diff_eq!(rm[0][0], 1.0, epsilon = 1e-5);
assert_abs_diff_eq!(rm[1][1], 1.0, epsilon = 1e-5);
assert_abs_diff_eq!(rm[2][2], 1.0, epsilon = 1e-5);
assert_abs_diff_ne!(rm[0][1], 0.0, epsilon = 1e-5);
assert_abs_diff_ne!(rm[0][2], 0.0, epsilon = 1e-5);
assert_abs_diff_ne!(rm[1][0], 0.0, epsilon = 1e-5);
assert_abs_diff_ne!(rm[1][2], 0.0, epsilon = 1e-5);
assert_abs_diff_ne!(rm[2][0], 0.0, epsilon = 1e-5);
assert_abs_diff_ne!(rm[2][1], 0.0, epsilon = 1e-5);
assert_abs_diff_eq!(p.hadec_j2000.ha, 0.4099821814417699, epsilon = 1e-8);
assert_abs_diff_eq!(p.hadec_j2000.dec, -0.5235987755982988, epsilon = 1e-10);
assert_abs_diff_eq!(p.lmst, 1.4597728734531659, epsilon = 1e-10);
assert_abs_diff_eq!(p.lmst_j2000, 1.4571797326383675, epsilon = 1e-8);
assert_abs_diff_eq!(p.array_latitude_j2000, -0.4661808009369447, epsilon = 1e-8);
assert_abs_diff_ne!(p.array_latitude_j2000, MWA_LAT_RAD, epsilon = 1e-5);
let pc_hadec = phase_centre.to_hadec(p.lmst);
let ha_diff_arcmin = (pc_hadec.ha - p.hadec_j2000.ha).to_degrees() * 60.0;
let dec_diff_arcmin = (pc_hadec.dec - p.hadec_j2000.dec).to_degrees() * 60.0;
assert_abs_diff_eq!(ha_diff_arcmin, 8.914561, epsilon = 1e-4);
assert_abs_diff_eq!(dec_diff_arcmin, 0.0, epsilon = 1e-10);
}
#[test]
fn test_precess_time_cotter_matches_old_precess_time() {
let epoch = Epoch::from_gpst_seconds(1065880128.0);
let phase_centre = RADec::from_degrees(0.0, -27.0);
let p = precess_time_in_frame(
UvwFrame::Cotter,
MWA_LONG_RAD,
MWA_LAT_RAD,
phase_centre,
epoch,
Duration::from_total_nanoseconds(0),
);
assert_abs_diff_eq!(p.hadec_j2000.ha, 6.0714305189419715, epsilon = 1e-10);
assert_abs_diff_eq!(p.hadec_j2000.dec, -0.47122418312765446, epsilon = 1e-10);
assert_abs_diff_eq!(p.lmst, 6.0747789094260245, epsilon = 1e-10);
assert_abs_diff_eq!(p.lmst_j2000, 6.071524853456497, epsilon = 1e-10);
assert_abs_diff_eq!(p.array_latitude_j2000, -0.467396549790915, epsilon = 1e-10);
}
}