Fix HDF5 build failure when ZLIB::ZLIB is an ALIAS target

Author: marinerhemant

cmake/deps/HDF5_custom.cmake

@@ -34,6 +34,24 @@
     set(HDF5_EXTERNALLY_CONFIGURED ON CACHE BOOL "" FORCE)
     set(HDF5_EXPORTED_TARGETS "" CACHE STRING "" FORCE)
 
+    # Workaround: CMake prohibits set_target_properties on ALIAS targets.
+    # When MIDAS builds zlib via FetchContent, ZLIB::ZLIB is created as an
+    # ALIAS (see top-level CMakeLists.txt).  HDF5's CMakeFilters.cmake tries
+    # set_target_properties(ZLIB::ZLIB PROPERTIES OUTPUT_NAME ...) which
+    # fails on the ALIAS.  Pre-setting H5_ZLIB_HEADER tells HDF5 that zlib
+    # is already externally configured, skipping its internal find+property
+    # code path.  We also pre-populate LINK_COMP_LIBS so HDF5 still links
+    # against zlib for compression support.
+    if(TARGET ZLIB::ZLIB)
+      get_target_property(_zlib_aliased ZLIB::ZLIB ALIASED_TARGET)
+      if(_zlib_aliased)
+        set(H5_ZLIB_HEADER "zlib.h")
+        set(H5_ZLIB_INCLUDE_DIR_GEN "${ZLIB_INCLUDE_DIR}")
+        set(H5_ZLIB_INCLUDE_DIRS "${ZLIB_INCLUDE_DIRS}")
+        set(LINK_COMP_LIBS "ZLIB::ZLIB")
+      endif()
+    endif()
+
     add_subdirectory(${hdf5_SOURCE_DIR} ${hdf5_BINARY_DIR} EXCLUDE_FROM_ALL)
 
     # Ensure HDF5 targets wait for the FetchContent zlib target to be built.

fwd_sim/em_spot_ownership.py

@@ -206,6 +206,8 @@ def e_step(
         pred_valid: torch.Tensor,
         obs_rings: Optional[torch.Tensor] = None,
         pred_rings: Optional[torch.Tensor] = None,
+        obs_scan_nrs: Optional[torch.Tensor] = None,
+        grain_scan_mask: Optional[torch.Tensor] = None,
     ) -> Tuple[torch.Tensor, torch.Tensor]:
         """E-step: compute soft ownership probabilities.
 
@@ -214,6 +216,10 @@ def e_step(
         2. |omega_obs - omega_pred| < tol_omega
         3. |eta_obs - eta_pred| < tol_eta
 
+        In pf-HEDM mode, additionally filters by scan position: grain g
+        can only own spot s if grain g is present at the scan position
+        where spot s was observed (grain_scan_mask[g, scanNr_of_s] == True).
+
         Within the box, the closest match (smallest omega+eta distance)
         is used for the Gaussian ownership kernel.
 
@@ -224,6 +230,9 @@ def e_step(
         pred_valid : (N, K) validity mask
         obs_rings : (S,) int ring indices for observed spots
         pred_rings : (N, K) int ring indices for predicted spots
+        obs_scan_nrs : (S,) int scan number for each observed spot (pf-HEDM)
+        grain_scan_mask : (N, n_scans) bool, grain_scan_mask[g, s] = True if
+            grain g is present at scan s. Derived from the C code's sinograms.
 
         Returns
         -------
@@ -239,13 +248,26 @@ def e_step(
         sigma2 = self.sigma ** 2
         TWO_PI = 2.0 * math.pi
         use_rings = obs_rings is not None and pred_rings is not None
+        use_scan_filter = (obs_scan_nrs is not None and
+                           grain_scan_mask is not None)
 
         ownership = torch.zeros(S, N, dtype=obs_spots.dtype, device=obs_spots.device)
         hkl_assignments = torch.zeros(S, N, dtype=torch.long, device=obs_spots.device)
 
         obs_eta = obs_spots[:, 1]    # (S,)
         obs_omega = obs_spots[:, 2]  # (S,)
 
+        # Pre-compute per-spot scan eligibility for each grain
+        # scan_ok[v] is (S,) bool: True if grain v is present at that spot's scan
+        scan_ok_per_grain = []
+        if use_scan_filter:
+            for v in range(N):
+                # grain_scan_mask[v] is (n_scans,) bool
+                # obs_scan_nrs is (S,) int
+                # Index into grain_scan_mask for each spot's scan number
+                scan_ok = grain_scan_mask[v][obs_scan_nrs]  # (S,) bool
+                scan_ok_per_grain.append(scan_ok)
+
         for v in range(N):
             valid_mask = pred_valid[v] > 0.5
             if not valid_mask.any():
@@ -278,6 +300,10 @@ def e_step(
 
                 in_box = ring_match & (d_omega.abs() < self.tol_omega) & (d_eta.abs() < self.tol_eta)
 
+                # Scan position filter: grain v must be present at this spot's scan
+                if use_scan_filter:
+                    in_box = in_box & scan_ok_per_grain[v]
+
                 # Distance for Gaussian kernel (only eta + omega, 2theta is handled by ring)
                 dist = torch.sqrt(d_omega ** 2 + d_eta ** 2)
 
@@ -460,6 +486,8 @@ def fit_from_orient(
         orient_matrices: torch.Tensor,
         positions: torch.Tensor,
         obs_rings: Optional[torch.Tensor] = None,
+        obs_scan_nrs: Optional[torch.Tensor] = None,
+        grain_scan_mask: Optional[torch.Tensor] = None,
         n_iter: int = 10,
         verbose: bool = True,
     ) -> EMResult:
@@ -475,6 +503,12 @@ def fit_from_orient(
         orient_matrices : (N, 3, 3) orientation matrices
         positions : (N, 3) grain positions (micrometers)
         obs_rings : (S,) int ring indices for observed spots
+        obs_scan_nrs : (S,) int scan number per observed spot (pf-HEDM).
+            If provided along with grain_scan_mask, the E-step filters
+            ownership by scan position.
+        grain_scan_mask : (N, n_scans) bool tensor. True if grain g is
+            present at scan s. Derived from the C code's sinograms:
+            grain_scan_mask[g, s] = any(sinos[g, :, s] > 0).
         n_iter : int
             Number of EM iterations (E-step + sigma annealing).
         verbose : bool
@@ -494,6 +528,8 @@ def fit_from_orient(
             ownership, hkl_assignments = self.e_step(
                 obs_spots, pred_coords, pred_valid,
                 obs_rings=obs_rings, pred_rings=pred_rings,
+                obs_scan_nrs=obs_scan_nrs,
+                grain_scan_mask=grain_scan_mask,
             )
 
             with torch.no_grad():
@@ -512,6 +548,8 @@ def fit_from_orient(
         ownership, hkl_assignments = self.e_step(
             obs_spots, pred_coords, pred_valid,
             obs_rings=obs_rings, pred_rings=pred_rings,
+            obs_scan_nrs=obs_scan_nrs,
+            grain_scan_mask=grain_scan_mask,
         )
 
         # Return orient_matrices reshaped as (N, 9) to fit EMResult euler_angles slot

tests/test_pf_hedm.py

@@ -3502,14 +3502,27 @@ def main():
                                                suffix='doTomo1_em_mlem')
                 passed = passed and em_passed
 
+                # --- Run 5: doTomo=1, FBP + EM spot-ownership (restart from indexing) ---
+                print('\n' + '#'*70)
+                print('  Run 5: doTomo=1, FBP + EM spot-ownership')
+                print('#'*70)
+                run_pf_pipeline(work_dir, args.nCPUs, doTomo=1,
+                                reconMethod='fbp', restartFrom='indexing',
+                                useEM=1)
+                em_fbp_passed = validate_tomo_recon(work_dir, 'em+fbp', gt)
+                cross_compare_gt_indexer_debug(work_dir, nCPUs=args.nCPUs,
+                                               suffix='doTomo1_em_fbp')
+                passed = passed and em_fbp_passed
+
                 # Summary
                 print('\n' + '='*70)
-                print('  4-WAY TOMO TEST SUMMARY')
+                print('  5-WAY TOMO TEST SUMMARY')
                 print('='*70)
                 print(f'    doTomo=0 (no recon):  {"PASS" if passed else "FAIL"}')
                 print(f'    doTomo=1, FBP:        {"PASS" if fbp_passed else "FAIL"}')
                 print(f'    doTomo=1, MLEM:       {"PASS" if mlem_passed else "FAIL"}')
                 print(f'    doTomo=1, EM+MLEM:    {"PASS" if em_passed else "FAIL"}')
+                print(f'    doTomo=1, EM+FBP:     {"PASS" if em_fbp_passed else "FAIL"}')
 
             if args.compare_seeded:
                 run_seeded_comparison(work_dir, args.nCPUs)