masster 0.3.10__py3-none-any.whl → 0.3.11__py3-none-any.whl

masster/sample/load.py

@@ -85,9 +85,9 @@ def load(
         filename = self.file_path
     filename = os.path.abspath(filename)
     if not os.path.exists(filename):
-        raise FileNotFoundError(f"Filename not valid. Provide a valid file path.")
+        raise FileNotFoundError("Filename not valid. Provide a valid file path.")
     self.ondisk = ondisk
-    
+
     # check if file is mzML
     if filename.lower().endswith(".mzml"):
         self._load_mzML(filename)
@@ -97,7 +97,7 @@ def load(
         self._load_raw(filename)
     elif filename.lower().endswith(".sample5"):
         self._load_sample5(filename)
-    #elif filename.lower().endswith(".h5"):
+    # elif filename.lower().endswith(".h5"):
     #    self._load_h5(filename)
     else:
         raise ValueError("File must be .mzML, .wiff, *.raw, or .sample5")
@@ -137,7 +137,7 @@ def _load_mzML(
     # check if filename exists
     if filename is None:
         raise ValueError("Filename must be provided.")
-    
+
     filename = os.path.abspath(filename)
     # check if it exists
     if not os.path.exists(filename):
@@ -310,7 +310,7 @@ def _load_raw(
         - Initiates further analysis by invoking analyze_dda().
     """
     from alpharaw.thermo import ThermoRawData
-    
+
     if not filename:
         raise ValueError("Filename must be provided.")
 
@@ -318,7 +318,7 @@ def _load_raw(
     # check if it exists
     if not os.path.exists(filename):
         raise FileNotFoundError(f"File {filename} not found.")
-    
+
     raw_data = ThermoRawData(centroided=False)
     raw_data.keep_k_peaks_per_spec = self.parameters.max_points_per_spectrum
     # check thatupdat filename ends with .raw
@@ -470,10 +470,12 @@ def _load_wiff(
     try:
         # Use masster's own implementation first
         from masster.sample.sciex import SciexWiffData as MassterSciexWiffData
+
         SciexWiffDataClass = MassterSciexWiffData
     except ImportError:
         # Fallback to alpharaw if masster implementation fails
         from alpharaw.sciex import SciexWiffData as AlpharawSciexWiffData
+
         SciexWiffDataClass = AlpharawSciexWiffData
 
     if not filename:
@@ -483,7 +485,7 @@ def _load_wiff(
     # check if it exists
     if not os.path.exists(filename):
         raise FileNotFoundError(f"File {filename} not found.")
-    
+
     raw_data = SciexWiffDataClass(centroided=False)
     raw_data.keep_k_peaks_per_spec = self.parameters.max_points_per_spectrum
 
@@ -911,7 +913,7 @@ def index_file(self):
             oms.MzMLFile().load(self.file_source, omsexp)
             self.file_obj = omsexp
     elif os.path.exists(self.file_source) and self.file_source.lower().endswith(".sample5"):
-        # this is an old save, try to see if 
+        # this is an old save, try to see if
         if os.path.exists(self.file_source.replace(".sample5", ".wiff")):
             self.set_source(self.file_source.replace(".sample5", ".wiff"))
         elif os.path.exists(self.file_source.replace(".sample5", ".raw")):
@@ -919,7 +921,9 @@ def index_file(self):
         elif os.path.exists(self.file_source.replace(".sample5", ".mzml")):
             self.set_source(self.file_source.replace(".sample5", ".mzml"))
         else:
-            raise FileNotFoundError(f"File {self.file_source} not found. Did the path change? Consider running source().")
+            raise FileNotFoundError(
+                f"File {self.file_source} not found. Did the path change? Consider running source()."
+            )
         self.index_file()
     else:
         raise FileNotFoundError(f"File {self.file_source} not found. Did the path change? Consider running source().")

masster/sample/plot.py

@@ -66,49 +66,51 @@ hv.extension("bokeh")
 def _is_notebook_environment():
     """
     Detect if code is running in a notebook environment (Jupyter, JupyterLab, or Marimo).
-    
+
     Returns:
         bool: True if running in a notebook, False otherwise
     """
     try:
         # Check for Jupyter/JupyterLab
         from IPython import get_ipython
+
         if get_ipython() is not None:
             # Check if we're in a notebook context
             shell = get_ipython().__class__.__name__
-            if shell in ['ZMQInteractiveShell', 'Shell']:  # Jupyter notebook/lab
+            if shell in ["ZMQInteractiveShell", "Shell"]:  # Jupyter notebook/lab
                 return True
-        
+
         # Check for Marimo
         import sys
-        if 'marimo' in sys.modules:
+
+        if "marimo" in sys.modules:
             return True
-        
+
         # Additional check for notebook environments
-        if hasattr(__builtins__, '__IPYTHON__') or hasattr(__builtins__, '_ih'):
+        if hasattr(__builtins__, "__IPYTHON__") or hasattr(__builtins__, "_ih"):
             return True
-            
+
     except ImportError:
         pass
-    
+
     return False
 
 
 def _display_plot(plot_object, layout=None):
     """
     Display a plot object in the appropriate way based on the environment.
-    
+
     Args:
         plot_object: The plot object to display (holoviews overlay, etc.)
         layout: Optional panel layout object
-        
+
     Returns:
         The layout object if in notebook environment, None otherwise
     """
     if _is_notebook_environment():
         # Display inline in notebook
         try:
-            # For Jupyter notebooks, just return the plot object - 
+            # For Jupyter notebooks, just return the plot object -
             # holoviews will handle the display automatically
             return plot_object
         except Exception:
@@ -395,17 +397,18 @@ def plot_2d(
     # Configure marker and size behavior based on size parameter
     use_dynamic_sizing = size.lower() in ["dyn", "dynamic"]
     use_slider_sizing = size.lower() == "slider"
-    
+
     def dynamic_sizing_hook(plot, element):
         """Hook to convert size-based markers to radius-based for dynamic behavior"""
         try:
-            if use_dynamic_sizing and hasattr(plot, 'state') and hasattr(plot.state, 'renderers'):
+            if use_dynamic_sizing and hasattr(plot, "state") and hasattr(plot.state, "renderers"):
                 from bokeh.models import Circle
+
                 for renderer in plot.state.renderers:
-                    if hasattr(renderer, 'glyph'):
+                    if hasattr(renderer, "glyph"):
                         glyph = renderer.glyph
                         # Check if it's a circle/scatter glyph that we can convert
-                        if hasattr(glyph, 'size') and marker_type == "circle":
+                        if hasattr(glyph, "size") and marker_type == "circle":
                             # Create a new Circle glyph with radius instead of size
                             new_glyph = Circle(
                                 x=glyph.x,
@@ -420,7 +423,7 @@ def plot_2d(
         except Exception:
             # Silently fail and use regular sizing if hook doesn't work
             pass
-    
+
     if use_dynamic_sizing:
         # Dynamic sizing: use coordinate-based sizing that scales with zoom
         marker_type = "circle"
@@ -446,7 +449,7 @@ def plot_2d(
         size_2 = markersize
         base_radius = None  # Not used in static mode
         hooks = []
-    
+
     color_1 = "forestgreen"
     color_2 = "darkorange"
     if filename is not None:
@@ -519,14 +522,16 @@ def plot_2d(
         # find features with ms2_scans not None  and iso==0
         features_df = feats[feats["ms2_scans"].notnull()]
         # Create feature points with proper sizing method
-        feature_hover_1 = HoverTool(tooltips=[
-            ("rt", "@rt"),
-            ("m/z", "@mz{0.0000}"),
-            ("feature_uid", "@feature_uid"),
-            ("inty", "@inty"),
-            ("quality", "@quality"),
-            ("rt_delta", "@rt_delta"),
-        ])
+        feature_hover_1 = HoverTool(
+            tooltips=[
+                ("rt", "@rt"),
+                ("m/z", "@mz{0.0000}"),
+                ("feature_uid", "@feature_uid"),
+                ("inty", "@inty"),
+                ("quality", "@quality"),
+                ("rt_delta", "@rt_delta"),
+            ],
+        )
         feature_points_1 = hv.Points(
             features_df,
             kdims=["rt", "mz"],
@@ -549,14 +554,16 @@ def plot_2d(
         )
         # find features without MS2 data
         features_df = feats[feats["ms2_scans"].isnull()]
-        feature_hover_2 = HoverTool(tooltips=[
-            ("rt", "@rt"),
-            ("m/z", "@mz{0.0000}"),
-            ("feature_uid", "@feature_uid"),
-            ("inty", "@inty"),
-            ("quality", "@quality"),
-            ("rt_delta", "@rt_delta"),
-        ])
+        feature_hover_2 = HoverTool(
+            tooltips=[
+                ("rt", "@rt"),
+                ("m/z", "@mz{0.0000}"),
+                ("feature_uid", "@feature_uid"),
+                ("inty", "@inty"),
+                ("quality", "@quality"),
+                ("rt_delta", "@rt_delta"),
+            ],
+        )
         feature_points_2 = hv.Points(
             features_df,
             kdims=["rt", "mz"],
@@ -583,16 +590,18 @@ def plot_2d(
             # Convert to pandas for plotting compatibility
             if hasattr(features_df, "to_pandas"):
                 features_df = features_df.to_pandas()
-            feature_hover_iso = HoverTool(tooltips=[
-                ("rt", "@rt"),
-                ("m/z", "@mz{0.0000}"),
-                ("feature_uid", "@feature_uid"),
-                ("inty", "@inty"),
-                ("quality", "@quality"),
-                ("rt_delta", "@rt_delta"),
-                ("iso", "@iso"),
-                ("iso_of", "@iso_of"),
-            ])
+            feature_hover_iso = HoverTool(
+                tooltips=[
+                    ("rt", "@rt"),
+                    ("m/z", "@mz{0.0000}"),
+                    ("feature_uid", "@feature_uid"),
+                    ("inty", "@inty"),
+                    ("quality", "@quality"),
+                    ("rt_delta", "@rt_delta"),
+                    ("iso", "@iso"),
+                    ("iso_of", "@iso_of"),
+                ],
+            )
             feature_points_iso = hv.Points(
                 features_df,
                 kdims=["rt", "mz"],
@@ -623,13 +632,15 @@ def plot_2d(
         if len(ms2_orphan) > 0:
             # pandalize
             ms2 = ms2_orphan.to_pandas()
-            ms2_hover_3 = HoverTool(tooltips=[
-                ("rt", "@rt"),
-                ("prec_mz", "@prec_mz{0.0000}"),
-                ("index", "@index"),
-                ("inty_tot", "@inty_tot"),
-                ("bl", "@bl"),
-            ])
+            ms2_hover_3 = HoverTool(
+                tooltips=[
+                    ("rt", "@rt"),
+                    ("prec_mz", "@prec_mz{0.0000}"),
+                    ("index", "@index"),
+                    ("inty_tot", "@inty_tot"),
+                    ("bl", "@bl"),
+                ],
+            )
             feature_points_3 = hv.Points(
                 ms2,
                 kdims=["rt", "prec_mz"],
@@ -648,13 +659,15 @@ def plot_2d(
         if len(ms2_linked) > 0:
             # pandalize
             ms2 = ms2_linked.to_pandas()
-            ms2_hover_4 = HoverTool(tooltips=[
-                ("rt", "@rt"),
-                ("prec_mz", "@prec_mz{0.0000}"),
-                ("index", "@index"),
-                ("inty_tot", "@inty_tot"),
-                ("bl", "@bl"),
-            ])
+            ms2_hover_4 = HoverTool(
+                tooltips=[
+                    ("rt", "@rt"),
+                    ("prec_mz", "@prec_mz{0.0000}"),
+                    ("index", "@index"),
+                    ("inty_tot", "@inty_tot"),
+                    ("bl", "@bl"),
+                ],
+            )
             feature_points_4 = hv.Points(
                 ms2,
                 kdims=["rt", "prec_mz"],
@@ -688,17 +701,17 @@ def plot_2d(
         # For slider functionality, we need to work with the feature points directly
         # and not nest DynamicMaps. We'll create the slider using param and panel.
         import param
-        import panel as pn
-        
+        import panel as on
+
         class MarkerSizeController(param.Parameterized):
             size_slider = param.Number(default=markersize, bounds=(1, 20), step=0.5)
-        
+
         controller = MarkerSizeController()
-        
+
         # Create a function that generates just the feature overlays with different sizes
         def create_feature_overlay(size_val):
             feature_overlay = None
-            
+
             if feature_points_4 is not None:
                 updated_points_4 = feature_points_4.opts(size=size_val)
                 feature_overlay = updated_points_4 if feature_overlay is None else feature_overlay * updated_points_4
@@ -713,22 +726,24 @@ def plot_2d(
                 feature_overlay = updated_points_2 if feature_overlay is None else feature_overlay * updated_points_2
             if feature_points_iso is not None:
                 updated_points_iso = feature_points_iso.opts(size=size_val)
-                feature_overlay = updated_points_iso if feature_overlay is None else feature_overlay * updated_points_iso
-                
+                feature_overlay = (
+                    updated_points_iso if feature_overlay is None else feature_overlay * updated_points_iso
+                )
+
             # Combine with the static raster background
             if feature_overlay is not None:
                 combined_overlay = raster * feature_overlay
             else:
                 combined_overlay = raster
-                
+
             if title is not None:
                 combined_overlay = combined_overlay.opts(title=title)
-                
+
             return combined_overlay
-        
+
         # Create a horizontal control widget on top of the plot
         # Create the slider widget with explicit visibility
-        size_slider = pn.widgets.FloatSlider(
+        size_slider = on.widgets.FloatSlider(
             name="Marker Size",
             start=1.0,
             end=20.0,
@@ -737,19 +752,19 @@ def plot_2d(
             width=300,
             height=40,
             margin=(5, 5),
-            show_value=True
+            show_value=True,
         )
-        
+
         # Create the slider widget row with clear styling
-        slider_widget = pn.Row(
-            pn.pane.HTML("<b>Marker Size Control:</b>", width=150, height=40, margin=(5, 10)),
+        slider_widget = on.Row(
+            on.pane.HTML("<b>Marker Size Control:</b>", width=150, height=40, margin=(5, 10)),
             size_slider,
             height=60,
-            margin=10
+            margin=10,
         )
-        
+
         # Create slider widget
-        size_slider = pn.widgets.FloatSlider(
+        size_slider = on.widgets.FloatSlider(
             name="Marker Size",
             start=1.0,
             end=20.0,
@@ -758,18 +773,18 @@ def plot_2d(
             width=300,
             height=40,
             margin=(5, 5),
-            show_value=True
+            show_value=True,
         )
-        
-        slider_widget = pn.Row(
-            pn.pane.HTML("<b>Marker Size:</b>", width=100, height=40, margin=(5, 10)),
+
+        slider_widget = on.Row(
+            on.pane.HTML("<b>Marker Size:</b>", width=100, height=40, margin=(5, 10)),
             size_slider,
             height=60,
-            margin=10
+            margin=10,
         )
-        
+
         # Simple reactive plot - slider mode doesn't use dynamic rasterization
-        @pn.depends(size_slider.param.value)
+        @on.depends(size_slider.param.value)
         def reactive_plot(size_val):
             overlay = create_feature_overlay(float(size_val))
             # Apply static rasterization for slider mode
@@ -779,19 +794,19 @@ def plot_2d(
                     aggregator=ds.count(),
                     width=raster_max_px,
                     height=raster_max_px,
-                    dynamic=False  # Static raster for slider mode
+                    dynamic=False,  # Static raster for slider mode
                 ).opts(
-                    cnorm='eq_hist',
-                    tools=['hover'],
+                    cnorm="eq_hist",
+                    tools=["hover"],
                     width=width,
-                    height=height
+                    height=height,
                 )
             else:
                 return overlay
-        
+
         # Create layout
-        layout = pn.Column(slider_widget, reactive_plot, sizing_mode='stretch_width')
-        
+        layout = on.Column(slider_widget, reactive_plot, sizing_mode="stretch_width")
+
         return layout
     else:
         # Create a panel layout without slider
@@ -1081,18 +1096,20 @@ def plot_2d_oracle(
     feat_df = feats.copy()
     feat_df = feat_df[feat_df["id_level"] == 2]
 
-    oracle_hover_1 = HoverTool(tooltips=[
-        ("rt", "@rt"),
-        ("m/z", "@mz{0.0000}"),
-        ("feature_uid", "@feature_uid"),
-        ("id_level", "@id_level"),
-        ("id_class", "@id_class"),
-        ("id_label", "@id_label"),
-        ("id_ion", "@id_ion"),
-        ("id_evidence", "@id_evidence"),
-        ("score", "@score"),
-        ("score2", "@score2"),
-    ])
+    oracle_hover_1 = HoverTool(
+        tooltips=[
+            ("rt", "@rt"),
+            ("m/z", "@mz{0.0000}"),
+            ("feature_uid", "@feature_uid"),
+            ("id_level", "@id_level"),
+            ("id_class", "@id_class"),
+            ("id_label", "@id_label"),
+            ("id_ion", "@id_ion"),
+            ("id_evidence", "@id_evidence"),
+            ("score", "@score"),
+            ("score2", "@score2"),
+        ],
+    )
     feature_points_1 = hv.Points(
         feat_df,
         kdims=["rt", "mz"],
@@ -1122,15 +1139,17 @@ def plot_2d_oracle(
     feat_df = feats.copy()
     feat_df = feat_df[(feat_df["ms2_scans"].notnull()) & (feat_df["id_level"] == 1)]
     if len(feat_df) > 0:
-        oracle_hover_2 = HoverTool(tooltips=[
-            ("rt", "@rt"),
-            ("m/z", "@mz{0.0000}"),
-            ("feature_uid", "@feature_uid"),
-            ("id_level", "@id_level"),
-            ("id_label", "@id_label"),
-            ("id_ion", "@id_ion"),
-            ("id_class", "@id_class"),
-        ])
+        oracle_hover_2 = HoverTool(
+            tooltips=[
+                ("rt", "@rt"),
+                ("m/z", "@mz{0.0000}"),
+                ("feature_uid", "@feature_uid"),
+                ("id_level", "@id_level"),
+                ("id_label", "@id_label"),
+                ("id_ion", "@id_ion"),
+                ("id_class", "@id_class"),
+            ],
+        )
         feature_points_2 = hv.Points(
             feat_df,
             kdims=["rt", "mz"],
@@ -1157,15 +1176,17 @@ def plot_2d_oracle(
     feat_df = feats.copy()
     feat_df = feat_df[(feat_df["ms2_scans"].isnull()) & (feat_df["id_level"] == 1)]
     if len(feat_df) > 0:
-        oracle_hover_3 = HoverTool(tooltips=[
-            ("rt", "@rt"),
-            ("m/z", "@mz{0.0000}"),
-            ("feature_uid", "@feature_uid"),
-            ("id_level", "@id_level"),
-            ("id_label", "@id_label"),
-            ("id_ion", "@id_ion"),
-            ("id_class", "@id_class"),
-        ])
+        oracle_hover_3 = HoverTool(
+            tooltips=[
+                ("rt", "@rt"),
+                ("m/z", "@mz{0.0000}"),
+                ("feature_uid", "@feature_uid"),
+                ("id_level", "@id_level"),
+                ("id_label", "@id_label"),
+                ("id_ion", "@id_ion"),
+                ("id_class", "@id_class"),
+            ],
+        )
         feature_points_3 = hv.Points(
             feat_df,
             kdims=["rt", "mz"],
@@ -1192,12 +1213,14 @@ def plot_2d_oracle(
     feat_df = feats.copy()
     feat_df = feat_df[(feat_df["ms2_scans"].notnull()) & (feat_df["id_level"] < 1)]
     if len(feat_df) > 0:
-        oracle_hover_4 = HoverTool(tooltips=[
-            ("rt", "@rt"),
-            ("m/z", "@mz{0.0000}"),
-            ("feature_uid", "@feature_uid"),
-            ("inty", "@inty"),
-        ])
+        oracle_hover_4 = HoverTool(
+            tooltips=[
+                ("rt", "@rt"),
+                ("m/z", "@mz{0.0000}"),
+                ("feature_uid", "@feature_uid"),
+                ("inty", "@inty"),
+            ],
+        )
         feature_points_4 = hv.Points(
             feat_df,
             kdims=["rt", "mz"],
@@ -1216,12 +1239,14 @@ def plot_2d_oracle(
     feat_df = feats.copy()
     feat_df = feat_df[(feat_df["ms2_scans"].isnull()) & (feat_df["id_level"] < 1)]
     if len(feat_df) > 0:
-        oracle_hover_5 = HoverTool(tooltips=[
-            ("rt", "@rt"),
-            ("m/z", "@mz{0.0000}"),
-            ("feature_uid", "@feature_uid"),
-            ("inty", "@inty"),
-        ])
+        oracle_hover_5 = HoverTool(
+            tooltips=[
+                ("rt", "@rt"),
+                ("m/z", "@mz{0.0000}"),
+                ("feature_uid", "@feature_uid"),
+                ("inty", "@inty"),
+            ],
+        )
         feature_points_5 = hv.Points(
             feat_df,
             kdims=["rt", "mz"],

masster/sample/processing.py

@@ -519,6 +519,10 @@ def find_features(self, **kwargs):
         low-quality peaks), lower values make it more permissive. Typical tuning range: ~3 (relaxed) to >10
         (stringent). Default: 10.0.
 
+    - isotope_filtering_model (str):
+        Isotope filtering model ('metabolites (2% RMS)', 'metabolites (5% RMS)', 'peptides', 'none').
+        Default: 'metabolites (5% RMS)'.
+
     Tuning recommendation: first set ``chrom_fwhm`` to match your LC peak shape, then set ``noise`` to a baseline
     intensity filter for your data, and finally adjust ``chrom_peak_snr`` to reach the desired balance between
     sensitivity and specificity.
@@ -556,24 +560,25 @@ def find_features(self, **kwargs):
                 self.logger.warning(f"Unknown parameter {key} ignored")
 
     # Set global parameters
-    if hasattr(params, 'threads') and params.threads is not None:
+    if hasattr(params, "threads") and params.threads is not None:
         try:
             # Try setting via OpenMP environment variable first (newer approach)
             import os
-            os.environ['OMP_NUM_THREADS'] = str(params.threads)
+
+            os.environ["OMP_NUM_THREADS"] = str(params.threads)
             self.logger.debug(f"Set thread count to {params.threads} via OMP_NUM_THREADS")
         except Exception:
             self.logger.warning(f"Could not set thread count to {params.threads} - using default")
-    
+
     # Set debug mode if enabled
-    if hasattr(params, 'debug') and params.debug:
+    if hasattr(params, "debug") and params.debug:
         self.logger.debug("Debug mode enabled")
-    elif hasattr(params, 'no_progress') and params.no_progress:
+    elif hasattr(params, "no_progress") and params.no_progress:
         self.logger.debug("No progress mode enabled")
-    
+
     self.logger.info("Starting feature detection...")
     self.logger.debug(
-        f"Parameters: chrom_fwhm={params.get('chrom_fwhm')}, noise={params.get('noise')}, tol_ppm={params.get('tol_ppm')}",
+        f"Parameters: chrom_fwhm={params.get('chrom_fwhm')}, noise={params.get('noise')}, tol_ppm={params.get('tol_ppm')}, isotope_filtering_model={params.get('isotope_filtering_model')}",
     )
 
     exp = oms.MSExperiment()
@@ -602,7 +607,8 @@ def find_features(self, **kwargs):
     # Apply MTD parameters
     mtd_par.setValue("mass_error_ppm", float(params.get("tol_ppm")))
     mtd_par.setValue("noise_threshold_int", float(params.get("noise")))
-    mtd_par.setValue("min_trace_length",
+    mtd_par.setValue(
+        "min_trace_length",
         float(params.get("min_trace_length_multiplier")) * float(params.get("chrom_fwhm_min")),
     )
     mtd_par.setValue(
@@ -610,7 +616,7 @@ def find_features(self, **kwargs):
         int(params.get("trace_termination_outliers")),
     )
     mtd_par.setValue("chrom_peak_snr", float(params.get("chrom_peak_snr")))
-    
+
     # Additional MTD parameters
     mtd_par.setValue("min_sample_rate", float(params.get("min_sample_rate")))
     mtd_par.setValue("min_trace_length", float(params.get("min_trace_length")))
@@ -636,10 +642,10 @@ def find_features(self, **kwargs):
         epd_par.setValue("masstrace_snr_filtering", "true")
     if params.get("mz_scoring_13C"):
         epd_par.setValue("mz_scoring_13C", "true")
-    
+
     # Additional EPD parameters
     epd_par.setValue("enabled", "true" if params.get("enabled") else "false")
-    
+
     epd.setParameters(epd_par)
     epd.detectPeaks(mass_traces, mass_traces_deconvol)
 
@@ -675,7 +681,7 @@ def find_features(self, **kwargs):
     ffm_par.setValue("local_mz_range", float(params.get("local_mz_range")))
     ffm_par.setValue("charge_lower_bound", int(params.get("charge_lower_bound")))
     ffm_par.setValue("charge_upper_bound", int(params.get("charge_upper_bound")))
-    
+    ffm_par.setValue("isotope_filtering_model", params.get("isotope_filtering_model"))
 
     ffm.setParameters(ffm_par)