void FwdFft<ComplexFFTWVector>::run(void)
{
if (wrapComplex_)
{
freqShift(vTime_);
}
run_();
}
void HeatSimulator::simulate() {
if (flags_.isCalculated_)
return;
heatGenerationMultiplier_ = owner_.attribute_(AttributeID::heatGenerationMultiplier)->value_();
for (auto slot: {Module::Slot::hi, Module::Slot::med, Module::Slot::low})
run_(slot);
flags_.isCalculated_ = true;
}
bool TestCase::run() const
{
if (initialize() == false)
return false;
if (run_() == false)
return false;
return finalize();
}
// Default constructor
WorkerMultiThreadedT(std::string const &worker_name,
std::shared_ptr<BrokerType> broker)
: Base(worker_name, broker),
context_pool_(new context_pool_type()),
executors_(4, context_pool_),
terminate_(false) {
// Add service result to the broker
this->add_service(result_signal);
// Start thread that performs preprocessing and post-processing
worker_thread_ = std::thread([this]() { run_(); });
}
void
PrefetchData::operator()()
{
try
{
run_();
}
CATCH_STD_ALL_EWHAT({
LOG_ERROR("Exception in prefetch thread: " << EWHAT <<
" - exiting");
ASSERT(false);
});
void MassTraceDetection::run(const PeakMap& input_exp, std::vector<MassTrace>& found_masstraces)
{
// make sure the output vector is empty
found_masstraces.clear();
// gather all peaks that are potential chromatographic peak apices
// - use work_exp for actual work (remove peaks below noise threshold)
// - store potential apices in chrom_apices
PeakMap work_exp;
MapIdxSortedByInt chrom_apices;
Size total_peak_count(0);
std::vector<Size> spec_offsets;
spec_offsets.push_back(0);
Size spectra_count(0);
// *********************************************************** //
// Step 1: Detecting potential chromatographic apices
// *********************************************************** //
for (PeakMap::ConstIterator it = input_exp.begin(); it != input_exp.end(); ++it)
{
// check if this is a MS1 survey scan
if (it->getMSLevel() != 1) continue;
std::vector<Size> indices_passing;
for (Size peak_idx = 0; peak_idx < it->size(); ++peak_idx)
{
double tmp_peak_int((*it)[peak_idx].getIntensity());
if (tmp_peak_int > noise_threshold_int_)
{
// Assume that noise_threshold_int_ contains the noise level of the
// data and we want to be chrom_peak_snr times above the noise level
// --> add this peak as possible chromatographic apex
if (tmp_peak_int > chrom_peak_snr_ * noise_threshold_int_)
{
chrom_apices.insert(std::make_pair(tmp_peak_int, std::make_pair(spectra_count, indices_passing.size())));
}
indices_passing.push_back(peak_idx);
++total_peak_count;
}
}
PeakMap::SpectrumType tmp_spec(*it);
tmp_spec.select(indices_passing);
work_exp.addSpectrum(tmp_spec);
spec_offsets.push_back(spec_offsets.back() + tmp_spec.size());
++spectra_count;
}
if (spectra_count < 3)
{
throw Exception::InvalidValue(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION,
"Input map consists of too few MS1 spectra (less than 3!). Aborting...", String(spectra_count));
}
// discard last spectrum's offset
spec_offsets.pop_back();
// *********************************************************************
// Step 2: start extending mass traces beginning with the apex peak (go
// through all peaks in order of decreasing intensity)
// *********************************************************************
run_(chrom_apices, total_peak_count, work_exp, spec_offsets, found_masstraces);
return;
} // end of MassTraceDetection::run
ReturnFlag Algorithm::run(){
ReturnFlag rf=run_();
m_isTerminated=true;
return rf;
};
void RevFft<ComplexFFTWVector>::run(void)
{
run_();
if (wrapComplex_)
freqShift(vTime_);
}
void RevFft<TimeType>::run(void)
{
run_();
}
void FwdFft<TimeType>::run(void)
{
run_();
}
void QTClusterFinder::run(const std::vector<FeatureMap<> > & input_maps,
ConsensusMap & result_map)
{
run_(input_maps, result_map);
}
void QTClusterFinder::run(const vector<ConsensusMap> & input_maps,
ConsensusMap & result_map)
{
run_(input_maps, result_map);
}
