void MassTraceDetection::run(PeakMap::ConstAreaIterator& begin,
PeakMap::ConstAreaIterator& end,
std::vector<MassTrace>& found_masstraces)
{
PeakMap map;
MSSpectrum<Peak1D> current_spectrum;
if (begin == end)
{
return;
}
for (; begin != end; ++begin)
{
// AreaIterator points on novel spectrum?
if (begin.getRT() != current_spectrum.getRT())
{
// save new spectrum in map
if (current_spectrum.getRT() != -1)
{
map.addSpectrum(current_spectrum);
}
current_spectrum.clear(false);
current_spectrum.setRT(begin.getRT());
}
current_spectrum.push_back(*begin);
}
map.addSpectrum(current_spectrum);
run(map, found_masstraces);
}
void getSwathFile(PeakMap& exp, int nr_swathes=32, bool ms1=true)
{
if (ms1)
{
MSSpectrum s;
s.setMSLevel(1);
Peak1D p; p.setMZ(100); p.setIntensity(200);
s.push_back(p);
exp.addSpectrum(s);
}
for (int i = 0; i< nr_swathes; i++)
{
MSSpectrum s;
s.setMSLevel(2);
std::vector<Precursor> prec(1);
prec[0].setIsolationWindowLowerOffset(12.5);
prec[0].setIsolationWindowUpperOffset(12.5);
prec[0].setMZ(400 + i*25 + 12.5);
s.setPrecursors(prec);
Peak1D p; p.setMZ(101 + i); p.setIntensity(201 + i);
s.push_back(p);
exp.addSpectrum(s);
}
}
bool IDEvaluationBase::addSearchFile(const String& file_name)
{
MSSpectrum<> points;
if (!loadCurve(file_name, points)) return false;
data_.addSpectrum(points);
PeakMap* exp = new PeakMap();
exp->addSpectrum(points);
spec_1d_->canvas()->addLayer(SpectrumCanvas::ExperimentSharedPtrType(exp));
spec_1d_->canvas()->setLayerName(spec_1d_->canvas()->getLayerCount() - 1, points.getMetaValue("search_engine"));
// set intensity mode (after spectrum has been added!)
setIntensityMode((int) SpectrumCanvas::IM_SNAP);
return true;
}
// Wrong assignment of the mono-isotopic mass for precursors are assumed:
// - if precursor_mz matches the mz of a non-monoisotopic feature mass trace
// - and in the case that believe_charge is true: if feature_charge matches the precursor_charge
// In the case of wrong mono-isotopic assignment several options for correction are available:
// keep_original will create a copy of the precursor and tandem spectrum for the new mono-isotopic mass trace and retain the original one
// all_matching_features does this not for only the closest feature but all features in a question
set<Size> correctToNearestFeature(const FeatureMap& features, PeakMap & exp, double rt_tolerance_s = 0.0, double mz_tolerance = 0.0, bool ppm = true, bool believe_charge = false, bool keep_original = false, bool all_matching_features = false, int max_trace = 2)
{
set<Size> corrected_precursors;
// for each precursor/MS2 find all features that are in the given tolerance window (bounding box + rt tolerances)
// if believe_charge is set, only add features that match the precursor charge
map<Size, set<Size> > scan_idx_to_feature_idx;
for (Size scan = 0; scan != exp.size(); ++scan)
{
// skip non-tandem mass spectra
if (exp[scan].getMSLevel() != 2 || exp[scan].getPrecursors().empty()) continue;
// extract precusor / MS2 information
const double pc_mz = exp[scan].getPrecursors()[0].getMZ();
const double rt = exp[scan].getRT();
const int pc_charge = exp[scan].getPrecursors()[0].getCharge();
for (Size f = 0; f != features.size(); ++f)
{
// feature is incompatible if believe_charge is set and charges don't match
if (believe_charge && features[f].getCharge() != pc_charge) continue;
// check if precursor/MS2 position overlap with feature
if (overlaps_(features[f], rt, pc_mz, rt_tolerance_s))
{
scan_idx_to_feature_idx[scan].insert(f);
}
}
}
// filter sets to retain compatible features:
// if precursor_mz = feature_mz + n * feature_charge (+/- mz_tolerance) a feature is compatible, others are removed from the set
for (map<Size, set<Size> >::iterator it = scan_idx_to_feature_idx.begin(); it != scan_idx_to_feature_idx.end(); ++it)
{
const Size scan = it->first;
const double pc_mz = exp[scan].getPrecursors()[0].getMZ();
const double mz_tolerance_da = ppm ? pc_mz * mz_tolerance * 1e-6 : mz_tolerance;
// Note: This is the "delete while iterating" pattern so mind the pre- and postincrement
for (set<Size>::iterator sit = it->second.begin(); sit != it->second.end(); )
{
if (!compatible_(features[*sit], pc_mz, mz_tolerance_da, max_trace))
{
it->second.erase(sit++);
}
else
{
++sit;
}
}
}
// remove entries with no compatible features (empty sets).
// Note: This is the "delete while iterating" pattern so mind the pre- and postincrement
for (map<Size, set<Size> >::iterator it = scan_idx_to_feature_idx.begin(); it != scan_idx_to_feature_idx.end(); )
{
if (it->second.empty())
{
scan_idx_to_feature_idx.erase(it++);
}
else
{
++it;
}
}
if (debug_level_ > 0)
{
LOG_INFO << "Number of precursors with compatible features: " << scan_idx_to_feature_idx.size() << endl;
}
if (!all_matching_features)
{
// keep only nearest features in set
for (map<Size, set<Size> >::iterator it = scan_idx_to_feature_idx.begin(); it != scan_idx_to_feature_idx.end(); ++it)
{
const Size scan = it->first;
const double pc_rt = exp[scan].getRT();
double min_distance = 1e16;
set<Size>::iterator best_feature = it->second.begin();
// determine nearest/best feature
for (set<Size>::iterator sit = it->second.begin(); sit != it->second.end(); ++sit)
{
const double current_distance = fabs(pc_rt - features[*sit].getRT());
if (current_distance < min_distance)
{
min_distance = current_distance;
best_feature = sit;
}
}
// delete all except the nearest/best feature
// Note: This is the "delete while iterating" pattern so mind the pre- and postincrement
for (set<Size>::iterator sit = it->second.begin(); sit != it->second.end(); )
{
if (sit != best_feature)
{
it->second.erase(sit++);
}
else
{
++sit;
}
}
}
}
// depending on all_matching_features option, only the nearest or all features are contained in the sets
// depending on options: move/copy corrected precursor and tandem spectrum
if (keep_original)
{
// duplicate spectra for each feature in set and adapt precursor_mz and precursor_charge to feature_mz and feature_charge
for (map<Size, set<Size> >::iterator it = scan_idx_to_feature_idx.begin(); it != scan_idx_to_feature_idx.end(); ++it)
{
const Size scan = it->first;
MSSpectrum<> spectrum = exp[scan];
corrected_precursors.insert(scan);
for (set<Size>::iterator f_it = it->second.begin(); f_it != it->second.end(); ++f_it)
{
spectrum.getPrecursors()[0].setMZ(features[*f_it].getMZ());
spectrum.getPrecursors()[0].setCharge(features[*f_it].getCharge());
exp.addSpectrum(spectrum);
}
}
}
else
{
// set precursor_mz and _charge to the feature_mz and _charge
for (map<Size, set<Size> >::iterator it = scan_idx_to_feature_idx.begin(); it != scan_idx_to_feature_idx.end(); ++it)
{
const Size scan = it->first;
exp[scan].getPrecursors()[0].setMZ(features[*it->second.begin()].getMZ());
exp[scan].getPrecursors()[0].setCharge(features[*it->second.begin()].getCharge());
corrected_precursors.insert(scan);
}
}
return corrected_precursors;
}