Improve default raw MWA data fine channel flags.

The (very) old code would simply crash if a frequency resolution other
than 10, 20 or 40 kHz was provided. This commit allows any resolution to
be used and makes it explicit that 80 kHz is being flagged at the
edges (the middle channel is also flagged if not MWAX).

CHANGELOG.md

@@ -13,6 +13,8 @@ Versioning](https://semver.org/spec/v2.0.0.html).
   `solutions-apply`.
 
 ### Fixed
+- Until now, `hyperdrive` only supported raw MWA data with a frequency
+  resolution of 10, 20 or 40 kHz. It now supports any resolution.
 - When reading from uvfits/measurement set, a metafits' dipole information was
   applied, but perhaps in the wrong order. Order checks are now in place, but
   tile names must be consistent between the metafits and uvfits/MS.

src/vis_io/read/raw/error.rs

@@ -22,9 +22,6 @@ pub(crate) enum RawReadError {
     #[error("All of this observation's coarse channels are deemed bad; cannot continue")]
     NoGoodCoarseChannels,
 
-    #[error("No fine-channel flags were specified, and no rule is in place for automatically flagging observations with a fine-channel resolution of {0} Hz")]
-    UnhandledFreqResolutionForFlags(u32),
-
     #[error("The raw MWA data contains no timesteps")]
     NoTimesteps,
 

src/vis_io/read/raw/mod.rs

@@ -200,29 +200,11 @@ impl RawDataReader {
             }
         }
 
-        let flagged_fine_chans_per_coarse_chan: Vec<usize> =
-            // If the flags aren't specified, use the observation's fine-channel
-            // frequency resolution to set them.
-            match (metafits_context.corr_fine_chan_width_hz, is_mwax) {
-                // 10 kHz, 128 channels.
-                (10000, true) => vec![
-                    0, 1, 2, 3, 4, 5, 6, 7, 120, 121, 122, 123, 124, 125, 126, 127,
-                ],
-                // Include the centre channel.
-                (10000, false) => vec![
-                    0, 1, 2, 3, 4, 5, 6, 7, 64, 120, 121, 122, 123, 124, 125, 126, 127,
-                ],
-
-                // 20 kHz, 64 channels.
-                (20000, true) => vec![0, 1, 2, 3, 60, 61, 62, 63],
-                (20000, false) => vec![0, 1, 2, 3, 32, 60, 61, 62, 63],
-
-                // 40 kHz, 32 channels.
-                (40000, true) => vec![0, 1, 30, 31],
-                (40000, false) => vec![0, 1, 16, 30, 31],
-
-                (f, _) => return Err(RawReadError::UnhandledFreqResolutionForFlags(f)),
-        };
+        let flagged_fine_chans_per_coarse_chan = get_80khz_fine_chan_flags_per_coarse_chan(
+            metafits_context.corr_fine_chan_width_hz,
+            metafits_context.num_corr_fine_chans_per_coarse,
+            is_mwax,
+        );
         let flagged_fine_chans = {
             let mut flagged_fine_chans = Vec::with_capacity(
                 flagged_fine_chans_per_coarse_chan.len() * mwalib_context.num_coarse_chans,
@@ -788,3 +770,25 @@ impl VisRead for RawDataReader {
         )
     }
 }
+
+fn get_80khz_fine_chan_flags_per_coarse_chan(
+    fine_chan_width: u32,
+    num_fine_chans_per_coarse_chan: usize,
+    is_mwax: bool,
+) -> Vec<usize> {
+    let mut flags = vec![];
+
+    // Any fractional parts are discarded, meaning e.g. if the resolution was
+    // 79kHz per channel, only 1 edge channel is flagged rather than 2.
+    let num_flagged_fine_chans_per_edge = (80000 / fine_chan_width) as usize;
+    for i in 0..num_flagged_fine_chans_per_edge {
+        flags.push(i);
+        flags.push(num_fine_chans_per_coarse_chan - 1 - i);
+    }
+    // Also put the centre channel in if this isn't an MWAX obs.
+    if !is_mwax {
+        flags.push(num_fine_chans_per_coarse_chan / 2);
+    }
+    flags.sort_unstable();
+    flags
+}

src/vis_io/read/raw/tests.rs

@@ -931,6 +931,46 @@ fn test_mwaf_flags_cotter() {
     }
 }
 
+#[test]
+fn test_default_flags_per_coarse_chan() {
+    assert_eq!(
+        get_80khz_fine_chan_flags_per_coarse_chan(10000, 128, true),
+        &[0, 1, 2, 3, 4, 5, 6, 7, 120, 121, 122, 123, 124, 125, 126, 127]
+    );
+    assert_eq!(
+        get_80khz_fine_chan_flags_per_coarse_chan(10000, 128, false),
+        &[0, 1, 2, 3, 4, 5, 6, 7, 64, 120, 121, 122, 123, 124, 125, 126, 127]
+    );
+
+    assert_eq!(
+        get_80khz_fine_chan_flags_per_coarse_chan(20000, 64, true),
+        &[0, 1, 2, 3, 60, 61, 62, 63]
+    );
+    assert_eq!(
+        get_80khz_fine_chan_flags_per_coarse_chan(20000, 64, false),
+        &[0, 1, 2, 3, 32, 60, 61, 62, 63]
+    );
+
+    assert_eq!(
+        get_80khz_fine_chan_flags_per_coarse_chan(40000, 32, true),
+        &[0, 1, 30, 31]
+    );
+    assert_eq!(
+        get_80khz_fine_chan_flags_per_coarse_chan(40000, 32, false),
+        &[0, 1, 16, 30, 31]
+    );
+
+    // Future proofing?
+    assert_eq!(
+        get_80khz_fine_chan_flags_per_coarse_chan(7200, 100, true),
+        &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
+    );
+    assert_eq!(
+        get_80khz_fine_chan_flags_per_coarse_chan(7200, 100, false),
+        &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 50, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
+    );
+}
+
 #[test]
 fn test_1090008640_calibration_quality() {
     let mut args = get_reduced_1090008640(false, false);