TargetedExperimentHelper.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: Andreas Bertsch $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/KERNEL/StandardTypes.h>
 
#include <OpenMS/CONCEPT/Types.h>
#include <OpenMS/CONCEPT/Exception.h>
#include <OpenMS/CONCEPT/Macros.h>
 
#include <OpenMS/CHEMISTRY/AASequence.h>
#include <OpenMS/METADATA/CVTerm.h>
#include <OpenMS/METADATA/CVTermList.h>
#include <OpenMS/METADATA/CVTermListInterface.h>
#include <OpenMS/CHEMISTRY/Residue.h>
#include <OpenMS/CONCEPT/HashUtils.h>
 
#include <functional>
 
namespace OpenMS
{
 
  namespace TargetedExperimentHelper
  {
 
    struct Configuration :
      public CVTermList
    {
      std::string contact_ref;
      std::string instrument_ref;
      std::vector<CVTermList> validations;
    };
 
    struct CV
    {
      CV(const std::string & new_id, const std::string & new_fullname, const std::string & new_version, const std::string & new_URI) :
        id(new_id),
        fullname(new_fullname),
        version(new_version),
        URI(new_URI)
      {
 
      }
 
      std::string id;
      std::string fullname;
      std::string version;
      std::string URI;
 
      bool operator==(const CV & cv) const
      {
        return id == cv.id &&
               fullname == cv.fullname &&
               version == cv.version &&
               URI == cv.URI;
      }
 
    };
 
    struct Protein :
      public CVTermList
    {
      Protein() = default;
      bool operator==(const Protein& rhs) const
      {
        return CVTermList::operator==(rhs) &&
          id == rhs.id &&
          sequence == rhs.sequence;
      }
 
      std::string id;
      std::string sequence;
 
    };
 
    class OPENMS_DLLAPI RetentionTime :
      public CVTermListInterface
    {
public:
 
      enum class RTUnit : std::int8_t
      {
        SECOND = 0,        
        MINUTE,            
        UNKNOWN,           
        SIZE_OF_RTUNIT
      };
 
      enum class RTType : std::int8_t
      {
        LOCAL = 0,        
        NORMALIZED,       
        PREDICTED,        
        HPINS,            
        IRT,              
        UNKNOWN,          
        SIZE_OF_RTTYPE
      };
 
      RetentionTime() :
        CVTermListInterface(),
        software_ref(""),
        retention_time_unit(RTUnit::SIZE_OF_RTUNIT),
        retention_time_type(RTType::SIZE_OF_RTTYPE),
        retention_time_set_(false),
        retention_time_(0.0)
        // retention_time_width(0.0),
        // retention_time_lower(0.0),
        // retention_time_upper(0.0)
      {
      }
 
      RetentionTime(const RetentionTime &) = default;
      RetentionTime(RetentionTime &&) noexcept = default;
      virtual ~RetentionTime() = default;
      RetentionTime & operator=(const RetentionTime &) & = default;
      RetentionTime & operator=(RetentionTime &&) & = default;
 
      bool operator==(const RetentionTime & rhs) const
      {
        return CVTermListInterface::operator==(rhs) &&
               software_ref == rhs.software_ref &&
               retention_time_unit == rhs.retention_time_unit &&
               retention_time_type == rhs.retention_time_type &&
               retention_time_set_ == rhs.retention_time_set_ &&
               retention_time_ == rhs.retention_time_;
      }
 
      bool isRTset() const
      {
        return retention_time_set_;
      }
      void setRT(double rt)
      {
        retention_time_ = rt;
        retention_time_set_ = true;
      }
      double getRT() const
      {
        OPENMS_PRECONDITION(isRTset(), "RT needs to be set")
        return retention_time_;
      }
 
      std::string software_ref;
      RTUnit retention_time_unit;
      RTType retention_time_type;
 
private:
 
      bool retention_time_set_;
      double retention_time_;
      // double retention_time_width;
      // double retention_time_lower;
      // double retention_time_upper;
    };
 
    class OPENMS_DLLAPI PeptideCompound :
      public CVTermList
    {
public:
      PeptideCompound() = default;
      PeptideCompound(const PeptideCompound &) = default;
      PeptideCompound(PeptideCompound &&) noexcept = default;
      PeptideCompound & operator=(const PeptideCompound &) & = default;
      PeptideCompound & operator=(PeptideCompound &&) & = default;
 
      bool operator==(const PeptideCompound & rhs) const
      {
        return CVTermList::operator==(rhs) &&
               rts == rhs.rts &&
               id == rhs.id &&
               charge_ == rhs.charge_ &&
               charge_set_ == rhs.charge_set_;
      }
 
      void setChargeState(int charge)
      {
        charge_ = charge;
        charge_set_ = true;
      }
 
      bool hasCharge() const
      {
        return charge_set_;
      }
 
      int getChargeState() const
      {
        OPENMS_PRECONDITION(charge_set_, "Cannot return charge which was never set")
        return charge_;
      }
 
      void setDriftTime(double dt)
      {
        drift_time_ = dt;
      }
 
      double getDriftTime() const
      {
        return drift_time_;
      }
 
 
      bool hasRetentionTime() const
      {
        return (!rts.empty() && rts[0].isRTset());
      }
 
      double getRetentionTime() const
      {
        if (!hasRetentionTime())
        {
          throw Exception::IllegalArgument(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION,
              "No retention time information available");
        }
        return rts[0].getRT();
      }
 
      RetentionTime::RTType getRetentionTimeType() const
      {
        if (!hasRetentionTime())
        {
          throw Exception::IllegalArgument(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION,
              "No retention time information available");
        }
        return rts[0].retention_time_type;
      }
 
      RetentionTime::RTUnit getRetentionTimeUnit() const
      {
        if (!hasRetentionTime())
        {
          throw Exception::IllegalArgument(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION,
              "No retention time information available");
        }
        return rts[0].retention_time_unit;
      }
 
      std::string id;
      std::vector<RetentionTime> rts;
 
protected:
      int charge_{0};
      bool charge_set_{false};
      double drift_time_{-1};
    };
 
    class OPENMS_DLLAPI Compound :
      public PeptideCompound
    {
public:
 
      Compound() :
        theoretical_mass(0.0)
      {
      }
 
      Compound(const Compound &) = default;
      Compound(Compound &&) noexcept = default;
      Compound & operator=(const Compound &) & = default;
      Compound & operator=(Compound &&) & = default;
 
      bool operator==(const Compound & rhs) const
      {
        return PeptideCompound::operator==(rhs) &&
               molecular_formula == rhs.molecular_formula &&
               smiles_string == rhs.smiles_string &&
               theoretical_mass == rhs.theoretical_mass;
      }
 
      std::string molecular_formula;
      std::string smiles_string;
      double theoretical_mass;
 
protected:
 
    };
 
    class OPENMS_DLLAPI Peptide :
      public PeptideCompound
    {
public:
      struct Modification :
        public CVTermListInterface
      {
        double avg_mass_delta;
        double mono_mass_delta;
        Int32 location;
        Int32 unimod_id;
 
        Modification() :
          CVTermListInterface(),
          location(-1),
          unimod_id(-1)
        {
        }
 
      };
 
      Peptide() = default;
      Peptide(const Peptide &) = default;
      Peptide(Peptide &&) noexcept = default;
      Peptide & operator=(const Peptide &) & = default;
      Peptide & operator=(Peptide &&) & = default;
 
      bool operator==(const Peptide & rhs) const
      {
        return PeptideCompound::operator==(rhs) &&
               protein_refs == rhs.protein_refs &&
               evidence == rhs.evidence &&
               sequence == rhs.sequence &&
               mods == rhs.mods &&
               peptide_group_label_ == rhs.peptide_group_label_;
      }
 
      void setPeptideGroupLabel(const std::string & label)
      {
        peptide_group_label_ = label;
      }
 
      std::string getPeptideGroupLabel() const
      {
        return peptide_group_label_;
      }
 
      std::vector<std::string> protein_refs;
      CVTermList evidence;
      std::string sequence;
      std::vector<Modification> mods;
 
protected:
      std::string peptide_group_label_;
    };
 
    struct OPENMS_DLLAPI Contact :
      public CVTermList
    {
      Contact() :
        CVTermList()
      {
      }
 
      bool operator==(const Contact & rhs) const
      {
        return CVTermList::operator==(rhs) &&
               id == rhs.id;
      }
 
      std::string id;
    };
 
    struct OPENMS_DLLAPI Publication :
      public CVTermList
    {
      Publication() :
        CVTermList()
      {
      }
 
      bool operator==(const Publication & rhs) const
      {
        return CVTermList::operator==(rhs) &&
               id == rhs.id;
      }
 
      std::string id;
    };
 
    struct OPENMS_DLLAPI Instrument :
      public CVTermList
    {
      Instrument() :
        CVTermList()
      {
      }
 
      bool operator==(const Instrument & rhs) const
      {
        return CVTermList::operator==(rhs) &&
               id == rhs.id;
      }
 
      std::string id;
    };
 
    struct OPENMS_DLLAPI Prediction :
      public CVTermList
    {
      Prediction() :
        CVTermList()
      {
      }
 
      bool operator==(const Prediction & rhs) const
      {
        return CVTermList::operator==(rhs) &&
               contact_ref == rhs.contact_ref &&
               software_ref == rhs.software_ref;
      }
 
      std::string software_ref;
      std::string contact_ref;
    };
 
    struct OPENMS_DLLAPI Interpretation :
      public CVTermListInterface
    {
 
      /*
      enum ResidueType
      {
        Full = 0,       // with N-terminus and C-terminus
        Internal,       // internal, without any termini
        NTerminal,      // only N-terminus
        CTerminal,      // only C-terminus
        AIon,           // MS:1001229 N-terminus up to the C-alpha/carbonyl carbon bond
        BIon,           // MS:1001224 N-terminus up to the peptide bond
        CIon,           // MS:1001231 N-terminus up to the amide/C-alpha bond
        XIon,           // MS:1001228 amide/C-alpha bond up to the C-terminus
        YIon,           // MS:1001220 peptide bond up to the C-terminus
        ZIon,           // MS:1001230 C-alpha/carbonyl carbon bond
        Precursor,      // MS:1001523 Precursor ion
        BIonMinusH20,   // MS:1001222 b ion without water
        YIonMinusH20,   // MS:1001223 y ion without water
        BIonMinusNH3,   // MS:1001232 b ion without ammonia
        YIonMinusNH3,   // MS:1001233 y ion without ammonia
        NonIdentified,  // MS:1001240 Non-identified ion
        Unannotated,    // no stored annotation
        SizeOfResidueType
      };
      */
 
      typedef Residue::ResidueType IonType; 
 
      unsigned char ordinal; 
      unsigned char rank; 
      IonType iontype; 
 
      // Constructor
      Interpretation() :
        CVTermListInterface(),
        ordinal(0),
        rank(0),
        iontype(Residue::Unannotated) // Unannotated does not imply any MS OBO term
      {
      }
 
      bool operator==(const Interpretation & rhs) const
      {
        return CVTermListInterface::operator==(rhs) &&
               ordinal == rhs.ordinal &&
               rank == rhs.rank &&
               iontype == rhs.iontype;
      }
 
      bool operator!=(const Interpretation & rhs) const
      {
        return !(operator==(rhs));
      }
 
    };
 
    struct OPENMS_DLLAPI TraMLProduct :
      public CVTermListInterface
    {
      TraMLProduct() = default;
      bool operator==(const TraMLProduct & rhs) const
      {
        return CVTermListInterface::operator==(rhs) &&
               charge_ == rhs.charge_ &&
               charge_set_ == rhs.charge_set_ &&
               mz_ == rhs.mz_ &&
               configuration_list_ == rhs.configuration_list_ &&
               interpretation_list_ == rhs.interpretation_list_;
      }
 
      void setChargeState(int charge)
      {
        charge_ = charge;
        charge_set_ = true;
      }
 
      bool hasCharge() const
      {
        return charge_set_;
      }
 
      int getChargeState() const
      {
        OPENMS_PRECONDITION(charge_set_, "Cannot return charge which was never set")
        return charge_;
      }
 
      double getMZ() const
      {
        return mz_;
      }
 
      void setMZ(double mz)
      {
        mz_ = mz;
      }
 
      const std::vector<Configuration> & getConfigurationList() const
      {
        return configuration_list_;
      }
 
      void addConfiguration(const Configuration& configuration)
      {
        configuration_list_.push_back(configuration);
      }
 
      const std::vector<Interpretation> & getInterpretationList() const
      {
        return interpretation_list_;
      }
 
      void addInterpretation(const Interpretation& interpretation)
      {
        interpretation_list_.push_back(interpretation);
      }
 
      void resetInterpretations()
      {
        return interpretation_list_.clear();
      }
 
private:
      int charge_{0}; 
      bool charge_set_{false}; 
      double mz_{0}; 
      std::vector<Configuration> configuration_list_; 
      std::vector<Interpretation> interpretation_list_;  
    };
 
    OPENMS_DLLAPI OpenMS::AASequence getAASequence(const Peptide& peptide);
 
    OPENMS_DLLAPI void setModification(int location, int max_size, const std::string& modification, OpenMS::AASequence & aas);
 
  }
 
  // hashCVTerms and hashCVTermList are defined in CVTermList.h
 
  // Convenience wrapper for backward compatibility
  inline std::size_t hashCVTermListInterface(const CVTermListInterface& cvtli) noexcept { return hashCVTerms(cvtli); }
 
} // namespace OpenMS
 
// Hash function specializations for TargetedExperimentHelper classes
// Placed in std namespace to allow use with std::unordered_map/set
namespace std
{
  template<>
  struct hash<OpenMS::TargetedExperimentHelper::CV>
  {
    std::size_t operator()(const OpenMS::TargetedExperimentHelper::CV& cv) const noexcept
    {
      std::size_t seed = 0;
      OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(cv.id));
      OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(cv.fullname));
      OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(cv.version));
      OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(cv.URI));
      return seed;
    }
  };
 
  template<>
  struct hash<OpenMS::TargetedExperimentHelper::Protein>
  {
    std::size_t operator()(const OpenMS::TargetedExperimentHelper::Protein& protein) const noexcept
    {
      std::size_t seed = OpenMS::hashCVTermList(protein);
      OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(protein.id));
      OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(protein.sequence));
      return seed;
    }
  };
 
  template<>
  struct hash<OpenMS::TargetedExperimentHelper::RetentionTime>
  {
    std::size_t operator()(const OpenMS::TargetedExperimentHelper::RetentionTime& rt) const noexcept
    {
      std::size_t seed = OpenMS::hashCVTermListInterface(rt);
      OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(rt.software_ref));
      OpenMS::hash_combine(seed, OpenMS::hash_int(static_cast<std::int8_t>(rt.retention_time_unit)));
      OpenMS::hash_combine(seed, OpenMS::hash_int(static_cast<std::int8_t>(rt.retention_time_type)));
      OpenMS::hash_combine(seed, OpenMS::hash_int(rt.isRTset() ? 1 : 0));
      if (rt.isRTset())
      {
        OpenMS::hash_combine(seed, OpenMS::hash_float(rt.getRT()));
      }
      return seed;
    }
  };
 
  template<>
  struct hash<OpenMS::TargetedExperimentHelper::PeptideCompound>
  {
    std::size_t operator()(const OpenMS::TargetedExperimentHelper::PeptideCompound& pc) const noexcept
    {
      std::size_t seed = OpenMS::hashCVTermList(pc);
      for (const auto& rt : pc.rts)
      {
        OpenMS::hash_combine(seed, std::hash<OpenMS::TargetedExperimentHelper::RetentionTime>{}(rt));
      }
      OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(pc.id));
      OpenMS::hash_combine(seed, OpenMS::hash_int(pc.hasCharge() ? 1 : 0));
      if (pc.hasCharge())
      {
        OpenMS::hash_combine(seed, OpenMS::hash_int(pc.getChargeState()));
      }
      return seed;
    }
  };
 
  template<>
  struct hash<OpenMS::TargetedExperimentHelper::Compound>
  {
    std::size_t operator()(const OpenMS::TargetedExperimentHelper::Compound& compound) const noexcept
    {
      std::size_t seed = std::hash<OpenMS::TargetedExperimentHelper::PeptideCompound>{}(compound);
      OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(compound.molecular_formula));
      OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(compound.smiles_string));
      OpenMS::hash_combine(seed, OpenMS::hash_float(compound.theoretical_mass));
      return seed;
    }
  };
 
  template<>
  struct hash<OpenMS::TargetedExperimentHelper::Peptide>
  {
    std::size_t operator()(const OpenMS::TargetedExperimentHelper::Peptide& peptide) const noexcept
    {
      std::size_t seed = std::hash<OpenMS::TargetedExperimentHelper::PeptideCompound>{}(peptide);
      for (const auto& ref : peptide.protein_refs)
      {
        OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(ref));
      }
      OpenMS::hash_combine(seed, OpenMS::hashCVTermList(peptide.evidence));
      OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(peptide.sequence));
      for (const auto& mod : peptide.mods)
      {
        OpenMS::hash_combine(seed, OpenMS::hashCVTermListInterface(mod));
        OpenMS::hash_combine(seed, OpenMS::hash_float(mod.avg_mass_delta));
        OpenMS::hash_combine(seed, OpenMS::hash_float(mod.mono_mass_delta));
        OpenMS::hash_combine(seed, OpenMS::hash_int(mod.location));
        OpenMS::hash_combine(seed, OpenMS::hash_int(mod.unimod_id));
      }
      OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(peptide.getPeptideGroupLabel()));
      return seed;
    }
  };
 
  template<>
  struct hash<OpenMS::TargetedExperimentHelper::Contact>
  {
    std::size_t operator()(const OpenMS::TargetedExperimentHelper::Contact& contact) const noexcept
    {
      std::size_t seed = OpenMS::hashCVTermList(contact);
      OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(contact.id));
      return seed;
    }
  };
 
  template<>
  struct hash<OpenMS::TargetedExperimentHelper::Publication>
  {
    std::size_t operator()(const OpenMS::TargetedExperimentHelper::Publication& pub) const noexcept
    {
      std::size_t seed = OpenMS::hashCVTermList(pub);
      OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(pub.id));
      return seed;
    }
  };
 
  template<>
  struct hash<OpenMS::TargetedExperimentHelper::Instrument>
  {
    std::size_t operator()(const OpenMS::TargetedExperimentHelper::Instrument& inst) const noexcept
    {
      std::size_t seed = OpenMS::hashCVTermList(inst);
      OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(inst.id));
      return seed;
    }
  };
 
  template<>
  struct hash<OpenMS::TargetedExperimentHelper::Prediction>
  {
    std::size_t operator()(const OpenMS::TargetedExperimentHelper::Prediction& pred) const noexcept
    {
      std::size_t seed = OpenMS::hashCVTermList(pred);
      OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(pred.software_ref));
      OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(pred.contact_ref));
      return seed;
    }
  };
 
  template<>
  struct hash<OpenMS::TargetedExperimentHelper::Interpretation>
  {
    std::size_t operator()(const OpenMS::TargetedExperimentHelper::Interpretation& interp) const noexcept
    {
      std::size_t seed = OpenMS::hashCVTermListInterface(interp);
      OpenMS::hash_combine(seed, OpenMS::hash_int(interp.ordinal));
      OpenMS::hash_combine(seed, OpenMS::hash_int(interp.rank));
      OpenMS::hash_combine(seed, OpenMS::hash_int(static_cast<int>(interp.iontype)));
      return seed;
    }
  };
 
  template<>
  struct hash<OpenMS::TargetedExperimentHelper::TraMLProduct>
  {
    std::size_t operator()(const OpenMS::TargetedExperimentHelper::TraMLProduct& product) const noexcept
    {
      std::size_t seed = OpenMS::hashCVTermListInterface(product);
      OpenMS::hash_combine(seed, OpenMS::hash_int(product.hasCharge() ? 1 : 0));
      if (product.hasCharge())
      {
        OpenMS::hash_combine(seed, OpenMS::hash_int(product.getChargeState()));
      }
      OpenMS::hash_combine(seed, OpenMS::hash_float(product.getMZ()));
      // Hash configuration_list_ (required for consistency with operator==)
      for (const auto& config : product.getConfigurationList())
      {
        OpenMS::hash_combine(seed, OpenMS::hashCVTermList(config));
        OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(config.contact_ref));
        OpenMS::hash_combine(seed, OpenMS::fnv1a_hash_string(config.instrument_ref));
        for (const auto& validation : config.validations)
        {
          OpenMS::hash_combine(seed, OpenMS::hashCVTermList(validation));
        }
      }
      for (const auto& interp : product.getInterpretationList())
      {
        OpenMS::hash_combine(seed, std::hash<OpenMS::TargetedExperimentHelper::Interpretation>{}(interp));
      }
      return seed;
    }
  };
 
} // namespace std