|
The Hookean bond term is of the Inclusion type (i.e., indexed
by the Atom Inclusion Type) and an individual term
is:
where
rij is the distance between atoms
i and j, Kb is the
stretching constant and bo
is the equilibrium bond length. The stretching constants are assigned
to this particular bond based on the Atom Inclusion Types of the two
participating atoms. The equilibrium bond length is specified
individually for each term, thus distinguishing this from the very
similar Bonds term.
This term can be used to implement a coarse-grained model of
large molecules, by representing large groups of atoms with a
pseudoatom each, and connecting any two pseudoatoms that are within a
cutoff distance with this term, thus modeling the molecules with a
network of bonds. (This idea comes from the
Gaussian Network Model, which uses a coarse-grained normal mode analysis. We are avoiding this name to prevent confusion.)
The Hooke
module is located in the Energy sub-directory of
the Yup package, hence:
Yup.Energy.Hooke.
The
hookean bond term is introduced into a simulation by first
creating an (empty) instance of the Hooke
object. Participating atom pairs are then added to
this object. Previously added bonds may also be
deleted or modified. All these actions affect only
a list of candidate bonds. The compile process
binds Coordinate and Gradient
AtomVectors
to the Hooke
module and then goes through the candidate bonds to
form a compiled bond list in which all the atoms
that are involved and the bond parameters that they
are to use are positively identified. Only then can
the bond term be evaluated. (Prior attempts at
evaluation will either yield an exception or null
results.) The evaluate method would now be called
many times as part of a molecular mechanics
calculation. Each call would yield different
results even though the compiled bond list is fixed
because the Coordinates are different at each call.
However, it is possible to modify the force constants continuously during a calculation. The
parameters are accessed through the subscript
operator. More radical changes can be made by
adding new bonds and modifying or deleting existing
bonds. These actions affect the candidate list and
immediately clear the compiled list. Therefore the Hooke
module must be compiled again before evaluation can
resume. The state of the Hooke
module can be judged by examining the data
attributes. The compiled bonds can also be examined
in great detail by printing the object.
This
manual is divided into several pages:
|
Name
|
Content
|
|
Hooke
|
Introduction:
this page.
|
|
Create
|
Creating
a new Hooke
object. The function Hooke().
|
|
Data
|
The
data attributes of a Hooke
object; some of which may be assigned
new values.
|
|
Manage
|
Managing
bonds: add new bonds, modifying
existing bonds and deleting existing
bonds. The methods:
add(),
modify()
and delete(). Also, the method freeze() that is unique to this term.
|
|
Compile
|
Preparing
a Hooke
object for evaluation of the energy and
gradients. The methods:
update()
and compile().
|
|
Evaluate
|
Evaluate
the bond energy and gradients. The
method: evaluate().
|
|
Subscript
|
The
subscript []
operator: used to access and to assign
values to the table of force constants
|
|
Print
|
Documents
the print, repr, delete and compare
operators.
|
|
Write
|
Writing
the finalized bond record to the force
field file.
|
Yup.Models.Null.HookeFFA is a helper module to generate the terms of this functions.
|