Merge pull request #100 from MannLabs/change_minrep_semantics

Fix filtering options in GUI

Author: ammarcsj

alphaquant/diffquant/condpair_analysis.py

@@ -37,7 +37,7 @@ def analyze_condpair(*,runconfig, condpair):
     c1_samples, c2_samples = aqutils.get_samples_used_from_samplemap_df(runconfig.samplemap_df, condpair[0], condpair[1])
 
     try:
-        df_c1, df_c2 = get_per_condition_dataframes(c1_samples, c2_samples, input_df_local,runconfig.minrep_both, runconfig.minrep_either, runconfig.minrep_c1, runconfig.minrep_c2)
+        df_c1, df_c2 = get_per_condition_dataframes(c1_samples, c2_samples, input_df_local, min_valid_values=runconfig.min_valid_values, valid_values_filter_mode=runconfig.valid_values_filter_mode, min_valid_values_c1=runconfig.min_valid_values_c1, min_valid_values_c2=runconfig.min_valid_values_c2)
     except Exception as e:
         LOGGER.info(e)
         return
@@ -153,53 +153,49 @@ def write_out_normed_df(normed_df_1, normed_df_2, pep2prot, results_dir, condpai
     merged_df.to_csv(f"{results_dir}/{aqutils.get_condpairname(condpair)}.normed.tsv", sep = "\t")
 
 
-def get_per_condition_dataframes(samples_c1, samples_c2, unnormed_df, minrep_both =None,  minrep_either = None, minrep_c1 = None, minrep_c2 = None):
+def get_per_condition_dataframes(samples_c1, samples_c2, unnormed_df, min_valid_values, valid_values_filter_mode, min_valid_values_c1, min_valid_values_c2):
 
     min_samples = min(len(samples_c1), len(samples_c2))
 
     if min_samples<2:
         raise Exception(f"condpair has not enough samples: c1:{len(samples_c1)} c2: {len(samples_c2)}, skipping")
 
-    if (minrep_either is not None) or ((minrep_c1 is not None) and (minrep_c2 is not None)): #minrep_both was set as default and should be overruled by minrep_either or minrep_c1 and minrep_c2
-        minrep_both = None
-
-    if minrep_either is not None:
-        minrep_either = np.min([get_minrep_for_cond(samples_c1, minrep_either), get_minrep_for_cond(samples_c2, minrep_either)])
-        passes_minrep_c1 = unnormed_df.loc[:, samples_c1].notna().sum(axis=1) >= minrep_either
-        passes_minrep_c2 = unnormed_df.loc[:, samples_c2].notna().sum(axis=1) >= minrep_either
-        passes_minrep_either = passes_minrep_c1 | passes_minrep_c2
-        unnormed_df = unnormed_df[passes_minrep_either]
+    if valid_values_filter_mode == "either":
+        min_valid_values = np.min([get_min_valid_values_for_cond(samples_c1, min_valid_values), get_min_valid_values_for_cond(samples_c2, min_valid_values)])
+        passes_min_valid_values_c1 = unnormed_df.loc[:, samples_c1].notna().sum(axis=1) >= min_valid_values
+        passes_min_valid_values_c2 = unnormed_df.loc[:, samples_c2].notna().sum(axis=1) >= min_valid_values
+        passes_min_valid_values = passes_min_valid_values_c1 | passes_min_valid_values_c2
+        unnormed_df = unnormed_df[passes_min_valid_values]
         df_c1 = unnormed_df.loc[:, samples_c1]
         df_c2 = unnormed_df.loc[:, samples_c2]
 
+    elif valid_values_filter_mode == "both":
+        min_valid_values_c1 = get_min_valid_values_for_cond(samples_c1, min_valid_values)
+        min_valid_values_c2 = get_min_valid_values_for_cond(samples_c2, min_valid_values)
+        df_c1 = unnormed_df.loc[:, samples_c1].dropna(thresh=min_valid_values_c1, axis=0)
+        df_c2 = unnormed_df.loc[:, samples_c2].dropna(thresh=min_valid_values_c2, axis=0)
+
+    elif valid_values_filter_mode == "per_condition":
+        min_valid_values_c1 = get_min_valid_values_for_cond(samples_c1, min_valid_values_c1)
+        min_valid_values_c2 = get_min_valid_values_for_cond(samples_c2, min_valid_values_c2)
+        df_c1 = unnormed_df.loc[:, samples_c1].dropna(thresh=min_valid_values_c1, axis=0)
+        df_c2 = unnormed_df.loc[:, samples_c2].dropna(thresh=min_valid_values_c2, axis=0)
+    else:
+        raise Exception(f"invalid value set for the variable valid_values_filter_mode: {valid_values_filter_mode}, please ensure that is set to: 'either', 'both' or 'per_condition'")
 
-    elif minrep_both is not None:
-        minrep_c1 = minrep_both
-        minrep_c2 = minrep_both
-
-    if (minrep_c1 is not None) and (minrep_c2 is not None):
-        minrep_c1 = get_minrep_for_cond(samples_c1, minrep_c1)
-        minrep_c2 = get_minrep_for_cond(samples_c2, minrep_c2)
-        df_c1 = unnormed_df.loc[:, samples_c1].dropna(thresh=minrep_c1, axis=0)
-        df_c2 = unnormed_df.loc[:, samples_c2].dropna(thresh=minrep_c2, axis=0)
-        if (len(df_c1.index)<5) | (len(df_c2.index)<5):
-            raise Exception(f"condpair has not enough data for processing c1: {len(df_c1.index)} c2: {len(df_c2.index)}, skipping")
-
-    if (minrep_both is None) and (minrep_either is None) and (minrep_c1 is None) and (minrep_c2 is None):
-        raise Exception("no minrep set, please specify!")
-
-
+    if (len(df_c1.index)<5) | (len(df_c2.index)<5):
+        raise Exception(f"condpair has not enough data for processing c1: {len(df_c1.index)} c2: {len(df_c2.index)}, skipping")
 
     return df_c1, df_c2
 
-def get_minrep_for_cond(c_samples, minrep):
-    if minrep is None: #in the case of None, no nans will be allowed
+def get_min_valid_values_for_cond(c_samples, min_valid_values):
+    if min_valid_values is None: #in the case of None, no nans will be allowed
         return None
     num_samples = len(c_samples)
-    if num_samples<minrep:
+    if num_samples<min_valid_values:
         return num_samples
     else:
-        return minrep
+        return min_valid_values
 
 
 

alphaquant/diffquant/diffutils.py

@@ -69,13 +69,13 @@ def get_samplenames_from_input_df(data):
 
 # Cell
 import numpy as np
-def filter_df_to_minrep(quant_df_wideformat, samples_c1, samples_c2, minrep):
+def filter_df_to_min_valid_values(quant_df_wideformat, samples_c1, samples_c2, min_valid_values):
     """filters dataframe in alphaquant format such that each column has a minimum number of replicates
     """
     quant_df_wideformat = quant_df_wideformat.replace(0, np.nan)
-    df_c1_minrep = quant_df_wideformat[samples_c1].dropna(thresh = minrep, axis = 0)
-    df_c2_minrep = quant_df_wideformat[samples_c2].dropna(thresh = minrep, axis = 0)
-    idxs_both = df_c1_minrep.index.intersection(df_c2_minrep.index)
+    df_c1_min_valid_values = quant_df_wideformat[samples_c1].dropna(thresh = min_valid_values, axis = 0)
+    df_c2_min_valid_values = quant_df_wideformat[samples_c2].dropna(thresh = min_valid_values, axis = 0)
+    idxs_both = df_c1_min_valid_values.index.intersection(df_c2_min_valid_values.index)
     quant_df_reduced = quant_df_wideformat.iloc[idxs_both].reset_index()
     return quant_df_reduced
 

alphaquant/ptm/ptmsite_mapping.py

@@ -673,7 +673,7 @@ def initialize_ptmsite_df(ptmsite_file, samplemap_file):
     ptmsite_df = pd.read_csv(ptmsite_file, sep = "\t")
     return ptmsite_df, samplemap_df
 
-def detect_site_occupancy_change(cond1, cond2, ptmsite_df ,samplemap_df, minrep = 2, threshold_prob = 0.05):
+def detect_site_occupancy_change(cond1, cond2, ptmsite_df ,samplemap_df, min_valid_values = 2, threshold_prob = 0.05):
     """
     uses a PTMsite df with headers "REFPROT", "gene","site", and headers for sample1, sample2, etc and determines
     whether a site appears/dissappears between conditions based on some probability threshold
@@ -708,7 +708,7 @@ def detect_site_occupancy_change(cond1, cond2, ptmsite_df ,samplemap_df, minrep
         numrep_c1 = len(cond1_vals)
         numrep_c2 = len(cond2_vals)
 
-        if(numrep_c1<minrep) | (numrep_c2 < minrep):
+        if(numrep_c1<min_valid_values) | (numrep_c2 < min_valid_values):
             continue
 
         cond1_prob = np.mean(cond1_vals)
@@ -741,7 +741,7 @@ def detect_site_occupancy_change(cond1, cond2, ptmsite_df ,samplemap_df, minrep
 import numpy as np
 import re
 
-def check_site_occupancy_changes_all_diffresults(results_folder = os.path.join(".","results"), siteprobs_filename = "siteprobs.tsv",samplemap_file = "samples.map",condpairs_to_compare = [], threshold_prob = 0.05, minrep = 2):
+def check_site_occupancy_changes_all_diffresults(results_folder = os.path.join(".","results"), siteprobs_filename = "siteprobs.tsv",samplemap_file = "samples.map",condpairs_to_compare = [], threshold_prob = 0.05, min_valid_values = 2):
 
     samplemap_df, _ = get_sample2cond_dataframe(samplemap_file)
     ptmsite_map = os.path.join(results_folder, siteprobs_filename)
@@ -765,7 +765,7 @@ def check_site_occupancy_changes_all_diffresults(results_folder = os.path.join("
         ptmsite_df_cpair = ptmsite_df_cpair.sort_index()
 
         condpairname = utils.get_condpairname(condpair)
-        df_occupancy = detect_site_occupancy_change(cond1, cond2, ptmsite_df_cpair, samplemap_df, minrep = minrep, threshold_prob = threshold_prob)
+        df_occupancy = detect_site_occupancy_change(cond1, cond2, ptmsite_df_cpair, samplemap_df, min_valid_values = min_valid_values, threshold_prob = threshold_prob)
         df_occupancy.to_csv(os.path.join(results_folder, f"{condpairname}.ptm_occupancy_changes.tsv"), sep = "\t", index = None)
 
 

alphaquant/run_pipeline.py

@@ -45,10 +45,10 @@ def run_pipeline(input_file: str,
                 multicond_median_analysis: bool = False,
                 condpairs_list: Optional[List[Tuple[str, str]]] = None,
                 file_has_alphaquant_format: bool = False,
-                minrep_both: int = 2,
-                minrep_either: Optional[int] = None,
-                minrep_c1: Optional[int] = None,
-                minrep_c2: Optional[int] = None,
+                min_valid_values: int = 2,
+                valid_values_filter_mode: str = "either", #options: "either", "and", "per_condition"
+                min_valid_values_c1: int = 0,
+                min_valid_values_c2: int = 0,
                 min_num_ions: int = 1,
                 minpep: int = 1,
                 organism: Optional[str] = None,
@@ -71,7 +71,12 @@ def run_pipeline(input_file: str,
                 protein_subset_for_normalization_file: Optional[str] = None,
                 protnorm_peptides: bool = True,
                 peptides_to_exclude_file: Optional[str] = None,
-                reset_progress_folder: bool = False) -> None:
+                reset_progress_folder: bool = False,
+                minrep_both: Optional[int] = None, #deprecated
+                minrep_either: Optional[int] = None, #deprecated
+                minrep_c1: Optional[int] = None, #deprecated
+                minrep_c2: Optional[int] = None, #deprecated
+                ) -> None:
     """Run differential analyses following the AlphaQuant pipeline. This function processes proteomics data through multiple steps including
         preprocessing, if applicable PTM site mapping, if applicable median condition creation, normalization, statistical testing, visualizations
         and writing of results tables.
@@ -86,10 +91,13 @@ def run_pipeline(input_file: str,
     multicond_median_analysis (bool): Whether to compare all conditions to a median condition. Defaults to False.
     condpairs_list (list): Specific condition pairs to compare. If None, performs all pairwise comparisons.
     file_has_alphaquant_format (bool): Whether the input file is already in AlphaQuant matrix format. Defaults to False.
-    minrep_both (int): Minimum replicate count required in both conditions. Defaults to 2.
-    minrep_either (int): Minimum replicate count required in either condition.
-    minrep_c1 (int): Minimum replicate count required in condition 1.
-    minrep_c2 (int): Minimum replicate count required in condition 2.
+    min_valid_values (int): Minimum number of valid values required across conditions. Defaults to 2.
+    valid_values_filter_mode (str): Strategy for filtering based on valid values. Options:
+        - "either": Include features that have at least 'min_valid_values' valid values in at least one condition.
+        - "both": Include only features that have at least 'min_valid_values' valid values in all conditions.
+        - "per_condition": Include only features that have at least 'min_valid_values_c1' valid values in condition 1 and 'min_valid_values_c2' valid values in condition 2.
+    min_valid_values_c1 (int): Minimum number of valid values required specifically in condition 1.
+    min_valid_values_c2 (int): Minimum number of valid values required specifically in condition 2.
     min_num_ions (int): Minimum number of ions required per peptide. Defaults to 1.
     minpep (int): Minimum number of peptides required per protein. Defaults to 1.
     organism (str): Organism name for PTM mapping (e.g., 'human', 'mouse'). Required if perform_ptm_mapping is True.
@@ -115,6 +123,27 @@ def run_pipeline(input_file: str,
     reset_progress_folder (bool): Clear and recreate the progress folder. Defaults to False.
     """
     LOGGER.info("Starting AlphaQuant")
+
+    #########################################################
+    # TODO: this backwards compatibility can be removed beginning of 2026
+    # to ensure backwards compatibility: in case the minrep paramters are set, we need to convert them to the min_valid_values and valid_values_filter_mode parameters
+    if minrep_both is not None:
+        min_valid_values = minrep_both
+        valid_values_filter_mode = "both"
+        LOGGER.warning("you set the parameter 'minrep_both', which is deprecated. Please use 'min_valid_values' and 'valid_values_filter_mode' instead.")
+    if minrep_either is not None:
+        min_valid_values = minrep_either
+        valid_values_filter_mode = "either"
+        LOGGER.warning("you set the parameter 'minrep_either', which is deprecated. Please use 'min_valid_values' and 'valid_values_filter_mode' instead.")
+    if minrep_c1 is not None and minrep_c2 is not None:
+        min_valid_values_c1 = minrep_c1
+        min_valid_values_c2 = minrep_c2
+        valid_values_filter_mode = "per_condition"
+        LOGGER.warning("you set the parameter 'minrep_c1' and 'minrep_c2', which is deprecated. Please use 'min_valid_values_c1' and 'min_valid_values_c2' instead.")
+    #########################################################
+
+
+
     input_file_original = input_file
     check_input_consistency(input_file_original, samplemap_file, samplemap_df)
     create_progress_folder_if_applicable(input_file_original, reset_progress_folder)

alphaquant/ui/dashboad_parts_plots_basic.py

@@ -176,7 +176,12 @@ def _extract_condpairs(self):
             self.condpairname_select.options = ["No conditions"]
             return
 
-        pattern = os.path.join(self.results_dir, "*_VS_*.results.tsv")
+        # Ensure directory path ends with separator for Windows compatibility
+        dir_path = self.results_dir
+        if not dir_path.endswith(os.sep):
+            dir_path += os.sep
+
+        pattern = os.path.join(dir_path, "*_VS_*.results.tsv")
         files = glob.glob(pattern)
 
         for f in files:

alphaquant/ui/dashboard_parts_run_pipeline.py

@@ -269,7 +269,8 @@ def _make_widgets(self):
 			name='Modification type:',
 			placeholder='e.g., [Phospho (STY)] for Spectronaut',
 			width=300,
-			description=gui_textfields.Descriptions.tooltips['ptm_settings']
+			description=gui_textfields.Descriptions.tooltips['ptm_settings'],
+			visible=False  # Hidden by default
 		)
 		self.input_type = pn.widgets.TextInput(
 			name='Input type:',
@@ -281,10 +282,11 @@ def _make_widgets(self):
 			options=['human', 'mouse'],
 			value='human',
 			width=300,
-			description='Select the organism your samples come from'
+			description='Select the organism your samples come from',
+			visible=False  # Hidden by default
 		)
-		self.filtering_options = pn.widgets.Select(
-			name='Filtering Options:',
+		self.valid_values_filter_mode = pn.widgets.Select(
+			name='Filtering options for min. valid values:',
 			options=[
 				'min. valid values in condition1 OR condition2',
 				'min. valid values in condition1 AND condition2',
@@ -295,33 +297,34 @@ def _make_widgets(self):
 			description=gui_textfields.Descriptions.tooltips['filtering_options']
 		)
 
-		self.minrep_either = pn.widgets.IntInput(
-			name='Min replicates (either condition):',
+		self.min_valid_values_OR = pn.widgets.IntInput(
+			name='Min valid values (either condition):',
 			value=2,
 			start=0,
 			width=300,
 			description='Minimum number of valid values required in at least one of the conditions'
 		)
 
-		self.minrep_both = pn.widgets.IntInput(
-			name='Min replicates (both conditions):',
+		self.min_valid_values_AND = pn.widgets.IntInput(
+			name='Min valid values (both conditions):',
 			value=2,
 			start=1,
 			width=300,
-			description='Minimum number of valid values required in both conditions'
+			description='Minimum number of valid values required in both conditions',
+			visible=False
 		)
 
-		self.minrep_c1 = pn.widgets.IntInput(
-			name='Min replicates (condition 1):',
+		self.min_valid_values_c1 = pn.widgets.IntInput(
+			name='Min valid values (condition 1):',
 			value=2,
 			start=0,
 			width=300,
 			description='Minimum number of valid values required in condition 1',
 			visible=False
 		)
 
-		self.minrep_c2 = pn.widgets.IntInput(
-			name='Min replicates (condition 2):',
+		self.min_valid_values_c2 = pn.widgets.IntInput(
+			name='Min valid values (condition 2):',
 			value=2,
 			start=0,
 			width=300,
@@ -395,45 +398,50 @@ def _make_widgets(self):
 		)
 
 		self.switches = {
-			'use_ml': pn.widgets.Switch(
+			'use_ml': pn.widgets.Checkbox(
 				name='Enable machine learning',
-				value=True
+				value=True,
+				width=300
 			),
-			'take_median_ion': pn.widgets.Switch(
+			'take_median_ion': pn.widgets.Checkbox(
 				name='Use median-centered ions',
-				value=True
+				value=True,
+				width=300
 			),
-			'perform_ptm_mapping': pn.widgets.Switch(
-				name='Enable PTM mapping',
-				value=False
+			'perform_ptm_mapping': pn.widgets.Checkbox(
+				name='Perform PTM site mapping',
+				value=False,
+				width=300
 			),
-			'perform_phospho_inference': pn.widgets.Switch(
+			'perform_phospho_inference': pn.widgets.Checkbox(
 				name='Enable phospho inference',
-				value=False
+				value=False,
+				width=300
 			),
-			'outlier_correction': pn.widgets.Switch(
+			'outlier_correction': pn.widgets.Checkbox(
 				name='Enable outlier correction',
-				value=True
+				value=True,
+				width=300
 			),
-			'normalize': pn.widgets.Switch(
+			'normalize': pn.widgets.Checkbox(
 				name='Enable normalization',
-				value=True
-			),
-			'use_iontree_if_possible': pn.widgets.Switch(
-				name='Use ion tree when possible',
-				value=True
+				value=True,
+				width=300
 			),
-			'write_out_results_tree': pn.widgets.Switch(
+			'write_out_results_tree': pn.widgets.Checkbox(
 				name='Write results tree',
-				value=True
+				value=True,
+				width=300
 			),
-			'use_multiprocessing': pn.widgets.Switch(
+			'use_multiprocessing': pn.widgets.Checkbox(
 				name='Enable multiprocessing',
-				value=False
+				value=False,
+				width=300
 			),
-			'runtime_plots': pn.widgets.Switch(
+			'runtime_plots': pn.widgets.Checkbox(
 				name='Generate runtime plots',
-				value=True
+				value=True,
+				width=300
 			),
 		}
 
@@ -444,7 +452,6 @@ def _make_widgets(self):
 			'perform_phospho_inference': pn.pane.Markdown('Infer phosphorylation sites from the data'),
 			'outlier_correction': pn.pane.Markdown('Automatically detect and correct outliers in the data'),
 			'normalize': pn.pane.Markdown('Normalize data to account for technical variations'),
-			'use_iontree_if_possible': pn.pane.Markdown('Use hierarchical ion structure when available'),
 			'write_out_results_tree': pn.pane.Markdown('Save detailed results in a tree structure'),
 			'use_multiprocessing': pn.pane.Markdown('Use multiple CPU cores to speed up processing (may use more memory)'),
 			'runtime_plots': pn.pane.Markdown('Create plots during analysis to visualize the process'),
@@ -494,10 +501,9 @@ def _make_widgets(self):
 		)
 		self.samplemap_fileupload.param.watch(self._update_samplemap_table, 'value')
 		self.samplemap_table.param.watch(self._add_conditions_for_assignment, 'value')
-		self.minrep_either.param.watch(self._update_minrep_both, 'value')
 		self.run_pipeline_button.param.watch(self._run_pipeline, 'clicks')
 		self.analysis_type.param.watch(self._update_analysis_type_visibility, 'value')
-		self.filtering_options.param.watch(self._toggle_filtering_options, 'value')
+		self.valid_values_filter_mode.param.watch(self._toggle_filtering_options, 'value')
 		self.path_output_folder.param.watch(self._update_results_dir, 'value')
 		self.path_analysis_file.param.watch(self._update_analysis_file, 'value')
 		self.samplemap_fileupload.param.watch(self._update_samplemap, 'value')
@@ -506,20 +512,57 @@ def _make_widgets(self):
 		self.assign_cond_pairs.param.watch(self._update_run_button_state, 'value')
 		self.analysis_type.param.watch(self._update_run_button_state, 'value')
 
+		# Add a watcher for the PTM mapping checkbox to show/hide other fields
+		self.switches['perform_ptm_mapping'].param.watch(self._toggle_ptm_fields, 'value')
 
 	def create(self):
 		"""
 		Build and return the main layout for the pipeline widget.
 		"""
 
-		ptm_section = pn.Row(
-			pn.Column(self.modification_type, self.organism)
+		# Create the PTM section with the checkbox at the top
+		ptm_section = pn.Column(
+			self.switches['perform_ptm_mapping'],
+			pn.pane.Markdown(
+				"<small><i>" + self.switch_descriptions['perform_ptm_mapping'].object + "</i></small>",
+				margin=(0, 0, 10, 20)
+			),
+			self.modification_type,
+			self.organism,
+			margin=(5, 5, 5, 5)
 		)
 
 		filtering_section = pn.Row(
-			pn.Column(self.filtering_options, self.minrep_either)
+			pn.Column(
+				self.valid_values_filter_mode,
+				self.min_valid_values_OR,
+				self.min_valid_values_AND,
+				self.min_valid_values_c1,
+				self.min_valid_values_c2
+			)
 		)
 
+		# Create a function to build the checkbox items
+		def create_checkbox_with_description(key, checkbox):
+			# Skip the PTM mapping checkbox since it's now in the PTM settings card
+			if key == 'perform_ptm_mapping':
+				return None
+
+			return pn.Column(
+				checkbox,
+				pn.pane.Markdown(
+					"<small><i>" + self.switch_descriptions[key].object + "</i></small>",
+					margin=(0, 0, 10, 20)
+				),
+				margin=(0, 0, 15, 0),
+				width=350
+			)
+
+		# Create the checkbox items, filtering out None values
+		checkbox_items = [create_checkbox_with_description(key, switch)
+						  for key, switch in self.switches.items()]
+		checkbox_items = [item for item in checkbox_items if item is not None]
+
 		advanced_settings_card = pn.Card(
 			pn.Column(
 				"### Threshold Settings",
@@ -528,13 +571,7 @@ def create(self):
 				self.cluster_threshold_pval,
 				pn.layout.Divider(),
 				"### Analysis Options",
-				pn.Column(*[
-					pn.Row(
-						switch,
-						self.switch_descriptions[key],
-						align='center'
-					) for key, switch in self.switches.items()
-				]),
+				*checkbox_items,
 			),
 			title='Advanced Configuration',
 			collapsed=True,
@@ -543,6 +580,16 @@ def create(self):
 			width=400
 		)
 
+		# Create PTM settings card with fixed width
+		ptm_settings_card = pn.Card(
+			ptm_section,
+			title='PTM Settings',
+			collapsed=True,
+			margin=(5, 5, 5, 5),
+			sizing_mode='fixed',
+			width=400
+		)
+
 		# Create samples and conditions layout
 		samples_conditions_layout = pn.Column(
 			self.sample_mapping_mode_container,
@@ -562,16 +609,6 @@ def create(self):
 			self.medianref_message,
 		)
 
-		# Create PTM settings card with fixed width
-		ptm_settings_card = pn.Card(
-			ptm_section,
-			title='PTM Settings',
-			collapsed=True,
-			margin=(5, 5, 5, 5),
-			sizing_mode='fixed',
-			width=400
-		)
-
 		main_col = pn.Column(
 			"### Input Files",
 			self.path_analysis_file,
@@ -729,8 +766,7 @@ def _run_pipeline(self, *events):
 					for pair in self.assign_cond_pairs.value
 				]
 
-			# Log samplemap status right before passing to pipeline
-			print(f"Samplemap right before pipeline run: {'Present with ' + str(len(self.samplemap_table.value)) + ' rows' if self.samplemap_table.value is not None else 'None'}")
+
 
 			# Collect all configuration parameters
 			pipeline_params = {
@@ -748,6 +784,20 @@ def _run_pipeline(self, *events):
 				'volcano_fdr': self.volcano_fdr.value,
 				'volcano_fcthresh': self.volcano_fcthresh.value,
 				'multicond_median_analysis': is_median_analysis,
+				"valid_values_filter_mode": self._translate_filter_mode_for_backend(),
+				"min_valid_values": self._get_min_valid_values(),
+				"min_valid_values_c1": self.min_valid_values_c1.value if self.valid_values_filter_mode.value == 'set min. valid values per condition' else None,
+				"min_valid_values_c2": self.min_valid_values_c2.value if self.valid_values_filter_mode.value == 'set min. valid values per condition' else None,
+				# Add the switch values to the pipeline parameters
+				'use_ml': self.switches['use_ml'].value,
+				'take_median_ion': self.switches['take_median_ion'].value,
+				'perform_ptm_mapping': self.switches['perform_ptm_mapping'].value,
+				'perform_phospho_inference': self.switches['perform_phospho_inference'].value,
+				'outlier_correction': self.switches['outlier_correction'].value,
+				'normalize': self.switches['normalize'].value,
+				'write_out_results_tree': self.switches['write_out_results_tree'].value,
+				'use_multiprocessing': self.switches['use_multiprocessing'].value,
+				'runtime_plots': self.switches['runtime_plots'].value,
 			}
 
 			# Log key parameters
@@ -1108,9 +1158,6 @@ def _check_condition_progress(self):
 			import traceback
 			traceback.print_exc()
 
-	def _update_minrep_both(self, *events):
-		"""Set minrep_both to 0 when minrep_either is changed."""
-		self.minrep_both.value = 0
 
 	def _update_results_dir(self, event):
 		"""Update central state with new results directory."""
@@ -1236,19 +1283,19 @@ def _update_analysis_type_visibility(self, change=None):
 	def _toggle_filtering_options(self, event):
 		"""Toggle visibility of replicate input fields based on filtering option."""
 		# Hide all first
-		self.minrep_either.visible = False
-		self.minrep_both.visible = False
-		self.minrep_c1.visible = False
-		self.minrep_c2.visible = False
+		self.min_valid_values_OR.visible = False
+		self.min_valid_values_AND.visible = False
+		self.min_valid_values_c1.visible = False
+		self.min_valid_values_c2.visible = False
 
 		# Show relevant widgets based on selection
 		if event.new == 'min. valid values in condition1 OR condition2':
-			self.minrep_either.visible = True
+			self.min_valid_values_OR.visible = True
 		elif event.new == 'min. valid values in condition1 AND condition2':
-			self.minrep_both.visible = True
+			self.min_valid_values_AND.visible = True
 		else:  # set min. valid values per condition
-			self.minrep_c1.visible = True
-			self.minrep_c2.visible = True
+			self.min_valid_values_c1.visible = True
+			self.min_valid_values_c2.visible = True
 
 	def _update_console(self):
 		"""Update the console output widget with new log messages."""
@@ -1292,6 +1339,53 @@ def _update_run_button_state(self, event=None):
 			self.run_pipeline_button.disabled = True
 			self.run_pipeline_button.description = 'Please select an analysis type'
 
+	def _get_min_valid_values(self):
+		"""
+		Return the appropriate min_valid_values based on the selected filter mode.
+		"""
+		filter_mode = self.valid_values_filter_mode.value
+
+		print(f"Getting min_valid_values with UI filter_mode: {filter_mode}")
+
+		if filter_mode == 'min. valid values in condition1 OR condition2':
+			min_val = self.min_valid_values_OR.value
+			print(f"Using OR mode with value: {min_val}")
+			return min_val
+		elif filter_mode == 'min. valid values in condition1 AND condition2':
+			min_val = self.min_valid_values_AND.value
+			print(f"Using AND mode with value: {min_val}")
+			return min_val
+		else:  # 'set min. valid values per condition'
+			# When using per-condition values, return None for the general min_valid_values
+			print("Using per-condition mode, returning None")
+			return None
+
+	def _translate_filter_mode_for_backend(self):
+		"""
+		Translate the UI filter mode option to the corresponding backend parameter value.
+		"""
+		ui_mode = self.valid_values_filter_mode.value
+
+		# Map UI options to backend values
+		mode_mapping = {
+			'min. valid values in condition1 OR condition2': 'either',
+			'min. valid values in condition1 AND condition2': 'both',
+			'set min. valid values per condition': 'per_condition'
+		}
+
+		backend_mode = mode_mapping.get(ui_mode, 'either')  # Default to 'either' if not found
+		print(f"Translating UI filter mode '{ui_mode}' to backend mode '{backend_mode}'")
+		return backend_mode
+
+	def _toggle_ptm_fields(self, event):
+		"""Toggle visibility of PTM-related fields based on the PTM mapping checkbox."""
+		if event.new:
+			self.modification_type.visible = True
+			self.organism.visible = True
+		else:
+			self.modification_type.visible = False
+			self.organism.visible = False
+
 class Tabs(param.Parameterized):
 	"""
 	This class creates a single pn.Tabs layout containing:

alphaquant/ui/gui_textfields.py

@@ -210,7 +210,7 @@ class Descriptions():
 
         'ptm_settings': """For Spectronaut PTM analysis:
 1. Modification Type: Specify exactly as it appears in Spectronaut modified sequence
-   Example: '[Phospho(STY)]' for phosphorylation
+   Example: '[Phospho (STY)]' for phosphorylation
 2. Organism: Select proteome for site mapping (human/mouse available at the moment)
 
 Note: Requires Spectronaut table with correct PTM columns (see table instructions)."""

example_nbs/differential_expression.ipynb

@@ -55,7 +55,7 @@
    "source": [
     "Now we can use the 'run_pipeline' command from AlphaQuant. This performs normalization between sample and then differential expression testing. The main output is a table of proteins with fold changes and an fdr value as a result of the differential expression test. Due to AlphaQuant's tree based approach, sensitivity is in general higher as compared to standard approaches like the t-test, i.e. there should be more proteins with significant fdr, especially for lower fold changes.\n",
     "\n",
-    "Important: We analyze only proteins with highly complete data across both conditions by setting minrep_both = 7, requiring seven valid values out of 10 possible replicates in each condition. To include proteins that may be absent in one condition, use minrep_either = 7 instead, which requires seven valid values in at least one condition while allowing any number of values in the other."
+    "Important: We analyze only proteins with highly complete data across both conditions by setting min_valid_values = 7, requiring seven valid values out of 10 possible replicates in each condition. To include proteins that may be absent in one condition. Additionally, we set valid_values_filter_mode = \"both\", which means that seven valid values need to be in both conditions for a protein to be included. If you want to include proteins completely missing in one condition, set set valid_values_filter_mode = \"either\", which requires seven valid values in at least one condition while allowing any number of values in the other."
    ]
   },
   {
@@ -67,7 +67,7 @@
     "import alphaquant.run_pipeline as aq_pipeline\n",
     "\n",
     "aq_pipeline.run_pipeline(input_file=INPUT_FILE, samplemap_file=SAMPLEMAP_FILE,\n",
-    "                         condpairs_list=CONDPAIRS_TO_COMPARE, results_dir=RESULTS_DIRECTORY, minrep_both=7)"
+    "                         condpairs_list=CONDPAIRS_TO_COMPARE, results_dir=RESULTS_DIRECTORY, min_valid_values=7, valid_values_filter_mode=\"both\")"
    ]
   },
   {

tests/e2e_tests_large/spectronaut_mixed_species.ipynb

@@ -35,9 +35,9 @@
    "source": [
     "import alphaquant.run_pipeline as run_pipeline\n",
     "\n",
-    "run_pipeline.run_pipeline(input_file=INPUT_FILE, samplemap_file=SAMPLEMAP_FILE, results_dir=RESULTS_DIR, runtime_plots=True, protein_subset_for_normalization_file=PROTEIN_SUBSET_FOR_NORMALIZATION, \n",
+    "run_pipeline.run_pipeline(input_file=INPUT_FILE, samplemap_file=SAMPLEMAP_FILE, results_dir=RESULTS_DIR, runtime_plots=True, protein_subset_for_normalization_file=PROTEIN_SUBSET_FOR_NORMALIZATION,\n",
     "                        annotation_columns=[\"PG.Organisms\"], condpairs_list=[CONDPAIR], peptides_to_exclude_file=SHARED_PEPTIDES_BETWEEN_SPECIES_FILE, input_type_to_use=\"spectronaut_fragion_isotopes_protein\",\n",
-    "                        minrep_either=2)"
+    "                        min_valid_values=2)"
    ]
   },
   {

tests/e2e_tests_small/mixed_species.ipynb

@@ -46,7 +46,7 @@
    "source": [
     "import alphaquant.run_pipeline as run_pipeline\n",
     "\n",
-    "run_pipeline.run_pipeline(input_file=INPUT_FILE, samplemap_file=SAMPLEMAP, results_dir=RESULTS_DIR, runtime_plots=True, minrep_either= 2, take_median_ion= True,\n",
+    "run_pipeline.run_pipeline(input_file=INPUT_FILE, samplemap_file=SAMPLEMAP, results_dir=RESULTS_DIR, runtime_plots=True, min_valid_values= 2, take_median_ion= True,\n",
     "                           annotation_columns=[\"PG.Genes\", \"PG.Organisms\"], input_type_to_use= \"spectronaut_fragion_ms1_protein\", peptides_to_exclude_file=SHARED_PEPTIDES_BETWEEN_SPECIES_FILE)"
    ]
   },

tests/e2e_tests_small/multi_condition.ipynb

@@ -57,7 +57,7 @@
    "source": [
     "import alphaquant.run_pipeline as run_pipeline\n",
     "\n",
-    "run_pipeline.run_pipeline(input_file=INPUT_FILE, samplemap_file=SAMPLEMAP, results_dir=RESULTS_DIR, runtime_plots=True, minrep_either= 2, take_median_ion= True, multicond_median_analysis=True,\n",
+    "run_pipeline.run_pipeline(input_file=INPUT_FILE, samplemap_file=SAMPLEMAP, results_dir=RESULTS_DIR, runtime_plots=True, min_valid_values= 2, take_median_ion= True, multicond_median_analysis=True,\n",
     "                           annotation_columns=[\"PG.Genes\", \"PG.Organisms\"], input_type_to_use= \"spectronaut_fragion_ms1_protein\", peptides_to_exclude_file=SHARED_PEPTIDES_BETWEEN_SPECIES_FILE)"
    ]
   },

tests/e2e_tests_small/phospho.ipynb

@@ -58,7 +58,7 @@
    "source": [
     "import alphaquant.run_pipeline as aq_run_pipeline\n",
     "\n",
-    "aq_run_pipeline.run_pipeline(input_file=INPUT_FILE, samplemap_file=SAMPLEMAP_FILE,  results_dir=RESULTS_DIR, minrep_both=2, modification_type=\"[Phospho (STY)]\",\n",
+    "aq_run_pipeline.run_pipeline(input_file=INPUT_FILE, samplemap_file=SAMPLEMAP_FILE,  results_dir=RESULTS_DIR, min_valid_values=2, modification_type=\"[Phospho (STY)]\",\n",
     "                             perform_ptm_mapping=True,organism=\"human\", runtime_plots=True,peptides_to_exclude_file=PEPTIDES_TO_REMOVE, normalize=True)"
    ]
   },
@@ -91,7 +91,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.11"
+   "version": "3.11.0"
   }
  },
  "nbformat": 4,