ExitCodes main_(int, const char **) { //------------------------------------------------------------- // parameter handling //------------------------------------------------------------- //input/output files String in(getStringOption_("in")); String out(getStringOption_("out")); //------------------------------------------------------------- // loading input //------------------------------------------------------------- MSExperiment<> exp; MzMLFile f; f.setLogType(log_type_); f.load(in, exp); //------------------------------------------------------------- // if meta data arrays are present, remove them and warn //------------------------------------------------------------- if (exp.clearMetaDataArrays()) { writeLog_("Warning: Spectrum meta data arrays cannot be sorted. They are deleted."); } //------------------------------------------------------------- // filter //------------------------------------------------------------- Param filter_param = getParam_().copy("algorithm:", true); writeDebug_("Used filter parameters", filter_param, 3); BernNorm filter; filter.setParameters(filter_param); filter.filterPeakMap(exp); //------------------------------------------------------------- // writing output //------------------------------------------------------------- //annotate output with data processing info addDataProcessing_(exp, getProcessingInfo_(DataProcessing::FILTERING)); f.store(out, exp); return EXECUTION_OK; }
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]); MzXMLFile mzxml; MzMLFile mzml; // temporary data storage MSExperiment<Peak1D> map; // convert MzXML to MzML mzxml.load(tutorial_data_path + "/data/Tutorial_FileIO.mzXML", map); mzml.store("Tutorial_FileIO.mzML", map); return 0; } //end of main
ExitCodes main_(int, const char **) { //------------------------------------------------------------- // parameter handling //------------------------------------------------------------- //input/output files String in(getStringOption_("in")); String out(getStringOption_("out")); //------------------------------------------------------------- // loading input //------------------------------------------------------------- MSExperiment<> exp; MzMLFile f; f.setLogType(log_type_); f.load(in, exp); //------------------------------------------------------------- // filter //------------------------------------------------------------- Param filter_param = getParam_().copy("algorithm:", true); writeDebug_("Used filter parameters", filter_param, 3); Normalizer filter; filter.setParameters(filter_param); filter.filterPeakMap(exp); //------------------------------------------------------------- // writing output //------------------------------------------------------------- //annotate output with data processing info addDataProcessing_(exp, getProcessingInfo_(DataProcessing::FILTERING)); f.store(out, exp); return EXECUTION_OK; }
ExitCodes main_(int, const char **) { //---------------------------------------------------------------- // load data //---------------------------------------------------------------- String in = getStringOption_("in"); String out = getStringOption_("out"); MSExperiment<> exp; MzMLFile f; f.setLogType(log_type_); f.load(in, exp); DoubleReal sampling_rate = getDoubleOption_("sampling_rate"); LinearResampler lin_resampler; Param resampler_param; resampler_param.setValue("spacing", sampling_rate); lin_resampler.setParameters(resampler_param); // resample every scan for (Size i = 0; i < exp.size(); ++i) { lin_resampler.raster(exp[i]); } //clear meta data because they are no longer meaningful exp.clearMetaDataArrays(); //annotate output with data processing info addDataProcessing_(exp, getProcessingInfo_(DataProcessing::DATA_PROCESSING)); //store output f.store(out, exp); return EXECUTION_OK; }
ExitCodes main_(int , const char**) override { String in = getStringOption_("in"); String out = getStringOption_("out"); MapType exp; MapType out_exp; Param picker_param = getParam_().copy("algorithm:", true); MzMLFile f; f.setLogType(log_type_); f.load(in,exp); PeakPickerIterative pp; pp.setParameters(picker_param); pp.setLogType(log_type_); pp.pickExperiment(exp, out_exp); addDataProcessing_(out_exp, getProcessingInfo_(DataProcessing::PEAK_PICKING)); f.store(out,out_exp); return EXECUTION_OK; }
ExitCodes main_(int, const char**) { //------------------------------------------------------------- // parameter handling //------------------------------------------------------------- //file list StringList file_list = getStringList_("in"); //file type FileHandler fh; FileTypes::Type force_type; if (getStringOption_("in_type").size() > 0) { force_type = FileTypes::nameToType(getStringOption_("in_type")); } else { force_type = fh.getType(file_list[0]); } //output file names and types String out_file = getStringOption_("out"); //------------------------------------------------------------- // calculations //------------------------------------------------------------- bool annotate_file_origin = getFlag_("annotate_file_origin"); if (force_type == FileTypes::FEATUREXML) { FeatureMap<> out; for (Size i = 0; i < file_list.size(); ++i) { FeatureMap<> map; FeatureXMLFile fh; fh.load(file_list[i], map); if (annotate_file_origin) { for (FeatureMap<>::iterator it = map.begin(); it != map.end(); ++it) { it->setMetaValue("file_origin", DataValue(file_list[i])); } } out += map; } //------------------------------------------------------------- // writing output //------------------------------------------------------------- //annotate output with data processing info addDataProcessing_(out, getProcessingInfo_(DataProcessing::FORMAT_CONVERSION)); FeatureXMLFile f; f.store(out_file, out); } else if (force_type == FileTypes::CONSENSUSXML) { ConsensusMap out; ConsensusXMLFile fh; fh.load(file_list[0], out); //skip first file for (Size i = 1; i < file_list.size(); ++i) { ConsensusMap map; ConsensusXMLFile fh; fh.load(file_list[i], map); if (annotate_file_origin) { for (ConsensusMap::iterator it = map.begin(); it != map.end(); ++it) { it->setMetaValue("file_origin", DataValue(file_list[i])); } } out += map; } //------------------------------------------------------------- // writing output //------------------------------------------------------------- //annotate output with data processing info addDataProcessing_(out, getProcessingInfo_(DataProcessing::FORMAT_CONVERSION)); ConsensusXMLFile f; f.store(out_file, out); } else if (force_type == FileTypes::TRAML) { TargetedExperiment out; for (Size i = 0; i < file_list.size(); ++i) { TargetedExperiment map; TraMLFile fh; fh.load(file_list[i], map); out += map; } //------------------------------------------------------------- // writing output //------------------------------------------------------------- //annotate output with data processing info Software software; software.setName("FileMerger"); software.setVersion(VersionInfo::getVersion()); out.addSoftware(software); TraMLFile f; f.store(out_file, out); } else { // we might want to combine different types, thus we only // query in_type (which applies to all files) // and not the suffix or content of a single file force_type = FileTypes::nameToType(getStringOption_("in_type")); //rt bool rt_auto_number = getFlag_("raw:rt_auto"); bool rt_filename = getFlag_("raw:rt_filename"); bool rt_custom = false; DoubleList custom_rts = getDoubleList_("raw:rt_custom"); if (custom_rts.size() != 0) { rt_custom = true; if (custom_rts.size() != file_list.size()) { writeLog_("Custom retention time list must have as many elements as there are input files!"); printUsage_(); return ILLEGAL_PARAMETERS; } } //ms level bool user_ms_level = getFlag_("raw:user_ms_level"); MSExperiment<> out; out.reserve(file_list.size()); UInt rt_auto = 0; UInt native_id = 0; std::vector<MSChromatogram<ChromatogramPeak> > all_chromatograms; for (Size i = 0; i < file_list.size(); ++i) { String filename = file_list[i]; //load file MSExperiment<> in; fh.loadExperiment(filename, in, force_type, log_type_); if (in.empty() && in.getChromatograms().empty()) { writeLog_(String("Warning: Empty file '") + filename + "'!"); continue; } out.reserve(out.size() + in.size()); //warn if custom RT and more than one scan in input file if (rt_custom && in.size() > 1) { writeLog_(String("Warning: More than one scan in file '") + filename + "'! All scans will have the same retention time!"); } for (MSExperiment<>::const_iterator it2 = in.begin(); it2 != in.end(); ++it2) { //handle rt Real rt_final = it2->getRT(); if (rt_auto_number) { rt_final = ++rt_auto; } else if (rt_custom) { rt_final = custom_rts[i]; } else if (rt_filename) { if (!filename.hasSubstring("rt")) { writeLog_(String("Warning: cannot guess retention time from filename as it does not contain 'rt'")); } for (Size i = 0; i < filename.size(); ++i) { if (filename[i] == 'r' && ++i != filename.size() && filename[i] == 't' && ++i != filename.size() && isdigit(filename[i])) { String rt; while (i != filename.size() && (filename[i] == '.' || isdigit(filename[i]))) { rt += filename[i++]; } if (rt.size() > 0) { // remove dot from rt3892.98.dta // ^ if (rt[rt.size() - 1] == '.') { // remove last character rt.erase(rt.end() - 1); } } try { float tmp = rt.toFloat(); rt_final = tmp; } catch (Exception::ConversionError) { writeLog_(String("Warning: cannot convert the found retention time in a value '" + rt + "'.")); } } } } // none of the rt methods were successful if (rt_final == -1) { writeLog_(String("Warning: No valid retention time for output scan '") + rt_auto + "' from file '" + filename + "'"); } out.addSpectrum(*it2); out.getSpectra().back().setRT(rt_final); out.getSpectra().back().setNativeID(native_id); if (user_ms_level) { out.getSpectra().back().setMSLevel((int)getIntOption_("raw:ms_level")); } ++native_id; } // if we had only one spectrum, we can annotate it directly, for more spectra, we just name the source file leaving the spectra unannotated (to avoid a long and redundant list of sourceFiles) if (in.size() == 1) { out.getSpectra().back().setSourceFile(in.getSourceFiles()[0]); in.getSourceFiles().clear(); // delete source file annotated from source file (its in the spectrum anyways) } // copy experimental settings from first file if (i == 0) { out.ExperimentalSettings::operator=(in); } else // otherwise append { out.getSourceFiles().insert(out.getSourceFiles().end(), in.getSourceFiles().begin(), in.getSourceFiles().end()); // could be emtpty if spectrum was annotated above, but that's ok then } // also add the chromatograms for (std::vector<MSChromatogram<ChromatogramPeak> >::const_iterator it2 = in.getChromatograms().begin(); it2 != in.getChromatograms().end(); ++it2) { all_chromatograms.push_back(*it2); } } // set the chromatograms out.setChromatograms(all_chromatograms); //------------------------------------------------------------- // writing output //------------------------------------------------------------- //annotate output with data processing info addDataProcessing_(out, getProcessingInfo_(DataProcessing::FORMAT_CONVERSION)); MzMLFile f; f.setLogType(log_type_); f.store(out_file, out); } return EXECUTION_OK; }
ExitCodes main_(int , const char**) { String in = getStringOption_("in"); String out_meta = getStringOption_("out"); String in_cached = in + ".cached"; String out_cached = out_meta + ".cached"; bool convert_back = getFlag_("convert_back"); if (!convert_back) { MapType exp; CachedmzML cacher; MzMLFile f; cacher.setLogType(log_type_); f.setLogType(log_type_); f.load(in,exp); cacher.writeMemdump(exp, out_cached); DataProcessing dp; std::set<DataProcessing::ProcessingAction> actions; actions.insert(DataProcessing::FORMAT_CONVERSION); dp.setProcessingActions(actions); dp.setMetaValue("cached_data", "true"); for (Size i=0; i<exp.size(); ++i) { exp[i].getDataProcessing().push_back(dp); } std::vector<MSChromatogram<ChromatogramPeak> > chromatograms = exp.getChromatograms(); for (Size i=0; i<chromatograms.size(); ++i) { chromatograms[i].getDataProcessing().push_back(dp); } exp.setChromatograms(chromatograms); cacher.writeMetadata(exp, out_meta); } else { MzMLFile f; MapType meta_exp; CachedmzML cacher; MapType exp_reading; cacher.setLogType(log_type_); f.setLogType(log_type_); f.load(in,meta_exp); cacher.readMemdump(exp_reading, in_cached); std::cout << " read back, got " << exp_reading.size() << " spectra " << exp_reading.getChromatograms().size() << " chromats " << std::endl; { for (Size i=0; i<meta_exp.size(); ++i) { for (Size j = 0; j < meta_exp[i].getDataProcessing().size(); j++) { DataProcessing& dp = meta_exp[i].getDataProcessing()[j]; if (dp.metaValueExists("cached_data")) { dp.removeMetaValue("cached_data"); } } } std::vector<MSChromatogram<ChromatogramPeak> > chromatograms = meta_exp.getChromatograms(); for (Size i=0; i<chromatograms.size(); ++i) { for (Size j = 0; j < chromatograms[i].getDataProcessing().size(); j++) { DataProcessing& dp = chromatograms[i].getDataProcessing()[j]; if (dp.metaValueExists("cached_data")) { dp.removeMetaValue("cached_data"); } } } } if (meta_exp.size() != exp_reading.size()) { std::cerr << " Both experiments need to have the same size!"; } for (Size i=0; i<exp_reading.size(); ++i) { for (Size j = 0; j < exp_reading[i].size(); j++) { meta_exp[i].push_back(exp_reading[i][j]); } } std::vector<MSChromatogram<ChromatogramPeak> > chromatograms = exp_reading.getChromatograms(); std::vector<MSChromatogram<ChromatogramPeak> > old_chromatograms = meta_exp.getChromatograms(); for (Size i=0; i<chromatograms.size(); ++i) { for (Size j = 0; j < chromatograms[i].size(); j++) { old_chromatograms[i].push_back(chromatograms[i][j]); } } meta_exp.setChromatograms(old_chromatograms); f.store(out_meta,meta_exp); } return EXECUTION_OK; }
ExitCodes main_(int, const char **) { //------------------------------------------------------------- // parsing parameters //------------------------------------------------------------- String in(getStringOption_("in")); String out(getStringOption_("out")); Size num_spots_per_row(getIntOption_("num_spots_per_row")); double RT_distance(getDoubleOption_("RT_distance")); //------------------------------------------------------------- // reading input //------------------------------------------------------------- PeakMap exp; MzMLFile f; f.setLogType(log_type_); f.load(in, exp); //------------------------------------------------------------- // calculations //------------------------------------------------------------- ProgressLogger pl; pl.setLogType(log_type_); pl.startProgress(0, exp.size(), "Assigning pseudo RTs."); Size num_ms1(0), num_ms1_base(0), row_counter(0); bool row_to_reverse(false); double actual_RT(0); for (Size i = 0; i != exp.size(); ++i) { pl.setProgress(i); if (row_to_reverse) { actual_RT = (double)(num_ms1_base + (num_spots_per_row - row_counter)) * RT_distance; writeDebug_("RT=" + String(actual_RT) + " (modified, row_counter=" + String(row_counter) + ")", 1); } else { actual_RT = (double)num_ms1 * RT_distance; writeDebug_("RT=" + String(actual_RT), 1); } exp[i].setRT(actual_RT); if (exp[i].getMSLevel() == 1) { if (++row_counter >= num_spots_per_row) { row_counter = 0; if (row_to_reverse) { row_to_reverse = false; } else { row_to_reverse = true; } } ++num_ms1; if (!row_to_reverse) { num_ms1_base = num_ms1; } } } pl.endProgress(); // sort the spectra according to their new RT exp.sortSpectra(); //------------------------------------------------------------- // writing output //------------------------------------------------------------- f.store(out, exp); return EXECUTION_OK; }
ExitCodes main_(int, const char **) { StringList file_list = getStringList_("in"); String tr_file_str = getStringOption_("tr"); String out = getStringOption_("out"); bool is_swath = getFlag_("is_swath"); bool ppm = getFlag_("ppm"); bool extract_MS1 = getFlag_("extract_MS1"); double min_upper_edge_dist = getDoubleOption_("min_upper_edge_dist"); double mz_extraction_window = getDoubleOption_("mz_window"); double rt_extraction_window = getDoubleOption_("rt_window"); String extraction_function = getStringOption_("extraction_function"); // If we have a transformation file, trafo will transform the RT in the // scoring according to the model. If we dont have one, it will apply the // null transformation. String trafo_in = getStringOption_("rt_norm"); TransformationDescription trafo; if (trafo_in.size() > 0) { TransformationXMLFile trafoxml; String model_type = getStringOption_("model:type"); Param model_params = getParam_().copy("model:", true); trafoxml.load(trafo_in, trafo); trafo.fitModel(model_type, model_params); } TransformationDescription trafo_inverse = trafo; trafo_inverse.invert(); const char * tr_file = tr_file_str.c_str(); MapType out_exp; std::vector< OpenMS::MSChromatogram > chromatograms; TraMLFile traml; OpenMS::TargetedExperiment targeted_exp; std::cout << "Loading TraML file" << std::endl; traml.load(tr_file, targeted_exp); std::cout << "Loaded TraML file" << std::endl; // Do parallelization over the different input files // Only in OpenMP 3.0 are unsigned loop variables allowed #ifdef _OPENMP #pragma omp parallel for #endif for (SignedSize i = 0; i < boost::numeric_cast<SignedSize>(file_list.size()); ++i) { boost::shared_ptr<PeakMap > exp(new PeakMap); MzMLFile f; // Logging and output to the console // IF_MASTERTHREAD f.setLogType(log_type_); // Find the transitions to extract and extract them MapType tmp_out; OpenMS::TargetedExperiment transition_exp_used; f.load(file_list[i], *exp); if (exp->empty() ) { continue; } // if empty, go on OpenSwath::SpectrumAccessPtr expptr = SimpleOpenMSSpectraFactory::getSpectrumAccessOpenMSPtr(exp); bool do_continue = true; if (is_swath) { do_continue = OpenSwathHelper::checkSwathMapAndSelectTransitions(*exp, targeted_exp, transition_exp_used, min_upper_edge_dist); } else { transition_exp_used = targeted_exp; } #ifdef _OPENMP #pragma omp critical (OpenSwathChromatogramExtractor_metadata) #endif // after loading the first file, copy the meta data from that experiment // this may happen *after* chromatograms were already added to the // output, thus we do NOT fill the experiment here but rather store all // the chromatograms in the "chromatograms" array and store them in // out_exp afterwards. if (i == 0) { out_exp = *exp; out_exp.clear(false); } std::cout << "Extracting " << transition_exp_used.getTransitions().size() << " transitions" << std::endl; std::vector< OpenSwath::ChromatogramPtr > chromatogram_ptrs; std::vector< ChromatogramExtractor::ExtractionCoordinates > coordinates; // continue if the map is not empty if (do_continue) { // Prepare the coordinates (with or without rt extraction) and then extract the chromatograms ChromatogramExtractor extractor; if (rt_extraction_window < 0) { extractor.prepare_coordinates(chromatogram_ptrs, coordinates, transition_exp_used, rt_extraction_window, extract_MS1); } else { // Use an rt extraction window of 0.0 which will just write the retention time in start / end positions extractor.prepare_coordinates(chromatogram_ptrs, coordinates, transition_exp_used, 0.0, extract_MS1); for (std::vector< ChromatogramExtractor::ExtractionCoordinates >::iterator it = coordinates.begin(); it != coordinates.end(); ++it) { it->rt_start = trafo_inverse.apply(it->rt_start) - rt_extraction_window / 2.0; it->rt_end = trafo_inverse.apply(it->rt_end) + rt_extraction_window / 2.0; } } extractor.extractChromatograms(expptr, chromatogram_ptrs, coordinates, mz_extraction_window, ppm, extraction_function); #ifdef _OPENMP #pragma omp critical (OpenSwathChromatogramExtractor_insertMS1) #endif { // Remove potential meta value indicating cached data SpectrumSettings exp_settings = (*exp)[0]; for (Size j = 0; j < exp_settings.getDataProcessing().size(); j++) { if (exp_settings.getDataProcessing()[j]->metaValueExists("cached_data")) { exp_settings.getDataProcessing()[j]->removeMetaValue("cached_data"); } } extractor.return_chromatogram(chromatogram_ptrs, coordinates, transition_exp_used, exp_settings, chromatograms, extract_MS1); } } // end of do_continue } // end of loop over all files / end of OpenMP // TODO check that no chromatogram IDs occur multiple times ! // store the output out_exp.setChromatograms(chromatograms); MzMLFile mzf; mzf.setLogType(log_type_); addDataProcessing_(out_exp, getProcessingInfo_(DataProcessing::SMOOTHING)); mzf.store(out, out_exp); return EXECUTION_OK; }
ExitCodes main_(int, const char **) override { //------------------------------------------------------------- // parameter handling //------------------------------------------------------------- String in = getStringOption_("in"); String out = getStringOption_("out"); //------------------------------------------------------------- // loading input //------------------------------------------------------------- PeakMap exp; MzMLFile f; f.load(in, exp); //------------------------------------------------------------- // calculations //------------------------------------------------------------- //determine maximum peak exp.updateRanges(); double max = exp.getMaxInt() / 100.0; for (PeakMap::Iterator it = exp.begin(); it != exp.end(); ++it) { if (it->getMSLevel() < 2) { for (PeakMap::SpectrumType::Iterator it2 = it->begin(); it2 != it->end(); ++it2) { it2->setIntensity(it2->getIntensity() / max); } } } /// @todo add chromatogram support for normalization, e.g. for MRM stuff (Andreas) /* vector<MSChromatogram > chroms = exp.getChromatograms(); double sum(0); for (vector<MSChromatogram >::iterator it = chroms.begin(); it != chroms.end(); ++it) { for (MSChromatogram::Iterator it2 = it->begin(); it2 != it->end(); ++it2) { sum += it2->getIntensity(); } } for (vector<MSChromatogram >::iterator it = chroms.begin(); it != chroms.end(); ++it) { for (MSChromatogram::Iterator it2 = it->begin(); it2 != it->end(); ++it2) { it2->setIntensity(it2->getIntensity() / sum * 1000000.0); } } exp.setChromatograms(chroms); */ //------------------------------------------------------------- // writing output //------------------------------------------------------------- //annotate output with data processing info addDataProcessing_(exp, getProcessingInfo_(DataProcessing::NORMALIZATION)); f.store(out, exp); return EXECUTION_OK; }
ExitCodes main_(int, const char**) { //------------------------------------------------------------- // parameter handling //------------------------------------------------------------- // file list StringList file_list = getStringList_("in"); // file type FileHandler file_handler; FileTypes::Type force_type; if (getStringOption_("in_type").size() > 0) { force_type = FileTypes::nameToType(getStringOption_("in_type")); } else { force_type = file_handler.getType(file_list[0]); } // output file names and types String out_file = getStringOption_("out"); bool annotate_file_origin = getFlag_("annotate_file_origin"); rt_gap_ = getDoubleOption_("rt_concat:gap"); vector<String> trafo_out = getStringList_("rt_concat:trafo_out"); if (trafo_out.empty()) { // resize now so we don't have to worry about indexing out of bounds: trafo_out.resize(file_list.size()); } else if (trafo_out.size() != file_list.size()) { writeLog_("Error: Number of transformation output files must equal the number of input files (parameters 'rt_concat:trafo_out'/'in')!"); return ILLEGAL_PARAMETERS; } //------------------------------------------------------------- // calculations //------------------------------------------------------------- if (force_type == FileTypes::FEATUREXML) { FeatureMap out; FeatureXMLFile fh; for (Size i = 0; i < file_list.size(); ++i) { FeatureMap map; fh.load(file_list[i], map); if (annotate_file_origin) { for (FeatureMap::iterator it = map.begin(); it != map.end(); ++it) { it->setMetaValue("file_origin", DataValue(file_list[i])); } } if (rt_gap_ > 0.0) // concatenate in RT { adjustRetentionTimes_(map, trafo_out[i], i == 0); } out += map; } //------------------------------------------------------------- // writing output //------------------------------------------------------------- // annotate output with data processing info addDataProcessing_(out, getProcessingInfo_(DataProcessing::FORMAT_CONVERSION)); fh.store(out_file, out); } else if (force_type == FileTypes::CONSENSUSXML) { ConsensusMap out; ConsensusXMLFile fh; fh.load(file_list[0], out); // skip first file for (Size i = 1; i < file_list.size(); ++i) { ConsensusMap map; fh.load(file_list[i], map); if (annotate_file_origin) { for (ConsensusMap::iterator it = map.begin(); it != map.end(); ++it) { it->setMetaValue("file_origin", DataValue(file_list[i])); } } if (rt_gap_ > 0.0) // concatenate in RT { adjustRetentionTimes_(map, trafo_out[i], i == 0); } out += map; } //------------------------------------------------------------- // writing output //------------------------------------------------------------- // annotate output with data processing info addDataProcessing_(out, getProcessingInfo_(DataProcessing::FORMAT_CONVERSION)); fh.store(out_file, out); } else if (force_type == FileTypes::TRAML) { TargetedExperiment out; TraMLFile fh; for (Size i = 0; i < file_list.size(); ++i) { TargetedExperiment map; fh.load(file_list[i], map); out += map; } //------------------------------------------------------------- // writing output //------------------------------------------------------------- // annotate output with data processing info Software software; software.setName("FileMerger"); software.setVersion(VersionInfo::getVersion()); out.addSoftware(software); fh.store(out_file, out); } else // raw data input (e.g. mzML) { // RT bool rt_auto_number = getFlag_("raw:rt_auto"); bool rt_filename = getFlag_("raw:rt_filename"); bool rt_custom = false; DoubleList custom_rts = getDoubleList_("raw:rt_custom"); if (!custom_rts.empty()) { rt_custom = true; if (custom_rts.size() != file_list.size()) { writeLog_("Custom retention time list (parameter 'raw:rt_custom') must have as many elements as there are input files (parameter 'in')!"); return ILLEGAL_PARAMETERS; } } // MS level Int ms_level = getIntOption_("raw:ms_level"); MSExperiment<> out; UInt rt_auto = 0; UInt native_id = 0; for (Size i = 0; i < file_list.size(); ++i) { String filename = file_list[i]; // load file force_type = file_handler.getType(file_list[i]); MSExperiment<> in; file_handler.loadExperiment(filename, in, force_type, log_type_); if (in.empty() && in.getChromatograms().empty()) { writeLog_(String("Warning: Empty file '") + filename + "'!"); continue; } out.reserve(out.size() + in.size()); // warn if custom RT and more than one scan in input file if (rt_custom && in.size() > 1) { writeLog_(String("Warning: More than one scan in file '") + filename + "'! All scans will have the same retention time!"); } // handle special raw data options: for (MSExperiment<>::iterator spec_it = in.begin(); spec_it != in.end(); ++spec_it) { float rt_final = spec_it->getRT(); if (rt_auto_number) { rt_final = ++rt_auto; } else if (rt_custom) { rt_final = custom_rts[i]; } else if (rt_filename) { static const boost::regex re("rt(\\d+(\\.\\d+)?)"); boost::smatch match; bool found = boost::regex_search(filename, match, re); if (found) { rt_final = String(match[1]).toFloat(); } else { writeLog_("Warning: could not extract retention time from filename '" + filename + "'"); } } // none of the rt methods were successful if (rt_final < 0) { writeLog_(String("Warning: No valid retention time for output scan '") + rt_auto + "' from file '" + filename + "'"); } spec_it->setRT(rt_final); spec_it->setNativeID("spectrum=" + String(native_id)); if (ms_level > 0) { spec_it->setMSLevel(ms_level); } ++native_id; } // if we have only one spectrum, we can annotate it directly, for more spectra, we just name the source file leaving the spectra unannotated (to avoid a long and redundant list of sourceFiles) if (in.size() == 1) { in[0].setSourceFile(in.getSourceFiles()[0]); in.getSourceFiles().clear(); // delete source file annotated from source file (it's in the spectrum anyways) } if (rt_gap_ > 0.0) // concatenate in RT { adjustRetentionTimes_(in, trafo_out[i], i == 0); } // add spectra to output for (MSExperiment<>::const_iterator spec_it = in.begin(); spec_it != in.end(); ++spec_it) { out.addSpectrum(*spec_it); } // also add the chromatograms for (vector<MSChromatogram<ChromatogramPeak> >::const_iterator chrom_it = in.getChromatograms().begin(); chrom_it != in.getChromatograms().end(); ++chrom_it) { out.addChromatogram(*chrom_it); } // copy experimental settings from first file if (i == 0) { out.ExperimentalSettings::operator=(in); } else // otherwise append { out.getSourceFiles().insert(out.getSourceFiles().end(), in.getSourceFiles().begin(), in.getSourceFiles().end()); // could be emtpty if spectrum was annotated above, but that's ok then } } //------------------------------------------------------------- // writing output //------------------------------------------------------------- // annotate output with data processing info addDataProcessing_(out, getProcessingInfo_(DataProcessing::FORMAT_CONVERSION)); MzMLFile f; f.setLogType(log_type_); f.store(out_file, out); } return EXECUTION_OK; }
ExitCodes main_(int , const char**) { String out_meta = getStringOption_("out"); String out_cached = out_meta + ".cached"; bool convert_back = getFlag_("convert_back"); FileHandler fh; //input file type String in = getStringOption_("in"); String in_cached = in + ".cached"; FileTypes::Type in_type = FileTypes::nameToType(getStringOption_("in_type")); if (in_type == FileTypes::UNKNOWN) { in_type = fh.getType(in); writeDebug_(String("Input file type: ") + FileTypes::typeToName(in_type), 2); } if (in_type == FileTypes::UNKNOWN) { writeLog_("Error: Could not determine input file type!"); return PARSE_ERROR; } //output file names and types String out = getStringOption_("out"); FileTypes::Type out_type = FileTypes::nameToType(getStringOption_("out_type")); if (out_type == FileTypes::UNKNOWN) { out_type = fh.getTypeByFileName(out); } if (out_type == FileTypes::UNKNOWN) { writeLog_("Error: Could not determine output file type!"); return PARSE_ERROR; } if (in_type == FileTypes::SQMASS && out_type == FileTypes::MZML) { MapType exp; SqMassFile sqfile; MzMLFile f; sqfile.load(in, exp); f.store(out, exp); return EXECUTION_OK; } else if (in_type == FileTypes::MZML && out_type == FileTypes::SQMASS) { MzMLFile f; SqMassFile sqfile; MapType exp; f.load(in, exp); sqfile.store(out, exp); return EXECUTION_OK; } if (!convert_back) { MapType exp; CachedmzML cacher; MzMLFile f; cacher.setLogType(log_type_); f.setLogType(log_type_); f.load(in,exp); cacher.writeMemdump(exp, out_cached); cacher.writeMetadata(exp, out_meta, true); } else { MzMLFile f; MapType meta_exp; CachedmzML cacher; MapType exp_reading; cacher.setLogType(log_type_); f.setLogType(log_type_); f.load(in,meta_exp); cacher.readMemdump(exp_reading, in_cached); std::cout << " read back, got " << exp_reading.size() << " spectra " << exp_reading.getChromatograms().size() << " chromats " << std::endl; { for (Size i=0; i<meta_exp.size(); ++i) { for (Size j = 0; j < meta_exp[i].getDataProcessing().size(); j++) { if (meta_exp[i].getDataProcessing()[j]->metaValueExists("cached_data")) { meta_exp[i].getDataProcessing()[j]->removeMetaValue("cached_data"); } } } for (Size i=0; i < meta_exp.getNrChromatograms(); ++i) { for (Size j = 0; j < meta_exp.getChromatogram(i).getDataProcessing().size(); j++) { if (meta_exp.getChromatogram(i).getDataProcessing()[j]->metaValueExists("cached_data")) { meta_exp.getChromatogram(i).getDataProcessing()[j]->removeMetaValue("cached_data"); } } } } if (meta_exp.size() != exp_reading.size()) { std::cerr << " Both experiments need to have the same size!"; } for (Size i=0; i<exp_reading.size(); ++i) { for (Size j = 0; j < exp_reading[i].size(); j++) { meta_exp[i].push_back(exp_reading[i][j]); } } std::vector<MSChromatogram<ChromatogramPeak> > chromatograms = exp_reading.getChromatograms(); std::vector<MSChromatogram<ChromatogramPeak> > old_chromatograms = meta_exp.getChromatograms(); for (Size i=0; i<chromatograms.size(); ++i) { for (Size j = 0; j < chromatograms[i].size(); j++) { old_chromatograms[i].push_back(chromatograms[i][j]); } } meta_exp.setChromatograms(old_chromatograms); f.store(out_meta,meta_exp); } return EXECUTION_OK; }
ExitCodes main_(int, const char**) { ExitCodes ret = checkParameters_(); if (ret != EXECUTION_OK) return ret; MapAlignmentAlgorithmSpectrumAlignment algorithm; Param algo_params = getParam_().copy("algorithm:", true); algorithm.setParameters(algo_params); algorithm.setLogType(log_type_); StringList ins = getStringList_("in"); StringList outs = getStringList_("out"); StringList trafos = getStringList_("trafo_out"); Param model_params = getParam_().copy("model:", true); String model_type = model_params.getValue("type"); model_params = model_params.copy(model_type + ":", true); std::vector<TransformationDescription> transformations; //------------------------------------------------------------- // perform peak alignment //------------------------------------------------------------- ProgressLogger progresslogger; progresslogger.setLogType(log_type_); // load input std::vector<MSExperiment<> > peak_maps(ins.size()); MzMLFile f; f.setLogType(log_type_); progresslogger.startProgress(0, ins.size(), "loading input files"); for (Size i = 0; i < ins.size(); ++i) { progresslogger.setProgress(i); f.load(ins[i], peak_maps[i]); } progresslogger.endProgress(); // try to align algorithm.align(peak_maps, transformations); if (model_type != "none") { for (vector<TransformationDescription>::iterator it = transformations.begin(); it != transformations.end(); ++it) { it->fitModel(model_type, model_params); } } // write output progresslogger.startProgress(0, outs.size(), "applying RT transformations and writing output files"); for (Size i = 0; i < outs.size(); ++i) { progresslogger.setProgress(i); MapAlignmentTransformer::transformRetentionTimes(peak_maps[i], transformations[i]); // annotate output with data processing info addDataProcessing_(peak_maps[i], getProcessingInfo_(DataProcessing::ALIGNMENT)); f.store(outs[i], peak_maps[i]); } progresslogger.endProgress(); if (!trafos.empty()) { TransformationXMLFile trafo_file; for (Size i = 0; i < transformations.size(); ++i) { trafo_file.store(trafos[i], transformations[i]); } } return EXECUTION_OK; }
ExitCodes main_(int, const char**) { //------------------------------------------------------------- // parameter handling //------------------------------------------------------------- //input file names String in = getStringOption_("in"); //input file type FileHandler fh; FileTypes::Type in_type = FileTypes::nameToType(getStringOption_("in_type")); if (in_type == FileTypes::UNKNOWN) { in_type = fh.getType(in); writeDebug_(String("Input file type: ") + FileTypes::typeToName(in_type), 2); } if (in_type == FileTypes::UNKNOWN) { writeLog_("Error: Could not determine input file type!"); return PARSE_ERROR; } //output file names and types String out = getStringOption_("out"); FileTypes::Type out_type = FileTypes::nameToType(getStringOption_("out_type")); if (out_type == FileTypes::UNKNOWN) { out_type = fh.getTypeByFileName(out); } if (out_type == FileTypes::UNKNOWN) { writeLog_("Error: Could not determine output file type!"); return PARSE_ERROR; } bool TIC_DTA2D = getFlag_("TIC_DTA2D"); writeDebug_(String("Output file type: ") + FileTypes::typeToName(out_type), 1); //------------------------------------------------------------- // reading input //------------------------------------------------------------- typedef MSExperiment<Peak1D> MSExperimentType; MSExperimentType exp; typedef MSExperimentType::SpectrumType SpectrumType; typedef FeatureMap<> FeatureMapType; FeatureMapType fm; ConsensusMap cm; writeDebug_(String("Loading input file"), 1); if (in_type == FileTypes::CONSENSUSXML) { ConsensusXMLFile().load(in, cm); cm.sortByPosition(); if ((out_type != FileTypes::FEATUREXML) && (out_type != FileTypes::CONSENSUSXML)) { // You you will lose information and waste memory. Enough reasons to issue a warning! writeLog_("Warning: Converting consensus features to peaks. You will lose information!"); exp.set2DData(cm); } } else if (in_type == FileTypes::EDTA) { EDTAFile().load(in, cm); cm.sortByPosition(); if ((out_type != FileTypes::FEATUREXML) && (out_type != FileTypes::CONSENSUSXML)) { // You you will lose information and waste memory. Enough reasons to issue a warning! writeLog_("Warning: Converting consensus features to peaks. You will lose information!"); exp.set2DData(cm); } } else if (in_type == FileTypes::FEATUREXML || in_type == FileTypes::TSV || in_type == FileTypes::PEPLIST || in_type == FileTypes::KROENIK) { fh.loadFeatures(in, fm, in_type); fm.sortByPosition(); if ((out_type != FileTypes::FEATUREXML) && (out_type != FileTypes::CONSENSUSXML)) { // You will lose information and waste memory. Enough reasons to issue a warning! writeLog_("Warning: Converting features to peaks. You will lose information! Mass traces are added, if present as 'num_of_masstraces' and 'masstrace_intensity_<X>' (X>=0) meta values."); exp.set2DData<true>(fm); } } else { fh.loadExperiment(in, exp, in_type, log_type_); } //------------------------------------------------------------- // writing output //------------------------------------------------------------- writeDebug_(String("Writing output file"), 1); if (out_type == FileTypes::MZML) { //add data processing entry addDataProcessing_(exp, getProcessingInfo_(DataProcessing:: CONVERSION_MZML)); MzMLFile f; f.setLogType(log_type_); ChromatogramTools().convertSpectraToChromatograms(exp, true); f.store(out, exp); } else if (out_type == FileTypes::MZDATA) { //annotate output with data processing info addDataProcessing_(exp, getProcessingInfo_(DataProcessing:: CONVERSION_MZDATA)); MzDataFile f; f.setLogType(log_type_); ChromatogramTools().convertChromatogramsToSpectra<MSExperimentType>(exp); f.store(out, exp); } else if (out_type == FileTypes::MZXML) { //annotate output with data processing info addDataProcessing_(exp, getProcessingInfo_(DataProcessing:: CONVERSION_MZXML)); MzXMLFile f; f.setLogType(log_type_); ChromatogramTools().convertChromatogramsToSpectra<MSExperimentType>(exp); f.store(out, exp); } else if (out_type == FileTypes::DTA2D) { //add data processing entry addDataProcessing_(exp, getProcessingInfo_(DataProcessing:: FORMAT_CONVERSION)); DTA2DFile f; f.setLogType(log_type_); ChromatogramTools().convertChromatogramsToSpectra<MSExperimentType>(exp); if (TIC_DTA2D) { // store the total ion chromatogram (TIC) f.storeTIC(out, exp); } else { // store entire experiment f.store(out, exp); } } else if (out_type == FileTypes::MGF) { //add data processing entry addDataProcessing_(exp, getProcessingInfo_(DataProcessing:: FORMAT_CONVERSION)); MascotGenericFile f; f.setLogType(log_type_); f.store(out, exp); } else if (out_type == FileTypes::FEATUREXML) { if ((in_type == FileTypes::FEATUREXML) || (in_type == FileTypes::TSV) || (in_type == FileTypes::PEPLIST) || (in_type == FileTypes::KROENIK)) { fm.applyMemberFunction(&UniqueIdInterface::setUniqueId); } else if (in_type == FileTypes::CONSENSUSXML || in_type == FileTypes::EDTA) { ConsensusMap::convert(cm, true, fm); } else // not loaded as feature map or consensus map { // The feature specific information is only defaulted. Enough reasons to issue a warning! writeLog_("Warning: Converting peaks to features will lead to incomplete features!"); fm.clear(); fm.reserve(exp.getSize()); typedef FeatureMapType::FeatureType FeatureType; FeatureType feature; feature.setQuality(0, 1); // override default feature.setQuality(1, 1); // override default feature.setOverallQuality(1); // override default for (MSExperimentType::ConstIterator spec_iter = exp.begin(); spec_iter != exp.end(); ++spec_iter ) { feature.setRT(spec_iter->getRT()); for (SpectrumType::ConstIterator peak1_iter = spec_iter->begin(); peak1_iter != spec_iter->end(); ++peak1_iter ) { feature.setMZ(peak1_iter->getMZ()); feature.setIntensity(peak1_iter->getIntensity()); feature.setUniqueId(); fm.push_back(feature); } } fm.updateRanges(); } addDataProcessing_(fm, getProcessingInfo_(DataProcessing:: FORMAT_CONVERSION)); FeatureXMLFile().store(out, fm); } else if (out_type == FileTypes::CONSENSUSXML) { if ((in_type == FileTypes::FEATUREXML) || (in_type == FileTypes::TSV) || (in_type == FileTypes::PEPLIST) || (in_type == FileTypes::KROENIK)) { fm.applyMemberFunction(&UniqueIdInterface::setUniqueId); ConsensusMap::convert(0, fm, cm); } // nothing to do for consensus input else if (in_type == FileTypes::CONSENSUSXML || in_type == FileTypes::EDTA) { } else // experimental data { ConsensusMap::convert(0, exp, cm, exp.size()); } addDataProcessing_(cm, getProcessingInfo_(DataProcessing:: FORMAT_CONVERSION)); ConsensusXMLFile().store(out, cm); } else if (out_type == FileTypes::EDTA) { if (fm.size() > 0 && cm.size() > 0) { LOG_ERROR << "Internal error: cannot decide on container (Consensus or Feature)! This is a bug. Please report it!"; return INTERNAL_ERROR; } if (fm.size() > 0) EDTAFile().store(out, fm); else if (cm.size() > 0) EDTAFile().store(out, cm); } else { writeLog_("Unknown output file type given. Aborting!"); printUsage_(); return ILLEGAL_PARAMETERS; } return EXECUTION_OK; }
ExitCodes main_(int, const char**) { //------------------------------------------------------------- // parameter handling //------------------------------------------------------------- //input file names String in = getStringOption_("in"); bool write_mzML_index = getFlag_("write_mzML_index"); //input file type FileHandler fh; FileTypes::Type in_type = FileTypes::nameToType(getStringOption_("in_type")); if (in_type == FileTypes::UNKNOWN) { in_type = fh.getType(in); writeDebug_(String("Input file type: ") + FileTypes::typeToName(in_type), 2); } if (in_type == FileTypes::UNKNOWN) { writeLog_("Error: Could not determine input file type!"); return PARSE_ERROR; } //output file names and types String out = getStringOption_("out"); FileTypes::Type out_type = FileTypes::nameToType(getStringOption_("out_type")); if (out_type == FileTypes::UNKNOWN) { out_type = fh.getTypeByFileName(out); } if (out_type == FileTypes::UNKNOWN) { writeLog_("Error: Could not determine output file type!"); return PARSE_ERROR; } bool TIC_DTA2D = getFlag_("TIC_DTA2D"); bool process_lowmemory = getFlag_("process_lowmemory"); writeDebug_(String("Output file type: ") + FileTypes::typeToName(out_type), 1); String uid_postprocessing = getStringOption_("UID_postprocessing"); //------------------------------------------------------------- // reading input //------------------------------------------------------------- typedef MSExperiment<Peak1D> MSExperimentType; MSExperimentType exp; typedef MSExperimentType::SpectrumType SpectrumType; typedef FeatureMap FeatureMapType; FeatureMapType fm; ConsensusMap cm; writeDebug_(String("Loading input file"), 1); if (in_type == FileTypes::CONSENSUSXML) { ConsensusXMLFile().load(in, cm); cm.sortByPosition(); if ((out_type != FileTypes::FEATUREXML) && (out_type != FileTypes::CONSENSUSXML)) { // You you will lose information and waste memory. Enough reasons to issue a warning! writeLog_("Warning: Converting consensus features to peaks. You will lose information!"); exp.set2DData(cm); } } else if (in_type == FileTypes::EDTA) { EDTAFile().load(in, cm); cm.sortByPosition(); if ((out_type != FileTypes::FEATUREXML) && (out_type != FileTypes::CONSENSUSXML)) { // You you will lose information and waste memory. Enough reasons to issue a warning! writeLog_("Warning: Converting consensus features to peaks. You will lose information!"); exp.set2DData(cm); } } else if (in_type == FileTypes::FEATUREXML || in_type == FileTypes::TSV || in_type == FileTypes::PEPLIST || in_type == FileTypes::KROENIK) { fh.loadFeatures(in, fm, in_type); fm.sortByPosition(); if ((out_type != FileTypes::FEATUREXML) && (out_type != FileTypes::CONSENSUSXML)) { // You will lose information and waste memory. Enough reasons to issue a warning! writeLog_("Warning: Converting features to peaks. You will lose information! Mass traces are added, if present as 'num_of_masstraces' and 'masstrace_intensity_<X>' (X>=0) meta values."); exp.set2DData<true>(fm); } } else if (process_lowmemory) { // Special switch for the low memory options: // We can transform the complete experiment directly without first // loading the complete data into memory. PlainMSDataWritingConsumer will // write out mzML to disk as they are read from the input. if (in_type == FileTypes::MZML && out_type == FileTypes::MZML) { PlainMSDataWritingConsumer consumer(out); consumer.getOptions().setWriteIndex(write_mzML_index); consumer.addDataProcessing(getProcessingInfo_(DataProcessing::CONVERSION_MZML)); MzMLFile mzmlfile; mzmlfile.setLogType(log_type_); mzmlfile.transform(in, &consumer); return EXECUTION_OK; } else if (in_type == FileTypes::MZXML && out_type == FileTypes::MZML) { PlainMSDataWritingConsumer consumer(out); consumer.getOptions().setWriteIndex(write_mzML_index); consumer.addDataProcessing(getProcessingInfo_(DataProcessing::CONVERSION_MZML)); MzXMLFile mzxmlfile; mzxmlfile.setLogType(log_type_); mzxmlfile.transform(in, &consumer); return EXECUTION_OK; } else { throw Exception::IllegalArgument(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Process_lowmemory option can only be used with mzML / mzXML input and mzML output data types."); } } else { fh.loadExperiment(in, exp, in_type, log_type_); } //------------------------------------------------------------- // writing output //------------------------------------------------------------- writeDebug_(String("Writing output file"), 1); if (out_type == FileTypes::MZML) { //add data processing entry addDataProcessing_(exp, getProcessingInfo_(DataProcessing:: CONVERSION_MZML)); MzMLFile f; f.setLogType(log_type_); f.getOptions().setWriteIndex(write_mzML_index); ChromatogramTools().convertSpectraToChromatograms(exp, true); f.store(out, exp); } else if (out_type == FileTypes::MZDATA) { //annotate output with data processing info addDataProcessing_(exp, getProcessingInfo_(DataProcessing:: CONVERSION_MZDATA)); MzDataFile f; f.setLogType(log_type_); ChromatogramTools().convertChromatogramsToSpectra<MSExperimentType>(exp); f.store(out, exp); } else if (out_type == FileTypes::MZXML) { //annotate output with data processing info addDataProcessing_(exp, getProcessingInfo_(DataProcessing:: CONVERSION_MZXML)); MzXMLFile f; f.setLogType(log_type_); ChromatogramTools().convertChromatogramsToSpectra<MSExperimentType>(exp); f.store(out, exp); } else if (out_type == FileTypes::DTA2D) { //add data processing entry addDataProcessing_(exp, getProcessingInfo_(DataProcessing:: FORMAT_CONVERSION)); DTA2DFile f; f.setLogType(log_type_); ChromatogramTools().convertChromatogramsToSpectra<MSExperimentType>(exp); if (TIC_DTA2D) { // store the total ion chromatogram (TIC) f.storeTIC(out, exp); } else { // store entire experiment f.store(out, exp); } } else if (out_type == FileTypes::MGF) { //add data processing entry addDataProcessing_(exp, getProcessingInfo_(DataProcessing:: FORMAT_CONVERSION)); MascotGenericFile f; f.setLogType(log_type_); f.store(out, exp, getFlag_("MGF_compact")); } else if (out_type == FileTypes::FEATUREXML) { if ((in_type == FileTypes::FEATUREXML) || (in_type == FileTypes::TSV) || (in_type == FileTypes::PEPLIST) || (in_type == FileTypes::KROENIK)) { if (uid_postprocessing == "ensure") { fm.applyMemberFunction(&UniqueIdInterface::ensureUniqueId); } else if (uid_postprocessing == "reassign") { fm.applyMemberFunction(&UniqueIdInterface::setUniqueId); } } else if (in_type == FileTypes::CONSENSUSXML || in_type == FileTypes::EDTA) { MapConversion::convert(cm, true, fm); } else // not loaded as feature map or consensus map { // The feature specific information is only defaulted. Enough reasons to issue a warning! writeLog_("Warning: Converting peaks to features will lead to incomplete features!"); fm.clear(); fm.reserve(exp.getSize()); typedef FeatureMapType::FeatureType FeatureType; FeatureType feature; feature.setQuality(0, 1); // override default feature.setQuality(1, 1); // override default feature.setOverallQuality(1); // override default for (MSExperimentType::ConstIterator spec_iter = exp.begin(); spec_iter != exp.end(); ++spec_iter ) { feature.setRT(spec_iter->getRT()); for (SpectrumType::ConstIterator peak1_iter = spec_iter->begin(); peak1_iter != spec_iter->end(); ++peak1_iter ) { feature.setMZ(peak1_iter->getMZ()); feature.setIntensity(peak1_iter->getIntensity()); feature.setUniqueId(); fm.push_back(feature); } } fm.updateRanges(); } addDataProcessing_(fm, getProcessingInfo_(DataProcessing:: FORMAT_CONVERSION)); FeatureXMLFile().store(out, fm); } else if (out_type == FileTypes::CONSENSUSXML) { if ((in_type == FileTypes::FEATUREXML) || (in_type == FileTypes::TSV) || (in_type == FileTypes::PEPLIST) || (in_type == FileTypes::KROENIK)) { if (uid_postprocessing == "ensure") { fm.applyMemberFunction(&UniqueIdInterface::ensureUniqueId); } else if (uid_postprocessing == "reassign") { fm.applyMemberFunction(&UniqueIdInterface::setUniqueId); } MapConversion::convert(0, fm, cm); } // nothing to do for consensus input else if (in_type == FileTypes::CONSENSUSXML || in_type == FileTypes::EDTA) { } else // experimental data { MapConversion::convert(0, exp, cm, exp.size()); } addDataProcessing_(cm, getProcessingInfo_(DataProcessing:: FORMAT_CONVERSION)); ConsensusXMLFile().store(out, cm); } else if (out_type == FileTypes::EDTA) { if (fm.size() > 0 && cm.size() > 0) { LOG_ERROR << "Internal error: cannot decide on container (Consensus or Feature)! This is a bug. Please report it!"; return INTERNAL_ERROR; } if (fm.size() > 0) EDTAFile().store(out, fm); else if (cm.size() > 0) EDTAFile().store(out, cm); } else if (out_type == FileTypes::CSV) { // as ibspectra is currently the only csv/text based format we assume // that out_type == FileTypes::CSV means ibspectra, if more formats // are added we need a more intelligent strategy to decide which // conversion is requested // IBSpectra selected as output type if (in_type != FileTypes::CONSENSUSXML) { LOG_ERROR << "Incompatible input data: FileConverter can only convert consensusXML files to ibspectra format."; return INCOMPATIBLE_INPUT_DATA; } IBSpectraFile ibfile; ibfile.store(out, cm); } else { writeLog_("Unknown output file type given. Aborting!"); printUsage_(); return ILLEGAL_PARAMETERS; } return EXECUTION_OK; }