masster 0.5.6__py3-none-any.whl → 0.5.8__py3-none-any.whl

masster/_version.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 
-__version__ = "0.5.6"
+__version__ = "0.5.8"
 
 
 def get_version():

masster/sample/plot.py

@@ -86,8 +86,6 @@ def _process_cmap(cmap, fallback="viridis", logger=None):
         cmap = "viridis"
     elif cmap == "grey":
         cmap = "Greys256"
-    elif cmap == "iridescent":
-        cmap = "iridescent_r"
     
     # If cmap package is not available, fall back to process_cmap
     if Colormap is None:
@@ -455,15 +453,15 @@ def plot_2d(
     show_ms2=False,
     show_in_browser=False,
     title=None,
-    cmap=None,
+    cmap='iridescent',
     marker="circle",
-    markersize=10,
+    markersize=5,
     size="static",
     raster_dynamic=True,
     raster_max_px=8,
     raster_threshold=0.8,
     height=600,
-    width=800,
+    width=750,
     mz_range=None,
     rt_range=None
 ):
@@ -529,7 +527,7 @@ def plot_2d(
         return
 
     # Process colormap using the cmap package
-    cmap_palette = _process_cmap(cmap, fallback="iridescent_r", logger=self.logger)
+    cmap_palette = _process_cmap(cmap, fallback="iridescent", logger=self.logger)
 
     # get columns rt, mz, inty from self.ms1_df, It's polars DataFrame
     spectradf = self.ms1_df.select(["rt", "mz", "inty"])

masster/study/defaults/merge_def.py

@@ -25,7 +25,7 @@ class merge_defaults:
         link_ms2 (bool): Whether to link MS2 spectra to consensus features. Default is True.
     """
 
-    method: str = "kd"
+    method: str = "qt"
     min_samples: int = 2
     rt_tol: float = 5.0
     mz_tol: float = 0.05

masster/study/helpers.py

@@ -2956,6 +2956,17 @@ def consensus_select(
     rt_delta_mean=None,
     id_top_score=None,
     identified=None,
+    # New adduct filter parameters
+    adduct_top=None,
+    adduct_charge_top=None,
+    adduct_mass_neutral_top=None,
+    adduct_mass_shift_top=None,
+    adduct_group=None,
+    adduct_of=None,
+    # New identification filter parameters
+    id_top_name=None,
+    id_top_class=None,
+    id_top_adduct=None,
     sortby=None,
     descending=True,
 ):
@@ -2990,6 +3001,17 @@ def consensus_select(
             - True: select only rows with id_top_name not null
             - False: select only rows with id_top_name null
             - None: no filtering (default)
+        # New adduct filter parameters
+        adduct_top: adduct type filter (list or single string value, e.g. "[M+H]+", "[M+Na]+")
+        adduct_charge_top: adduct charge filter (tuple for range, single value for exact match)
+        adduct_mass_neutral_top: neutral mass filter (tuple for range, single value for minimum)
+        adduct_mass_shift_top: adduct mass shift filter (tuple for range, single value for minimum)
+        adduct_group: adduct group ID filter (list, single value, or tuple for range)
+        adduct_of: adduct representative UID filter (list, single value, or tuple for range)
+        # New identification filter parameters
+        id_top_name: identification name filter (list or single string value for compound names)
+        id_top_class: identification class filter (list or single string value for compound classes)
+        id_top_adduct: identification adduct filter (list or single string value for identified adducts)
         sortby: column name(s) to sort by (string, list of strings, or None for no sorting)
         descending: sort direction (True for descending, False for ascending, default is True)
 
@@ -3004,7 +3026,10 @@ def consensus_select(
     filter_params = [mz, rt, inty_mean, consensus_uid, consensus_id, number_samples, 
                     number_ms2, quality, bl, chrom_coherence_mean, chrom_prominence_mean,
                     chrom_prominence_scaled_mean, chrom_height_scaled_mean, 
-                    rt_delta_mean, id_top_score, identified]
+                    rt_delta_mean, id_top_score, identified,
+                    # New adduct and identification parameters
+                    adduct_top, adduct_charge_top, adduct_mass_neutral_top, adduct_mass_shift_top,
+                    adduct_group, adduct_of, id_top_name, id_top_class, id_top_adduct]
     
     if all(param is None for param in filter_params) and sortby is None:
         return self.consensus_df.clone()
@@ -3132,6 +3157,126 @@ def consensus_select(
         else:
             warnings.append("'id_top_name' column not found in consensus_df")
 
+    # Handle adduct_top filter (string or list)
+    if adduct_top is not None:
+        if "adduct_top" in available_columns:
+            if isinstance(adduct_top, list):
+                filter_conditions.append(pl.col("adduct_top").is_in(adduct_top))
+            else:
+                filter_conditions.append(pl.col("adduct_top") == adduct_top)
+        else:
+            warnings.append("'adduct_top' column not found in consensus_df")
+
+    # Handle adduct_charge_top filter (single value, range tuple, or list)
+    if adduct_charge_top is not None:
+        if "adduct_charge_top" in available_columns:
+            if isinstance(adduct_charge_top, tuple) and len(adduct_charge_top) == 2:
+                filter_conditions.append(
+                    (pl.col("adduct_charge_top") >= adduct_charge_top[0]) &
+                    (pl.col("adduct_charge_top") <= adduct_charge_top[1])
+                )
+            elif isinstance(adduct_charge_top, list):
+                filter_conditions.append(pl.col("adduct_charge_top").is_in(adduct_charge_top))
+            else:
+                filter_conditions.append(pl.col("adduct_charge_top") == adduct_charge_top)
+        else:
+            warnings.append("'adduct_charge_top' column not found in consensus_df")
+
+    # Handle adduct_mass_neutral_top filter (single value, range tuple, or list)
+    if adduct_mass_neutral_top is not None:
+        if "adduct_mass_neutral_top" in available_columns:
+            if isinstance(adduct_mass_neutral_top, tuple) and len(adduct_mass_neutral_top) == 2:
+                filter_conditions.append(
+                    (pl.col("adduct_mass_neutral_top") >= adduct_mass_neutral_top[0]) &
+                    (pl.col("adduct_mass_neutral_top") <= adduct_mass_neutral_top[1])
+                )
+            elif isinstance(adduct_mass_neutral_top, list):
+                filter_conditions.append(pl.col("adduct_mass_neutral_top").is_in(adduct_mass_neutral_top))
+            else:
+                filter_conditions.append(pl.col("adduct_mass_neutral_top") == adduct_mass_neutral_top)
+        else:
+            warnings.append("'adduct_mass_neutral_top' column not found in consensus_df")
+
+    # Handle adduct_mass_shift_top filter (single value, range tuple, or list)
+    if adduct_mass_shift_top is not None:
+        if "adduct_mass_shift_top" in available_columns:
+            if isinstance(adduct_mass_shift_top, tuple) and len(adduct_mass_shift_top) == 2:
+                filter_conditions.append(
+                    (pl.col("adduct_mass_shift_top") >= adduct_mass_shift_top[0]) &
+                    (pl.col("adduct_mass_shift_top") <= adduct_mass_shift_top[1])
+                )
+            elif isinstance(adduct_mass_shift_top, list):
+                filter_conditions.append(pl.col("adduct_mass_shift_top").is_in(adduct_mass_shift_top))
+            else:
+                filter_conditions.append(pl.col("adduct_mass_shift_top") == adduct_mass_shift_top)
+        else:
+            warnings.append("'adduct_mass_shift_top' column not found in consensus_df")
+
+    # Handle adduct_group filter (single value or list)
+    if adduct_group is not None:
+        if "adduct_group" in available_columns:
+            if isinstance(adduct_group, list):
+                filter_conditions.append(pl.col("adduct_group").is_in(adduct_group))
+            else:
+                filter_conditions.append(pl.col("adduct_group") == adduct_group)
+        else:
+            warnings.append("'adduct_group' column not found in consensus_df")
+
+    # Handle adduct_of filter (single value or list)
+    if adduct_of is not None:
+        if "adduct_of" in available_columns:
+            if isinstance(adduct_of, list):
+                filter_conditions.append(pl.col("adduct_of").is_in(adduct_of))
+            else:
+                filter_conditions.append(pl.col("adduct_of") == adduct_of)
+        else:
+            warnings.append("'adduct_of' column not found in consensus_df")
+
+    # Handle id_top_name filter (string or list)
+    if id_top_name is not None:
+        if "id_top_name" in available_columns:
+            if isinstance(id_top_name, list):
+                filter_conditions.append(pl.col("id_top_name").is_in(id_top_name))
+            else:
+                filter_conditions.append(pl.col("id_top_name") == id_top_name)
+        else:
+            warnings.append("'id_top_name' column not found in consensus_df")
+
+    # Handle id_top_class filter (string or list)
+    if id_top_class is not None:
+        if "id_top_class" in available_columns:
+            if isinstance(id_top_class, list):
+                filter_conditions.append(pl.col("id_top_class").is_in(id_top_class))
+            else:
+                filter_conditions.append(pl.col("id_top_class") == id_top_class)
+        else:
+            warnings.append("'id_top_class' column not found in consensus_df")
+
+    # Handle id_top_adduct filter (string or list)
+    if id_top_adduct is not None:
+        if "id_top_adduct" in available_columns:
+            if isinstance(id_top_adduct, list):
+                filter_conditions.append(pl.col("id_top_adduct").is_in(id_top_adduct))
+            else:
+                filter_conditions.append(pl.col("id_top_adduct") == id_top_adduct)
+        else:
+            warnings.append("'id_top_adduct' column not found in consensus_df")
+
+    # Handle id_top_score filter (single value, range tuple, or list)
+    if id_top_score is not None:
+        if "id_top_score" in available_columns:
+            if isinstance(id_top_score, tuple) and len(id_top_score) == 2:
+                filter_conditions.append(
+                    (pl.col("id_top_score") >= id_top_score[0]) &
+                    (pl.col("id_top_score") <= id_top_score[1])
+                )
+            elif isinstance(id_top_score, list):
+                filter_conditions.append(pl.col("id_top_score").is_in(id_top_score))
+            else:
+                filter_conditions.append(pl.col("id_top_score") == id_top_score)
+        else:
+            warnings.append("'id_top_score' column not found in consensus_df")
+
     # Log warnings once
     for warning in warnings:
         self.logger.warning(warning)

masster/study/id.py

@@ -1201,7 +1201,7 @@ def lib_reset(study):
         logger.info("Library and identification data reset completed")
 
 
-def _get_adducts(study, adducts_list: list = None, **kwargs):
+def _get_adducts(study, adducts_list: list | None = None, **kwargs):
     """
     Generate comprehensive adduct specifications for study-level adduct filtering.
 

masster/study/merge.py

@@ -441,8 +441,7 @@ def merge(study, **kwargs) -> None:
     cached_adducts_df = None
     cached_valid_adducts = None
     try:
-        from masster.study.id import _get_adducts
-        cached_adducts_df = _get_adducts(study)
+        cached_adducts_df = study._get_adducts()
         if not cached_adducts_df.is_empty():
             cached_valid_adducts = set(cached_adducts_df["name"].to_list())
         else:
@@ -2258,6 +2257,7 @@ def _perform_adduct_grouping(study, rt_tol, mz_tol):
                 {
                     "consensus_uid": row["consensus_uid"],
                     "rt": row["rt"],
+                    "mz": row["mz"],  # Add missing mz field
                     "adduct_mass_neutral_top": row.get("adduct_mass_neutral_top"),
                     "adduct_top": row.get("adduct_top"),
                     "inty_mean": row.get("inty_mean", 0),
@@ -2265,8 +2265,9 @@ def _perform_adduct_grouping(study, rt_tol, mz_tol):
             )
 
         # Use optimized adduct grouping
+        study.logger.info(f"About to call adduct grouping for {len(consensus_data)} consensus features")
         adduct_group_list, adduct_of_list = __merge_adduct_grouping(
-            study, consensus_data, rt_tol, mz_tol
+            study, consensus_data, rt_tol/3, mz_tol
         )
 
         # Add the new columns to consensus_df
@@ -2713,8 +2714,6 @@ def __identify_adduct_by_mass_shift(study, rt_tol, cached_adducts_df=None):
         cached_adducts_df: Pre-computed adducts DataFrame for performance
     """
     import polars as pl
-    import numpy as np
-    from collections import defaultdict
     
     # Check if consensus_df exists and has features
     if len(study.consensus_df) == 0:
@@ -2727,8 +2726,7 @@ def __identify_adduct_by_mass_shift(study, rt_tol, cached_adducts_df=None):
     if cached_adducts_df is None or cached_adducts_df.is_empty():
         try:
             # Use lower min_probability for better adduct coverage in mass shift identification
-            from masster.study.id import _get_adducts
-            cached_adducts_df = _get_adducts(study, min_probability=0.01)
+            cached_adducts_df = study._get_adducts(min_probability=0.01)
         except Exception as e:
             study.logger.warning(f"Could not retrieve adducts for mass shift identification: {e}")
             return
@@ -2822,9 +2820,8 @@ def __identify_adduct_by_mass_shift(study, rt_tol, cached_adducts_df=None):
         mz1 = feature1["mz"]
         adduct1 = feature1["adduct_top"]
         
-        # Skip if already has identified adduct (not [M+?]) - DISABLED to allow re-evaluation
-        # if adduct1 and "?" not in adduct1:
-        #     continue
+        # Conservative approach: Don't skip features here - let algorithm find pairs first
+        # We'll check for inappropriate assignments later in the pair processing logic
             
         # Search for coeluting features within strict RT tolerance
         for j in range(i + 1, n_features):
@@ -2838,9 +2835,7 @@ def __identify_adduct_by_mass_shift(study, rt_tol, cached_adducts_df=None):
             mz2 = feature2["mz"]
             adduct2 = feature2["adduct_top"]
             
-            # Skip if already has identified adduct (not [M+?]) - DISABLED to allow re-evaluation
-            # if adduct2 and "?" not in adduct2:
-            #     continue
+            # Conservative approach: Don't skip feature2 here either - process all potential pairs
             
             # Calculate observed m/z difference
             mz_diff = mz2 - mz1
@@ -2890,24 +2885,45 @@ def __identify_adduct_by_mass_shift(study, rt_tol, cached_adducts_df=None):
                         else:
                             # Assignment based on mass shift direction
                             # catalog_shift = (ms1 - ms2) / abs(charge1) where ms1 = from_adduct mass shift, ms2 = to_adduct mass shift
-                            # If catalog_shift > 0: from_adduct has higher m/z than to_adduct
-                            # If catalog_shift < 0: from_adduct has lower m/z than to_adduct
-                            # observed mz_diff = mz2 - mz1
-                            # If mz_diff matches catalog_shift: feature2 should get to_adduct, feature1 should get from_adduct
-                            # If mz_diff matches -catalog_shift: assignments are swapped
+                            # If catalog_shift > 0: from_adduct has higher mass shift than to_adduct  
+                            # If catalog_shift < 0: from_adduct has lower mass shift than to_adduct
+                            # observed mz_diff = mz2 - mz1 (always positive for mz2 > mz1)
+                            # 
+                            # CRITICAL FIX: Correct assignment logic
+                            # When mz_diff matches positive catalog_shift: 
+                            #   - from_adduct is the heavier adduct (higher mass shift)
+                            #   - to_adduct is the lighter adduct (lower mass shift)  
+                            #   - Higher m/z feature should get the heavier adduct (from_adduct)
+                            #   - Lower m/z feature should get the lighter adduct (to_adduct)
                             
                             if abs(mz_diff - catalog_shift) <= abs(mz_diff - (-catalog_shift)):
                                 # mz_diff matches catalog_shift direction
-                                from_feature = feature1
-                                to_feature = feature2
-                                from_adduct_name = best_rel["from_adduct"]
-                                to_adduct_name = best_rel["to_adduct"]
+                                if catalog_shift > 0:
+                                    # from_adduct is heavier, to_adduct is lighter
+                                    from_feature = feature2  # Higher m/z gets heavier adduct
+                                    to_feature = feature1    # Lower m/z gets lighter adduct
+                                    from_adduct_name = best_rel["from_adduct"]  # Heavier adduct
+                                    to_adduct_name = best_rel["to_adduct"]      # Lighter adduct
+                                else:
+                                    # from_adduct is lighter, to_adduct is heavier
+                                    from_feature = feature1  # Lower m/z gets lighter adduct
+                                    to_feature = feature2    # Higher m/z gets heavier adduct
+                                    from_adduct_name = best_rel["from_adduct"]  # Lighter adduct  
+                                    to_adduct_name = best_rel["to_adduct"]      # Heavier adduct
                             else:
                                 # mz_diff matches reverse direction of catalog_shift
-                                from_feature = feature2
-                                to_feature = feature1
-                                from_adduct_name = best_rel["to_adduct"] 
-                                to_adduct_name = best_rel["from_adduct"]
+                                if catalog_shift > 0:
+                                    # Reverse: from_adduct becomes lighter, to_adduct becomes heavier
+                                    from_feature = feature1  # Lower m/z gets lighter adduct
+                                    to_feature = feature2    # Higher m/z gets heavier adduct
+                                    from_adduct_name = best_rel["to_adduct"]    # Now lighter adduct
+                                    to_adduct_name = best_rel["from_adduct"]    # Now heavier adduct
+                                else:
+                                    # Reverse: from_adduct becomes heavier, to_adduct becomes lighter
+                                    from_feature = feature2  # Higher m/z gets heavier adduct
+                                    to_feature = feature1    # Lower m/z gets lighter adduct
+                                    from_adduct_name = best_rel["to_adduct"]    # Now heavier adduct
+                                    to_adduct_name = best_rel["from_adduct"]    # Now lighter adduct
                         
                         # Get adduct details from catalog
                         from_adduct_info = adduct_info.get(from_adduct_name, {})
@@ -2922,7 +2938,40 @@ def __identify_adduct_by_mass_shift(study, rt_tol, cached_adducts_df=None):
                         from_neutral_mass = from_feature["mz"] * abs(from_charge) - from_mass_shift
                         to_neutral_mass = to_feature["mz"] * abs(to_charge) - to_mass_shift
                         
-                        # Store updates
+                        # Smart conservative check: prevent inappropriate assignments to isolated features
+                        # Check if both features are isolated (single-member groups) with [M+?]1+ assignments
+                        def is_isolated_unknown_feature(feature):
+                            """Check if a feature is isolated with unknown adduct"""
+                            if not feature["adduct_top"] or "[M+?]" not in feature["adduct_top"]:
+                                return False  # Not unknown, safe to process
+                            
+                            # Check group size
+                            try:
+                                feature_row = study.consensus_df.filter(study.consensus_df["consensus_uid"] == feature["consensus_uid"])
+                                if len(feature_row) > 0:
+                                    adduct_group = feature_row["adduct_group"].iloc[0]
+                                    if adduct_group > 0:
+                                        group_members = study.consensus_df.filter(study.consensus_df["adduct_group"] == adduct_group)
+                                        return len(group_members) <= 1  # Isolated if group size <= 1
+                            except Exception:
+                                pass
+                            return True  # Default to isolated if can't determine
+                        
+                        from_isolated = is_isolated_unknown_feature(from_feature)
+                        to_isolated = is_isolated_unknown_feature(to_feature)
+                        
+                        # Only skip assignment if BOTH features are isolated AND would get the SAME adduct
+                        # (This prevents inappropriate duplicate assignments to isolated features)
+                        skip_assignment = (from_isolated and to_isolated and from_adduct_name == to_adduct_name)
+                        
+                        if skip_assignment:
+                            study.logger.debug(
+                                f"Skipping inappropriate assignment: both isolated features would get {from_adduct_name} "
+                                f"(UIDs {from_feature['consensus_uid']}, {to_feature['consensus_uid']})"
+                            )
+                            continue  # Skip this pair, continue to next relationship
+                        
+                        # Store updates (legitimate pair or at least one feature already has specific adduct)
                         adduct_updates[from_feature["consensus_uid"]] = {
                             "adduct_top": from_adduct_name,
                             "adduct_charge_top": from_charge,
@@ -3083,164 +3132,518 @@ def __merge_feature_lookup(study_obj, features_df):
     return features_lookup
 
 
+def _get_features_matrix(study, consensus_data, quant_col="inty"):
+    """
+    Create a local intensity matrix from features_df for correlation calculations.
+    
+    Args:
+        study: Study object with features_df and samples_df
+        consensus_data: List of consensus feature dictionaries
+        quant_col: Column name to use for quantification (default: "inty")
+    
+    Returns:
+        pandas.DataFrame: Matrix with consensus_uid as index, sample names as columns
+    """
+    import pandas as pd
+    import numpy as np
+    
+    # Get all sample names
+    sample_names = study.samples_df["sample_name"].to_list()
+    consensus_uids = [int(f["consensus_uid"]) for f in consensus_data]
+    
+    # Initialize matrix with zeros
+    matrix_data = pd.DataFrame(
+        index=pd.Index(consensus_uids, name="consensus_uid"),
+        columns=sample_names,
+        data=0.0,
+        dtype=float
+    )
+    
+    study.logger.debug(f"Building local features matrix: {len(consensus_uids)} features x {len(sample_names)} samples")
+    
+    # Fill matrix with actual intensity values
+    features_df_pandas = study.features_df.to_pandas()
+    samples_df_pandas = study.samples_df.to_pandas()
+    consensus_mapping_pandas = study.consensus_mapping_df.to_pandas()
+    
+    # Create sample_uid to sample_name mapping
+    uid_to_name = dict(zip(samples_df_pandas["sample_uid"], samples_df_pandas["sample_name"]))
+    
+    # For each consensus feature, get intensities from all samples
+    for consensus_uid in consensus_uids:
+        # Get all feature_uids that map to this consensus_uid
+        feature_mappings = consensus_mapping_pandas[
+            consensus_mapping_pandas["consensus_uid"] == consensus_uid
+        ]
+        
+        for _, mapping in feature_mappings.iterrows():
+            feature_uid = mapping["feature_uid"]
+            sample_uid = mapping["sample_uid"]
+            sample_name = uid_to_name.get(sample_uid, f"sample_{sample_uid}")
+            
+            # Get intensity for this feature
+            feature_row = features_df_pandas[
+                (features_df_pandas["feature_uid"] == feature_uid) & 
+                (features_df_pandas["sample_uid"] == sample_uid)
+            ]
+            
+            if len(feature_row) > 0:
+                intensity = feature_row[quant_col].iloc[0]
+                if pd.notna(intensity):
+                    matrix_data.loc[consensus_uid, sample_name] = float(intensity)
+    
+    # Convert any remaining NaN to 0
+    matrix_data = matrix_data.fillna(0.0)
+    
+    study.logger.debug(f"Local matrix built successfully with shape {matrix_data.shape}")
+    
+    return matrix_data
+
+
+def _get_adduct_deltas_with_likelihood(study):
+    """
+    Extract all pairwise mass differences between adducts with joint likelihood scoring.
+    
+    Args:
+        study: Study object with _get_adducts method
+        
+    Returns:
+        List of tuples: (mass_delta, joint_likelihood, adduct1_name, adduct2_name)
+        Sorted by joint_likelihood descending (most likely pairs first)
+    """
+    try:
+        adducts_df = study._get_adducts()
+        
+        if adducts_df is None or adducts_df.is_empty():
+            study.logger.warning("No adducts dataframe available for study")
+            return []
+        
+        # Convert to pandas for easier manipulation
+        adducts_pd = adducts_df.to_pandas()
+        
+        # Check if we have likelihood/probability information
+        likelihood_col = None
+        for col in ['likelihood', 'probability', 'freq', 'frequency', 'score']:
+            if col in adducts_pd.columns:
+                likelihood_col = col
+                break
+        
+        # If no likelihood column, estimate based on adduct type
+        if likelihood_col is None:
+            adducts_pd['estimated_likelihood'] = adducts_pd.apply(_estimate_adduct_likelihood, axis=1)
+            likelihood_col = 'estimated_likelihood'
+        
+        # Get mass column (try different possible column names)
+        mass_col = None
+        for col_name in ['mass_shift', 'mass', 'mass_shift_da', 'mass_da']:
+            if col_name in adducts_pd.columns:
+                mass_col = col_name
+                break
+        
+        if mass_col is None:
+            study.logger.warning(f"No mass column found in adducts dataframe. Available columns: {list(adducts_pd.columns)}")
+            return []
+        
+        # Calculate all pairwise differences with joint likelihoods
+        adduct_pairs = []
+        for i in range(len(adducts_pd)):
+            for j in range(i + 1, len(adducts_pd)):
+                row_i = adducts_pd.iloc[i]
+                row_j = adducts_pd.iloc[j]
+                
+                # Skip if masses are NaN or invalid
+                if (hasattr(row_i[mass_col], '__iter__') and not isinstance(row_i[mass_col], str)) or \
+                   (hasattr(row_j[mass_col], '__iter__') and not isinstance(row_j[mass_col], str)):
+                    continue
+                    
+                mass_i = float(row_i[mass_col])
+                mass_j = float(row_j[mass_col])
+                delta = abs(mass_i - mass_j)
+                
+                if delta > 0.1:  # Only meaningful mass differences
+                    # Joint likelihood is sum of individual likelihoods
+                    joint_likelihood = float(row_i[likelihood_col]) + float(row_j[likelihood_col])
+                    
+                    adduct1_name = row_i.get('adduct', row_i.get('name', f'adduct_{i}'))
+                    adduct2_name = row_j.get('adduct', row_j.get('name', f'adduct_{j}'))
+                    
+                    # CRITICAL FIX: Order adducts consistently from lower mass to higher mass
+                    # This ensures consistent assignment: lower mass adduct = from_adduct, higher mass adduct = to_adduct
+                    if mass_i <= mass_j:
+                        # row_i has lower or equal mass shift -> from_adduct
+                        # row_j has higher mass shift -> to_adduct  
+                        adduct_pairs.append((round(delta, 4), joint_likelihood, adduct1_name, adduct2_name))
+                    else:
+                        # row_j has lower mass shift -> from_adduct
+                        # row_i has higher mass shift -> to_adduct
+                        adduct_pairs.append((round(delta, 4), joint_likelihood, adduct2_name, adduct1_name))
+        
+        # Sort by joint likelihood descending (most likely pairs first)
+        adduct_pairs.sort(key=lambda x: x[1], reverse=True)
+        
+        study.logger.debug(f"Extracted {len(adduct_pairs)} adduct pairs with likelihood scoring")
+        return adduct_pairs
+        
+    except Exception as e:
+        study.logger.warning(f"Could not extract adduct deltas with likelihood: {e}. No adducts defined - returning empty list.")
+        return []
+
+
+def _estimate_adduct_likelihood(adduct_row):
+    """
+    Estimate likelihood of an adduct based on common knowledge.
+    
+    Args:
+        adduct_row: pandas Series with adduct information
+        
+    Returns:
+        float: Estimated likelihood (0.0 to 1.0)
+    """
+    adduct_name = str(adduct_row.get('adduct', adduct_row.get('name', ''))).lower()
+    
+    # Common likelihood estimates based on adduct frequency in positive mode
+    likelihood_map = {
+        '[m+h]': 0.9,      # Most common
+        '[m+na]': 0.7,     # Very common
+        '[m+nh4]': 0.6,    # Common
+        '[m+k]': 0.3,      # Less common
+        '[m+2h]': 0.2,     # Doubly charged, less frequent
+        '[m+3h]': 0.1,     # Triply charged, rare
+        '[m+h-h2o]': 0.4,  # Loss adducts, moderately common
+    }
+    
+    # Find best match
+    for pattern, likelihood in likelihood_map.items():
+        if pattern in adduct_name:
+            return likelihood
+    
+    # Default for unknown adducts
+    return 0.2
+
+
+def _get_adduct_deltas(study):
+    """
+    Extract all pairwise mass differences between adducts from study adducts data.
+    
+    Args:
+        study: Study object with _get_adducts method
+        
+    Returns:
+        List of mass differences (deltas) for adduct filtering
+    """
+    # Use the enhanced function and extract just the deltas for backward compatibility
+    adduct_pairs = _get_adduct_deltas_with_likelihood(study)
+    return [pair[0] for pair in adduct_pairs]  # Extract just the mass deltas
+
+
+def _fast_correlation(vec1, vec2):
+    """
+    Fast Pearson correlation coefficient calculation.
+    Optimized for repeated use in tight loops.
+    """
+    if len(vec1) != len(vec2):
+        return 0.0
+    
+    # Remove NaN values and corresponding positions
+    mask = ~(np.isnan(vec1) | np.isnan(vec2))
+    if np.sum(mask) < 2:  # Need at least 2 valid points
+        return 0.0
+    
+    v1 = vec1[mask]
+    v2 = vec2[mask]
+    
+    # Fast correlation using numpy built-in
+    try:
+        corr_matrix = np.corrcoef(v1, v2)
+        return corr_matrix[0, 1] if not np.isnan(corr_matrix[0, 1]) else 0.0
+    except Exception:
+        return 0.0
+
+
 def __merge_adduct_grouping(study, consensus_data, rt_tol, mz_tol):
     """
-    Optimized O(n log n) adduct grouping using spatial indexing.
+    Groups consensus features that represent the same molecule with different adducts.
+    Uses multi-step filtering:
+    1. Build local intensity matrix once
+    2. RT coelution filtering with spatial indexing
+    3. Mass shift validation with hash lookup
+    4. Hierarchical boss structure (prevent transitivity)
+    5. Correlation-based confirmation
+    6. Intensity-based ranking for final selection
     
     Args:
-        study: Study object with logger
+        study: Study object
         consensus_data: List of consensus feature dictionaries
-        rt_tol: RT tolerance in minutes
-        mz_tol: m/z tolerance in Da
+        rt_tol: Retention time tolerance (seconds) 
+        mz_tol: M/z tolerance (Da)
         
     Returns:
         Tuple of (adduct_group_list, adduct_of_list)
     """
+    
     if not consensus_data:
         return [], []
-    
+        
     n_features = len(consensus_data)
-    if n_features > 10000:
-        study.logger.info(f"Adduct grouping for {n_features} consensus features...")
-    else:
-        study.logger.debug(f"Adduct grouping for {n_features} consensus features...")
+    study.logger.info(f"Starting adduct grouping for {n_features} features")
     
-    # Build spatial index using RT and neutral mass as coordinates
-    features_by_mass = defaultdict(list)
-    mass_bin_size = mz_tol * 2  # 2x tolerance for conservative binning
-    
-    valid_features = []
-    for feature in consensus_data:
-        consensus_uid = feature["consensus_uid"]
+    # Step 1: Build local intensity matrix ONCE
+    try:
+        intensity_matrix_pd = _get_features_matrix(study, consensus_data, quant_col="inty")
+        
+        if intensity_matrix_pd is None or len(intensity_matrix_pd) == 0:
+            study.logger.warning("Could not build local intensity matrix - creating single-feature groups")
+            adduct_group_list = list(range(1, len(consensus_data) + 1))
+            adduct_of_list = [0] * len(consensus_data)
+            return adduct_group_list, adduct_of_list
+            
+        study.logger.info(f"Built local intensity matrix: {len(intensity_matrix_pd)} features x {len(intensity_matrix_pd.columns)} samples")
+        
+    except Exception as e:
+        study.logger.warning(f"Could not build local intensity matrix: {e}. Creating single-feature groups.")
+        adduct_group_list = list(range(1, len(consensus_data) + 1))
+        adduct_of_list = [0] * len(consensus_data)
+        return adduct_group_list, adduct_of_list
+    
+    # Step 2: Get adduct pairs with likelihood information and build hash map for fast lookup  
+    adduct_pairs_with_likelihood = _get_adduct_deltas_with_likelihood(study)
+    study.logger.info(f"Using {len(adduct_pairs_with_likelihood)} adduct pairs with likelihood scoring")
+    
+    # Build hash map for O(1) mass shift lookup
+    mass_shift_map = {}  # rounded_delta -> [(likelihood, adduct1, adduct2), ...]
+    for mass_delta, joint_likelihood, adduct1, adduct2 in adduct_pairs_with_likelihood:
+        key = round(mass_delta / mz_tol) * mz_tol  # Round to tolerance grid
+        if key not in mass_shift_map:
+            mass_shift_map[key] = []
+        mass_shift_map[key].append((joint_likelihood, adduct1, adduct2))
+    
+    # Sort each mass shift group by likelihood (highest first)
+    for key in mass_shift_map:
+        mass_shift_map[key].sort(key=lambda x: x[0], reverse=True)
+    
+    # Step 3: Pre-compute feature properties and sort by RT for spatial filtering
+    feature_props = []
+    for i, feature in enumerate(consensus_data):
+        uid = feature["consensus_uid"]
         rt = feature["rt"]
-        neutral_mass = feature.get("adduct_mass_neutral_top")
+        mz = feature["mz"]
         intensity = feature.get("inty_mean", 0)
-        adduct = feature.get("adduct_top", "")
         
-        if neutral_mass is not None:
-            mass_bin = int(neutral_mass / mass_bin_size)
-            features_by_mass[mass_bin].append((consensus_uid, rt, neutral_mass, intensity, adduct))
-            valid_features.append((consensus_uid, rt, neutral_mass, intensity, adduct, mass_bin))
+        # Get matrix vector once
+        matrix_vector = intensity_matrix_pd.loc[uid].values if uid in intensity_matrix_pd.index else None
+        
+        feature_props.append({
+            'index': i,
+            'uid': uid,
+            'rt': rt,
+            'mz': mz,
+            'intensity': intensity,
+            'vector': matrix_vector,
+            'feature': feature
+        })
     
-    # Union-Find for efficient grouping
-    class UnionFind:
-        def __init__(study, n):
-            study.parent = list(range(n))
-            study.rank = [0] * n
-        
-        def find(study, x):
-            if study.parent[x] != x:
-                study.parent[x] = study.find(study.parent[x])
-            return study.parent[x]
-        
-        def union(study, x, y):
-            px, py = study.find(x), study.find(y)
-            if px == py:
-                return
-            if study.rank[px] < study.rank[py]:
-                px, py = py, px
-            study.parent[py] = px
-            if study.rank[px] == study.rank[py]:
-                study.rank[px] += 1
-    
-    uid_to_idx = {feature[0]: i for i, feature in enumerate(valid_features)}
-    uf = UnionFind(len(valid_features))
-    
-    # Find groups using spatial index
-    checked_pairs = set()
-    for i, (uid1, rt1, mass1, inty1, adduct1, bin1) in enumerate(valid_features):
-        for bin_offset in [-1, 0, 1]:
-            check_bin = bin1 + bin_offset
-            if check_bin not in features_by_mass:
-                continue
-                
-            for uid2, rt2, mass2, inty2, adduct2 in features_by_mass[check_bin]:
-                if uid1 >= uid2:
-                    continue
+    # Sort by RT for efficient spatial filtering
+    feature_props.sort(key=lambda x: x['rt'])
+    
+    # Initialize grouping structures
+    uid_to_boss = {}  # Hierarchical structure: uid -> boss_uid
+    boss_to_members = {}  # boss_uid -> [member_uids]
+    processed_uids = set()
+    
+    # Step 4: Process features with optimized RT filtering
+    for i, boss_prop in enumerate(feature_props):
+        boss_uid = boss_prop['uid']
+        
+        if boss_uid in processed_uids:
+            continue
+            
+        if boss_prop['vector'] is None:
+            processed_uids.add(boss_uid)
+            continue
+            
+        # Initialize as boss
+        if boss_uid not in uid_to_boss:
+            uid_to_boss[boss_uid] = boss_uid
+            boss_to_members[boss_uid] = []
+        
+        boss_rt = boss_prop['rt']
+        boss_mz = boss_prop['mz']
+        boss_vector = boss_prop['vector']
+        
+        # Step 5: Efficient RT coelution filtering using sorted array
+        candidate_pairs = []
+        
+        # Search backwards from current position
+        j = i - 1
+        while j >= 0 and (boss_rt - feature_props[j]['rt']) <= rt_tol:
+            candidate = feature_props[j]
+            if candidate['uid'] not in processed_uids and candidate['vector'] is not None:
+                if candidate['uid'] not in uid_to_boss or uid_to_boss[candidate['uid']] == candidate['uid']:
+                    # Calculate mz difference and check mass shift
+                    mz_diff = abs(boss_mz - candidate['mz'])
+                    mass_shift_key = round(mz_diff / mz_tol) * mz_tol
+                    
+                    if mass_shift_key in mass_shift_map:
+                        likelihood, adduct1, adduct2 = mass_shift_map[mass_shift_key][0]  # Best likelihood
+                        candidate_pairs.append((candidate, likelihood, (adduct1, adduct2)))
+            j -= 1
+            
+        # Search forwards from current position
+        j = i + 1
+        while j < len(feature_props) and (feature_props[j]['rt'] - boss_rt) <= rt_tol:
+            candidate = feature_props[j]
+            if candidate['uid'] not in processed_uids and candidate['vector'] is not None:
+                if candidate['uid'] not in uid_to_boss or uid_to_boss[candidate['uid']] == candidate['uid']:
+                    # Calculate mz difference and check mass shift
+                    mz_diff = abs(boss_mz - candidate['mz'])
+                    mass_shift_key = round(mz_diff / mz_tol) * mz_tol
+                    
+                    if mass_shift_key in mass_shift_map:
+                        likelihood, adduct1, adduct2 = mass_shift_map[mass_shift_key][0]  # Best likelihood
+                        candidate_pairs.append((candidate, likelihood, (adduct1, adduct2)))
+            j += 1
+        
+        # Sort candidates by likelihood (descending) to prioritize chemically meaningful pairs
+        candidate_pairs.sort(key=lambda x: x[1], reverse=True)
+        
+        # Step 6: Process candidates in likelihood priority order
+        for candidate_prop, likelihood, adduct_info in candidate_pairs:
+            candidate_uid = candidate_prop['uid']
+            candidate_vector = candidate_prop['vector']
+            
+            # Correlation confirmation with optimized threshold
+            try:
+                correlation = _fast_correlation(boss_vector, candidate_vector)
                 
-                pair = (min(uid1, uid2), max(uid1, uid2))
-                if pair in checked_pairs:
+                if correlation < 0.5:  # More permissive for legitimate adduct relationships
                     continue
-                checked_pairs.add(pair)
                 
-                mass_diff = abs(mass1 - mass2)
-                rt_diff = abs(rt1 - rt2) / 60.0  # Convert to minutes
+            except Exception:
+                continue
+            
+            # Step 7: Hierarchical assignment (merge groups if needed)
+            if candidate_uid in boss_to_members:
+                old_members = boss_to_members[candidate_uid].copy()
+                del boss_to_members[candidate_uid]
                 
-                if mass_diff <= mz_tol and rt_diff <= rt_tol:
-                    j = uid_to_idx[uid2]
-                    uf.union(i, j)
+                # Reassign old members to new boss
+                for member in old_members:
+                    uid_to_boss[member] = boss_uid
+                    boss_to_members[boss_uid].append(member)
+            
+            # Assign candidate to current boss
+            uid_to_boss[candidate_uid] = boss_uid
+            boss_to_members[boss_uid].append(candidate_uid)
+            processed_uids.add(candidate_uid)
+        
+        processed_uids.add(boss_uid)
+    
+    # Step 8: Intensity-based ranking within groups (optimized)
+    for boss_uid in list(boss_to_members.keys()):
+        members = boss_to_members[boss_uid]
+        if len(members) == 0:
+            continue
+            
+        all_group_members = [boss_uid] + members
+        
+        # Find member with highest intensity efficiently
+        max_intensity = -1
+        new_boss = boss_uid
+        
+        for member_uid in all_group_members:
+            # Find member_uid in feature_props
+            member_intensity = next((fp['intensity'] for fp in feature_props if fp['uid'] == member_uid), 0)
+            if member_intensity > max_intensity:
+                max_intensity = member_intensity
+                new_boss = member_uid
+        
+        # Update boss if needed
+        if new_boss != boss_uid:
+            boss_to_members[new_boss] = [m for m in all_group_members if m != new_boss]
+            del boss_to_members[boss_uid]
+            
+            # Update all member references
+            for member in all_group_members:
+                uid_to_boss[member] = new_boss
     
-    # Extract groups
-    groups_by_root = defaultdict(list)
-    for i, (uid, rt, mass, inty, adduct, _) in enumerate(valid_features):
-        root = uf.find(i)
-        groups_by_root[root].append(valid_features[i])
+    # Count and log results
+    total_groups = len(boss_to_members)
+    multi_member_groups = sum(1 for members in boss_to_members.values() if len(members) > 0)
+    total_grouped_features = sum(len(members) + 1 for members in boss_to_members.values())
     
-    groups = {}
-    group_id = 1
-    assigned_groups = {}
+    study.logger.info(f"Grouping results: {total_groups} groups ({multi_member_groups} multi-member, {total_grouped_features} features)")
     
-    for group_members in groups_by_root.values():
-        member_uids = [uid for uid, _, _, _, _, _ in group_members]
-        
-        for uid in member_uids:
-            assigned_groups[uid] = group_id
-        groups[group_id] = member_uids
-        group_id += 1
+    # Step 9: Convert to return format (optimized)
+    uid_to_index = {fp['uid']: fp['index'] for fp in feature_props}
+    adduct_group_list = [0] * n_features
+    adduct_of_list = [0] * n_features
     
-    # Handle features without neutral mass
-    for feature in consensus_data:
-        uid = feature["consensus_uid"]
-        if uid not in assigned_groups:
-            assigned_groups[uid] = group_id
-            groups[group_id] = [uid]
-            group_id += 1
-    
-    # Determine adduct_of for each group
-    group_adduct_of = {}
-    for grp_id, member_uids in groups.items():
-        best_uid = None
-        best_priority = -1
-        best_intensity = 0
-        
-        for uid in member_uids:
-            feature_data = next((f for f in consensus_data if f["consensus_uid"] == uid), None)
-            if not feature_data:
-                continue
-                
-            adduct = feature_data.get("adduct_top", "")
-            intensity = feature_data.get("inty_mean", 0)
-            
-            priority = 0
-            if adduct and ("[M+H]" in adduct or adduct == "H" or adduct == "?"):
-                priority = 3
-            elif adduct and "[M-H]" in adduct:
-                priority = 2
-            elif adduct and "M" in adduct:
-                priority = 1
-            
-            if priority > best_priority or (priority == best_priority and intensity > best_intensity):
-                best_uid = uid
-                best_priority = priority
-                best_intensity = intensity
+    group_counter = 1
+    for boss_uid, members in boss_to_members.items():
+        # Assign boss
+        boss_idx = uid_to_index[boss_uid]
+        adduct_group_list[boss_idx] = group_counter
+        adduct_of_list[boss_idx] = 0
+        
+        # Assign members
+        for member_uid in members:
+            member_idx = uid_to_index[member_uid]
+            adduct_group_list[member_idx] = group_counter
+            adduct_of_list[member_idx] = boss_uid
         
-        group_adduct_of[grp_id] = best_uid if best_uid else member_uids[0]
+        group_counter += 1
     
-    # Build final lists in same order as consensus_data
-    adduct_group_list = []
-    adduct_of_list = []
+    # Handle ungrouped features
+    for i in range(n_features):
+        if adduct_group_list[i] == 0:
+            adduct_group_list[i] = group_counter
+            adduct_of_list[i] = 0
+            group_counter += 1
     
-    for feature in consensus_data:
-        uid = feature["consensus_uid"]
-        group = assigned_groups.get(uid, 0)
-        adduct_of = group_adduct_of.get(group, uid)
+    return adduct_group_list, adduct_of_list
+
+
+def _fast_correlation(x, y):
+    """
+    Fast correlation coefficient calculation for consensus matrix data.
+    
+    In the consensus matrix:
+    - Negative values (typically -1.0) indicate missing features  
+    - Zero and positive values are actual intensities
+    - Only consider intensities >= 1000 for meaningful correlation
+    
+    Args:
+        x, y: numpy arrays of the same length
         
-        adduct_group_list.append(group)
-        adduct_of_list.append(adduct_of)
+    Returns:
+        Correlation coefficient (float), 0 if cannot be calculated
+    """
+    import numpy as np
     
-    if n_features > 10000:
-        study.logger.info("Adduct grouping completed.")
-    else:
-        study.logger.debug("Adduct grouping completed.")
-
-    return adduct_group_list, adduct_of_list
+    # For consensus matrix: exclude negative values (missing features) and very low intensities
+    # Use a very low threshold since processed matrix values are often scaled/normalized  
+    valid = ~(np.isnan(x) | np.isnan(y) | (x < 0) | (y < 0) | (x < 0.1) | (y < 0.1))
+    
+    if np.sum(valid) < 3:  # Need at least 3 valid pairs
+        return 0.0
+    
+    x_valid = x[valid]
+    y_valid = y[valid]
+    
+    # If all values are the same (e.g., all zeros), correlation is undefined
+    if np.var(x_valid) == 0 or np.var(y_valid) == 0:
+        return 0.0
+    
+    # Fast correlation using numpy
+    try:
+        correlation_matrix = np.corrcoef(x_valid, y_valid)
+        correlation = correlation_matrix[0, 1]
+        
+        # Handle NaN result
+        if np.isnan(correlation):
+            return 0.0
+            
+        return correlation
+        
+    except Exception:
+        return 0.0

masster/study/study.py

@@ -108,7 +108,7 @@ from masster.study.parameters import get_parameters_property
 from masster.study.parameters import set_parameters_property
 from masster.study.save import save, save_consensus, save_samples
 from masster.study.export import export_mgf, export_mztab, export_xlsx, export_parquet
-from masster.study.id import lib_load, identify, get_id, id_reset, lib_reset
+from masster.study.id import lib_load, identify, get_id, id_reset, lib_reset, _get_adducts
 
 from masster.logger import MassterLogger
 from masster.study.defaults.study_def import study_defaults
@@ -380,6 +380,7 @@ class Study:
     get_orphans = get_orphans
     get_sample_stats = get_sample_stats
     get_consensus_stats = get_consensus_stats
+    _get_adducts = _get_adducts
     
     # === Data Selection and Filtering ===
     samples_select = samples_select

{masster-0.5.6.dist-info → masster-0.5.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: masster
-Version: 0.5.6
+Version: 0.5.8
 Summary: Mass spectrometry data analysis package
 Project-URL: homepage, https://github.com/zamboni-lab/masster
 Project-URL: repository, https://github.com/zamboni-lab/masster

{masster-0.5.6.dist-info → masster-0.5.8.dist-info}/RECORD

@@ -1,5 +1,5 @@
 masster/__init__.py,sha256=ueZ224WPNRRjQEYTaQUol818nwQgJwB93HbEfmtPRmg,1041
-masster/_version.py,sha256=rLineW-O0OSBF7JBd31acdcshluNBFss77bXVJCx5BY,256
+masster/_version.py,sha256=BXXXNsuN4ipe6lTSVTBWB-FcZgzIiyQ_OToEKfd6hos,256
 masster/chromatogram.py,sha256=iYpdv8C17zVnlWvOFgAn9ns2uFGiF-GgoYf5QVVAbHs,19319
 masster/logger.py,sha256=tR65N23zfrNpcZNbZm2ot_Aual9XrGB1MWjLrovZkMs,16749
 masster/spectrum.py,sha256=TWIgDcl0lveG40cLVZTWGp8-FxMolu-P8EjZyRBtXL4,49850
@@ -25,7 +25,7 @@ masster/sample/helpers.py,sha256=27eZFFidr02-DlSi4-eF4bpSk_y-qU3eoFCAOshRO20,421
 masster/sample/lib.py,sha256=E-j9c3Wd8f9a-H8xj7CAOwlA8KcyXPoFyYm3c8r7LtI,33755
 masster/sample/load.py,sha256=swjRBCoFGni9iPztHIKPVB5ru_xDMVryB_inPXdujTw,51819
 masster/sample/parameters.py,sha256=Gg2KcuNbV_wZ_Wwv93QlM5J19ji0oSIvZLPV1NoBmq0,4456
-masster/sample/plot.py,sha256=vA37dwmpeymVW8xobrsLhsD7X8x7EQIOw50Csiica84,86675
+masster/sample/plot.py,sha256=-rHqdi6q7jqjS8ENpTlxjwJBMZAwo-6OsNmE_d1JVQk,86617
 masster/sample/processing.py,sha256=CjaLCElDKECeCvYWqzT5EH_-rPQ0Y4A30zKjZfqmS5s,55915
 masster/sample/quant.py,sha256=tHNjvUFTdehKR31BXBZnVsBxMD9XJHgaltITOjr71uE,7562
 masster/sample/sample.py,sha256=VhQik_ev1liRqGUtbZvV1NOjfFzgfZI1orfQT87gai4,20643
@@ -42,15 +42,15 @@ masster/study/__init__.py,sha256=55axdFuqRX4aXtJ8ocnhcLB32fNtmmJpCi58moO0r4g,237
 masster/study/analysis.py,sha256=L-wXBnGZCLB5UUDrjIdOiMG9zdej3Tw_SftcEmmTukM,84264
 masster/study/export.py,sha256=joFK9jip2UM4lVAvhkdKVeUdNdM4D8uP2WE49IaVJgw,60172
 masster/study/h5.py,sha256=84plxM7gYFdn_mNbcg8XxE_NRZmiIBqs_XhfHMiXshk,95364
-masster/study/helpers.py,sha256=ZhvLetoEROHMSrMKZo8jXQMJhTochITgAG_vwjs_8Mg,183129
-masster/study/id.py,sha256=r_vZQYNxqNXf_pjgk_CLkl1doLnLa956mTuVmlHN52o,80075
+masster/study/helpers.py,sha256=dOj7rJlVx7uKCRt1iMOsZHuz4b9Kch5d68biUyIK1mE,190834
+masster/study/id.py,sha256=Tiw_i2jDxUWaPnzd5PzgSnLSRDDDJkwLYbjzA0XcBwQ,80082
 masster/study/load.py,sha256=7d11294YYEGrSKox3cwvetv2vqcstYT1SnyAhHH5V_Q,107706
-masster/study/merge.py,sha256=D9xNRlEaMPTPZQAZhiBBSzQ-27lD60fCDmKb0cYST-M,149764
+masster/study/merge.py,sha256=-SNlroqQVuOyzsJimvgf9c6T9V3yt-mx_2lW3L2kE-g,169501
 masster/study/parameters.py,sha256=bTvmcwX9INxzcrEAmTiFH8qeWVhwkvMTZjuP394pz5o,3279
 masster/study/plot.py,sha256=LEIzoYiUyq1aswh-sw8S-ESvN2DaQKN5l22yLW8gZe8,107647
 masster/study/processing.py,sha256=n5208v-JQGq3bBP-ncgl2__hHWSQQYHx2fl4Mm0THdI,58538
 masster/study/save.py,sha256=47AP518epJJ9TjaGGyrLKsMsyjIk8_J4ka7bmsnRtFQ,9268
-masster/study/study.py,sha256=TnZkTLB8Z5R-AVqoHfUNvmkTthfUI4OPmBo_LYR_e8g,38654
+masster/study/study.py,sha256=gudugPJk3LOtZh-YsszSRCBDrBG78cexoG0CSM86EPs,38701
 masster/study/study5_schema.json,sha256=0IZxM9VVI0TUlx74BPzJDT44kySi6NZZ6iLR0j8bU_s,7736
 masster/study/defaults/__init__.py,sha256=m3Z5KXGqsTdh7GjYzZoENERt39yRg0ceVRV1DeCt1P0,610
 masster/study/defaults/align_def.py,sha256=Du0F592ej2einT8kOx8EUs610axSvur8_-6N19O-uJY,10209
@@ -61,14 +61,14 @@ masster/study/defaults/find_ms2_def.py,sha256=RL0DFG41wQ05U8UQKUGr3vzSl3mU0m0knQ
 masster/study/defaults/identify_def.py,sha256=96rxoCAPQj_yX-3mRoD2LTkTLJgG27eJQqwarLv5jL0,10580
 masster/study/defaults/integrate_chrom_def.py,sha256=0MNIWGTjty-Zu-NTQsIweuj3UVqEY3x1x8pK0mPwYak,7264
 masster/study/defaults/integrate_def.py,sha256=Vf4SAzdBfnsSZ3IRaF0qZvWu3gMDPHdgPfMYoPKeWv8,7246
-masster/study/defaults/merge_def.py,sha256=3W13QSZaIzxHTDFifW-Nncu_phIqZgf0TpcllaKwbHE,12978
+masster/study/defaults/merge_def.py,sha256=krR099IkENLlJVxpSjdje3E6h-_qtlc3Ep6Hpy6inrU,12978
 masster/study/defaults/study_def.py,sha256=h8dYbi9xv0sesCSQik49Z53IkskMmNtW6ixl7it5pL0,16033
 masster/wizard/README.md,sha256=mL1A3YWJZOefpJ6D0-HqGLkVRmUlOpwyVFdvJBeeoZM,14149
 masster/wizard/__init__.py,sha256=a2hcZnHASjfuw1lqZhZnvTR58rc33rRnoGAY_JfvGhI,683
 masster/wizard/example.py,sha256=xEZFTH9UZ8HKOm6s3JL8Js0Uw5ChnISWBHSZCL32vsM,7983
 masster/wizard/wizard.py,sha256=UobIGFZtp1s_9WJlpl6DQ2-pp7flPQ6dlYZJqYE92OM,38131
-masster-0.5.6.dist-info/METADATA,sha256=Vbsgbvaxv5TP83vvlXhTlG7vdrkUaN8fvdkSwVil3HY,45113
-masster-0.5.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-masster-0.5.6.dist-info/entry_points.txt,sha256=ZHguQ_vPmdbpqq2uGtmEOLJfgP-DQ1T0c07Lxh30wc8,58
-masster-0.5.6.dist-info/licenses/LICENSE,sha256=bx5iLIKjgAdYQ7sISn7DsfHRKkoCUm1154sJJKhgqnU,35184
-masster-0.5.6.dist-info/RECORD,,
+masster-0.5.8.dist-info/METADATA,sha256=Y_1eR5BbxbKoJmfrJE2W_gShiIa7ba2bw8vAPD6hMD4,45113
+masster-0.5.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+masster-0.5.8.dist-info/entry_points.txt,sha256=ZHguQ_vPmdbpqq2uGtmEOLJfgP-DQ1T0c07Lxh30wc8,58
+masster-0.5.8.dist-info/licenses/LICENSE,sha256=bx5iLIKjgAdYQ7sISn7DsfHRKkoCUm1154sJJKhgqnU,35184
+masster-0.5.8.dist-info/RECORD,,