VMD (current) Compound List
Here are the classes, structs, unions and interfaces with brief descriptions:
atom \brief Stores numeric id, mass and all mutable data for an
atom, mostly used by a
colvar::cvc This class may be used to keep atomic data such as id, mass, position and collective variable derivatives) altogether. There may be multiple instances with identical numeric id, all acting independently: forces communicated through these instances will be summed together
AtomColor Parse and maintain the data for how a molecule should be colored
atomparser_node Each node of the parse tree contains all data needed for that description
AtomRep Parse and maintain the data for how a molecule should be represented
AtomRepDataInfo Define which slots are used for a rep style, and their default values
AtomRepParamStruct Structure definition for structures used to define what data each rep needs
AtomSel This interacts with the AtomParser
BaseMolecule Base class for all molecules, without display-specific information. This portion of a molecule contains the structural data, and all routines to find the structure (backbone, residues, etc). It does NOT contain the animation list; that is maintained by
Molecule (which is derived from this class)
Buttons Buttons is a representation for a set of n boolean inputs. This fairly abstract class should be subclassed to make Buttons objects that actually know how to get their buttons. This is somewhat parallel to the Tracker object, compare them!
CaveScene Scene subclass that allocates from a CAVE shared memory arena, and coordinates multiple rendering slave processes
CmdAnimDup Duplicate a given frame at the end of the traj
CmdAnimNewFrame Not really a command, but that's how info gets passed to the GUI's
CmdColorName Change the color index for a specifed name in a specified category
CmdDisplayClip Clipping
plane controls This handles the whole range of clipping
plane options There are derived classes so you won't have to have the funky flags to change {near,fixed} clipping
plane {to a fixed,by a relative} amount or not
CmdDisplayProj Set the projection to either perspective or orthographic
CmdIMDRate Set the IMD transfer rate and storage mode
CmdIMDSim Change IMD connection status (pause, detach, kill)
CmdMobileMode Change the current mouse mode This command doesn't generate an output text command, it is just used to change the VMD internal state
CmdMolAddRep Add a new representation to the specified molecule
CmdMolBondsRecalc Re-analyze structure after atom names, bonds, etc have been modified
CmdMolColor Set the current atom coloring method in moleculeList
CmdMolFix Make the Nth molecule 'fixed' or 'free'
CmdMolLoad Notification that a molecule has been created
CmdMolNumPeriodic Set the number of periodic images displayed for the selected representation
CmdMolOn Make the Nth molecule 'on' or 'off'
CmdMolReanalyze Re-analyze structure after atom names, bonds, etc have been modified
CmdMolRep Set the current atom representation in moleculeList
CmdMolShowPeriodic Set which periodic images are displayed for the selected representation
CmdMolShowRep Set the "shown" state for the selected representation
CmdMolSmoothRep Set the trajectory smoothing window size for the selected representation
CmdMolSSRecalc Recalculate secondary structure based on current coordinates
CmdMolVolume Add a new volumetric dataset to the selected molecule
CmdMouseMode Change the current mouse mode This command doesn't generate an output text command, it is just used to change the VMD internal state
CmdRotMat Apply a matrix transformation to the current scene
CmdSpaceballMode Change the current mouse mode This command doesn't generate an output text command, it is just used to change the VMD internal state
CmdToolRep Attach a tool to a particular representation (instead of picking)
ColorScale Color gradient/ramp used by value-based coloring methods
colvar \brief A collective variable (main class); to be defined, it needs at least one object of a derived class of
colvar::cvc; it calculates and returns a
colvarvalue object This class parses the configuration, defines the behaviour and stores the value (
colvar::x) and all related data of a collective variable. How the value is calculated is defined in
colvar::cvc and its derived classes. The colvar object contains pointers to multiple
colvar::cvc derived objects, which can be combined together into one collective variable. This makes possible to implement new collective variables at runtime based on the existing ones. Currently, this possibility is limited to a polynomial, using the coefficients
cvc::sup_coeff and the exponents
cvc::sup_np. In case of non-scalar variables, only exponents equal to 1 are accepted. Please note that most of its members are
colvarvalue objects, i.e. they can handle different data types together, and must all be set to the same type of
colvar::value() before using them together in assignments or other operations; this is usually done automatically in the constructor. If you add a new member of
colvarvalue type, you should also add its initialization line in the colvar constructor
colvar::cvc \brief Colvar component (base class for collective variables) A colvar::cvc object (or an object of a
cvc-derived class) implements the calculation of a collective variable, its gradients and any other related physical quantities that depend on microscopic degrees of freedom. No restriction is set to what kind of calculation a colvar::cvc object performs (usually an analytical function of atomic coordinates). The only constraints are that:
-
- The value is calculated by the \link calc_value() \endlink method, and is an object of \link colvarvalue \endlink class. This provides a transparent way to treat scalar and non-scalar variables alike, and allows an automatic selection of the applicable algorithms. - The object provides an implementation \link apply_force() \endlink to apply forces to atoms. Typically, one or more \link colvarmodule::atom_group \endlink objects are used, but this is not a requirement for as long as the \link colvar::cvc \endlink object communicates with the simulation program. <b> If you wish to implement a new collective variable component, you should write your own class by inheriting directly from \link colvar::cvc \endlink, or one of its derived classes (for instance, \link colvar::distance \endlink is frequently used, because it provides useful data and function members for any colvar based on two atom groups).</b> The steps are: \par 1. Declare the new class as a derivative of \link colvar::cvc \endlink in the file \link colvarcomp.h \endlink 2. Implement the new class in a file named colvarcomp_<something>.cpp 3. Declare the name of the new class inside the \link colvar \endlink class in \link colvar.h \endlink (see "list of available components") 4. Add a call for the new class in colvar::init_components()/ (file:
-
colvar.cpp)
colvar::dihedPC \brief Colvar component:
dihedPC Projection of the config onto a
dihedral principal component See e.g. Altis et al., J. Chem. Phys 126, 244111 (2007) Based on a set of '
dihedral' cvcs
colvar_grid< T > \brief Grid of values of a function of several collective variables
-
Parameters:
-
T
The data type Only scalar colvars supported so far: vector colvars are treated as arrays
colvarbias \brief Collective variable bias, base class
colvarbias_ti \brief Base class for unconstrained thermodynamic-integration FE estimator
colvardeps \brief Parent class for a member object of a bias, cv or cvc etc. containing features and their dependencies, and handling dependency resolution There are 3 kinds of features: 1. Dynamic features are under the control of the dependency resolution system. They may be enabled or disabled depending on dependencies. 2. User features may be enabled based on user input (they may trigger a failure upon dependency resolution, though) 3. Static features are static properties of the object, determined programmatically at initialization time. The following diagram summarizes the dependency tree at the bias,
colvar, and colvarcomp levels. Isolated and atom group features are not shown to save space.
colvarmodule \brief Collective variables module (main class) Class to control the collective variables calculation. An object (usually one) of this class is spawned from the MD program, containing all i/o routines and general interface. At initialization, the colvarmodule object creates a proxy object to provide a transparent interface between the MD program and the child objects
colvarmodule::matrix2d< T > \brief Arbitrary size array (two dimensions) suitable for linear algebra operations (i.e. for floating point numbers it can be used with library functions)
colvarmodule::vector1d< T > \brief Arbitrary size array (one dimensions) suitable for linear algebra operations (i.e. for floating point numbers it can be used with library functions)
colvarparse \file
colvarparse.h Parsing functions for collective variables \brief Base class containing parsing functions; all objects which need to parse input inherit from this
colvarparse::read_block \brief Helper class to read a block of the type "key { ... }" from a stream and store it in a string Useful on restarts, where the file is too big to be loaded in a string by key_lookup; it can only check that the keyword is correct and the block is properly delimited by braces, not skipping other blocks
colvarproxy \brief Interface between the collective variables module and the simulation or analysis program (NAMD, VMD, LAMMPS...). This is the base class: each interfaced program is supported by a derived class
colvarvalue \brief Value of a collective variable: this is a metatype which can be set at runtime. By default it is set to be a scalar number, and can be treated as such in all operations (this is done by most
colvar::cvc implementations). colvarvalue allows
colvar to be treat different data types. By default, a colvarvalue variable is a scalar number. To use it as another type, declare and initialize it as `colvarvalue x(colvarvalue::type_xxx)`, use `x.type (colvarvalue::type_xxx)` at a later stage, or if unset, assign the type with `x = y;`, provided y is correctly set. All operators (either unary or binary) on a colvarvalue object performs one or more checks on the Type, except when reading from a stream, when there is no way to detect the Type. To use `is >> x;` x
MUST already have a type correcly set up for properly parsing the stream. No problem of course with the output streams: `os << x;`
Note on performance: to avoid type checks in a long array of colvarvalue objects, use one of the existing "_opt" functions or implement a new one
Command Command base class from which all other commands are derived Derived classes must provide a unique constructor, destructor, and optionally provide a 'create_text' routine if the command has a text equivalent which should be echoed to a log file
CommandQueue Stores Commands to be run in a queue, notifies UIs when they are run
CoorData Abstract base class for objects that periodically read/write timesteps
ctxt XXX old-style context structure; from when we used a
SymbolTable instance to loop up functions for molinfo
CUDAAccel Manages enumeration and initialization of CUDA devices
DeltaCounter Counter control used to set fieldline integration delta
DispCmdBeginRepGeomGroup Mark the beginning of a new representation This should only be called once per rep, or weird things can happen when exporting to external renderers, where we track unique rep group IDs, names, etc. Group names cannot contain spaces, but can allow underscores and all normal alphanumeric characters
DispCmdComment Add a comment to the display list, to make token output etc. meaningful. these are free-form and can occur anywhere
DispCmdLineArray Plot a series of lines, all with the same color the array should be of the form v1 v2 v1 v2 ... Note that the data is not stored in the struct; we copy directly into the display list. That way you don't have to keep this struct around after calling putdata. Kinda like DispCmdDataBlock
DispCmdPointArray Draw points from the specified position, and color arrays, with given size
DispCmdPolyLineArray Plot a series of connected polylines, all with the same color the array should be of the form v1 v2 v3 v4 ... Note that the data is not stored in the struct; we copy directly into the display list. That way you don't have to keep this struct around after calling putdata. Kinda like DispCmdDataBlock
DispCmdSphere Draw a sphere of specified radius at the given position
DispCmdText Display 3-D text at the given text coordinates
DispCmdTriangle Draw a triangle, given the three points (computes the normals from the cross product) and all normals are the same -or- draw the triangle, given the three points and the three normals
DispCmdTriMesh Draw a mesh consisting of vertices, facets, colors, normals etc
DispCmdVolSlice Apply a 3-D texture to a slice through the current volume texture
DispCmdVolumeTexture Tell OpenGL to cache a 3D texture with the given unique ID. Memory for the texture is retained by the caller, not copied into the display list
DispCmdWireMesh Draw a wire mesh consisting of vertices, facets, colors, normals etc
DisplayDevice Abstract base class for objects which can process a list of drawing commands and render the drawing to some device (screen, file, preprocessing script, etc.), and provide mouse and keyboard events
DrawMoleculeMonitor A monitor class that acts as a proxy for things like labels that have to be notified when molecules change their state
Feedback A Feedback is a representation for force-feedback. Subclass this for specific haptic devices
FileRenderer This is the base class for all the renderers that go to a file and are on the render list. There are five operations available to the outside world
FileSpec File loading parameter specification, what frames, volume sets, etc to load
FPS Displayable subclass to display the current display update rate onscreen
Fragment A Fragment contains a list of residues which are connected each other, and to no one else. This is at the residue level, and not the atom level. The residue numbers are the unique_resid as assigned in
BaseMolecule
FrameEvent Indicates that the frame of a certain molecule has changed
FrameSelector Fltk dialog for selecting/deleting ranges of frames
FreeVRScene Scene subclass that allocates from a FreeVR shared memory arena, and coordinates multiple rendering slave processes
GeometryMol Base class for objects that make atomic measurements in a molecule
glxdata GLX-specific low-level handles and window IDs
GrabTool The grab tool allows users to move molecules around
GraphicsFltkRepVolumetric Base class for reps that use volumetric data XXX We can't get the information we need from
AtomRep to fill in the data set names or their min/max ranges. Thus we have to add methods for
GraphicsFltkMenu to tell us what this information is
GraphLabelEvent XXX These are undocumented... The user has requested the given labels to be graphed
GRIDCELL Set of 8 volume samples used for isosurface extraction
GridSearchPair Linked list of atom index pairs generated by the vmd_gridsearch1 and vmd_gridsearch2 XXX on 64-bit machines the next pointers are as large as the atom index data in each node, so half of the memory is wasted in pointer chasing. Calling malloc/free once per pair when building the linked list is a severe multithreading scalability bottleneck due to OS-level mutex locks in malloc/free and/or the kernel VM. On Linux, it is also problematic due to the threaded version of malloc allocating huge blocks and fragmenting memory tremendously. This implementation should not be used for any threaded code
GridSearchPairlist Linked list of ResizeArrays containing pairlists, optimized for multithreading. Compared with the
GridSearchPair linked list, The list of ResizeArrays uses half as much memory per pair, reduces the malloc calls so they are logarithmic rather than linear with the number of bonds, and reduces free call count to one per-thread down from one per-
bond. Since the
ResizeArray results in a contiguous block of memory, the traversal coherency is also significantly improved. Ultimately we should convert all of the grid search routines to use this type of data structure, or one like it
HelpEvent Indicates that help is desired on the given topic
IdList Calculate which molecules to operate upon from the given molecule name; put the data in idList, and return the pointer to the integer list. If NULL is returned, there was an error or no molecules were specified. If an error occurs, this prints out the error message as well.
Molecule names are of the form n1[|n2[.... [|nN]...]] where ni is either "all", "top", "active", "inactive", "displayed", "on", "off", "fixed", "free", "none", or an ID. There should be no spaces in the name
IMDheader IMD communication protocol message header structure
IMDMgr High level interactive MD simulation management and update management
IMDSim Handle the low-level setup and teardown of interactive MD simulations
IMDSimBlocking A single-threaded implementation of the interactive MD coordinate/force update communication loop
IMDSimThread A multithreaded implementation of the interactive MD coordinate/force communication update loop
Inform Takes messages and displays them to the given ostream. Also creates 3 global instances: msgInfo, msgWarn, msgErr. A message is sent to an Inform object by treating it as an ostream, then ending the message by sending the 'sendmsg' manipulator
IsoContour Class implementing triangulated isocontour extraction routines
IsoSlider Slider control with text entry box, used to select isovalues, etc
IsoSurface Class implementing triangulated isosurface extraction routines
JRegex Regular expression matching interface
JString A minimalistic string class we use instead of similar classes from the STL or the GNU libraries for better portability and greatly reduced code size. (only implements the functionality we actually need, doesn't balloon the entire VMD binary as some past string class implementations did). Implements regular expression matching methods used by VMD
LINE Structure defining a triangle generated by isocontour extraction code
LinkageEdge A Linkage Edge object consists of: - left_atom (smaller atom id), right_atom (larger atom id) - list of linkage paths which include the edge
LinkagePath A Linkage Path object consists of - a list of atoms in the path, contained in the
SmallRing - the index of the start and end rings
LogfileEvent Gives the interpreter the text of a command being written to a logfile
MainFltkMenu VMDFltkMenu subclass implementing the main molecule browser GUI, with pulldown menus to change mouse state and bring up other menus
Matrix4 4x4 matrix class with numerous operators, conversions, etc
Mobile UIObject subclass for mobile/wireless phone/tablet motion control
MolAtom Class/struct which holds data for one atom
MolBrowser Fl_Multi_Browser subclass that keeps track of the main VMD menu and a
VMDApp context
Molecule Main Molecule objects, which contains all the capabilities necessary to store, draw, and manipulate a molecule. This adds to the functions of
DrawMolecule and
BaseMolecule by adding file I/O interfaces etc
MoleculeEvent Set when a molecule is created and destroyed or modified Eventually add codes A/F/D changes, etc
MoleculeList Manages a list of the molecules being displayed
MolFilePlugin VMD interface to 'molfile' plugins. Molfile plugins read coordinate files, structure files, volumetric data, and graphics data. The data is loaded into a new or potentially preexisting molecule in VMD
Mouse UIObject subclass implementing Mouse-based motion control, picking, etc
MouseModeEvent Tell when the mouse mode changes. I hope no one is using this..
MSMSCoord Structure containing MSMS vertex coordinates
MSMSFace Structure containing MSMS facet information
MSMSInterface Manages communication with the MSMS surface generation program Can only use this class once!
myBrowser Fl_Hold_Browser subclass customized to allow double-clicking for toggling graphical representations on and off
myFl_Chart A replacement for Fl_Chart, which has a bug that causes it to sometimes draw outside its bounding box
NameList< T > Template class, stores a list of unique names indexed in the order they are added. For each name, which acts as a key, there is an associated integer value. NameList string lookups are accelerated through the use of an internal hash table
NanoShaperInterface Manages communication with the NanoShaper surface generation program Can only use this class once!
netint Structure used to perform byte swapping operations
OpenGLCache Class to manage caching of OpenGL-related resources and handles such as display lists, textures, vertex buffer objects, etc. The IDs being stored are sparse unsigned long integer keys
OpenGLDisplayDevice Subclass of
OpenGLRenderer, this object has routines used by all the different display devices that are OpenGL-specific. Will render drawing commands into a single X window
OpenGLExtensions Manages the use of OpenGL extensions, provides queries, OS-specific function pointer setup, and some OpenGL state management
OpenGLRenderer DisplayDevice subclass implementing the low-level OpenGL rendering functions used by several derived
DisplayDevice subclasses. This class renders drawing commands into a window provided by one of the further subclasses
OpenGLShader Manages enumeration and initialization of OpenGL programmable shaders
Orbital The Orbital class, which stores orbitals, SCF energies, etc. for a single timestep
ParseTree An atom selection expression parse tree
PBCControls Fl_Group subclass implementing controls for displaying periodic images for a graphical representation
PickEvent Command subclass for picking events, used to notify the GUI of updates
PickList Maintains a list of
Pickable objects, find and deal with items picked by a pointer device
PinchTool Tool subclass implementing a function similar to
TugTool except that the force is only applied in the direction the tool is oriented
PluginMgr Scans a specified set of directories looking for shared libraries that implement the vmdplugin interface. Stores a copy of the plugins it finds so that they can be passed to routines that know the specific interface for the plugin
PrintTool The print tool allows users to print tracker values on the fly
PythonEvalEvent This command allows us to evaluate an arbitrary string in the Python interpreter
QMData QM data management class. Concerns QM related data that are not timestep dependent
QMTimestep Timesteps store coordinates, energies, etc. for one trajectory timestep
RepChoice Chooser control used to select from a list of representation settings
RepChoiceSmall Narrow chooser control used to select from a list of representation settings
Residue Based on the uniq_resid assigned in
BaseMolecule, a residue knows what other residues it is connected to, and maintains a list of the atoms it contains
ResizeArray< T > A template class which implements a dynamically-growing, automatically resizing array of data of a given type. Elements in the array may be accessed via the [] operator. When new data is added to the end of an array, the size of the array is automatically increased if necessary. XXX Do not parametrize this class with a datatype which cannot be shallow-copied! This class uses memcpy to resize, and therefore classes which contain dynamically-allocated memory blocks will crash and burn if the ResizeArray ever gets resized
RotateTool Tool subclass implementing a rotational orientation control with haptic feedback which constrains the position of the pointer to the surface of a sphere while it is being manipulated
Segmentation Top-level class that given an image will segement the image using watershed and then postprocess the segmentation using a space scale filter algorithm
SelectionBuilder Fl_Group subclass implementing a set of controls for browsing atom data fields, editing atom selection macros, and GUI-based atom selection construction
SensorConfig Provides a Sensor with configuration information by parsing one or more configuration files
shell_t A Shell (Gaussian type orbital)
ShortSlider Shorter slider control for use with longer labels
SmallRing A SmallRing contains a list of atoms which are connected to each other to form a loop. The atom numbers are the unique atom numbers as used in
BaseMolecule. The ordering of the atoms, in addition to specifying how the atoms in the ring are connected, also gives the orientation (handedness) of the ring if orientated is non-zero
SmallRingLinkages A SmallRingLinkages object contains a list of edges which lie on paths connecting (orientated) SmallRings
SortableArray< T > A sort-capable variant of the
ResizeArray template class. In addition to the methods provided there, this template also allows either quicksorting or insertion sorting of the elements in the array
SpringTool A tool for connecting atoms with springs
SQUARECELL Set of 4 grid samples used for isocontour extraction
Stack< T > A template class which implements a simple stack of arbitrary data. Items are pushed onto and popped off of the stack, or may just be copied from the stack
StepCounter Counter control used to set volume extraction step size
Surf Interface to the SURF solvent accessible surface package
symbol_data Simplifies the use of three basic data types in an array situation. It does the conversion as needed and can be told to change size
SymbolTable Tracks names and functions needed to parse a selection for the given class
SymbolTableElement Keeps track of the template-dependent mapping from index to member function
TclEvalEvent Evaluate the given string in the Tcl interpreter
Timestep Timesteps store coordinates, energies, etc. for one trajectory timestep
TimestepEvent Indicates that a new timestep has been received over a remote connection
Tool A Tool represents a virtual device used to manipulate objects on the screen. Tools use input from
VMDTracker,
Feedback, and Button devices and draw a pointer on the screen. Tools can give up their devices to another tool to effectively allow a tool to change its type on the fly
TRIANGLE Structure defining a triangle generated by isosurface extraction code
TugTool A tool for interacting with MD simulations
UIObject User Interface Object base class. All user interface modules are derived from this; it provides methods for registering with the command processor and 'signing up' for which commands it is interested in, as well as generating commands and events
UIText UIObject class providing text based user interfaces for scripting etc
UIVR UIObject subclass implementing a Virtual Reality user interface. I coordinates multiple tools, taking manipulation commands from them and giving them back various messages and flags. UIVR is the thing which has to know about the different kinds of tools
VMDApp The main VMD application instance, created by the main entry point
VMDClipPlane Data structure describing user specified clipping planes
VMDDIR Unix directory traversal handle
VMDDisplayList Display list data structure used to hold all of the rendering commands VMD generates and interprets in order to do its 3-D rendering
VMDMenu Base class for all GUI menus in VMD
VMDTitle Displayable subclass for a flashy title object displayed when VMD starts up, until a molecule is loaded
VMDTracker An object representing a connection to a machine that controls 3d input devices (optionally with buttons, force-feedback, etc). One connection may control one or many devices, so there needs to be a global list of trackers which the Sensors peruse when first being initialized. This class is named VMDTracker to avoid name conflicts with the UNC tracker library
VolMapCreate Virtual class for dealing with the computation of VolMaps, based on atomic selections and atomic data and coordinates. It provides utilities for computing such maps. Various algorithms and specific calculations are done by child classes. The end result is a VolMap object, which can be passed to VMD (N/A yet) or written to a file
VolMapCreateILS Implicit Ligand Sampling (ILS) algorithm. It finds the energy of placing a monoatomic or diatomic ligand at many points in the protein
VolumetricData Volumetric data class for potential maps, electron density maps, etc
XY Structure containing xy values for line vertices
XYZ Structure containing xyz values for triangle vertices and normals
Generated on Sun Nov 16 02:46:34 2025 for VMD (current) by
doxygen1.2.14 written by Dimitri van Heesch,
© 1997-2002