Add more repair tests and improve implementation

Author: felixhekhorn

pineappl/src/packed_array.rs

@@ -93,9 +93,11 @@ impl<T: Copy + Default + PartialEq> PackedArray<T> {
     /// Clear array, if it is empty.
     ///
     /// See https://github.com/NNPDF/pineappl/issues/338 and https://github.com/NNPDF/pineappl/commit/591cdcfa434ef7028dbbdc5f8da2ab83b273029c.
-    /// Return value indicates, whether it was cleared
+    /// Return value indicates, whether it was cleared (now)
     pub fn clear_if_empty(&mut self) -> bool {
-        if self.indexed_iter().count() == 0 {
+        // 1) are there actually elements?
+        // 2) some of them might be default (and filtered away)
+        if self.lengths.len() > 0 && self.indexed_iter().count() == 0 {
             self.clear();
             return true;
         }
@@ -1012,24 +1014,28 @@ mod tests {
 
     #[test]
     fn clear_if_empty() {
+        // create an empty array
         let mut array = PackedArray::new(vec![40, 50, 50]);
+        let was_repaired = array.clear_if_empty();
+        assert!(array.is_empty());
+        assert!(!was_repaired);
 
         // set something, which is not nothing
         array[[0, 0, 0]] = 1;
         assert!(!array.is_empty());
-        let must_be_false = array.clear_if_empty();
+        let was_repaired = array.clear_if_empty();
         assert!(!array.is_empty());
-        assert!(!must_be_false);
+        assert!(!was_repaired);
 
         // setting the default value does not clear the array on it's own ...
         array[[0, 0, 0]] = 0;
         assert!(!array.is_empty());
         assert_eq!(array.indexed_iter().count(), 0);
 
         // ... one needs to make that explicitly
-        let must_be_true = array.clear_if_empty();
+        let was_repaired = array.clear_if_empty();
         assert!(array.is_empty());
-        assert!(must_be_true);
+        assert!(was_repaired);
         assert_eq!(array.indexed_iter().count(), 0);
     }
 

pineappl/src/subgrid.rs

@@ -712,6 +712,30 @@ mod tests {
         );
     }
 
+    #[test]
+    fn import_subgrid_v1_repair() {
+        let x = vec![
+            0.015625, 0.03125, 0.0625, 0.125, 0.1875, 0.25, 0.375, 0.5, 0.75, 1.0,
+        ];
+        // create empty grid
+        let mut grid1: SubgridEnum = ImportSubgridV1::new(
+            PackedArray::new(vec![1, 10, 10]),
+            vec![vec![0.0], x.clone(), x.clone()],
+        )
+        .into();
+        assert_eq!(grid1.node_values(), vec![vec![0.0], x.clone(), x.clone()]);
+        assert!(grid1.is_empty());
+        // set a default value
+        if let SubgridEnum::ImportSubgridV1(ref mut x) = grid1 {
+            x.array[[0, 1, 2]] = 0.0;
+        }
+        assert!(!grid1.is_empty());
+        // now fix
+        let has_repaired = grid1.repair();
+        assert!(grid1.is_empty());
+        assert!(has_repaired);
+    }
+
     #[test]
     fn interp_subgrid_v1_fill_zero() {
         let interps = v0::default_interps(false, 2);
@@ -799,4 +823,20 @@ mod tests {
 
         assert_eq!(subgrid.shape(), [23, 1, 1]);
     }
+
+    #[test]
+    fn interp_subgrid_v1_repair() {
+        let interps = v0::default_interps(false, 2);
+        let mut subgrid = InterpSubgridV1::new(&interps);
+        // Fill something
+        subgrid.fill(&interps, &[1000.0, 0.5, 0.5], 1.0);
+        assert!(!subgrid.is_empty());
+        // The multiply with 0 trick is still possible at f856cd871afc2ba44d5e19e658dba3f38893fcab
+        subgrid.scale(0.);
+        assert!(subgrid.is_empty());
+        // now fix
+        let has_repaired = subgrid.repair();
+        assert!(subgrid.is_empty());
+        assert!(!has_repaired);
+    }
 }