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 main(self): #after path_parsing method we have self.src_full_name_list for f in get_list_full_names(self.src): print("Map Alignment implementation") print("Source file:", f) # to prepare(init) empty list and entity; self.init_entity(**self.kw) self.reference_map = oms.FeatureMap() self.toAlign_map = oms.FeatureMap() oms.FeatureXMLFile().load(self.reference_file, self.reference_map) oms.FeatureXMLFile().load(f, self.toAlign_map) #Set reference_map file self.ma.entity.setReference(self.reference_map) #3rd step create object for the computed transformation transformation = oms.TransformationDescription() # the 4rd step: self.ma.entity.align(self.toAlign_map, transformation) # the 5th step: is store result into file; self.dst_full_file_name = os.path.join(self.dst,\ convert_src_to_dst_file_name(f, self.dst, self.suffix_dst_files, self.ext_dst_files) ) #print("dst=",dst_full_file_name) oms.FeatureXMLFile().store(self.dst_full_file_name, self.toAlign_map) oms.FeatureXMLFile().store(self.dst_full_file_name, self.reference_map) print("Aligned data stored into:", self.dst_full_file_name)
def test_run_mrmfeaturefinder(self): # load chromatograms chromatograms = pyopenms.MSExperiment() fh = pyopenms.FileHandler() fh.loadExperiment(self.chromatograms, chromatograms) # load TraML file targeted = pyopenms.TargetedExperiment() tramlfile = pyopenms.TraMLFile() tramlfile.load(self.tramlfile, 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() featurefinder.pickExperiment(chromatograms, output, targeted, trafo, empty_swath) self.assertAlmostEqual(output.size(), 3) self.assertAlmostEqual(output[0].getRT(), 3119.092041015, eps) self.assertAlmostEqual(output[0].getIntensity(), 3614.99755859375, eps) self.assertAlmostEqual( output[0].getMetaValue(b"var_xcorr_shape_weighted"), 0.997577965259552, eps) self.assertAlmostEqual(output[0].getMetaValue(b"sn_ratio"), 86.00413513183594, eps)
def test_extractor(self): targeted = pyopenms.TargetedExperiment() tramlfile = pyopenms.TraMLFile() tramlfile.load(self.filename, targeted) exp = pyopenms.MSExperiment() pyopenms.MzMLFile().load(self.filename_mzml, exp) trafo = pyopenms.TransformationDescription() tmp_out = pyopenms.MSExperiment() extractor = pyopenms.ChromatogramExtractor() extractor.extractChromatograms(exp, tmp_out, targeted, 10, False, trafo, -1, "tophat") # Basically test that the output is non-zero (e.g. the data is # correctly relayed to python) # The functionality is not tested here! self.assertEqual(len(tmp_out.getChromatograms()), len(targeted.getTransitions())) self.assertNotEqual(len(tmp_out.getChromatograms()), 0) self.assertEqual(tmp_out.getChromatograms()[0].size(), exp.size()) self.assertNotEqual(tmp_out.getChromatograms()[0].size(), 0) self.assertNotEqual(tmp_out.getChromatograms()[0][0].getRT(), 0) self.assertNotEqual(tmp_out.getChromatograms()[0][0].getIntensity(), 0)
def test_readfile_content(self): exp = pyopenms.MSExperiment() pyopenms.MzMLFile().load(self.filename, exp) exp_size = exp.size() saccess = pyopenms.SpectrumAccessOpenMS(exp) ### double mz # mz around which should be extracted ### double rt_start # rt start of extraction (in seconds) ### double rt_end # rt end of extraction (in seconds) ### libcpp_string id # identifier targeted = [] coord = pyopenms.ExtractionCoordinates() coord.mz = 618.31 coord.rt_start = 4000 coord.rt_end = 5000 coord.id = b"tr3" targeted.append(coord) coord = pyopenms.ExtractionCoordinates() coord.mz = 628.45 coord.rt_start = 4000 coord.rt_end = 5000 coord.id = b"tr1" targeted.append(coord) coord = pyopenms.ExtractionCoordinates() coord.mz = 654.38 coord.rt_start = 4000 coord.rt_end = 5000 coord.id = b"tr2" targeted.append(coord) trafo = pyopenms.TransformationDescription() # Start with length zero tmp_out = [pyopenms.OSChromatogram() for i in range(len(targeted))] self.assertEqual(len(tmp_out[0].getIntensityArray()), 0) extractor = pyopenms.ChromatogramExtractorAlgorithm() mz_extraction_window = 10.0 ppm = False extractor.extractChromatograms(saccess, tmp_out, targeted, mz_extraction_window, ppm, -1.0, b"tophat") # Basically test that the output is non-zero (e.g. the data is # correctly relayed to python) # The functionality is not tested here! self.assertEqual(len(tmp_out), len(targeted)) self.assertNotEqual(len(tmp_out), 0) # End with different length self.assertEqual(len(tmp_out[0].getIntensityArray()), exp_size) self.assertNotEqual(len(tmp_out[0].getIntensityArray()), 0) self.assertNotEqual(len(tmp_out[0].getTimeArray()), 0) self.assertNotEqual(tmp_out[0].getIntensityArray()[0], 0) self.assertNotEqual(tmp_out[0].getTimeArray()[0], 0)
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 testTransformationDescription(): """ @tests: TransformationDescription.__init__ TransformationDescription.apply TransformationDescription.getDataPoints """ td = pyopenms.TransformationDescription() assert td.getDataPoints() == [] assert isinstance(td.apply(0.0), float)
def testTransformationXMLFile(): """ @tests: TransformationXMLFile.__init__ TransformationXMLFile.load TransformationXMLFile.store """ fh = pyopenms.TransformationXMLFile() td = pyopenms.TransformationDescription() fh.store("test.transformationXML", td) fh.load("test.transformationXML", td) assert td.getDataPoints() == []
def main(options): # load TraML file targeted = pyopenms.TargetedExperiment() pyopenms.TraMLFile().load(options.traml_in, targeted) # Create empty files as input and finally as output empty_swath = pyopenms.MSExperiment() trafo = pyopenms.TransformationDescription() output = pyopenms.MSExperiment() # load input for infile in options.infiles: exp = pyopenms.MSExperiment() pyopenms.FileHandler().loadExperiment(infile, exp) transition_exp_used = pyopenms.TargetedExperiment() do_continue = True if options.is_swath: do_continue = pyopenms.OpenSwathHelper( ).checkSwathMapAndSelectTransitions(exp, targeted, transition_exp_used, options.min_upper_edge_dist) else: transition_exp_used = targeted if do_continue: # set up extractor and run tmp_out = pyopenms.MSExperiment() extractor = pyopenms.ChromatogramExtractor() extractor.extractChromatograms(exp, tmp_out, targeted, options.extraction_window, options.ppm, trafo, options.rt_extraction_window, options.extraction_function) # add all chromatograms to the output for chrom in tmp_out.getChromatograms(): output.addChromatogram(chrom) dp = pyopenms.DataProcessing() pa = pyopenms.ProcessingAction().SMOOTHING dp.setProcessingActions(set([pa])) chromatograms = output.getChromatograms() for chrom in chromatograms: this_dp = chrom.getDataProcessing() this_dp.append(dp) chrom.setDataProcessing(this_dp) output.setChromatograms(chromatograms) pyopenms.MzMLFile().store(options.outfile, output)
def test_run_mrmrtnormalizer(self): # load chromatograms chromatograms = pyopenms.MSExperiment() fh = pyopenms.FileHandler() fh.loadExperiment(self.chromatograms, chromatograms) # load TraML file targeted = pyopenms.TargetedExperiment() tramlfile = pyopenms.TraMLFile() tramlfile.load(self.tramlfile, 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".encode(), 'false'.encode(), ''.encode()) 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().removeOutliersIterative( pairs, 0.95, 0.6, True, "iter_jackknife") pairs_corrected = [list(p) for p in pairs_corrected] expected = [(1497.56884765625, 1881.0), (2045.9776611328125, 2409.0), (2151.4814453125, 2509.0), (1924.0750732421875, 2291.0), (612.9832153320312, 990.0), (1086.2474365234375, 1470.0), (1133.89404296875, 1519.0), (799.5291137695312, 1188.0), (1397.1541748046875, 1765.0)] for exp, res in zip(expected, pairs_corrected): self.assertAlmostEqual(exp[0], res[0], eps) self.assertAlmostEqual(exp[1], res[1], eps)
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 processPools(fileList, args): groups = groupSamplePools(fileList) # read raw input files and process for key, value in groups.items(): sys.stdout.write('Working on {}\n'.format(key)) # load files and split polarity posRuns = list() negRuns = list() raw = pyopenms.MSExperiment() for file in value: pyopenms.MzDataFile().load(file, raw) pos, neg = splitPolarity(raw) posRuns.append(pos) negRuns.append(neg) # run alignment alg = pyopenms.MapAlignmentAlgorithmIdentification() posTrans = list() posTrans = [pyopenms.TransformationDescription() for x in range(1)] #negTrans = [pyopenms.TransformationDescription() for x in range(len(negRuns))] alg.align(posRuns, posTrans)
def align(in_files, out_files, out_trafos, reference_index, reference_file, params): 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)): align_features = False elif in_types == set((pms.Type.FEATUREXML, )): align_features = True else: raise Exception("different kinds of input files") algorithm = pms.MapAlignmentAlgorithmPoseClustering() alignment_params = params.copy("algorithm:", True) algorithm.setParameters(alignment_params) algorithm.setLogType(pms.LogType.CMD) plog = pms.ProgressLogger() plog.setLogType(pms.LogType.CMD) if reference_file: file_ = reference_file elif reference_index > 0: file_ = in_files[reference_index - 1] else: sizes = [] if align_features: fh = pms.FeatureXMLFile() plog.startProgress(0, len(in_files), "Determine Reference map") for i, in_f in enumerate(in_files): sizes.append((fh.loadSize(in_f), in_f)) plog.setProgress(i) else: fh = pms.MzMLFile() mse = pms.MSExperiment() plog.startProgress(0, len(in_files), "Determine Reference map") for i, in_f in enumerate(in_files): fh.load(in_f, mse) mse.updateRanges() sizes.append((mse.getSize(), in_f)) plog.setProgress(i) plog.endProgress() __, file_ = max(sizes) f_fmxl = pms.FeatureXMLFile() if not out_files: options = f_fmxl.getOptions() options.setLoadConvexHull(False) options.setLoadSubordinates(False) f_fmxl.setOptions(options) if align_features: map_ref = pms.FeatureMap() f_fxml_tmp = pms.FeatureXMLFile() options = f_fmxl.getOptions() options.setLoadConvexHull(False) options.setLoadSubordinates(False) f_fxml_tmp.setOptions(options) f_fxml_tmp.load(file_, map_ref) algorithm.setReference(map_ref) else: map_ref = pms.MSExperiment() pms.MzMLFile().load(file_, map_ref) algorithm.setReference(map_ref) plog.startProgress(0, len(in_files), "Align input maps") for i, in_file in enumerate(in_files): trafo = pms.TransformationDescription() if align_features: map_ = pms.FeatureMap() f_fxml_tmp = pms.FeatureXMLFile() f_fxml_tmp.setOptions(f_fmxl.getOptions()) f_fxml_tmp.load(in_file, map_) if in_file == file_: trafo.fitModel("identity") else: algorithm.align(map_, trafo) if out_files: pms.MapAlignmentTransformer.transformSingleFeatureMap( map_, trafo) addDataProcessing(map_, params, pms.ProcessingAction.ALIGNMENT) f_fxml_tmp.store(out_files[i], map_) else: map_ = pms.MSExperiment() pms.MzMLFile().load(in_file, map_) if in_file == file_: trafo.fitModel("identity") else: algorithm.align(map_, trafo) if out_files: pms.MapAlignmentTransformer.transformSinglePeakMap(map_, trafo) addDataProcessing(map_, params, pms.ProcessingAction.ALIGNMENT) pms.MzMLFile().store(out_files[i], map_) if out_trafos: pms.TransformationXMLFile().store(out_trafos[i], trafo) plog.setProgress(i + 1) plog.endProgress()
def align_feature_xmls(feature_xml_lis, consensus_map_out_path="", class_label_dict={}): """ first apply pose clustering to include all features maps next link/group them across all features Each MS1 spectrum from raw-file will create a feature file - we need to load and align them to get unique and representative features :param feature_xml_lis: :param consensus_map_out_path: :return: consensus_map, consensus_map_out_path, measurement_names """ # do consensus map normalization and export - # can't hack normalization together from lack of example usage and poor signature # - no normalization implemented # openms won't deal with posix paths - wants to have strings instead # need to make sure it get's those # let's sort them to make sure feature matrix is also sorted feature_xml_lis = sorted([str(fx) for fx in feature_xml_lis]) num_features_list = [] for current_feature_xml_path in feature_xml_lis: # load features into FeatureMaps cm = oms.FeatureMap() # current_map oms.FeatureXMLFile().load(current_feature_xml_path, cm) # list_functions(current_map, prefix="") num_features_list.append(cm.size()) del cm # should choose the feature file / experiment with most features as reference max_index = np.argmax(num_features_list) reference_map_path = feature_xml_lis[max_index] default_max_num_peaks_considered = 1000 default_max_scaling_value = 10.0 aligned_paths = [] for i, current_feature_xml_path in enumerate(feature_xml_lis): # load features into FeatureMaps reference_map = oms.FeatureMap( ) # pairwise alignment - so need master map - oms.FeatureXMLFile().load(reference_map_path, reference_map) current_map = oms.FeatureMap() oms.FeatureXMLFile().load(current_feature_xml_path, current_map) # create a transformation description required as init for aligner transformation_description = oms.TransformationDescription() # adjust max scaling parameter otherwise leads to error when running with algae samples # adjust max num peaks to 2k - also would leads to error when running with algae samples aligner = oms.MapAlignmentAlgorithmPoseClustering() aligner_params = aligner.getParameters() # print(aligner_params.asDict().keys()) max_scaling_key = b'superimposer:max_scaling' # aligner_params.getEntry(max_scaling_key) aligner_params.setValue(max_scaling_key, default_max_scaling_value) max_num_peaks_key = b'max_num_peaks_considered' # aligner_params.getEntry(max_num_peaks_key) aligner_params.setValue( max_num_peaks_key, default_max_num_peaks_considered) # default = 1000 # need higher default for algae # decrease runtime by removing weak signals # print(aligner_params.asDict()) num_used_points_key = b'superimposer:num_used_points' # aligner_params.getEntry(num_used_points_key) aligner_params.setValue( num_used_points_key, 1000) # half the default parameter, speed up alignment aligner.setParameters(aligner_params) aligner.setReference(reference_map) try: # run alignment aligner.align(current_map, transformation_description) except RuntimeError as re: if 'max_num_peaks_considered' in str(re): # retry with higher threshold - required for algae dataset default_max_num_peaks_considered = 15000 # 15 fold - makes it a lot slower but less error prone aligner_params.setValue(max_num_peaks_key, default_max_num_peaks_considered) default_max_scaling_value = 20.0 # need to increase to 20 aligner_params.setValue(max_scaling_key, default_max_scaling_value) # max shift could also be off - issue for ckd dataset default_max_shift_value = 2000.0 # need to increase from 1000 to 2000 max_shift_key = b'superimposer:max_shift' aligner_params.setValue(max_shift_key, default_max_shift_value) print( f"Encountered GC/MS Clustering issue - setting 'max_num_peaks_considered' to {default_max_num_peaks_considered}, 'superimposer:max_scaling' to {default_max_scaling_value} and 'superimposer:max_shift' to {default_max_shift_value}" ) aligner.setParameters(aligner_params) aligner.setReference(reference_map) aligner.align(current_map, transformation_description) current_map.updateRanges() reference_map.updateRanges() # update feature XML files - both reference and current updated_current_map_path = default_store_aligned_feature_xml( current_map, current_feature_xml_path) updated_reference_path = default_store_aligned_feature_xml( reference_map, reference_map_path) reference_map_path = updated_reference_path aligned_paths.append(updated_current_map_path) print(f"Finished alignment of {i}/{len(feature_xml_lis)-1}") # also replace here with new reference we updated the reference map to aligned_paths[max_index] = reference_map_path # link/group them across features to create consensus map grouper = oms.FeatureGroupingAlgorithmUnlabeled() # leave parameters default # according to openms documentation: # b) Call "setReference", "addToGroup" (n times), "getResultMap" in that order. for i, current_feature_map_path in enumerate(aligned_paths): print(f"Grouping features {i}/{len(aligned_paths)-1}") current_map = oms.FeatureMap() oms.FeatureXMLFile().load(current_feature_map_path, current_map) if not i: # first iteration - use as reference grouper.setReference(i, current_map) else: grouper.addToGroup(i, current_map) # get consensus map consensus_map = grouper.getResultMap() # consensus map requires some mapping between ids and filenames - otherwise will complain print(f"Mapping aligned results back to class labels") class_label_fns = list(class_label_dict.keys()) fds = {i: oms.ColumnHeader() for i, _ in enumerate(aligned_paths)} measurement_names = [] for i, aligned_path in enumerate(aligned_paths): # fds[i].filename = b"file0" current_fn = f"{str(Path(aligned_path).stem)}{str(Path(aligned_path).suffix)}" # this is where we need to replace the feature_xml filenames with the ones from class_labels if class_label_dict: # could do longest substring match with each of the fns in class_label dict to find matching filename # django will rename duplicate filenames instead of overwriting # or we expect both featureXML input and class_label_dict to be ordered - which they should be when using the getter fds[i].filename = class_label_fns[i] else: fds[i].filename = current_fn.encode( "UTF8") # needs bytestring representation measurement_names.append(current_fn) consensus_map.setColumnHeaders(fds) # cleanup aligned_feature_xmls - can be >30mb per file - so better remove them for ap in aligned_paths: os.remove(ap) # do consensus map normalization and export to consensus files # using median normalization, also available are Quantile and "robust regression" normalizer = oms.ConsensusMapNormalizerAlgorithmMedian() # ConsensusMapNormalizerAlgorithmMedian # signature of class is more than incomplete ... *args **kwargs for required parameters is not the best implementation choice... # but gives TypeError requiring int when calling with # normalizer.normalizeMaps(consensus_map, "NM_SCALE", "", "") # """ normalizer.normalizeMaps(map, method, acc_filter, desc_filter) map ConsensusMap method whether to use scaling or shifting to same median acc_filter string describing the regular expression for filtering accessions desc_filter string describing the regular expression for filtering descriptions """ """ method: probably 0 / 1 - referenced as Enumerator in OpenMS documentation from shell output can deduce normalization methods are 0: NM_SCALE scale to same median using division/multiplication 1: NM_SHIFT shift using subtraction/addition """ normalizer.normalizeMaps(consensus_map, 0, "", "") # don't export if not required - requires more file management # now export if consensus_map_out_path: print("Storing consensus xml") oms.ConsensusXMLFile().store(str(consensus_map_out_path), consensus_map) return consensus_map, measurement_names
def run_ma(self, **kwargs): #create object for the computed transformation self.transformation = oms.TransformationDescription() #align self.ma_algorithm.align(self.toAlign, self.transformation)