MzIdentMLDOMHandler.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: Mathias Walzer $
// $Authors: Mathias Walzer$
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/CHEMISTRY/AASequence.h>
#include <OpenMS/CONCEPT/UniqueIdGenerator.h>
#include <OpenMS/FORMAT/ControlledVocabulary.h>
#include <OpenMS/FORMAT/HANDLERS/XMLHandler.h>
#include <OpenMS/KERNEL/StandardTypes.h>
#include <OpenMS/METADATA/CVTermList.h>
#include <OpenMS/METADATA/PeptideIdentification.h>
#include <OpenMS/METADATA/PeptideIdentificationList.h>
#include <OpenMS/METADATA/ProteinHit.h>
#include <OpenMS/METADATA/ProteinIdentification.h>
 
 
#include <list>
 
struct _xmlNode;
typedef struct _xmlNode xmlNode;
#include <map>
#include <set>
#include <stdexcept>
#include <string>
#include <vector>
 
namespace OpenMS
{
  class ProgressLogger;
 
  namespace Internal
  {
    class OPENMS_DLLAPI MzIdentMLDOMHandler
    {
public:
      MzIdentMLDOMHandler(const std::vector<ProteinIdentification>& pro_id, const PeptideIdentificationList& pep_id, const std::string& version, const ProgressLogger& logger);
 
      MzIdentMLDOMHandler(std::vector<ProteinIdentification>& pro_id, PeptideIdentificationList& pep_id, const std::string& version, const ProgressLogger& logger);
 
      virtual ~MzIdentMLDOMHandler();
 
      void readMzIdentMLFile(const std::string& mzid_file);
      void writeMzIdentMLFile(const std::string& mzid_file);
 
protected:
      const ProgressLogger& logger_;
 
      ControlledVocabulary cv_;
      ControlledVocabulary unimod_;
 
      std::vector<ProteinIdentification>* pro_id_ = nullptr;
      PeptideIdentificationList* pep_id_ = nullptr;
 
      const std::vector<ProteinIdentification>* cpro_id_ = nullptr;
      const PeptideIdentificationList* cpep_id_ = nullptr;
 
      const std::string schema_version_;
 
      ControlledVocabulary::CVTerm getChildWithName_(const std::string& parent_accession, const std::string& name) const;
 
      void initScoreTermCaches_();
 
 
      std::pair<CVTermList, std::map<std::string, DataValue> > parseParamGroup_(const std::vector<xmlNode*>& paramGroup);
      CVTerm parseCvParam_(xmlNode* param);
      std::pair<std::string, DataValue> parseUserParam_(xmlNode* param);
      void parseAnalysisSoftwareList_(const std::vector<xmlNode*>& analysisSoftwareElements);
      void parseDBSequenceElements_(const std::vector<xmlNode*>& dbSequenceElements);
      void parsePeptideElements_(const std::vector<xmlNode*>& peptideElements);
      //AASequence parsePeptideSiblings_(const std::vector<xmlNode*>& peptideSiblings);
      AASequence parsePeptideSiblings_(xmlNode* peptide);
      SignedSize inferModificationLocation_(xmlNode* modification_element, Size peptide_length) const;
      void parsePeptideEvidenceElements_(const std::vector<xmlNode*>& peptideEvidenceElements);
      void parseSpectrumIdentificationElements_(const std::vector<xmlNode*>& spectrumIdentificationElements);
      void parseSpectrumIdentificationProtocolElements_(const std::vector<xmlNode*>& spectrumIdentificationProtocolElements);
      void parseInputElements_(const std::vector<xmlNode*>& inputElements);
      void parseSpectrumIdentificationListElements_(const std::vector<xmlNode*>& spectrumIdentificationListElements);
      ProteinIdentification& runOfList_(const std::string& spectrum_identification_list_ref);
      void parseSpectrumIdentificationItemSetXLMS(std::set<std::string>::const_iterator set_it, std::multimap<std::string, int> xl_val_map, xmlNode* element_res, const std::string& spectrumID);
      void parseSpectrumIdentificationItemElement_(xmlNode* spectrumIdentificationItemElement, PeptideIdentification& spectrum_identification, std::string& spectrumIdentificationList_ref);
      void parseProteinDetectionHypothesisElement_(xmlNode* proteinDetectionHypothesisElement, ProteinIdentification& protein_identification);
      void parseProteinAmbiguityGroupElement_(xmlNode* proteinAmbiguityGroupElement, ProteinIdentification& protein_identification);
      void parseProteinDetectionListElements_(const std::vector<xmlNode*>& proteinDetectionListElements);
      static ProteinIdentification::SearchParameters findSearchParameters_(std::pair<CVTermList, std::map<std::string, DataValue> > as_params);
 
      void buildCvList_(xmlNode* cvElements);
      void buildAnalysisSoftwareList_(xmlNode* analysisSoftwareElements);
      void buildSequenceCollection_(xmlNode* sequenceCollectionElements);
      void buildAnalysisCollection_(xmlNode* analysisCollectionElements);
      void buildAnalysisProtocolCollection_(xmlNode* protocolElements);
      void buildInputDataCollection_(xmlNode* inputElements);
      void buildEnclosedCV_(xmlNode* parentElement, const std::string& encel, const std::string& acc, const std::string& name, const std::string& cvref);
      void buildAnalysisDataCollection_(xmlNode* analysisElements);
 
 
private:
      MzIdentMLDOMHandler();
      MzIdentMLDOMHandler(const MzIdentMLDOMHandler& rhs);
      MzIdentMLDOMHandler& operator=(const MzIdentMLDOMHandler& rhs);
 
      struct AnalysisSoftware
      {
        std::string name;
        std::string version;
      };
      struct PeptideEvidence
      {
        int start;
        int stop;
        char pre;
        char post;
        bool idec;
      };
      struct DBSequence
      {
        std::string sequence;
        std::string database_ref;
        std::string accession;
        CVTermList cvs;
      };
      struct SpectrumIdentification
      {
        std::string spectra_data_ref;
        std::string search_database_ref;
        std::string spectrum_identification_protocol_ref;
        std::string spectrum_identification_list_ref;
      };
      struct ModificationParam
      {
        std::string fixed_mod;
        long double mass_delta;
        std::string residues;
        CVTermList modification_param_cvs;
        CVTermList specificities;
      };
      struct SpectrumIdentificationProtocol
      {
        CVTerm searchtype;
        std::string enzyme;
        CVTermList parameter_cvs;
        std::map<std::string, DataValue> parameter_ups;
//        std::vector<ModificationParam> modification_parameter;
        CVTermList modification_parameter;
        long double precursor_tolerance;
        long double fragment_tolerance;
        CVTermList threshold_cvs;
        std::map<std::string, DataValue> threshold_ups;
      };
      struct DatabaseInput
      {
        std::string name;
        std::string location;
        std::string version;
        DateTime date;
      };
 
 
      std::unique_ptr<XMLHandler> xml_handler_ = nullptr;
 
      //from AnalysisSoftware
      std::string search_engine_;
      std::string search_engine_version_;
      //mapping from AnalysisSoftware
      std::map<std::string, AnalysisSoftware> as_map_; 
 
      //mapping from DataCollection Inputs
      std::map<std::string, std::string> sr_map_; 
      std::map<std::string, std::string> sd_map_; 
      std::map<std::string, DatabaseInput> db_map_; 
 
      //mapping from SpectrumIdentification - SpectrumIdentification will be the new IdentificationRuns
      std::map<std::string, SpectrumIdentification> si_map_; 
      std::map<std::string, size_t> si_pro_map_; 
 
      //mapping from SpectrumIdentificationProtocol
      std::map<std::string, SpectrumIdentificationProtocol> sp_map_; 
 
      //mapping from SequenceCollection
      std::map<std::string, AASequence> pep_map_; 
      std::map<std::string, PeptideEvidence> pe_ev_map_; 
      std::map<std::string, std::string> pv_db_map_; 
      std::multimap<std::string, std::string> p_pv_map_; 
      std::map<std::string, DBSequence> db_sq_map_; 
 
      std::list<std::list<std::string> > hit_pev_; 
 
      bool xl_ms_search_ = false; 
      std::map<std::string, std::string> xl_id_donor_map_; 
      //std::map<std::string, std::string> xl_id_acceptor_map_; ///< mapping Peptide id -> crosslink acceptor value
      std::map<std::string, std::string> xl_id_acceptor_map_; 
      std::map<std::string, SignedSize> xl_donor_pos_map_; 
      std::map<std::string, SignedSize> xl_acceptor_pos_map_; 
      std::map<std::string, double> xl_mass_map_; 
      std::map<std::string, std::string> xl_mod_map_; 
 
      std::set<std::string> q_score_child_terms_;
      std::set<std::string> e_score_child_terms_;
      std::set<std::string> specific_score_child_terms_;
    };
  } // namespace Internal
} // namespace OpenMS