FileInfo.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 $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/config.h>
#include <OpenMS/CONCEPT/ProgressLogger.h>  // ProgressLogger::LogType (nested enum; cannot be forward-declared)
#include <OpenMS/CONCEPT/Types.h>           // Int / UInt / UInt64
#include <OpenMS/FORMAT/FileTypes.h>
#include <OpenMS/MATH/StatisticFunctions.h> // Math::SummaryStatistics
 
#include <cstdint>
#include <iosfwd>
#include <map>
#include <optional>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
 
namespace OpenMS
{
  class OPENMS_DLLAPI FileInfo
  {
  public:
    FileInfo() = default;
    ~FileInfo() = default;
 
    // ---------------------------------------------------------------------
    // nested value types (all pyOpenMS-bindable: plain structs / vector / map)
    // ---------------------------------------------------------------------
 
    struct OPENMS_DLLAPI Range
    {
      bool present = false;
      double min = 0.0;
      double max = 0.0;
    };
 
    struct OPENMS_DLLAPI RangeSet
    {
      Range rt;        
      Range mz;        
      Range mobility;  
      Range intensity;
      bool has_mobility = false; 
    };
 
    struct OPENMS_DLLAPI Ranges
    {
      RangeSet combined;                              
      RangeSet spectra_overall;                       
      std::map<UInt, RangeSet> per_ms_level;          
      RangeSet chromatograms;                         
      bool is_experiment = false;                     
    };
 
    struct OPENMS_DLLAPI FileMeta
    {
      std::string file_name;
      FileTypes::Type file_type = FileTypes::UNKNOWN;
      std::string file_type_name;                     
    };
 
    struct OPENMS_DLLAPI ExperimentMeta
    {
      bool present = false;
      std::string document_id;
      std::string date;
      // sample
      std::string sample_name, sample_organism, sample_comment;
      // instrument
      std::string instrument_name, instrument_model, instrument_vendor;
      std::vector<std::string> ion_sources, mass_analyzers, detectors;
      // contacts
      struct OPENMS_DLLAPI Contact { std::string first_name, last_name, email; };
      std::vector<Contact> contacts;
    };
 
    struct OPENMS_DLLAPI ProcessingStep
    {
      std::string software_name, software_version, completion_time;
      std::vector<std::string> actions;
    };
 
    struct OPENMS_DLLAPI NamedStats
    {
      std::string title;
      Math::SummaryStatistics<std::vector<double>> stats;
    };
 
    struct OPENMS_DLLAPI PeakInfo
    {
      std::string instrument_name;
      std::vector<std::pair<std::string, double>> mass_analyzers;  
      std::vector<Int> ms_levels;
      UInt64 total_peaks = 0;                                  
      UInt64 num_spectra = 0;
      std::map<Int, UInt64> spectra_per_ms_level;
      std::map<Int, std::string> peak_type_per_ms_level;      
      std::map<std::pair<Int, std::string>, UInt64> activation_methods;
      std::map<Int, UInt64> precursor_charges;                
      std::map<std::string, UInt64> float_arrays, int_arrays, string_arrays; 
      std::vector<double> faims_cvs;
      UInt64 num_chromatograms = 0;
      UInt64 num_chrom_peaks = 0;
      std::map<std::string, UInt64> chromatogram_types;       
 
      std::vector<std::tuple<Int, std::string, UInt64>> activationMethodsFlat() const;
    };
 
    struct OPENMS_DLLAPI FeatureInfo
    {
      bool is_consensus = false;
      UInt64 num_features = 0;                       
      double tic = 0.0;                              
      std::map<Int, UInt64> charges;                 
      std::map<UInt64, UInt64> ids_per_element;      
      UInt64 assigned_ids = 0, unassigned_ids = 0;
      // consensus only:
      std::map<UInt64, UInt64> size_distribution;    
      struct OPENMS_DLLAPI MapColumn { std::string filename, identifier, label; UInt64 size = 0; };
      std::vector<MapColumn> map_columns;
    };
 
    struct OPENMS_DLLAPI IdentInfo
    {
      std::string db_name, db_version, taxonomy;
      std::vector<std::string> search_engines;       
      UInt64 num_runs = 0, protein_hits = 0, non_redundant_protein_hits = 0;
      UInt64 matched_spectra = 0, peptide_hits = 0;
      double psms_per_spectrum = 0.0, avg_peptide_length = 0.0;
      UInt64 non_redundant_peptides = 0, modified_tophits = 0;
      std::map<std::string, UInt64> modification_counts;
    };
 
    struct OPENMS_DLLAPI FastaInfo
    {
      UInt64 num_sequences = 0, total_residues = 0;
      bool is_nucleic_acid = false;
      Math::SummaryStatistics<std::vector<double>> length_stats;
      std::map<char, UInt64> residue_counts;
      UInt64 seq_with_ambiguous = 0, dup_headers = 0, dup_sequences = 0;
      std::map<std::string, UInt64> ambiguity_counts; 
    };
 
    struct OPENMS_DLLAPI MzTabInfo
    {
      std::string version, mode, type;
      UInt64 psms = 0, peptides = 0, proteins = 0, oligonucleotides = 0, osms = 0,
             small_molecules = 0, nucleic_acids = 0;
    };
 
    struct OPENMS_DLLAPI ValidationInfo
    {
      bool performed = false, supported = true, valid = false;
      std::string schema_version;
      std::string detail;                            
      std::vector<std::string> warnings, errors;     
      // indexed-mzML (-i)
      bool index_checked = false, index_valid = false;
      UInt64 indexed_spectra = 0, indexed_chromatograms = 0;
    };
 
    struct OPENMS_DLLAPI CorruptionInfo
    {
      bool performed = false;
      std::vector<std::string> errors, warnings;     
    };
 
    struct OPENMS_DLLAPI DetailInfo
    {
      bool performed = false;
      std::vector<std::string> lines;
    };
 
    struct OPENMS_DLLAPI Result
    {
      FileMeta                      meta;
      Ranges                        ranges;          
      std::optional<PeakInfo>       peak;
      std::optional<FeatureInfo>    feature;
      std::optional<IdentInfo>      ident;
      std::optional<FastaInfo>      fasta;
      std::optional<MzTabInfo>      mztab;
      std::optional<ExperimentMeta> experiment_meta;
      std::vector<ProcessingStep>   processing;
      std::vector<NamedStats>       statistics;
      ValidationInfo                validation;
      CorruptionInfo                corruption;
      DetailInfo                    detail;
      std::string                   transformation_summary; 
      std::string                   targeted_summary;       
 
      std::string                   text;
      std::string                   tsv;
    };
 
    struct OPENMS_DLLAPI Options
    {
      FileTypes::Type forced_type = FileTypes::UNKNOWN; 
      bool meta = false;          
      bool processing = false;    
      bool statistics = false;    
      bool detailed = false;      
      bool check_corrupt = false; 
      bool validate = false;      
      bool check_index = false;   
      ProgressLogger::LogType log_type = ProgressLogger::NONE; 
    };
 
    // ---------------------------------------------------------------------
    // public API (all pyOpenMS-bindable)
    // ---------------------------------------------------------------------
 
    Result run(const std::string& filename, const Options& options);
 
    Result run(const std::string& filename) { return run(filename, Options()); }
 
    Result runAll(const std::string& filename);
 
    static std::string toText(const Result& r, const Options& options);
 
    static std::string toText(const Result& r) { return toText(r, Options()); }
 
    static std::string toTSV(const Result& r, const Options& options);
 
    static std::string toTSV(const Result& r) { return toTSV(r, Options()); }
 
  private:
    void report_(const std::string& in, FileTypes::Type in_type, const Options& o,
                 std::ostream& os, std::ostream& os_tsv, Result& r);
  };
} // namespace OpenMS