emdbva 0.0.1.dev146__tar.gz → 0.0.1.dev148__tar.gz

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

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

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

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

{emdbva-0.0.1.dev146 → 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.dev146 → 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.dev146 → 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.dev146 → 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: