Analysis modules

    Table of contents
    No headers

    Modules used for analysis


    • Name: Selection (src/gromacs/selection/)
      * Responsibility:
      Provides functionality for parsing and evaluating selections.
      * Dependencies:
      Uses error handling modules to report errors during selection processing.
      Uses the options module to provide a custom selection option type that
      provides values directly as selections.
      * Provided interfaces:
      1) Functionality for parsing and evaluating selections.
      2) A wrapper around the first interface using the options module for
      easy use in the trajectory analysis module.
      * Future:
      Currently most implementation is from the C code in 4.5.  Some minor
      features that used to work there have not yet been implemented.
      In the long run, it would be good to use the options module also
      within the selection implementation (the design should allow for
      that), and use some C++ within the selection parser/evaluator
      (currently, there are poor-man's virtual tables implemented as arrays
      of function pointers...) (Redmine issue #652).
    • Name: Analysis Data (src/gromacs/analysisdata/)
      * Responsibilities:
      Provides functionality for transparently processing data in parallel
      analysis tools.  The tools can simply attach post-processing modules
      (e.g., writing the data into an xvg file) to a data object, and then
      add data to that object concurrently.  The data object takes care of
      ordering the data such that it gets post-processed in the correct
      * Dependencies:
      The plot functionality uses some functionality from the selection and
      options modules to get some global settings and to write selections
      into the output files.
      * Provided interfaces:
      1) Data objects and processing modules to transparently handle output
      of data from (possibly parallel) analysis tools.
      2) Interface for implementing new processing modules that can be
      attached to data objects.
      * Future:
      Thread- and/or MPI-parallel data processing should be implemented.
      More data processing modules should be implemented as required by
      trajectory analysis tools.
      Currently supports only data of type "real"; in cases it would be
      useful to explicitly support either int or double as well.
    • Name: Trajectory Analysis (src/gromacs/trajectoryanalysis/)
      * Responsibilities:
      Provides a framework that implements tasks that are common to (nearly)
      all trajectory analysis tools.  Provides a base class that provides a
      set of virtual functions that can be overridden to implement an actual
      analysis tool.
      * Dependencies:
      Uses selection module for processing selections.
      Uses options module to define options common to all analysis tools
      (e.g., trajectory input options) and to assign values from
      command-line options to both common and analysis module specific
      Concrete analysis modules under
      src/gromacs/trajectoryanalysis/modules/ use data structures from the
      analysis data module.  Currently these two frameworks have no direct
      dependence, but this may change for parallel tools (but not
      * Provided interfaces:
      1) Base class for implementing trajectory analysis modules/tools (also
      implements a set of concrete modules under
      2) Command-line runner that can be used to run an analysis module
      implementing the first interface as a command-line tool.
      * Future:
      Thread- and/or MPI-parallel runner should be implemented. Do we want to implement a small communication library for this to send around static data uses mpi or threads? With threads one could send pointers instead of copying the static data. Such a module could be used in more places.
      More concrete modules/tools should be implemented.
    • Analysis algorithms
      • The actual algorithms for the analysis of trajectory data.
    Page last modified 14:16, 11 May 2011 by hess