Home  · Classes  · Annotated Classes  · Modules  · Members  · Namespaces  · Related Pages

High-level data analysis

OpenMS offers a number of classes for high-level data analysis. This covers map alignment, peptide/protein identification, clustering, etc. The classes described in this section can be found in the ANALYSIS folder.

Map alignment

Pairwise map alignment

The class PoseClusteringPairwiseMapMatcher can be used to map the element of one LC-MS map onto the elements of another LC-MS map. Corresponding elements of the two maps are moved closer together and the retention time as well as the m/z dimensions of the two maps become comparable. The transformation which maps one map onto the other is computed during the so called superposition phase.

Superposition phase: In the first step of the superpositon phase, an approximation of the transformation is estimated which is used to determine reliable landmarks in the two maps. These landmarks enable in the second step the evaluation of a more precise transformation. For both steps, different classes can be chosen. Using the PoseClusteringSuperimposerAffine, an affine transformation can be estimated and the PoseClusteringSuperimposerShift estimates a transformation consisting of only a translation in rt and m/z. Given a first approximation of the underlying warp, the SimplePairFinder or the DelaunayPairFinder can be used to determine landmarks in the two maps which represent potential corresponding elements. These landmarks are used by the MapMatcherRegression to improve the inital transformation. The following example (Tutorial_PairwiseAlignment.C) shows how to use the PoseClusteringPairwiseMapMatcher and the MapMatcherRegression for the pairwise alignment of two maps. The PoseClusteringPairwiseMapMatcher is based on the PoseClusteringSuperimposerAffine, and a DelaunayPairFinder. The initial as well as the final transformation is stored in gridXML format.

We load two feature maps and instantiate a PoseClusteringPairwiseMapMatcher object. The PoseClusteringPairwiseMapMatcher gets references to both maps and a Param object which defines the type of transformation and pairfinder. Additionally, the value of mz_bucket_size is set, which represents the maximum deviation in m/z of two corresponding elements.

Int main()
{
  FeatureMap<> exp_feature_1;
  FeatureMap<> exp_feature_2;
  
  FeatureXMLFile featurexml_file;
  featurexml_file.load("../TEST/TOPP/MapAlignmentFeatureMap1.xml",exp_feature_1);
  featurexml_file.load("../TEST/TOPP/MapAlignmentFeatureMap2.xml",exp_feature_2);
  
  Param param;
  param.setValue("superimposer:type","poseclustering_affine");
  param.setValue("superimposer:tuple_search:mz_bucket_size",0.3);
  param.setValue("pairfinder:type","DelaunayPairFinder");
  
  std::vector < ElementPair<Feature> > landmarks;
  PoseClusteringPairwiseMapMatcher< FeatureMap<> > pcpm;
  pcpm.setParameters(param);
  pcpm.setElementMap(0,exp_feature_1);    
  pcpm.setElementMap(1,exp_feature_2);
  pcpm.run();
The PoseClusteringPairwiseMapMatcher determines a vector of element pairs and an initial estimate of the transformation. We store this initial transformation under "FirstAffineTransformation.gridXML" and pass the element pairs along with the initial transformation to a MapMatcher object.
  
  GridFile grid_file;
  grid_file.store("FirstAffineTransformation.gridXML",pcpm.getGrid());
  
  MapMatcherRegression< Feature > lr;
  lr.setElementPairs(pcpm.getElementPairs());
  lr.setGrid(pcpm.getGrid());
Using these landmarks, an improved transformation is estimated and stored under "SecondAffineTransformation.gridXML"
  lr.estimateTransform();
  grid_file.store("SecondAffineTransformation.gridXML",lr.getGrid());    
   
  return 0;
} //end of main
Note:
The class MapDewarper can be used to apply the transformation to the elements of a map.

Multiple map alignment

The StarAlignment class performs a star-like progressive multiple LC-MS map alignment based upon pairwise alignments as described above. Depending on the processing state of the input maps, the output of a multiple alignment varies. Peak maps are iteratively mapped onto one reference map and the result of the multiple peak map alignment are the dewarped maps themselves. In case of multiple feature maps, corresponding elements in all maps are determined during the so called consensus phase and are combined to a ConsensusMap using DelaunayPairFinder. The StarAlignment is able to compute the alignment of multiple peak, feature, or consensus maps. It provides the warps of all maps relative to the reference map as a result for the alignment of peak maps and computes a ConsensusMap as a result of a multiple feature, or consensus map alignment. The transformations can be stored in gridXML format using the GridFile as mentioned in the example above and can be applied to the maps using the MapDewarper. The ConsensusMap can be stored in ConsensusXML using a ConsensusXMLFile.

Identification


Generated Tue Apr 1 15:36:40 2008 -- using doxygen 1.5.4 OpenMS / TOPP 1.1