emdbva 0.0.1.dev145__tar.gz → 0.0.1.dev147__tar.gz

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

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

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

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

{emdbva-0.0.1.dev145 → emdbva-0.0.1.dev147}/va/metrics/resmap.py

@@ -180,7 +180,7 @@ def resmap_filecheck(mapone, output_path):
     return check if check else False
 
 
-def resmap_chimerax(mapone, output_path):
+def relion_local_res_chimerax(orgmap, mapone, output_path):
     """
         Generate chimerax cmd for ResMap results
 
@@ -188,10 +188,10 @@ def resmap_chimerax(mapone, output_path):
         None. ChimeraX command files may be written to the output directory.
     """
 
-    mapname = os.path.basename(mapone)
     output_chimerax_file = '{}{}_chimerax.cxc'.format(output_path, os.path.basename(mapone))
-    orgmap = '{}{}_ori.map'.format(output_path, os.path.splitext(mapname)[0])
-    resmap = '{}{}_ori_resmap.map'.format(output_path, os.path.splitext(mapname)[0])
+    orgmap = orgmap
+    # resmap = '{}{}_ori_resmap.map'.format(output_path, os.path.splitext(mapname)[0])
+    resmap = mapone
     header = mrcfile.open(mapone, mode='r', header_only=True)
     voxsizes = header.voxel_size.tolist()
     if all(element == voxsizes[0] for element in voxsizes):
@@ -305,12 +305,12 @@ def run_resmap_chimerax(bindisplay, locCHIMERA, cxcfile):
         if not bindisplay:
             subprocess.check_call(locCHIMERA + " --offscreen --nogui " + cxcfile, cwd=os.path.dirname(cxcfile),
                                   shell=True)
-            print('Animated PNG for ResMap result has been produced.')
+            print('Animated PNG for local resolution result has been produced.')
         else:
             subprocess.check_call(locCHIMERA + " " + cxcfile, cwd=os.path.dirname(cxcfile), shell=True)
-            print('Animated PNG for ResMap result has been produced.')
+            print('Animated PNG for local resolution result has been produced.')
     except subprocess.CalledProcessError as suberr:
-        err = 'Saving ResMap local resolution animated png error: {}.'.format(suberr)
+        err = 'Saving local resolution animated png error: {}.'.format(suberr)
         errlist.append(err)
         sys.stderr.write(err + '\n')
 

{emdbva-0.0.1.dev145 → emdbva-0.0.1.dev147}/va/prepareandrun_codon_airflow.py

@@ -627,7 +627,14 @@ class prepareandrun():
             logging.info('Validation command completed.')
             self.data_sync()
         else:
-            logging.info('Validation command failed; skipping data sync.')
+            logging.error(
+                'Validation command failed with exit code %s; skipping data sync. '
+                'See stdout: %s and stderr: %s',
+                return_code,
+                stdout_path,
+                stderr_path,
+            )
+            raise subprocess.CalledProcessError(return_code, orgcmd)
 
         # predmem = self.memmsg(self.mapsize)
         # bsub -M predmem .....
@@ -665,7 +672,7 @@ class prepareandrun():
 
     def data_sync(self):
         """
-            sync data at corresponding folder to staging and production folders
+            sync data at corresponding folder to public production folders
 
         :return: None
         """
@@ -673,94 +680,82 @@ class prepareandrun():
         result_folder = '{}{}/va/'.format(MAP_SERVER_PATH, sub_dir)
         id = list(self.idsubdirs.keys())[0]
         prod_folder = '{}/{}/va'.format(VA_PROD_PATH, sub_dir)
+        fallback_prod_folder = prod_folder.replace('/nfs/public/', '/nfs/ebi/public/', 1)
         logging.info(prod_folder)
+        logging.info(fallback_prod_folder)
         alljsonfile = glob.glob('{}emd_{}_all.json'.format(result_folder, id))
-        if alljsonfile:
+        if not alljsonfile:
+            logging.info('No all json output, job failed to the end')
+            return None
+
+        rsync_filters = (
+            "--include '*/' "
+            "--include '*_rawmap.map' "
+            "--include '*_mask.mrc' "
+            "--exclude '*_locres.mrc' "
+            "--exclude '*.map' "
+            "--exclude '*.mrc' "
+            "--exclude '*.gz' "
+            "--exclude 'emd-*.cif' "
+            "--include '*' "
+        )
+
+        def sync_command(target_folder):
             quoted_result = shlex.quote(result_folder)
-            quoted_prod = shlex.quote(prod_folder)
-
-            rsync_filters = (
-                "--include '*/' "
-                "--include '*_rawmap.map' "
-                "--include '*_mask.mrc' "
-                "--exclude '*_locres.mrc' "
-                "--exclude '*.map' "
-                "--exclude '*.mrc' "
-                "--exclude '*.gz' "
-                "--exclude 'emd-*.cif' "
-                "--include '*' "
+            quoted_target = shlex.quote(target_folder.rstrip('/'))
+            return (
+                'mkdir -p {target} && '
+                'rsync -avzrhP {filters}{source} {target}/'
+            ).format(
+                target=quoted_target,
+                filters=rsync_filters,
+                source=quoted_result,
             )
 
-            sync_cmd = (
-                f"rsync -avzrhP {rsync_filters}"
-                f"{quoted_result} {quoted_prod}"
+        def sbatch_command(job_name, stdout_name, stderr_name, target_folder):
+            wrap_cmd = sync_command(target_folder)
+            return (
+                'sbatch --wait -p datamover --mem=10G --time 12:00:00 '
+                '-J {job_name} --mail-user=pdb_em@ebi.ac.uk '
+                '--mail-type=END --mail-type=FAIL '
+                '-o {stdout_path} -e {stderr_path} --wrap="{wrap_cmd}"'
+            ).format(
+                job_name=shlex.quote(job_name),
+                stdout_path=shlex.quote('{}{}'.format(result_folder, stdout_name)),
+                stderr_path=shlex.quote('{}{}'.format(result_folder, stderr_name)),
+                wrap_cmd=wrap_cmd,
             )
-            prod_stdout = f"{result_folder}{id}_prodsync_stdout.txt"
-            prod_stderr = f"{result_folder}{id}_prodsync_stderr.txt"
-
-            # for codon staging, production and dev
-            try:
-                subprocess.check_call(['ssh', 'wp-p1m2-e1',
-                                       'ls ' + prod_folder],
-                                      stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-                prod_rc = self.run_shell_command(sync_cmd, prod_stdout, prod_stderr)
-                if prod_rc == 0:
-                    logging.info('Target folder exists and data sync to production has completed')
-                else:
-                    logging.info('Target folder exists but data sync to production failed')
-
-                # sync data to HL
-                fallback_prod_folder = prod_folder
-                quoted_fallback_prod_folder = shlex.quote(fallback_prod_folder)
-                quoted_fallback_source = shlex.quote(fallback_prod_folder.rstrip('/') + '/')
-                quoted_fallback_dest = 'hl2-ws-login:' + shlex.quote(fallback_prod_folder.rstrip('/') + '/')
-
-                fallback_sync_cmd = (
-                    f"ssh hl2-ws-login 'mkdir -p {quoted_fallback_prod_folder}' && "
-                    f"rsync -avzrhP {rsync_filters}"
-                    f"{quoted_fallback_source} {quoted_fallback_dest}"
-                )
-                fallback_stdout = f"{result_folder}{id}_fallbacksync_stdout.txt"
-                fallback_stderr = f"{result_folder}{id}_fallbacksync_stderr.txt"
-                fallback_rc = self.run_shell_command(fallback_sync_cmd, fallback_stdout, fallback_stderr)
-                if fallback_rc == 0:
-                    logging.info("Fallback validation_analysis sync has completed")
-                else:
-                    logging.info("Fallback validation_analysis sync failed")
 
-            except subprocess.CalledProcessError as e:
-                try:
-                    subprocess.check_call(['ssh wp-p1m2-e1 "mkdir -p ' + prod_folder + '"'], stdout=subprocess.PIPE,
-                                          stderr=subprocess.PIPE, shell=True)
-                    prod_rc = self.run_shell_command(sync_cmd, prod_stdout, prod_stderr)
-                    if prod_rc == 0:
-                        logging.info('Target folder was created and data sync to production has completed')
-                    else:
-                        logging.info('Target folder was created but data sync to production failed')
-
-                    # sync data to HL
-                    fallback_prod_folder = prod_folder
-                    quoted_fallback_prod_folder = shlex.quote(fallback_prod_folder)
-                    quoted_fallback_source = shlex.quote(fallback_prod_folder.rstrip('/') + '/')
-                    quoted_fallback_dest = 'hl2-ws-login:' + shlex.quote(fallback_prod_folder.rstrip('/') + '/')
-
-                    fallback_sync_cmd = (
-                        f"ssh hl2-ws-login 'mkdir -p {quoted_fallback_prod_folder}' && "
-                        f"rsync -avzrhP {rsync_filters}"
-                        f"{quoted_fallback_source} {quoted_fallback_dest}"
-                    )
-                    fallback_stdout = f"{result_folder}{id}_fallbacksync_stdout.txt"
-                    fallback_stderr = f"{result_folder}{id}_fallbacksync_stderr.txt"
-                    fallback_rc = self.run_shell_command(fallback_sync_cmd, fallback_stdout, fallback_stderr)
-                    if fallback_rc == 0:
-                        logging.info("Fallback validation_analysis sync has completed")
-                    else:
-                        logging.info("Fallback validation_analysis sync failed")
-
-                except subprocess.CalledProcessError as e:
-                    logging.info('Target folder not properly produced.')
-        else:
-            logging.info('No all json output, job failed to the end')
+        sync_jobs = [
+            (
+                'production',
+                sbatch_command(
+                    'vasync_{}'.format(id),
+                    '{}_prodsync_stdout.txt'.format(id),
+                    '{}_prodsync_stderr.txt'.format(id),
+                    prod_folder,
+                ),
+            ),
+            (
+                'fallback',
+                sbatch_command(
+                    'vafallbacksync_{}'.format(id),
+                    '{}_fallbacksync_stdout.txt'.format(id),
+                    '{}_fallbacksync_stderr.txt'.format(id),
+                    fallback_prod_folder,
+                ),
+            ),
+        ]
+
+        for label, job_cmd in sync_jobs:
+            logging.info('Submitting %s sync job...', label)
+            logging.info(job_cmd)
+            subprocess.check_call(
+                ['ssh', 'codon-slurm-login', job_cmd],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            logging.info('%s sync job has been submitted', label)
 
         return None
 
@@ -1069,7 +1064,6 @@ def main():
 
     if not myobj.onlycopy and not myobj.onlysync:
         myobj.runcmd()
-        myobj.data_sync()
     else:
         logging.info('Only copy files. Please make sure use --update t/Ture/1')
 

{emdbva-0.0.1.dev145 → emdbva-0.0.1.dev147}/va/utils/misc.py

@@ -142,51 +142,74 @@ def interpolated_intercept(x, y1, y2):
 
 
 def interpolated_intercepts_general(x, y1, y2):
-    """Find the intercepts of two curves, given by the same x data"""
+    """
+    Find intersections between two curves sharing the same x-axis.
 
-    def intercept(point1, point2, point3, point4):
-        """Find the intersection between two lines.
+    This version avoids nan/inf intersections and avoids divide-by-zero
+    from the general line-intersection method.
+    """
 
-        The first line is defined by the line between point1 and point2.
-        The second line is defined by the line between point3 and point4.
-        Each point is an (x, y) tuple.
+    x = np.asarray(x, dtype=float)
+    y1 = np.asarray(y1, dtype=float)
+    y2 = np.asarray(y2, dtype=float)
 
-        Returns: the intercept, in (x, y) format.
-        """
+    min_len = min(len(x), len(y1), len(y2))
+    x = x[:min_len]
+    y1 = y1[:min_len]
+    y2 = y2[:min_len]
 
-        def line(p1, p2):
-            A = (p1[1] - p2[1])
-            B = (p2[0] - p1[0])
-            C = (p1[0] * p2[1] - p2[0] * p1[1])
-            return A, B, -C
+    valid = np.isfinite(x) & np.isfinite(y1) & np.isfinite(y2)
 
-        def intersection(L1, L2):
-            D = L1[0] * L2[1] - L1[1] * L2[0]
-            Dx = L1[2] * L2[1] - L1[1] * L2[2]
-            Dy = L1[0] * L2[2] - L1[2] * L2[0]
-            x = Dx / D
-            y = Dy / D
-            return x, y
-
-        L1 = line([point1[0], point1[1]], [point2[0], point2[1]])
-        L2 = line([point3[0], point3[1]], [point4[0], point4[1]])
+    x = x[valid]
+    y1 = y1[valid]
+    y2 = y2[valid]
 
-        return intersection(L1, L2)
+    if len(x) < 2:
+        return [], []
 
-    idxs = np.argwhere(np.diff(np.sign(y1 - y2)) != 0)
+    order = np.argsort(x)
+    x = x[order]
+    y1 = y1[order]
+    y2 = y2[order]
 
+    diff = y1 - y2
 
     xcs = []
     ycs = []
 
-    for idx in idxs:
-        xc, yc = intercept((x[idx], y1[idx]), (x[idx + 1], y1[idx + 1]), (x[idx], y2[idx]), (x[idx + 1], y2[idx + 1]))
+    for i in range(len(x) - 1):
+        x0 = x[i]
+        x1 = x[i + 1]
+        d0 = diff[i]
+        d1 = diff[i + 1]
+
+        if not np.isfinite(d0) or not np.isfinite(d1):
+            continue
+
+        if x1 == x0:
+            continue
+
+        # Exact crossing at the first point.
+        if d0 == 0:
+            xc = x0
+            yc = y1[i]
 
-        txc = xc[0].tolist()
-        tyc = yc[0].tolist()
+        # Crossing between two adjacent points.
+        elif d0 * d1 < 0:
+            denom = d0 - d1
+            if denom == 0:
+                continue
+
+            t = d0 / denom
+            xc = x0 + t * (x1 - x0)
+            yc = y1[i] + t * (y1[i + 1] - y1[i])
+
+        else:
+            continue
 
-        xcs.append(txc)
-        ycs.append(tyc)
+        if np.isfinite(xc) and np.isfinite(yc):
+            xcs.append(float(xc))
+            ycs.append(float(yc))
 
     return xcs, ycs
 
@@ -198,12 +221,15 @@ def remove_duplicate_intersections(xs, ys):
         :param ys: list of y values
     """
 
-    rxs = [round(val, 5) for val in xs]
-    rys = [round(val, 5) for val in ys]
-    # round xs and ys to 4-5 decimal potins and then do the following
-    pairs = list(zip(rxs, rys))
-    unique_pairs = set(pairs)
-    unique_pairs_list = sorted(list(unique_pairs), key=lambda x: x[0])
+    pairs = []
+
+    for x, y in zip(xs, ys):
+        if not np.isfinite(x) or not np.isfinite(y):
+            continue
+
+        pairs.append((round(float(x), 5), round(float(y), 5)))
+
+    unique_pairs_list = sorted(set(pairs), key=lambda pair: pair[0])
 
     return unique_pairs_list
 

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

@@ -335,31 +335,61 @@ class GetStars:
 
         return final_curves
 
-
     @staticmethod
     def intersections_into_curve(intersections, levels, corrected_curve, phase_rand_curve):
         """
-            After getting the intersections and insert them into these curves
-
-        :param intersections: list of data pairs containing intersections
-        :param levels: list of x value of two intersect curves
-        :param corrected_curve: list of value of correction curve correlation values
-        :param phase_rand_curve: list of value of phase rand curve correlation
+        Insert valid intersection x-values into the curve x-axis and interpolate
+        corrected and phase-randomized curves onto the new x-axis.
         """
 
-        for a, b in intersections:
+        levels = np.asarray(levels, dtype=float)
+        corrected_curve = np.asarray(corrected_curve, dtype=float)
+        phase_rand_curve = np.asarray(phase_rand_curve, dtype=float)
 
-            exists = np.any(levels == a)
-            if not exists:
-                index = np.searchsorted(levels, a)
-                levels = np.insert(levels, index, a)
-                corrected_curve = np.insert(corrected_curve, index, b)
-                phase_rand_curve = np.insert(phase_rand_curve, index, b)
-            else:
-                print(a, b)
-                print('Intersection point on curve data')
+        valid = (
+                np.isfinite(levels)
+                & np.isfinite(corrected_curve)
+                & np.isfinite(phase_rand_curve)
+        )
+
+        levels = levels[valid]
+        corrected_curve = corrected_curve[valid]
+        phase_rand_curve = phase_rand_curve[valid]
+
+        if len(levels) < 2:
+            return levels, corrected_curve, phase_rand_curve
+
+        order = np.argsort(levels)
+        levels = levels[order]
+        corrected_curve = corrected_curve[order]
+        phase_rand_curve = phase_rand_curve[order]
+
+        # Remove duplicated x values because np.interp needs increasing x.
+        unique_levels, unique_idx = np.unique(levels, return_index=True)
+        levels = unique_levels
+        corrected_curve = corrected_curve[unique_idx]
+        phase_rand_curve = phase_rand_curve[unique_idx]
+
+        intersection_xs = []
+
+        for x, y in intersections:
+            if not np.isfinite(x) or not np.isfinite(y):
+                continue
 
-        return levels, corrected_curve, phase_rand_curve
+            if levels[0] <= x <= levels[-1]:
+                intersection_xs.append(float(x))
+
+        if intersection_xs:
+            new_levels = np.unique(
+                np.concatenate([levels, np.asarray(intersection_xs, dtype=float)])
+            )
+        else:
+            new_levels = levels
+
+        new_corrected_curve = np.interp(new_levels, levels, corrected_curve)
+        new_phase_rand_curve = np.interp(new_levels, levels, phase_rand_curve)
+
+        return new_levels, new_corrected_curve, new_phase_rand_curve
 
     def plot_fsc(self, data_curves, other_curves=None, other_curves_lable='Provided FSC'):
         """
@@ -413,48 +443,213 @@ class GetStars:
 
     def plot_feature_zone(self, intersections, levels, corrected_curve, phase_rand_curve):
         """
-            Plot feature zone and save to image
-
-        :param intersections: list of tuples containing intersections in (x,y) coordinates
-        :param levels: list of frequency values
-        :param corrected_curve: list of corrected FSC value from Relion Star file
-        :param phase_rand_curve: list of phase randomized FSC value from Relion
+        Plot feature zone and save to image.
         """
 
+        levels = np.asarray(levels, dtype=float)
+        corrected_curve = np.asarray(corrected_curve, dtype=float)
+        phase_rand_curve = np.asarray(phase_rand_curve, dtype=float)
+
+        valid = (
+                np.isfinite(levels)
+                & np.isfinite(corrected_curve)
+                & np.isfinite(phase_rand_curve)
+        )
+
+        levels = levels[valid]
+        corrected_curve = corrected_curve[valid]
+        phase_rand_curve = phase_rand_curve[valid]
+
+        if len(levels) < 2:
+            return 0.0, 0.0
+
+        order = np.argsort(levels)
+        levels = levels[order]
+        corrected_curve = corrected_curve[order]
+        phase_rand_curve = phase_rand_curve[order]
+
+        valid_intersections = [
+            (float(x), float(y))
+            for x, y in intersections
+            if np.isfinite(x) and np.isfinite(y)
+        ]
+
+        valid_intersections = sorted(set(valid_intersections), key=lambda p: p[0])
+
+        plt.plot(levels, corrected_curve, color='red', label='FSC corrected')
+        plt.plot(levels, phase_rand_curve, color='blue', label='Phase randomized')
+
         frequency = 1 / self.randomise_from()
-        plt.plot(levels, corrected_curve, color='red', label='t')
-        plt.plot(levels, phase_rand_curve, color='blue', label='correlation')
-        feature_area = 0
-        for i in range(len(intersections)):
-            if i == len(intersections) - 1:
-                idx_start = np.where(levels == intersections[i][0])[0][0]
-                idx_end = len(levels)
-            else:
-                idx_start = np.where(levels == intersections[i][0])[0][0]
-                idx_end = np.where(levels == intersections[i + 1][0])[0][0]
-            print(
-                f'plt.fill_between(levels[{idx_start}:{idx_end}], corrected_curve[{idx_start}:{idx_end}], phase_rand_curve[{idx_start}:{idx_end}], where=(corrected_curve[{idx_start}:{idx_end}] >= phase_rand_curve[{idx_start}:{idx_end}]), color="gray", alpha=0.5)')
-            plt.fill_between(levels[idx_start:idx_end], corrected_curve[idx_start:idx_end], phase_rand_curve[idx_start:idx_end],
-                             where=(corrected_curve[idx_start:idx_end] >= phase_rand_curve[idx_start:idx_end]), color='pink', alpha=0.5)
-
-            status = all(x >= y for x, y in zip(corrected_curve[idx_start:idx_end], phase_rand_curve[idx_start:idx_end]))
-
-            if status:
-                cur_area = np.trapz(corrected_curve[idx_start:idx_end] - phase_rand_curve[idx_start:idx_end], levels[idx_start:idx_end])
-                feature_area += cur_area
-                # validation area
-                # area_one = np.trapz(corrected_curve[idx_start:idx_end], levels[idx_start:idx_end])
-                # area_two = np.trapz(phase_rand_curve[idx_start:idx_end], levels[idx_start:idx_end])
-                # print(area_one - area_two)
-                # print(cur_area)
-
-        closest_idx = min(range(len(levels)), key=lambda t: abs(levels[t] - frequency))
-        y_values = [0] * (len(levels) - closest_idx)
-        overfit_area = np.trapz(phase_rand_curve[closest_idx:], levels[closest_idx:])
-        plt.fill_between(levels[closest_idx:], phase_rand_curve[closest_idx:],
-                         y_values,
-                         where=(phase_rand_curve[closest_idx:] >= 0),
-                         color='blue', alpha=0.5)
+
+        # ============================================================
+        # FEATURE ZONE (PINK)
+        # ============================================================
+        # Feature area is independent of the randomization frequency.
+        #
+        # Count ALL area between the two curves wherever:
+        #
+        #     corrected FSC > phase-randomized FSC
+        #
+        # over the entire available frequency range.
+
+        feature_delta = corrected_curve - phase_rand_curve
+
+        feature_area = np.trapz(
+            np.clip(feature_delta, 0, None),
+            levels
+        )
+
+        plt.fill_between(
+            levels,
+            corrected_curve,
+            phase_rand_curve,
+            where=(corrected_curve >= phase_rand_curve),
+            interpolate=True,
+            color='pink',
+            alpha=0.5,
+        )
+
+        # ============================================================
+        # OVERFIT ZONE (BLUE)
+        # ============================================================
+        # Blue area DOES depend on randomization frequency.
+        # It starts exactly at:
+        #
+        #     frequency = 1 / self.randomise_from()
+        #
+        # and is the positive area between phase-randomized FSC
+        # and the x-axis.
+
+        overfit_area = 0.0
+
+        if levels[0] <= frequency < levels[-1]:
+            # Find the first original data point AFTER the exact
+            # randomization frequency.
+            start_idx = np.searchsorted(
+                levels,
+                frequency,
+                side='right'
+            )
+
+            # Interpolate the phase-randomized FSC at the exact
+            # randomization frequency.
+            phase_at_frequency = np.interp(
+                frequency,
+                levels,
+                phase_rand_curve
+            )
+
+            # Explicitly insert the exact randomization frequency
+            # as the first point.
+            overfit_x = np.concatenate(
+                ([frequency], levels[start_idx:])
+            )
+
+            overfit_phase = np.concatenate(
+                ([phase_at_frequency], phase_rand_curve[start_idx:])
+            )
+
+            # Count only positive phase-randomized FSC as blue area.
+            overfit_area = np.trapz(
+                np.clip(overfit_phase, 0, None),
+                overfit_x
+            )
+
+            # Draw blue area starting exactly at randomization frequency.
+            plt.fill_between(
+                overfit_x,
+                overfit_phase,
+                0,
+                where=(overfit_phase >= 0),
+                interpolate=True,
+                color='blue',
+                alpha=0.5,
+            )
+
+        # feature_area = 0.0
+        #
+        # if valid_intersections:
+        #     intersection_xs = [x for x, y in valid_intersections]
+        #
+        #     # Use searchsorted instead of exact equality.
+        #     boundaries = [np.searchsorted(levels, x) for x in intersection_xs]
+        #     boundaries = [max(0, min(idx, len(levels))) for idx in boundaries]
+        #     boundaries = sorted(set(boundaries))
+        #
+        #     for i in range(len(boundaries)):
+        #         idx_start = boundaries[i]
+        #
+        #         if i == len(boundaries) - 1:
+        #             idx_end = len(levels)
+        #         else:
+        #             idx_end = boundaries[i + 1]
+        #
+        #         if idx_end <= idx_start:
+        #             continue
+        #
+        #         seg_levels = levels[idx_start:idx_end]
+        #         seg_corrected = corrected_curve[idx_start:idx_end]
+        #         seg_phase = phase_rand_curve[idx_start:idx_end]
+        #
+        #         if len(seg_levels) < 2:
+        #             continue
+        #
+        #         finite_segment = (
+        #                 np.all(np.isfinite(seg_levels))
+        #                 and np.all(np.isfinite(seg_corrected))
+        #                 and np.all(np.isfinite(seg_phase))
+        #         )
+        #
+        #         if not finite_segment:
+        #             continue
+        #
+        #         above = seg_corrected >= seg_phase
+        #
+        #         plt.fill_between(
+        #             seg_levels,
+        #             seg_corrected,
+        #             seg_phase,
+        #             where=above,
+        #             color='pink',
+        #             alpha=0.5,
+        #         )
+        #
+        #         if np.all(above):
+        #             cur_area = np.trapz(
+        #                 seg_corrected - seg_phase,
+        #                 seg_levels,
+        #             )
+        #             feature_area += cur_area
+        #
+        # frequency = 1 / self.randomise_from()
+        #
+        # closest_idx = int(np.argmin(np.abs(levels - frequency)))
+        #
+        # overfit_x = levels[closest_idx:]
+        # overfit_y = phase_rand_curve[closest_idx:]
+        #
+        # valid_overfit = np.isfinite(overfit_x) & np.isfinite(overfit_y)
+        #
+        # overfit_x = overfit_x[valid_overfit]
+        # overfit_y = overfit_y[valid_overfit]
+        #
+        # if len(overfit_x) >= 2:
+        #     y_values = np.zeros(len(overfit_x))
+        #     overfit_area = np.trapz(overfit_y, overfit_x)
+        #
+        #     plt.fill_between(
+        #         overfit_x,
+        #         overfit_y,
+        #         y_values,
+        #         where=(overfit_y >= 0),
+        #         color='blue',
+        #         alpha=0.5,
+        #     )
+        # else:
+        #     overfit_area = 0.0
+
+        plt.legend(loc='best', fontsize='x-small')
+
         zone_image = f'{self.va_dir}/feature_zone.png'
         plt.savefig(zone_image)
         plt.close()
@@ -564,56 +759,141 @@ class GetStars:
 
     def feature_zone(self, data_curves):
         """
-            By given two curves get the feature zone based on the intersections
-            return quantified area of that zone
-            :param data_curves: dictionary contains all curves
+        Given two curves, calculate feature zone and overfit zone.
         """
 
         zones = {}
         result = {}
-        all_curves = None
-        if 'curves' in data_curves.keys():
-            all_curves = data_curves['curves']
 
-        levels = None
-        corrected_curve = None
-        phase_rand_curve = None
-        masked_curve = None
-        unmasked_curve = None
-        if all_curves:
-            if 'level' in all_curves.keys():
-                levels = np.array(all_curves['level'])
-            if 'fsc_corrected' in all_curves.keys():
-                corrected_curve = np.array(all_curves['fsc_corrected'])
-            if 'phaserandmization' in all_curves.keys():
-                phase_rand_curve = np.array(all_curves['phaserandmization'])
-            if 'phaserandomization' in all_curves.keys():
-                phase_rand_curve = np.array(all_curves['phaserandomization'])
-            if 'fsc_masked' in all_curves.keys():
-                masked_curve = np.array(all_curves['fsc_masked'])
-            if 'fsc' in all_curves.keys():
-                unmasked_curve = np.array(all_curves['fsc'])
+        all_curves = data_curves.get('curves')
+        if not all_curves:
+            return result
+
+        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:
+            return result
+
+        try:
+            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))
+
+            levels = levels[:min_len]
+            corrected_curve = corrected_curve[:min_len]
+            phase_rand_curve = phase_rand_curve[:min_len]
+
+            valid = (
+                    np.isfinite(levels)
+                    & np.isfinite(corrected_curve)
+                    & np.isfinite(phase_rand_curve)
+            )
+
+            levels = levels[valid]
+            corrected_curve = corrected_curve[valid]
+            phase_rand_curve = phase_rand_curve[valid]
+
+            if len(levels) < 2:
+                return result
+
+            order = np.argsort(levels)
+            levels = levels[order]
+            corrected_curve = corrected_curve[order]
+            phase_rand_curve = phase_rand_curve[order]
+
+            xs, ys = interpolated_intercepts_general(
+                levels,
+                corrected_curve,
+                phase_rand_curve,
+            )
 
-        if isinstance(levels, np.ndarray) and isinstance(corrected_curve, np.ndarray) and isinstance(phase_rand_curve, np.ndarray):
-            xs, ys = interpolated_intercepts_general(levels, corrected_curve, phase_rand_curve)
             intersections = remove_duplicate_intersections(xs, ys)
-            nlevels, ncorrected_curve, phase_rand_curve = self.intersections_into_curve(intersections, levels, corrected_curve, phase_rand_curve)
-            feature_area, overfit_area = self.plot_feature_zone(intersections, nlevels, ncorrected_curve, phase_rand_curve)
-            masking_area = self.area_difference(masked_curve, corrected_curve, levels)
-            corrected_unmasked_difference = sum(corrected_curve - unmasked_curve)
-            corrected_masked_difference = sum(masked_curve - corrected_curve)
-            if corrected_unmasked_difference == 0:
-                print('Corrected is the same as the unmasked.')
-                masking_area_ratio = 999
+
+            nlevels, ncorrected_curve, nphase_rand_curve = self.intersections_into_curve(
+                intersections,
+                levels,
+                corrected_curve,
+                phase_rand_curve,
+            )
+
+            feature_area, overfit_area = self.plot_feature_zone(
+                intersections,
+                nlevels,
+                ncorrected_curve,
+                nphase_rand_curve,
+            )
+
+            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]
+
+                masked_curve = masked_curve[order]
+                unmasked_curve = unmasked_curve[order]
+
+                masking_area = self.area_difference(
+                    masked_curve,
+                    corrected_curve,
+                    levels,
+                )
+
+                corrected_unmasked_difference = np.nansum(
+                    corrected_curve - unmasked_curve
+                )
+                corrected_masked_difference = np.nansum(
+                    masked_curve - corrected_curve
+                )
+
+                if corrected_unmasked_difference == 0:
+                    masking_area_ratio = 999
+                else:
+                    masking_area_ratio = abs(
+                        corrected_masked_difference / corrected_unmasked_difference
+                    )
             else:
-                masking_area_ratio = abs(corrected_masked_difference / corrected_unmasked_difference)
+                masking_area = 0.0
+                masking_area_ratio = 0.0
+
+            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)
-            zones['feature_zone_ratio'] = keep_three_significant_digits(zones['feature_zone'] / (zones['feature_zone'] + zones['overfit_zone']))
+
+            total_area = feature_area + overfit_area
+            if total_area == 0:
+                zones['feature_zone_ratio'] = 0
+            else:
+                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,
+                'masking_area': 0,
+                'masking_area_ratio': 0,
+                'feature_zone_ratio': 0,
+                'error': str(exc),
+            }
+
         return result
 
 

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

@@ -6888,10 +6888,9 @@ class ValidationAnalysis:
             start = timeit.default_timer()
             errlist = []
             result_dict = {}
-            # if strudelapp and self.models:
             if self.hmeven and self.hmodd:
-                even = self.hmeven.fullname
-                odd = self.hmodd.fullname
+                even = self.hmeven._iostream.name
+                odd = self.hmodd._iostream.name
                 full_map = '{}{}'.format(self.workdir, self.mapname)
                 out_path = '{}_relion'.format(full_map)
                 print(out_path)
@@ -6911,16 +6910,26 @@ class ValidationAnalysis:
                 check = locres_filecheck(odd, even, out_path)
                 if check:
                     try:
-                        resmap_chimerax_file = resmap_chimerax(odd, self.workdir)
-                        if os.path.isfile(resmap_chimerax_file):
-                            vtkpack, chimeraapp = self.surface_envcheck()
-                            bindisplay = os.getenv('DISPLAY')
-                            run_resmap_chimerax(bindisplay, chimeraapp, resmap_chimerax_file)
-                            # resmap = '{}_ori_resmap.map'.format(odd[:-4])
-                            # output_json = '{}{}_resmap.json'.format(self.workdir, self.mapname)
-                            # save_imagestojson(resmap, output_json)
+                        map_basename = os.path.splitext(os.path.basename(odd))[0]
+                        orgmap = self.rawmap._iostream.name
+                        resmap = '{}/{}_relion/{}_{}_locres.mrc'.format(self.workdir, self.mapname, os.path.basename(odd), os.path.basename(even))
+                        missing_view_inputs = resmap if not os.path.isfile(resmap) else None
+
+                        print(missing_view_inputs)
+                        if missing_view_inputs:
+                            err = 'Skipping local resolution views; missing input files: {}.'.format(
+                                ', '.join(missing_view_inputs)
+                            )
+                            errlist.append(err)
+                            sys.stderr.write(err + '\n')
+                        else:
+                            local_res_chimerax_file = relion_local_res_chimerax(orgmap, resmap, self.workdir)
+                            if os.path.isfile(local_res_chimerax_file):
+                                vtkpack, chimeraapp = self.surface_envcheck()
+                                bindisplay = os.getenv('DISPLAY')
+                                run_resmap_chimerax(bindisplay, chimeraapp, local_res_chimerax_file)
                     except:
-                        err = 'ResMap views error: {}.'.format(sys.exc_info()[1])
+                        err = 'Local resolution views error: {}.'.format(sys.exc_info()[1])
                         errlist.append(err)
                         sys.stderr.write(err + '\n')
                 else:
@@ -6928,6 +6937,8 @@ class ValidationAnalysis:
 
                 if errlist:
                     result_dict['err'] = errlist
+                    output_json = '{}{}_resmap.json'.format(self.workdir, self.mapname)
+                    out_json(result_dict, output_json)
                 else:
                     try:
                         resmap = '{}_ori_resmap.map'.format(odd[:-4])
@@ -6960,7 +6971,7 @@ class ValidationAnalysis:
             except (TypeError, ValueError):
                 res_val = None
             if res_val is not None:
-                local_res = localres_histogram(self.hmodd.fullname, self.mapname, res_val)
+                local_res = localres_histogram(self.hmodd._iostream.name, self.mapname, res_val)
             else:
                 local_res = None
 

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

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