XIMParquetFile.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: Justin Sing $
// $Authors: Justin Sing $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/CONCEPT/Types.h>
#include <OpenMS/DATASTRUCTURES/StringUtils.h>
#include <OpenMS/FORMAT/ParquetFilter.h>
 
#include <vector>
 
namespace OpenMS
{
  class OPENMS_DLLAPI XIMParquetFile
  {
  public:
    struct OPENMS_DLLAPI XIMMobilogram
    {
      Int64 run_id{0};
      std::string source_file;
      Int64 ms_level{0};
      std::string mobilogram_type;
 
      bool has_precursor_id{false};
      Int64 precursor_id{0};
      bool has_transition_id{false};
      Int64 transition_id{0};
      bool has_feature_id{false};
      Int64 feature_id{0};
      bool has_feature_rt{false};
      double feature_rt{0.0};
      std::string modified_sequence;
      bool has_precursor_charge{false};
      Int64 precursor_charge{0};
      bool has_product_charge{false};
      Int64 product_charge{0};
      bool has_detecting_transition{false};
      Int64 detecting_transition{0};
      bool has_precursor_decoy{false};
      Int64 precursor_decoy{0};
      bool has_product_decoy{false};
      Int64 product_decoy{0};
      bool has_transition_ordinal{false};
      Int64 transition_ordinal{0};
      std::string transition_type;
      std::string annotation;
 
      std::vector<double> mobility;
      std::vector<double> intensity;
    };
 
    struct OPENMS_DLLAPI XIMRunInfo
    {
      Int64 run_id{0};
      std::string source_file;
    };
 
    struct OPENMS_DLLAPI XIMAnalyte
    {
      bool has_precursor_id{false};
      Int64 precursor_id{0};
      std::string modified_sequence;
      bool has_precursor_charge{false};
      Int64 precursor_charge{0};
      bool has_precursor_decoy{false};
      Int64 precursor_decoy{0};
 
      bool has_transition_id{false};
      Int64 transition_id{0};
      bool has_product_charge{false};
      Int64 product_charge{0};
      bool has_transition_ordinal{false};
      Int64 transition_ordinal{0};
      bool has_detecting_transition{false};
      Int64 detecting_transition{0};
      bool has_product_decoy{false};
      Int64 product_decoy{0};
      std::string transition_type;
      std::string annotation;
 
      std::vector<Int64> transition_ids;
      std::vector<Int64> product_charges;
      std::vector<Int64> transition_ordinals;
      std::vector<Int64> detecting_transitions;
      std::vector<Int64> product_decoys;
      std::vector<std::string> transition_types;
      std::vector<std::string> annotations;
    };
 
    explicit XIMParquetFile(const std::string& filename);
 
    explicit XIMParquetFile(const std::vector<std::string>& filenames);
    XIMParquetFile(const XIMParquetFile& rhs) = default;
    XIMParquetFile& operator=(const XIMParquetFile& rhs) = default;
 
    const std::string& getFilename() const;
 
    const std::vector<std::string>& getFilenames() const;
 
    void load(std::vector<XIMMobilogram>& output) const;
 
    void getMobilograms(std::vector<XIMMobilogram>& output,
                          Int64 precursor_id = -1,
                          Int64 transition_id = -1,
                          const std::string& modified_sequence = "",
                          Int64 precursor_charge = -1,
                          Int64 product_charge = -1,
                          Int64 ms_level = -1,
                          Int64 run_id = -1,
                          const std::string& mobilogram_type = "",
                          Int64 feature_id = -1,
                          double feature_rt = -1.0,
                          const std::string& filter = "") const;
 
    void getMobilograms(std::vector<XIMMobilogram>& output,
                          const ParquetFilter& filter) const;
 
    void getMobilograms(std::vector<XIMMobilogram>& output,
                          const ParquetFilterBuilder& filter) const;
 
    void getRuns(std::vector<XIMRunInfo>& output) const;
 
    void getAnalytes(std::vector<XIMAnalyte>& output,
                     const std::vector<std::string>& columns = {},
                     bool nest_transitions = true) const;
 
    void getColumns(std::vector<std::string>& output) const;
 
  private:
    void getMobilograms_(std::vector<XIMMobilogram>& output,
                           const FilterExpression& extra_filter,
                           Int64 precursor_id,
                           Int64 transition_id,
                           const std::string& modified_sequence,
                           Int64 precursor_charge,
                           Int64 product_charge,
                           Int64 ms_level,
                           Int64 run_id,
                           const std::string& mobilogram_type,
                           Int64 feature_id,
                           double feature_rt,
                           const std::string& filter) const;
 
    std::string filename_;
    std::vector<std::string> filenames_;
  };
 
  typedef XIMParquetFile::XIMMobilogram XIMMobilogram;
  typedef XIMParquetFile::XIMRunInfo XIMRunInfo;
  typedef XIMParquetFile::XIMAnalyte XIMAnalyte;
} // namespace OpenMS