ExitCodes main_(int, const char**)
{
// LOG_DEBUG << "Starting..." << endl;
//----------------------------------------------------------------
// load ids
//----------------------------------------------------------------
// LOG_DEBUG << "Loading idXML..." << endl;
String id = getStringOption_("id");
vector<ProteinIdentification> protein_ids;
vector<PeptideIdentification> peptide_ids;
FileTypes::Type in_type = FileHandler::getType(id);
if (in_type == FileTypes::IDXML)
{
IdXMLFile().load(id, protein_ids, peptide_ids);
}
else if (in_type == FileTypes::MZIDENTML)
{
MzIdentMLFile().load(id, protein_ids, peptide_ids);
}
else
{
throw Exception::IllegalArgument(__FILE__, __LINE__,
__PRETTY_FUNCTION__,
"wrong id fileformat");
}
String in = getStringOption_("in");
String out = getStringOption_("out");
in_type = FileHandler::getType(in);
//----------------------------------------------------------------
//create mapper
//----------------------------------------------------------------
// LOG_DEBUG << "Creating mapper..." << endl;
IDMapper mapper;
Param p = mapper.getParameters();
p.setValue("rt_tolerance", getDoubleOption_("rt_tolerance"));
p.setValue("mz_tolerance", getDoubleOption_("mz_tolerance"));
p.setValue("mz_measure", getStringOption_("mz_measure"));
p.setValue("mz_reference", getStringOption_("mz_reference"));
p.setValue("ignore_charge", getFlag_("ignore_charge") ? "true" : "false");
mapper.setParameters(p);
//----------------------------------------------------------------
// consensusXML
//----------------------------------------------------------------
if (in_type == FileTypes::CONSENSUSXML)
{
// LOG_DEBUG << "Processing consensus map..." << endl;
ConsensusXMLFile file;
ConsensusMap map;
file.load(in, map);
bool measure_from_subelements = getFlag_("consensus:use_subelements");
bool annotate_ids_with_subelements = getFlag_("consensus:annotate_ids_with_subelements");
mapper.annotate(map, peptide_ids, protein_ids, measure_from_subelements, annotate_ids_with_subelements);
//annotate output with data processing info
addDataProcessing_(map, getProcessingInfo_(DataProcessing::IDENTIFICATION_MAPPING));
file.store(out, map);
}
//----------------------------------------------------------------
// featureXML
//----------------------------------------------------------------
if (in_type == FileTypes::FEATUREXML)
{
// LOG_DEBUG << "Processing feature map..." << endl;
FeatureMap map;
FeatureXMLFile file;
file.load(in, map);
mapper.annotate(map, peptide_ids, protein_ids,
getFlag_("feature:use_centroid_rt"),
getFlag_("feature:use_centroid_mz"));
//annotate output with data processing info
addDataProcessing_(map, getProcessingInfo_(DataProcessing::IDENTIFICATION_MAPPING));
file.store(out, map);
}
//----------------------------------------------------------------
// MzQuantML
//----------------------------------------------------------------
if (in_type == FileTypes::MZQUANTML)
{
// LOG_DEBUG << "Processing mzq ..." << endl;
MSQuantifications msq;
MzQuantMLFile file;
file.load(in, msq);
bool measure_from_subelements = getFlag_("consensus:use_subelements");
for (std::vector<ConsensusMap>::iterator it = msq.getConsensusMaps().begin(); it != msq.getConsensusMaps().end(); ++it)
{
mapper.annotate(*it, peptide_ids, protein_ids, measure_from_subelements);
//annotate output with data processing info
addDataProcessing_(*it, getProcessingInfo_(DataProcessing::IDENTIFICATION_MAPPING));
}
//~ writeDebug_(msq.getConsensusMaps().size(),3);
//~ writeDebug_(msq.getConsensusMaps().back().size(),3);
//~ writeDebug_(msq.getAnalysisSummary().quant_type_,3);
file.store(out, msq);
}
// LOG_DEBUG << "Done." << endl;
return EXECUTION_OK;
}
ExitCodes main_(int, const char**)
{
//input file names
String in = getStringOption_("in");
String out = getStringOption_("out");
String out_mzq = getStringOption_("out_mzq");
//prevent loading of fragment spectra
PeakFileOptions options;
options.setMSLevels(vector<Int>(1, 1));
//reading input data
MzMLFile f;
f.getOptions() = options;
f.setLogType(log_type_);
PeakMap exp;
f.load(in, exp);
exp.updateRanges();
if (exp.getSpectra().empty())
{
throw OpenMS::Exception::FileEmpty(__FILE__, __LINE__, __FUNCTION__, "Error: No MS1 spectra in input file.");
}
// determine type of spectral data (profile or centroided)
SpectrumSettings::SpectrumType spectrum_type = exp[0].getType();
if (spectrum_type == SpectrumSettings::RAWDATA)
{
if (!getFlag_("force"))
{
throw OpenMS::Exception::IllegalArgument(__FILE__, __LINE__, __FUNCTION__, "Error: Profile data provided but centroided spectra expected. To enforce processing of the data set the -force flag.");
}
}
//load seeds
FeatureMap seeds;
if (getStringOption_("seeds") != "")
{
FeatureXMLFile().load(getStringOption_("seeds"), seeds);
}
//setup of FeatureFinder
FeatureFinder ff;
ff.setLogType(log_type_);
// A map for the resulting features
FeatureMap features;
// get parameters specific for the feature finder
Param feafi_param = getParam_().copy("algorithm:", true);
writeDebug_("Parameters passed to FeatureFinder", feafi_param, 3);
// Apply the feature finder
ff.run(FeatureFinderAlgorithmPicked::getProductName(), exp, features, feafi_param, seeds);
features.applyMemberFunction(&UniqueIdInterface::setUniqueId);
// DEBUG
if (debug_level_ > 10)
{
FeatureMap::Iterator it;
for (it = features.begin(); it != features.end(); ++it)
{
if (!it->isMetaEmpty())
{
vector<String> keys;
it->getKeys(keys);
LOG_INFO << "Feature " << it->getUniqueId() << endl;
for (Size i = 0; i < keys.size(); i++)
{
LOG_INFO << " " << keys[i] << " = " << it->getMetaValue(keys[i]) << endl;
}
}
}
}
//-------------------------------------------------------------
// writing files
//-------------------------------------------------------------
//annotate output with data processing info
addDataProcessing_(features, getProcessingInfo_(DataProcessing::QUANTITATION));
// write features to user specified output file
FeatureXMLFile map_file;
// Remove detailed convex hull information and subordinate features
// (unless requested otherwise) to reduce file size of feature files
// unless debugging is turned on.
if (debug_level_ < 5)
{
FeatureMap::Iterator it;
for (it = features.begin(); it != features.end(); ++it)
{
it->getConvexHull().expandToBoundingBox();
for (Size i = 0; i < it->getConvexHulls().size(); ++i)
{
it->getConvexHulls()[i].expandToBoundingBox();
}
it->getSubordinates().clear();
}
}
map_file.store(out, features);
if (!out_mzq.trim().empty())
{
MSQuantifications msq(features, exp.getExperimentalSettings(), exp[0].getDataProcessing());
msq.assignUIDs();
MzQuantMLFile file;
file.store(out_mzq, msq);
}
return EXECUTION_OK;
}
ExitCodes main_(int, const char **)
{
//-------------------------------------------------------------
// parameter handling
//-------------------------------------------------------------
String in = getStringOption_("in");
String out = getStringOption_("out");
String out_stats = getStringOption_("out_stats");
String out_mzq = getStringOption_("out_mzq");
Int itraq_type = (getStringOption_("type") == "4plex" ? ItraqQuantifier::FOURPLEX : ItraqQuantifier::EIGHTPLEX);
//-------------------------------------------------------------
// loading input
//-------------------------------------------------------------
MzMLFile mz_data_file;
MSExperiment<Peak1D> exp;
mz_data_file.setLogType(log_type_);
mz_data_file.load(in, exp);
//-------------------------------------------------------------
// calculations
//-------------------------------------------------------------
Param extract_param(getParam_().copy("algorithm:Extraction:", true));
ItraqChannelExtractor itraq_ce(itraq_type, extract_param);
ConsensusMap consensus_map_raw, consensus_map_quant;
// extract raw signals
itraq_ce.run(exp, consensus_map_raw);
// do normalization
Param quant_param(getParam_().copy("algorithm:Quantification:", true));
ItraqQuantifier itraq_quant(itraq_type, quant_param);
itraq_quant.run(consensus_map_raw, consensus_map_quant);
// assign unique ID to output file (this might throw an exception.. but thats ok, as we want the program to quit then)
if (getStringOption_("id_pool").trim().length() > 0) getDocumentIDTagger_().tag(consensus_map_quant);
// annotate output file with MetaInformation
Param metainfo_param(getParam_().copy("algorithm:MetaInformation:", true));
for (Param::ParamIterator it = metainfo_param.begin(); it != metainfo_param.end(); ++it)
{
consensus_map_quant.setMetaValue(it->name, it->value);
}
//-------------------------------------------------------------
// writing output
//-------------------------------------------------------------
//annotate output with data processing info
addDataProcessing_(consensus_map_quant, getProcessingInfo_(DataProcessing::QUANTITATION));
// add filename references
for (ConsensusMap::FileDescriptions::iterator it = consensus_map_quant.getFileDescriptions().begin();
it != consensus_map_quant.getFileDescriptions().end();
++it)
{
it->second.filename = in;
}
ConsensusXMLFile cm_file;
cm_file.store(out, consensus_map_quant);
if (!out_mzq.trim().empty())
{
MSQuantifications msq;
std::vector<std::vector<std::pair<String, DoubleReal> > > labels;
if (itraq_type == ItraqQuantifier::FOURPLEX)
{
for (Size i = 0; i < 4; ++i)
{
std::vector<std::pair<String, DoubleReal> > one_label;
one_label.push_back(std::make_pair<String, DoubleReal>(String("Channel ") + String(ItraqConstants::CHANNELS_FOURPLEX[i][0]), DoubleReal(ItraqConstants::CHANNELS_FOURPLEX[i][0])));
labels.push_back(one_label);
}
}
else //ItraqQuantifier::EIGHTPLEX
{
for (Size i = 0; i < 8; ++i)
{
std::vector<std::pair<String, DoubleReal> > one_label;
one_label.push_back(std::make_pair<String, DoubleReal>(String("Channel ") + String(ItraqConstants::CHANNELS_EIGHTPLEX[i][0]), DoubleReal(ItraqConstants::CHANNELS_EIGHTPLEX[i][0])));
labels.push_back(one_label);
}
}
msq.registerExperiment(exp, labels); //add assays
msq.assignUIDs();
MSQuantifications::QUANT_TYPES quant_type = MSQuantifications::MS2LABEL;
msq.setAnalysisSummaryQuantType(quant_type); //add analysis_summary_
msq.addConsensusMap(consensus_map_quant); //add ITRAQAnalyzer result
//~ add AuditCollection - no such concept in TOPPTools yet
MzQuantMLFile file;
file.store(out_mzq, msq);
}
std::cout << itraq_quant.getStats();
if (!out_stats.trim().empty())
{
ofstream f;
f.open(out_stats.c_str(), ios_base::out);
f << itraq_quant.getStats();
f.close();
}
return EXECUTION_OK;
}
