IdentificationData.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-2020.
//
// 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: Hendrik Weisser $
// $Authors: Hendrik Weisser $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/METADATA/ID/DataProcessingStep.h>
#include <OpenMS/METADATA/ID/DataQuery.h>
#include <OpenMS/METADATA/ID/DBSearchParam.h>
#include <OpenMS/METADATA/ID/IdentifiedCompound.h>
#include <OpenMS/METADATA/ID/IdentifiedSequence.h>
#include <OpenMS/METADATA/ID/MetaData.h>
#include <OpenMS/METADATA/ID/MoleculeParentMatch.h>
#include <OpenMS/METADATA/ID/MoleculeQueryMatch.h>
#include <OpenMS/METADATA/ID/ParentMolecule.h>
#include <OpenMS/METADATA/ID/ParentMoleculeGroup.h>
#include <OpenMS/METADATA/ID/QueryMatchGroup.h>
#include <OpenMS/METADATA/ID/ScoreType.h>
#include <OpenMS/FORMAT/MzTab.h>
 
#include <boost/unordered_set.hpp>
 
namespace OpenMS
{
  class OPENMS_DLLAPI IdentificationData: public MetaInfoInterface
  {
  public:
 
    // type definitions:
    using MoleculeType = IdentificationDataInternal::MoleculeType;
    using MassType = IdentificationDataInternal::MassType;
 
    using InputFiles = IdentificationDataInternal::InputFiles;
    using InputFileRef = IdentificationDataInternal::InputFileRef;
 
    using DataProcessingSoftware =
      IdentificationDataInternal::DataProcessingSoftware;
    using DataProcessingSoftwares =
      IdentificationDataInternal::DataProcessingSoftwares;
    using ProcessingSoftwareRef =
      IdentificationDataInternal::ProcessingSoftwareRef;
 
    using DataProcessingStep = IdentificationDataInternal::DataProcessingStep;
    using DataProcessingSteps = IdentificationDataInternal::DataProcessingSteps;
    using ProcessingStepRef = IdentificationDataInternal::ProcessingStepRef;
 
    using DBSearchParam = IdentificationDataInternal::DBSearchParam;
    using DBSearchParams = IdentificationDataInternal::DBSearchParams;
    using SearchParamRef = IdentificationDataInternal::SearchParamRef;
    using DBSearchSteps = IdentificationDataInternal::DBSearchSteps;
 
    using ScoreType = IdentificationDataInternal::ScoreType;
    using ScoreTypes = IdentificationDataInternal::ScoreTypes;
    using ScoreTypeRef = IdentificationDataInternal::ScoreTypeRef;
 
    using AppliedProcessingStep =
      IdentificationDataInternal::AppliedProcessingStep;
    using AppliedProcessingSteps =
      IdentificationDataInternal::AppliedProcessingSteps;
 
    using DataQuery = IdentificationDataInternal::DataQuery;
    using DataQueries = IdentificationDataInternal::DataQueries;
    using DataQueryRef = IdentificationDataInternal::DataQueryRef;
 
    using ParentMolecule = IdentificationDataInternal::ParentMolecule;
    using ParentMolecules = IdentificationDataInternal::ParentMolecules;
    using ParentMoleculeRef = IdentificationDataInternal::ParentMoleculeRef;
 
    using MoleculeParentMatch = IdentificationDataInternal::MoleculeParentMatch;
    using ParentMatches = IdentificationDataInternal::ParentMatches;
 
    using IdentifiedPeptide = IdentificationDataInternal::IdentifiedPeptide;
    using IdentifiedPeptides = IdentificationDataInternal::IdentifiedPeptides;
    using IdentifiedPeptideRef =
      IdentificationDataInternal::IdentifiedPeptideRef;
 
    using IdentifiedCompound = IdentificationDataInternal::IdentifiedCompound;
    using IdentifiedCompounds = IdentificationDataInternal::IdentifiedCompounds;
    using IdentifiedCompoundRef =
      IdentificationDataInternal::IdentifiedCompoundRef;
 
    using IdentifiedOligo = IdentificationDataInternal::IdentifiedOligo;
    using IdentifiedOligos = IdentificationDataInternal::IdentifiedOligos;
    using IdentifiedOligoRef = IdentificationDataInternal::IdentifiedOligoRef;
 
    using PeakAnnotations = IdentificationDataInternal::PeakAnnotations;
    using IdentifiedMoleculeRef =
      IdentificationDataInternal::IdentifiedMoleculeRef;
 
    using MoleculeQueryMatch = IdentificationDataInternal::MoleculeQueryMatch;
    using MoleculeQueryMatches =
      IdentificationDataInternal::MoleculeQueryMatches;
    using QueryMatchRef = IdentificationDataInternal::QueryMatchRef;
 
    // @TODO: allow multiple sets of groups, like with parent molecules
    // ("ParentMoleculeGroupings")?
    using QueryMatchGroup = IdentificationDataInternal::QueryMatchGroup;
    using QueryMatchGroups = IdentificationDataInternal::QueryMatchGroups;
    using MatchGroupRef = IdentificationDataInternal::MatchGroupRef;
 
    using ParentMoleculeGroup = IdentificationDataInternal::ParentMoleculeGroup;
    using ParentMoleculeGroups =
      IdentificationDataInternal::ParentMoleculeGroups;
    using ParentGroupRef = IdentificationDataInternal::ParentGroupRef;
    using ParentMoleculeGrouping =
      IdentificationDataInternal::ParentMoleculeGrouping;
    using ParentMoleculeGroupings =
      IdentificationDataInternal::ParentMoleculeGroupings;
 
    using AddressLookup = boost::unordered_set<uintptr_t>;
 
 
    IdentificationData():
      current_step_ref_(processing_steps_.end())
    {
    }
    // Copy constructor - not allowed, as references would be invalidated:
    // @TODO: implement using deep copy
    IdentificationData(const IdentificationData& other) = delete;
 
    IdentificationData(IdentificationData&& other):
      input_files_(std::move(other.input_files_)),
      processing_softwares_(std::move(other.processing_softwares_)),
      processing_steps_(std::move(other.processing_steps_)),
      db_search_params_(std::move(other.db_search_params_)),
      db_search_steps_(std::move(other.db_search_steps_)),
      score_types_(std::move(other.score_types_)),
      data_queries_(std::move(other.data_queries_)),
      parent_molecules_(std::move(other.parent_molecules_)),
      parent_molecule_groupings_(std::move(other.parent_molecule_groupings_)),
      identified_peptides_(std::move(other.identified_peptides_)),
      identified_compounds_(std::move(other.identified_compounds_)),
      identified_oligos_(std::move(other.identified_oligos_)),
      query_matches_(std::move(other.query_matches_)),
      query_match_groups_(std::move(other.query_match_groups_)),
      current_step_ref_(std::move(other.current_step_ref_)),
      // look-up tables:
      data_query_lookup_(std::move(other.data_query_lookup_)),
      parent_molecule_lookup_(std::move(other.parent_molecule_lookup_)),
      identified_peptide_lookup_(std::move(other.identified_peptide_lookup_)),
      identified_compound_lookup_(std::move(other.identified_compound_lookup_)),
      identified_oligo_lookup_(std::move(other.identified_oligo_lookup_)),
      query_match_lookup_(std::move(other.query_match_lookup_))
    {
    }
 
    InputFileRef registerInputFile(const String& file);
 
    ProcessingSoftwareRef registerDataProcessingSoftware(
      const DataProcessingSoftware& software);
 
    SearchParamRef registerDBSearchParam(const DBSearchParam& param);
 
    ProcessingStepRef registerDataProcessingStep(const DataProcessingStep&
                                                 step);
 
    ProcessingStepRef registerDataProcessingStep(
      const DataProcessingStep& step, SearchParamRef search_ref);
 
    ScoreTypeRef registerScoreType(const ScoreType& score);
 
    DataQueryRef registerDataQuery(const DataQuery& query);
 
    ParentMoleculeRef registerParentMolecule(const ParentMolecule& parent);
 
    void registerParentMoleculeGrouping(const ParentMoleculeGrouping& grouping);
 
    IdentifiedPeptideRef registerIdentifiedPeptide(const IdentifiedPeptide&
                                                   peptide);
 
    IdentifiedCompoundRef registerIdentifiedCompound(const IdentifiedCompound&
                                                     compound);
 
    IdentifiedOligoRef registerIdentifiedOligo(const IdentifiedOligo& oligo);
 
    QueryMatchRef registerMoleculeQueryMatch(const MoleculeQueryMatch& match);
 
    MatchGroupRef registerQueryMatchGroup(const QueryMatchGroup& group);
 
    const InputFiles& getInputFiles() const
    {
      return input_files_;
    }
 
    const DataProcessingSoftwares& getDataProcessingSoftwares() const
    {
      return processing_softwares_;
    }
 
    const DataProcessingSteps& getDataProcessingSteps() const
    {
      return processing_steps_;
    }
 
    const DBSearchParams& getDBSearchParams() const
    {
      return db_search_params_;
    }
 
    const DBSearchSteps& getDBSearchSteps() const
    {
      return db_search_steps_;
    }
 
    const ScoreTypes& getScoreTypes() const
    {
      return score_types_;
    }
 
    const DataQueries& getDataQueries() const
    {
      return data_queries_;
    }
 
    const ParentMolecules& getParentMolecules() const
    {
      return parent_molecules_;
    }
 
    const ParentMoleculeGroupings& getParentMoleculeGroupings() const
    {
      return parent_molecule_groupings_;
    }
 
    const IdentifiedPeptides& getIdentifiedPeptides() const
    {
      return identified_peptides_;
    }
 
    const IdentifiedCompounds& getIdentifiedCompounds() const
    {
      return identified_compounds_;
    }
 
    const IdentifiedOligos& getIdentifiedOligos() const
    {
      return identified_oligos_;
    }
 
    const MoleculeQueryMatches& getMoleculeQueryMatches() const
    {
      return query_matches_;
    }
 
    const QueryMatchGroups& getQueryMatchGroups() const
    {
      return query_match_groups_;
    }
 
    void addScore(QueryMatchRef match_ref, ScoreTypeRef score_ref,
                  double value);
 
    void setCurrentProcessingStep(ProcessingStepRef step_ref);
 
    ProcessingStepRef getCurrentProcessingStep();
 
    void clearCurrentProcessingStep();
 
    // @TODO: this currently doesn't take molecule type into account - should it?
    std::vector<QueryMatchRef> getBestMatchPerQuery(ScoreTypeRef
                                                    score_ref) const;
 
    std::pair<ScoreTypeRef, bool> findScoreType(const String& score_name) const;
 
    void calculateCoverages(bool check_molecule_length = false);
 
    void cleanup(bool require_query_match = true,
                 bool require_identified_sequence = true,
                 bool require_parent_match = true,
                 bool require_parent_group = false,
                 bool require_match_group = false);
 
    static bool isBetterScore(double first, double second, bool higher_better)
    {
      if (higher_better) return first > second;
      return first < second;
    }
 
  protected:
 
    // containers:
    InputFiles input_files_;
    DataProcessingSoftwares processing_softwares_;
    DataProcessingSteps processing_steps_;
    DBSearchParams db_search_params_;
    // @TODO: store SearchParamRef inside ProcessingStep? (may not be required
    // for many processing steps)
    DBSearchSteps db_search_steps_;
    ScoreTypes score_types_;
    DataQueries data_queries_;
    ParentMolecules parent_molecules_;
    ParentMoleculeGroupings parent_molecule_groupings_;
    IdentifiedPeptides identified_peptides_;
    IdentifiedCompounds identified_compounds_;
    IdentifiedOligos identified_oligos_;
    MoleculeQueryMatches query_matches_;
    QueryMatchGroups query_match_groups_;
 
    ProcessingStepRef current_step_ref_;
 
    // look-up tables for fast checking of reference validity:
    AddressLookup data_query_lookup_;
    AddressLookup parent_molecule_lookup_;
    // @TODO: just use one "identified_molecule_lookup_" for all molecule types?
    AddressLookup identified_peptide_lookup_;
    AddressLookup identified_compound_lookup_;
    AddressLookup identified_oligo_lookup_;
    AddressLookup query_match_lookup_;
 
    void checkScoreTypes_(const std::map<ScoreTypeRef, double>& scores) const;
 
    void checkAppliedProcessingSteps_(const AppliedProcessingSteps&
                                      steps_and_scores) const;
 
    void checkParentMatches_(const ParentMatches& matches,
                             MoleculeType expected_type) const;
 
    template <typename ElementType>
    struct ModifyMultiIndexAddProcessingStep
    {
      ModifyMultiIndexAddProcessingStep(ProcessingStepRef step_ref):
        step_ref(step_ref)
      {
      }
 
      void operator()(ElementType& element)
      {
        element.addProcessingStep(step_ref);
      }
 
      ProcessingStepRef step_ref;
    };
 
    template <typename ElementType>
    struct ModifyMultiIndexAddScore
    {
      ModifyMultiIndexAddScore(ScoreTypeRef score_type_ref, double value):
        score_type_ref(score_type_ref), value(value)
      {
      }
 
      void operator()(ElementType& element)
      {
        if (element.steps_and_scores.empty())
        {
          element.addScore(score_type_ref, value);
        }
        else // add score to most recent step
        {
          element.addScore(score_type_ref, value,
                           element.steps_and_scores.back().processing_step_opt);
        }
      }
 
      ScoreTypeRef score_type_ref;
      double value;
    };
 
    template <typename ElementType>
    struct ModifyMultiIndexRemoveParentMatches
    {
      ModifyMultiIndexRemoveParentMatches(const AddressLookup& lookup):
        lookup(lookup)
      {
      }
 
      void operator()(ElementType& element)
      {
        removeFromSetIf_(element.parent_matches,
                         [&](const ParentMatches::iterator it)
                         {
                           return !lookup.count(it->first);
                         });
      }
 
      const AddressLookup& lookup;
    };
 
 
    template <typename ContainerType, typename ElementType>
    typename ContainerType::iterator insertIntoMultiIndex_(
      ContainerType& container, const ElementType& element)
    {
      checkAppliedProcessingSteps_(element.steps_and_scores);
 
      auto result = container.insert(element);
      if (!result.second) // existing element - merge in new information
      {
        container.modify(result.first, [&element](ElementType& existing)
                         {
                           existing += element;
                         });
      }
 
      // add current processing step (if necessary):
      if (current_step_ref_ != processing_steps_.end())
      {
        ModifyMultiIndexAddProcessingStep<ElementType>
          modifier(current_step_ref_);
        container.modify(result.first, modifier);
      }
 
      return result.first;
    }
 
    template <typename ContainerType, typename ElementType>
    typename ContainerType::iterator insertIntoMultiIndex_(
      ContainerType& container, const ElementType& element,
      AddressLookup& lookup)
    {
      typename ContainerType::iterator ref =
        insertIntoMultiIndex_(container, element);
      lookup.insert(uintptr_t(&(*ref)));
      return ref;
    }
 
    template <typename RefType, typename ContainerType>
    static bool isValidReference_(RefType ref, ContainerType& container)
    {
      for (auto it = container.begin(); it != container.end(); ++it)
      {
        if (ref == it) return true;
      }
      return false;
    }
 
    template <typename RefType>
    static bool isValidHashedReference_(
      RefType ref, const AddressLookup& lookup)
    {
      return lookup.count(ref);
    }
 
    template <typename ContainerType, typename PredicateType>
    // static void removeFromSetIf_(ContainerType& container, std::function<bool(RefType)> predicate)
    static void removeFromSetIf_(ContainerType& container, PredicateType predicate)
    {
      for (auto it = container.begin(); it != container.end(); )
      {
        if (predicate(it))
        {
          it = container.erase(it);
        }
        else
        {
          ++it;
        }
      }
    }
 
    template <typename ContainerType>
    static void removeFromSetIfNotHashed_(
      ContainerType& container, const AddressLookup& lookup)
    {
      removeFromSetIf_(container, [&lookup](typename ContainerType::iterator it)
                       {
                         return !lookup.count(uintptr_t(&(*it)));
                       });
    }
 
    template <typename ContainerType>
    static void updateAddressLookup_(const ContainerType& container,
                                     AddressLookup& lookup)
    {
      lookup.clear();
      lookup.reserve(container.size());
      for (const auto& element : container)
      {
        lookup.insert(uintptr_t(&element));
      }
    }
 
 
    // IDFilter needs access to do its job:
    friend class IDFilter;
  };
}