masster 0.2.4__py3-none-any.whl → 0.3.0__py3-none-any.whl

masster/sample/sciex.py

@@ -0,0 +1,1213 @@
+"""
+Standalone Sciex WIFF file reader module.
+
+This module provides a standalone implementation of Sciex WIFF file reading
+functionality that uses the DLLs from alpharaw's ext/sciex directory directly
+without importing from the alpharaw package.
+
+Requirements:
+- pythonnet (pip install pythonnet)
+- alpharaw package must be installed to access the DLLs in site-packages/alpharaw/ext/sciex/
+- On Linux/macOS: mono runtime must be installed
+
+The .NET imports (System, Clearcore2, WiffOps4Python) will only work when
+pythonnet is properly installed and configured.
+"""
+
+import os
+import site
+import warnings
+
+from typing import Any, ClassVar
+
+import numpy as np
+import pandas as pd
+
+
+# Import centroiding functionality (simplified naive centroid implementation)
+def naive_centroid(
+    peak_mzs: np.ndarray,
+    peak_intensities: np.ndarray,
+    centroiding_ppm: float = 20.0,
+) -> tuple[np.ndarray, np.ndarray]:
+    """
+    Simplified naive centroiding implementation.
+    """
+    if len(peak_mzs) == 0:
+        return np.array([]), np.array([])
+
+    # Simple centroiding: combine peaks within tolerance
+    centroided_mzs = []
+    centroided_intensities = []
+
+    i = 0
+    while i < len(peak_mzs):
+        current_mz = peak_mzs[i]
+        current_intensity = peak_intensities[i]
+
+        # Look for nearby peaks within tolerance
+        j = i + 1
+        total_intensity = current_intensity
+        weighted_mz_sum = current_mz * current_intensity
+
+        while j < len(peak_mzs):
+            tolerance = current_mz * centroiding_ppm * 1e-6
+            if abs(peak_mzs[j] - current_mz) <= tolerance:
+                total_intensity += peak_intensities[j]
+                weighted_mz_sum += peak_mzs[j] * peak_intensities[j]
+                j += 1
+            else:
+                break
+
+        # Calculate centroided m/z and intensity
+        if total_intensity > 0:
+            centroided_mz = weighted_mz_sum / total_intensity
+            centroided_mzs.append(centroided_mz)
+            centroided_intensities.append(total_intensity)
+
+        i = j
+
+    return np.array(centroided_mzs), np.array(centroided_intensities)
+
+
+# CLR utilities implementation
+try:
+    # require pythonnet, pip install pythonnet on Windows
+    import clr
+
+    clr.AddReference("System")
+
+    import ctypes
+
+    import System  # noqa: F401
+
+    from System.Globalization import CultureInfo
+    from System.Runtime.InteropServices import GCHandle
+    from System.Runtime.InteropServices import GCHandleType
+    from System.Threading import Thread
+
+    de_fr = CultureInfo("fr-FR")
+    other = CultureInfo("en-US")
+
+    Thread.CurrentThread.CurrentCulture = other
+    Thread.CurrentThread.CurrentUICulture = other
+
+    # Find the alpharaw ext/sciex directory in site-packages
+    ext_dir = None
+    for site_dir in site.getsitepackages():
+        potential_ext_dir = os.path.join(site_dir, "alpharaw", "ext", "sciex")
+        if os.path.exists(potential_ext_dir):
+            ext_dir = potential_ext_dir
+            break
+
+    if ext_dir is None:
+        # Try alternative locations
+        import alpharaw
+
+        alpharaw_dir = os.path.dirname(alpharaw.__file__)
+        ext_dir = os.path.join(alpharaw_dir, "ext", "sciex")
+
+    if not os.path.exists(ext_dir):
+        raise ImportError("Could not find alpharaw ext/sciex directory with DLLs")
+
+    # Add Sciex DLL references
+    clr.AddReference(
+        os.path.join(ext_dir, "Clearcore2.Data.AnalystDataProvider.dll"),
+    )
+    clr.AddReference(os.path.join(ext_dir, "Clearcore2.Data.dll"))
+    clr.AddReference(os.path.join(ext_dir, "WiffOps4Python.dll"))
+
+    import Clearcore2  # noqa: F401
+    import WiffOps4Python  # noqa: F401
+
+    from Clearcore2.Data.AnalystDataProvider import AnalystDataProviderFactory
+    from Clearcore2.Data.AnalystDataProvider import AnalystWiffDataProvider
+    from WiffOps4Python import WiffOps as DotNetWiffOps
+
+    HAS_DOTNET = True
+except Exception as e:
+    # allows to use the rest of the code without clr
+    warnings.warn(
+        f"Dotnet-based dependencies could not be loaded. Sciex support is disabled. Error: {e}",
+        stacklevel=2,
+    )
+    HAS_DOTNET = False
+
+
+def dot_net_array_to_np_array(src):
+    """
+    Convert .NET array to NumPy array.
+    See https://mail.python.org/pipermail/pythondotnet/2014-May/001527.html
+    """
+    if src is None:
+        return np.array([], dtype=np.float64)
+    src_hndl = GCHandle.Alloc(src, GCHandleType.Pinned)
+    try:
+        src_ptr = src_hndl.AddrOfPinnedObject().ToInt64()
+        buf_type = ctypes.c_double * len(src)
+        cbuf = buf_type.from_address(src_ptr)
+        dest = np.frombuffer(cbuf, dtype='float64').copy()  # type: ignore[call-overload]
+    finally:
+        if src_hndl.IsAllocated:
+            src_hndl.Free()
+        return dest  # noqa: B012
+
+
+class SciexWiff2FileReader:
+    """
+    Specialized reader for Sciex WIFF2 files using optimal DLL combination.
+    
+    WIFF2 is a newer format from Sciex that may have enhanced capabilities
+    compared to the original WIFF format. This reader is optimized specifically
+    for WIFF2 files and uses the most appropriate DLLs for maximum information extraction.
+    
+    Based on comprehensive DLL analysis, WIFF2 files require specific handling and
+    may use different underlying storage mechanisms than regular WIFF files.
+    """
+    
+    def __init__(self, filename: str):
+        """
+        Initialize WIFF2 reader with file path.
+        
+        Parameters
+        ----------
+        filename : str
+            Path to the WIFF2 file
+        """
+        if not HAS_DOTNET:
+            raise ValueError(
+                "Dotnet-based dependencies are required for reading Sciex WIFF2 files. "
+                "Install pythonnet and ensure alpharaw DLLs are available."
+            )
+        
+        self.filename = filename
+        self.ext_dir = self._find_dll_directory()
+        self._ensure_wiff2_dlls_loaded()
+        
+        # Try different initialization strategies for WIFF2
+        self._initialize_wiff2_reader()
+    
+    def _find_dll_directory(self):
+        """Find the alpharaw DLL directory using the same discovery pattern."""
+        for site_dir in site.getsitepackages():
+            potential_ext_dir = os.path.join(site_dir, "alpharaw", "ext", "sciex")
+            if os.path.exists(potential_ext_dir):
+                return potential_ext_dir
+        
+        # Fallback to alpharaw module location
+        try:
+            import alpharaw
+            alpharaw_dir = os.path.dirname(alpharaw.__file__)
+            return os.path.join(alpharaw_dir, "ext", "sciex")
+        except ImportError:
+            raise ImportError("Could not find alpharaw DLL directory")
+    
+    def _ensure_wiff2_dlls_loaded(self):
+        """Ensure all necessary WIFF2 DLLs are loaded."""
+        # Key DLLs identified through comprehensive analysis
+        required_dlls = [
+            "Clearcore2.Data.Wiff2.dll",  # Primary WIFF2 support
+            "Clearcore2.Data.AnalystDataProvider.dll", 
+            "Clearcore2.Data.dll",
+            "Clearcore2.Data.Common.dll",
+            "Clearcore2.Data.Core.dll",
+            "Clearcore2.StructuredStorage.dll",  # For WIFF2 storage format
+            "WiffOps4Python.dll"
+        ]
+        
+        for dll in required_dlls:
+            dll_path = os.path.join(self.ext_dir, dll)
+            if os.path.exists(dll_path):
+                try:
+                    clr.AddReference(dll_path)
+                except:
+                    pass  # May already be loaded
+            else:
+                warnings.warn(f"WIFF2 DLL not found: {dll}", stacklevel=2)
+    
+    def _initialize_wiff2_reader(self):
+        """
+        Initialize WIFF2 reader with fallback strategies.
+        
+        WIFF2 files may require different initialization approaches than WIFF files.
+        We try multiple strategies based on the comprehensive DLL analysis.
+        """
+        initialization_errors = []
+        
+        # Strategy 1: Try standard AnalystDataProvider (may work for some WIFF2)
+        try:
+            from Clearcore2.Data.AnalystDataProvider import AnalystDataProviderFactory
+            from Clearcore2.Data.AnalystDataProvider import AnalystWiffDataProvider
+            
+            self._wiffDataProvider = AnalystWiffDataProvider()
+            self._wiff_file = AnalystDataProviderFactory.CreateBatch(
+                self.filename,
+                self._wiffDataProvider,
+            )
+            
+            self.sample_names = self._wiff_file.GetSampleNames()
+            self.sample_count = len(self.sample_names)
+            self.initialization_method = "AnalystDataProvider"
+            return
+            
+        except Exception as e:
+            initialization_errors.append(f"AnalystDataProvider: {e}")
+        
+        # Strategy 2: Try alpharaw's SciexWiffData (correct API)
+        try:
+            from alpharaw.sciex import SciexWiffData
+            
+            self._alpharaw_reader = SciexWiffData()
+            self._alpharaw_reader.import_raw(self.filename)
+            
+            # Extract basic information (SciexWiffData doesn't have sample_names property)
+            self.sample_names = ['Sample_0']  # Default since WIFF2 format needs investigation
+            self.sample_count = 1
+            self.initialization_method = "alpharaw_SciexWiffData"
+            
+            # Store the reader for later use
+            self._wiff_data = self._alpharaw_reader
+            return
+            
+        except Exception as e:
+            initialization_errors.append(f"alpharaw_SciexWiffData: {e}")
+        
+        # Strategy 3: Try direct WIFF2 DLL approach
+        try:
+            # Check if file is recognized as WIFF2
+            from Clearcore2.Data.AnalystDataProvider import DataProviderHelper
+            
+            is_wiff2 = DataProviderHelper.IsMdWiffFile(self.filename)
+            if is_wiff2:
+                # Try specialized WIFF2 handling
+                warnings.warn(
+                    f"File detected as WIFF2 format but specialized reader not fully implemented. "
+                    f"Consider using alpharaw.ms_data_from_file() directly.",
+                    stacklevel=2
+                )
+                # For now, fall back to treating as regular WIFF with enhanced parameters
+                self._initialize_as_enhanced_wiff()
+                return
+            
+        except Exception as e:
+            initialization_errors.append(f"WIFF2 detection: {e}")
+        
+        # If all strategies fail, provide comprehensive error information with helpful suggestions
+        error_summary = "; ".join(initialization_errors)
+        
+        # Check if this is a WIFF2 format issue specifically
+        if "could not be opened (result = -2147286960)" in error_summary:
+            raise RuntimeError(
+                f"WIFF2 file format is not supported by the current DLL combination. "
+                f"Error code -2147286960 (0x80030050) indicates format incompatibility. "
+                f"The file '{self.filename}' appears to be a valid WIFF2 file but requires "
+                f"newer or different DLLs than currently available. "
+                f"Try converting the WIFF2 file to WIFF format or use alternative tools. "
+                f"Full error details: {error_summary}"
+            )
+        else:
+            raise RuntimeError(
+                f"Failed to initialize WIFF2 reader with any strategy. "
+                f"Errors: {error_summary}. "
+                f"The file may be corrupted, locked, or require different dependencies."
+            )
+    
+    def _initialize_as_enhanced_wiff(self):
+        """Fallback: Initialize as enhanced WIFF with WIFF2-optimized parameters."""
+        # Use the same initialization as regular WIFF but with warnings
+        try:
+            from Clearcore2.Data.AnalystDataProvider import AnalystDataProviderFactory
+            from Clearcore2.Data.AnalystDataProvider import AnalystWiffDataProvider
+            
+            self._wiffDataProvider = AnalystWiffDataProvider()
+            self._wiff_file = AnalystDataProviderFactory.CreateBatch(
+                self.filename,
+                self._wiffDataProvider,
+            )
+            
+            self.sample_names = self._wiff_file.GetSampleNames()
+            self.sample_count = len(self.sample_names)
+            self.initialization_method = "enhanced_wiff_fallback"
+            
+            warnings.warn(
+                "WIFF2 file opened using WIFF reader fallback. "
+                "Some WIFF2-specific features may not be available.",
+                stacklevel=2
+            )
+            
+        except Exception as e:
+            raise RuntimeError(f"Enhanced WIFF fallback also failed: {e}")
+
+    def get_file_metadata(self) -> dict[str, Any]:
+        """Get comprehensive file metadata for WIFF2 format."""
+        metadata: dict[str, Any] = {
+            'format': 'WIFF2',
+            'sample_count': self.sample_count,
+            'sample_names': list(self.sample_names),
+            'file_size': os.path.getsize(self.filename),
+            'file_path': self.filename,
+            'initialization_method': self.initialization_method,
+            'samples': []  # Initialize samples list
+        }
+        
+        if self.initialization_method == "alpharaw":
+            # Get metadata from alpharaw reader
+            try:
+                if hasattr(self._alpharaw_reader, 'get_spectrum_count'):
+                    metadata['total_spectra'] = self._alpharaw_reader.get_spectrum_count()
+                
+                # Add alpharaw-specific metadata
+                for attr in ['creation_time', 'instrument_model', 'ms_levels']:
+                    if hasattr(self._alpharaw_reader, attr):
+                        try:
+                            value = getattr(self._alpharaw_reader, attr)
+                            if callable(value):
+                                metadata[attr] = value()
+                            else:
+                                metadata[attr] = value
+                        except:
+                            pass
+                            
+            except Exception as e:
+                metadata['metadata_error'] = str(e)
+        
+        elif hasattr(self, '_wiff_file'):
+            # Get metadata from standard WIFF reader
+            try:
+                for i in range(self.sample_count):
+                    sample = self._wiff_file.GetSample(i)
+                    sample_info = {
+                        'index': i,
+                        'name': str(self.sample_names[i]),
+                    }
+                    
+                    if hasattr(sample, 'Details'):
+                        details = sample.Details
+                        if hasattr(details, 'AcquisitionDateTime'):
+                            sample_info['acquisition_time'] = str(details.AcquisitionDateTime.ToString("O"))
+                    
+                    if hasattr(sample, 'MassSpectrometerSample'):
+                        ms_sample = sample.MassSpectrometerSample
+                        sample_info['experiment_count'] = ms_sample.ExperimentCount
+                    
+                    metadata['samples'].append(sample_info)
+                    
+            except Exception as e:
+                metadata['metadata_error'] = str(e)
+        
+        return metadata
+
+    def load_sample(self, sample_id: int = 0, **kwargs):
+        """
+        Load sample data with WIFF2-optimized settings.
+        
+        Parameters
+        ----------
+        sample_id : int
+            Sample index to load
+        **kwargs
+            Additional parameters for data loading
+        
+        Returns
+        -------
+        dict
+            Comprehensive spectral data dictionary
+        """
+        if self.initialization_method == "alpharaw":
+            return self._load_sample_alpharaw(sample_id, **kwargs)
+        else:
+            return self._load_sample_standard(sample_id, **kwargs)
+    
+    def _load_sample_alpharaw(self, sample_id: int, **kwargs):
+        """Load sample using alpharaw reader."""
+        # Enhanced parameters for WIFF2
+        enhanced_params = {
+            'centroid': kwargs.get('centroid', True),
+            'centroid_ppm': kwargs.get('centroid_ppm', 15.0),
+            'keep_k_peaks': kwargs.get('keep_k_peaks', 3000),
+        }
+        
+        try:
+            # Use alpharaw's data extraction
+            spectrum_df = self._alpharaw_reader.spectrum_df
+            peak_df = self._alpharaw_reader.peak_df
+            
+            # Convert to the expected format
+            spectral_data = {
+                'peak_indices': spectrum_df[['peak_start_idx', 'peak_stop_idx']].values.flatten(),
+                'peak_mz': peak_df['mz'].values,
+                'peak_intensity': peak_df['intensity'].values,
+                'rt': spectrum_df['rt'].values,
+                'ms_level': spectrum_df['ms_level'].values,
+                'precursor_mz': spectrum_df.get('precursor_mz', np.full(len(spectrum_df), -1.0)).values,
+                'precursor_charge': spectrum_df.get('precursor_charge', np.full(len(spectrum_df), 0)).values,
+                'isolation_lower_mz': spectrum_df.get('isolation_lower_mz', np.full(len(spectrum_df), -1.0)).values,
+                'isolation_upper_mz': spectrum_df.get('isolation_upper_mz', np.full(len(spectrum_df), -1.0)).values,
+                'nce': spectrum_df.get('nce', np.full(len(spectrum_df), 0.0)).values,
+                'metadata': {
+                    'format': 'WIFF2',
+                    'sample_id': sample_id,
+                    'sample_name': str(self.sample_names[sample_id]) if sample_id < len(self.sample_names) else f'Sample_{sample_id}',
+                    'loading_params': enhanced_params,
+                    'total_spectra': len(spectrum_df),
+                    'total_peaks': len(peak_df),
+                    'ms1_count': np.sum(spectrum_df['ms_level'] == 1),
+                    'ms2_count': np.sum(spectrum_df['ms_level'] > 1),
+                    'rt_range': [float(spectrum_df['rt'].min()), float(spectrum_df['rt'].max())] if len(spectrum_df) > 0 else [0, 0],
+                    'reader_method': 'alpharaw'
+                }
+            }
+            
+            return spectral_data
+            
+        except Exception as e:
+            raise RuntimeError(f"Failed to load WIFF2 sample via alpharaw: {e}")
+    
+    def _load_sample_standard(self, sample_id: int, **kwargs):
+        """Load sample using standard WIFF reader with WIFF2 enhancements."""
+        # Use enhanced parameters optimized for WIFF2
+        enhanced_params = {
+            'centroid': kwargs.get('centroid', True),
+            'centroid_ppm': kwargs.get('centroid_ppm', 15.0),  # Tighter for WIFF2
+            'ignore_empty_scans': kwargs.get('ignore_empty_scans', True),
+            'keep_k_peaks': kwargs.get('keep_k_peaks', 3000),  # More peaks for WIFF2
+        }
+        
+        if sample_id < 0 or sample_id >= self.sample_count:
+            raise ValueError(f"Sample ID {sample_id} out of range (0-{self.sample_count-1})")
+        
+        # Use the same loading approach as SciexWiffFileReader but with enhancements
+        sample = self._wiff_file.GetSample(sample_id)
+        ms_sample = sample.MassSpectrometerSample
+        
+        # Process data (same as SciexWiffFileReader.load_sample but with enhanced params)
+        _peak_indices: list[int] = []
+        peak_mz_list: list[np.ndarray] = []
+        peak_intensity_list: list[np.ndarray] = []
+        rt_list: list[float] = []
+        ms_level_list: list[int] = []
+        precursor_mz_list: list[float] = []
+        precursor_charge_list: list[int] = []
+        nce_list: list[float] = []
+        isolation_lower_list: list[float] = []
+        isolation_upper_list: list[float] = []
+        
+        exp_list = [ms_sample.GetMSExperiment(i) for i in range(ms_sample.ExperimentCount)]
+        
+        for j in range(exp_list[0].Details.NumberOfScans):
+            for i in range(ms_sample.ExperimentCount):
+                exp = exp_list[i]
+                mass_spectrum = exp.GetMassSpectrum(j)
+                mass_spectrum_info = exp.GetMassSpectrumInfo(j)
+                details = exp.Details
+                ms_level = mass_spectrum_info.MSLevel
+                
+                if (ms_level > 1 and not details.IsSwath and 
+                    mass_spectrum.NumDataPoints <= 0 and enhanced_params['ignore_empty_scans']):
+                    continue
+                
+                mz_array = dot_net_array_to_np_array(mass_spectrum.GetActualXValues())
+                int_array = dot_net_array_to_np_array(mass_spectrum.GetActualYValues()).astype(np.float32)
+                
+                if enhanced_params['centroid']:
+                    mz_array, int_array = naive_centroid(
+                        mz_array, int_array, 
+                        centroiding_ppm=enhanced_params['centroid_ppm']
+                    )
+                
+                if len(mz_array) > enhanced_params['keep_k_peaks']:
+                    top_indices = np.argsort(int_array)[-enhanced_params['keep_k_peaks']:]
+                    top_indices = np.sort(top_indices)
+                    mz_array = mz_array[top_indices]
+                    int_array = int_array[top_indices]
+                
+                peak_mz_list.append(mz_array)
+                peak_intensity_list.append(int_array)
+                _peak_indices.append(len(peak_mz_list[-1]))
+                
+                rt_list.append(exp.GetRTFromExperimentCycle(j))
+                ms_level_list.append(ms_level)
+                
+                # Enhanced precursor handling for WIFF2
+                center_mz = -1.0
+                isolation_window = 0.0
+                
+                if ms_level > 1:
+                    if details.IsSwath and details.MassRangeInfo.Length > 0:
+                        try:
+                            from WiffOps4Python import WiffOps as DotNetWiffOps
+                            center_mz = DotNetWiffOps.get_center_mz(details)
+                            isolation_window = DotNetWiffOps.get_isolation_window(details)
+                        except:
+                            center_mz = mass_spectrum_info.ParentMZ
+                            isolation_window = 3.0
+                    
+                    if isolation_window <= 0:
+                        isolation_window = 3.0
+                    if center_mz <= 0:
+                        center_mz = mass_spectrum_info.ParentMZ
+                    
+                    precursor_mz_list.append(center_mz)
+                    precursor_charge_list.append(mass_spectrum_info.ParentChargeState)
+                    nce_list.append(float(mass_spectrum_info.CollisionEnergy))
+                    isolation_lower_list.append(center_mz - isolation_window / 2)
+                    isolation_upper_list.append(center_mz + isolation_window / 2)
+                else:
+                    precursor_mz_list.append(-1.0)
+                    precursor_charge_list.append(0)
+                    nce_list.append(0.0)
+                    isolation_lower_list.append(-1.0)
+                    isolation_upper_list.append(-1.0)
+        
+        # Finalize arrays
+        peak_indices = np.empty(len(rt_list) + 1, np.int64)
+        peak_indices[0] = 0
+        peak_indices[1:] = np.cumsum(_peak_indices)
+        
+        return {
+            'peak_indices': peak_indices,
+            'peak_mz': np.concatenate(peak_mz_list) if peak_mz_list else np.array([]),
+            'peak_intensity': np.concatenate(peak_intensity_list) if peak_intensity_list else np.array([]),
+            'rt': np.array(rt_list, dtype=np.float64),
+            'ms_level': np.array(ms_level_list, dtype=np.int8),
+            'precursor_mz': np.array(precursor_mz_list, dtype=np.float64),
+            'precursor_charge': np.array(precursor_charge_list, dtype=np.int8),
+            'isolation_lower_mz': np.array(isolation_lower_list, dtype=np.float64),
+            'isolation_upper_mz': np.array(isolation_upper_list, dtype=np.float64),
+            'nce': np.array(nce_list, dtype=np.float32),
+            'metadata': {
+                'format': 'WIFF2',
+                'sample_id': sample_id,
+                'sample_name': str(self.sample_names[sample_id]),
+                'loading_params': enhanced_params,
+                'total_spectra': len(rt_list),
+                'total_peaks': sum(_peak_indices),
+                'ms1_count': np.sum(np.array(ms_level_list) == 1),
+                'ms2_count': np.sum(np.array(ms_level_list) > 1),
+                'rt_range': [float(np.min(rt_list)), float(np.max(rt_list))] if rt_list else [0, 0],
+                'creation_time': str(sample.Details.AcquisitionDateTime.ToString("O")) if hasattr(sample, 'Details') else '',
+                'reader_method': 'standard_enhanced'
+            }
+        }
+
+    def close(self):
+        """Close the WIFF2 file and clean up resources."""
+        if hasattr(self, '_wiffDataProvider'):
+            try:
+                self._wiffDataProvider.Close()
+            except:
+                pass
+        
+        if hasattr(self, '_alpharaw_reader'):
+            try:
+                self._alpharaw_reader.close()
+            except:
+                pass
+    
+    def __enter__(self):
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+    
+    def __repr__(self):
+        return f"SciexWiff2FileReader(file='{self.filename}', samples={self.sample_count}, method={self.initialization_method})"
+
+
+class SciexWiffFileReader:
+    """
+    Direct implementation of Sciex WIFF file reader using the DLLs without alpharaw dependency.
+    """
+
+    def __init__(self, filename: str):
+        if not HAS_DOTNET:
+            raise ValueError(
+                "Dotnet-based dependencies are required for reading Sciex files. "
+                "Do you have pythonnet and/or mono installed? "
+                "See the alpharaw documentation for details.",
+            )
+
+        self._wiffDataProvider = AnalystWiffDataProvider()
+        self._wiff_file = AnalystDataProviderFactory.CreateBatch(
+            filename,
+            self._wiffDataProvider,
+        )
+        self.sample_names = self._wiff_file.GetSampleNames()
+
+    def close(self):
+        """Close the file and clean up resources."""
+        self._wiffDataProvider.Close()
+
+    def load_sample(
+        self,
+        sample_id: int,
+        centroid: bool = True,
+        centroid_ppm: float = 20.0,
+        ignore_empty_scans: bool = True,
+        keep_k_peaks: int = 2000,
+    ) -> dict[str, Any]:
+        """
+        Load a sample from the WIFF file and extract spectral data.
+
+        Parameters
+        ----------
+        sample_id : int
+            ID of the sample to load
+        centroid : bool
+            Whether to centroid the data
+        centroid_ppm : float
+            PPM tolerance for centroiding
+        ignore_empty_scans : bool
+            Whether to skip empty scans
+        keep_k_peaks : int
+            Maximum number of peaks to keep per spectrum
+
+        Returns
+        -------
+        dict
+            Dictionary containing spectral data
+        """
+        if sample_id < 0 or sample_id >= len(self.sample_names):
+            raise ValueError("Incorrect sample number.")
+
+        self.wiffSample = self._wiff_file.GetSample(sample_id)
+        self.msSample = self.wiffSample.MassSpectrometerSample
+
+        _peak_indices: list[int] = []
+        peak_mz_array_list: list[np.ndarray] = []
+        peak_intensity_array_list: list[np.ndarray] = []
+        rt_list: list[float] = []
+        ms_level_list: list[int] = []
+        precursor_mz_list: list[float] = []
+        precursor_charge_list: list[int] = []
+        ce_list: list[float] = []
+        isolation_lower_mz_list: list[float] = []
+        isolation_upper_mz_list: list[float] = []
+
+        exp_list = [self.msSample.GetMSExperiment(i) for i in range(self.msSample.ExperimentCount)]
+
+        for j in range(exp_list[0].Details.NumberOfScans):
+            for i in range(self.msSample.ExperimentCount):
+                exp = exp_list[i]
+                mass_spectrum = exp.GetMassSpectrum(j)
+                mass_spectrum_info = exp.GetMassSpectrumInfo(j)
+                details = exp.Details
+                ms_level = mass_spectrum_info.MSLevel
+
+                if ms_level > 1 and not details.IsSwath and mass_spectrum.NumDataPoints <= 0 and ignore_empty_scans:
+                    continue
+
+                mz_array = dot_net_array_to_np_array(mass_spectrum.GetActualXValues())
+                int_array = dot_net_array_to_np_array(
+                    mass_spectrum.GetActualYValues(),
+                ).astype(np.float32)
+
+                if centroid:
+                    (mz_array, int_array) = naive_centroid(
+                        mz_array,
+                        int_array,
+                        centroiding_ppm=centroid_ppm,
+                    )
+
+                if len(mz_array) > keep_k_peaks:
+                    idxes = np.argsort(int_array)[-keep_k_peaks:]
+                    idxes = np.sort(idxes)
+                    mz_array = mz_array[idxes]
+                    int_array = int_array[idxes]
+
+                peak_mz_array_list.append(mz_array)
+                peak_intensity_array_list.append(int_array)
+
+                _peak_indices.append(len(peak_mz_array_list[-1]))
+                rt_list.append(exp.GetRTFromExperimentCycle(j))
+
+                ms_level_list.append(ms_level)
+
+                center_mz = -1.0
+                isolation_window = 0.0
+
+                if ms_level > 1:
+                    if details.IsSwath and details.MassRangeInfo.Length > 0:
+                        center_mz = DotNetWiffOps.get_center_mz(details)
+                        isolation_window = DotNetWiffOps.get_isolation_window(details)
+                    if isolation_window <= 0:
+                        isolation_window = 3.0
+                    if center_mz <= 0:
+                        center_mz = mass_spectrum_info.ParentMZ
+                    precursor_mz_list.append(center_mz)
+                    precursor_charge_list.append(mass_spectrum_info.ParentChargeState)
+                    ce_list.append(float(mass_spectrum_info.CollisionEnergy))
+                    isolation_lower_mz_list.append(center_mz - isolation_window / 2)
+                    isolation_upper_mz_list.append(center_mz + isolation_window / 2)
+                else:
+                    precursor_mz_list.append(-1.0)
+                    precursor_charge_list.append(0)
+                    ce_list.append(0.0)
+                    isolation_lower_mz_list.append(-1.0)
+                    isolation_upper_mz_list.append(-1.0)
+
+        peak_indices = np.empty(len(rt_list) + 1, np.int64)
+        peak_indices[0] = 0
+        peak_indices[1:] = np.cumsum(_peak_indices)
+
+        return {
+            "peak_indices": peak_indices,
+            "peak_mz": np.concatenate(peak_mz_array_list),
+            "peak_intensity": np.concatenate(peak_intensity_array_list),
+            "rt": np.array(rt_list, dtype=np.float64),
+            "ms_level": np.array(ms_level_list, dtype=np.int8),
+            "precursor_mz": np.array(precursor_mz_list, dtype=np.float64),
+            "precursor_charge": np.array(precursor_charge_list, dtype=np.int8),
+            "isolation_lower_mz": np.array(isolation_lower_mz_list),
+            "isolation_upper_mz": np.array(isolation_upper_mz_list),
+            "nce": np.array(ce_list, dtype=np.float32),
+        }
+
+
+class SciexWiffData:
+    """
+    Standalone Sciex WIFF data reader class that mimics alpharaw.sciex.SciexWiffData
+    functionality but uses DLLs directly without importing from alpharaw.
+    """
+
+    # Column data types mapping
+    column_dtypes: ClassVar[dict[str, Any]] = {
+        "rt": np.float64,
+        "ms_level": np.int8,
+        "precursor_mz": np.float64,
+        "isolation_lower_mz": np.float64,
+        "isolation_upper_mz": np.float64,
+        "precursor_charge": np.int8,
+        "nce": np.float32,
+        "injection_time": np.float32,
+        "activation": "U",
+    }
+
+    def __init__(self, centroided: bool = True, save_as_hdf: bool = False, **kwargs):
+        """
+        Parameters
+        ----------
+        centroided : bool, optional
+            If peaks will be centroided after loading, by default True.
+        save_as_hdf : bool, optional
+            Automatically save hdf after load raw data, by default False.
+        """
+        self.spectrum_df: pd.DataFrame = pd.DataFrame()
+        self.peak_df: pd.DataFrame = pd.DataFrame()
+        self._raw_file_path = ""
+        self.centroided = centroided
+        self._save_as_hdf = save_as_hdf
+        self.creation_time = ""
+        self.file_type = "sciex"
+        self.instrument = "sciex"
+
+        if self.centroided:
+            self.centroided = False
+            warnings.warn(
+                "Centroiding for Sciex data is not well implemented yet",
+                stacklevel=2,
+            )
+
+        self.centroid_ppm = 20.0
+        self.ignore_empty_scans = True
+        self.keep_k_peaks_per_spec = 2000
+        self.sample_id = 0
+
+    @property
+    def raw_file_path(self) -> str:
+        """Get the raw file path."""
+        return self._raw_file_path
+
+    @raw_file_path.setter
+    def raw_file_path(self, value: str):
+        """Set the raw file path."""
+        self._raw_file_path = value
+
+    def import_raw(self, wiff_file_path: str) -> None:
+        """
+        Import raw data from a WIFF file.
+
+        Parameters
+        ----------
+        wiff_file_path : str
+            Path to the WIFF file
+        """
+        self.raw_file_path = wiff_file_path
+        data_dict = self._import(wiff_file_path)
+        self._set_dataframes(data_dict)
+
+    def _import(self, _wiff_file_path: str) -> dict[str, Any]:
+        """
+        Implementation of data import interface.
+
+        Parameters
+        ----------
+        _wiff_file_path : str
+            Absolute or relative path of the sciex wiff file.
+
+        Returns
+        -------
+        dict
+            Spectrum information dict.
+        """
+        wiff_reader = SciexWiffFileReader(_wiff_file_path)
+        data_dict = wiff_reader.load_sample(
+            self.sample_id,
+            centroid=self.centroided,
+            centroid_ppm=self.centroid_ppm,
+            ignore_empty_scans=self.ignore_empty_scans,
+            keep_k_peaks=self.keep_k_peaks_per_spec,
+        )
+        self.creation_time = wiff_reader.wiffSample.Details.AcquisitionDateTime.ToString("O")
+        wiff_reader.close()
+        return data_dict
+
+    def _set_dataframes(self, raw_data: dict[str, Any]) -> None:
+        """
+        Set the spectrum and peak dataframes from raw data dictionary.
+
+        Parameters
+        ----------
+        raw_data : dict
+            Dictionary containing the raw spectral data
+        """
+        self.create_spectrum_df(len(raw_data["rt"]))
+        self.set_peak_df_by_indexed_array(
+            raw_data["peak_mz"],
+            raw_data["peak_intensity"],
+            raw_data["peak_indices"][:-1],
+            raw_data["peak_indices"][1:],
+        )
+
+        for col, val in raw_data.items():
+            if col in self.column_dtypes:
+                if self.column_dtypes[col] == "O":
+                    self.spectrum_df[col] = list(val)
+                else:
+                    self.spectrum_df[col] = np.array(val, dtype=self.column_dtypes[col])
+
+    def create_spectrum_df(self, spectrum_num: int) -> None:
+        """
+        Create an empty spectrum dataframe from the number of spectra.
+
+        Parameters
+        ----------
+        spectrum_num : int
+            The number of spectra.
+        """
+        self.spectrum_df = pd.DataFrame(index=np.arange(spectrum_num, dtype=np.int64))
+        self.spectrum_df["spec_idx"] = self.spectrum_df.index.values
+
+    def set_peak_df_by_indexed_array(
+        self,
+        mz_array: np.ndarray,
+        intensity_array: np.ndarray,
+        peak_start_indices: np.ndarray,
+        peak_stop_indices: np.ndarray,
+    ) -> None:
+        """
+        Set peak dataframe using indexed arrays.
+
+        Parameters
+        ----------
+        mz_array : np.ndarray
+            Array of m/z values
+        intensity_array : np.ndarray
+            Array of intensity values
+        peak_start_indices : np.ndarray
+            Array of start indices for each spectrum
+        peak_stop_indices : np.ndarray
+            Array of stop indices for each spectrum
+        """
+        self.peak_df = pd.DataFrame()
+        self.peak_df["mz"] = mz_array.astype(np.float64)
+        self.peak_df["intensity"] = intensity_array.astype(np.float32)
+
+        # Set peak start and stop indices in spectrum df
+        self.spectrum_df["peak_start_idx"] = peak_start_indices
+        self.spectrum_df["peak_stop_idx"] = peak_stop_indices
+
+    def get_peaks(self, spec_idx: int) -> tuple[np.ndarray, np.ndarray]:
+        """
+        Get peaks for a specific spectrum.
+
+        Parameters
+        ----------
+        spec_idx : int
+            Spectrum index
+
+        Returns
+        -------
+        tuple
+            (mz_array, intensity_array)
+        """
+        start, end = self.spectrum_df[["peak_start_idx", "peak_stop_idx"]].values[
+            spec_idx,
+            :,
+        ]
+        return (
+            self.peak_df.mz.values[start:end],
+            self.peak_df.intensity.values[start:end],
+        )
+
+    def save_hdf(self, hdf_file_path: str) -> None:
+        """
+        Save data to HDF5 file (placeholder implementation).
+
+        Parameters
+        ----------
+        hdf_file_path : str
+            Path to save the HDF5 file
+        """
+        # This would require implementing HDF5 saving functionality
+        # For now, just save as pickle or implement as needed
+        import pickle
+
+        with open(hdf_file_path.replace(".hdf", ".pkl"), "wb") as f:
+            pickle.dump(
+                {
+                    "spectrum_df": self.spectrum_df,
+                    "peak_df": self.peak_df,
+                    "creation_time": self.creation_time,
+                    "raw_file_path": self.raw_file_path,
+                    "file_type": self.file_type,
+                    "centroided": self.centroided,
+                    "instrument": self.instrument,
+                },
+                f,
+            )
+
+    def __repr__(self) -> str:
+        return f"SciexWiffData(file_path='{self.raw_file_path}', spectra={len(self.spectrum_df)})"
+
+
+# Convenience functions to maintain compatibility with existing code
+def load_wiff_file(filename: str, **kwargs) -> SciexWiffData:
+    """
+    Load a WIFF file and return a SciexWiffData object.
+
+    Parameters
+    ----------
+    filename : str
+        Path to the WIFF file
+    **kwargs
+        Additional arguments to pass to SciexWiffData constructor
+
+    Returns
+    -------
+    SciexWiffData
+        Loaded WIFF data object
+    """
+    wiff_data = SciexWiffData(**kwargs)
+    wiff_data.import_raw(filename)
+    return wiff_data
+
+
+def load_wiff2_file(filename: str, **kwargs) -> dict[str, Any]:
+    """
+    Load a WIFF2 file and return spectral data.
+
+    Note: WIFF2 format support is limited with current DLL versions.
+    If you encounter format incompatibility errors, try using the regular
+    WIFF file instead or convert WIFF2 to WIFF format.
+
+    Parameters
+    ----------
+    filename : str
+        Path to the WIFF2 file
+    **kwargs
+        Additional arguments for WIFF2 loading (sample_id, centroid, etc.)
+
+    Returns
+    -------
+    dict
+        Spectral data dictionary with enhanced WIFF2 information
+        
+    Raises
+    ------
+    RuntimeError
+        If WIFF2 format is not supported by current DLL combination
+    """
+    sample_id = kwargs.pop('sample_id', 0)
+    
+    try:
+        with SciexWiff2FileReader(filename) as reader:
+            return reader.load_sample(sample_id, **kwargs)  # type: ignore[no-any-return]
+    except RuntimeError as e:
+        if "format is not supported" in str(e):
+            # Suggest using regular WIFF file if available
+            wiff_file = filename.replace('.wiff2', '.wiff')
+            if os.path.exists(wiff_file):
+                raise RuntimeError(
+                    f"WIFF2 format not supported. However, a regular WIFF file was found: "
+                    f"'{wiff_file}'. Try using load_wiff_file('{wiff_file}') instead."
+                ) from e
+            else:
+                raise RuntimeError(
+                    f"WIFF2 format not supported and no corresponding WIFF file found. "
+                    f"Original error: {e}"
+                ) from e
+        else:
+            raise
+
+
+def load_wiff_file_smart(filename: str, **kwargs) -> dict[str, Any] | SciexWiffData:
+    """
+    Smart WIFF file loader that automatically handles WIFF and WIFF2 formats.
+    
+    This function will first try to load the file as specified, and if it's a WIFF2
+    file that fails due to format incompatibility, it will suggest alternatives.
+
+    Parameters
+    ----------
+    filename : str
+        Path to the WIFF or WIFF2 file
+    **kwargs
+        Additional arguments for loading (sample_id, centroid, etc.)
+
+    Returns
+    -------
+    dict
+        Spectral data dictionary
+    """
+    if filename.lower().endswith('.wiff2'):
+        try:
+            return load_wiff2_file(filename, **kwargs)
+        except RuntimeError as e:
+            if "format is not supported" in str(e):
+                # Check if regular WIFF file exists
+                wiff_file = filename.replace('.wiff2', '.wiff')
+                if os.path.exists(wiff_file):
+                    warnings.warn(
+                        f"WIFF2 format not supported, falling back to WIFF file: {wiff_file}",
+                        stacklevel=2
+                    )
+                    return load_wiff_file(wiff_file, **kwargs)
+            raise
+    else:
+        return load_wiff_file(filename, **kwargs)
+
+
+def get_sample_names(filename: str) -> list:
+    """
+    Get the sample names from a WIFF file.
+
+    Parameters
+    ----------
+    filename : str
+        Path to the WIFF file
+
+    Returns
+    -------
+    list
+        List of sample names
+    """
+    reader = SciexWiffFileReader(filename)
+    try:
+        return list(reader.sample_names)
+    finally:
+        reader.close()
+
+
+def get_wiff2_sample_names(filename: str) -> list:
+    """
+    Get the sample names from a WIFF2 file.
+
+    Parameters
+    ----------
+    filename : str
+        Path to the WIFF2 file
+
+    Returns
+    -------
+    list
+        List of sample names
+    """
+    with SciexWiff2FileReader(filename) as reader:
+        return list(reader.sample_names)
+
+
+def get_wiff2_metadata(filename: str) -> dict[str, Any]:
+    """
+    Get comprehensive metadata from a WIFF2 file.
+
+    Parameters
+    ----------
+    filename : str
+        Path to the WIFF2 file
+
+    Returns
+    -------
+    dict
+        Comprehensive WIFF2 file metadata
+    """
+    with SciexWiff2FileReader(filename) as reader:
+        return reader.get_file_metadata()  # type: ignore[no-any-return]
+
+
+# Example usage and testing
+if __name__ == "__main__":
+    print("Standalone Sciex WIFF reader implementation")
+    print("Usage example:")
+    print("""
+    from sciex import SciexWiffData, load_wiff_file
+
+    # Create reader instance
+    wiff_data = SciexWiffData(centroided=False)
+    wiff_data.import_raw("path/to/file.wiff")
+
+    # Or use convenience function
+    wiff_data = load_wiff_file("path/to/file.wiff")
+
+    # Access spectrum and peak data
+    print(f"Number of spectra: {len(wiff_data.spectrum_df)}")
+    print(f"Number of peaks: {len(wiff_data.peak_df)}")
+
+    # Get peaks for first spectrum
+    mz, intensity = wiff_data.get_peaks(0)
+    """)
+
+    # Test that the module can be imported and classes instantiated
+    try:
+        test_data = SciexWiffData()
+        print(f"✓ SciexWiffData class instantiated successfully: {test_data}")
+        print(f"✓ Has dotnet support: {HAS_DOTNET}")
+
+        # Test with example WIFF file if available
+        example_file = os.path.join(
+            os.path.dirname(__file__),
+            "data",
+            "examples",
+            "2025_01_14_VW_7600_LpMx_DBS_CID_2min_TOP15_030msecMS1_005msecReac_CE35_DBS-ON_3.wiff",
+        )
+
+        if os.path.exists(example_file):
+            print(f"\n✓ Found example WIFF file: {example_file}")
+            print("Testing WIFF file loading...")
+
+            # Test loading the example file
+            wiff_data = load_wiff_file(example_file)
+            print("✓ Successfully loaded WIFF file")
+            print(f"  - Number of spectra: {len(wiff_data.spectrum_df)}")
+            print(f"  - Number of peaks: {len(wiff_data.peak_df)}")
+            print(f"  - Creation time: {wiff_data.creation_time}")
+            print(f"  - File type: {wiff_data.file_type}")
+            print(f"  - Instrument: {wiff_data.instrument}")
+
+            # Test getting peaks from first spectrum
+            if len(wiff_data.spectrum_df) > 0:
+                mz, intensity = wiff_data.get_peaks(0)
+                print(f"  - First spectrum has {len(mz)} peaks")
+                if len(mz) > 0:
+                    print(f"  - m/z range: {mz.min():.2f} - {mz.max():.2f}")
+                    print(
+                        f"  - Intensity range: {intensity.min():.0f} - {intensity.max():.0f}",
+                    )
+        else:
+            print(f"\n⚠ Example WIFF file not found at: {example_file}")
+
+    except Exception as e:
+        print(f"✗ Error during testing: {e}")
+        import traceback
+
+        traceback.print_exc()