updated model loader tests to cover decomposed curves

src/test/java/gov/usgs/earthquake/nshmp/model/LoaderTests.java

 package gov.usgs.earthquake.nshmp.model;
 
+import static gov.usgs.earthquake.nshmp.calc.HazardExport.CURVE_FILE;
+import static gov.usgs.earthquake.nshmp.calc.HazardExport.GMM_DIR;
+import static gov.usgs.earthquake.nshmp.calc.HazardExport.MAG_DIR;
+import static gov.usgs.earthquake.nshmp.calc.HazardExport.TYPE_DIR;
 import static java.lang.Math.abs;
 import static java.util.stream.Collectors.toMap;
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
@@ -11,10 +15,8 @@ import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.Arrays;
 import java.util.EnumMap;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Map.Entry;
 import java.util.OptionalDouble;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
@@ -31,8 +33,10 @@ import gov.usgs.earthquake.nshmp.calc.HazardCalcs;
 import gov.usgs.earthquake.nshmp.calc.HazardExport;
 import gov.usgs.earthquake.nshmp.calc.Site;
 import gov.usgs.earthquake.nshmp.calc.Sites;
+import gov.usgs.earthquake.nshmp.data.MutableXySequence;
 import gov.usgs.earthquake.nshmp.data.XySequence;
 import gov.usgs.earthquake.nshmp.geo.Location;
+import gov.usgs.earthquake.nshmp.gmm.Gmm;
 import gov.usgs.earthquake.nshmp.gmm.Imt;
 
 class LoaderTests {
@@ -51,14 +55,14 @@ class LoaderTests {
 
   static HazardModel model;
   static List<Site> sites;
-  static Map<Location, Map<Imt, XySequence>> expecteds;
+  static Expecteds expecteds;
   static ExecutorService exec;
 
   @BeforeAll
   static void setUpBeforeClass() throws IOException {
     model = ModelLoader.load(MODEL_PATH);
     sites = Sites.fromCsv(SITES_PATH, model.siteData(), OptionalDouble.empty());
-    expecteds = loadExpecteds();
+    expecteds = new Expecteds();
     int cores = Runtime.getRuntime().availableProcessors();
     exec = Executors.newFixedThreadPool(cores);
   }
@@ -72,21 +76,67 @@ class LoaderTests {
   @MethodSource("siteStream")
   final void testLocation(Site site) {
     Location loc = site.location();
-    Map<Imt, XySequence> expected = expecteds.get(loc);
+    // Map<Imt, XySequence> totalExpected = expecteds.totalCurves.get(loc);
     Hazard actual = HazardCalcs.hazard(model, model.config(), site, exec);
-    assertCurvesEqual(expected, actual, TOLERANCE);
+    assertCurvesEqual(loc, expecteds, actual, TOLERANCE);
   }
 
   private static Stream<Site> siteStream() {
     return sites.stream();
   }
 
-  private static void assertCurvesEqual(Map<Imt, XySequence> expected, Hazard actual, double tol) {
-    expected.entrySet().forEach(
-        e -> assertCurveEquals(
-            e.getValue(),
-            actual.curves().get(e.getKey()),
-            tol));
+  private static void assertCurvesEqual(
+      Location loc,
+      Expecteds expecteds,
+      Hazard actuals,
+      double tol) {
+
+    var gmmActualsImtMap = HazardExport.curvesByGmm(actuals);
+    var typeActualsImtMap = HazardExport.curvesBySource(actuals);
+
+    for (Imt imt : expecteds.totalCurves.keySet()) {
+
+      // total curve
+      XySequence totalExpected = expecteds.totalCurves.get(imt).get(loc);
+      XySequence totalActual = actuals.curves().get(imt);
+      assertCurveEquals(totalExpected, totalActual, tol);
+
+      /*
+       * For decomposed curves we need to loop actuals because expecteds will
+       * have additional zero-values curves for missing GMMs, source types and
+       * magnitudes.
+       */
+
+      // GMM curves
+      Map<Gmm, Map<Location, XySequence>> gmmExpecteds = expecteds.gmmCurves.get(imt);
+      Map<Gmm, ? extends XySequence> gmmActuals = gmmActualsImtMap.get(imt);
+      for (Gmm gmm : gmmActuals.keySet()) {
+        XySequence gmmExpected = gmmExpecteds.get(gmm).get(loc);
+        XySequence gmmActual = gmmActuals.get(gmm);
+        assertCurveEquals(gmmExpected, gmmActual, tol);
+      }
+
+      // Source type curves
+      Map<SourceType, Map<Location, XySequence>> typeExpecteds = expecteds.typeCurves.get(imt);
+      Map<SourceType, ? extends XySequence> typeActuals = typeActualsImtMap.get(imt);
+      for (SourceType type : typeActuals.keySet()) {
+        XySequence typeExpected = typeExpecteds.get(type).get(loc);
+        XySequence typeActual = typeActuals.get(type);
+        assertCurveEquals(typeExpected, typeActual, tol);
+      }
+
+      // Magnitude curves
+      Map<Double, XySequence> magExpecteds = expecteds.magCurves.get(imt).get(loc);
+      Map<Double, MutableXySequence> magActuals = actuals.magCurves().get(imt);
+      for (Double m : magActuals.keySet()) {
+        // if mag bin not used actuals will be null
+        // and expecteds will be array of zeros
+        if (magActuals.get(m) == null) {
+          continue;
+        }
+        assertCurveEquals(magExpecteds.get(m), magActuals.get(m), tol);
+      }
+    }
   }
 
   private static void assertCurveEquals(XySequence expected, XySequence actual, double tol) {
@@ -103,7 +153,7 @@ class LoaderTests {
     // y-value difference relative to tolerance
     assertArrayEquals(expectedYs, actualYs, tol);
 
-    // y-value difference relative to tolerance
+    // y-value ratio relative to tolerance
     for (int i = 0; i < expectedYs.length; i++) {
       String message = String.format(
           "arrays differ at [%s] expected:<[%s]> but was:<[%s]>",
@@ -117,84 +167,125 @@ class LoaderTests {
         Double.valueOf(expected).equals(Double.valueOf(actual));
   }
 
-  /* read curves then transpose */
-  private static Map<Location, Map<Imt, XySequence>> loadExpecteds() throws IOException {
-    // consider centralized curve file processing
-    Map<Imt, Map<Location, XySequence>> curves = Files.walk(RESULTS_PATH)
-        .filter(LoaderTests::isCurveFile)
-        .collect(toMap(
-            LoaderTests::imtFromPath,
-            LoaderTests::readCurves));
-    return transpose(curves);
-  }
+  private static class Expecteds {
+
+    Map<Imt, Map<Location, XySequence>> totalCurves = new EnumMap<>(Imt.class);
+    Map<Imt, Map<Gmm, Map<Location, XySequence>>> gmmCurves = new EnumMap<>(Imt.class);
+    Map<Imt, Map<SourceType, Map<Location, XySequence>>> typeCurves = new EnumMap<>(Imt.class);
+    Map<Imt, Map<Location, Map<Double, XySequence>>> magCurves = new EnumMap<>(Imt.class);
+
+    Expecteds() {
+      try {
+        Map<Imt, Path> imtDirs = Files.list(RESULTS_PATH)
+            .filter(Files::isDirectory)
+            .collect(toMap(
+                p -> Imt.valueOf(p.getFileName().toString()),
+                p -> p));
+        imtDirs.forEach(this::loadImtDir);
+      } catch (IOException ioe) {
+        throw new RuntimeException(ioe);
+      }
+    }
 
-  private static boolean isCurveFile(Path path) {
-    return path.getFileName().toString().equals("curves.csv");
-  }
+    void loadImtDir(Imt imt, Path path) {
+      try {
+
+        totalCurves.put(imt, readLocationCurves(path.resolve(CURVE_FILE)));
+
+        var imtGmmCurves = Files.list(path.resolve(GMM_DIR))
+            .filter(Files::isDirectory)
+            .collect(toMap(
+                p -> Gmm.valueOf(p.getFileName().toString()),
+                p -> readLocationCurves(p.resolve(CURVE_FILE))));
+        gmmCurves.put(imt, imtGmmCurves);
+
+        var imtTypeCurves = Files.list(path.resolve(TYPE_DIR))
+            .filter(Files::isDirectory)
+            .collect(toMap(
+                p -> SourceType.valueOf(p.getFileName().toString()),
+                p -> readLocationCurves(p.resolve(CURVE_FILE))));
+        typeCurves.put(imt, imtTypeCurves);
+
+        var imtMagCurves = Files.list(path.resolve(MAG_DIR))
+            .filter(p -> p.getFileName().toString().endsWith(".csv"))
+            .collect(toMap(
+                p -> readLocation(p),
+                p -> readMagnitudeCurves(p)));
 
-  private static Imt imtFromPath(Path path) {
-    return Imt.valueOf(path.getParent().getFileName().toString());
+        magCurves.put(imt, imtMagCurves);
+
+      } catch (IOException ioe) {
+        throw new RuntimeException(ioe);
+      }
+    }
   }
 
-  private static Map<Location, XySequence> readCurves(Path path) {
+  private static Map<Location, XySequence> readLocationCurves(Path path) {
+    int offset = 3;
     try {
       List<String> lines = Files.readAllLines(path);
-      double[] imls = toValues(lines.get(0));
+      double[] imls = readValues(lines.get(0), offset);
       return lines.stream()
           .skip(1)
-          .map(line -> toCurve(line, imls))
           .collect(toMap(
-              Entry::getKey,
-              Entry::getValue));
+              line -> readLocation(line),
+              line -> XySequence.create(imls, readValues(line, 3))));
     } catch (IOException ioe) {
       throw new RuntimeException(ioe);
     }
   }
 
-  private static Entry<Location, XySequence> toCurve(String line, double[] xs) {
-    Site site = toSite(line);
-    double[] ys = toValues(line);
-    return Map.entry(site.location(), XySequence.create(xs, ys));
+  /* Read a location from a line string. */
+  private static Location readLocation(String line) {
+    String[] s = line.split(",");
+    return Location.create(
+        Double.parseDouble(s[1]),
+        Double.valueOf(s[2]));
+  }
+
+  /* Read a location from a CSV filename. */
+  private static Location readLocation(Path path) {
+    String f = path.getFileName().toString();
+    String[] s = f.substring(0, f.length() - 4).split(",");
+    return Location.create(
+        Double.parseDouble(s[1]),
+        Double.parseDouble(s[2]));
   }
 
-  private static Site toSite(String line) {
-    String[] s = Arrays.stream(line.split(","))
-        .map(String::trim)
-        .limit(3)
-        .toArray(String[]::new);
-    String name = s[0];
-    Location loc = Location.create(
-        Double.valueOf(s[1]),
-        Double.valueOf(s[2]));
-    return Site.builder()
-        .name(name)
-        .location(loc)
-        .build();
+  private static Map<Double, XySequence> readMagnitudeCurves(Path path) {
+    int offset = 1;
+    try {
+      List<String> lines = Files.readAllLines(path);
+      double[] imls = readValues(lines.get(0), offset);
+      Map<Double, XySequence> pp = lines.stream()
+          .skip(1)
+          .collect(toMap(
+              line -> Double.valueOf(line.substring(0, line.indexOf(","))),
+              line -> readMagnitudeCurve(line, imls, offset)));
+      return pp;
+    } catch (IOException ioe) {
+      throw new RuntimeException(ioe);
+    }
   }
 
-  private static double[] toValues(String line) {
+  private static XySequence readMagnitudeCurve(
+      String line,
+      double[] xs,
+      int offset) {
+
+    double[] ys = readValues(line, offset);
+    return XySequence.create(xs, ys);
+  }
+
+  /* Read values from a comma-delimited string. */
+  private static double[] readValues(String line, int offset) {
     return Arrays.stream(line.split(","))
         .map(String::trim)
-        .skip(3)
+        .skip(offset)
         .mapToDouble(Double::parseDouble)
         .toArray();
   }
 
-  private static Map<Location, Map<Imt, XySequence>> transpose(
-      Map<Imt, Map<Location, XySequence>> mapIn) {
-
-    Map<Location, Map<Imt, XySequence>> mapOut = new HashMap<>();
-    for (Entry<Imt, Map<Location, XySequence>> imtEntry : mapIn.entrySet()) {
-      Imt imt = imtEntry.getKey();
-      for (Entry<Location, XySequence> locEntry : imtEntry.getValue().entrySet()) {
-        Location loc = locEntry.getKey();
-        XySequence xy = locEntry.getValue();
-        mapOut.computeIfAbsent(loc, k -> new EnumMap<>(Imt.class)).put(imt, xy);
-      }
-    }
-    return mapOut;
-  }
-
   public static void main(String[] args) throws IOException {
     model = ModelLoader.load(MODEL_PATH);
     List<Site> sites = Sites.fromCsv(SITES_PATH, model.siteData(), OptionalDouble.empty());