| OpenMS 2.5.0

MapAlignmentAlgorithmSpectrumAlignment.h
Go to the documentation of this file.
1 // --------------------------------------------------------------------------
2 // OpenMS -- Open-Source Mass Spectrometry
3 // --------------------------------------------------------------------------
4 // Copyright The OpenMS Team -- Eberhard Karls University Tuebingen,
5 // ETH Zurich, and Freie Universitaet Berlin 2002-2020.
6 //
7 // This software is released under a three-clause BSD license:
8 // * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 // * Redistributions in binary form must reproduce the above copyright
11 // notice, this list of conditions and the following disclaimer in the
12 // documentation and/or other materials provided with the distribution.
13 // * Neither the name of any author or any participating institution
14 // may be used to endorse or promote products derived from this software
15 // without specific prior written permission.
16 // For a full list of authors, refer to the file AUTHORS.
17 // --------------------------------------------------------------------------
18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 // ARE DISCLAIMED. IN NO EVENT SHALL ANY OF THE AUTHORS OR THE CONTRIBUTING
22 // INSTITUTIONS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
23 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
24 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
25 // OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
26 // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
27 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
28 // ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 //
30 // --------------------------------------------------------------------------
31 // $Maintainer: Timo Sachsenberg $
32 // $Authors: Vipul Patel $
33 // --------------------------------------------------------------------------
34
35 #pragma once
36
37 #include <OpenMS/ANALYSIS/MAPMATCHING/TransformationDescription.h>
38 #include <OpenMS/COMPARISON/SPECTRA/PeakSpectrumCompareFunctor.h>
39 #include <OpenMS/CONCEPT/ProgressLogger.h>
40 #include <OpenMS/DATASTRUCTURES/DefaultParamHandler.h>
41 #include <OpenMS/DATASTRUCTURES/String.h>
42
43 namespace OpenMS
44 {
54 class OPENMS_DLLAPI MapAlignmentAlgorithmSpectrumAlignment :
55 public DefaultParamHandler,
56 public ProgressLogger
57 {
58 public:
60 MapAlignmentAlgorithmSpectrumAlignment();
61
63 ~MapAlignmentAlgorithmSpectrumAlignment() override;
64
66 virtual void align(std::vector<PeakMap >&, std::vector<TransformationDescription>&);
67
68 private:
70 MapAlignmentAlgorithmSpectrumAlignment(const MapAlignmentAlgorithmSpectrumAlignment&);
72 MapAlignmentAlgorithmSpectrumAlignment & operator=(const MapAlignmentAlgorithmSpectrumAlignment &);
73
82 class OPENMS_DLLAPI Compare
83 {
84 protected:
85 bool flag;
86
87 public:
88
90 explicit Compare(bool b = false) :
91 flag(b)
92 {
93 }
94
104 inline bool operator()(const std::pair<std::pair<Int, float>, float>& c1, const std::pair<std::pair<Int, float>, float>& c2)
105 {
106 if (!flag)
107 {
108 return c1.second > c2.second;
109 }
110 else
111 {
112 return (c1.first).first < (c2.first).first;
113 }
114 }
115
123 inline bool operator()(const std::pair<float, float>& c1, const std::pair<float, float>& c2)
124 {
125 if (!flag)
126 {
127 return c1.first > c2.first;
128 }
129 else
130 {
131 return c1.first < c2.first;
132 }
133 }
134
135 };
136
152 void prepareAlign_(const std::vector<MSSpectrum*>& pattern, PeakMap& aligned, std::vector<TransformationDescription>& transformation);
153
164 void msFilter_(PeakMap& peakmap, std::vector<MSSpectrum*>& spectrum_pointer_container);
165
178 bool insideBand_(Size i, Size j, Size n, Size m, Int k_);
179
197 Int bestk_(const std::vector<MSSpectrum*>& pattern,
198 std::vector<MSSpectrum*>& aligned, std::map<Size, std::map<Size, float> >& buffer,
199 bool column_row_orientation, Size xbegin, Size xend, Size ybegin, Size yend);
200
221 float scoreCalculation_(Size i, Size j, Size patternbegin, Size alignbegin,
222 const std::vector<MSSpectrum*>& pattern, std::vector<MSSpectrum*>& aligned,
223 std::map<Size, std::map<Size, float> >& buffer, bool column_row_orientation);
224
228 float scoring_(const MSSpectrum& a, MSSpectrum& b);
229
251 void affineGapalign_(Size xbegin, Size ybegin, Size xend, Size yend,
252 const std::vector<MSSpectrum*>& pattern,
253 std::vector<MSSpectrum*>& aligned,
254 std::vector<int>& xcoordinate, std::vector<float>& ycoordinate,
255 std::vector<int>& xcoordinatepattern);
256
272 void bucketFilter_(const std::vector<MSSpectrum*>& pattern,
273 std::vector<MSSpectrum*>& aligned, std::vector<Int>& xcoordinate,
274 std::vector<float>& ycoordinate, std::vector<Int>& xcoordinatepattern);
275
296 void debugFileCreator_(const std::vector<MSSpectrum*>& pattern, std::vector<MSSpectrum*>& aligned);
297
303 void debugscoreDistributionCalculation_(float score);
304
306 float gap_;
308 float e_;
310 PeakSpectrumCompareFunctor* c1_;
312 float cutoffScore_;
314 Size bucketsize_;
316 Size anchorPoints_;
318 bool debug_;
320 float mismatchscore_;
322 float threshold_;
324 std::vector<std::vector<float> > debugmatrix_;
326 std::vector<std::vector<float> > debugscorematrix_;
328 std::vector<std::pair<float, float> > debugtraceback_;
330 std::vector<float> scoredistribution_; //save the cell i, j , matchscore, insertscore, traceback
331 //docu in base class
332 void updateMembers_() override;
333 };
334
335 } // namespace OpenMS
336
OpenMS::MapAlignmentAlgorithmSpectrumAlignment::debugmatrix_
std::vector< std::vector< float > > debugmatrix_
Container holding the score of the matchmatrix and also the insertmatrix.
Definition: MapAlignmentAlgorithmSpectrumAlignment.h:324
OpenMS::MapAlignmentAlgorithmSpectrumAlignment::threshold_
float threshold_
This is the minimum score for counting as a match(1-cutoffScore_)
Definition: MapAlignmentAlgorithmSpectrumAlignment.h:322
OpenMS::MapAlignmentAlgorithmSpectrumAlignment::Compare::operator()
bool operator()(const std::pair< std::pair< Int, float >, float > &c1, const std::pair< std::pair< Int, float >, float > &c2)
overloaded operator() for comparing maps of maps std::pair<std::pair<Int,float>,float>.
Definition: MapAlignmentAlgorithmSpectrumAlignment.h:104
OpenMS::DefaultParamHandler
A base class for all classes handling default parameters.
Definition: DefaultParamHandler.h:91
OpenMS::MSExperiment
In-Memory representation of a mass spectrometry experiment.
Definition: MSExperiment.h:77
OpenMS::MapAlignmentAlgorithmSpectrumAlignment::e_
float e_
Extension cost after a gap is open.
Definition: MapAlignmentAlgorithmSpectrumAlignment.h:308
OpenMS::MapAlignmentAlgorithmSpectrumAlignment::Compare::Compare
Compare(bool b=false)
Default constructor with an order flag.
Definition: MapAlignmentAlgorithmSpectrumAlignment.h:90
OpenMS::MapAlignmentAlgorithmSpectrumAlignment::Compare
inner class necessary for using the sort algorithm.
Definition: MapAlignmentAlgorithmSpectrumAlignment.h:82
OpenMS::MSSpectrum
The representation of a 1D spectrum.
Definition: MSSpectrum.h:67
String.h
ProgressLogger.h
OpenMS
Main OpenMS namespace.
Definition: FeatureDeconvolution.h:46
OpenMS::MapAlignmentAlgorithmSpectrumAlignment::debugscorematrix_
std::vector< std::vector< float > > debugscorematrix_
Container holding the only the score of Spectra.
Definition: MapAlignmentAlgorithmSpectrumAlignment.h:326
OpenMS::ProgressLogger
Base class for all classes that want to report their progress.
Definition: ProgressLogger.h:54
TransformationDescription.h
OpenMS::PeakSpectrumCompareFunctor
Base class for compare functors of spectra, that return a similarity value for two spectra...
Definition: PeakSpectrumCompareFunctor.h:52
PeakSpectrumCompareFunctor.h
DefaultParamHandler.h
OpenMS::MapAlignmentAlgorithmSpectrumAlignment::Compare::operator()
bool operator()(const std::pair< float, float > &c1, const std::pair< float, float > &c2)
overloaded operator() for comparing pairs of float, float std::pair<float,float>. ...
Definition: MapAlignmentAlgorithmSpectrumAlignment.h:123
OpenMS::MapAlignmentAlgorithmSpectrumAlignment
A map alignment algorithm based on spectrum similarity (dynamic programming).
Definition: MapAlignmentAlgorithmSpectrumAlignment.h:54
OpenMS::MapAlignmentAlgorithmSpectrumAlignment::anchorPoints_
Size anchorPoints_
Defines the amount of anchor points which are selected within one bucket.
Definition: MapAlignmentAlgorithmSpectrumAlignment.h:316
OpenMS::MapAlignmentAlgorithmSpectrumAlignment::cutoffScore_
float cutoffScore_
This is the minimal score to be count as a mismatch(range 0.0 - 1.0)
Definition: MapAlignmentAlgorithmSpectrumAlignment.h:312
int
OpenMS::MapAlignmentAlgorithmSpectrumAlignment::debug_
bool debug_
Debug mode flag default: False.
Definition: MapAlignmentAlgorithmSpectrumAlignment.h:318
OpenMS::MapAlignmentAlgorithmSpectrumAlignment::mismatchscore_
float mismatchscore_
Represent the cost of a mismatch in the alignment.
Definition: MapAlignmentAlgorithmSpectrumAlignment.h:320
OpenMS::MapAlignmentAlgorithmSpectrumAlignment::Compare::flag
bool flag
Definition: MapAlignmentAlgorithmSpectrumAlignment.h:85
OpenMS::MapAlignmentAlgorithmSpectrumAlignment::c1_
PeakSpectrumCompareFunctor * c1_
Pointer holds the scoring function, which can be selected.
Definition: MapAlignmentAlgorithmSpectrumAlignment.h:310
OpenMS::MapAlignmentAlgorithmSpectrumAlignment::scoredistribution_
std::vector< float > scoredistribution_
Container holding the score of each cell(matchmatrix,insertmatrix, traceback)
Definition: MapAlignmentAlgorithmSpectrumAlignment.h:330
OpenMS::Size
size_t Size
Size type e.g. used as variable which can hold result of size()
Definition: Types.h:127
OpenMS::MapAlignmentAlgorithmSpectrumAlignment::gap_
float gap_
Represent the gap cost for opening or closing a gap in the alignment.
Definition: MapAlignmentAlgorithmSpectrumAlignment.h:306
OpenMS::MapAlignmentAlgorithmSpectrumAlignment::debugtraceback_
std::vector< std::pair< float, float > > debugtraceback_
Container holding the path of the traceback.
Definition: MapAlignmentAlgorithmSpectrumAlignment.h:328
OpenMS::MapAlignmentAlgorithmSpectrumAlignment::bucketsize_
Size bucketsize_
Defines the size of one bucket.
Definition: MapAlignmentAlgorithmSpectrumAlignment.h:314