35 #ifndef OPENMS_TRANSFORMATIONS_RAW2PEAK_PEAKPICKERITERATIVE_H
36 #define OPENMS_TRANSFORMATIONS_RAW2PEAK_PEAKPICKERITERATIVE_H
118 defaults_.setValue(
"signal_to_noise_", 1.0,
"Signal to noise value, each peak is required to be above this value (turn off by setting it to 0.0)");
119 defaults_.setValue(
"peak_width", 0.0,
"Expected peak width half width in Dalton - peaks will be extended until this half width is reached (even if the intensitity is increasing). In conjunction with check_width_internally it will also be used to remove peaks whose spacing is larger than this value.");
122 defaults_.setValue(
"spacing_difference", 1.5,
"Difference between peaks in multiples of the minimal difference to continue. The higher this value is set, the further apart peaks are allowed to be to still extend a peak. E.g. if the value is set to 1.5 and in a current peak the minimal spacing between peaks is 10 mDa, then only peaks at most 15 mDa apart will be added to the peak.", ListUtils::create<String>(
"advanced"));
123 defaults_.setValue(
"sn_bin_count_", 30,
"Bin count for the Signal to Noise estimation.", ListUtils::create<String>(
"advanced"));
124 defaults_.setValue(
"nr_iterations_", 5,
"Nr of iterations to perform (how many times the peaks are re-centered).", ListUtils::create<String>(
"advanced"));
125 defaults_.setMinInt(
"nr_iterations_", 1);
126 defaults_.setValue(
"sn_win_len_", 20.0,
"Window length for the Signal to Noise estimation.", ListUtils::create<String>(
"advanced"));
128 defaults_.setValue(
"check_width_internally",
"false",
"Delete peaks where the spacing is larger than the peak width (should be set to true to avoid artefacts)", ListUtils::create<String>(
"advanced"));
129 defaults_.setValidStrings(
"check_width_internally", ListUtils::create<String>(
"true,false"));
131 defaults_.setValue(
"ms1_only",
"false",
"Only do MS1");
132 defaults_.setValidStrings(
"ms1_only", ListUtils::create<String>(
"true,false"));
133 defaults_.setValue(
"clear_meta_data",
"false",
"Delete meta data about peak width");
134 defaults_.setValidStrings(
"clear_meta_data", ListUtils::create<String>(
"true,false"));
142 signal_to_noise_ = (
double)param_.getValue(
"signal_to_noise_");
143 peak_width_ = (
double)param_.getValue(
"peak_width");
144 spacing_difference_ = (
double)param_.getValue(
"spacing_difference");
145 sn_bin_count_ = (
double)param_.getValue(
"sn_bin_count_");
146 nr_iterations_ = (
double)param_.getValue(
"nr_iterations_");
147 sn_win_len_ = (
double)param_.getValue(
"sn_win_len_");
149 check_width_internally_ = param_.getValue(
"check_width_internally").toBool();
168 template <
typename PeakType>
170 std::vector<PeakCandidate>& PeakCandidates,
173 for (
Size peak_it = 0; peak_it < PeakCandidates.size(); peak_it++)
175 int i = PeakCandidates[peak_it].index;
176 double central_peak_mz = input[i].getMZ(), central_peak_int = input[i].getIntensity();
177 double left_neighbor_mz = input[i - 1].getMZ(), left_neighbor_int = input[i - 1].getIntensity();
178 double right_neighbor_mz = input[i + 1].getMZ(), right_neighbor_int = input[i + 1].getIntensity();
181 double left_to_central = std::fabs(central_peak_mz - left_neighbor_mz);
182 double central_to_right = std::fabs(right_neighbor_mz - central_peak_mz);
183 double min_spacing = (left_to_central < central_to_right) ? left_to_central : central_to_right;
184 double est_peak_width = peak_width_;
186 if (check_width_internally_ && (left_to_central > est_peak_width || central_to_right > est_peak_width))
189 PeakCandidates[peak_it].integrated_intensity = -1;
190 PeakCandidates[peak_it].leftWidth = -1;
191 PeakCandidates[peak_it].rightWidth = -1;
192 PeakCandidates[peak_it].mz = -1;
196 std::map<double, double> peak_raw_data;
198 peak_raw_data[central_peak_mz] = central_peak_int;
199 peak_raw_data[left_neighbor_mz] = left_neighbor_int;
200 peak_raw_data[right_neighbor_mz] = right_neighbor_int;
206 while ((i - k + 1) > 0
207 && std::fabs(input[i - k].getMZ() - peak_raw_data.begin()->first) < spacing_difference_ * min_spacing
208 && (input[i - k].getIntensity() < peak_raw_data.begin()->second
209 || std::fabs(input[i - k].getMZ() - central_peak_mz) < est_peak_width)
212 if (signal_to_noise_ > 0.0)
214 if (snt.getSignalToNoise(input[i - k]) < signal_to_noise_)
219 peak_raw_data[input[i -
k].getMZ()] = input[i -
k].getIntensity();
222 double leftborder = input[i - k + 1].getMZ();
226 while ((i + k) < input.size()
227 && std::fabs(input[i + k].getMZ() - peak_raw_data.rbegin()->first) < spacing_difference_ * min_spacing
228 && (input[i + k].getIntensity() < peak_raw_data.rbegin()->second
229 || std::fabs(input[i + k].getMZ() - central_peak_mz) < est_peak_width)
232 if (signal_to_noise_ > 0.0)
234 if (snt.getSignalToNoise(input[i + k]) < signal_to_noise_)
240 peak_raw_data[input[i +
k].getMZ()] = input[i +
k].getIntensity();
246 double rightborder = input[i + k - 1].getMZ();
248 double weighted_mz = 0;
249 double integrated_intensity = 0;
250 for (std::map<double, double>::const_iterator map_it = peak_raw_data.begin(); map_it != peak_raw_data.end(); ++map_it)
252 weighted_mz += map_it->first * map_it->second;
253 integrated_intensity += map_it->second;
255 weighted_mz /= integrated_intensity;
258 PeakCandidates[peak_it].integrated_intensity = integrated_intensity;
259 PeakCandidates[peak_it].leftWidth = leftborder;
260 PeakCandidates[peak_it].rightWidth = rightborder;
261 PeakCandidates[peak_it].mz = weighted_mz;
264 double min_diff = std::fabs(weighted_mz - input[i].getMZ());
268 for (
int m = 1; i - m > 0 && leftborder < input[i - m].getMZ(); m++)
270 if (std::fabs(weighted_mz - input[i - m].getMZ()) < min_diff)
272 min_diff = std::fabs(weighted_mz - input[i - m].getMZ());
277 for (
int m = 1; i - m > 0 && rightborder > input[i + m].getMZ(); m++)
279 if (std::fabs(weighted_mz - input[i + m].getMZ()) < min_diff)
281 min_diff = std::fabs(weighted_mz - input[i + m].getMZ());
285 PeakCandidates[peak_it].index = min_i;
301 template <
typename PeakType>
305 if (input.size() < 3)
return;
309 output.SpectrumSettings::operator=(input);
310 output.MetaInfoInterface::operator=(input);
317 std::vector<PeakCandidate> PeakCandidates;
323 pepi_param.
setValue(
"signal_to_noise", signal_to_noise_);
324 pepi_param.
setValue(
"spacing_difference", spacing_difference_);
326 pp.
pick(input, picked_spectrum);
329 std::vector<PeakCandidate> newPeakCandidates_;
331 LOG_DEBUG <<
"Candidates " << picked_spectrum.size() << std::endl;
332 for (
Size k = 0;
k < input.size() && j < picked_spectrum.size();
k++)
334 if (input[
k].getMZ() > picked_spectrum[j].getMZ())
336 LOG_DEBUG <<
"got a value " <<
k <<
" @ " << input[
k] << std::endl;
337 PeakCandidate pc = {
k, picked_spectrum[j].getIntensity(), -1, -1, -1, -1};
338 newPeakCandidates_.push_back(pc);
343 PeakCandidates = newPeakCandidates_;
348 if (signal_to_noise_ > 0.0)
350 Param snt_parameters = snt.getParameters();
351 snt_parameters.
setValue(
"win_len", sn_win_len_);
352 snt_parameters.
setValue(
"bin_count", sn_bin_count_);
353 snt.setParameters(snt_parameters);
358 for (
int i = 0; i < nr_iterations_; i++)
360 pickRecenterPeaks_(input, PeakCandidates, snt);
370 LOG_DEBUG <<
"Will now merge candidates" << std::endl;
371 for (
Size peak_it = 0; peak_it < PeakCandidates.size(); peak_it++)
373 if (PeakCandidates[peak_it].leftWidth < 0)
continue;
376 for (
Size m = peak_it + 1; m < PeakCandidates.size(); m++)
378 if (PeakCandidates[m].mz >= PeakCandidates[peak_it].leftWidth && PeakCandidates[m].mz <= PeakCandidates[peak_it].rightWidth)
380 LOG_DEBUG <<
"Remove peak " << m <<
" : " << PeakCandidates[m].mz <<
" " <<
381 PeakCandidates[m].peak_apex_intensity <<
" (too close to " << PeakCandidates[peak_it].mz <<
382 " " << PeakCandidates[peak_it].peak_apex_intensity <<
")" << std::endl;
383 PeakCandidates[m].leftWidth = PeakCandidates[m].rightWidth = -1;
388 peak.
setMZ(PeakCandidates[peak_it].mz);
389 peak.
setIntensity(PeakCandidates[peak_it].integrated_intensity);
390 output.push_back(peak);
392 LOG_DEBUG <<
"Push peak " << peak_it <<
" " << peak << std::endl;
393 output.
getFloatDataArrays()[0].push_back(PeakCandidates[peak_it].integrated_intensity);
398 LOG_DEBUG <<
"Found seeds: " << PeakCandidates.size() <<
" / Found peaks: " << output.size() << std::endl;
402 template <
typename PeakType>
414 bool ms1_only = param_.getValue(
"ms1_only").toBool();
415 bool clear_meta_data = param_.getValue(
"clear_meta_data").toBool();
418 startProgress(0, input.
size(),
"picking peaks");
419 for (
Size scan_idx = 0; scan_idx != input.
size(); ++scan_idx)
421 if (ms1_only && (input[scan_idx].getMSLevel() != 1))
423 output[scan_idx] = input[scan_idx];
427 pick(input[scan_idx], output[scan_idx]);
428 if (clear_meta_data) {output[scan_idx].getFloatDataArrays().
clear();}
430 setProgress(progress++);
This class implements a peak-picking algorithm for high-resolution MS data (specifically designed for...
Definition: PeakPickerIterative.h:97
~PeakPickerIterative()
Destructor.
Definition: PeakPickerIterative.h:153
void setValue(const String &key, const DataValue &value, const String &description="", const StringList &tags=StringList())
Sets a value.
const Param & getDefaults() const
Non-mutable access to the default parameters.
double spacing_difference_
Definition: PeakPickerIterative.h:105
A 2-dimensional raw data point or peak.
Definition: Peak2D.h:55
UInt getMSLevel() const
Returns the MS level.
Definition: MSSpectrum.h:259
Size size() const
Definition: MSExperiment.h:117
void setMZ(CoordinateType coordinate)
Mutable access to the m/z coordinate (index 1)
Definition: Peak2D.h:197
void sortByPosition()
Lexicographically sorts the peaks by their position.
Definition: MSSpectrum.h:419
void pickRecenterPeaks_(const MSSpectrum< PeakType > &input, std::vector< PeakCandidate > &PeakCandidates, SignalToNoiseEstimatorMedian< MSSpectrum< PeakType > > &snt)
Definition: PeakPickerIterative.h:169
Peak data (also called centroided data or stick data)
Definition: SpectrumSettings.h:74
double signal_to_noise_
Definition: PeakPickerIterative.h:103
double leftWidth
Definition: PeakPickerIterative.h:57
int index
Definition: PeakPickerIterative.h:53
const String & getName() const
Returns the name.
Definition: MSSpectrum.h:271
void setName(const String &name)
Sets the name.
Definition: MSSpectrum.h:277
void resize(Size s)
Definition: MSExperiment.h:122
void setParameters(const Param ¶m)
Sets the parameters.
float mz
Definition: PeakPickerIterative.h:59
int nr_iterations_
Definition: PeakPickerIterative.h:107
#define LOG_DEBUG
Macro for general debugging information.
Definition: LogStream.h:459
void setIntensity(IntensityType intensity)
Non-mutable access to the data point intensity (height)
Definition: Peak2D.h:167
double integrated_intensity
Definition: PeakPickerIterative.h:56
double peak_width_
Definition: PeakPickerIterative.h:104
void pick(const MSSpectrum< PeakType > &input, MSSpectrum< PeakType > &output) const
Applies the peak-picking algorithm to a single spectrum (MSSpectrum). The resulting picked peaks are ...
Definition: PeakPickerHiRes.h:102
int sn_bin_count_
Definition: PeakPickerIterative.h:106
double getRT() const
Definition: MSSpectrum.h:243
void setMSLevel(UInt ms_level)
Sets the MS level.
Definition: MSSpectrum.h:265
void updateMembers_()
This method is used to update extra member variables at the end of the setParameters() method...
Definition: PeakPickerIterative.h:140
void clear(bool clear_meta_data)
Clears all data and meta data.
Definition: MSSpectrum.h:635
void setRT(double rt)
Sets the absolute retention time (is seconds)
Definition: MSSpectrum.h:249
Management and storage of parameters / INI files.
Definition: Param.h:75
In-Memory representation of a mass spectrometry experiment.
Definition: MSExperiment.h:69
bool sort_peaks_by_intensity(const PeakCandidate &a, const PeakCandidate &b)
Definition: PeakPickerIterative.h:63
PeakPickerIterative()
Constructor.
Definition: PeakPickerIterative.h:114
void setType(SpectrumType type)
sets the spectrum type
void pick(const MSSpectrum< PeakType > &input, MSSpectrum< PeakType > &output)
Definition: PeakPickerIterative.h:302
double rightWidth
Definition: PeakPickerIterative.h:58
double sn_win_len_
Definition: PeakPickerIterative.h:108
A small structure to hold peak candidates.
Definition: PeakPickerIterative.h:51
void clear(bool clear_meta_data)
Clears all data and meta data.
Definition: MSExperiment.h:850
Base class for all classes that want to report their progress.
Definition: ProgressLogger.h:55
double peak_apex_intensity
Definition: PeakPickerIterative.h:54
void pickExperiment(const MSExperiment< PeakType > &input, MSExperiment< PeakType > &output)
Definition: PeakPickerIterative.h:403
bool check_width_internally_
Definition: PeakPickerIterative.h:109
A base class for all classes handling default parameters.
Definition: DefaultParamHandler.h:92
const FloatDataArrays & getFloatDataArrays() const
Returns a const reference to the float meta data arrays.
Definition: MSSpectrum.h:298
This class implements a fast peak-picking algorithm best suited for high resolution MS data (FT-ICR-M...
Definition: PeakPickerHiRes.h:75
Description of the experimental settings.
Definition: ExperimentalSettings.h:59