Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages  

VMD (current) Compound List

Here are the classes, structs, unions and interfaces with brief descriptions:
ANARIDisplayDeviceFileRenderer subclass to exports VMD scenes to ANARI
anr_materialStructure containing material properties used to shade a Displayable
ArithmeticPathCV::ArithmeticPathBase< element_type, scalar_type, path_type >
ArtDisplayDeviceFileRenderer subclass to export VMD scenes to ART ray tracer scene format
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
atom_group\brief Group of atom objects, mostly used by a colvar::cvc object to gather all atomic data
AtomColorParse and maintain the data for how a molecule should be colored
atomparser_nodeEach node of the parse tree contains all data needed for that description
atomparser_stringStores an atom parser string with its string type enumeration
AtomRepParse and maintain the data for how a molecule should be represented
AtomRepDataInfoDefine which slots are used for a rep style, and their default values
AtomRepParamStructStructure definition for structures used to define what data each rep needs
AtomSelThis interacts with the AtomParser
atomsel_ctxtContext which must be passd to xxx_keyword_info functions in SymbolTable
AxesA Displayable object which consisting of a set of axes
BaseMoleculeBase 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)
basis_atom_tBasis set definition for one atom
ButtonsButtons 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!
CaveButtonsButtons subclass that gets its info from the CAVE wand
CaveDisplayDeviceDisplayDevice subclass that runs in the CAVE
CaveSceneScene subclass that allocates from a CAVE shared memory arena, and coordinates multiple rendering slave processes
CaveTrackerVMDTracker subclass that interfaces to the CAVE wand
CmdAddAtomSelMacroCreate a new atom selection macro
CmdAnimDeleteDelete frames
CmdAnimDirSet direction of animation
CmdAnimDupDuplicate a given frame at the end of the traj
CmdAnimJumpJump to a new frame
CmdAnimNewFrameNot really a command, but that's how info gets passed to the GUI's
CmdAnimNewNumFramesSignal that a molecule has a new number of frames
CmdAnimSkipSet frame skip value
CmdAnimSpeedSet animation speed
CmdAnimStyleSet style of animation
CmdAnimWriteFileWrite frames to a file
CmdColorChangeChange the rgb settings for a specified color
CmdColorNameChange the color index for a specifed name in a specified category
CmdColorScaleMethodChange the method used to calculate the color scale
CmdColorScaleSettingsChange the settings for the color scale
CmdDelAtomSelMacroDelete the specified atom selection macro
CmdDisplayAAOnTurn on/off antialiasing
CmdDisplayAOAmbientSet ambient occlusion ambient factor
CmdDisplayAODirectSet ambient occlusion direct lighting factor
CmdDisplayAOOnSet ambient occlusion rendering mode
CmdDisplayAxesChange the axes location
CmdDisplayBackgroundGradientOnTurn on/off background gradient
CmdDisplayCacheModeSet caching mode of display
CmdDisplayClipClipping 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
CmdDisplayClipFarChange the far clipping plane to a fixed value
CmdDisplayClipFarRelChange the far clipping plane to by a relative value
CmdDisplayClipNearChange the near clipping plane to a fixed value leaving everything else up to the base class :)
CmdDisplayClipNearRelChange the near clipping plane to by a relative value
CmdDisplayCueDensitySet the depth cueing exp/exp2 density parameter
CmdDisplayCueEndSet the depth cueing end distance
CmdDisplayCueModeSet depth cueing mode
CmdDisplayCueStartSet the depth cueing start distance
CmdDisplayCullingOnTurn on/off culling
CmdDisplayDepthcueOnTurn on/off depth cueing
CmdDisplayDoFFNumberSet depth of field f/stop number
CmdDisplayDoFFocalDistSet depth of field focal plane distance
CmdDisplayDoFOnSet depth of field rendering mode
CmdDisplayEyesepSet eye separation of display
CmdDisplayFocallenSet focal length of display
CmdDisplayFPSOnFPS indicator
CmdDisplayLightHLHighlight the Nth light
CmdDisplayLightMoveSet the position of the Nth light
CmdDisplayLightOnTurn on/off the Nth light
CmdDisplayLightRotRotate the position of the Nth light
CmdDisplayProjSet the projection to either perspective or orthographic
CmdDisplayRenderModeSet rendering mode of display
CmdDisplayScreenDistanceSet distance to screen from origin
CmdDisplayScreenHeightSet screen height value
CmdDisplayShadowOnSet shadow rendering mode
CmdDisplayStageLocationChange the stage location
CmdDisplayStagePanelsSet the number of stage panels
CmdDisplayStageSizeSet the number of stage panels
CmdDisplayStereoSet stereo mode of display
CmdDisplayStereoSwapTurn on/off stereo eye swap
CmdIMDConnectConnect to a running IMD simulation
CmdIMDCopyUnitCellSet the IMD unit cell copy mode
CmdIMDRateSet the IMD transfer rate and storage mode
CmdIMDSimChange IMD connection status (pause, detach, kill)
CmdLabelAddAdd a new label
CmdLabelAddspringAdd a new spring
CmdLabelDeleteDelete the Nth label in a category
CmdLabelShowToggle a geometry category on/off
CmdMaterialAddAdd a new material
CmdMaterialChangeChange a property of an existing material
CmdMaterialDefaultReset a material to defaults
CmdMaterialDeleteDelete a material
CmdMaterialRenameRename an existing material
CmdMenuExtensionAddAdd an item to the VMD extension menu
CmdMenuExtensionRemoveRemove an item from the VMD extension menu
CmdMenuShowTurn a menu on/off
CmdMobileModeChange the current mouse mode This command doesn't generate an output text command, it is just used to change the VMD internal state
CmdMolActiveMake the Nth molecule 'active' or 'inactive'
CmdMolAddRepAdd a new representation to the specified molecule
CmdMolBondsRecalcRe-analyze structure after atom names, bonds, etc have been modified
CmdMolCancelCancel the loading/saving of a coordinate file
CmdMolChangeRepChange the representation to the current defaults
CmdMolChangeRepItemChange 1 representation characteristic for the specified mol
CmdMolColorSet the current atom coloring method in moleculeList
CmdMolDeleteDelete the Nth molecule in the molecule List
CmdMolDeleteRepDelete a representation for the specified molecule
CmdMolDrawFramesSet the range of frames to draw for this rep
CmdMolFixMake the Nth molecule 'fixed' or 'free'
CmdMolLoadNotification that a molecule has been created
CmdMolMaterialSet the current atom material method in moleculeList
CmdMolNewCreate a new molecule
CmdMolNumPeriodicSet the number of periodic images displayed for the selected representation
CmdMolOnMake the Nth molecule 'on' or 'off'
CmdMolReanalyzeRe-analyze structure after atom names, bonds, etc have been modified
CmdMolRenameRename a molecule
CmdMolRepSet the current atom representation in moleculeList
CmdMolRepColorUpdateChange the auto-update for the color of the specified rep
CmdMolRepSelUpdateChange the auto-update for the selection of the specified rep
CmdMolScaleMinmaxSet the color scale min/max range for the selected representation
CmdMolSelectSet the current atom selection in moleculeList
CmdMolShowInstancesSet which instance images are displayed for the selected representation
CmdMolShowPeriodicSet which periodic images are displayed for the selected representation
CmdMolShowRepSet the "shown" state for the selected representation
CmdMolSmoothRepSet the trajectory smoothing window size for the selected representation
CmdMolSSRecalcRecalculate secondary structure based on current coordinates
CmdMolTopMake the Nth molecule 'top'
CmdMolVolumeAdd a new volumetric dataset to the selected molecule
CmdMouseModeChange the current mouse mode This command doesn't generate an output text command, it is just used to change the VMD internal state
CmdPluginUpdateUpdate the GUI plugin list with any newly loaded plugins
CmdRenderRender the global scene
CmdRenderOptionSet the render execution command
CmdResetViewReset the current view for the current scene
CmdRockOffStop rocking the current scene
CmdRockOnRock the current scene
CmdRotateRotate the current scene
CmdRotMatApply a matrix transformation to the current scene
CmdScaleScale the current scene
CmdSpaceballModeChange the current mouse mode This command doesn't generate an output text command, it is just used to change the VMD internal state
CmdToolAddDeviceAdd a device to a tool
CmdToolCallbackRegister a callback with a tool
CmdToolChangeChange the type of tool, keeping the sensor
CmdToolCreateCreate a new tool, attaching a sensor
CmdToolDeleteDelete a tool
CmdToolDeleteDeviceDelete a device from a tool
CmdToolOffsetChange the position offset for a tool
CmdToolRepAttach a tool to a particular representation (instead of picking)
CmdToolScaleChange the position scaling factor for a tool
CmdToolScaleForceChange the force scaling factor for a tool
CmdToolScaleSpringChange the force feedback spring constant for a tool
CmdTranslateTranslate the current scene
ColorFltkMenuVMDFltkMenu subclass providing a GUI to change color settings
ColorScaleColor gradient/ramp used by value-based coloring methods
ColorscaleImageClass to maintain a GUI-usable image of a ColorScale
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::alpha_angles\brief Colvar component: alpha helix content of a contiguous segment of 5 or more residues, implemented as a sum of Ca-Ca-Ca angles and hydrogen bonds (colvarvalue::type_scalar type, range [0:1])
colvar::angle\brief Colvar component: angle between the centers of mass of three groups (colvarvalue::type_scalar type, range [0:PI])
colvar::coordnum\brief Colvar component: coordination number between two groups (colvarvalue::type_scalar type, range [0:N1*N2])
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::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::dihedral\brief Colvar component: dihedral between the centers of mass of four groups (colvarvalue::type_scalar type, range [-PI:PI])
colvar::dipole_angle\brief Colvar component: angle between the dipole of a molecule and an axis formed by two groups of atoms(colvarvalue::type_scalar type, range [0:PI])
colvar::dipole_magnitude\brief Colvar component: dipole magnitude of a molecule
colvar::distance\brief Colvar component: distance between the centers of mass of two groups (colvarvalue::type_scalar type, range [0:*))
colvar::distance_dir\brief Colvar component: distance unit vector (direction) between centers of mass of two groups (colvarvalue::type_unit3vector type, range [-1:1]x[-1:1]x[-1:1])
colvar::distance_inv\brief Colvar component: average distance between two groups of atoms, weighted as the sixth power, as in NMR refinements(colvarvalue::type_scalar type, range (0:*))
colvar::distance_pairs\brief Colvar component: N1xN2 vector of pairwise distances (colvarvalue::type_vector type, range (0:*) for each component)
colvar::distance_xy\brief Colvar component: projection of the distance vector on a plane (colvarvalue::type_scalar type, range [0:*))
colvar::distance_z\brief Colvar component: projection of the distance vector along an axis(colvarvalue::type_scalar type, range (-*:*))
colvar::eigenvector\brief Colvar component: projection of 3N coordinates onto an eigenvector(colvarvalue::type_scalar type, range (-*:*))
colvar::groupcoordnum\brief Colvar component: coordination number between two groups (colvarvalue::type_scalar type, range [0:N1*N2])
colvar::gyration\brief Colvar component: Radius of gyration of an atom group (colvarvalue::type_scalar type, range [0:*))
colvar::h_bond\brief Colvar component: hydrogen bond, defined as the product of a colvar::coordnum and 1/2*(1-cos((180-ang)/ang_tol)) (colvarvalue::type_scalar type, range [0:1])
colvar::inertia\brief Colvar component: moment of inertia of an atom group (colvarvalue::type_scalar type, range [0:*))
colvar::inertia_z\brief Colvar component: moment of inertia of an atom group around a user-defined axis (colvarvalue::type_scalar type, range [0:*))
colvar::orientation\brief Colvar component: orientation in space of an atom group, with respect to a set of reference coordinates (colvarvalue::type_quaternion type, range [-1:1]x[-1:1]x[-1:1]x[-1:1])
colvar::orientation_angle\brief Colvar component: angle of rotation with respect to a set of reference coordinates (colvarvalue::type_scalar type, range [0:PI))
colvar::orientation_proj\brief Colvar component: cosine of the angle of rotation with respect to a set of reference coordinates (colvarvalue::type_scalar type, range [-1:1])
colvar::polar_phi\brief Colvar component: polar coordinate phi of a group (colvarvalue::type_scalar type, range [-180:180])
colvar::polar_theta\brief Colvar component: polar coordinate theta of a group (colvarvalue::type_scalar type, range [0:180])
colvar::rmsd\brief Colvar component: root mean square deviation (RMSD) of a group with respect to a set of reference coordinates; uses colvar::orientation to calculate the rotation matrix (colvarvalue::type_scalar type, range [0:*))
colvar::selfcoordnum\brief Colvar component: self-coordination number within a group (colvarvalue::type_scalar type, range [0:N*(N-1)/2])
colvar::spin_angle\brief Colvar component: angle of rotation around a predefined axis (colvarvalue::type_scalar type, range [-PI:PI])
colvar::tilt\brief Colvar component: projection of the orientation vector onto a predefined axis (colvarvalue::type_scalar type, range [-1:1])
colvar_grid< T >\brief Grid of values of a function of several collective variables
T  The data type Only scalar colvars supported so far: vector colvars are treated as arrays
colvar_grid_count\brief Colvar_grid derived class to hold counters in discrete n-dim colvar space
colvar_grid_gradientClass for accumulating the gradient of a scalar function on a grid
colvar_grid_scalarClass for accumulating a scalar function on a grid
colvarbias\brief Collective variable bias, base class
colvarbias_abfABF bias
colvarbias_histogramHistogram "bias" (does as the name says)
colvarbias_metaMetadynamics bias (implementation of colvarbias)
colvarbias_meta::hill\brief A hill for the metadynamics bias
colvarbias_restraint\brief Most general definition of a colvar restraint: see derived classes for specific types (implementation of colvarbias)
colvarbias_restraint_centersDefinition and parsing of the restraint centers
colvarbias_restraint_centers_movingOptions to change the restraint centers over time
colvarbias_restraint_harmonic\brief Harmonic bias restraint (implementation of colvarbias_restraint)
colvarbias_restraint_harmonic_walls\brief Wall restraint (implementation of colvarbias_restraint)
colvarbias_restraint_histogramRestrain the 1D histogram of a set of variables (or of a multidimensional one)
colvarbias_restraint_kDefinition and parsing of the force constant
colvarbias_restraint_k_movingOptions to change the restraint force constant over time
colvarbias_restraint_linear\brief Linear bias restraint (implementation of colvarbias_restraint)
colvarbias_restraint_movingOptions to change the restraint configuration over time (shared between centers and k moving)
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.
colvardeps::featureDescribes a feature and its dependencies used in a static array within each subclass
colvardeps::feature_stateThis contains the current state of each feature for each object
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::matrix2d< T >::row
colvarmodule::quaternion\brief 1-dimensional vector of real numbers with four components and a quaternion algebra
colvarmodule::rmatrix\brief 2-dimensional array of real numbers with three components along each dimension (works with colvarmodule::rvector)
colvarmodule::rotation\brief A rotation between two sets of coordinates (for the moment a wrapper for colvarmodule::quaternion)
colvarmodule::rvectorVector of real numbers with three components
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)
colvarparams\file colvarparams.h Functions to handle scalar parameters used in objects
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. Only pure virtual functions ("= 0") must be reimplemented to ensure baseline functionality
colvarproxy_atom_groups\brief Container of atom group data (allow collection of aggregated atomic data)
colvarproxy_atoms\brief Container of atomic data for processing by Colvars
colvarproxy_ioMethods for data input/output
colvarproxy_replicas\brief Methods for multiple-replica communication
colvarproxy_scriptMethods for scripting language interface (Tcl or Python)
colvarproxy_smp\brief Methods for SMP parallelization
colvarproxy_systemMethods for accessing the simulation system (PBCs, integrator, etc)
colvarproxy_tclMethods for using Tcl within Colvars
colvarproxy_vmd\brief Communication between colvars and VMD (implementation of colvarproxy)
colvarproxy_volmaps\brief Container of grid-based objects
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
CommandCommand 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
CommandQueueStores Commands to be run in a queue, notifies UIs when they are run
CoorDataAbstract base class for objects that periodically read/write timesteps
CoorPluginDataCoorPluginData: Uses a MolFilePlugin to load a coordinate file
ctxtXXX old-style context structure; from when we used a SymbolTable instance to loop up functions for molinfo
CUDAAccelManages enumeration and initialization of CUDA devices
DeltaCounterCounter control used to set fieldline integration delta
DepthSortObjectClass for storage and re-ordering of depth-sorted geometry as needed for PSDisplayDevice
DispCmdBeginRepGeomGroupMark 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
DispCmdColorIndexSet the current drawing color to the specified index
DispCmdCommentAdd a comment to the display list, to make token output etc. meaningful. these are free-form and can occur anywhere
DispCmdConePlot a cone at the given position
DispCmdCylinderDraw a cylinder between two endpoints
DispCmdLatticeCubeArrayDraw axis-aligned lattic cubes from the specified
DispCmdLinePlot a line at the given position
DispCmdLineArrayPlot 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
DispCmdLineTypeSet the current line type
DispCmdLineWidthSet the current line width
DispCmdLitPointArrayDraw points from the specified position, and color arrays, with given size
DispCmdPickPointIndicate a point which may be picked, and the associated 'tag'
DispCmdPickPointArrayCreate an array of indexed points which may be picked and their associated tags
DispCmdPointPlot a point at the given position
DispCmdPointArrayDraw points from the specified position, and color arrays, with given size
DispCmdPolyLineArrayPlot 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
DispCmdSphereDraw a sphere of specified radius at the given position
DispCmdSphereArrayDraw spheres from the specified position, radii, and color arrays
DispCmdSphereResSet the current sphere resolution
DispCmdSphereTypeSet the current sphere type
DispCmdSquareDraw a square, given 3 of four points
DispCmdTextDisplay 3-D text at the given text coordinates
DispCmdTriangleDraw 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
DispCmdTriMeshDraw a mesh consisting of vertices, facets, colors, normals etc
DispCmdTriStripsDraw a set of triangle strips
DispCmdVolSliceApply a 3-D texture to a slice through the current volume texture
DispCmdVolumeTextureTell 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
DispCmdWireMeshDraw a wire mesh consisting of vertices, facets, colors, normals etc
DisplayableBase class for all objects which are drawn by a DisplayDevice
DisplayColorDisplayable subclass containing the background color information
DisplayDeviceAbstract 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
DisplayFltkMenuVMDFltkMenu subclass providing a GUI for setting display options
DrawForceA Displayable subclass for drawing forces applied by IMD
DrawMoleculeSubclass of BaseMolecule and Displayable for drawing a molecule
DrawMoleculeMonitorA monitor class that acts as a proxy for things like labels that have to be notified when molecules change their state
DrawMolItemDisplayable subclass for creating geometric representations of molecules
DrawToolDisplayable used to render a tool on the screen
FeedbackA Feedback is a representation for force-feedback. Subclass this for specific haptic devices
FileChooserFltkMenuVMDFltkMenu subclass providing a GUI for loading files into VMD
FileRendererThis 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
FileRenderer::AdvancedLightStateAdvancedLight state data
FileRenderer::LightStateLight state, passed to renderer before render commands are executed
FileRenderListManage a list of FileRenderer objects that can be used to render a scene
FileSpecFile loading parameter specification, what frames, volume sets, etc to load
FltkOpenGLDisplayDeviceOpenGLRenderer subclass, displays to an FLTK window
FPSDisplayable subclass to display the current display update rate onscreen
FragmentA 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
FrameEventIndicates that the frame of a certain molecule has changed
FrameSelectorFltk dialog for selecting/deleting ranges of frames
FreeVRButtonsButtons subclass that gets its info from the FreeVR wand
FreeVRDisplayDeviceOpenGLRenderer subclass for FreeVR displays
FreeVRSceneScene subclass that allocates from a FreeVR shared memory arena, and coordinates multiple rendering slave processes
FreeVRTrackerVMDTracker subclass that interfaces to the FreeVR wand
GaussianBlur< IMAGE_T >
GelatoDisplayDeviceFileRenderer subclass to exports VMD scenes to Gelato PYG scene format
GeometricPathCV::GeometricPathBase< element_type, scalar_type, path_type >
GeometryAngleGeometryMol subclass to measure and display the angle between three atoms
GeometryAtomGeometryMol subclass to label an atom
GeometryBondGeometryMol subclass to measure and display bond lengths and distances
GeometryDihedralGeometryMol subclass to measure and display dihedral angle between 4 atoms
GeometryFltkMenuVMDFltkMenu subclass to manage geometry data, labels, and picked atoms
GeometryListDisplayable subclass to maintain geometry monitors, and draw them to a scene
GeometryMolBase class for objects that make atomic measurements in a molecule
GeometryMonitorA monitor class that watches GeometryMol objects for updates
GeometrySpringGeometryMol subclass to simulate and draw a spring between two atoms in IMD
GeomListStructStructure used to store data about each category
glxdataGLX-specific low-level handles and window IDs
GrabToolThe grab tool allows users to move molecules around
GraphicsFltkMenuVMDFltkMenu subclass implementing a GUI for controlling graphical representations of molecules
GraphicsFltkRepGUI controls for each draw style, creates rep commands for CmdMolChangeRepItem or CmdMolRep, and sets its valuators correctly given an AtomRep
GraphicsFltkRepBeads'Beads' representation controls
GraphicsFltkRepBonds'Bonds' representation controls
GraphicsFltkRepCartoon'Cartoon' representation controls
GraphicsFltkRepCPK'CPK' representation controls
GraphicsFltkRepDotted'Dotted' representation controls
GraphicsFltkRepDynamicBonds'DynamicBonds' representation controls
GraphicsFltkRepFieldLines'FieldLines' representation controls
GraphicsFltkRepHBonds'HBonds' representation controls
GraphicsFltkRepIsosurface'Isosurface' representation controls
GraphicsFltkRepLicorice'Licorice' representation controls
GraphicsFltkRepLines'Lines' representation controls
GraphicsFltkRepMSMS'MSMS' representation controls
GraphicsFltkRepNanoShaper'NanoShaper' representation controls
GraphicsFltkRepNewCartoon'NewCartoon' representation controls
GraphicsFltkRepNewRibbons'NewRibbons' representation controls
GraphicsFltkRepOrbital'Orbital' representation controls
GraphicsFltkRepOrbital::minmaxVolumetric rep internal class for managing min/max values
GraphicsFltkRepPoints'Points' representation controls
GraphicsFltkRepQuickSurf'QuickSurf' representation controls
GraphicsFltkRepRibbons'Ribbons' representation controls
GraphicsFltkRepSolvent'Solvent' representation controls
GraphicsFltkRepSurf'Surf' representation controls
GraphicsFltkRepTrace'Trace' representation controls
GraphicsFltkRepTube'Tube' representation controls
GraphicsFltkRepVDW'VDW' representation controls
GraphicsFltkRepVolumeSlice'VolumeSlice' representation controls
GraphicsFltkRepVolumetricBase 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
GraphicsFltkRepVolumetric::minmaxVolumetric rep internal class for managing min/max values
GraphLabelEventXXX These are undocumented... The user has requested the given labels to be graphed
GRIDCELLSet of 8 volume samples used for isosurface extraction
GridResCounterCounter control used to set grid spacing
GridSearchPairLinked 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
GridSearchPairlistLinked 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
group_t< IMAGE_T >
HelpEventIndicates that help is desired on the given topic
IdListCalculate 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
IMDheaderIMD communication protocol message header structure
IMDMgrHigh level interactive MD simulation management and update management
IMDSimHandle the low-level setup and teardown of interactive MD simulations
IMDSimBlockingA single-threaded implementation of the interactive MD coordinate/force update communication loop
IMDSimThreadA multithreaded implementation of the interactive MD coordinate/force communication update loop
InformTakes 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
InitializeStructureEventSet when a molecular structure is created and destroyed
integrate_potentialIntegrate (1D, 2D or 3D) gradients
InterpEventCommand subclass that acts as a base class for interpreter events
IsoContourClass implementing triangulated isocontour extraction routines
IsoSliderSlider control with text entry box, used to select isovalues, etc
IsoSurfaceClass implementing triangulated isosurface extraction routines
isosurface_cbdataIsosurface callback data structure containing multiple pointers
JoystickToolThe 3d analog of a joystick
JRegexRegular expression matching interface
JStringA 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
LibGelatoDisplayDeviceFileRenderer subclass to exports VMD scenes to Gelato PYG scene format
LibTachyonDisplayDeviceFileRenderer subclass renders via compiled-in Tachyon ray tracing engine
LINEStructure defining a triangle generated by isocontour extraction code
LinkageEdgeA Linkage Edge object consists of: - left_atom (smaller atom id), right_atom (larger atom id) - list of linkage paths which include the edge
LinkagePathA Linkage Path object consists of - a list of atoms in the path, contained in the SmallRing - the index of the start and end rings
LogfileEventGives the interpreter the text of a command being written to a logfile
MainFltkMenuVMDFltkMenu subclass implementing the main molecule browser GUI, with pulldown menus to change mouse state and bring up other menus
MaterialStructure containing material properties used to shade a Displayable
MaterialFltkMenuVMDFltkMenu subclass implementing a GUI for creating and configuring material properties
MaterialListManages a list of materials that can be applied to Displayable objects
Matrix44x4 matrix class with numerous operators, conversions, etc
MayaDisplayDeviceFileRenderer subclass to export VMD scenes to Maya ASCII format
MobileUIObject subclass for mobile/wireless phone/tablet motion control
MobileButtonsButtons subclass that gets its info from a WiFi SmartMobile
MobileDeviceCommandEventIndicates that a mobile device has a specific command to run
MobileEventSets the most recent Mobile translation, rotation, and button state
MobileStateChangedEventIndicates that the mobile device state has changed
MobileTrackerVMDTracker subclass that gets its info from the Mobile driver
MolAtomClass/struct which holds data for one atom
MolBrowserFl_Multi_Browser subclass that keeps track of the main VMD menu and a VMDApp context
MoleculeMain 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
MoleculeEventSet when a molecule is created and destroyed or modified Eventually add codes A/F/D changes, etc
MoleculeGraphicsDisplayable subclass to generate graphics directly from scripts and plugins
MoleculeListManages a list of the molecules being displayed
MolFilePluginVMD 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
MouseUIObject subclass implementing Mouse-based motion control, picking, etc
MouseModeEventTell when the mouse mode changes. I hope no one is using this..
MousePositionEventSets the most recent mouse position and button state
MSMSCoordStructure containing MSMS vertex coordinates
MSMSFaceStructure containing MSMS facet information
MSMSInterfaceManages communication with the MSMS surface generation program Can only use this class once!
myBrowserFl_Hold_Browser subclass customized to allow double-clicking for toggling graphical representations on and off
myFl_ChartA replacement for Fl_Chart, which has a bug that causes it to sometimes draw outside its bounding box
myglwindowFl_Gl_Window subclass that implements an OpenGL rendering surface for use by the FltkOpenGLDisplayDevice class
UIestimator::n_vector< T >
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
NanoShaperCoordStructure containing NanoShaper vertex coordinates
NanoShaperFaceStructure containing NanoShaper facet information
NanoShaperInterfaceManages communication with the NanoShaper surface generation program Can only use this class once!
netintStructure used to perform byte swapping operations
OpenGLCacheClass 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
OpenGLDisplayDeviceSubclass 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
OpenGLExtensionsManages the use of OpenGL extensions, provides queries, OS-specific function pointer setup, and some OpenGL state management
OpenGLPbufferDisplayDeviceSubclass 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
OpenGLRendererDisplayDevice 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
OpenGLShaderManages enumeration and initialization of OpenGL programmable shaders
OptiXDisplayDeviceFileRenderer subclass to exports VMD scenes to OptiX
OrbitalThe Orbital class, which stores orbitals, SCF energies, etc. for a single timestep
orbital_cbdataOrbital callback data structure containing multiple pointers
ort_materialStructure containing material properties used to shade a Displayable
osp_materialStructure containing material properties used to shade a Displayable
OSPRay2DisplayDeviceFileRenderer subclass to exports VMD scenes to OSPRay
OSPRayDisplayDeviceFileRenderer subclass to exports VMD scenes to OSPRay
ParseTreeAn atom selection expression parse tree
PBCControlsFl_Group subclass implementing controls for displaying periodic images for a graphical representation
PhoneButtonsButtons subclass that gets its info from a WiFi SmartPhone
PhoneTrackerVMDTracker subclass that gets its info from the Phone driver
PickableContains data which may be selected with a pointer in a DisplayDevice
PickAtomCallbackEventSets the molid, atomid, and client of the last callback-picked atom
PickAtomEventSets the molid and atomid of the last picked atom
PickEventCommand subclass for picking events, used to notify the GUI of updates
PickGraphicsEventSets the molid, tag, and button of the last picked user graphics
PickListMaintains a list of Pickable objects, find and deal with items picked by a pointer device
PickModePick mode management class
PickModeAddBondPickMode subclass to add bonds between two atoms
PickModeAnglesPickMode subclass for angle labels
PickModeAtomsPickMode subclass for labeling atoms
PickModeBondsPickMode subclass for bond/distance labels
PickModeCenterPickMode subclass to define the molecule's centering/global translation
PickModeDihedralsPickMode subclass for dihedral labels
PickModeForcePickMode subclass for applying forces to atoms
PickModeForceAtomPickMode subclass to apply a force to a single atom
PickModeForceFragmentPickMode subclass to apply a force to a single fragment
PickModeForceResiduePickMode subclass to apply a force to a single residue
PickModeListList of all available PickMode subclasses
PickModeMolLabelPickMode subclass to add labels to atoms
PickModeMovePickMode subclass for moving atoms (no forces applied)
PickModeMoveAtomPickMode subclass for moving atoms (no forces applied)
PickModeMoveFragmentPickMode subclass for moving fragments (no forces applied)
PickModeMoveMoleculePickMode subclass for moving whole molecules (no forces applied)
PickModeMoveRepPickMode subclass for moving a selected rep's atoms (no forces applied)
PickModeMoveResiduePickMode subclass for moving residues (no forces applied)
PickModeUserPickMode subclass to add bonds between two atoms
PickSelectionEventList the atoms involved in the last geometry object created
PickValueEventSets the value of the last created Geometry
PinchToolTool subclass implementing a function similar to TugTool except that the force is only applied in the direction the tool is oriented
PlainTextInterpTextInterp subclass implementing a last resort text interpreter if no other is available
PluginMgrScans 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
POV3DisplayDeviceFileRenderer subclass exports scenes to POV-Ray 3.x ray tracer scene format
prim_tA Gaussian primitive
PrintToolThe print tool allows users to print tracker values on the fly
PSDisplayDeviceFileRenderer subclass exports VMD scenes to PostScript files
PythonEvalEventThis command allows us to evaluate an arbitrary string in the Python interpreter
PythonTextInterpTextInterp subclass implementing the Python-based text command interpreter
QMDataQM data management class. Concerns QM related data that are not timestep dependent
QMTimestepTimesteps store coordinates, energies, etc. for one trajectory timestep
QuatQuaternion class
quicksurf_cbdataQuickSurf callback data structure containing multiple pointers
R3dDisplayDeviceFileRenderer subclass exports VMD scene to a file in Raster3D format
RadianceDisplayDeviceFileRenderer subclass to export VMD scenes to a Radiance scene file
RadiusCounterCounter control used to set radii
RayShadeDisplayDeviceFileRenderer subclass to exports VMD scenes to Rayshade scene format
RenderFltkMenuVMDFltkMenu subclass implementing a GUI for exporting and rendering VMD scenes via the FileRenderer classes in FileRenderList
RenderManDisplayDeviceFileRenderer subclass to exports VMD scenes to Renderman RIB scene format
RepChoiceChooser control used to select from a list of representation settings
RepChoiceSmallNarrow chooser control used to select from a list of representation settings
ResidueBased 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
ResolutionCounterCounter control used to set tessellation resolution
RotateToolTool 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
SaveTrajectoryFltkMenuVMDFltkMenu subclass implementing a GUI for saving trajectory and coordinate frames to files
ScaleSpaceFilter< GROUP_T, IMAGE_T >
SceneContains lists of Displayable objects and draws them to a DisplayDevice
SegmentationTop-level class that given an image will segement the image using watershed and then postprocess the segmentation using a space scale filter algorithm
SelectionBuilderFl_Group subclass implementing a set of controls for browsing atom data fields, editing atom selection macros, and GUI-based atom selection construction
SensorConfigProvides a Sensor with configuration information by parsing one or more configuration files
shell_tA Shell (Gaussian type orbital)
ShortSliderShorter slider control for use with longer labels
SmallRingA 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
SmallRingLinkagesA SmallRingLinkages object contains a list of edges which lie on paths connecting (orientated) SmallRings
SnapshotDisplayDeviceFileRenderer subclass to save VMD images in a supported image file format
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
SpaceballUIObject subclass for Spaceball-based motion control
SpaceballButtonsButtons subclass that gets its info from the local Spaceball
SpaceballEventSets the most recent Spaceball translation, rotation, and button state
SpaceballTrackerVMDTracker subclass that gets its info from the Spaceball driver
SpringToolA tool for connecting atoms with springs
SQUARECELLSet 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
StageDisplayable subclass implementing a checkered "stage"
state_t< GROUP_T, IMAGE_T >
StepCounterCounter control used to set volume extraction step size
STLDisplayDeviceFileRenderer subclass to export VMD scenes to STL solid model format
SurfInterface to the SURF solvent accessible surface package
symbol_dataSimplifies the use of three basic data types in an array situation. It does the conversion as needed and can be told to change size
SymbolTableTracks names and functions needed to parse a selection for the given class
SymbolTableElementKeeps track of the template-dependent mapping from index to member function
TachyonDisplayDeviceFileRenderer subclass to export VMD scenes to the Tachyon scene format
TclEvalEventEvaluate the given string in the Tcl interpreter
TclTextInterpTextInterp subclass implementing the Tcl-based text command interpreter
TextInterpBase class for all text interpreters
TimestepTimesteps store coordinates, energies, etc. for one trajectory timestep
TimestepEventIndicates that a new timestep has been received over a remote connection
ToolA 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
ToolFltkMenuVMDFltkMenu subclass that implements a GUI for configuring Tool, Sensor, Button, Feedback, and VMDTracker objects
TrajectoryReadEventIndicates when all the frames of a trajectory have been read
TRIANGLEStructure defining a triangle generated by isosurface extraction code
TugToolA tool for interacting with MD simulations
UIObjectUser 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
UITextUIObject class providing text based user interfaces for scripting etc
UIVRUIObject 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
UserKeyEventEvaluate the given hotkey combination
VMDAppThe main VMD application instance, created by the main entry point
VMDClipPlaneData structure describing user specified clipping planes
VMDDIRUnix directory traversal handle
VMDDisplayListDisplay list data structure used to hold all of the rendering commands VMD generates and interprets in order to do its 3-D rendering
VMDFltkMenuVMDMenu and FL_Window subclass for managing all FLTK-based menus in VMD
VMDMenuBase class for all GUI menus in VMD
VMDTitleDisplayable subclass for a flashy title object displayed when VMD starts up, until a molecule is loaded
VMDTkinterMenuVMDMenu subclass to manage Tkinter extension menus added by the user
VMDTkMenuVMDMenu subclass to manage Tk extension menus added by the user
VMDTrackerAn 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
vmdwinjoystickStore low-level Win32 joystick status and config info
VolMapCreateVirtual 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
VolMapCreateILSImplicit Ligand Sampling (ILS) algorithm. It finds the energy of placing a monoatomic or diatomic ligand at many points in the protein
VolumetricDataVolumetric data class for potential maps, electron density maps, etc
VRJugglerButtonsButtons subclass that gets its info from the VRJuggler wand
VRJugglerDisplayDeviceDisplayDevice subclass that runs in the VRJuggler
VRJugglerTrackerVMDTracker subclass that interfaces to the VRJuggler wand
Vrml2DisplayDeviceFileRenderer subclass to export VMD scenes to VRML2/VRML97 scene format
VrmlDisplayDeviceFileRenderer subclass to export VMD scenes to VRML 1.0 scene format
VRPNButtonsButtons subclass that gets its info over the net from VRPN
VRPNFeedbackFeedback subclass for sending haptic forces to VRPN over the net
VRPNTrackerVMDTracker subclass the manage VRPN tracker devices
VRPNTrackerUserDataVRPN tracker position and orientation data
Watershed< GROUP_T, IMAGE_T >Class that performs watershed segmentation and filtering
watershed_gpu_state_t< GROUP_T, IMAGE_T >
WavefrontDisplayDeviceFileRenderer subclass to export VMD scenes to Wavefront "OBJ" format
Win32JoystickUIObject subclass to allow joystick-based motion control on MS-Windows
X3DDisplayDeviceFileRenderer subclass to export VMD scenes to X3D scene format
XYStructure containing xy values for line vertices
XYZStructure containing xyz values for triangle vertices and normals

Generated on Wed Nov 11 02:43:58 2020 for VMD (current) by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002