emdbva 0.0.1.dev152__tar.gz → 0.0.1.dev155__tar.gz

{emdbva-0.0.1.dev152/emdbva.egg-info → emdbva-0.0.1.dev155}/PKG-INFO

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

{emdbva-0.0.1.dev152 → emdbva-0.0.1.dev155/emdbva.egg-info}/PKG-INFO

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

{emdbva-0.0.1.dev152 → emdbva-0.0.1.dev155}/emdbva.egg-info/SOURCES.txt

@@ -30,6 +30,7 @@ va/metrics/map_map_cc.py
 va/metrics/overlap_percentage.py
 va/metrics/phaserandomization.py
 va/metrics/phenix_cc.py
+va/metrics/phenix_locres.py
 va/metrics/phenix_mm.py
 va/metrics/projections.py
 va/metrics/qscore.py
@@ -47,6 +48,7 @@ va/utils/ChimeraxViews.py
 va/utils/MapProcessor.py
 va/utils/Model.py
 va/utils/__init__.py
+va/utils/chimerax_combined_locres.py
 va/utils/cl_weights.pth
 va/utils/log_utils.py
 va/utils/misc.py

{emdbva-0.0.1.dev152 → emdbva-0.0.1.dev155}/va/mainva.py

@@ -151,13 +151,18 @@ def allruns(validationobj, runs):
     #     validationobj.phrand()
 
     # Resmap local resolution
-    if 'locres' in runs:
-        validationobj.mask_volume()
-        validationobj.locres_resmap()
-        validationobj.locres_histo()
-        validationobj.locres_residue()
-        validationobj.model_map_ration()
-        validationobj.locres_map()
+    # if 'locres' in runs:
+    #     validationobj.mask_volume()
+    #     validationobj.locres_resmap()
+    #     validationobj.locres_histo()
+    #     validationobj.locres_residue()
+    #     validationobj.model_map_ration()
+    #     validationobj.locres_map()
+
+    if 'locres_phe' in runs:
+        validationobj.phenix_local_resolution(run_phenix=True)
+    elif 'locres_phe_results' in runs:
+        validationobj.phenix_local_resolution(run_phenix=False)
 
     # EMringer
     if 'emringer' in runs:

emdbva-0.0.1.dev155/va/metrics/phenix_locres.py

@@ -0,0 +1,324 @@
+"""Run PHENIX local-resolution calculations and serialize their results."""
+
+import json
+import os
+import re
+import subprocess
+import sys
+from distutils.spawn import find_executable
+
+
+EXECUTABLE = "phenix.local_resolution"
+
+
+def find_local_resolution_executable():
+    """Find the PHENIX local-resolution executable on ``PATH``."""
+    return find_executable(EXECUTABLE)
+
+
+def validate_inputs(half_maps):
+    """Return validation errors for the two required half maps."""
+    errors = []
+    if len(half_maps) != 2:
+        return ["PHENIX local resolution requires exactly two half maps."]
+    for label, path in (("half map 1", half_maps[0]), ("half map 2", half_maps[1])):
+        if not path or not os.path.isfile(path):
+            errors.append("Required {} is missing: {}".format(label, path))
+    return errors
+
+
+def build_command(executable, half_maps, output_dir, resolution=None):
+    """Build a PHENIX command with both documented half-map PHIL inputs."""
+    command = [
+        executable,
+        "input_files.map_model.half_map={}".format(os.path.abspath(half_maps[0])),
+        "input_files.map_model.half_map={}".format(os.path.abspath(half_maps[1])),
+        "output.prefix={}".format(os.path.join(os.path.abspath(output_dir), "phenix_locres")),
+        "output.overwrite=True",
+    ]
+    if resolution is not None:
+        command.append("crystal_info.resolution={}".format(resolution))
+    return command
+
+
+def find_output_map(output_dir, half_maps, stdout=""):
+    """Locate the local-resolution map reported by PHENIX, excluding full maps."""
+    match = re.search(r"^\s*local_resolution_map\s*:\s*(\S+)\s*$", stdout, re.MULTILINE)
+    if match:
+        reported_path = match.group(1)
+        candidate = reported_path if os.path.isabs(reported_path) else os.path.join(output_dir, reported_path)
+        if os.path.isfile(candidate):
+            return candidate
+
+    candidates = []
+    for half_map in half_maps:
+        half_map_stem = os.path.splitext(os.path.basename(half_map))[0]
+        candidate = os.path.join(output_dir, "{}_local_resolution.ccp4".format(half_map_stem))
+        if os.path.isfile(candidate) and candidate not in candidates:
+            candidates.append(candidate)
+    return candidates[0] if len(candidates) == 1 else None
+
+
+def output_map_paths(output_dir, half_maps):
+    """Return the expected local-resolution and full-map output paths."""
+    pair_name = "{}_{}".format(
+        os.path.basename(half_maps[0]), os.path.basename(half_maps[1])
+    )
+    return (os.path.join(output_dir, "{}_local_resolution.map".format(pair_name)),
+            os.path.join(output_dir, "{}_full.map".format(pair_name)))
+
+
+def rename_output_maps(output_dir, half_maps, stdout=""):
+    """Rename PHENIX local-resolution and sharpened maps using both input names."""
+    local_map = find_output_map(output_dir, half_maps, stdout)
+    if local_map is None:
+        return None, None
+
+    full_match = re.search(r"^\s*full_map\s*:\s*(\S+)\s*$", stdout, re.MULTILINE)
+    full_map = None
+    if full_match:
+        reported_path = full_match.group(1)
+        candidate = reported_path if os.path.isabs(reported_path) else os.path.join(output_dir, reported_path)
+        if os.path.isfile(candidate):
+            full_map = candidate
+
+    local_destination, full_destination = output_map_paths(output_dir, half_maps)
+    os.replace(local_map, local_destination)
+
+    if full_map is not None:
+        os.replace(full_map, full_destination)
+    else:
+        full_destination = None
+    return local_destination, full_destination
+
+
+def read_map_statistics(map_path):
+    """Read basic statistics from a PHENIX local-resolution map."""
+    try:
+        import mrcfile
+        import numpy as np
+    except ImportError as exc:
+        raise RuntimeError("mrcfile and numpy are required to read the PHENIX map: {}".format(exc))
+
+    with mrcfile.open(map_path, permissive=False) as map_file:
+        values = np.asarray(map_file.data, dtype=float)
+        values = values[np.isfinite(values)]
+        if values.size == 0:
+            raise ValueError("Local-resolution map contains no finite values.")
+        return {
+            "min": float(values.min()),
+            "max": float(values.max()),
+            "mean": float(values.mean()),
+        }
+
+
+def reuse_local_resolution(half_maps, output_dir):
+    """Load an existing PHENIX output map without invoking PHENIX.
+
+    Returns:
+        dict or None: A result suitable for post-processing, or None if the
+        expected map is missing or unreadable.
+    """
+    if len(half_maps) != 2 or not all(half_maps):
+        print('Cannot reuse PHENIX local resolution: both half-map names are required.')
+        return None
+    output_map, full_map = output_map_paths(output_dir, half_maps)
+    if not os.path.isfile(output_map):
+        print('No existing PHENIX local-resolution map found: {}'.format(output_map))
+        return None
+    try:
+        statistics = read_map_statistics(output_map)
+    except Exception as exc:
+        print('Cannot read existing PHENIX local-resolution map {}: {}'.format(output_map, exc))
+        return None
+    return {
+        'status': 'success',
+        'method': 'phenix',
+        'output_map': os.path.relpath(output_map, output_dir),
+        'full_map': os.path.relpath(full_map, output_dir) if os.path.isfile(full_map) else None,
+        'statistics': statistics,
+        'reused': True,
+    }
+
+
+def run_local_resolution(half_maps, output_dir, resolution=None):
+    """Run PHENIX and return a structured success or error result."""
+    result = {"status": "error", "method": "phenix", "errors": []}
+    errors = validate_inputs(half_maps)
+    if errors:
+        result["errors"] = errors
+        return result
+
+    executable = find_local_resolution_executable()
+    if not executable:
+        result["errors"] = ["PHENIX executable {} is not available.".format(EXECUTABLE)]
+        return result
+
+    os.makedirs(output_dir, exist_ok=True)
+    command = build_command(executable, half_maps, output_dir, resolution)
+    print(f"Phenix local resolution command: {' '.join(command)}")
+    try:
+        process = subprocess.Popen(
+            command,
+            cwd=output_dir,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+        )
+        output_lines = []
+        for line in process.stdout:
+            print(line, end="", flush=True)
+            output_lines.append(line)
+        return_code = process.wait()
+    except OSError as exc:
+        result["errors"] = ["Could not start {}: {}".format(EXECUTABLE, exc)]
+        return result
+
+    result["stdout"] = "".join(output_lines)
+    result["return_code"] = return_code
+    if return_code != 0:
+        result["errors"] = ["{} exited with code {}.".format(EXECUTABLE, return_code)]
+        return result
+
+    output_map, full_map = rename_output_maps(output_dir, half_maps, result["stdout"])
+    if output_map is None or not os.path.isfile(output_map):
+        result["errors"] = ["PHENIX did not produce one identifiable local-resolution map."]
+        return result
+    try:
+        statistics = read_map_statistics(output_map)
+    except Exception as exc:
+        result["errors"] = ["Could not read PHENIX local-resolution map: {}".format(exc)]
+        return result
+
+    return {
+        "status": "success",
+        "method": "phenix",
+        "output_map": os.path.relpath(output_map, output_dir),
+        "full_map": os.path.relpath(full_map, output_dir) if full_map else None,
+        "statistics": statistics,
+        "return_code": return_code,
+    }
+
+
+def write_result(output_path, result):
+    """Write a PHENIX local-resolution JSON fragment."""
+    with open(output_path, "w", encoding="utf-8") as output_file:
+        json.dump({"phenix_local_resolution": result}, output_file, indent=2)
+    return output_path
+
+
+def create_local_resolution_views(chimerax, map_path, resolution_map, contour, output_dir, prefix):
+    """Generate three ChimeraX surface views colored by local resolution."""
+    if not chimerax:
+        raise RuntimeError("ChimeraX executable is not available.")
+    for path in (map_path, resolution_map):
+        if not path or not os.path.isfile(path):
+            raise FileNotFoundError("Map file does not exist: {}".format(path))
+    if contour is None:
+        raise ValueError("A contour level is required for the surface view.")
+
+    def quoted(path):
+        return '"{}"'.format(os.path.abspath(path).replace('\\', '\\\\').replace('"', '\\"'))
+
+    script_path = os.path.join(output_dir, prefix + '_chimerax.cxc')
+    images = {
+        'original': {axis: prefix + '_' + axis.upper() + '.png' for axis in ('x', 'y', 'z')},
+        'scaled': {axis: prefix + '_scaled_' + axis.upper() + '.png' for axis in ('x', 'y', 'z')},
+    }
+    with open(script_path, 'w', encoding='utf-8') as script:
+        script.write('open {}\nvolume #1 style surface\nvolume #1 step 1\n'.format(quoted(map_path)))
+        script.write('volume #1 level {}\n'.format(float(contour)))
+        script.write('open {}\nvolume #2 style surface\nvolume #2 step 1\n'.format(quoted(resolution_map)))
+        script.write('hide #2 models\nset bgColor #B8B8B8\ncolor sample #1 map #2 palette blue:white:red range full key true\n')
+        script.write('key pos 0.25,0.05 size 0.53,0.015 labelSide right/bottom fontSize 9 border false labelColor black\n')
+        for axis, rotation in (('z', ''), ('x', 'turn y 90\n'), ('y', 'turn x -90\n')):
+            script.write('view orient\n' + rotation)
+            script.write('view #1 pad 0.25 cofr true\n')
+            script.write('save {} width 1200 height 1200\n'.format(
+                quoted(os.path.join(output_dir, images['original'][axis]))))
+            script.write('save {} width 300 height 300\n'.format(
+                quoted(os.path.join(output_dir, images['scaled'][axis]))))
+        script.write('exit\n')
+    has_display = bool(os.environ.get('DISPLAY') or os.environ.get('WAYLAND_DISPLAY'))
+    if sys.platform == 'darwin' and not os.environ.get('SSH_CONNECTION'):
+        has_display = True
+    command = [chimerax]
+    if not has_display:
+        command.extend(['--offscreen', '--nogui'])
+    command.append(script_path)
+    subprocess.run(command, cwd=output_dir, check=True)
+    missing = [
+        name for size_images in images.values() for name in size_images.values()
+        if not os.path.isfile(os.path.join(output_dir, name))
+    ]
+    if missing:
+        raise RuntimeError('ChimeraX did not produce images: {}'.format(', '.join(missing)))
+    return images
+
+
+def create_combined_local_resolution_views(chimerax, map_path, resolution_map, model_path,
+                                           contour, residue_data, output_dir, prefix):
+    """Render a transparent map and residue-colored model with a shared scale."""
+    if not chimerax:
+        raise RuntimeError('ChimeraX executable is not available.')
+    for path in (map_path, resolution_map, model_path):
+        if not path or not os.path.isfile(path):
+            raise FileNotFoundError('Input file does not exist: {}'.format(path))
+    if contour is None:
+        raise ValueError('An author contour level is required for the primary map.')
+    values = residue_data['localResolution']
+    if not values:
+        raise ValueError('No residue local-resolution values are available.')
+    def quoted(path):
+        return '"{}"'.format(os.path.abspath(path).replace('\\', '\\\\').replace('"', '\\"'))
+
+    script_path = os.path.join(output_dir, prefix + '_chimerax.cxc')
+    config_path = os.path.join(output_dir, prefix + '_color_config.txt')
+    residue_specs = []
+    for residue in residue_data['residue']:
+        match = re.fullmatch(r'([^:\s/]+):(-?\d+)\s+\S+', residue)
+        if not match:
+            raise ValueError('Unsupported residue identifier: {}'.format(residue))
+        residue_specs.append('/{}:{}'.format(match.group(1), match.group(2)))
+    if len(residue_specs) != len(values):
+        raise ValueError('Residue identifiers and local-resolution values do not match.')
+    with open(config_path, 'w', encoding='utf-8') as config_file:
+        json.dump({'residues': residue_specs, 'values': values}, config_file, allow_nan=False)
+    images = {
+        'original': {axis: prefix + '_' + axis.upper() + '.png' for axis in ('x', 'y', 'z')},
+        'scaled': {axis: prefix + '_scaled_' + axis.upper() + '.png' for axis in ('x', 'y', 'z')},
+    }
+    with open(script_path, 'w', encoding='utf-8') as script:
+        script.write('open {}\nvolume #1 style surface\nvolume #1 step 1\n'.format(quoted(map_path)))
+        script.write('volume #1 level {}\n'.format(float(contour)))
+        script.write('open {}\nhide #2 models\n'.format(quoted(resolution_map)))
+        rescolor_script = os.path.join(os.path.dirname(__file__), '..', 'utils', 'rescolor.py')
+        color_script = os.path.join(os.path.dirname(__file__), '..', 'utils', 'chimerax_combined_locres.py')
+        script.write('open {} id #10\nopen {}\n'.format(quoted(model_path), quoted(rescolor_script)))
+        script.write('show #10 ribbons\nhide #10 atoms\n')
+        script.write('runscript {} {}\n'.format(quoted(color_script), quoted(config_path)))
+        script.write('transparency #1 65 target s\n')
+        script.write('lighting soft\n')
+        script.write('set bgColor #B8B8B8\n')
+        for axis, rotation in (('z', ''), ('x', 'turn y 90\n'), ('y', 'turn x -90\n')):
+            script.write('view orient\n' + rotation + 'view #1 pad 0.25 cofr true\n')
+            script.write('save {} width 1200 height 1200\n'.format(
+                quoted(os.path.join(output_dir, images['original'][axis]))))
+            script.write('save {} width 300 height 300\n'.format(
+                quoted(os.path.join(output_dir, images['scaled'][axis]))))
+        script.write('exit\n')
+    has_display = bool(os.environ.get('DISPLAY') or os.environ.get('WAYLAND_DISPLAY'))
+    if sys.platform == 'darwin' and not os.environ.get('SSH_CONNECTION'):
+        has_display = True
+    command = [chimerax]
+    if not has_display:
+        command.extend(['--offscreen', '--nogui'])
+    subprocess.run(command + [script_path], cwd=output_dir, check=True)
+    missing = [
+        name for size_images in images.values() for name in size_images.values()
+        if not os.path.isfile(os.path.join(output_dir, name))
+    ]
+    if missing:
+        raise RuntimeError('ChimeraX did not produce images: {}'.format(', '.join(missing)))
+    return images

{emdbva-0.0.1.dev152 → emdbva-0.0.1.dev155}/va/metrics/residue_locres.py

@@ -2,6 +2,90 @@ from va.utils.misc import floattohex, scale_values, scale_value, float_to_hex
 from va.utils.MapProcessor import MapProcessor
 from va.utils.ChimeraxViews import ChimeraxViews
 import numpy as np
+import os
+import mrcfile
+
+LOCAL_RESOLUTION_PALETTE = [(0, 0, 255), (255, 255, 255), (255, 0, 0)]
+
+
+def interpolate_atom_local_resolutions(map_path, inmodels):
+    """Interpolate map values at atom positions and summarize them per residue.
+
+    Args:
+        map_path (str): Local-resolution MRC/CCP4 map path.
+        inmodels: Model or list of models with Bio.PDB-style atom coordinates.
+
+    Returns:
+        tuple: Model-indexed atom and residue dictionaries. Outside-map and
+        non-finite samples have a null atom value and are excluded from means.
+    """
+    from scipy.ndimage import map_coordinates
+
+    models = inmodels if isinstance(inmodels, list) else [inmodels]
+    atom_results, residue_results = {}, {}
+    with mrcfile.open(map_path, permissive=False) as local_map:
+        header = local_map.header
+        axis_order = [int(header.mapc), int(header.mapr), int(header.maps)]
+        if sorted(axis_order) != [1, 2, 3]:
+            raise ValueError('Invalid local-resolution map axis order: {}'.format(axis_order))
+        voxel_sizes = local_map.voxel_size.tolist()
+        angles = [float(header.cellb.alpha), float(header.cellb.beta), float(header.cellb.gamma)]
+        transform = MapProcessor.map_matrix(voxel_sizes, angles)
+        origin = np.array([header.origin.x, header.origin.y, header.origin.z], dtype=float)
+        starts = np.array([header.nxstart, header.nystart, header.nzstart], dtype=float)
+        shape = np.array(local_map.data.shape)
+
+        for model_index, model in enumerate(models):
+            atoms, residue_names, residue_values, chain_values = [], [], [], {}
+            for chain in model.get_chains():
+                for residue in chain.get_residues():
+                    sampled_values = []
+                    for atom in residue.get_atoms():
+                        element = (getattr(atom, 'element', '') or '').strip().upper()
+                        xyz_index = transform.dot(np.asarray(atom.coord, dtype=float) - origin)
+                        crs_index = xyz_index[np.array(axis_order) - 1] - starts
+                        zyx_index = crs_index[::-1]
+                        value = None
+                        if np.all(np.isfinite(zyx_index)) and np.all(zyx_index >= 0) and np.all(zyx_index <= shape - 1):
+                            sampled = float(map_coordinates(local_map.data, zyx_index[:, None], order=1, mode='nearest', prefilter=False)[0])
+                            if np.isfinite(sampled):
+                                value = sampled
+                                sampled_values.append(value)
+                        atoms.append({
+                            'chain': str(chain.id), 'residue_number': int(residue.id[1]),
+                            'insertion_code': str(residue.id[2]).strip(),
+                            'hetero_flag': str(residue.id[0]).strip(),
+                            'residue_name': str(residue.resname), 'atom_name': str(atom.name),
+                            'altloc': str(atom.get_altloc()).strip(), 'element': element,
+                            'serial_number': getattr(atom, 'serial_number', None),
+                            'local_resolution': value,
+                        })
+                    if sampled_values:
+                        value = round(float(np.mean(sampled_values)), 4)
+                        residue_names.append('{}:{} {}'.format(chain.id, residue.id[1], residue.resname))
+                        residue_values.append(value)
+                        chain_values.setdefault(str(chain.id), []).append(value)
+
+            model_name = os.path.basename(model.filename)
+            atom_results[str(model_index)] = {'name': model_name, 'atoms': atoms}
+            if not residue_values:
+                continue
+            lower, upper = min(residue_values), max(residue_values)
+            colors = [float_to_hex((value - lower) / (upper - lower) if upper > lower else 0.5,
+                                   LOCAL_RESOLUTION_PALETTE)
+                      for value in residue_values]
+            chain_summary = {}
+            for chain, values in chain_values.items():
+                mean = round(float(np.mean(values)), 3)
+                color_value = (mean - lower) / (upper - lower) if upper > lower else 0.5
+                chain_summary[chain] = {'value': mean, 'color': float_to_hex(max(0, min(1, color_value)), LOCAL_RESOLUTION_PALETTE),
+                                        'numberOfResidues': len(values)}
+            residue_results[str(len(residue_results))] = {
+                'name': model_name,
+                'data': {'residue': residue_names, 'localResolution': residue_values,
+                         'color': colors, 'chainResolution': chain_summary},
+            }
+    return atom_results, residue_results
 
 
 def local_resolution_json(map, inmodels, radius, value_range):
@@ -98,7 +182,8 @@ def local_resolution_json(map, inmodels, radius, value_range):
 
         data_result['residue'] = allkeys
         data_result['localResolution'] = allvalues
-        data_result['color'] = [float_to_hex(i) for i in scale_values(allvalues, new_min, new_max)]
+        data_result['color'] = [float_to_hex(i, LOCAL_RESOLUTION_PALETTE)
+                                for i in scale_values(allvalues, new_min, new_max)]
         # data_result['color'] = [float_to_hex(i) for i in scale_values(allvalues, 0, 1)]
         data_result['chainResolution'] = chainaiscore
         result[str(modelcount-1)] = {'name': modelname, 'data': data_result}

{emdbva-0.0.1.dev152 → emdbva-0.0.1.dev155}/va/metrics/resmap.py

@@ -412,16 +412,19 @@ def get_masked_indices(input_mask):
         return None
 
 
-def localres_histogram(mapone, primary_mapname, resolution=None):
+def localres_histogram(mapone, primary_mapname, resolution=None, local_resolution_path=None):
     """
         local resolution histogram
     """
 
     mapname = os.path.basename(mapone)
     output_path = os.path.dirname(mapone)
-    file_pattern = '{}/{}_relion/*_locres.mrc'.format(output_path, primary_mapname)
-    resmapname_glob = glob.glob(file_pattern)
-    resmapname = resmapname_glob[0] if len(resmapname_glob) > 0 else None
+    if local_resolution_path is None:
+        file_pattern = '{}/{}_relion/*_locres.mrc'.format(output_path, primary_mapname)
+        resmapname_glob = glob.glob(file_pattern)
+        resmapname = resmapname_glob[0] if len(resmapname_glob) > 0 else None
+    else:
+        resmapname = local_resolution_path
     mask_file = f'{output_path}/{primary_mapname}_relion/mask/{primary_mapname}_mask.mrc'
     bin_mask = get_masked_indices(mask_file)
     final_dict = {}

{emdbva-0.0.1.dev152 → emdbva-0.0.1.dev155}/va/preparation.py

@@ -910,6 +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,
+                       'locres_phe': False, 'locres_phe_results': False,
                        'phrand': False, 'predictcontour': False, 'mapmapcc': False}
             for key in resdict.keys():
                 if key in runs:
@@ -924,8 +925,10 @@ 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', 'mapmapcc',
+                                'smoc', 'resccc', 'locres', 'locres_phe', 'phrand', 'predictcontour', 'mapmapcc',
                                 ])
+                if 'locres_phe_results' in runs:
+                    runlist.append('locres_phe_results')
 
             if self.masks is None:
                 runlist.remove('mask')

{emdbva-0.0.1.dev152 → emdbva-0.0.1.dev155}/va/utils/ChimeraxViews.py

@@ -162,7 +162,8 @@ class ChimeraxViews:
         surface_file_name = '{}/{}_{}'.format(self.va_dir, model_name, map_name)
         model = f'{self.va_dir}/{model_name}'
         if data_type == 'residue_local_resolution':
-            list_items = list(itertools.islice(min_median_max.items(), 3))
+            items = min_median_max.items() if isinstance(min_median_max, dict) else min_median_max
+            list_items = list(itertools.islice(items, 3))
             min_value, min_color = list_items[0]
             median_value, median_color = list_items[1]
             max_value, max_color = list_items[2]
@@ -187,7 +188,7 @@ class ChimeraxViews:
                 # )
                 if count == 0:
                     count += 1
-                    fp.write(f'rescolors /{chain}:{res} {color} ')
+                    fp.write(f'rescolors /{chain}:{res} {color}' + ('\n' if number_of_item == 1 else ' '))
                 elif count == number_of_item - 1:
                     fp.write(f'/{chain}:{res} {color}\n')
                 else:
@@ -197,29 +198,33 @@ class ChimeraxViews:
             if data_type == 'residue_local_resolution':
                 fp.write(
                     'key showTool true\n'
-                    'key size 0.25000,0.02000\n'
-                    'key pos 0.72000,0.05000\n'
-                    f'key blue-white-red :{round(min_value, 2)} :{round((min_value+max_value)/2, 2)} :{round(max_value, 2)}\n'
-                    f'key {min_color}:{round(min_value, 1)} {median_color}:{round(median_value, 1)} {max_color}:{round(max_value, 1)}\n'
+                    'key size 0.50000,0.02000\n'
+                    'key pos 0.25000,0.05000\n'
+                    'key numericLabelSpacing equal\n'
+                    'key border false\n'
+                    'key labelColor black\n'
+                    f'key blue:{min_value:.2f} white:{median_value:.2f} red:{max_value:.2f}\n'
                 )
+            framing = 'view pad 0.25 cofr true\n' if data_type == 'residue_local_resolution' else 'view cofr True\n'
+            background = 'set bgColor #B8B8B8\n' if data_type == 'residue_local_resolution' else 'set bgColor white\n'
             fp.write(
                 # 'key showTool true\n'
                 # 'key size 0.25000,0.02000\n'
                 # 'key pos 0.72000,0.05000\n'
                 # f'key blue-white-red :{round(min, 2)} :{round((min+max)/2, 2)} :{round(max, 2)}\n'
                 # f'key {min_color}:{round(min_value, 1)} {median_color}:{round(median_value, 1)} {max_color}:{round(max_value, 1)}\n'
-                'set bgColor white\n'
+                background +
                 'lighting soft\n'
-                'view cofr True\n'
+                + framing +
                 f'save {str(surface_file_name)}_z{cur_type}.jpeg supersample 1 width 1200 height 1200\n'
                 'turn x -90\n'
                 'turn y -90\n'
-                'view cofr True\n'
+                + framing +
                 f'save {str(surface_file_name)}_y{cur_type}.jpeg supersample 1 width 1200 height 1200\n'
                 'view orient\n'
                 'turn x 90\n'
                 'turn z 90\n'
-                'view cofr True\n'
+                + framing +
                 f'save {str(surface_file_name)}_x{cur_type}.jpeg supersample 1 width 1200 height 1200\n'
                 'close all\n'
                 'exit'
@@ -421,22 +426,17 @@ class ChimeraxViews:
                         model_name = cur_model[key]
                 min_middle_max = None
                 if data_type == 'residue_local_resolution':
-                    min_middle_max = {}
+                    min_middle_max = []
                     min_value = min(values)
                     max_value = max(values)
-                    real_middle = (min_value + max_value) / 2
-                    difference = [abs(value - real_middle) for value in values]
-                    middle_index = difference.index(min(difference))
-                    middle_value = values[middle_index]
-                    min_value, middle_value, max_value = (min(values), middle_value, max(values))
+                    middle_value = (min_value + max_value) / 2
                     min_index = values.index(min_value)
                     max_index = values.index(max_value)
                     min_colour = colors[min_index]
-                    middle_colour = colors[middle_index]
+                    middle_colour = '#FFFFFF'
                     max_colour = colors[max_index]
-                    min_middle_max[min_value] = min_colour
-                    min_middle_max[middle_value] = middle_colour
-                    min_middle_max[max_value] = max_colour
+                    min_middle_max.extend([(min_value, min_colour), (middle_value, middle_colour),
+                                           (max_value, max_colour)])
                 # result = self.json_to_attributes(data_type)
                 chimerax_file_name = self.write_residue_cxc(colors, residues, map_name, model_name, data_type, min_middle_max)
                 # Use attributes file for colouring

emdbva-0.0.1.dev155/va/utils/chimerax_combined_locres.py

@@ -0,0 +1,80 @@
+"""Color a combined map/model view using its surface and residue values.
+
+This script is run by ChimeraX with a configuration filename as its argument.
+"""
+
+import json
+import sys
+
+import numpy as np
+from chimerax.core.commands import run
+from chimerax.core.errors import UserError
+
+
+def color_combined_view(session, config):
+    """Sample the contoured map surface and apply one shared color range."""
+    primary = session.models.list(model_id=(1,))
+    resolution = session.models.list(model_id=(2,))
+    if len(primary) != 1 or len(resolution) != 1:
+        raise UserError('Expected primary and local-resolution maps #1 and #2.')
+    primary_map, resolution_map = primary[0], resolution[0]
+    primary_map.update_drawings()
+    all_values = list(config['values'])
+    sampled_count = 0
+    map_lower, map_upper = None, None
+    for surface in primary_map.surfaces:
+        if not surface.display or surface.vertices is None or not len(surface.vertices):
+            continue
+        values, outside = resolution_map.interpolated_values(
+            surface.vertices, surface.scene_position, out_of_bounds_list=True
+        )
+        inside = np.ones(len(values), dtype=bool)
+        inside[outside] = False
+        sampled = values[inside & np.isfinite(values)]
+        if len(sampled):
+            sample_lower, sample_upper = float(sampled.min()), float(sampled.max())
+            map_lower = sample_lower if map_lower is None else min(map_lower, sample_lower)
+            map_upper = sample_upper if map_upper is None else max(map_upper, sample_upper)
+        sampled_count += len(sampled)
+    if not sampled_count:
+        raise UserError('No valid local-resolution values on the displayed map surface.')
+    model_lower, model_upper = min(all_values), max(all_values)
+    lower, upper = min(map_lower, model_lower), max(map_upper, model_upper)
+    if lower == upper:
+        lower, upper = lower - 0.01, upper + 0.01
+
+    run(session, 'color sample #1 map #2 palette blue:white:red range {},{} key true'.format(lower, upper))
+    run(session, 'key blue: white: red: pos 0.25,0.08 size 0.5,0.02 border false')
+    for label, limits, text_y, arrow_start, arrow_end in (
+        ('Map', (map_lower, map_upper), 0.073, 0.074, 0.08),
+        ('Model', (model_lower, model_upper), 0.110, 0.110, 0.10),
+    ):
+        run(session, '2dlabels text "{}" color black size 9 xpos 0.16 ypos {}'.format(label, text_y))
+        values = (limits[0], (limits[0] + limits[1]) / 2, limits[1])
+        for value in sorted(set(values)):
+            xpos = 0.25 + 0.5 * (value - lower) / (upper - lower)
+            run(session, '2dlabels arrow start {},{} end {},{} color black weight 0.3 headStyle pointer'.format(
+                xpos, arrow_start, xpos, arrow_end))
+            label_x = xpos
+            if label == 'Map' and value == map_lower:
+                label_x = 0.25 + 0.5 * (model_lower - lower) / (upper - lower)
+            run(session, '2dlabels text "{:.2f}" color black size 9 xpos {} ypos {}'.format(
+                value, max(0.0, label_x - 0.012), text_y))
+    colors = []
+    for spec, value in zip(config['residues'], config['values']):
+        position = (value - lower) / (upper - lower)
+        palette = ((0, 0, 255), (255, 255, 255), (255, 0, 0))
+        index = min(int(position * 2), 1)
+        fraction = position * 2 - index
+        rgb = tuple(int(start + fraction * (end - start))
+                    for start, end in zip(palette[index], palette[index + 1]))
+        colors.append('{} #{:02x}{:02x}{:02x}'.format(spec, *rgb))
+    run(session, 'rescolors ' + ' '.join(colors))
+    session.logger.info('Combined local-resolution ranges: map {:.4f}-{:.4f} Å, model {:.4f}-{:.4f} Å '
+                        '(shared {:.4f}-{:.4f} Å; {} surface samples).'.format(
+                            map_lower, map_upper, model_lower, model_upper, lower, upper, sampled_count))
+
+
+if 'session' in globals():
+    with open(sys.argv[1], encoding='utf-8') as config_file:
+        color_combined_view(session, json.load(config_file))

{emdbva-0.0.1.dev152 → emdbva-0.0.1.dev155}/va/validationanalysis.py

@@ -62,6 +62,9 @@ from va.metrics.threedfsc import run_threedfsc
 from va.metrics.smoc import run_smoc
 from va.metrics.phenix_cc import *
 from va.metrics.phenix_mm import *
+from va.metrics.phenix_locres import (run_local_resolution, reuse_local_resolution, create_local_resolution_views,
+                                     create_combined_local_resolution_views,
+                                     write_result as write_phenix_locres_result)
 from va.metrics.resmap import *
 from va.metrics.bars import *
 from va.metrics.phaserandomization import *
@@ -7269,6 +7272,100 @@ class ValidationAnalysis:
         print('Local resolution views time: %s' % (end - start))
         print('------------------------------------')
 
+    def phenix_local_resolution(self, run_phenix=True):
+        """Run PHENIX or reuse its existing map and generate result artifacts."""
+        output_dir = self.workdir
+        output_json = os.path.join(self.workdir, '{}_phenix_local_resolution.json'.format(self.mapname))
+        half_maps = [
+            getattr(self.hmodd, 'fullname', None),
+            getattr(self.hmeven, 'fullname', None),
+        ]
+        if run_phenix:
+            result = run_local_resolution(half_maps, output_dir, self.resolution)
+        else:
+            result = reuse_local_resolution(half_maps, output_dir)
+            if result is None:
+                return None
+        if result.get('status') == 'success':
+            resolution_map = os.path.join(output_dir, result['output_map'])
+            if self.models:
+                try:
+                    atom_data, residue_data = interpolate_atom_local_resolutions(resolution_map, self.models)
+                    atom_json = os.path.join(output_dir, self.mapname + '_atom_local_resolution.json')
+                    with open(atom_json, 'w', encoding='utf-8') as output_file:
+                        json.dump({'atom_local_resolution': atom_data}, output_file, indent=2, allow_nan=False)
+                    if residue_data:
+                        residue_json = os.path.join(output_dir, self.mapname + '_residue_local_resolution.json')
+                        with open(residue_json, 'w', encoding='utf-8') as output_file:
+                            json.dump({'residue_local_resolution': residue_data}, output_file, indent=2, allow_nan=False)
+                        _, model_chimerax = self.surface_envcheck()
+                        if model_chimerax:
+                            model_local_resolution_views(residue_json, self.mapname, 'residue_local_resolution', model_chimerax)
+                            combined_views = {}
+                            for model_result in residue_data.values():
+                                model_name = model_result['name']
+                                try:
+                                    prefix = '{}_{}_phenix_local_resolution_combined'.format(self.mapname, model_name)
+                                    combined_views[model_name] = create_combined_local_resolution_views(
+                                        model_chimerax, self.map.fullname, resolution_map,
+                                        os.path.join(output_dir, model_name), self.cl,
+                                        model_result['data'], output_dir, prefix)
+                                except Exception as exc:
+                                    sys.stderr.write('Combined local-resolution views for {} failed: {}.\n'.format(model_name, exc))
+                            if combined_views:
+                                combined_json = os.path.join(output_dir, self.mapname + '_modelmap_localresolutionviews.json')
+                                with open(combined_json, 'w', encoding='utf-8') as output_file:
+                                    json.dump({'model_map_local_resolution_views': combined_views}, output_file, indent=2)
+                        else:
+                            sys.stderr.write('ChimeraX unavailable; skipping residue local-resolution views.\n')
+                    else:
+                        sys.stderr.write('No model residues had valid local-resolution samples.\n')
+                except Exception as exc:
+                    sys.stderr.write('PHENIX atom/residue local resolution failed: {}.\n'.format(exc))
+            try:
+                resolution = float(self.resolution) if self.resolution is not None else None
+            except (TypeError, ValueError):
+                resolution = None
+            try:
+                histogram = localres_histogram(
+                    half_maps[0], self.mapname, resolution, local_resolution_path=resolution_map
+                )
+                if histogram:
+                    histogram_json = os.path.join(output_dir, self.mapname + '_localres_histo.json')
+                    with open(histogram_json, 'w', encoding='utf-8') as output_file:
+                        json.dump({'local_res_histogram': histogram}, output_file)
+            except Exception as exc:
+                sys.stderr.write('PHENIX local-resolution histogram failed: {}.\n'.format(exc))
+            _, chimerax = self.surface_envcheck()
+            views = {}
+            for label, map_obj in (('primary', self.map), ('raw', self.rawmap)):
+                if map_obj is None:
+                    print('Skipping PHENIX local-resolution {} views: map is missing.'.format(label))
+                    continue
+                try:
+                    contour = self.cl if label == 'primary' else calc_level_dev(map_obj.data)[0]
+                    map_basename = os.path.basename(map_obj.fullname)
+                    prefix = '{}_phenix_local_resolution'.format(map_basename)
+                    views[label] = create_local_resolution_views(
+                        chimerax, map_obj.fullname, resolution_map, contour, output_dir, prefix
+                    )
+                    view_key = 'local_resolution_views' if label == 'primary' else 'rawmap_local_resolution_views'
+                    view_json = os.path.join(output_dir, '{}_localresolutionviews.json'.format(map_basename))
+                    with open(view_json, 'w', encoding='utf-8') as output_file:
+                        json.dump({view_key: views[label]}, output_file, indent=2)
+                except Exception as exc:
+                    sys.stderr.write('PHENIX local-resolution {} views failed: {}.\n'.format(label, exc))
+            if views:
+                result['views'] = views
+        try:
+            write_phenix_locres_result(output_json, result)
+        except Exception as exc:
+            sys.stderr.write('Saving PHENIX local-resolution JSON failed: {}.\n'.format(exc))
+        if result.get('status') != 'success':
+            for error in result.get('errors', []):
+                sys.stderr.write('PHENIX local-resolution error: {}\n'.format(error))
+        return result
+
     @profile_peak_memory()
     def emringer(self):
         """

{emdbva-0.0.1.dev152 → emdbva-0.0.1.dev155}/va/version.py

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