bool DigestionEnzyme::setValueFromFile(const String& key, const String& value)
{
if (key.hasSuffix(":Name"))
{
setName(value);
return true;
}
if (key.hasSuffix(":RegEx"))
{
setRegEx(value);
return true;
}
if (key.hasSuffix(":RegExDescription"))
{
setRegExDescription(value);
return true;
}
if (key.hasSubstring(":Synonyms:"))
{
addSynonym(value);
return true;
}
return false;
}
//reimplemented in order to handle index MzML
bool MzMLFile::isValid(const String& filename, std::ostream& os)
{
//determine if this is indexed mzML or not
bool indexed = false;
TextFile file(filename, true, 4);
String s;
s.concatenate(file.begin(), file.end());
if (s.hasSubstring("<indexedmzML"))
{
indexed = true;
}
// find the corresponding schema
String current_location;
if (indexed)
{
current_location = File::find(indexed_schema_location_);
}
else
{
current_location = File::find(schema_location_);
}
return XMLValidator().isValid(filename, current_location, os);
}
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;
}
#endif
TEST_EQUAL(File::getUserDirectory(), dirname)
// Note: this does not guarantee any more that the user directory or an
// OpenMS.ini file exists at the new location.
END_SECTION
START_SECTION(static Param getSystemParameters())
Param p = File::getSystemParameters();
TEST_EQUAL(p.size()>0, true)
TEST_EQUAL(p.getValue("version"), VersionInfo::getVersion())
END_SECTION
START_SECTION(static String findDatabase(const String &db_name))
TEST_EXCEPTION(Exception::FileNotFound, File::findDatabase("filedoesnotexists"))
String db = File::findDatabase("./CV/unimod.obo");
//TEST_EQUAL(db,"wtf")
TEST_EQUAL(db.hasSubstring("share/OpenMS"), true)
END_SECTION
START_SECTION(static String findExecutable(const OpenMS::String& toolName))
{
TEST_EXCEPTION(Exception::FileNotFound, File::findExecutable("executable_does_not_exist"))
TEST_EQUAL(File::path(File::findExecutable("File_test")) + "/", File::getExecutablePath())
}
END_SECTION
/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////
END_TEST
void createFragment_(String & fragment, const Param & param)
{
//std::cerr << "FRAGMENT: " << fragment << "\n\n";
// e.g.: -input %BASENAME[%%in].mzML
// we have to make this little detour param -> vector<String>
// to sort the param names by length, otherwise we have a
// problem with parameter substitution
// i.e., if A is a prefix of B and gets replaced first, the
// suffix of B remains and will cause trouble!
vector<String> param_names;
param_names.reserve(param.size());
for (Param::ParamIterator it = param.begin(); it != param.end(); ++it)
{
param_names.push_back(it->name);
}
// sort by length
std::sort(param_names.begin(), param_names.end(), reverseComparator(StringSizeLess()));
// iterate through all input params and replace with values:
SignedSize allowed_percent(0); // filenames might contain '%', which are allowed to remain there (and even must remain)
for (vector<String>::iterator it = param_names.begin(); it != param_names.end(); ++it)
{
if (!fragment.hasSubstring("%%" + *it)) continue;
String s_new = paramToString_(param.getEntry(*it));
allowed_percent += s_new.length() - String(s_new).substitute("%", "").length();
//std::cerr << "IN: " << s_new << "(" << allowed_percent << "\n";
fragment.substitute("%%" + *it, s_new);
}
if (fragment.hasSubstring("%%")) throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Invalid '%%' found in '" + fragment + "' after replacing all parameters!", fragment);
// %TMP replace:
fragment.substitute("%TMP", File::getTempDirectory());
// %RND replace:
fragment.substitute("%RND", String(UniqueIdGenerator::getUniqueId()));
// %WORKINGDIR replace:
fragment.substitute("%WORKINGDIR", tde_.working_directory);
// %DIR% replace
{
QRegExp rx("%DIR\\[(.*)\\]");
rx.setMinimal(true);
int pos = 0;
QString t_tmp = fragment.toQString();
//std::cout << "fragment is:" << fragment << std::endl;
while ((pos = rx.indexIn(t_tmp, pos)) != -1)
{
String value = rx.cap(1); // param name (hopefully)
// replace in fragment:
QFileInfo qfi(value.toQString());
//std::cout << "match @ " << pos << " " << value << " --> " << qfi.canonicalPath() << "\n";
t_tmp = t_tmp.replace(String("%DIR[" + value + "]").toQString(), qfi.canonicalPath());
}
fragment = String(t_tmp);
//std::cout << "NEW fragment is:" << fragment << std::endl;
}
// %BASENAME% replace
{
QRegExp rx("%BASENAME\\[(.*)\\]");
rx.setMinimal(true);
int pos = 0, count = 0;
QString t_tmp = fragment.toQString();
while ((pos = rx.indexIn(t_tmp, pos)) != -1)
{
//std::cout << "match @ " << pos << "\n";
String value = rx.cap(1); // param name (hopefully)
// replace in fragment:
QFileInfo qfi(value.toQString());
//std::cout << "match @ " << pos << " " << value << " --> " << qfi.completeBaseName() << "\n";
t_tmp = t_tmp.replace(String("%BASENAME[" + value + "]").toQString(), qfi.completeBaseName());
++count;
}
// update expected count of valid '%'
allowed_percent -= (fragment.length() - String(fragment).substitute("%", "").length()) // original # of %
- (t_tmp.length() - String(t_tmp).substitute("%", "").length()) // new # of %
- count; // expected # of % due to %BASENAME
fragment = String(t_tmp);
}
SignedSize diff = (fragment.length() - String(fragment).substitute("%", "").length()) - allowed_percent;
//std::cerr << "allowed: " << allowed_percent << "\n" << "diff: " << diff << " in: " << fragment << "\n";
if (diff > 0) throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Mapping still contains '%' after substitution! Did you use % instead of %%?", fragment);
else if (diff < 0) throw Exception::InvalidValue(__FILE__, __LINE__, __PRETTY_FUNCTION__, "Error: '%' from a filename where accidentally considered command tags! "
"This is a bug! Remove '%' from input filesnames to fix, but please report this as well!", fragment);
//std::cout << fragment << "'\n";
}
bool MRMFragmentSelection::peakselectionIsAllowed_(const RichPeak1D & peak)
{
StringList allowed_charges = param_.getValue("allowed_charges");
String name;
if (peak.metaValueExists("IonName"))
{
name = peak.getMetaValue("IonName");
}
if (name != "")
{
StringList allowed_types = param_.getValue("allowed_ion_types");
bool type_found(false);
for (StringList::const_iterator it = allowed_types.begin(); it != allowed_types.end(); ++it)
{
if (name.hasSubstring(*it))
{
type_found = true;
}
}
if (type_found)
{
bool allow_loss_ions(param_.getValue("allow_loss_ions").toBool());
Size charges = count(name.begin(), name.end(), '+');
bool charges_ok = ListUtils::contains(allowed_charges, String(charges));
if (allow_loss_ions && charges_ok)
{
// TODO implement charges
return true;
}
else
{
if (!(name.hasSubstring("-H") || name.hasSubstring("-C") || name.hasSubstring("-N")))
{
Size c = count(name.begin(), name.end(), '+');
if (ListUtils::contains(allowed_charges, String(c)))
{
return true;
}
else
{
return false;
}
}
else
{
return false;
}
}
}
else
{
return false;
}
}
else
{
return false;
}
return true;
}
START_SECTION((void setInitialParameters(const GumbelDistributionFitResult& result)))
{
GumbelDistributionFitter f1;
GumbelDistributionFitter::GumbelDistributionFitResult result;
f1.setInitialParameters(result);
NOT_TESTABLE //implicitly tested in fit method
}
END_SECTION
START_SECTION((const String& getGnuplotFormula() const ))
{
String formula = ptr->getGnuplotFormula();
// f(x)=(1/1) * exp(-(x - 1)/1) * exp(-1 * exp(-(x-1)/1))
TEST_EQUAL(formula.hasSubstring("f(x)="), true)
TEST_EQUAL(formula.hasSubstring(") * exp(-exp(("), true)
TEST_EQUAL(formula.hasSubstring(" - x)/"), true)
}
END_SECTION
START_SECTION((GumbelDistributionFitter(const GumbelDistributionFitter& rhs)))
NOT_TESTABLE
END_SECTION
START_SECTION((GumbelDistributionFitter& operator = (const GumbelDistributionFitter& rhs)))
NOT_TESTABLE
END_SECTION
GumbelDistributionFitter::GumbelDistributionFitResult* p = 0;
START_SECTION((GumbelDistributionFitter::GumbelDistributionFitResult()))
p = new GumbelDistributionFitter::GumbelDistributionFitResult;
void MzTabModificationList::fromCellString(const String& s)
{
String lower = s;
lower.toLower().trim();
if (lower == "null")
{
setNull(true);
}
else
{
String ss = s;
std::vector<String> fields;
if (!ss.hasSubstring("[")) // no parameters
{
ss.split(",", fields);
for (Size i = 0; i != fields.size(); ++i)
{
MzTabModification ms;
ms.fromCellString(fields[i]);
entries_.push_back(ms);
}
}
else
{
// example string: 3|4[a,b,,v]|8[,,"blabla, [bla]",v],1|2|3[a,b,,v]-mod:123
// we don't want to split at the , inside of [ ] MzTabParameter brackets.
// Additionally, and we don't want to recognise quoted brackets inside the MzTabParameter where they can occur in quoted text (see example string)
bool in_param_bracket = false;
bool in_quotes = false;
for (Size pos = 0; pos != ss.size(); ++pos)
{
// param_bracket state
if (ss[pos] == '[' && !in_quotes)
{
in_param_bracket = true;
continue;
}
if (ss[pos] == ']' && !in_quotes)
{
in_param_bracket = false;
continue;
}
// quote state
if (ss[pos] == '\"')
{
in_quotes = !in_quotes;
continue;
}
// comma in param bracket
if (ss[pos] == ',' && !in_quotes && in_param_bracket)
{
ss[pos] = ((char)007); // use ASCII bell as temporary separator
continue;
}
}
// now the split at comma is save
ss.split(",", fields);
for (Size i = 0; i != fields.size(); ++i)
{
fields[i].substitute(((char)007), ','); // resubstitute comma after split
MzTabModification ms;
ms.fromCellString(fields[i]);
entries_.push_back(ms);
}
}
}
}
