def getModelDefaults(default_model):
params = pms.Param()
params.setValue("type", pms.DataValue(default_model), "Type of model")
model_types = [ "linear", "b_spline", "interpolated"]
if default_model not in model_types:
model_types.insert(0, default_model)
params.setValidStrings("type", model_types)
model_params = pms.Param()
pms.TransformationModelLinear.getDefaultParameters(model_params)
params.insert("linear:", model_params)
params.setSectionDescription("linear", "Parameters for 'linear' model")
pms.TransformationModelBSpline.getDefaultParameters(model_params)
params.insert("b_spline:", model_params)
params.setSectionDescription("b_spline", "Parameters for 'b_spline' model")
pms.TransformationModelInterpolated.getDefaultParameters(model_params)
entry = model_params.getEntry("interpolation_type")
interpolation_types = entry.valid_strings
if "polynomial" in interpolation_types:
interpolation_types.remove("polynomial")
model_params.setValidStrings("interpolation_type", interpolation_types)
params.insert("interpolated:", model_params)
params.setSectionDescription("interpolated", "Parameters for 'interpolated' model")
return params
def parseCTDCommandLine(argv, model, openms_param):
# Configure CTDOpt to use OpenMS style on the command line.
directives = parse_cl_directives(argv,
input_ctd='ini',
write_tool_ctd='write_ini',
prefix='-')
if directives[
"write_tool_ctd"] is not None: # triggered if -write_ini was provided on CML
# if called with -write_ini write CTD
model.write_ctd(directives["write_tool_ctd"])
exit(0)
elif directives["input_ctd"] is not None: # read ctd/ini file
model = CTDModel(from_file=directives["input_ctd"])
# print(model.get_defaults())
param = pms.Param()
fh = pms.ParamXMLFile()
fh.load(directives["input_ctd"], param)
openms_param.update(param, True)
return model.get_defaults(), openms_param
else: # only command line options provided
temp = tempfile.NamedTemporaryFile(
suffix='ini') # makes sure we get a writable file
tmp_name = temp.name
temp.close() # removes the file
model.write_ctd(tmp_name)
param = pms.Param()
fh = pms.ParamXMLFile()
fh.load(tmp_name, param)
openms_param.update(param)
os.remove(tmp_name)
return model.parse_cl_args(argv), openms_param
def build_params():
mtd_params = pyopenms.MassTraceDetection().getDefaults()
mtd_params.remove("chrom_peak_snr")
mtd_params.remove("noise_threshold_int")
epdet_params = pyopenms.ElutionPeakDetection().getDefaults()
epdet_params.remove("noise_threshold_int")
epdet_params.remove("chrom_peak_snr")
epdet_params.remove("chrom_fwhm")
common_params = pyopenms.Param()
common_params.setValue(
"noise_threshold_int", 10.0,
"Intensity threshold below which peaks are regarded as noise.")
common_params.setValue(
"chrom_peak_snr", 3.0,
"Minimum signal-to-noise a mass trace should have")
common_params.setValue(
"chrom_fwhm", 5.0,
"Expected chromatographic peak width (in seconds).")
ffm_params = pyopenms.FeatureFindingMetabo().getDefaults()
ffm_params.remove("chrom_fwhm")
combined_params = pyopenms.Param()
combined_params.insert("common_", common_params)
combined_params.insert("mtd_", mtd_params)
combined_params.insert("epdet_", epdet_params)
combined_params.insert("ffm_", ffm_params)
return combined_params
def getDefaultParameters():
model_param = getModelDefaults("linear")
algo_param = pms.MapAlignmentAlgorithmPoseClustering().getParameters()
default = pms.Param()
default.insert("model:", model_param)
default.insert("algorithm:", algo_param)
return default
def testFeatureFinderAlgorithmPicked():
"""
@tests:
FeatureFinderAlgorithmPicked.__init__
FeatureFinderAlgorithmPicked.getDefaults
FeatureFinderAlgorithmPicked.getName
FeatureFinderAlgorithmPicked.getParameters
FeatureFinderAlgorithmPicked.getProductName
FeatureFinderAlgorithmPicked.setName
FeatureFinderAlgorithmPicked.setParameters
"""
ff = pyopenms.FeatureFinderAlgorithmPicked()
p = ff.getDefaults()
_testParam(p)
_testParam(ff.getParameters())
assert ff.getName() == "FeatureFinderAlgorithm"
assert pyopenms.FeatureFinderAlgorithmPicked.getProductName(
) == "centroided"
ff.setParameters(pyopenms.Param())
ff.setName("test")
assert ff.getName() == "test"
def algorithm(chromatograms, targeted):
# Create empty files as input and finally as output
empty_swath = pyopenms.MSExperiment()
trafo = pyopenms.TransformationDescription()
output = pyopenms.FeatureMap()
# set up featurefinder and run
featurefinder = pyopenms.MRMFeatureFinderScoring()
# set the correct rt use values
scoring_params = pyopenms.MRMFeatureFinderScoring().getDefaults()
scoring_params.setValue("Scores:use_rt_score", 'false', '')
featurefinder.setParameters(scoring_params)
featurefinder.pickExperiment(chromatograms, output, targeted, trafo,
empty_swath)
# get the pairs
pairs = []
simple_find_best_feature(output, pairs, targeted)
pairs_corrected = pyopenms.MRMRTNormalizer().rm_outliers(pairs, 0.95, 0.6)
pairs_corrected = [list(p) for p in pairs_corrected]
# // store transformation, using a linear model as default
trafo_out = pyopenms.TransformationDescription()
trafo_out.setDataPoints(pairs_corrected)
model_params = pyopenms.Param()
model_params.setValue("symmetric_regression", 'false', '')
model_type = "linear"
trafo_out.fitModel(model_type, model_params)
return trafo_out
def __init__(self):
self.__dict__ = Elements.__we_are_all_one # shared state
if not hasattr(self, "rows"):
#path = os.path.dirname(os.path.abspath(__file__))
path = pyopenms.File.find("CHEMISTRY/Elements.xml", [])
param = pyopenms.Param()
ph = pyopenms.ParamXMLFile()
ph.load(path, param)
data = NestedBunchDict()
for k, value in param.asDict().items():
fields = k.split(":")
element = fields[1]
kind = fields[2]
if kind in ["Name", "Symbol", "AtomicNumber"]:
data[element][kind] = value
if kind == "Isotopes":
massnumber = int(fields[3])
kind = fields[4]
data[element]["Isotopes"][massnumber][kind] = value
colNames = [
"number", "symbol", "name", "massnumber", "mass", "abundance"
]
colTypes = [int, str, str, int, float, float]
colFormats = ["%d", "%s", "%s", "%d", "%.10f", "%.3f"]
rows = []
for props in data.values():
row0 = [props.AtomicNumber, props.Symbol, props.Name]
for k, isoprop in props.Isotopes.items():
row = row0 + [
k, isoprop.AtomicMass,
isoprop.RelativeAbundance / 100.0
]
rows.append(row)
super(Elements, self).__init__(colNames,
colTypes,
colFormats,
rows,
title="Elements")
self.sortBy("number")
self.massDict = dict()
for row in self.rows:
sym = self.getValue(row, "symbol")
massnum = self.getValue(row, "massnumber")
mass = self.getValue(row, "mass")
self.massDict[sym, massnum] = mass
syms = set(s for s, _ in self.massDict.keys())
for sym in syms:
minmass = min(mass for (s, mass) in self.massDict.keys()
if s == sym)
self.massDict[sym, None] = self.massDict[sym, minmass]
# borg pattern is sh*t for columns which hold a reference to the
# table which might change, but the columns stay the same !!!
self.resetInternals()
def main(options):
out = options.outfile
chromat_in = options.infile
traml_in = options.traml_in
trafo_in = options.trafo_in
pp = pyopenms.MRMTransitionGroupPicker()
metabolomics = False
# this is an important weight for RT-deviation -- the larger the value, the less importance will be given to exact RT matches
# for proteomics data it tends to be a good idea to set it to the length of
# the RT space (e.g. for 100 second RT space, set it to 100)
rt_normalization_factor = 100.0
pp_params = pp.getDefaults();
pp_params.setValue("PeakPickerMRM:remove_overlapping_peaks", options.remove_overlapping_peaks, '')
pp_params.setValue("PeakPickerMRM:method", options.method, '')
if (metabolomics):
# Need to change those for metabolomics and very short peaks!
pp_params.setValue("PeakPickerMRM:signal_to_noise", 0.01, '')
pp_params.setValue("PeakPickerMRM:peak_width", 0.1, '')
pp_params.setValue("PeakPickerMRM:gauss_width", 0.1, '')
pp_params.setValue("resample_boundary", 0.05, '')
pp_params.setValue("compute_peak_quality", "true", '')
pp.setParameters(pp_params)
scorer = pyopenms.MRMFeatureFinderScoring()
scoring_params = scorer.getDefaults();
# Only report the top 5 features
scoring_params.setValue("stop_report_after_feature", 5, '')
scoring_params.setValue("rt_normalization_factor", rt_normalization_factor, '')
scorer.setParameters(scoring_params);
chromatograms = pyopenms.MSExperiment()
fh = pyopenms.FileHandler()
fh.loadExperiment(chromat_in, chromatograms)
targeted = pyopenms.TargetedExperiment();
tramlfile = pyopenms.TraMLFile();
tramlfile.load(traml_in, targeted);
trafoxml = pyopenms.TransformationXMLFile()
trafo = pyopenms.TransformationDescription()
if trafo_in is not None:
model_params = pyopenms.Param()
model_params.setValue("symmetric_regression", "false", "", [])
model_type = "linear"
trafoxml.load(trafo_in, trafo, True)
trafo.fitModel(model_type, model_params);
light_targeted = pyopenms.LightTargetedExperiment();
pyopenms.OpenSwathDataAccessHelper().convertTargetedExp(targeted, light_targeted)
output = algorithm(chromatograms, light_targeted, pp, scorer, trafo)
pyopenms.FeatureXMLFile().store(out, output);
def updateDefaults(args, defaults):
if args.ini:
param = pms.Param()
fh = pms.ParamXMLFile()
fh.load(args.ini, param)
defaults.update(param)
elif args.dict_ini:
with open(args.dict_ini, "r") as fp:
try:
dd = eval(fp.read())
except:
raise Exception("could not parse %s" % args.dict_ini)
defaults.update(dd)
def testTransformationModels():
"""
@tests:
TransformationModelBSpline.getDefaultParameters
TransformationModelBSpline.getParameters
TransformationModelInterpolated.getDefaultParameters
TransformationModelInterpolated.getParameters
TransformationModelLinear.getDefaultParameters
TransformationModelLinear.getParameters
"""
for clz in [
pyopenms.TransformationModelBSpline,
pyopenms.TransformationModelLinear,
pyopenms.TransformationModelInterpolated
]:
mod = clz()
p = pyopenms.Param()
clz.getDefaultParameters(p)
def testFeatureFinder():
"""
@tests:
FeatureFinder.__init__
FeatureFinder.endProgress
FeatureFinder.getLogType
FeatureFinder.getParameters
FeatureFinder.run
FeatureFinder.setLogType
FeatureFinder.setProgress
FeatureFinder.startProgress
"""
ff = pyopenms.FeatureFinder()
name = pyopenms.FeatureFinderAlgorithmPicked.getProductName()
ff.run(name, pyopenms.MSExperiment(), pyopenms.FeatureMap(),
pyopenms.Param(), pyopenms.FeatureMap())
_testProgressLogger(ff)
p = ff.getParameters(name)
_testParam(p)
def _computeTransformation(algo, refMap, fm, numBreakpoints):
# be careful: alignFeatureMaps modifies second arg,
# so you MUST NOT put the arg as [] into this
# function ! in this case you have no access to the calculated
# transformations.
import pyopenms
is_v2 = pyopenms.__version__.startswith("2.0.")
# ts = []
# index is 1-based, so 1 refers to refMap when calling
# alignFeatureMaps below:
algo.setReference(refMap)
trafo = pyopenms.TransformationDescription()
if (refMap == fm):
trafo.fitModel("identity")
else:
algo.align(fm, trafo)
model_params = pyopenms.Param()
if is_v2:
model_params.setValue("num_nodes", numBreakpoints, "", [])
model_params.setValue("wavelength", 0.0, "", [])
model_params.setValue("boundary_condition", 2, "", [])
model_params.setValue("extrapolate", "bspline", "", [])
else:
pyopenms.TransformationModelBSpline.getDefaultParameters(
model_params)
model_params.setValue("num_breakpoints", numBreakpoints, "", [])
trafo.fitModel("b_spline", model_params)
# from here on used:
# trafo.getDataPoints
# trafo.apply
lowess = False
if lowess:
dp = trafo.getDataPoints()
x, y = zip(*dp)
smoother = None # smoother_lowess(y, x, frat, iterations)
trafo = LowessTrafoHolder(smoother, dp)
return trafo
def _computeTransformation(algo, refMap, fm, numBreakpoints):
# be careful: alignFeatureMaps modifies second arg,
# so you MUST NOT put the arg as [] into this
# function ! in this case you have no access to the calculated
# transformations.
import pyopenms
#ts = []
# index is 1-based, so 1 refers to refMap when calling
# alignFeatureMaps below:
algo.setReference(refMap)
trafo = pyopenms.TransformationDescription()
if (refMap == fm):
trafo.fitModel("identity")
else:
algo.align(fm, trafo)
model_params = pyopenms.Param()
pyopenms.TransformationModelBSpline.getDefaultParameters(model_params)
model_params.setValue("num_breakpoints", numBreakpoints, "", [])
trafo.fitModel("b_spline", model_params)
trafo.getModelParameters(model_params)
return trafo
def main():
parser = argparse.ArgumentParser(description="PeakPickerHiRes")
parser.add_argument("-in",
action="append",
type=str,
dest="in_",
metavar="input_file",
)
parser.add_argument("-seeds",
action="store",
type=str,
metavar="seeds_file",
)
parser.add_argument("-out",
action="append",
type=str,
metavar="output_file",
)
parser.add_argument("-trafo_out",
action="append",
type=str,
metavar="output_file",
)
parser.add_argument("-ini",
action="store",
type=str,
metavar="ini_file",
)
parser.add_argument("-dict_ini",
action="store",
type=str,
metavar="python_dict_ini_file",
)
parser.add_argument("-write_ini",
action="store",
type=str,
metavar="ini_file",
)
parser.add_argument("-write_dict_ini",
action="store",
type=str,
metavar="python_dict_ini_file",
)
parser.add_argument("-reference:file",
action="store",
type=str,
metavar="reference_file",
dest="reference_file",
)
parser.add_argument("-reference:index",
action="store",
type=int,
metavar="reference_index",
dest="reference_index",
)
args = parser.parse_args()
def collect(args):
return [f.strip() for arg in args or [] for f in arg.split(",")]
in_files = collect(args.in_)
out_files = collect(args.out)
trafo_out_files = collect(args.trafo_out)
run_mode = args.in_ is not None and args.out is not None\
and (args.ini is not None or args.dict_ini is not None)
write_mode = args.write_ini is not None or args.write_dict_ini is not None
ok = run_mode or write_mode
if not ok:
parser.error("either specify -in, -(trafo_)out and -(dict)ini for running "
"the peakpicker\nor -write(dict)ini for creating std "
"ini file")
defaults = getDefaultParameters()
if args.write_dict_ini or args.write_ini:
if args.write_dict_ini:
with open(args.write_dict_ini, "w") as fp:
pprint.pprint(defaults.asDict(), stream=fp)
if args.write_ini:
defaults.store(args.write_ini)
else:
if args.ini:
param = pms.Param()
param.load(args.ini)
defaults.update(param, False, False)
elif args.dict_ini:
with open(args.dict_ini, "r") as fp:
try:
dd = eval(fp.read())
except:
raise Exception("could not parse %s" % args.dict_ini)
defaults.updateFrom(dd)
if not out_files and not trafo_out_files:
parser.error("need -out or -trafo_out files")
if out_files and len(out_files) != len(in_files):
parser.error("need as many -out files as -in files")
if trafo_out_files and len(trafo_out_files) != len(in_files):
parser.error("need as many -trafo_out files as -in files")
if args.reference_index is not None and args.reference_file is not None:
parser.error("can only handle either reference:index or reference:file")
if args.reference_index is not None:
if args.reference_index <0 or args.reference_index >= len(in_files):
parser.error("reference:index invalid")
in_types = set(pms.FileHandler.getType(in_) for in_ in in_files)
if in_types <= set((pms.Type.MZML, pms.Type.MZXML, pms.Type.MZDATA)):
pass
elif in_types == set((pms.Type.FEATUREXML,)):
pass
else:
parser.error("different kinds of input files")
align(in_files, out_files, trafo_out_files, args.reference_index or 0,
args.reference_file or "", defaults)
def _testParam(p):
"""
@tests:
Param.__init__
Param.addTag
Param.addTags
Param.asDict
Param.clearTags
Param.copy
Param.exists
Param.getDescription
Param.getEntry
Param.getSectionDescription
Param.getTags
Param.getValue
Param.hasTag
Param.insert
Param.load
Param.setMaxFloat
Param.setMaxInt
Param.setMinFloat
Param.setMinInt
Param.setSectionDescription
Param.setValidStrings
Param.setValue
Param.size
Param.store
Param.update
Param.updateFrom
Param.__eq__
Param.__ge__
Param.__gt__
Param.__le__
Param.__lt__
Param.__ne__
ParamEntry.__init__
ParamEntry.description
ParamEntry.isValid
ParamEntry.max_float
ParamEntry.max_int
ParamEntry.min_float
ParamEntry.min_int
ParamEntry.name
ParamEntry.tags
ParamEntry.valid_strings
ParamEntry.value
ParamEntry.__eq__
ParamEntry.__ge__
ParamEntry.__gt__
ParamEntry.__le__
ParamEntry.__lt__
ParamEntry.__ne__
"""
assert p == p
dd = p.asDict()
assert len(dd) == p.size()
assert isinstance(dd, dict)
keys = dd.keys()
for k in keys:
value = p.getValue(k)
desc = p.getDescription(k)
tags = p.getTags(k)
p.setValue(k, value, desc, tags)
p.setValue(k, value, desc)
assert p.exists(k)
f = k.split(":")[0]
p.setSectionDescription(f, k)
assert p.getSectionDescription(f) == k
assert not p.exists("asdflkj01231321321v")
p.addTag(k, "a")
p.addTags(k, ["b", "c"])
assert sorted(p.getTags(k)) == ["a", "b", "c"]
p.clearTags(k)
assert p.getTags(k) == []
pn = pyopenms.Param()
pn.insert("master:", p)
assert pn.exists("master:" + k)
p1 = pn.copy("master:", True)
assert p1 == p
p1.update(p, True, False)
p.setValidStrings
p.setMinFloat
p.setMaxFloat
p.setMinInt
p.setMaxInt
p.store("test.ini")
p1 = pyopenms.Param()
p1.load("test.ini")
assert p == p1
e1 = p1.getEntry(k)
for f in [
"name", "description", "value", "tags", "valid_strings",
"min_float", "max_float", "min_int", "max_int"
]:
assert getattr(e1, f) is not None
assert e1 == e1
def main():
parser = argparse.ArgumentParser(description="PeakPickerHiRes")
parser.add_argument(
"-in",
action="store",
type=str,
dest="in_",
metavar="input_file",
)
parser.add_argument(
"-out",
action="store",
type=str,
metavar="output_file",
)
parser.add_argument(
"-ini",
action="store",
type=str,
metavar="ini_file",
)
parser.add_argument(
"-dict_ini",
action="store",
type=str,
metavar="python_dict_ini_file",
)
parser.add_argument(
"-write_ini",
action="store",
type=str,
metavar="ini_file",
)
parser.add_argument(
"-write_dict_ini",
action="store",
type=str,
metavar="python_dict_ini_file",
)
args = parser.parse_args()
run_mode = args.in_ is not None and args.out is not None\
and (args.ini is not None or args.dict_ini is not None)
write_mode = args.write_ini is not None or args.write_dict_ini is not None
ok = run_mode or write_mode
if not ok:
parser.error("either specify -in, -out and -(dict)ini for running "
"the peakpicker\nor -write(dict)ini for creating std "
"ini file")
defaults = pms.PeakPickerHiRes().getDefaults()
if args.write_dict_ini or args.write_ini:
if args.write_dict_ini:
with open(args.write_dict_ini, "w") as fp:
pprint.pprint(defaults.asDict(), stream=fp)
if args.write_ini:
defaults.store(args.write_ini)
else:
if args.ini:
param = pms.Param()
param.load(args.ini)
defaults.update(param, False, False)
elif args.dict_ini:
with open(args.dict_ini, "r") as fp:
try:
dd = eval(fp.read())
except:
raise Exception("could not parse %s" % args.dict_ini)
defaults.updateFrom(dd)
fh = pms.MzXMLFile()
fh.setLogType(pms.LogType.CMD)
input_map = pms.MSExperiment()
fh.load(args.in_, input_map)
run_peak_picker(input_map, defaults, args.out)
