BrukerTimsFile.h

Go to the documentation of this file.

// Copyright (c) 2002-present, OpenMS Inc. -- EKU Tuebingen, ETH Zurich, and FU Berlin
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <OpenMS/config.h>
 
#ifdef WITH_OPENTIMS
 
#include <OpenMS/KERNEL/MSExperiment.h>
#include <OpenMS/CONCEPT/ProgressLogger.h>
#include <OpenMS/INTERFACES/IMSDataConsumer.h>
#include <OpenMS/OPENSWATHALGO/DATAACCESS/SwathMap.h>
#include <cstdint>
#include <functional>
#include <limits>
#include <memory>
#include <string>
 
class TimsDataHandle;
 
namespace OpenMS
{
  class FullSwathFileConsumer;
 
  class OPENMS_DLLAPI BrukerTimsFile : public ProgressLogger
  {
  public:
    struct Config
    {
      double calibration_tolerance = 0.0;  
      bool calibrate = false;              
 
      bool load_ms1 = true;                
 
      bool load_ms2 = true;                
 
      uint32_t frame_id_min = 0;
      uint32_t frame_id_max = std::numeric_limits<uint32_t>::max();
 
      double rt_min_sec = 0.0;
      double rt_max_sec = std::numeric_limits<double>::infinity();
 
      bool rt_selects_spectra = false;
 
      double im_min = 0.0;
      double im_max = std::numeric_limits<double>::infinity();
 
      enum class CentroidAlgo { OFF, GREEDY2D, HILL_BASED };
 
      CentroidAlgo ms1_centroid_algo = CentroidAlgo::OFF;
 
      CentroidAlgo ms2_centroid_algo = CentroidAlgo::OFF;
 
      float ms1_centroid_mz_ppm = 10.0f; 
      float ms1_centroid_im_pct = 0.0f;  
      int   ms1_centroid_max_peaks = 100000; 
 
      float  ms2_centroid_mz_ppm        = 20.0f; 
      double centroid_valley_factor     = 1.3;  
      Size   ms1_centroid_min_hill_length = 1;  
      Size   ms2_centroid_min_hill_length = 2;  
      Size   centroid_max_scan_gap        = 0;  
      bool   expose_hill_bounds           = false; 
 
      bool   isotopic_prefilter         = false;
      double isotopic_prefilter_tol_ppm = 50.0;  
 
      int dia_ms2_n_neighbors = 0;  
      int dia_ms2_min_support = 1;  
      bool dia_ms2_centroid = false; 
 
      int    ms1_n_neighbors         = 0;    
      int    ms1_min_support         = 0;    
      double ms1_max_rt_distance_sec = 0.0;  
 
      enum ExportMode { AUTO, SPECTRUM, FRAME };
      ExportMode export_mode = AUTO;       
 
      enum class TimsCalibrationStrategy { AUTO, BRUKER_SDK, RATIONAL, LINEAR };
      TimsCalibrationStrategy tims_calibration_strategy = TimsCalibrationStrategy::AUTO;
 
      enum class PressureCompensation { NONE, GLOBAL, PER_FRAME };
      PressureCompensation pressure_compensation = PressureCompensation::NONE;
 
      std::string bruker_sdk_path;
    };
 
    enum class DataFormat
    {
      NONE,              
      TDF,               
      TSF,               
      BAF,               
      UNREADABLE_ARCHIVE 
    };
 
    static DataFormat detectFormat(const std::string& path);
 
    static void checkDataFormat(const std::string& path);
 
    struct DIAStreamingMetadata
    {
      std::vector<OpenSwath::SwathMap> boundaries;  
      int nr_ms1_spectra = 0;                       
      std::vector<int> nr_ms2_spectra;              
    };
 
    DIAStreamingMetadata readDIAMetadata(const std::string& path, ExperimentalSettings& exp_settings);
    DIAStreamingMetadata readDIAMetadata(const std::string& path, ExperimentalSettings& exp_settings,
                                         const Config& config);
 
    void loadDIAStreaming(const std::string& path, FullSwathFileConsumer& consumer);
    void loadDIAStreaming(const std::string& path, FullSwathFileConsumer& consumer,
                          const Config& config);
 
    void load(const std::string& path, MSExperiment& exp);
    void load(const std::string& path, MSExperiment& exp, const Config& config);
 
    void transform(const std::string& path, Interfaces::IMSDataConsumer* consumer);
    void transform(const std::string& path, Interfaces::IMSDataConsumer* consumer, const Config& config);
 
  private:
    using SpectrumSink = std::function<void(MSSpectrum&)>;
 
    // The public read functions of the same names run these and report SQLite and decoding errors as Exception::ParseError
    DIAStreamingMetadata readDIAMetadata_(const std::string& path, ExperimentalSettings& exp_settings, const Config& config);
    void loadDIAStreaming_(const std::string& path, FullSwathFileConsumer& consumer, const Config& config);
    void load_(const std::string& path, MSExperiment& exp, const Config& config);
    void transform_(const std::string& path, Interfaces::IMSDataConsumer* consumer, const Config& config);
 
    // The loaders emit their spectra in order of retention time, spectra of equal retention time MS1
    // first, unless the configuration is one of the two that transform() names.
 
    void loadDDA_(TimsDataHandle& handle, const SpectrumSink& sink, const Config& config);
 
    void loadDIA_(TimsDataHandle& handle, const SpectrumSink& sink, const Config& config);
 
    void loadFrames_(TimsDataHandle& handle, const SpectrumSink& sink, const Config& config);
 
    struct TSFRun;
 
    void loadTSF_(TSFRun& run, const SpectrumSink& sink);
 
    void loadExperimentalSettings_(const std::string& path, const std::string& d_path, ExperimentalSettings& settings);
 
    struct UnpackedArchive;
 
    static std::shared_ptr<UnpackedArchive> unpack_(const std::string& path);
 
    std::shared_ptr<UnpackedArchive> takeUnpacked_(const std::string& path);
 
    std::shared_ptr<UnpackedArchive> unpacked_;
  };
 
} // namespace OpenMS
 
#endif // WITH_OPENTIMS