emdbva 0.0.1.dev147__tar.gz → 0.0.1.dev148__tar.gz

{emdbva-0.0.1.dev147/emdbva.egg-info → emdbva-0.0.1.dev148}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: emdbva
-Version: 0.0.1.dev147
+Version: 0.0.1.dev148
 Summary: CryoEM validation toolkit
 Home-page: https://test.pypi.org/project/va/
 Author: Zhe Wang

{emdbva-0.0.1.dev147 → emdbva-0.0.1.dev148/emdbva.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: emdbva
-Version: 0.0.1.dev147
+Version: 0.0.1.dev148
 Summary: CryoEM validation toolkit
 Home-page: https://test.pypi.org/project/va/
 Author: Zhe Wang

{emdbva-0.0.1.dev147 → emdbva-0.0.1.dev148}/emdbva.egg-info/SOURCES.txt

@@ -26,6 +26,7 @@ va/metrics/emda_mmcc.py
 va/metrics/emringer.py
 va/metrics/inclusion.py
 va/metrics/map_data_validation.py
+va/metrics/map_map_cc.py
 va/metrics/overlap_percentage.py
 va/metrics/phaserandomization.py
 va/metrics/phenix_cc.py

{emdbva-0.0.1.dev147 → emdbva-0.0.1.dev148}/va/mainva.py

@@ -119,6 +119,10 @@ def allruns(validationobj, runs):
         validationobj.fscs()
         # validationobj.surface_ratios()
 
+    # PHENIX map-map correlation
+    if 'mapmapcc' in runs:
+        validationobj.map_map_cc()
+
     # mmFSC
     if 'mmfsc' in runs:
         validationobj.phenix_mmfsc()

emdbva-0.0.1.dev148/va/metrics/map_map_cc.py

@@ -0,0 +1,139 @@
+"""PHENIX map-map correlation metric helpers."""
+
+import os
+import re
+import subprocess
+from distutils.spawn import find_executable
+
+
+_MAP_MAP_CC_PATTERN = re.compile(
+    r"Map-map CC is\s+([-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][-+]?\d+)?)"
+)
+
+
+def parse_map_map_cc_output(stdout_text):
+    """Extract the map-map correlation value from PHENIX output.
+
+    Args:
+        stdout_text (str): Combined standard output and error text from
+            ``phenix.map_correlations``.
+
+    Returns:
+        float or None: The parsed correlation, or ``None`` when the expected
+        result line is absent or cannot be converted to a number.
+    """
+    if not isinstance(stdout_text, str):
+        return None
+    match = _MAP_MAP_CC_PATTERN.search(stdout_text)
+    if match is None:
+        return None
+    try:
+        return float(match.group(1))
+    except (TypeError, ValueError):
+        return None
+
+
+def run_map_map_cc(map1_path, map2_path, output_path, echo=True):
+    """Run PHENIX map-map correlation for two map files.
+
+    Args:
+        map1_path (str): Path to the first map.
+        map2_path (str): Path to the second map.
+        output_path (str): Directory for the PHENIX stdout diagnostic file.
+        echo (bool): Whether to print captured PHENIX output.
+
+    Returns:
+        tuple: ``(errlist, result, stdout_text)``. ``result`` is empty when
+        the executable, inputs, subprocess, or parser fails.
+    """
+    errlist = []
+    result = {}
+    stdout_text = ""
+
+    phenix_path = find_executable("phenix.map_correlations")
+    if phenix_path is None:
+        return ["Phenix executable phenix.map_correlations is not available."], result, stdout_text
+
+    if not os.path.isfile(map1_path):
+        errlist.append("Map file does not exist: {}".format(map1_path))
+    if not os.path.isfile(map2_path):
+        errlist.append("Map file does not exist: {}".format(map2_path))
+    if errlist:
+        return errlist, result, stdout_text
+
+    try:
+        os.makedirs(output_path, exist_ok=True)
+    except OSError as exc:
+        return ["Could not create output directory {}: {}".format(output_path, exc)], result, stdout_text
+
+    command = [phenix_path, map1_path, map2_path]
+    try:
+        completed = subprocess.run(
+            command,
+            cwd=output_path,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            check=False,
+        )
+        stdout_text = completed.stdout or ""
+    except OSError as exc:
+        return ["Failed to run phenix.map_correlations: {}".format(exc)], result, stdout_text
+    finally:
+        log_path = os.path.join(output_path, "map_correlations.stdout")
+        try:
+            with open(log_path, "w", encoding="utf-8") as log_file:
+                log_file.write(stdout_text)
+        except OSError as exc:
+            errlist.append("Could not write {}: {}".format(log_path, exc))
+
+    if echo:
+        print(stdout_text, end="")
+    if completed.returncode != 0:
+        errlist.append("phenix.map_correlations exited with code {}".format(completed.returncode))
+    if "error" in stdout_text.lower():
+        errlist.extend(
+            line.strip() for line in stdout_text.splitlines() if "error" in line.lower()
+        )
+
+    correlation = parse_map_map_cc_output(stdout_text)
+    if correlation is None:
+        errlist.append("Could not parse 'Map-map CC is ...' from PHENIX output.")
+
+    if not errlist:
+        map1_name = os.path.basename(map1_path)
+        map2_name = os.path.basename(map2_path)
+        result = {"name": [map1_name, map2_name], "value": correlation}
+    return errlist, result, stdout_text
+
+
+def write_map_map_cc_json(map1_path, map2_path, correlation, output_path):
+    """Write a successful map-map correlation result as a JSON fragment.
+
+    Args:
+        map1_path (str): Path to the first map.
+        map2_path (str): Path to the second map.
+        correlation (float): Parsed map-map correlation value.
+        output_path (str): Directory in which to write the fragment.
+
+    Returns:
+        str: Path to the written JSON file.
+    """
+    import json
+
+    os.makedirs(output_path, exist_ok=True)
+    map1_name = os.path.basename(map1_path)
+    map2_name = os.path.basename(map2_path)
+    pair_name = "{}_{}".format(map1_name, map2_name)
+    output_file = os.path.join(output_path, pair_name + "_cc.json")
+    data = {
+        "map_map_cc": {
+            pair_name: {
+                "names": [map1_name, map2_name],
+                "value": correlation,
+            }
+        }
+    }
+    with open(output_file, "w", encoding="utf-8") as handle:
+        json.dump(data, handle, indent=2)
+    return output_file

{emdbva-0.0.1.dev147 → emdbva-0.0.1.dev148}/va/metrics/phaserandomization.py

@@ -89,7 +89,7 @@ def relion_mask(raw_map, out_dir, mapname=None):
         print(f'Relion mask command: {relion_mask_cmd}')
         # Produce my own mask to compare with relion mask and time
         try:
-            ownmask_loose = os.path.join(out_dir, f'{mapname}_ownmask.mrc')
+            ownmask_loose = os.path.join(out_dir, f'{mapname}_mask.mrc')
             relion_auto_mask(original_input_mrc, ownmask_loose, float(max_val_thirty), dilatepx, softpx)
             print(f'Relion auto mask command: {relion_auto_mask.__name__}')
         except Exception as e:
@@ -97,7 +97,7 @@ def relion_mask(raw_map, out_dir, mapname=None):
             ownmask_loose = None
 
         if angpix and max_val_thirty and dilatepx and softpx and input_mrc:
-            subprocess.run(relion_mask_cmd, shell=True)
+            # subprocess.run(relion_mask_cmd, shell=True)
             if not MapProcessor.check_map_starts(mask_loose, original_input_mrc):
                 print('Relion mask does not have the same nstarts as the original map.')
                 MapProcessor.update_map_starts(original_input_mrc, mask_loose)
@@ -221,7 +221,7 @@ def relion_auto_mask_fast(data, threshold, extend_pixels, edge_width, verbose=Tr
     steps = []
     if verbose:
         steps = tqdm(total=3, desc="Masking Steps", unit="step")
- 
+
     # Step 1: Initial binary mask
     mask = (data >= threshold).astype(np.float32)
     if verbose:

{emdbva-0.0.1.dev147 → emdbva-0.0.1.dev148}/va/preparation.py

@@ -910,7 +910,7 @@ class PreParation:
                        'volume': False, 'fsc': False, 'raps': False, 'mapmodel': False, 'inclusion': False,
                        'largestvariance': False, 'mask': False, 'symmetry': False, 'rmmcc': False, 'smoc': False,
                        'resccc': False, 'emringer': False, 'strudel': False, '3dfsc': False, 'locres': False,
-                       'phrand': False, 'predictcontour': False}
+                       'phrand': False, 'predictcontour': False, 'mapmapcc': False}
             for key in resdict.keys():
                 if key in runs:
                     resdict[key] = True
@@ -924,7 +924,7 @@ class PreParation:
             if self.mapname is not None:
                 runlist.extend(['projection', 'central', 'surface', 'volume', 'density', 'raps', 'largestvariance',
                                 'mask', 'fsc', 'mmfsc', 'rmmcc', 'symmetry', 'qscore', 'strudel', 'emringer', '3dfsc',
-                                'smoc', 'resccc', 'locres', 'phrand', 'predictcontour',
+                                'smoc', 'resccc', 'locres', 'phrand', 'predictcontour', 'mapmapcc',
                                 ])
 
             if self.masks is None:

{emdbva-0.0.1.dev147 → emdbva-0.0.1.dev148}/va/utils/stars.py

@@ -757,9 +757,139 @@ class GetStars:
 
         return area
 
+    @staticmethod
+    def curve_touches_or_crosses_zero(curve, atol=1e-12):
+        """
+        Check whether a curve touches or crosses y=0.
+
+        Returns
+        -------
+        bool
+            True if:
+            - any sampled value is approximately zero, OR
+            - two adjacent values have opposite signs.
+
+            False if the entire curve stays strictly on one side of zero.
+
+        Parameters
+        ----------
+        curve : array-like
+            Y values of the curve.
+
+        atol : float
+            Absolute tolerance used to consider a value equal to zero.
+        """
+
+        curve = np.asarray(curve, dtype=float)
+
+        # Ignore NaN / +/-inf values.
+        curve = curve[np.isfinite(curve)]
+
+        if curve.size == 0:
+            return False
+
+        # Does an actual sampled point touch zero?
+        if np.any(np.isclose(curve, 0.0, atol=atol, rtol=0.0)):
+            return True
+
+        # Does the curve cross zero between two adjacent samples?
+        crosses_zero = np.any(
+            curve[:-1] * curve[1:] < 0
+        )
+
+        return bool(crosses_zero)
+
     def feature_zone(self, data_curves):
         """
-        Given two curves, calculate feature zone and overfit zone.
+        Calculate feature-zone, overfit-zone, and masking diagnostics.
+
+        Masking notation
+        ----------------
+        M = masked FSC
+        C = corrected FSC
+        U = unmasked FSC
+
+        The masking metrics are:
+
+            N = integral(M - C) dx
+
+                Signed Masked-Corrected area.
+                N > 0 : M is above C in the integrated sense.
+                N < 0 : C is above M in the integrated sense.
+
+            D = integral(M - U) dx
+
+                Signed Masked-Unmasked area.
+                D > 0 : M is above U in the integrated sense.
+                D < 0 : U is above M in the integrated sense.
+
+            R_signed = N / D
+
+                Signed relative position of C with respect to M and U.
+                This is useful for determining the integrated ordering
+                of the three curves, but can become unreliable when D
+                is close to zero because of curve crossing/cancellation.
+
+            MC_abs = integral(|M - C|) dx
+
+                Total absolute separation between Masked and Corrected.
+
+            MU_abs = integral(|M - U|) dx
+
+                Total absolute separation between Masked and Unmasked.
+
+            R_abs = MC_abs / MU_abs
+
+                Main masking discrepancy metric.
+
+                This value is stored using the existing key:
+
+                    masking_area_ratio
+
+                for backwards compatibility.
+
+                R_abs ~= 0:
+                    Masked and Corrected track very closely.
+
+                Increasing R_abs:
+                    Increasing Masked-Corrected disagreement relative
+                    to the overall Masked-Unmasked separation.
+
+                R_abs ~= 1:
+                    Masked-Corrected disagreement is approximately as
+                    large as Masked-Unmasked disagreement.
+
+                R_abs > 1:
+                    Corrected is, in total absolute area, farther from
+                    Masked than Unmasked is from Masked.
+
+            Q_mc = |N| / MC_abs
+
+                Directionality/cancellation metric for M-C.
+
+                Q_mc ~= 1:
+                    M-C has mostly one sign. The sign of N is meaningful.
+
+                Q_mc ~= 0:
+                    Strong crossing/cancellation between M and C.
+                    The sign of N alone should not be interpreted as a
+                    simple global curve ordering.
+
+            Q_mu = |D| / MU_abs
+
+                Directionality/cancellation metric for M-U.
+
+                Q_mu ~= 1:
+                    M-U has mostly one sign. The sign of D is meaningful.
+
+                Q_mu ~= 0:
+                    Strong crossing/cancellation between M and U.
+                    R_signed may therefore be unstable or misleading.
+
+        Notes
+        -----
+        All masking metrics are calculated over the same complete valid
+        frequency range. No high-frequency-only restriction is applied.
         """
 
         zones = {}
@@ -771,28 +901,42 @@ class GetStars:
 
         levels = all_curves.get('level')
         corrected_curve = all_curves.get('fsc_corrected')
-
         phase_rand_curve = all_curves.get('phaserandomization')
+
         if phase_rand_curve is None:
             phase_rand_curve = all_curves.get('phaserandmization')
 
         masked_curve = all_curves.get('fsc_masked')
         unmasked_curve = all_curves.get('fsc')
 
-        if levels is None or corrected_curve is None or phase_rand_curve is None:
+        if (
+                levels is None
+                or corrected_curve is None
+                or phase_rand_curve is None
+        ):
             return result
 
         try:
+            # ----------------------------------------------------------
+            # Prepare feature-zone curves
+            # ----------------------------------------------------------
+
             levels = np.asarray(levels, dtype=float)
             corrected_curve = np.asarray(corrected_curve, dtype=float)
             phase_rand_curve = np.asarray(phase_rand_curve, dtype=float)
 
-            min_len = min(len(levels), len(corrected_curve), len(phase_rand_curve))
+            min_len = min(
+                len(levels),
+                len(corrected_curve),
+                len(phase_rand_curve),
+            )
 
             levels = levels[:min_len]
             corrected_curve = corrected_curve[:min_len]
             phase_rand_curve = phase_rand_curve[:min_len]
 
+            # Remove points that cannot be used for the feature-zone
+            # calculation.
             valid = (
                     np.isfinite(levels)
                     & np.isfinite(corrected_curve)
@@ -806,11 +950,38 @@ class GetStars:
             if len(levels) < 2:
                 return result
 
+            # Integration and interpolation require an ordered x axis.
             order = np.argsort(levels)
+
             levels = levels[order]
             corrected_curve = corrected_curve[order]
             phase_rand_curve = phase_rand_curve[order]
 
+            # ----------------------------------------------------------
+            # Check whether corrected FSC and phase-randomized FSC
+            # touch or cross y=0.
+            # ----------------------------------------------------------
+
+            corrected_touches_zero = self.curve_touches_or_crosses_zero(
+                corrected_curve
+            )
+
+            phase_touches_zero = self.curve_touches_or_crosses_zero(
+                phase_rand_curve
+            )
+
+            feature_zone_corrected_fsc_nottouching_zero = (
+                not corrected_touches_zero
+            )
+
+            feature_zone_phase_fsc_nottouching_zero = (
+                not phase_touches_zero
+            )
+
+            # ----------------------------------------------------------
+            # Feature-zone / overfit-zone calculation
+            # ----------------------------------------------------------
+
             xs, ys = interpolated_intercepts_general(
                 levels,
                 corrected_curve,
@@ -819,7 +990,11 @@ class GetStars:
 
             intersections = remove_duplicate_intersections(xs, ys)
 
-            nlevels, ncorrected_curve, nphase_rand_curve = self.intersections_into_curve(
+            (
+                nlevels,
+                ncorrected_curve,
+                nphase_rand_curve,
+            ) = self.intersections_into_curve(
                 intersections,
                 levels,
                 corrected_curve,
@@ -833,63 +1008,390 @@ class GetStars:
                 nphase_rand_curve,
             )
 
+            # ----------------------------------------------------------
+            # Default masking values
+            # ----------------------------------------------------------
+
+            masking_area = 0.0
+
+            # Existing indexed field.
+            # This will now contain R_abs.
+            masking_area_ratio = np.nan
+
+            masked_corrected_signed_area = np.nan  # N
+            masked_unmasked_signed_area = np.nan  # D
+
+            masked_corrected_absolute_area = np.nan  # MC_abs
+            masked_unmasked_absolute_area = np.nan  # MU_abs
+
+            masking_signed_ratio = np.nan  # R_signed
+
+            masked_corrected_directionality = np.nan  # Q_mc
+            masked_unmasked_directionality = np.nan  # Q_mu
+
+            # ----------------------------------------------------------
+            # Masking calculations
+            # ----------------------------------------------------------
+
             if masked_curve is not None and unmasked_curve is not None:
-                masked_curve = np.asarray(masked_curve, dtype=float)[:min_len][valid]
-                unmasked_curve = np.asarray(unmasked_curve, dtype=float)[:min_len][valid]
 
+                # Apply exactly the same initial trimming and validity mask
+                # that was used for levels/corrected/phase-randomized curves.
+                masked_curve = np.asarray(
+                    masked_curve,
+                    dtype=float,
+                )[:min_len][valid]
+
+                unmasked_curve = np.asarray(
+                    unmasked_curve,
+                    dtype=float,
+                )[:min_len][valid]
+
+                # Apply the same sorting order.
                 masked_curve = masked_curve[order]
                 unmasked_curve = unmasked_curve[order]
 
-                masking_area = self.area_difference(
-                    masked_curve,
-                    corrected_curve,
-                    levels,
+                # ------------------------------------------------------
+                # There may still be non-finite values in M or U even
+                # though level/C/phase-randomized were valid.
+                #
+                # Use one common mask so M, C, U and x always remain
+                # aligned.
+                # ------------------------------------------------------
+
+                mask_valid = (
+                        np.isfinite(levels)
+                        & np.isfinite(masked_curve)
+                        & np.isfinite(corrected_curve)
+                        & np.isfinite(unmasked_curve)
                 )
 
-                corrected_unmasked_difference = np.nansum(
-                    corrected_curve - unmasked_curve
-                )
-                corrected_masked_difference = np.nansum(
-                    masked_curve - corrected_curve
-                )
+                mask_levels = levels[mask_valid]
+                mask_masked = masked_curve[mask_valid]
+                mask_corrected = corrected_curve[mask_valid]
+                mask_unmasked = unmasked_curve[mask_valid]
+
+                if len(mask_levels) >= 2:
+
+                    # ==================================================
+                    # Signed areas
+                    # ==================================================
+
+                    # N = integral(M - C) dx
+                    #
+                    # Positive:
+                    #     Masked has more integrated area than Corrected.
+                    #
+                    # Negative:
+                    #     Corrected has more integrated area than Masked.
+                    masked_corrected_signed_area = np.trapz(
+                        mask_masked - mask_corrected,
+                        mask_levels,
+                    )
 
-                if corrected_unmasked_difference == 0:
-                    masking_area_ratio = 999
-                else:
-                    masking_area_ratio = abs(
-                        corrected_masked_difference / corrected_unmasked_difference
+                    # D = integral(M - U) dx
+                    #
+                    # Positive:
+                    #     Masked has more integrated area than Unmasked.
+                    #
+                    # Negative:
+                    #     Unmasked has more integrated area than Masked.
+                    masked_unmasked_signed_area = np.trapz(
+                        mask_masked - mask_unmasked,
+                        mask_levels,
+                    )
+
+                    # ==================================================
+                    # Absolute areas
+                    # ==================================================
+
+                    # Total geometrical separation between M and C.
+                    masked_corrected_absolute_area = np.trapz(
+                        np.abs(mask_masked - mask_corrected),
+                        mask_levels,
+                    )
+
+                    # Total geometrical separation between M and U.
+                    masked_unmasked_absolute_area = np.trapz(
+                        np.abs(mask_masked - mask_unmasked),
+                        mask_levels,
+                    )
+
+                    # Keep the historical "masking_area" field, but make
+                    # its definition consistent with the new masking
+                    # metric:
+                    #
+                    #     masking_area = integral(|M-C|) dx
+                    #
+                    masking_area = masked_corrected_absolute_area
+
+                    # ==================================================
+                    # R_signed = N / D
+                    # ==================================================
+
+                    if not np.isclose(
+                            masked_unmasked_signed_area,
+                            0.0,
+                            rtol=1e-8,
+                            atol=1e-12,
+                    ):
+                        masking_signed_ratio = (
+                                masked_corrected_signed_area
+                                / masked_unmasked_signed_area
+                        )
+                    else:
+                        # D ~= 0 makes N/D undefined or numerically
+                        # unstable.
+                        masking_signed_ratio = np.nan
+
+                    # ==================================================
+                    # R_abs = MC_abs / MU_abs
+                    #
+                    # THIS replaces the old masking_area_ratio.
+                    # ==================================================
+
+                    if not np.isclose(
+                            masked_unmasked_absolute_area,
+                            0.0,
+                            rtol=1e-8,
+                            atol=1e-12,
+                    ):
+                        masking_area_ratio = (
+                                masked_corrected_absolute_area
+                                / masked_unmasked_absolute_area
+                        )
+                    else:
+                        # If M and U have essentially no absolute
+                        # separation, there is no meaningful denominator
+                        # against which to normalize M-C.
+                        masking_area_ratio = np.nan
+
+                    # ==================================================
+                    # Q_mc
+                    #
+                    # |integral(M-C)| / integral(|M-C|)
+                    # ==================================================
+
+                    if not np.isclose(
+                            masked_corrected_absolute_area,
+                            0.0,
+                            rtol=1e-8,
+                            atol=1e-12,
+                    ):
+                        masked_corrected_directionality = (
+                                abs(masked_corrected_signed_area)
+                                / masked_corrected_absolute_area
+                        )
+                    else:
+                        # M and C essentially coincide.
+                        #
+                        # There is no cancellation to diagnose. Setting
+                        # Q_mc to 1 is convenient because their difference
+                        # is perfectly consistent (zero everywhere within
+                        # numerical tolerance).
+                        masked_corrected_directionality = 1.0
+
+                    # ==================================================
+                    # Q_mu
+                    #
+                    # |integral(M-U)| / integral(|M-U|)
+                    # ==================================================
+
+                    if not np.isclose(
+                            masked_unmasked_absolute_area,
+                            0.0,
+                            rtol=1e-8,
+                            atol=1e-12,
+                    ):
+                        masked_unmasked_directionality = (
+                                abs(masked_unmasked_signed_area)
+                                / masked_unmasked_absolute_area
+                        )
+                    else:
+                        # Same convention as Q_mc.
+                        masked_unmasked_directionality = 1.0
+
+                    # Numerical integration may occasionally produce
+                    # 1.0000000000000002 etc.
+                    masked_corrected_directionality = min(
+                        1.0,
+                        max(
+                            0.0,
+                            float(masked_corrected_directionality),
+                        ),
+                    )
+
+                    masked_unmasked_directionality = min(
+                        1.0,
+                        max(
+                            0.0,
+                            float(masked_unmasked_directionality),
+                        ),
                     )
-            else:
-                masking_area = 0.0
-                masking_area_ratio = 0.0
+
+            # ----------------------------------------------------------
+            # Convert main feature-zone results
+            # ----------------------------------------------------------
 
             feature_area = float(feature_area or 0.0)
             overfit_area = float(overfit_area or 0.0)
             masking_area = float(masking_area or 0.0)
-            masking_area_ratio = float(masking_area_ratio or 0.0)
 
-            zones['feature_zone'] = keep_three_significant_digits(feature_area)
-            zones['overfit_zone'] = keep_three_significant_digits(overfit_area)
-            zones['masking_area'] = keep_three_significant_digits(masking_area)
-            zones['masking_area_ratio'] = keep_three_significant_digits(masking_area_ratio)
+            # ----------------------------------------------------------
+            # Existing output fields
+            # ----------------------------------------------------------
+
+            zones['feature_zone'] = keep_three_significant_digits(
+                feature_area
+            )
+
+            zones['overfit_zone'] = keep_three_significant_digits(
+                overfit_area
+            )
+
+            zones['masking_area'] = keep_three_significant_digits(
+                masking_area
+            )
+
+            zones['feature_zone_corrected_fsc_nottouching_zero'] = (
+                feature_zone_corrected_fsc_nottouching_zero
+            )
+
+            zones['feature_zone_phase_fsc_nottouching_zero'] = (
+                feature_zone_phase_fsc_nottouching_zero
+            )
+
+            # IMPORTANT:
+            #
+            # Keep this key unchanged because it is already indexed by
+            # downstream code.
+            #
+            # It now represents:
+            #
+            #     integral(|M-C|) / integral(|M-U|)
+            #
+            if np.isfinite(masking_area_ratio):
+                zones['masking_area_ratio'] = keep_three_significant_digits(
+                    float(masking_area_ratio)
+                )
+            else:
+                zones['masking_area_ratio'] = None
+
+            # ----------------------------------------------------------
+            # New masking diagnostic fields
+            # ----------------------------------------------------------
+
+            # N
+            if np.isfinite(masked_corrected_signed_area):
+                zones['masked_corrected_signed_area'] = (
+                    keep_three_significant_digits(
+                        float(masked_corrected_signed_area)
+                    )
+                )
+            else:
+                zones['masked_corrected_signed_area'] = None
+
+            # D
+            if np.isfinite(masked_unmasked_signed_area):
+                zones['masked_unmasked_signed_area'] = (
+                    keep_three_significant_digits(
+                        float(masked_unmasked_signed_area)
+                    )
+                )
+            else:
+                zones['masked_unmasked_signed_area'] = None
+
+            # Absolute M-C area
+            if np.isfinite(masked_corrected_absolute_area):
+                zones['masked_corrected_absolute_area'] = (
+                    keep_three_significant_digits(
+                        float(masked_corrected_absolute_area)
+                    )
+                )
+            else:
+                zones['masked_corrected_absolute_area'] = None
+
+            # Absolute M-U area
+            if np.isfinite(masked_unmasked_absolute_area):
+                zones['masked_unmasked_absolute_area'] = (
+                    keep_three_significant_digits(
+                        float(masked_unmasked_absolute_area)
+                    )
+                )
+            else:
+                zones['masked_unmasked_absolute_area'] = None
+
+            # R_signed
+            if np.isfinite(masking_signed_ratio):
+                zones['masking_signed_ratio'] = (
+                    keep_three_significant_digits(
+                        float(masking_signed_ratio)
+                    )
+                )
+            else:
+                zones['masking_signed_ratio'] = None
+
+            # Q_mc
+            if np.isfinite(masked_corrected_directionality):
+                zones['masked_corrected_directionality'] = (
+                    keep_three_significant_digits(
+                        float(masked_corrected_directionality)
+                    )
+                )
+            else:
+                zones['masked_corrected_directionality'] = None
+
+            # Q_mu
+            if np.isfinite(masked_unmasked_directionality):
+                zones['masked_unmasked_directionality'] = (
+                    keep_three_significant_digits(
+                        float(masked_unmasked_directionality)
+                    )
+                )
+            else:
+                zones['masked_unmasked_directionality'] = None
+
+            # ----------------------------------------------------------
+            # Feature-zone ratio
+            # ----------------------------------------------------------
 
             total_area = feature_area + overfit_area
-            if total_area == 0:
+
+            if np.isclose(total_area, 0.0):
                 zones['feature_zone_ratio'] = 0
             else:
-                zones['feature_zone_ratio'] = keep_three_significant_digits(
-                    feature_area / total_area
+                zones['feature_zone_ratio'] = (
+                    keep_three_significant_digits(
+                        feature_area / total_area
+                    )
                 )
 
             result['feature_zones'] = zones
 
         except Exception as exc:
             print(f'Feature zone calculation failed: {exc}')
+
             result['feature_zones'] = {
                 'feature_zone': 0,
                 'overfit_zone': 0,
+
+                'feature_zone_corrected_fsc_nottouching_zero': None,
+                'feature_zone_phase_fsc_nottouching_zero': None,
+
+                # Existing indexed fields
                 'masking_area': 0,
-                'masking_area_ratio': 0,
+                'masking_area_ratio': None,
+
+
+                # New masking diagnostics
+                'masked_corrected_signed_area': None,
+                'masked_unmasked_signed_area': None,
+                'masked_corrected_absolute_area': None,
+                'masked_unmasked_absolute_area': None,
+                'masking_signed_ratio': None,
+                'masked_corrected_directionality': None,
+                'masked_unmasked_directionality': None,
+
                 'feature_zone_ratio': 0,
                 'error': str(exc),
             }

{emdbva-0.0.1.dev147 → emdbva-0.0.1.dev148}/va/validationanalysis.py

@@ -77,6 +77,7 @@ from va.metrics.qscore import *
 from va.metrics.inclusion import *
 from va.metrics.connected_percentage import *
 from va.metrics.overlap_percentage import *
+from va.metrics.map_map_cc import run_map_map_cc, write_map_map_cc_json
 from metrics.map_data_validation import run_map_data_validation
 import va
 
@@ -227,8 +228,8 @@ class ValidationAnalysis:
         self.get_resolution()
         self.relion_mask = None
         self.masked_rawmap = None
-        if self.rawmap:
-            self.relion_mask = self.get_relion_mask()
+        # if self.rawmap:
+        #     self.relion_mask = self.get_relion_mask()
         # make a symbolic link for relion_mask in the va folder
         if self.relion_mask:
             mask_name = os.path.basename(self.relion_mask)
@@ -4053,6 +4054,42 @@ class ValidationAnalysis:
             print('Mising half map(s).')
 
 
+    def map_map_cc(self):
+        """Calculate PHENIX map-map CC for the primary and half maps.
+
+        The metric is opt-in through the ``mapmapcc`` run token. It writes a
+        JSON fragment for each successful primary/half-map or half-map pair
+        and skips cleanly when the required maps are unavailable.
+        """
+        if self.map is None or self.hmeven is None or self.hmodd is None:
+            print('Map-map CC skipped: primary map and both half maps are required.')
+            return None
+
+        primary_path = getattr(self.map, 'fullname', None)
+        even_path = getattr(self.hmeven, 'fullname', None)
+        odd_path = getattr(self.hmodd, 'fullname', None)
+        if not primary_path or not even_path or not odd_path:
+            print('Map-map CC skipped: primary or half-map filenames are unavailable.')
+            return None
+        if not all(os.path.isfile(path) for path in (primary_path, even_path, odd_path)):
+            print('Map-map CC skipped: one or more required map files do not exist.')
+            return None
+
+        map_pairs = (
+            (primary_path, odd_path),
+            (primary_path, even_path),
+            (even_path, odd_path),
+        )
+        for map1_path, map2_path in map_pairs:
+            errlist, result, _stdout = run_map_map_cc(map1_path, map2_path, self.workdir)
+            if errlist:
+                for error in errlist:
+                    sys.stderr.write('Map-map CC error: {}\n'.format(error))
+                continue
+            write_map_map_cc_json(map1_path, map2_path, result['value'], self.workdir)
+        return None
+
+
     def readfsc(self, asym=1.0):
         """
 

{emdbva-0.0.1.dev147 → emdbva-0.0.1.dev148}/va/version.py

@@ -18,5 +18,5 @@ under the License.
 
 """
 
-__version__ = '0.0.1.dev147'
+__version__ = '0.0.1.dev148'
 __em_statistics_version__ = '202505.v01'