ConsensusMap.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-2012.
//
// 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: Erhan Kenar $
// $Authors: $
// --------------------------------------------------------------------------

#ifndef OPENMS_KERNEL_CONSENSUSMAP_H
#define OPENMS_KERNEL_CONSENSUSMAP_H

#include <OpenMS/DATASTRUCTURES/Map.h>
#include <OpenMS/KERNEL/MSExperiment.h>
#include <OpenMS/KERNEL/ConsensusFeature.h>
#include <OpenMS/KERNEL/RangeManager.h>
#include <OpenMS/KERNEL/ComparatorUtils.h>
#include <OpenMS/METADATA/ProteinIdentification.h>
#include <OpenMS/KERNEL/FeatureMap.h>
#include <OpenMS/CONCEPT/UniqueIdIndexer.h>

namespace OpenMS
{
  class ConsensusMap : // no OPENMS_DLLAPI here, since the class is derived from an STL class - we do not want parts of the STL lib in OpenMS.lib, since it will cause linker errors
    public std::vector<ConsensusFeature>,
    public MetaInfoInterface,
    public RangeManager<2>,
    public DocumentIdentifier,
    public UniqueIdInterface,
    public UniqueIdIndexer<ConsensusMap>
  {

public:

    struct OPENMS_DLLAPI FileDescription :
      public MetaInfoInterface
    {
      FileDescription();

      String filename;
      String label;
      Size size;
      UInt64 unique_id;
    };


    typedef std::vector<ConsensusFeature> Base;
    typedef RangeManager<2> RangeManagerType;
    typedef Map<UInt64, FileDescription> FileDescriptions;
    typedef std::vector<ConsensusFeature>::iterator Iterator;
    typedef std::vector<ConsensusFeature>::const_iterator ConstIterator;
    typedef std::vector<ConsensusFeature>::reverse_iterator ReverseIterator;
    typedef std::vector<ConsensusFeature>::const_reverse_iterator ConstReverseIterator;

    OPENMS_DLLAPI ConsensusMap();

    OPENMS_DLLAPI ConsensusMap(const ConsensusMap & source);

    OPENMS_DLLAPI ~ConsensusMap();

    OPENMS_DLLAPI explicit ConsensusMap(Base::size_type n);

    OPENMS_DLLAPI ConsensusMap & operator=(const ConsensusMap & source);

    OPENMS_DLLAPI ConsensusMap & operator+=(const ConsensusMap & rhs);

    OPENMS_DLLAPI void clear(bool clear_meta_data = true);

    OPENMS_DLLAPI const FileDescriptions & getFileDescriptions() const;

    OPENMS_DLLAPI FileDescriptions & getFileDescriptions();

    OPENMS_DLLAPI const String & getExperimentType() const;

    OPENMS_DLLAPI void setExperimentType(const String & experiment_type);


    OPENMS_DLLAPI void sortByIntensity(bool reverse = false);

    OPENMS_DLLAPI void sortByRT();

    OPENMS_DLLAPI void sortByMZ();

    OPENMS_DLLAPI void sortByPosition();

    OPENMS_DLLAPI void sortByQuality(bool reverse = false);

    OPENMS_DLLAPI void sortBySize();

    OPENMS_DLLAPI void sortByMaps();


    template <typename FeatureT>
    static void convert(UInt64 const input_map_index,
                        FeatureMap<FeatureT> const & input_map,
                        ConsensusMap & output_map,
                        Size n = -1)
    {
      if (n > input_map.size())
      {
        n = input_map.size();
      }

      output_map.clear(true);
      output_map.reserve(n);

      // An arguable design decision, see above.
      output_map.setUniqueId(input_map.getUniqueId());

      for (UInt64 element_index = 0; element_index < n; ++element_index)
      {
        output_map.push_back(ConsensusFeature(input_map_index, input_map[element_index]));
      }
      output_map.getFileDescriptions()[input_map_index].size = (Size) input_map.size();
      output_map.setProteinIdentifications(input_map.getProteinIdentifications());
      output_map.setUnassignedPeptideIdentifications(input_map.getUnassignedPeptideIdentifications());
      output_map.updateRanges();
    }

    OPENMS_DLLAPI static void convert(UInt64 const input_map_index,
                                      MSExperiment<> & input_map,
                                      ConsensusMap & output_map,
                                      Size n = -1)
    {
      output_map.clear(true);

      // see @todo above
      output_map.setUniqueId();

      input_map.updateRanges(1);
      if (n > input_map.getSize())
      {
        n = input_map.getSize();
      }
      output_map.reserve(n);
      std::vector<Peak2D> tmp;
      tmp.reserve(input_map.getSize());

      // TODO Avoid tripling the memory consumption by this call
      input_map.get2DData(tmp);

      std::partial_sort(tmp.begin(),
                        tmp.begin() + n,
                        tmp.end(),
                        reverseComparator(Peak2D::IntensityLess()));

      for (Size element_index = 0; element_index < n; ++element_index)
      {
        output_map.push_back(ConsensusFeature(input_map_index,
                                              tmp[element_index],
                                              element_index));
      }

      output_map.getFileDescriptions()[input_map_index].size = n;
      output_map.updateRanges();
    }

    OPENMS_DLLAPI static void convert(UInt64 const input_map_index,
                                      std::vector<Peak2D> & input_map,
                                      ConsensusMap & output_map,
                                      Size n = -1)
    {
      // Clear the map and assign new ID.
      output_map.setUniqueId();
      output_map.clear(true);

      // Determine the maximum size of the map and resize the output map accordingly.
      if (n > input_map.size())
      {
        n = input_map.size();
      }
      output_map.reserve(n);

      std::partial_sort(input_map.begin(),
                        input_map.begin() + n,
                        input_map.end(),
                        reverseComparator(Peak2D::IntensityLess()));

      for (Size element_index = 0; element_index < n; ++element_index)
      {
        output_map.push_back(ConsensusFeature(input_map_index, input_map[element_index], element_index));
      }

      output_map.getFileDescriptions()[input_map_index].size = n;
      output_map.updateRanges();
    }

    template <typename FeatureT>
    static void convert(ConsensusMap const & input_map,
                        const bool keep_uids,
                        FeatureMap<FeatureT> & output_map)
    {
      output_map.clear(true);
      output_map.resize(input_map.size());
      output_map.DocumentIdentifier::operator=(input_map);

      if (keep_uids) output_map.UniqueIdInterface::operator=(input_map);
      else output_map.setUniqueId();

      output_map.setProteinIdentifications(input_map.getProteinIdentifications());
      output_map.setUnassignedPeptideIdentifications(input_map.getUnassignedPeptideIdentifications());

      for (Size i = 0; i < input_map.size(); ++i)
      {
        Feature & f = output_map[i];
        const ConsensusFeature & c = input_map[i];
        f.BaseFeature::operator=(c);
        if (!keep_uids) f.setUniqueId();
      }
    }

    // Docu in base class
    OPENMS_DLLAPI void updateRanges();

    OPENMS_DLLAPI void swap(ConsensusMap & from);

    OPENMS_DLLAPI const std::vector<ProteinIdentification> & getProteinIdentifications() const;

    OPENMS_DLLAPI std::vector<ProteinIdentification> & getProteinIdentifications();

    OPENMS_DLLAPI void setProteinIdentifications(const std::vector<ProteinIdentification> & protein_identifications);

    OPENMS_DLLAPI const std::vector<PeptideIdentification> & getUnassignedPeptideIdentifications() const;

    OPENMS_DLLAPI std::vector<PeptideIdentification> & getUnassignedPeptideIdentifications();

    OPENMS_DLLAPI void setUnassignedPeptideIdentifications(const std::vector<PeptideIdentification> & unassigned_peptide_identifications);

    OPENMS_DLLAPI const std::vector<DataProcessing> & getDataProcessing() const;

    OPENMS_DLLAPI std::vector<DataProcessing> & getDataProcessing();

    OPENMS_DLLAPI void setDataProcessing(const std::vector<DataProcessing> & processing_method);

    OPENMS_DLLAPI bool operator==(const ConsensusMap & rhs) const;

    OPENMS_DLLAPI bool operator!=(const ConsensusMap & rhs) const;

    template <typename Type>
    Size applyMemberFunction(Size (Type::* member_function)())
    {
      Size assignments = 0;
      assignments += ((*this).*member_function)();
      for (Iterator iter = this->begin(); iter != this->end(); ++iter)
      {
        assignments += ((*iter).*member_function)();
      }
      return assignments;
    }

    template <typename Type>
    Size applyMemberFunction(Size (Type::* member_function)() const) const
    {
      Size assignments = 0;
      assignments += ((*this).*member_function)();
      for (ConstIterator iter = this->begin(); iter != this->end(); ++iter)
      {
        assignments += ((*iter).*member_function)();
      }
      return assignments;
    }

protected:

    FileDescriptions file_description_;

    String experiment_type_;

    std::vector<ProteinIdentification> protein_identifications_;

    std::vector<PeptideIdentification> unassigned_peptide_identifications_;

    std::vector<DataProcessing> data_processing_;
  };

  OPENMS_DLLAPI std::ostream & operator<<(std::ostream & os, const ConsensusMap & cons_map);

} // namespace OpenMS

#endif // OPENMS_KERNEL_CONSENSUSMAP_H