OSWData.h

Go to the documentation of this file.

// --------------------------------------------------------------------------
//                   OpenMS -- Open-Source Mass Spectrometry
// --------------------------------------------------------------------------
// Copyright The OpenMS Team -- Eberhard Karls University Tuebingen,
// ETH Zurich, and Freie Universitaet Berlin 2002-2022.
//
// This software is released under a three-clause BSD license:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of any author or any participating institution
//    may be used to endorse or promote products derived from this software
//    without specific prior written permission.
// For a full list of authors, refer to the file AUTHORS.
// --------------------------------------------------------------------------
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL ANY OF THE AUTHORS OR THE CONTRIBUTING
// INSTITUTIONS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// --------------------------------------------------------------------------
// $Maintainer: Chris Bielow $
// $Authors: Chris Bielow $
// --------------------------------------------------------------------------

#pragma once

#include <OpenMS/DATASTRUCTURES/String.h>

#include <map>
#include <vector>

namespace OpenMS
{
    class MSExperiment;

    struct OPENMS_DLLAPI OSWHierarchy
    {
      enum Level
      {
        PROTEIN,
        PEPTIDE,
        FEATURE,
        TRANSITION,
        SIZE_OF_VALUES
      };
      static const char* LevelName[SIZE_OF_VALUES];
    };

    struct OPENMS_DLLAPI OSWIndexTrace
    {
      int idx_prot = -1;
      int idx_pep = -1;
      int idx_feat = -1;
      int idx_trans = -1;
      OSWHierarchy::Level lowest = OSWHierarchy::Level::SIZE_OF_VALUES;

      bool isSet() const
      {
        return lowest != OSWHierarchy::Level::SIZE_OF_VALUES;
      }

    };

    struct OPENMS_DLLAPI OSWTransition
    {
      public:
        OSWTransition() = default;
        OSWTransition(const String& annotation, const UInt32 id, const float product_mz, const char type, const bool is_decoy);
        OSWTransition(const OSWTransition& rhs) = default;
        OSWTransition& operator=(const OSWTransition& rhs) = default;
        OSWTransition(OSWTransition&& rhs) = default;
        OSWTransition& operator=(OSWTransition&& rhs) = default;
        ~OSWTransition() = default;

        const String& getAnnotation() const
        {
          return annotation_;
        }
        UInt32 getID() const
        {
          return id_;
        }
        float getProductMZ() const
        {
          return product_mz_;
        }
        char getType() const
        {
          return type_;
        }
        bool isDecoy() const
        {
          return is_decoy_;
        }

      private:
        String annotation_; 
        UInt32 id_;         
        float product_mz_;  
        char type_;         
        bool is_decoy_;     
    };

    class OPENMS_DLLAPI OSWPeakGroup
    {
      public:
        static constexpr float QVALUE_MISSING = -1;

        OSWPeakGroup() = default;
        
        OSWPeakGroup(const float rt_experimental, const float rt_left_width, const float rt_right_width, const float rt_delta, std::vector<UInt32>&& transition_ids, const float q_value = -1);
        
        OSWPeakGroup(const OSWPeakGroup& rhs) = default;
        
        OSWPeakGroup& operator=(const OSWPeakGroup& rhs) = default;

        OSWPeakGroup(OSWPeakGroup&& rhs) = default;
        
        OSWPeakGroup& operator=(OSWPeakGroup&& rhs) = default;

        float getRTExperimental() const
        {
          return rt_experimental_;
        }
        float getRTLeftWidth() const
        {
          return rt_left_width_;
        }
        float getRTRightWidth() const
        {
          return rt_right_width_;
        }
        float getRTDelta() const
        {
          return rt_delta_;
        }
        float getQValue() const
        {
          return q_value_;
        }
        const std::vector<UInt32>& getTransitionIDs() const
        {
          return transition_ids_;
        }

      private:
        float rt_experimental_{ 0 }; 
        float rt_left_width_{ 0 };   
        float rt_right_width_{ 0 };  
        float rt_delta_{ 0 };        
        float q_value_{ -1 };        
        std::vector<UInt32> transition_ids_; 
    };

    class OPENMS_DLLAPI OSWPeptidePrecursor
    {
      public:
        OSWPeptidePrecursor() = default;
        OSWPeptidePrecursor(const String& seq, const short charge, const bool decoy, const float precursor_mz, std::vector<OSWPeakGroup>&& features);
        OSWPeptidePrecursor(const OSWPeptidePrecursor& rhs) = default;
        OSWPeptidePrecursor& operator=(const OSWPeptidePrecursor& rhs) = default;
        OSWPeptidePrecursor(OSWPeptidePrecursor&& rhs) = default;
        OSWPeptidePrecursor& operator=(OSWPeptidePrecursor&& rhs) = default;

        const String& getSequence() const
        {
          return seq_;
        }
        short getCharge() const
        {
          return charge_;
        }
        bool isDecoy() const
        {
          return decoy_;
        }
        float getPCMz() const
        {
          return precursor_mz_;
        }
        const std::vector<OSWPeakGroup>& getFeatures() const
        {
          return features_;
        }

      private:
        String seq_;
        short charge_{0};
        bool decoy_{false};
        float precursor_mz_{0};
        std::vector<OSWPeakGroup> features_;
    };

    class OPENMS_DLLAPI OSWProtein
    {
      public:
        OSWProtein() = default;
        OSWProtein(const String& accession, const Size id, std::vector<OSWPeptidePrecursor>&& peptides);
        OSWProtein(const OSWProtein& rhs) = default;
        OSWProtein& operator=(const OSWProtein& rhs) = default;
        OSWProtein(OSWProtein&& rhs) = default;
        OSWProtein& operator=(OSWProtein&& rhs) = default;

        const String& getAccession() const
        {
          return accession_;
        }

        Size getID() const
        {
          return id_;
        }

        const std::vector<OSWPeptidePrecursor>& getPeptidePrecursors() const
        {
          return peptides_;
        }

      private:
        String accession_;
        Size id_;
        std::vector<OSWPeptidePrecursor> peptides_;
    };


    class OPENMS_DLLAPI OSWData
    {
      public:
        void addTransition(const OSWTransition& tr)
        {
          transitions_.emplace(tr.getID(), tr);
        }

        void addTransition(OSWTransition&& tr)
        {
          UInt32 id = tr.getID();
          transitions_.emplace(id, std::move(tr));
        }

        void addProtein(OSWProtein&& prot);

        const std::vector<OSWProtein>& getProteins() const
        {
          return proteins_;
        }

        void setProtein(const Size index, OSWProtein&& protein)
        {
          checkTransitions_(protein);
          proteins_[index] = std::move(protein);
        }

        Size transitionCount() const
        {
          return transitions_.size();
        }

        const OSWTransition& getTransition(const UInt32 id) const
        {
          return transitions_.at(id);
        }
        
        const std::map<UInt32, OSWTransition>& getTransitions() const
        {
          return transitions_;
        }

        void setSqlSourceFile(const String& filename)
        {
          source_file_ = filename;
        }

        const String& getSqlSourceFile() const
        {
          return source_file_;
        }

        void setRunID(const UInt64 run_id)
        {
          run_id_ = run_id;
        }

        UInt64 getRunID() const
        {
          return run_id_;
        }

        void clear();

        void clearProteins();

        void buildNativeIDResolver(const MSExperiment& chrom_traces);

        UInt fromNativeID(int transition_id) const;

      protected:
        void checkTransitions_(const OSWProtein& prot) const;

      private:
        std::map<UInt32, OSWTransition> transitions_;
        std::vector<OSWProtein> proteins_;
        String source_file_;                        
        UInt64 run_id_;                             
        std::map<UInt32, UInt32> transID_to_index_; 
    };
    

} // namespace OpenMS