docs: record AK plan execution corrections; ignore CTest Testing/ dir

Plan updated with the Approx (not Catch::Approx) and
src/LibMTRSim/CMakeLists.txt corrections discovered during execution.

Author: imikejackson

.gitignore

@@ -2,3 +2,4 @@
 CLAUDE.md
 *.mat
 /docs/superpowers
+/Testing

docs/superpowers/plans/2026-06-01-milestone-ak.md

@@ -6,7 +6,11 @@
 
 **Architecture:** The heavy lifting is consolidated into a single reusable LibMTRSim entry point `simulateMTR()` that runs PGRF → orientation sampling → per-voxel assignment and returns results in **SIMPLNX z,y,x voxel order**. LibMTRSim Catch2 tests (in `tests/`) cover the numerics (deterministic helpers + a statistical end-to-end test reusing the ODF exemplar). The filter is a thin SIMPLNX wrapper (`MTRSimFilter` + `MTRSim` algorithm) whose tests (in `test/`) only verify the filter's value-add: parameter→params mapping, ODF-geometry→component reconstruction, array creation/types/names/1-based ids, seed handling, preflight validation, and the optional color array.
 
-**Tech Stack:** C++17, Eigen, simplnx filter framework, Catch2 v2 (note: `Catch::Approx`, not `Approx`), CMake, GitHub Actions.
+**Tech Stack:** C++17, Eigen, simplnx filter framework, Catch2 v2 (this repo uses the **bare `Approx`** matcher — `Approx` does NOT compile here), CMake, GitHub Actions.
+
+> **Correction applied during execution:** all Catch2 tests in this plan use
+> bare `Approx(...)`, not `Approx(...)`. The standalone LibMTRSim source
+> list is in `src/LibMTRSim/CMakeLists.txt` (not `LibMTRSim.cmake`).
 
 ---
 
@@ -69,7 +73,7 @@ simplnx checkout is at `/Users/mjackson/Workspace7/simplnx`):
 - `src/app/main.cpp` — call `simulateMTR()` instead of inline orchestration.
 - `MTRSimPlugin.cmake` — add `MTRSimDriver.{hpp,cpp}` to LibMTRSim sources;
   add `MTRSimFilter`/`MTRSim` to `FilterList`/`AlgorithmList`.
-- `LibMTRSim.cmake` — add `MTRSimDriver.{hpp,cpp}` to the standalone library.
+- `src/LibMTRSim/CMakeLists.txt` — add `MTRSimDriver.{hpp,cpp}` to the standalone library source/header lists.
 - `tests/CMakeLists.txt` — add `test_mtrsim_driver.cpp`.
 - `test/CMakeLists.txt` — add `MTRSimTest.cpp`.
 
@@ -194,13 +198,13 @@ TEST_CASE("buildUniformODF produces correct bin centres", "[mtrsim_driver]") {
   REQUIRE(uni.phi1Bins.size() == 72 * 36 * 72);
 
   // Uniform mass: every bin equal, sums to 1.
-  REQUIRE(uni.odfVal.sum() == Catch::Approx(1.0));
-  REQUIRE(uni.odfVal[0] == Catch::Approx(1.0 / (72.0 * 36.0 * 72.0)));
+  REQUIRE(uni.odfVal.sum() == Approx(1.0));
+  REQUIRE(uni.odfVal[0] == Approx(1.0 / (72.0 * 36.0 * 72.0)));
 
   // First bin centre: i1=iPHI=i2=0 -> all 0.5 * step.
-  REQUIRE(uni.phi1Bins[0] == Catch::Approx(0.5 * 2.0 * std::numbers::pi / 72.0));
-  REQUIRE(uni.phiBins[0] == Catch::Approx(0.5 * std::numbers::pi / 36.0));
-  REQUIRE(uni.phi2Bins[0] == Catch::Approx(0.5 * 2.0 * std::numbers::pi / 72.0));
+  REQUIRE(uni.phi1Bins[0] == Approx(0.5 * 2.0 * std::numbers::pi / 72.0));
+  REQUIRE(uni.phiBins[0] == Approx(0.5 * std::numbers::pi / 36.0));
+  REQUIRE(uni.phi2Bins[0] == Approx(0.5 * 2.0 * std::numbers::pi / 72.0));
 }
 ```
 
@@ -266,12 +270,12 @@ TEST_CASE("gridToODFComponent derives bin centres in radians and normalizes", "[
       mtrsim::gridToODFComponent(values, n1, nPHI, n2, 5.0, 5.0, 5.0);
 
   REQUIRE(c.odfVal.size() == n1 * nPHI * n2);
-  REQUIRE(c.odfVal.sum() == Catch::Approx(1.0)); // normalized
+  REQUIRE(c.odfVal.sum() == Approx(1.0)); // normalized
   // 5 deg step -> first bin centre 2.5 deg in radians.
   const double deg2rad = std::numbers::pi / 180.0;
-  REQUIRE(c.phi1Bins[0] == Catch::Approx(2.5 * deg2rad));
-  REQUIRE(c.phiBins[0] == Catch::Approx(2.5 * deg2rad));
-  REQUIRE(c.phi2Bins[0] == Catch::Approx(2.5 * deg2rad));
+  REQUIRE(c.phi1Bins[0] == Approx(2.5 * deg2rad));
+  REQUIRE(c.phiBins[0] == Approx(2.5 * deg2rad));
+  REQUIRE(c.phi2Bins[0] == Approx(2.5 * deg2rad));
 }
 ```
 
@@ -569,9 +573,9 @@ TEST_CASE("simulateMTR reproduces target volume fractions (statistical)", "[mtrs
   // Empirical volume fractions within tolerance of targets.
   std::array<int, 3> counts{0, 0, 0};
   for (int v : r.mtrIndex) { counts[v - 1]++; }
-  REQUIRE(static_cast<double>(counts[0]) / N == Catch::Approx(0.30).margin(0.05));
-  REQUIRE(static_cast<double>(counts[1]) / N == Catch::Approx(0.35).margin(0.05));
-  REQUIRE(static_cast<double>(counts[2]) / N == Catch::Approx(0.35).margin(0.05));
+  REQUIRE(static_cast<double>(counts[0]) / N == Approx(0.30).margin(0.05));
+  REQUIRE(static_cast<double>(counts[1]) / N == Approx(0.35).margin(0.05));
+  REQUIRE(static_cast<double>(counts[2]) / N == Approx(0.35).margin(0.05));
 
   // Euler ranges valid.
   for (double a : r.phi1) { REQUIRE(a >= 0.0); REQUIRE(a <= 2.0 * std::numbers::pi); }
@@ -1166,8 +1170,8 @@ TEST_CASE("MTRSimFilter: execute produces valid MTR ids + Eulers", "[MTRSim]")
     counts[v - 1]++;
   }
   const double n = static_cast<double>(ids.getNumberOfTuples());
-  REQUIRE(counts[0] / n == Catch::Approx(0.30).margin(0.06));
-  REQUIRE(counts[1] / n == Catch::Approx(0.35).margin(0.06));
+  REQUIRE(counts[0] / n == Approx(0.30).margin(0.06));
+  REQUIRE(counts[1] / n == Approx(0.35).margin(0.06));
 
   // Seed array recorded.
   auto& seedArr = ds.getDataRefAs<UInt64Array>(DataPath({"MTRSim SeedValue"}));

src/LibMTRSim/IPFMapper.hpp

@@ -17,8 +17,10 @@ namespace mtrsim {
  * EbsdLib's `LaueOps` and `ebsdlib::CrystalStructure::*` codes directly.
  */
 enum class CrystalSystem {
-  HCP, ///< Hexagonal close-packed (maps to ebsdlib::CrystalStructure::Hexagonal_High)
-  FCC, ///< Face-centred cubic    (maps to ebsdlib::CrystalStructure::Cubic_High)
+  HCP, ///< Hexagonal close-packed (maps to
+       ///< ebsdlib::CrystalStructure::Hexagonal_High)
+  FCC, ///< Face-centred cubic    (maps to
+       ///< ebsdlib::CrystalStructure::Cubic_High)
 };
 
 /**

src/LibMTRSim/MTRSimDriver.cpp

@@ -30,14 +30,17 @@ ODFComponent buildUniformODF(int n1, int nPHI, int n2) {
   }
 
   ODFComponent uni;
-  uni.odfVal = Eigen::VectorXd::Constant(nTotal, 1.0 / static_cast<double>(nTotal));
+  uni.odfVal =
+      Eigen::VectorXd::Constant(nTotal, 1.0 / static_cast<double>(nTotal));
   uni.phi1Bins = std::move(phi1Bins);
   uni.phiBins = std::move(phiBins);
   uni.phi2Bins = std::move(phi2Bins);
   return uni;
 }
 
-ODFComponent gridToODFComponent(const std::vector<double>& values, int n1, int nPHI, int n2, double stepDeg1, double stepDegPHI, double stepDeg2) {
+ODFComponent gridToODFComponent(const std::vector<double> &values, int n1,
+                                int nPHI, int n2, double stepDeg1,
+                                double stepDegPHI, double stepDeg2) {
   const int nTotal = n1 * nPHI * n2;
   const double deg2rad = std::numbers::pi / 180.0;
   const double s1 = stepDeg1 * deg2rad;
@@ -68,34 +71,39 @@ ODFComponent gridToODFComponent(const std::vector<double>& values, int n1, int n
   return c;
 }
 
-MTRSimResult simulateMTR(const SimulationParams& params,
-                         const std::vector<ODFComponent>& odfComponents,
-                         std::mt19937_64& rng,
-                         int n1, int nPHI, int n2) {
+MTRSimResult simulateMTR(const SimulationParams &params,
+                         const std::vector<ODFComponent> &odfComponents,
+                         std::mt19937_64 &rng, int n1, int nPHI, int n2) {
   const int nx = static_cast<int>(std::round(params.xLen / params.dx));
   const int ny = static_cast<int>(std::round(params.yLen / params.dy));
-  const int nz = std::max(static_cast<int>(std::round(params.zLen / params.dz)), 1);
+  const int nz =
+      std::max(static_cast<int>(std::round(params.zLen / params.dz)), 1);
   const int N = nx * ny * nz;
 
-  if (static_cast<int>(odfComponents.size()) != static_cast<int>(params.volumeFractions.size())) {
-    throw std::invalid_argument("simulateMTR: odfComponents count must equal volumeFractions count");
+  if (static_cast<int>(odfComponents.size()) !=
+      static_cast<int>(params.volumeFractions.size())) {
+    throw std::invalid_argument(
+        "simulateMTR: odfComponents count must equal volumeFractions count");
   }
 
   // 1. PGRF assignment (sim-ordered, 1-based component ids).
   PGRFSimulation pgrf{rng};
   const PGRFResult pgrf_result = pgrf.run(params); // throws on bad dims
 
   if (static_cast<int>(pgrf_result.mtrIndex.size()) != N) {
-    throw std::runtime_error("simulateMTR: PGRF result size does not match grid dimensions");
+    throw std::runtime_error(
+        "simulateMTR: PGRF result size does not match grid dimensions");
   }
 
   // 2. Sample N orientations per component against the uniform reference.
   const ODFComponent uniformOdf = buildUniformODF(n1, nPHI, n2);
   const int numComponents = static_cast<int>(odfComponents.size());
-  std::vector<Eigen::MatrixXd> orientSamples(static_cast<std::size_t>(numComponents));
+  std::vector<Eigen::MatrixXd> orientSamples(
+      static_cast<std::size_t>(numComponents));
   ODFSampler sampler{rng};
   for (int j = 0; j < numComponents; ++j) {
-    orientSamples[static_cast<std::size_t>(j)] = sampler.sampleN(N, odfComponents[static_cast<std::size_t>(j)], uniformOdf);
+    orientSamples[static_cast<std::size_t>(j)] = sampler.sampleN(
+        N, odfComponents[static_cast<std::size_t>(j)], uniformOdf);
   }
 
   // 3. Assign per-voxel orientation by component (sim order).
@@ -106,9 +114,12 @@ MTRSimResult simulateMTR(const SimulationParams& params,
   for (int i = 0; i < N; ++i) {
     const int comp = pgrf_result.mtrIndex[i] - 1;
     mtrSim[static_cast<std::size_t>(i)] = pgrf_result.mtrIndex[i];
-    phi1Sim[static_cast<std::size_t>(i)] = orientSamples[static_cast<std::size_t>(comp)](i, 0);
-    phiSim[static_cast<std::size_t>(i)]  = orientSamples[static_cast<std::size_t>(comp)](i, 1);
-    phi2Sim[static_cast<std::size_t>(i)] = orientSamples[static_cast<std::size_t>(comp)](i, 2);
+    phi1Sim[static_cast<std::size_t>(i)] =
+        orientSamples[static_cast<std::size_t>(comp)](i, 0);
+    phiSim[static_cast<std::size_t>(i)] =
+        orientSamples[static_cast<std::size_t>(comp)](i, 1);
+    phi2Sim[static_cast<std::size_t>(i)] =
+        orientSamples[static_cast<std::size_t>(comp)](i, 2);
   }
 
   // 4. Remap to SIMPLNX z,y,x order.
@@ -117,9 +128,9 @@ MTRSimResult simulateMTR(const SimulationParams& params,
   out.ny = ny;
   out.nz = nz;
   out.mtrIndex = remapSimToZYX(mtrSim, nx, ny, nz);
-  out.phi1     = remapSimToZYX(phi1Sim, nx, ny, nz);
-  out.phi      = remapSimToZYX(phiSim,  nx, ny, nz);
-  out.phi2     = remapSimToZYX(phi2Sim, nx, ny, nz);
+  out.phi1 = remapSimToZYX(phi1Sim, nx, ny, nz);
+  out.phi = remapSimToZYX(phiSim, nx, ny, nz);
+  out.phi2 = remapSimToZYX(phi2Sim, nx, ny, nz);
   return out;
 }
 

src/LibMTRSim/MTRSimDriver.hpp

@@ -2,7 +2,7 @@
 
 #include "libmtrsim_export.h"
 
-#include "ODFSampler.hpp"      // mtrsim::ODFComponent, mtrsim::EulerAngles
+#include "ODFSampler.hpp" // mtrsim::ODFComponent, mtrsim::EulerAngles
 #include "SimulationParams.hpp"
 
 #include <Eigen/Dense>
@@ -28,12 +28,15 @@ LIBMTRSIM_EXPORT ODFComponent buildUniformODF(int n1, int nPHI, int n2);
  * @brief Reconstruct an ODF component from flat grid data + degree spacing.
  *
  * @param values    Flat ODFval, length n1*nPHI*n2, row-major with
- *                  ix = i1*(nPHI*n2) + iPHI*n2 + i2 (phi1 slowest, phi2 fastest).
+ *                  ix = i1*(nPHI*n2) + iPHI*n2 + i2 (phi1 slowest, phi2
+ * fastest).
  * @param n1,nPHI,n2  Bin counts along phi1, PHI, phi2.
  * @param stepDeg1,stepDegPHI,stepDeg2  Bin sizes [degrees] (geometry spacing).
  * @return ODFComponent with bin centres [rad] and values normalized to sum 1.
  */
-LIBMTRSIM_EXPORT ODFComponent gridToODFComponent(const std::vector<double>& values, int n1, int nPHI, int n2, double stepDeg1, double stepDegPHI, double stepDeg2);
+LIBMTRSIM_EXPORT ODFComponent
+gridToODFComponent(const std::vector<double> &values, int n1, int nPHI, int n2,
+                   double stepDeg1, double stepDegPHI, double stepDeg2);
 
 /**
  * @brief Remap a per-voxel vector from simulation order to SIMPLNX z,y,x order.
@@ -45,13 +48,15 @@ LIBMTRSIM_EXPORT ODFComponent gridToODFComponent(const std::vector<double>& valu
  * @tparam T element type (int or double).
  */
 template <typename T>
-std::vector<T> remapSimToZYX(const std::vector<T>& in, int nx, int ny, int nz) {
+std::vector<T> remapSimToZYX(const std::vector<T> &in, int nx, int ny, int nz) {
   std::vector<T> out(in.size());
   for (int iz = 0; iz < nz; ++iz) {
     for (int iy = 0; iy < ny; ++iy) {
       for (int ix = 0; ix < nx; ++ix) {
-        const std::size_t kSim = static_cast<std::size_t>(iz) * nx * ny + static_cast<std::size_t>(ix) * ny + iy;
-        const std::size_t kNx = static_cast<std::size_t>(iz) * ny * nx + static_cast<std::size_t>(iy) * nx + ix;
+        const std::size_t kSim = static_cast<std::size_t>(iz) * nx * ny +
+                                 static_cast<std::size_t>(ix) * ny + iy;
+        const std::size_t kNx = static_cast<std::size_t>(iz) * ny * nx +
+                                static_cast<std::size_t>(iy) * nx + ix;
         out[kNx] = in[kSim];
       }
     }
@@ -66,25 +71,27 @@ struct LIBMTRSIM_EXPORT MTRSimResult {
   int nx = 0;
   int ny = 0;
   int nz = 0;
-  std::vector<int32_t> mtrIndex;   ///< 1-based component id per voxel, length N
-  std::vector<double> phi1;        ///< Euler phi1 [rad] per voxel, length N
-  std::vector<double> phi;         ///< Euler PHI  [rad] per voxel, length N
-  std::vector<double> phi2;        ///< Euler phi2 [rad] per voxel, length N
+  std::vector<int32_t> mtrIndex; ///< 1-based component id per voxel, length N
+  std::vector<double> phi1;      ///< Euler phi1 [rad] per voxel, length N
+  std::vector<double> phi;       ///< Euler PHI  [rad] per voxel, length N
+  std::vector<double> phi2;      ///< Euler phi2 [rad] per voxel, length N
 };
 
 /**
  * @brief Run the full MTR simulation: PGRF assignment -> per-component ODF
  *        sampling -> per-voxel orientation assignment, returned in SIMPLNX
  *        z,y,x voxel order.
  *
- * @param params         Fully populated SimulationParams (consistent length unit).
- * @param odfComponents  One ODFComponent per volume-fraction entry, shared grid.
+ * @param params         Fully populated SimulationParams (consistent length
+ * unit).
+ * @param odfComponents  One ODFComponent per volume-fraction entry, shared
+ * grid.
  * @param rng            Seeded RNG (mt19937_64).
  * @param n1,nPHI,n2     Bin counts of the ODF grid (for the uniform reference).
  */
-LIBMTRSIM_EXPORT MTRSimResult simulateMTR(const SimulationParams& params,
-                                          const std::vector<ODFComponent>& odfComponents,
-                                          std::mt19937_64& rng,
-                                          int n1, int nPHI, int n2);
+LIBMTRSIM_EXPORT MTRSimResult
+simulateMTR(const SimulationParams &params,
+            const std::vector<ODFComponent> &odfComponents,
+            std::mt19937_64 &rng, int n1, int nPHI, int n2);
 
 } // namespace mtrsim