DIAQCMetrics.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
//
// --------------------------------------------------------------------------
// $Maintainer: Timo Sachsenberg $
// $Authors: Timo Sachsenberg, David L. Tabb $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/CONCEPT/Types.h>
#include <OpenMS/FORMAT/FileTypes.h>
 
#include <array>
#include <iosfwd>
#include <string>
#include <vector>
 
namespace OpenMS
{
  class ExperimentalSettings;
  class MSSpectrum;
 
  class DIAQCMetrics
  {
  public:
    enum class TICSource
    {
      AUTO,     
      FILE,     
      COMPUTED  
    };
 
    enum class PeakCountMode
    {
      ALL,      
      NONZERO   
    };
 
    enum class IonMobilityKey
    {
      AUTO,     
      FAIMS,    
      NONE      
    };
 
    struct Options
    {
      TICSource tic_source = TICSource::AUTO;
      PeakCountMode peak_count = PeakCountMode::ALL;
      IonMobilityKey ion_mobility = IonMobilityKey::AUTO;
    };
 
    using PeakCountSummary = std::array<double, 5>;
 
    using TICQuantileRTs = std::array<double, 3>;
 
    struct WindowMetrics
    {
      bool has_isolation_window = false;  
      double target_mz;                   
      double lower_mz;                    
      double upper_mz;                    
      double width_mz;                    
      double faims_cv;                    
      double ion_mobility_lower;          
      double ion_mobility_upper;          
      double mass_resolving_power;        
      Size spectrum_count = 0;
      double rt_min;                      
      double rt_max;                      
      double cycle_time_median;           
      TICQuantileRTs tic_quantile_rt;
      double total_tic = 0.0;
      PeakCountSummary peak_count;
 
      WindowMetrics();
    };
 
    struct RunMetrics
    {
      std::string source_file;            
      std::string input_path;             
      FileTypes::Type input_type = FileTypes::MZML; 
      std::string file_sha1;              
      std::string instrument;             
      std::string serial_number;          
      std::string start_time_stamp;       
 
      double rt_min;                      
      double rt_max;                      
      Size ms1_count = 0;
      Size msn_count = 0;                 
      Size ms2_count = 0;                 
      Size spectra_without_rt = 0;        
      Size ms2_multiple_precursors = 0;   
      Size ms2_scan_ion_mobility = 0;     
      Size ms2_im_array_without_range = 0; 
      double precursor_mz_min;            
      double precursor_mz_max;            
 
      double ms1_mass_resolving_power;    
      TICQuantileRTs ms1_tic_quantile_rt;
      double ms1_total_tic = 0.0;
      double ms1_cycle_time_median;
      PeakCountSummary ms1_peak_count;
 
      TICQuantileRTs ms2_tic_quantile_rt;
      double ms2_total_tic = 0.0;
      PeakCountSummary ms2_peak_count;
 
      Size window_count = 0;              
      Size windows_measured_once = 0;     
      double window_spectra_min;          
      double window_spectra_max;          
      double window_mz_min;               
      double window_mz_max;               
      double window_width_min;
      double window_width_max;
      double window_cycle_time_mean;      
      double window_cycle_time_median;    
      double window_half_tic_rt_min;      
      double window_half_tic_rt_max;      
      double window_total_tic_min;
      double window_total_tic_max;
      double window_peak_count_median_min;
      double window_peak_count_median_max;
 
      std::vector<WindowMetrics> windows;  
 
      WindowMetrics without_isolation_window;
 
      RunMetrics();
    };
 
    DIAQCMetrics();
 
    explicit DIAQCMetrics(const Options& options);
 
    void setExperimentalSettings(const ExperimentalSettings& settings);
 
    void addSpectrum(const MSSpectrum& spectrum);
 
    Size size() const;
 
    RunMetrics compute() const;
 
    void clear();
 
    static void writeRunTable(const std::vector<RunMetrics>& runs, std::ostream& os);
 
    static void writeWindowTable(const std::vector<RunMetrics>& runs, std::ostream& os);
 
    static void writeMzQC(const std::vector<RunMetrics>& runs, std::ostream& os, const std::string& software_version, const std::string& creation_date);
 
  private:
    struct SpectrumRecord
    {
      double rt = 0.0;
      UInt ms_level = 0;
      double tic = 0.0;
      Size peak_count = 0;
      double mass_resolving_power = 0.0;  // NaN if not annotated
      bool has_isolation_window = false;
      double precursor_mz = 0.0;          // NaN if none
      double target_mz = 0.0;
      double lower_offset = 0.0;
      double upper_offset = 0.0;
      double faims_cv = 0.0;              // NaN if none
      double ion_mobility_lower = 0.0;    // NaN if none
      double ion_mobility_upper = 0.0;    // NaN if none
      bool scan_ion_mobility = false;     // the spectrum looks like a single ion mobility scan
      bool im_array_without_range = false; // an ion mobility array, but no ion mobility range of the window
      Size precursor_count = 0;
    };
 
    struct GroupStatistics;
 
    Options options_;
    std::vector<SpectrumRecord> records_;
    std::string instrument_;
    std::string serial_number_;
    std::string start_time_stamp_;
  };
} // namespace OpenMS