ExitCodes main_(int, const char **)
{
// parameter handling
String in = getStringOption_("in");
String out = getStringOption_("out");
// input file type
FileTypes::Type in_type = FileHandler::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;
}
String document_id;
vector<ProteinIdentification> prot_ids;
vector<PeptideIdentification> pep_ids;
IdXMLFile().load(in, prot_ids, pep_ids, document_id);
MzTabFile mztab;
mztab.store(out, prot_ids, pep_ids, in, document_id);
return EXECUTION_OK;
}
void MapAlignmentAlgorithmIdentification::setReference(Size reference_index,
const String & reference_file)
{
reference_.clear();
reference_index_ = reference_index;
// reference is one of the input files, or no reference given:
if (reference_index_ || reference_file.empty())
return;
// reference is external file:
LOG_DEBUG << "Extracting reference RT data..." << endl;
SeqToList rt_data;
bool sorted = true;
FileTypes::Type filetype = FileHandler::getType(reference_file);
if (filetype == FileTypes::MZML)
{
MSExperiment<> experiment;
MzMLFile().load(reference_file, experiment);
getRetentionTimes_(experiment, rt_data);
sorted = false;
}
else if (filetype == FileTypes::FEATUREXML)
{
FeatureMap<> features;
FeatureXMLFile().load(reference_file, features);
getRetentionTimes_(features, rt_data);
}
else if (filetype == FileTypes::CONSENSUSXML)
{
ConsensusMap features;
ConsensusXMLFile().load(reference_file, features);
getRetentionTimes_(features, rt_data);
}
else if (filetype == FileTypes::IDXML)
{
vector<ProteinIdentification> proteins;
vector<PeptideIdentification> peptides;
IdXMLFile().load(reference_file, proteins, peptides);
getRetentionTimes_(peptides, rt_data);
}
computeMedians_(rt_data, reference_, sorted);
if (reference_.empty())
{
throw Exception::MissingInformation(
__FILE__, __LINE__, __PRETTY_FUNCTION__,
"Could not extract retention time information from the reference file");
}
}
bool
validate(const std::vector<std::string>& file_names)
{
std::cout << "checking (created temporary files)..." << std::endl;
bool passed_all = true;
for (Size i = 0; i < file_names.size(); ++i)
{
if (File::exists(file_names[i]))
{
FileTypes::Type type = FileHandler::getType(file_names[i]);
bool passed_single = true;
bool skipped = false;
switch (type)
{
case FileTypes::MZML:
{
if (!MzMLFile().isValid(file_names[i]))
{
std::cout << " - Error: mzML file does not validate against XML schema '" << file_names[i] << "'" << std::endl;
passed_single = false;
}
StringList errors, warnings;
if (!MzMLFile().isSemanticallyValid(file_names[i], errors,
warnings))
{
std::cout << " - Error: mzML file semantically invalid '" << file_names[i] << "'" << std::endl;
for (Size j = 0; j < errors.size(); ++j)
{
std::cout << "Error - " << errors[j] << std::endl;
}
passed_single = false;
}
}
break;
case FileTypes::MZDATA:
if (!MzDataFile().isValid(file_names[i], std::cerr))
{
std::cout << " - Error: Invalid mzData file '" << file_names[i] << "'" << std::endl;
passed_single = false;
}
break;
case FileTypes::MZXML:
if (!MzXMLFile().isValid(file_names[i], std::cerr))
{
std::cout << " - Error: Invalid mzXML file '" << file_names[i] << "'" << std::endl;
passed_single = false;
}
break;
case FileTypes::FEATUREXML:
if (!FeatureXMLFile().isValid(file_names[i], std::cerr))
{
std::cout << " - Error: Invalid featureXML file '" << file_names[i] << "'" << std::endl;
passed_single = false;
}
break;
case FileTypes::IDXML:
if (!IdXMLFile().isValid(file_names[i], std::cerr))
{
std::cout << " - Error: Invalid idXML file '" << file_names[i] << "'" << std::endl;
passed_single = false;
}
break;
case FileTypes::CONSENSUSXML:
if (!ConsensusXMLFile().isValid(file_names[i], std::cerr))
{
std::cout << " - Error: Invalid consensusXML file '" << file_names[i] << "'" << std::endl;
passed_single = false;
}
break;
case FileTypes::INI:
if (!ParamXMLFile().isValid(file_names[i], std::cerr))
{
std::cout << " - Error: Invalid Param file '" << file_names[i] << "'" << std::endl;
passed_single = false;
}
break;
case FileTypes::TRANSFORMATIONXML:
if (!TransformationXMLFile().isValid(file_names[i], std::cerr))
{
passed_single = false;
}
break;
default:
skipped = true;
break;
}
//output for single file
if (skipped)
{
std::cout << " + skipped file '" << file_names[i] << "' (type: " << FileTypes::typeToName(type) << ")" << std::endl;
}
else if (passed_single)
{
std::cout << " + valid file '" << file_names[i] << "' (type: " << FileTypes::typeToName(type) << ")" << std::endl;
}
else
{
passed_all = false;
std::cout << " - invalid file '" << file_names[i] << "' (type: " << FileTypes::typeToName(type) << ")" << std::endl;
}
}
}
//output for all files
if (passed_all)
{
std::cout << ": passed" << std::endl << std::endl;
}
else
{
std::cout << ": failed" << std::endl << std::endl;
}
return passed_all;
}
void QuantitativeExperimentalDesign::mergeIDFiles_(vector<ProteinIdentification> & proteins, vector<PeptideIdentification> & peptides, const String & experiment, StringList & file_paths)
{
set<String> used_ids;
vector<ProteinIdentification> additional_proteins;
vector<PeptideIdentification> additional_peptides;
LOG_INFO << "Merge idXML-files:" << endl;
for (StringList::Iterator file_it = file_paths.begin(); file_it != file_paths.end(); ++file_it)
{
// load should clear the vectors
IdXMLFile().load(*file_it, additional_proteins, additional_peptides);
for (vector<ProteinIdentification>::iterator prot_it =
additional_proteins.begin(); prot_it !=
additional_proteins.end(); ++prot_it)
{
prot_it->setMetaValue("experiment", DataValue(experiment));
}
for (vector<PeptideIdentification>::iterator pep_it =
additional_peptides.begin(); pep_it !=
additional_peptides.end(); ++pep_it)
{
pep_it->setMetaValue("experiment", DataValue(experiment));
}
UInt counter = 1;
for (vector<ProteinIdentification>::iterator prot_it = additional_proteins.begin(); prot_it != additional_proteins.end(); ++prot_it, ++counter)
{
String id = prot_it->getIdentifier();
if (used_ids.find(id) != used_ids.end()) // ID used previously
{
LOG_INFO << "Warning: The identifier '" + id + "' was used before!" << endl;
// generate a new ID:
DateTime date_time = prot_it->getDateTime();
String new_id;
String search_engine = prot_it->getSearchEngine();
do
{
date_time = date_time.addSecs(1);
new_id = search_engine + "_" + date_time.toString(Qt::ISODate);
}
while (used_ids.find(new_id) != used_ids.end());
LOG_INFO << "New identifier '" + new_id + "' generated as replacement." << endl;
// update fields:
prot_it->setIdentifier(new_id);
prot_it->setDateTime(date_time);
for (vector<PeptideIdentification>::iterator pep_it = additional_peptides.begin(); pep_it != additional_peptides.end(); ++pep_it)
{
if (pep_it->getIdentifier() == id)
pep_it->setIdentifier(new_id);
}
used_ids.insert(new_id);
}
else
used_ids.insert(id);
}
proteins.insert(proteins.end(), additional_proteins.begin(), additional_proteins.end());
peptides.insert(peptides.end(), additional_peptides.begin(), additional_peptides.end());
}
}
ExitCodes main_(int, const char **)
{
String in = getStringOption_("in");
StringList out = getStringList_("out");
SeedListGenerator seed_gen;
// results (actually just one result, except for consensusXML input):
Map<UInt64, SeedListGenerator::SeedList> seed_lists;
Size num_maps = 0;
FileTypes::Type in_type = FileHandler::getType(in);
if (in_type == FileTypes::CONSENSUSXML)
{
ConsensusMap consensus;
ConsensusXMLFile().load(in, consensus);
num_maps = consensus.getFileDescriptions().size();
if (out.size() != num_maps)
{
writeLog_("Error: expected " + String(num_maps) +
" output filenames");
return ILLEGAL_PARAMETERS;
}
seed_gen.generateSeedLists(consensus, seed_lists);
}
else if (out.size() > 1)
{
writeLog_("Error: expected only one output filename");
return ILLEGAL_PARAMETERS;
}
else if (in_type == FileTypes::MZML)
{
MSExperiment<> experiment;
MzMLFile().load(in, experiment);
seed_gen.generateSeedList(experiment, seed_lists[0]);
}
else if (in_type == FileTypes::IDXML)
{
vector<ProteinIdentification> proteins;
vector<PeptideIdentification> peptides;
IdXMLFile().load(in, proteins, peptides);
seed_gen.generateSeedList(peptides, seed_lists[0],
getFlag_("use_peptide_mass"));
}
else if (in_type == FileTypes::FEATUREXML)
{
FeatureMap features;
FeatureXMLFile().load(in, features);
seed_gen.generateSeedList(
features.getUnassignedPeptideIdentifications(), seed_lists[0]);
}
// output:
num_maps = 0;
for (Map<UInt64, SeedListGenerator::SeedList>::Iterator it =
seed_lists.begin(); it != seed_lists.end(); ++it, ++num_maps)
{
FeatureMap features;
seed_gen.convertSeedList(it->second, features);
//annotate output with data processing info:
addDataProcessing_(features, getProcessingInfo_(
DataProcessing::DATA_PROCESSING));
FeatureXMLFile().store(out[num_maps], features);
}
return EXECUTION_OK;
}
