marlu 0.16.1

Convenience Rust code that handles coordinate transformations, Jones matrices, I/O. for the Murchison Widefield Array (MWA) radio telescope. Previously known as mwa_rust_core
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

//! Handling of Earth Coordinates (Latitude/Longitude/Height)

use std::fmt::Display;

use erfa::Ellipsoid;

use crate::{
    constants::{MWA_HEIGHT_M, MWA_LAT_RAD, MWA_LONG_RAD},
    XyzGeocentric,
};

#[derive(Clone, Copy, Debug, Default, PartialEq)]
/// An earth position: Latitude, Longitude and Height [radians, meters]
pub struct LatLngHeight {
    /// Longitude \[radians\]
    pub longitude_rad: f64,
    /// Latitude \[radians\]
    pub latitude_rad: f64,
    /// Height above ellipsoid \[meters\]
    pub height_metres: f64,
}

impl LatLngHeight {
    /// Get a [`LatLngHeight`] at the MWA's position.
    pub fn mwa() -> LatLngHeight {
        Self {
            longitude_rad: MWA_LONG_RAD,
            latitude_rad: MWA_LAT_RAD,
            height_metres: MWA_HEIGHT_M,
        }
    }

    /// Provide a new [`LatLngHeight`] at the MWA's position.
    #[deprecated = "use `LatLngHeight::mwa` instead"]
    pub fn new_mwa() -> LatLngHeight {
        Self::mwa()
    }

    /// Convert to [`XyzGeocentric`] via
    /// [`erfa::transform::geodetic_to_geocentric`] with the specified
    /// [`Ellipsoid`]
    pub fn to_geocentric(self, ellipsoid: Ellipsoid) -> XyzGeocentric {
        let geocentric_vector = erfa::transform::geodetic_to_geocentric(
            ellipsoid,
            self.longitude_rad,
            self.latitude_rad,
            self.height_metres,
        )
        .expect("latitude should be between -pi/2 and pi/2");
        XyzGeocentric {
            x: geocentric_vector[0],
            y: geocentric_vector[1],
            z: geocentric_vector[2],
        }
    }

    /// Convert to geocentric via the default [`Ellipsoid::WGS84`].
    pub fn to_geocentric_wgs84(self) -> XyzGeocentric {
        self.to_geocentric(Ellipsoid::WGS84)
    }
}

impl Display for LatLngHeight {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "{{ longitude: {:.4}°, latitude: {:.4}°, height: {}m }}",
            self.longitude_rad.to_degrees(),
            self.latitude_rad.to_degrees(),
            self.height_metres
        )
    }
}

#[cfg(any(test, feature = "approx"))]
impl approx::AbsDiffEq for LatLngHeight {
    type Epsilon = f64;

    fn default_epsilon() -> f64 {
        f64::EPSILON
    }

    fn abs_diff_eq(&self, other: &Self, epsilon: f64) -> bool {
        f64::abs_diff_eq(&self.longitude_rad, &other.longitude_rad, epsilon)
            && f64::abs_diff_eq(&self.latitude_rad, &other.latitude_rad, epsilon)
            && f64::abs_diff_eq(&self.height_metres, &other.height_metres, epsilon)
    }
}

#[cfg(any(test, feature = "approx"))]
impl approx::RelativeEq for LatLngHeight {
    #[inline]
    fn default_max_relative() -> f64 {
        f64::EPSILON
    }

    #[inline]
    fn relative_eq(&self, other: &Self, epsilon: f64, max_relative: f64) -> bool {
        f64::relative_eq(
            &self.longitude_rad,
            &other.longitude_rad,
            epsilon,
            max_relative,
        ) && f64::relative_eq(
            &self.latitude_rad,
            &other.latitude_rad,
            epsilon,
            max_relative,
        ) && f64::relative_eq(
            &self.height_metres,
            &other.height_metres,
            epsilon,
            max_relative,
        )
    }

    #[inline]
    fn relative_ne(
        &self,
        other: &Self,
        epsilon: Self::Epsilon,
        max_relative: Self::Epsilon,
    ) -> bool {
        !Self::relative_eq(self, other, epsilon, max_relative)
    }
}

#[cfg(test)]
mod tests {
    use approx::assert_abs_diff_eq;

    use crate::constants::{MWA_HEIGHT_M, MWA_LAT_RAD, MWA_LONG_RAD};

    use super::*;

    #[test]
    fn test_display_latlngheight() {
        let latlngheight = LatLngHeight {
            longitude_rad: 0.0,
            latitude_rad: 0.0,
            height_metres: 0.0,
        };
        let result = format!("{latlngheight}");
        assert!(!result.is_empty());
    }

    #[test]
    fn test_abs_diff_eq() {
        let latlngheight = LatLngHeight {
            longitude_rad: MWA_LONG_RAD * 0.9999999999,
            latitude_rad: MWA_LAT_RAD * 0.9999999999,
            height_metres: MWA_HEIGHT_M * 0.9999999999,
        };

        assert_abs_diff_eq!(latlngheight, LatLngHeight::mwa(), epsilon = 1e-7);
    }
}