\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

AtomColor

Parse and maintain the data for how a molecule should be colored

Each node of the parse tree contains all data needed for that description

atomparser_string

Stores an atom parser string with its string type enumeration

AtomPosType

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

atomsel_ctxt

Context which must be passd to xxx_keyword_info functions in SymbolTable

atomsel_iterobject

AtomSelThr

Axes

A Displayable object which consisting of a set of axes

axis

barrier_struct

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)

basis_atom_t

Basis set definition for one atom

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!

CaveButtons

Buttons subclass that gets its info from the CAVE wand

CaveDisplayDevice

DisplayDevice subclass that runs in the CAVE

CaveScene

Scene subclass that allocates from a CAVE shared memory arena, and coordinates multiple rendering slave processes

CaveTracker

VMDTracker subclass that interfaces to the CAVE wand

clusterparms_t

CmdAddAtomSelMacro

Create a new atom selection macro

CmdAnimDelete

Delete frames

CmdAnimDir

Set direction of animation

CmdAnimDup

Duplicate a given frame at the end of the traj

CmdAnimJump

Jump to a new frame

CmdAnimNewFrame

Not really a command, but that's how info gets passed to the GUI's

CmdAnimNewNumFrames

Signal that a molecule has a new number of frames

CmdAnimSkip

Set frame skip value

CmdAnimSpeed

Set animation speed

CmdAnimStyle

Set style of animation

CmdAnimWriteFile

Write frames to a file

CmdColorChange

Change the rgb settings for a specified color

CmdColorItem

CmdColorName

Change the color index for a specifed name in a specified category

CmdColorScaleColors

CmdColorScaleMethod

Change the method used to calculate the color scale

CmdColorScaleSettings

Change the settings for the color scale

CmdDelAtomSelMacro

Delete the specified atom selection macro

CmdDisplayAAOn

Turn on/off antialiasing

CmdDisplayAOAmbient

Set ambient occlusion ambient factor

CmdDisplayAODirect

Set ambient occlusion direct lighting factor

CmdDisplayAOOn

Set ambient occlusion rendering mode

CmdDisplayAxes

Change the axes location

CmdDisplayBackgroundGradientOn

Turn on/off background gradient

CmdDisplayCacheMode

Set caching mode of display

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

CmdDisplayClipFar

Change the far clipping plane to a fixed value

CmdDisplayClipFarRel

Change the far clipping plane to by a relative value

CmdDisplayClipNear

Change the near clipping plane to a fixed value leaving everything else up to the base class :)

CmdDisplayClipNearRel

Change the near clipping plane to by a relative value

CmdDisplayCueDensity

Set the depth cueing exp/exp2 density parameter

CmdDisplayCueEnd

Set the depth cueing end distance

CmdDisplayCueMode

Set depth cueing mode

CmdDisplayCueStart

Set the depth cueing start distance

CmdDisplayCullingOn

Turn on/off culling

CmdDisplayDepthcueOn

Turn on/off depth cueing

CmdDisplayDoFFNumber

Set depth of field f/stop number

CmdDisplayDoFFocalDist

Set depth of field focal plane distance

CmdDisplayDoFOn

Set depth of field rendering mode

CmdDisplayEyesep

Set eye separation of display

CmdDisplayFocallen

Set focal length of display

CmdDisplayFPSOn

FPS indicator

CmdDisplayLightHL

Highlight the Nth light

CmdDisplayLightMove

Set the position of the Nth light

CmdDisplayLightOn

Turn on/off the Nth light

CmdDisplayLightRot

Rotate the position of the Nth light

CmdDisplayProj

Set the projection to either perspective or orthographic

CmdDisplayRenderMode

Set rendering mode of display

CmdDisplayScreenDistance

Set distance to screen from origin

CmdDisplayScreenHeight

Set screen height value

CmdDisplayShadowOn

Set shadow rendering mode

CmdDisplayStageLocation

Change the stage location

CmdDisplayStagePanels

Set the number of stage panels

CmdDisplayStageSize

Set the number of stage panels

CmdDisplayStereo

Set stereo mode of display

CmdDisplayStereoSwap

Turn on/off stereo eye swap

CmdIMDConnect

Connect to a running IMD simulation

CmdIMDCopyUnitCell

Set the IMD unit cell copy mode

CmdIMDRate

Set the IMD transfer rate and storage mode

CmdIMDSim

Change IMD connection status (pause, detach, kill)

CmdLabelAdd

Add a new label

CmdLabelAddspring

Add a new spring

CmdLabelDelete

Delete the Nth label in a category

CmdLabelShow

Toggle a geometry category on/off

CmdLabelTextFormat

CmdLabelTextOffset

CmdLabelTextSize

CmdLabelTextThickness

CmdMaterialAdd

Add a new material

CmdMaterialChange

Change a property of an existing material

CmdMaterialDefault

Reset a material to defaults

CmdMaterialDelete

Delete a material

CmdMaterialRename

Rename an existing material

CmdMenuExtensionAdd

Add an item to the VMD extension menu

CmdMenuExtensionRemove

Remove an item from the VMD extension menu

CmdMenuShow

Turn a menu on/off

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

CmdMolActive

Make the Nth molecule 'active' or 'inactive'

CmdMolAddRep

Add a new representation to the specified molecule

CmdMolBondsRecalc

Re-analyze structure after atom names, bonds, etc have been modified

CmdMolCancel

Cancel the loading/saving of a coordinate file

CmdMolChangeRep

Change the representation to the current defaults

CmdMolChangeRepItem

Change 1 representation characteristic for the specified mol

CmdMolColor

Set the current atom coloring method in moleculeList

CmdMolDelete

Delete the Nth molecule in the molecule List

CmdMolDeleteRep

Delete a representation for the specified molecule

CmdMolDrawFrames

Set the range of frames to draw for this rep

CmdMolFix

Make the Nth molecule 'fixed' or 'free'

CmdMolLoad

Notification that a molecule has been created

CmdMolMaterial

Set the current atom material method in moleculeList

CmdMolNew

Create a new molecule

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

CmdMolRename

Rename a molecule

CmdMolRep

Set the current atom representation in moleculeList

CmdMolRepColorUpdate

Change the auto-update for the color of the specified rep

CmdMolRepSelUpdate

Change the auto-update for the selection of the specified rep

CmdMolScaleMinmax

Set the color scale min/max range for the selected representation

CmdMolSelect

Set the current atom selection in moleculeList

CmdMolShowInstances

Set which instance images are displayed for the selected representation

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

CmdMolTop

Make the Nth molecule 'top'

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

CmdPluginUpdate

Update the GUI plugin list with any newly loaded plugins

CmdRender

Render the global scene

CmdRenderOption

Set the render execution command

CmdResetView

Reset the current view for the current scene

CmdRockOff

Stop rocking the current scene

CmdRockOn

Rock the current scene

CmdRotate

Rotate the current scene

CmdRotMat

Apply a matrix transformation to the current scene

CmdScale

Scale 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

CmdToolAddDevice

Add a device to a tool

CmdToolCallback

CmdToolChange

Change the type of tool, keeping the sensor

CmdToolCreate

Create a new tool, attaching a sensor

CmdToolDelete

Delete a tool

CmdToolDeleteDevice

Delete a device from a tool

CmdToolOffset

Change the position offset for a tool

CmdToolRep

Attach a tool to a particular representation (instead of picking)

CmdToolScale

Change the position scaling factor for a tool

CmdToolScaleForce

Change the force scaling factor for a tool

CmdToolScaleSpring

Change the force feedback spring constant for a tool

CmdTranslate

Translate the current scene

ColorFltkMenu

VMDFltkMenu subclass providing a GUI to change color settings

ColorScale

Color gradient/ramp used by value-based coloring methods

ColorscaleImage

Class to maintain a GUI-usable image of a ColorScale

ColorscaleLumaChart

Class to maintain a GUI-usable image of a ColorScale

ColorScaleTypeInfo

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::alch_Flambda

colvar::alch_lambda

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::aspathCV

colvar::azpathCV

colvar::cartesian

colvar::CartesianBasedPath

colvar::componentDisabled

colvar::coordnum

\brief Colvar component: coordination number between two groups (colvarvalue::type_scalar type, range [0:N1*N2])

colvar::CVBasedPath

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::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_vec

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::euler_phi

colvar::euler_psi

colvar::euler_theta

colvar::groupcoordnum

\brief Colvar component: coordination number between two groups (colvarvalue::type_scalar type, range [0:N1*N2])

colvar::gspath

colvar::gspathCV

colvar::gyration

\brief Colvar component: Radius of gyration of an atom group (colvarvalue::type_scalar type, range [0:*))

colvar::gzpath

colvar::gzpathCV

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::linearCombination

colvar::map_total

colvar::neuralNetwork

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

Parameters:

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_gradient

Class for accumulating the gradient of a scalar function on a grid

colvar_grid_scalar

Class for accumulating a scalar function on a grid

colvarbias

\brief Collective variable bias, base class

colvarbias_abf

ABF bias

colvarbias_alb

colvarbias_histogram

Histogram "bias" (does as the name says)

colvarbias_meta

Metadynamics 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_centers

Definition and parsing of the restraint centers

colvarbias_restraint_centers_moving

Options 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_histogram

Restrain the 1D histogram of a set of variables (or of a multidimensional one)

colvarbias_restraint_k

Definition and parsing of the force constant

colvarbias_restraint_k_moving

Options to change the restraint force constant over time

colvarbias_restraint_linear

\brief Linear bias restraint (implementation of colvarbias_restraint)

colvarbias_restraint_moving

Options to change the restraint configuration over time (shared between centers and k moving)

colvarbias_reweightaMD

Reweighted histogram for accelerated molecular dynamics (aMD) or Gaussian aMD (GaMD)

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::feature

Describes a feature and its dependencies used in a static array within each subclass

colvardeps::feature_state

This 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::rvector

Vector 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

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_io

Methods for data input/output

colvarproxy_replicas

\brief Methods for multiple-replica communication

colvarproxy_script

Methods for scripting language interface (Tcl or Python)

colvarproxy_smp

\brief Methods for SMP parallelization

colvarproxy_system

Methods for accessing the simulation system (PBCs, integrator, etc)

colvarproxy_tcl

Methods for using Tcl within Colvars

colvarproxy_vmd

\brief Communication between colvars and VMD (implementation of colvarproxy)

colvarproxy_volmaps

\brief Container of grid-based objects

colvarscript

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

Combinations

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

compile_data

ComputeOccupancyMap_t

CoorData

Abstract base class for objects that periodically read/write timesteps

CoorPluginData

CoorPluginData: Uses a MolFilePlugin to load a coordinate file

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

Counter control used to set fieldline integration delta

densitythrparms

DepthSortObject

Class for storage and re-ordering of depth-sorted geometry as needed for PSDisplayDevice

DirectionalLight

DirectionalLightList

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

DispCmdColorIndex

Set the current drawing color to the specified index

DispCmdComment

Add a comment to the display list, to make token output etc. meaningful. these are free-form and can occur anywhere

DispCmdCone

Plot a cone at the given position

DispCmdCylinder

Draw a cylinder between two endpoints

DispCmdLatticeCubeArray

Draw axis-aligned lattic cubes from the specified

DispCmdLine

Plot a line at the given position

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

DispCmdLineType

Set the current line type

DispCmdLineWidth

Set the current line width

DispCmdLitPointArray

Draw points from the specified position, and color arrays, with given size

DispCmdPickPoint

Indicate a point which may be picked, and the associated 'tag'

DispCmdPickPointArray

Create an array of indexed points which may be picked and their associated tags

DispCmdPoint

Plot a point at the given position

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

DispCmdSphereArray

Draw spheres from the specified position, radii, and color arrays

DispCmdSphereRes

Set the current sphere resolution

DispCmdSphereType

Set the current sphere type

DispCmdSquare

Draw a square, given 3 of four points

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

DispCmdTriStrips

Draw a set of triangle strips

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

Displayable

Base class for all objects which are drawn by a DisplayDevice

DisplayColor

Displayable subclass containing the background color information

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

DisplayFltkMenu

VMDFltkMenu subclass providing a GUI for setting display options

DisplayRocker

DrawForce

A Displayable subclass for drawing forces applied by IMD

DrawMolecule

Subclass of BaseMolecule and Displayable for drawing a molecule

DrawMoleculeMonitor

A monitor class that acts as a proxy for things like labels that have to be notified when molecules change their state

DrawMolItem

Displayable subclass for creating geometric representations of molecules

DrawTool

Displayable used to render a tool on the screen

A Feedback is a representation for force-feedback. Subclass this for specific haptic devices

FileChooserFltkMenu

VMDFltkMenu subclass providing a GUI for loading files into VMD

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

FileRenderer::AdvancedLightState

AdvancedLight state data

FileRenderer::LightState

Light state, passed to renderer before render commands are executed

FileRenderList

Manage a list of FileRenderer objects that can be used to render a scene

FileSpec

File loading parameter specification, what frames, volume sets, etc to load

FindWithinData

flint_t

FltkOpenGLDisplayDevice

OpenGLRenderer subclass, displays to an FLTK window

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

FreeVRButtons

Buttons subclass that gets its info from the FreeVR wand

FreeVRDisplayDevice

OpenGLRenderer subclass for FreeVR displays

FreeVRScene

Scene subclass that allocates from a FreeVR shared memory arena, and coordinates multiple rendering slave processes

FreeVRTracker

VMDTracker subclass that interfaces to the FreeVR wand

GaussianBlur< IMAGE_T >

GelatoDisplayDevice

FileRenderer subclass to exports VMD scenes to Gelato PYG scene format

GeometricPathCV::GeometricPathBase< element_type, scalar_type, path_type >

GeometryAngle

GeometryMol subclass to measure and display the angle between three atoms

GeometryAtom

GeometryMol subclass to label an atom

GeometryBond

GeometryMol subclass to measure and display bond lengths and distances

GeometryDihedral

GeometryMol subclass to measure and display dihedral angle between 4 atoms

GeometryFltkMenu

VMDFltkMenu subclass to manage geometry data, labels, and picked atoms

GeometryList

Displayable subclass to maintain geometry monitors, and draw them to a scene

GeometryMol

Base class for objects that make atomic measurements in a molecule

GeometryMonitor

A monitor class that watches GeometryMol objects for updates

GeometrySpring

GeometryMol subclass to simulate and draw a spring between two atoms in IMD

GeomListStruct

Structure used to store data about each category

GLX-specific low-level handles and window IDs

gofrparms_t

gpuqcprmsdthreadparms

gpuseg_temp_storage

GrabTool

The grab tool allows users to move molecules around

GraphicsFltkMenu

VMDFltkMenu subclass implementing a GUI for controlling graphical representations of molecules

GraphicsFltkRep

GUI 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::minmax

Volumetric 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

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

GraphicsFltkRepVolumetric::minmax

Volumetric rep internal class for managing min/max values

GraphLabelEvent

XXX These are undocumented... The user has requested the given labels to be graphed

GraphLayout

GRIDCELL

Set of 8 volume samples used for isosurface extraction

GridList

GridResCounter

Counter control used to set grid spacing

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

Indicates that help is desired on the given topic

hersheyhandle

HMDMgr

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

IMDEnergies

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

IndexList

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

InitializeStructureEvent

Set when a molecular structure is created and destroyed

integrate_potential

Integrate (1D, 2D or 3D) gradients

InterpEvent

Command subclass that acts as a base class for interpreter events

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

isosurface_cbdata

Isosurface callback data structure containing multiple pointers

JoystickTool

The 3d analog of a joystick

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

latthrparms

LibGelatoDisplayDevice

FileRenderer subclass to exports VMD scenes to Gelato PYG scene format

LibTachyonDisplayDevice

FileRenderer subclass renders via compiled-in Tachyon ray tracing engine

LINE

Structure defining a triangle generated by isocontour extraction code

linenoiseCompletions

linenoiseState

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

M_VRJapp

maddthrparms

MainFltkMenu

VMDFltkMenu subclass implementing the main molecule browser GUI, with pulldown menus to change mouse state and bring up other menus

match_data

Material

Structure containing material properties used to shade a Displayable

MaterialFltkMenu

VMDFltkMenu subclass implementing a GUI for creating and configuring material properties

MaterialList

Manages a list of materials that can be applied to Displayable objects

Matrix4

4x4 matrix class with numerous operators, conversions, etc

MayaDisplayDevice

FileRenderer subclass to export VMD scenes to Maya ASCII format

Mobile

UIObject subclass for mobile/wireless phone/tablet motion control

MobileButtons

Buttons subclass that gets its info from a WiFi SmartMobile

MobileDeviceCommandEvent

Indicates that a mobile device has a specific command to run

MobileEvent

Sets the most recent Mobile translation, rotation, and button state

mobilehandle

MobileStateChangedEvent

Indicates that the mobile device state has changed

MobileTracker

VMDTracker subclass that gets its info from the Mobile driver

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

MolData

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

MoleculeGraphics

Displayable subclass to generate graphics directly from scripts and plugins

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..

MousePositionEvent

Sets the most recent mouse position and button state

Msmpot_t

MsmpotCuda_t

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!

My_Fl_Positioner

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

myglwindow

Fl_Gl_Window subclass that implements an OpenGL rendering surface for use by the FltkOpenGLDisplayDevice class

UIestimator::n_matrix

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

NanoShaperCoord

Structure containing NanoShaper vertex coordinates

NanoShaperFace

Structure containing NanoShaper facet information

NanoShaperInterface

Manages communication with the NanoShaper surface generation program Can only use this class once!

netint

Structure used to perform byte swapping operations

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

OpenGLPbufferDisplayDevice

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

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

OptiXDisplayDevice

FileRenderer subclass to exports VMD scenes to OptiX

OptiXRenderer

Orbital

The Orbital class, which stores orbitals, SCF energies, etc. for a single timestep

orbital_cbdata

Orbital callback data structure containing multiple pointers

orbthrparms

ort_directional_light

ort_material

Structure containing material properties used to shade a Displayable

ort_positional_light

OsgNavigator

osp_cylinder_array_color

osp_directional_light

osp_material

Structure containing material properties used to shade a Displayable

osp_positional_light

osp_sphere_array_color

osp_trimesh_v3f_n3f_c3f

OSPRay2DisplayDevice

FileRenderer subclass to exports VMD scenes to OSPRay

OSPRay2Renderer

OSPRayDisplayDevice

FileRenderer subclass to exports VMD scenes to OSPRay

OSPRayRenderer

ParseTree

An atom selection expression parse tree

PBCControls

Fl_Group subclass implementing controls for displaying periodic images for a graphical representation

PerRayData_radiance

PerRayData_shadow

PhoneButtons

Buttons subclass that gets its info from a WiFi SmartPhone

PhoneTracker

VMDTracker subclass that gets its info from the Phone driver

Pickable

Contains data which may be selected with a pointer in a DisplayDevice

PickAtomCallbackEvent

Sets the molid, atomid, and client of the last callback-picked atom

PickAtomEvent

Sets the molid and atomid of the last picked atom

PickEvent

Command subclass for picking events, used to notify the GUI of updates

PickGraphicsEvent

Sets the molid, tag, and button of the last picked user graphics

PickList

Maintains a list of Pickable objects, find and deal with items picked by a pointer device

PickMode

Pick mode management class

PickModeAddBond

PickMode subclass to add bonds between two atoms

PickModeAngles

PickMode subclass for angle labels

PickModeAtoms

PickMode subclass for labeling atoms

PickModeBonds

PickMode subclass for bond/distance labels

PickModeCenter

PickMode subclass to define the molecule's centering/global translation

PickModeDihedrals

PickMode subclass for dihedral labels

PickModeForce

PickMode subclass for applying forces to atoms

PickModeForceAtom

PickMode subclass to apply a force to a single atom

PickModeForceFragment

PickMode subclass to apply a force to a single fragment

PickModeForceResidue

PickMode subclass to apply a force to a single residue

PickModeList

List of all available PickMode subclasses

PickModeMolLabel

PickMode subclass to add labels to atoms

PickModeMove

PickMode subclass for moving atoms (no forces applied)

PickModeMoveAtom

PickMode subclass for moving atoms (no forces applied)

PickModeMoveFragment

PickMode subclass for moving fragments (no forces applied)

PickModeMoveMolecule

PickMode subclass for moving whole molecules (no forces applied)

PickModeMoveRep

PickMode subclass for moving a selected rep's atoms (no forces applied)

PickModeMoveResidue

PickMode subclass for moving residues (no forces applied)

PickModeUser

PickMode subclass to add bonds between two atoms

PickSelectionEvent

List the atoms involved in the last geometry object created

PickValueEvent

Sets the value of the last created Geometry

PinchTool

Tool subclass implementing a function similar to TugTool except that the force is only applied in the direction the tool is oriented

PlainTextInterp

TextInterp subclass implementing a last resort text interpreter if no other is available

plane

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

FileRenderer subclass exports scenes to POV-Ray 3.x ray tracer scene format

prim_t

A Gaussian primitive

PrintTool

The print tool allows users to print tracker values on the fly

PSDisplayDevice

FileRenderer subclass exports VMD scenes to PostScript files

ptrstack

PyAtomSelObject

PythonEvalEvent

This command allows us to evaluate an arbitrary string in the Python interpreter

PythonTextInterp

TextInterp subclass implementing the Python-based text command interpreter

qcprmsdthreadparms

QMData

QM data management class. Concerns QM related data that are not timestep dependent

QMTimestep

Timesteps store coordinates, energies, etc. for one trajectory timestep

Quat

Quaternion class

QuickSurf

quicksurf_cbdata

QuickSurf callback data structure containing multiple pointers

R3dDisplayDevice

FileRenderer subclass exports VMD scene to a file in Raster3D format

RadianceDisplayDevice

FileRenderer subclass to export VMD scenes to a Radiance scene file

RadiusCounter

Counter control used to set radii

RayShadeDisplayDevice

FileRenderer subclass to exports VMD scenes to Rayshade scene format

VMDFltkMenu subclass implementing a GUI for exporting and rendering VMD scenes via the FileRenderer classes in FileRenderList

RenderManDisplayDevice

FileRenderer subclass to exports VMD scenes to Renderman RIB scene format

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

ResolutionCounter

Counter control used to set tessellation resolution

RibbonFrame

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

sasathreadparms

SaveTrajectoryFltkMenu

VMDFltkMenu subclass implementing a GUI for saving trajectory and coordinate frames to files

ScaleSpaceFilter< GROUP_T, IMAGE_T >

Scene

Contains lists of Displayable objects and draws them to a DisplayDevice

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

simenc_handle

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

SnapshotDisplayDevice

FileRenderer 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

Spaceball

UIObject subclass for Spaceball-based motion control

SpaceballButtons

Buttons subclass that gets its info from the local Spaceball

spaceballevent

SpaceballEvent

Sets the most recent Spaceball translation, rotation, and button state

spaceballhandle

SpaceballTracker

VMDTracker subclass that gets its info from the Spaceball driver

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

Stage

Displayable subclass implementing a checkered "stage"

state_t< GROUP_T, IMAGE_T >

StepCounter

Counter control used to set volume extraction step size

STLDisplayDevice

FileRenderer subclass to export VMD scenes to STL solid model format

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

Symmetry

TachyonDisplayDevice

FileRenderer subclass to export VMD scenes to the Tachyon scene format

TclEvalEvent

Evaluate the given string in the Tcl interpreter

TclTextInterp

TextInterp subclass implementing the Tcl-based text command interpreter

TextInterp

Base class for all text interpreters

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

ToolFltkMenu

VMDFltkMenu subclass that implements a GUI for configuring Tool, Sensor, Button, Feedback, and VMDTracker objects

TrajectoryReadEvent

Indicates when all the frames of a trajectory have been read

TRIANGLE

Structure defining a triangle generated by isosurface extraction code

TugTool

A tool for interacting with MD simulations

UIestimator::UIestimator

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

usage

Track usage of Colvars features

UserKeyEvent

Evaluate the given hotkey combination

vmd_opencl_orbital_handle

vmd_trimesh_c4u_n3b_v3f

The main VMD application instance, created by the main entry point

VMDClipPlane

Data structure describing user specified clipping planes

VMDCollab

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

VMDDisplayList::VMDLinkIter

VMDFltkMenu

VMDMenu and FL_Window subclass for managing all FLTK-based menus in VMD

VMDMenu

Base class for all GUI menus in VMD

VMDTempFile

VMDTitle

Displayable subclass for a flashy title object displayed when VMD starts up, until a molecule is loaded

VMDTkinterMenu

VMDMenu subclass to manage Tkinter extension menus added by the user

VMDTkMenu

VMDMenu subclass to manage Tk extension menus added by the user

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

vmdwinjoystick

Store low-level Win32 joystick status and config info

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

VolMapCreateCoulombPotential

VolMapCreateCoulombPotentialMSM

VolMapCreateDensity

VolMapCreateDistance

VolMapCreateILS

Implicit Ligand Sampling (ILS) algorithm. It finds the energy of placing a monoatomic or diatomic ligand at many points in the protein

VolMapCreateInterp

VolMapCreateMask

VolMapCreateOccupancy

VolumeTexture

VolumetricData

Volumetric data class for potential maps, electron density maps, etc