void InternalCalibration::calibrateMapGlobally(const FeatureMap<> & feature_map, FeatureMap<> & calibrated_feature_map, std::vector<PeptideIdentification> & ref_ids, String trafo_file_name)
{
checkReferenceIds_(ref_ids);
calibrated_feature_map = feature_map;
// clear the ids
for (Size f = 0; f < calibrated_feature_map.size(); ++f)
{
calibrated_feature_map[f].getPeptideIdentifications().clear();
}
// map the reference ids onto the features
IDMapper mapper;
Param param;
param.setValue("rt_tolerance", (DoubleReal)param_.getValue("rt_tolerance"));
param.setValue("mz_tolerance", param_.getValue("mz_tolerance"));
param.setValue("mz_measure", param_.getValue("mz_tolerance_unit"));
mapper.setParameters(param);
std::vector<ProteinIdentification> vec;
mapper.annotate(calibrated_feature_map, ref_ids, vec);
// calibrate
calibrateMapGlobally(calibrated_feature_map, calibrated_feature_map, trafo_file_name);
// copy the old ids
calibrated_feature_map.setUnassignedPeptideIdentifications(feature_map.getUnassignedPeptideIdentifications());
for (Size f = 0; f < feature_map.size(); ++f)
{
calibrated_feature_map[f].getPeptideIdentifications().clear();
if (!feature_map[f].getPeptideIdentifications().empty())
{
calibrated_feature_map[f].setPeptideIdentifications(feature_map[f].getPeptideIdentifications());
}
}
}
ExitCodes main_(int, const char **)
{
//-------------------------------------------------------------
// parameter handling
//-------------------------------------------------------------
String in_spectra = getStringOption_("in_spectra");
String in_identifications = getStringOption_("in_identifications");
String outfile = getStringOption_("model_output_file");
Int precursor_charge = getIntOption_("precursor_charge");
//-------------------------------------------------------------
// init SvmTheoreticalSpectrumGeneratorTrainer
//-------------------------------------------------------------
SvmTheoreticalSpectrumGeneratorTrainer trainer;
Param param = getParam_().copy("algorithm:", true);
String write_files = getFlag_("write_training_files") ? "true" : "false";
param.setValue("write_training_files", write_files);
trainer.setParameters(param);
//-------------------------------------------------------------
// loading input
//-------------------------------------------------------------
PeakMap map;
MzMLFile().load(in_spectra, map);
std::vector<PeptideIdentification> pep_ids;
std::vector<ProteinIdentification> prot_ids;
String tmp_str;
IdXMLFile().load(in_identifications, prot_ids, pep_ids, tmp_str);
IDMapper idmapper;
Param par;
par.setValue("rt_tolerance", 0.001);
par.setValue("mz_tolerance", 0.001);
idmapper.setParameters(par);
idmapper.annotate(map, pep_ids, prot_ids);
//generate vector of annotations
std::vector<AASequence> annotations;
PeakMap::iterator it;
for (it = map.begin(); it != map.end(); ++it)
{
annotations.push_back(it->getPeptideIdentifications()[0].getHits()[0].getSequence());
}
trainer.trainModel(map, annotations, outfile, precursor_charge);
return EXECUTION_OK;
}
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;
}