emdbva 0.0.1.dev127__tar.gz → 0.0.1.dev129__tar.gz

{emdbva-0.0.1.dev127/emdbva.egg-info → emdbva-0.0.1.dev129}/PKG-INFO

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

{emdbva-0.0.1.dev127 → emdbva-0.0.1.dev129/emdbva.egg-info}/PKG-INFO

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

{emdbva-0.0.1.dev127 → emdbva-0.0.1.dev129}/va/preparation.py

@@ -669,12 +669,44 @@ class PreParation:
         block = doc.sole_block()
 
         # Extract resolution and reconstruction method
-        reconstruction_method = block.find_value('_em_experiment.reconstruction_method').replace("'", "").lower() or None
-        resolution = block.find_value('_em_3d_reconstruction.resolution')
-        resolution = float(resolution) if resolution and resolution != '?' else None
+        rm = block.find_value('_em_experiment.reconstruction_method')
+        reconstruction_method = (
+            str(rm).replace("'", "").strip().lower()
+            if rm and str(rm).strip() not in ('?', '.', '')
+            else None
+        )
+
+        # Extract resolution (scalar)
+        res = block.find_value('_em_3d_reconstruction.resolution')
+        resolution = None
+        if res and str(res).strip() not in ('?', '.', ''):
+            try:
+                resolution = float(str(res).strip().strip("'").strip('"'))
+            except ValueError:
+                resolution = None
+
+        # Fallback: try loop column *only if it exists*
         if resolution is None and reconstruction_method != 'tomography':
-            resolution_loop = block.find_loop('_em_3d_reconstruction.resolution')
-            resolution = next(x for x in resolution_loop if x != '?')
+            col = block.find_loop('_em_3d_reconstruction.resolution')  # returns Column
+
+            # If the column is nil, get_loop() will either fail or be useless.
+            # So we just try to iterate safely:
+            value = None
+            try:
+                for x in col:  # iterates over column values if non-nil
+                    sx = str(x).strip().strip("'").strip('"')
+                    if sx not in ('?', '.', ''):
+                        value = sx
+                        break
+            except Exception:
+                value = None
+
+            if value is not None:
+                try:
+                    resolution = float(value)
+                except ValueError:
+                    resolution = None
+
 
         # Initialize map containers
         map_data = {'primary': {}, 'mask': {}, 'odd': {}, 'even': {}}
@@ -701,6 +733,7 @@ class PreParation:
                 map_types = [map_type]
             except Exception as e:
                 # fallback or log error
+                print(f'Error parsing map information: {e}')
                 contour_levels, map_files, map_types = [], [], []
 
         # Parse combined map data

{emdbva-0.0.1.dev127 → emdbva-0.0.1.dev129}/va/utils/ChimeraxViews.py

@@ -475,11 +475,17 @@ class ChimeraxViews:
         output_json = {}
         raw_map = f'{self.va_dir}/{map_name[:-4] + "_rawmap.map"}'
         mask_map = f'{self.va_dir}/{map_name}_relion/mask/{map_name}_mask.mrc'
+        # if mask does not exist, treat as no mask
+        if not os.path.isfile(mask_map):
+            mask_map = None
         local_resolution_map_glob = glob.glob(f'{self.va_dir}/{map_name}_relion/*_locres.mrc')
         local_resolution_map = local_resolution_map_glob[0] if len(local_resolution_map_glob) > 0 else None
         map_processor = MapProcessor()
-        binarized_mask_map = map_processor.binarized_mask(mask_map, map_name)
-        masked_raw_map = map_processor.mask_map(raw_map, binarized_mask_map)
+        if mask_map:
+            binarized_mask_map = map_processor.binarized_mask(mask_map, map_name)
+            masked_raw_map = map_processor.mask_map(raw_map, binarized_mask_map)
+        else:
+            masked_raw_map = raw_map
         map_min, map_max = map_processor.map_minmax(masked_raw_map, local_resolution_map)
         real_min = map_min if map_min < all_models_min_value else all_models_min_value
         real_max = map_max if map_max > all_models_max_value else all_models_max_value
@@ -487,7 +493,8 @@ class ChimeraxViews:
         new_max = scale_value(map_max, real_min, real_max, 0, 1)
         num_elements = 50
         palette_colours = self.generate_palette(new_min, new_max, map_min, map_max, num_elements)
-        chimerax_file_name = self.write_maps_cxc(os.path.basename(masked_raw_map), local_resolution_map, palette_colours, data_type)
+        chimerax_file_name = self.write_maps_cxc(os.path.basename(masked_raw_map), local_resolution_map,
+                                                 palette_colours, data_type)
         out = self.run_chimerax(chimerax_file_name)
         surfaces_dict = self.rescale_view(os.path.basename(masked_raw_map), None, None, data_type)
         output_json[f'{data_type}_views'] = surfaces_dict

{emdbva-0.0.1.dev127 → emdbva-0.0.1.dev129}/va/utils/stars.py

@@ -64,6 +64,12 @@ class GetStars:
 
         return float(self.data_general_block()['_rlnFinalResolution'])
 
+    def bfactor_sharpen(self):
+        """
+            Get the resolution value that Relion is use for the phase randomization calculation
+        """
+        return float(self.data_general_block()['_rlnBfactorUsedForSharpening'])
+
     def data_fsc_block(self):
         """
         Get the data_fsc block
@@ -89,6 +95,73 @@ class GetStars:
 
         return data_fsc_block
 
+    def data_guinier_block(self):
+        """
+        Get the data_guinier block (RELION postprocess output).
+
+        Returns:
+            dict: { column_name(str): [values...] }
+                  Example keys (typical RELION):
+                    - ResolutionSquared
+                    - LogAmplitudesOriginal
+                    - LogAmplitudesWeighted
+                    - LogAmplitudesSharpened
+                    - LogAmplitudesIntercept
+        """
+        if 'data_guinier' not in self.star_blocks:
+            return {}
+
+        lines = [l.strip() for l in self.star_blocks['data_guinier'] if l.strip()]
+        if not lines:
+            return {}
+
+        # Find loop_ line
+        try:
+            loop_idx = lines.index('loop_')
+        except ValueError:
+            # Sometimes it could be "loop_" with trailing spaces already stripped above,
+            # or the block could be non-loop (rare). In that case, return empty for now.
+            return {}
+
+        # Read headers: consecutive lines starting with "_rln"
+        header_lines = []
+        i = loop_idx + 1
+        while i < len(lines) and lines[i].startswith('_rln'):
+            header_lines.append(lines[i])
+            i += 1
+
+        # Convert header lines to clean names (strip "_rln" and remove "#n")
+        headers = []
+        for h in header_lines:
+            # e.g. "_rlnResolutionSquared #1" -> "ResolutionSquared"
+            parts = h.split()
+            tag = parts[0]  # "_rlnResolutionSquared"
+            headers.append(tag[4:])  # remove "_rln"
+
+        # Remaining lines are data rows
+        data_rows = lines[i:]
+        if not data_rows or not headers:
+            return {}
+
+        # Parse rows into columns
+        col_values = [[] for _ in headers]
+        for row in data_rows:
+            vals = row.split()
+            if len(vals) < len(headers):
+                # skip malformed/short row
+                continue
+            for ci in range(len(headers)):
+                v = vals[ci]
+                # RELION usually uses numeric values; be defensive anyway
+                try:
+                    fv = float(v)
+                    col_values[ci].append(keep_three_significant_digits(fv))
+                except Exception:
+                    col_values[ci].append(v)
+
+        return dict(zip(headers, col_values))
+
+
     def data_extra(self, data_fsc_block):
         """
         Add half bit, one-bit and 3-sigma to data_fsc_block
@@ -148,6 +221,7 @@ class GetStars:
         corrected = data_fsc_block['FourierShellCorrelationCorrected']
         phase_rand = data_fsc_block.get('CorrectedFourierShellCorrelationPhaseRandomizedMaskedMaps', None)
         randomise_from = self.randomise_from()
+        sharpen_bfactor = self.bfactor_sharpen()
 
         x_gold, y_gold = interpolated_intercept(x, correlation, gold)
         x_half, y_half = interpolated_intercept(x, correlation, half)
@@ -214,7 +288,8 @@ class GetStars:
             'phase_randomized_0.143': {'x': x_phase_gold, 'y': y_phase_gold},
             'phase_randomized_half': {'x': x_phase_half, 'y': y_phase_half},
             'phase_randomized_halfbit': {'x': x_phase_halfbit, 'y': y_phase_halfbit},
-            'randomise_from': randomise_from
+            'randomise_from': randomise_from,
+            'sharpen_bfactor': sharpen_bfactor
         }
         }
 
@@ -240,6 +315,14 @@ class GetStars:
             'fsc_corrected': 'FourierShellCorrelationCorrected'
         }
         curves = {key: data_fsc_block[value] for key, value in curve_mapping.items() if value in data_fsc_block}
+
+        # incorporate any guinier curves returned by data_guinier_block()
+        guinier = self.data_guinier_block()
+        if guinier:
+            # add guinier columns into curves; avoid overwriting existing keys
+            for gk, gv in guinier.items():
+                curves[f'guinier_{str(gk).lower()}'] = gv
+
         final_curves = {'curves': curves}
 
         return final_curves
@@ -315,6 +398,7 @@ class GetStars:
             plt.plot(levels, golden_line, linestyle='-.',  label='0.143')
             plt.legend(loc='upper right', fontsize='x-small')
             plt.savefig(self.va_dir + '/current_Relion_fsc.png')
+            print(f'FSC curve saved to {self.va_dir}/current_Relion_fsc.png')
             plt.close()
 
     def plot_feature_zone(self, intersections, levels, corrected_curve, phase_rand_curve):
@@ -365,6 +449,95 @@ class GetStars:
         plt.close()
 
         return feature_area, overfit_area
+
+    def plot_guinier(self, guinier_block=None, save_path=None, show=False):
+        """
+        Plot Guinier curves (Log amplitudes vs ResolutionSquared).
+
+        Parameters:
+            guinier_block (dict): output from self.data_guinier_block(). If None, the method will call it.
+            save_path (str): full path to save the image. If None, saves to `self.va_dir/current_Relion_guinier.png`.
+            show (bool): if True, call plt.show() before closing.
+        Returns:
+            str or None: path to saved image or None if no data.
+        """
+        if guinier_block is None:
+            guinier_block = self.data_guinier_block()
+        if not guinier_block:
+            print('No guinier data to plot')
+            return None
+
+        # prefer canonical key name
+        x_key = None
+        for candidate in ('ResolutionSquared', 'resolutionSquared', 'Resolution_Squared', 'Resolution'):
+            if candidate in guinier_block:
+                x_key = candidate
+                break
+        if x_key is None:
+            print('No resolution column found in guinier data')
+            return None
+
+        try:
+            x = np.array(guinier_block[x_key], dtype=float)
+        except Exception:
+            print('Resolution column contains non-numeric data')
+            return None
+
+        # detect weighted column to filter out -99 sentinel rows
+        weighted_key = next((k for k in guinier_block.keys() if 'weighted' in k.lower()), None)
+        mask = None
+        if weighted_key is not None:
+            try:
+                weighted_arr = np.array(guinier_block[weighted_key], dtype=float)
+                mask = weighted_arr != -99
+                if not np.any(mask):
+                    print('All weighted values are -99; no guinier data to plot')
+                    return None
+                # apply mask to x
+                x = x[mask]
+            except Exception:
+                mask = None
+
+        # pick numeric columns excluding the x column
+        y_keys = [k for k in guinier_block.keys() if k != x_key]
+        if not y_keys:
+            print('No guinier amplitude columns to plot')
+            return None
+
+        plt.figure(figsize=(6, 4))
+        for key in y_keys:
+            try:
+                y = np.array(guinier_block[key], dtype=float)
+            except Exception:
+                # skip non-numeric series
+                continue
+            if mask is not None:
+                # ensure same length before applying mask
+                if y.shape[0] != mask.shape[0]:
+                    # skip series with mismatched length
+                    continue
+                y = y[mask]
+            if y.size == 0 or x.size == 0 or x.shape[0] != y.shape[0]:
+                # skip empty or mismatched series
+                continue
+            plt.plot(x, y, linestyle='-', label=key)
+
+        plt.xlabel(x_key)
+        plt.ylabel('Log Amplitude')
+        plt.title('Guinier plot')
+        plt.legend(loc='best', fontsize='x-small')
+        plt.grid(True)
+
+        out_path = save_path or f'{self.va_dir}/current_Relion_guinier.png'
+        plt.tight_layout()
+        plt.savefig(out_path)
+        if show:
+            plt.show()
+        plt.close()
+        print(f'Guinier plot saved to {out_path}')
+        return out_path
+
+
     @staticmethod
     def area_difference(curve_one, curve_two, levels):
         """

{emdbva-0.0.1.dev127 → emdbva-0.0.1.dev129}/va/validationanalysis.py

@@ -293,7 +293,11 @@ class ValidationAnalysis:
                 star = GetStars(star_file_dir)
                 nomask_resolution = star.final_resolution()
                 # For cases where Relion resolution is too high, use the input resolution
-                nomask_resolution = min(nomask_resolution, 15 * float(self.resolution))
+                if self.resolution is not None:
+                    try:
+                        nomask_resolution = min(nomask_resolution, 15 * float(self.resolution))
+                    except (TypeError, ValueError):
+                        pass
                 raw_map_name = find_rawmap_file(self.workdir)
                 filtered_raw_map = self.get_lowpassed_map(f'{self.workdir}/{raw_map_name}', nomask_resolution)
                 relion_mask_name = relion_mask(filtered_raw_map, relion_mask_dir, self.mapname)
@@ -3845,6 +3849,7 @@ class ValidationAnalysis:
                 star.plot_fsc(data_curves, (xlist, ylist))
             else:
                 star.plot_fsc(data_curves)
+            star.plot_guinier()
             data_intersections = star.all_intersection(data_fsc_block)
 
             fsc_dict = {**data_curves, **data_intersections, **zones}
@@ -6464,93 +6469,233 @@ class ValidationAnalysis:
     def phenix_mmfsc(self):
         """
             Run Phenix map-model FSC calculation
+            Now also supports:
+              - raw map (existing)
+              - half map odd
+              - half map even
         :return:
         """
 
-        if self.platform == 'emdb' and self.met != 'tomo' and self.met != 'crys' :
+        if self.platform == 'emdb' and self.met != 'tomo' and self.met != 'crys':
             start = timeit.default_timer()
             errlist = []
+
             result_dict = {}
             raw_result_dict = {}
-            # if strudelapp and self.models:
+            odd_result_dict = {}
+            even_result_dict = {}
+
             if self.models:
                 nummodels = 0
+
                 allresults = {}
                 raw_allresults = {}
+                odd_allresults = {}
+                even_allresults = {}
+
                 for model in self.models:
+                    # prepare some vars so they always exist
+                    rerr = None
+                    mmfsclog = None
+
+                    raw_rerr = None
+                    raw_mmfsclog = None
+
+                    odd_rerr = None
+                    odd_mmfsclog = None
+
+                    even_rerr = None
+                    even_mmfsclog = None
+
                     try:
                         full_model = '{}{}'.format(self.workdir, os.path.basename(model.filename))
                         full_map = '{}{}'.format(self.workdir, self.mapname)
                         out_path = '{}_phenix'.format(full_model)
+
+                        # -------------------------
+                        # Primary map mmFSC (existing)
+                        # -------------------------
                         rerr = run_phenixmmfsc(full_model, full_map, out_path)
                         tmmfsclog = '{}/fsc_model.unmasked.mtriage.log'.format(out_path)
                         mmfsclog = '{}/fsc_model.unmasked.mtriage_{}.log'.format(out_path, self.mapname)
                         change_filename(tmmfsclog, mmfsclog)
-                        raw_mmfsclog = None
-                        raw_rerr = None
+
+                        # -------------------------
+                        # Raw map mmFSC (existing behavior)
+                        # NOTE: your code checks self.hmodd and self.hmeven to decide raw.
+                        # If you actually mean "if rawmap exists", replace condition with "if self.rawmap"
+                        # -------------------------
                         if self.hmodd and self.hmeven:
                             raw_full_map = self.rawmap.fullname
                             raw_mapname = os.path.basename(raw_full_map)
                             raw_rerr = run_phenixmmfsc(full_model, raw_full_map, out_path)
+                            tmmfsclog = '{}/fsc_model.unmasked.mtriage.log'.format(out_path)
                             raw_mmfsclog = '{}/fsc_model.unmasked.mtriage_{}.log'.format(out_path, raw_mapname)
                             change_filename(tmmfsclog, raw_mmfsclog)
+
+                        # -------------------------
+                        # Half-map odd/even mmFSC (NEW)
+                        # -------------------------
+                        if self.hmodd and self.hmeven:
+                            # odd
+                            odd_full_map = getattr(self.hmodd, "fullname", self.hmodd)
+                            odd_mapname = os.path.basename(odd_full_map)
+                            odd_rerr = run_phenixmmfsc(full_model, odd_full_map, out_path)
+                            tmmfsclog = '{}/fsc_model.unmasked.mtriage.log'.format(out_path)
+                            odd_mmfsclog = '{}/fsc_model.unmasked.mtriage_{}.log'.format(out_path, odd_mapname)
+                            change_filename(tmmfsclog, odd_mmfsclog)
+
+                            # even
+                            even_full_map = getattr(self.hmeven, "fullname", self.hmeven)
+                            even_mapname = os.path.basename(even_full_map)
+                            even_rerr = run_phenixmmfsc(full_model, even_full_map, out_path)
+                            tmmfsclog = '{}/fsc_model.unmasked.mtriage.log'.format(out_path)
+                            even_mmfsclog = '{}/fsc_model.unmasked.mtriage_{}.log'.format(out_path, even_mapname)
+                            change_filename(tmmfsclog, even_mmfsclog)
+
                         end = timeit.default_timer()
                         print('Phenix mmFSC time: %s' % (end - start))
                         print('------------------------------------')
+
                     except:
                         err = 'Phenix mmFSC calculation error: {}.'.format(sys.exc_info()[1])
                         errlist.append(err)
                         sys.stderr.write(err + '\n')
+
                     nyquist = 1 / (2 * self.map.voxel_size.tolist()[0])
-                    try:
-                        df = read_mmfsc(mmfsclog, rerr)
-                        mmfscdict = mmfscdf_todict(df, nyquist)
 
-                        allresults[str(nummodels)] = {'name': os.path.basename(model.filename),
-                                                      'data': mmfscdict}
+                    # -------------------------
+                    # Parse + collect results (Primary)
+                    # -------------------------
+                    try:
+                        if mmfsclog is not None and rerr is not None:
+                            df = read_mmfsc(mmfsclog, rerr)
+                            mmfscdict = mmfscdf_todict(df, nyquist)
+
+                            allresults[str(nummodels)] = {
+                                'name': os.path.basename(model.filename),
+                                'data': mmfscdict
+                            }
+                    except:
+                        err = 'Save Phenix mmFSC data error: {}.'.format(sys.exc_info()[1])
+                        errlist.append(err)
+                        sys.stderr.write(err + '\n')
 
-                        if self.hmodd and self.hmeven:
+                    # -------------------------
+                    # Parse + collect results (Raw)
+                    # -------------------------
+                    try:
+                        if self.hmodd and self.hmeven and raw_mmfsclog is not None and raw_rerr is not None:
                             raw_df = read_mmfsc(raw_mmfsclog, raw_rerr)
                             raw_mmfscdict = mmfscdf_todict(raw_df, nyquist)
 
-                            raw_allresults[str(nummodels)] = {'name': os.path.basename(model.filename),
-                                                              'data': raw_mmfscdict}
+                            raw_allresults[str(nummodels)] = {
+                                'name': os.path.basename(model.filename),
+                                'data': raw_mmfscdict
+                            }
+                    except:
+                        err = 'Save raw Phenix mmFSC data error: {}.'.format(sys.exc_info()[1])
+                        errlist.append(err)
+                        sys.stderr.write(err + '\n')
+
+                    # -------------------------
+                    # Parse + collect results (Half odd) NEW
+                    # -------------------------
+                    try:
+                        if self.hmodd and self.hmeven and odd_mmfsclog is not None and odd_rerr is not None:
+                            odd_df = read_mmfsc(odd_mmfsclog, odd_rerr)
+                            odd_mmfscdict = mmfscdf_todict(odd_df, nyquist)
+
+                            odd_allresults[str(nummodels)] = {
+                                'name': os.path.basename(model.filename),
+                                'data': odd_mmfscdict
+                            }
+                    except:
+                        err = 'Save half-odd Phenix mmFSC data error: {}.'.format(sys.exc_info()[1])
+                        errlist.append(err)
+                        sys.stderr.write(err + '\n')
 
+                    # -------------------------
+                    # Parse + collect results (Half even) NEW
+                    # -------------------------
+                    try:
+                        if self.hmodd and self.hmeven and even_mmfsclog is not None and even_rerr is not None:
+                            even_df = read_mmfsc(even_mmfsclog, even_rerr)
+                            even_mmfscdict = mmfscdf_todict(even_df, nyquist)
+
+                            even_allresults[str(nummodels)] = {
+                                'name': os.path.basename(model.filename),
+                                'data': even_mmfscdict
+                            }
                     except:
-                        err = 'Save Phenix mmFSC data error: {}.'.format(sys.exc_info()[1])
+                        err = 'Save half-even Phenix mmFSC data error: {}.'.format(sys.exc_info()[1])
                         errlist.append(err)
                         sys.stderr.write(err + '\n')
+
                     nummodels += 1
 
+                # -------------------------
+                # Build output dicts (same pattern you used)
+                # -------------------------
                 if allresults:
                     result_dict['mmfsc'] = allresults
+
                 if raw_allresults:
                     raw_result_dict['raw_mmfsc'] = raw_allresults
 
+                if odd_allresults:
+                    odd_result_dict['half_odd_mmfsc'] = odd_allresults
+
+                if even_allresults:
+                    even_result_dict['half_even_mmfsc'] = even_allresults
+
                 if errlist:
+                    # keep your behavior: errors only attached to result_dict
                     result_dict['err'] = errlist
 
+                # -------------------------
+                # Write JSON files (same gating logic you used)
+                # -------------------------
                 if len(result_dict) == 1 and 'mmfsc' in result_dict:
                     try:
-                        with codecs.open(self.workdir + self.mapname + '_mmfsc.json', 'w',
-                                         encoding='utf-8') as f:
+                        with codecs.open(self.workdir + self.mapname + '_mmfsc.json', 'w', encoding='utf-8') as f:
                             json.dump(result_dict, f)
                     except:
                         sys.stderr.write('Saving to mmFSC json error: {}.\n'.format(sys.exc_info()[1]))
-
                 else:
                     print('mmFSC was not collected, please check the error!')
 
                 if len(raw_result_dict) == 1 and 'raw_mmfsc' in raw_result_dict:
                     try:
-                        with codecs.open(self.workdir + self.mapname + '_raw_mmfsc.json', 'w',
-                                         encoding='utf-8') as f:
+                        with codecs.open(self.workdir + self.mapname + '_raw_mmfsc.json', 'w', encoding='utf-8') as f:
                             json.dump(raw_result_dict, f)
                     except:
                         sys.stderr.write('Saving to raw mmFSC json error: {}.\n'.format(sys.exc_info()[1]))
+                else:
+                    if self.hmodd and self.hmeven:
+                        print('Raw map mmFSC was not collected, please check the error!')
+
+                if len(odd_result_dict) == 1 and 'half_odd_mmfsc' in odd_result_dict:
+                    try:
+                        with codecs.open(self.workdir + self.mapname + '_half_odd_mmfsc.json', 'w',
+                                         encoding='utf-8') as f:
+                            json.dump(odd_result_dict, f)
+                    except:
+                        sys.stderr.write('Saving to half-odd mmFSC json error: {}.\n'.format(sys.exc_info()[1]))
+                else:
+                    if self.hmodd and self.hmeven:
+                        print('Half-odd map mmFSC was not collected, please check the error!')
 
+                if len(even_result_dict) == 1 and 'half_even_mmfsc' in even_result_dict:
+                    try:
+                        with codecs.open(self.workdir + self.mapname + '_half_even_mmfsc.json', 'w',
+                                         encoding='utf-8') as f:
+                            json.dump(even_result_dict, f)
+                    except:
+                        sys.stderr.write('Saving to half-even mmFSC json error: {}.\n'.format(sys.exc_info()[1]))
                 else:
-                    print('Raw map mmFSC was not collected, please check the error!')
+                    if self.hmodd and self.hmeven:
+                        print('Half-even map mmFSC was not collected, please check the error!')
 
             else:
                 print('No model!!')
@@ -6558,6 +6703,7 @@ class ValidationAnalysis:
 
         return None
 
+
     @profile_peak_memory()
     def locres_resmap(self):
         """
@@ -6633,10 +6779,16 @@ class ValidationAnalysis:
         result_dict = {}
         errlist = []
         start = timeit.default_timer()
+        local_res = None
         if self.platform == 'emdb' and self.met != 'tomo' and self.hmodd and self.hmeven:
-            local_res = localres_histogram(self.hmodd.fullname, self.mapname, float(self.resolution))
-        else:
-            local_res = None
+            try:
+                res_val = float(self.resolution) if self.resolution is not None else None
+            except (TypeError, ValueError):
+                res_val = None
+            if res_val is not None:
+                local_res = localres_histogram(self.hmodd.fullname, self.mapname, res_val)
+            else:
+                local_res = None
 
         if local_res:
             result_dict['local_res_histogram'] = local_res

{emdbva-0.0.1.dev127 → emdbva-0.0.1.dev129}/va/version.py

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