int main(int argc, const char** argv)
{
if (argc < 2) return 1;
// the path to the data should be given on the command line
String tutorial_data_path(argv[1]);
IndexedMzMLFileLoader imzml;
// load data from an indexed MzML file
OnDiscMSExperiment<> map;
imzml.load(tutorial_data_path + "/data/Tutorial_FileIO_indexed.mzML", map);
// Get the first spectrum in memory, do some constant (non-changing) data processing
MSSpectrum<> s = map.getSpectrum(0);
std::cout << "There are " << map.getNrSpectra() << " spectra in the input file." << std::endl;
std::cout << "The first spectrum has " << s.size() << " peaks." << std::endl;
// store the (unmodified) data in a different file
imzml.store("Tutorial_FileIO_output.mzML", map);
return 0;
} //end of main
ExitCodes main_(int, const char**) override
{
//-------------------------------------------------------------
// parameter handling
//-------------------------------------------------------------
String in = getStringOption_("in");
String out = getStringOption_("out");
IndexedMzMLFileLoader loader;
//-------------------------------------------------------------
// loading input
//-------------------------------------------------------------
OnDiscPeakMap exp;
loader.load(in, exp);
// We could write out this warning in the constructor if no spectra have come our way ...
/*
if (ms_exp_raw.empty() && ms_exp_raw.getChromatograms().size() == 0)
{
LOG_WARN << "The given file does not contain any conventional peak data, but might"
" contain chromatograms. This tool currently cannot handle them, sorry.";
return INCOMPATIBLE_INPUT_DATA;
}
*/
// We could check with the first spectrum that we process whether it fulfills the requirements
// check for peak type (profile data required)
/*
if (!ms_exp_raw.empty() && PeakTypeEstimator().estimateType(ms_exp_raw[0].begin(), ms_exp_raw[0].end()) == SpectrumSettings::CENTROID)
{
writeLog_("Warning: OpenMS peak type estimation indicates that this is not profile data!");
}
*/
// We can check each spectrum and throw an error if it is not sorted
// check if spectra are sorted
/*
for (Size i = 0; i < ms_exp_raw.size(); ++i)
{
if (!ms_exp_raw[i].isSorted())
{
writeLog_("Error: Not all spectra are sorted according to peak m/z positions. Use FileFilter to sort the input!");
return INCOMPATIBLE_INPUT_DATA;
}
}
*/
// We can check each chromatogram and throw an error if it is not sorted
//check if chromatograms are sorted
/*
for (Size i = 0; i < ms_exp_raw.getChromatograms().size(); ++i)
{
if (!ms_exp_raw.getChromatogram(i).isSorted())
{
writeLog_("Error: Not all chromatograms are sorted according to peak m/z positions. Use FileFilter to sort the input!");
return INCOMPATIBLE_INPUT_DATA;
}
}
*/
//-------------------------------------------------------------
// pick
//-------------------------------------------------------------
PeakMap ms_exp_peaks;
///////////////////////////////////
// Create PeakPickerHiRes and hand it to the PPHiResMzMLConsumer
///////////////////////////////////
Param pepi_param = getParam_().copy("algorithm:", true);
writeDebug_("Parameters passed to LowMemPeakPickerHiRes", pepi_param, 3);
PeakPickerHiRes pp;
pp.setLogType(log_type_);
pp.setParameters(pepi_param);
pp.pickExperiment(exp, ms_exp_peaks);
//-------------------------------------------------------------
// writing output
//-------------------------------------------------------------
//annotate output with data processing info
addDataProcessing_(ms_exp_peaks, getProcessingInfo_(DataProcessing::PEAK_PICKING));
MzMLFile mz_data_file;
mz_data_file.setLogType(log_type_);
mz_data_file.store(out, ms_exp_peaks);
return EXECUTION_OK;
}
ExitCodes main_(int, const char**) override
{
//-------------------------------------------------------------
// parameter handling
//-------------------------------------------------------------
//input file names
String in = getStringOption_("in");
String read_method = getStringOption_("read_method");
bool load_data = getStringOption_("loadData") == "true";
if (read_method == "streaming")
{
std::cout << "Read method: streaming" << std::endl;
// Create the consumer, set output file name, transform
TICConsumer consumer;
MzMLFile mzml;
mzml.setLogType(log_type_);
PeakFileOptions opt = mzml.getOptions();
opt.setFillData(load_data); // whether to actually load any data
opt.setSkipXMLChecks(true); // save time by not checking base64 strings for whitespaces
opt.setMaxDataPoolSize(100);
opt.setAlwaysAppendData(false);
mzml.setOptions(opt);
mzml.transform(in, &consumer, true, true);
std::cout << "There are " << consumer.nr_spectra << " spectra and " << consumer.nr_peaks << " peaks in the input file." << std::endl;
std::cout << "The total ion current is " << consumer.TIC << std::endl;
size_t after;
SysInfo::getProcessMemoryConsumption(after);
std::cout << " Memory consumption after " << after << std::endl;
}
else if (read_method == "regular")
{
std::cout << "Read method: regular" << std::endl;
MzMLFile mzml;
mzml.setLogType(log_type_);
PeakFileOptions opt = mzml.getOptions();
opt.setFillData(load_data); // whether to actually load any data
opt.setSkipXMLChecks(true); // save time by not checking base64 strings for whitespaces
mzml.setOptions(opt);
PeakMap map;
mzml.load(in, map);
double TIC = 0.0;
long int nr_peaks = 0;
for (Size i =0; i < map.size(); i++)
{
nr_peaks += map[i].size();
for (Size j = 0; j < map[i].size(); j++)
{
TIC += map[i][j].getIntensity();
}
}
std::cout << "There are " << map.size() << " spectra and " << nr_peaks << " peaks in the input file." << std::endl;
std::cout << "The total ion current is " << TIC << std::endl;
size_t after;
SysInfo::getProcessMemoryConsumption(after);
std::cout << " Memory consumption after " << after << std::endl;
}
else if (read_method == "indexed")
{
std::cout << "Read method: indexed" << std::endl;
IndexedMzMLFileLoader imzml;
// load data from an indexed MzML file
OnDiscPeakMap map;
imzml.load(in, map);
double TIC = 0.0;
long int nr_peaks = 0;
if (load_data)
{
for (Size i =0; i < map.getNrSpectra(); i++)
{
OpenMS::Interfaces::SpectrumPtr sptr = map.getSpectrumById(i);
nr_peaks += sptr->getIntensityArray()->data.size();
TIC += std::accumulate(sptr->getIntensityArray()->data.begin(), sptr->getIntensityArray()->data.end(), 0.0);
}
}
std::cout << "There are " << map.getNrSpectra() << " spectra and " << nr_peaks << " peaks in the input file." << std::endl;
std::cout << "The total ion current is " << TIC << std::endl;
size_t after;
SysInfo::getProcessMemoryConsumption(after);
std::cout << " Memory consumption after " << after << std::endl;
}
else if (read_method == "indexed_parallel")
{
std::cout << "Read method: indexed (parallel)" << std::endl;
IndexedMzMLFileLoader imzml;
PeakFileOptions opt = imzml.getOptions();
opt.setFillData(load_data); // whether to actually load any data
imzml.setOptions(opt);
// load data from an indexed MzML file
OnDiscPeakMap map;
map.openFile(in, true);
map.setSkipXMLChecks(true);
double TIC = 0.0;
long int nr_peaks = 0;
if (load_data)
{
// firstprivate means that each thread has its own instance of the
// variable, each copy initialized with the initial value
#ifdef _OPENMP
#pragma omp parallel for firstprivate(map)
#endif
for (SignedSize i =0; i < (SignedSize)map.getNrSpectra(); i++)
{
OpenMS::Interfaces::SpectrumPtr sptr = map.getSpectrumById(i);
double nr_peaks_l = sptr->getIntensityArray()->data.size();
double TIC_l = std::accumulate(sptr->getIntensityArray()->data.begin(), sptr->getIntensityArray()->data.end(), 0.0);
#ifdef _OPENMP
#pragma omp critical (indexed)
#endif
{
TIC += TIC_l;
nr_peaks += nr_peaks_l;
}
}
}
std::cout << "There are " << map.getNrSpectra() << " spectra and " << nr_peaks << " peaks in the input file." << std::endl;
std::cout << "The total ion current is " << TIC << std::endl;
size_t after;
SysInfo::getProcessMemoryConsumption(after);
std::cout << " Memory consumption after " << after << std::endl;
}
else if (read_method == "cached")
{
std::cout << "Read method: cached" << std::endl;
// Special handling of cached mzML as input types:
// we expect two paired input files which we should read into exp
std::vector<String> split_out;
in.split(".cachedMzML", split_out);
if (split_out.size() != 2)
{
LOG_ERROR << "Cannot deduce base path from input '" << in <<
"' (note that '.cachedMzML' should only occur once as the final ending)" << std::endl;
return ILLEGAL_PARAMETERS;
}
String in_meta = split_out[0] + ".mzML";
MzMLFile f;
f.setLogType(log_type_);
CachedmzML cacher;
cacher.setLogType(log_type_);
CachedmzML cache;
cache.createMemdumpIndex(in);
const std::vector<std::streampos> spectra_index = cache.getSpectraIndex();
std::ifstream ifs_;
ifs_.open(in.c_str(), std::ios::binary);
double TIC = 0.0;
long int nr_peaks = 0;
for (Size i=0; i < spectra_index.size(); ++i)
{
BinaryDataArrayPtr mz_array(new BinaryDataArray);
BinaryDataArrayPtr intensity_array(new BinaryDataArray);
int ms_level = -1;
double rt = -1.0;
ifs_.seekg(spectra_index[i]);
CachedmzML::readSpectrumFast(mz_array, intensity_array, ifs_, ms_level, rt);
nr_peaks += intensity_array->data.size();
for (Size j = 0; j < intensity_array->data.size(); j++)
{
TIC += intensity_array->data[j];
}
}
std::cout << "There are " << spectra_index.size() << " spectra and " << nr_peaks << " peaks in the input file." << std::endl;
std::cout << "The total ion current is " << TIC << std::endl;
size_t after;
SysInfo::getProcessMemoryConsumption(after);
std::cout << " Memory consumption after " << after << std::endl;
}
else if (read_method == "cached_parallel")
{
std::cout << "Read method: cached parallel" << std::endl;
// Special handling of cached mzML as input types:
// we expect two paired input files which we should read into exp
std::vector<String> split_out;
in.split(".cachedMzML", split_out);
if (split_out.size() != 2)
{
LOG_ERROR << "Cannot deduce base path from input '" << in <<
"' (note that '.cachedMzML' should only occur once as the final ending)" << std::endl;
return ILLEGAL_PARAMETERS;
}
String in_meta = split_out[0] + ".mzML";
MzMLFile f;
f.setLogType(log_type_);
CachedmzML cacher;
cacher.setLogType(log_type_);
CachedmzML cache;
cache.createMemdumpIndex(in);
const std::vector<std::streampos> spectra_index = cache.getSpectraIndex();
FileAbstraction filestream(in);
double TIC = 0.0;
long int nr_peaks = 0;
#ifdef _OPENMP
#pragma omp parallel for firstprivate(filestream)
#endif
for (SignedSize i=0; i < (SignedSize)spectra_index.size(); ++i)
{
BinaryDataArrayPtr mz_array(new BinaryDataArray);
BinaryDataArrayPtr intensity_array(new BinaryDataArray);
int ms_level = -1;
double rt = -1.0;
// we only change the position of the thread-local filestream
filestream.getStream().seekg(spectra_index[i]);
CachedmzML::readSpectrumFast(mz_array, intensity_array, filestream.getStream(), ms_level, rt);
double nr_peaks_l = intensity_array->data.size();
double TIC_l = std::accumulate(intensity_array->data.begin(), intensity_array->data.end(), 0.0);
#ifdef _OPENMP
#pragma omp critical (indexed)
#endif
{
TIC += TIC_l;
nr_peaks += nr_peaks_l;
}
}
std::cout << "There are " << spectra_index.size() << " spectra and " << nr_peaks << " peaks in the input file." << std::endl;
std::cout << "The total ion current is " << TIC << std::endl;
size_t after;
SysInfo::getProcessMemoryConsumption(after);
std::cout << " Memory consumption after " << after << std::endl;
}
return EXECUTION_OK;
}