def __init__(self, dof, state=None, hooks=None, counter0=0):
"""
**Arguments:**
dof
A specification of the degrees of freedom. The convergence
criteria are also part of this argument. This must be a DOF
instance.
**Optional arguments:**
state
A list with state items. State items are simple objects
that take or derive a property from the current state of the
iterative algorithm.
hooks
A function (or a list of functions) that is called after every
iterative.
counter0
The counter value associated with the initial state.
"""
self.dof = dof
Iterative.__init__(self, dof.ff, state, hooks, counter0)
def propagate(self):
# Allow specialized hooks to modify the state before the regular verlet
# step.
self.call_verlet_hooks('pre')
# Regular verlet step
self.acc = -self.gpos / self.masses.reshape(-1, 1)
self.vel += 0.5 * self.acc * self.timestep
self.pos += self.timestep * self.vel
self.ff.update_pos(self.pos)
self.gpos[:] = 0.0
self.vtens[:] = 0.0
self.epot = self.ff.compute(self.gpos, self.vtens)
self.acc = -self.gpos / self.masses.reshape(-1, 1)
self.vel += 0.5 * self.acc * self.timestep
self.ekin = self._compute_ekin()
# Allow specialized verlet hooks to modify the state after the step
self.call_verlet_hooks('post')
# Calculate the total position change
self.posnieuw = self.pos.copy()
self.delta[:] = self.posnieuw - self.posoud
self.posoud[:] = self.posnieuw
# Common post-processing of a single step
self.time += self.timestep
self.compute_properties()
Iterative.propagate(self) # Includes call to conventional hooks
def __init__(self, dof, state=None, hooks=None, counter0=0):
"""
**Arguments:**
dof
A specification of the degrees of freedom. The convergence
criteria are also part of this argument. This must be a DOF
instance.
**Optional arguments:**
state
A list with state items. State items are simple objects
that take or derive a property from the current state of the
iterative algorithm.
hooks
A function (or a list of functions) that is called after every
iterative.
counter0
The counter value associated with the initial state.
"""
self.dof = dof
Iterative.__init__(self, dof.ff, state, hooks, counter0)
def __init__(self, ff, fn_traj, state=None, hooks=None, counter0=0):
"""
**Arguments:**
ff
A ForceField instance
fn_traj
A hdf5 file name containing the trajectory
**Optional arguments:**
state
A list with state items. State items are simple objects
that take or derive a property from the current state of the
iterative algorithm.
hooks
A function (or a list of functions) that is called after every
iterative.
counter0
The counter value associated with the initial state.
"""
self.traj = h5py.File(fn_traj, 'r')
self.nframes = len(self.traj['trajectory/pos'][:])
Iterative.__init__(self, ff, state, hooks, counter0)
def __init__(self, ff, fn_traj, state=None, hooks=None, counter0=0):
"""
**Arguments:**
ff
A ForceField instance
fn_traj
A hdf5 file name containing the trajectory
**Optional arguments:**
state
A list with state items. State items are simple objects
that take or derive a property from the current state of the
iterative algorithm.
hooks
A function (or a list of functions) that is called after every
iterative.
counter0
The counter value associated with the initial state.
"""
self.traj = h5.File(fn_traj, 'r')
self.nframes = len(self.traj['trajectory/pos'][:])
Iterative.__init__(self, ff, state, hooks, counter0)
def propagate(self):
# Allow specialized hooks to modify the state before the regular verlet
# step.
self.call_verlet_hooks('pre')
# Regular verlet step
self.acc = -self.gpos/self.masses.reshape(-1,1)
self.vel += 0.5*self.acc*self.timestep
self.pos += self.timestep*self.vel
self.ff.update_pos(self.pos)
self.gpos[:] = 0.0
self.vtens[:] = 0.0
self.epot = self.ff.compute(self.gpos, self.vtens)
self.acc = -self.gpos/self.masses.reshape(-1,1)
self.vel += 0.5*self.acc*self.timestep
self.ekin = self._compute_ekin()
# Allow specialized verlet hooks to modify the state after the step
self.call_verlet_hooks('post')
# Calculate the total position change
self.posnieuw = self.pos.copy()
self.delta[:] = self.posnieuw-self.posoud
self.posoud[:] = self.posnieuw
# Common post-processing of a single step
self.time += self.timestep
self.compute_properties()
Iterative.propagate(self) # Includes call to conventional hooks
def initialize(self):
# Standard initialization of Verlet algorithm
self.gpos[:] = 0.0
self.ff.update_pos(self.pos)
self.epot = self.ff.compute(self.gpos)
self.acc = -self.gpos/self.masses.reshape(-1,1)
# Allow for specialized initializations by the Verlet hooks.
self.call_verlet_hooks('init')
# Configure the number of degrees of freedom if needed
if self.ndof is None:
self.ndof = self.pos.size
# Common post-processing of the initialization
self.compute_properties()
Iterative.initialize(self) # Includes calls to conventional hooks
def initialize(self):
# Standard initialization of Verlet algorithm
self.gpos[:] = 0.0
self.ff.update_pos(self.pos)
self.epot = self.ff.compute(self.gpos)
self.acc = -self.gpos / self.masses.reshape(-1, 1)
self.posoud = self.pos.copy()
# Allow for specialized initializations by the Verlet hooks.
self.call_verlet_hooks('init')
# Configure the number of degrees of freedom if needed
if self.ndof is None:
self.ndof = self.pos.size
# Common post-processing of the initialization
self.compute_properties(self.restart_h5)
Iterative.initialize(self) # Includes calls to conventional hooks
def propagate(self):
# Allow specialized hooks to modify the state before the regular verlet
# step.
self.call_verlet_hooks('pre')
# Regular verlet step
self.delta[:] = self.timestep*self.vel + (0.5*self.timestep**2)*self.acc
self.pos += self.delta
self.ff.update_pos(self.pos)
self.gpos[:] = 0.0
self.vtens[:] = 0.0
self.epot = self.ff.compute(self.gpos, self.vtens)
acc = -self.gpos/self.masses.reshape(-1,1)
self.vel += 0.5*(acc+self.acc)*self.timestep
self.acc = acc
# Allow specialized verlet hooks to modify the state after the step
self.call_verlet_hooks('post')
# Common post-processing of a single step
self.time += self.timestep
self.compute_properties()
Iterative.propagate(self) # Includes call to conventional hooks
def propagate(self):
self.dof.check_convergence()
Iterative.propagate(self)
return self.dof.converged
def initialize(self):
# The first call to check_convergence will never flag convergence, but
# it is need to keep track of some convergence criteria.
self.dof.check_convergence()
Iterative.initialize(self)
def __init__(self,
ff,
timestep=None,
state=None,
hooks=None,
vel0=None,
temp0=300,
scalevel0=True,
time0=None,
ndof=None,
counter0=None,
restart_h5=None):
"""
**Arguments:**
ff
A ForceField instance
**Optional arguments:**
timestep
The integration time step (in atomic units)
state
A list with state items. State items are simple objects
that take or derive a property from the current state of the
iterative algorithm.
hooks
A function (or a list of functions) that is called after every
iterative.
vel0
An array with initial velocities. If not given, random
velocities are sampled from the Maxwell-Boltzmann distribution
corresponding to the optional arguments temp0 and scalevel0
temp0
The (initial) temperature for the random initial velocities
scalevel0
If True (the default), the random velocities are rescaled such
that the instantaneous temperature coincides with temp0.
time0
The time associated with the initial state.
ndof
When given, this option overrides the number of degrees of
freedom determined from internal heuristics. When ndof is not
given, its default value depends on the thermostat used. In most
cases it is 3*natom, except for the NHC thermostat where the
number if internal degrees of freedom is counted. The ndof
attribute is used to derive the temperature from the kinetic
energy.
counter0
The counter value associated with the initial state.
restart_h5
HDF5 object containing the restart information
"""
# Assign init arguments
if timestep is None and restart_h5 is None:
raise AssertionError('No Verlet timestep is found')
self.ndof = ndof
self.hooks = hooks
self.restart_h5 = restart_h5
# Retrieve the necessary properties if restarting. Restart objects
# are overwritten by optional arguments in VerletIntegrator
if self.restart_h5 is None:
# set None variables to default value
if time0 is None: time0 = 0.0
if counter0 is None: counter0 = 0
self.pos = ff.system.pos.copy()
self.rvecs = ff.system.cell.rvecs.copy()
self.timestep = timestep
self.time = time0
else:
# Arguments associated with the unit cell and positions are always retrieved
tgrp = self.restart_h5['trajectory']
self.pos = tgrp['pos'][-1, :, :]
ff.update_pos(self.pos)
if 'cell' in tgrp:
self.rvecs = tgrp['cell'][-1, :, :]
ff.update_rvecs(self.rvecs)
else:
self.rvecs = None
# Arguments which can be provided in the VerletIntegrator object are only
# taken from the restart file if not provided explicitly
if time0 is None:
self.time = tgrp['time'][-1]
else:
self.time = time0
if counter0 is None:
counter0 = tgrp['counter'][-1]
if vel0 is None:
vel0 = tgrp['vel'][-1, :, :]
if timestep is None:
self.timestep = self.restart_h5['/restart/timestep'][()]
self._restart_add_hooks(self.restart_h5, ff)
# Verify the hooks: combine thermostat and barostat if present
self._verify_hooks()
# The integrator needs masses. If not available, take default values.
if ff.system.masses is None:
ff.system.set_standard_masses()
self.masses = ff.system.masses
# Set random initial velocities if needed.
if vel0 is None:
self.vel = get_random_vel(temp0, scalevel0, self.masses)
else:
self.vel = vel0.copy()
# Working arrays
self.gpos = np.zeros(self.pos.shape, float)
self.delta = np.zeros(self.pos.shape, float)
self.vtens = np.zeros((3, 3), float)
# Tracks quality of the conserved quantity
self._cons_err_tracker = ConsErrTracker(restart_h5)
Iterative.__init__(self, ff, state, self.hooks, counter0)
def propagate(self):
self.dof.check_convergence()
Iterative.propagate(self)
return self.dof.converged
def initialize(self):
# The first call to check_convergence will never flag convergence, but
# it is need to keep track of some convergence criteria.
self.dof.check_convergence()
Iterative.initialize(self)
def __init__(self, ff, timestep, state=None, hooks=None, vel0=None,
temp0=300, scalevel0=True, time0=0.0, ndof=None, counter0=0):
"""
**Arguments:**
ff
A ForceField instance
timestep
The integration time step (in atomic units)
**Optional arguments:**
state
A list with state items. State items are simple objects
that take or derive a property from the current state of the
iterative algorithm.
hooks
A function (or a list of functions) that is called after every
iterative.
vel0
An array with initial velocities. If not given, random
velocities are sampled from the Maxwell-Boltzmann distribution
corresponding to the optional arguments temp0 and scalevel0
temp0
The (initial) temperature for the random initial velocities
scalevel0
If True (the default), the random velocities are rescaled such
that the instantaneous temperature coincides with temp0.
time0
The time associated with the initial state.
ndof
When given, this option overrides the number of degrees of
freedom determined from internal heuristics. When ndof is not
given, its default value depends on the thermostat used. In most
cases it is 3*natom, except for the NHC thermostat where the
number if internal degrees of freedom is counted. The ndof
attribute is used to derive the temperature from the kinetic
energy.
counter0
The counter value associated with the initial state.
"""
# Assign init arguments
self.pos = ff.system.pos.copy()
self.timestep = timestep
self.time = time0
self.ndof = ndof
# The integrator needs masses. If not available, take default values.
if ff.system.masses is None:
ff.system.set_standard_masses()
self.masses = ff.system.masses
# Set random initial velocities if needed.
if vel0 is None:
self.vel = get_random_vel(temp0, scalevel0, self.masses)
else:
self.vel = vel0.copy()
# Working arrays
self.gpos = np.zeros(self.pos.shape, float)
self.delta = np.zeros(self.pos.shape, float)
self.vtens = np.zeros((3, 3), float)
# Tracks quality of the conserved quantity
self._cons_err_tracker = ConsErrTracker()
Iterative.__init__(self, ff, state, hooks, counter0)
def __init__(self, ff, timestep=None, state=None, hooks=None, vel0=None,
temp0=300, scalevel0=True, time0=None, ndof=None, counter0=None, restart_h5=None):
"""
**Arguments:**
ff
A ForceField instance
**Optional arguments:**
timestep
The integration time step (in atomic units)
state
A list with state items. State items are simple objects
that take or derive a property from the current state of the
iterative algorithm.
hooks
A function (or a list of functions) that is called after every
iterative.
vel0
An array with initial velocities. If not given, random
velocities are sampled from the Maxwell-Boltzmann distribution
corresponding to the optional arguments temp0 and scalevel0
temp0
The (initial) temperature for the random initial velocities
scalevel0
If True (the default), the random velocities are rescaled such
that the instantaneous temperature coincides with temp0.
time0
The time associated with the initial state.
ndof
When given, this option overrides the number of degrees of
freedom determined from internal heuristics. When ndof is not
given, its default value depends on the thermostat used. In most
cases it is 3*natom, except for the NHC thermostat where the
number if internal degrees of freedom is counted. The ndof
attribute is used to derive the temperature from the kinetic
energy.
counter0
The counter value associated with the initial state.
restart_h5
HDF5 object containing the restart information
"""
# Assign init arguments
if timestep is None and restart_h5 is None:
raise AssertionError('No Verlet timestep is found')
self.ndof = ndof
self.hooks = hooks
self.restart_h5 = restart_h5
# Retrieve the necessary properties if restarting. Restart objects
# are overwritten by optional arguments in VerletIntegrator
if self.restart_h5 is None:
# set None variables to default value
if time0 is None: time0 = 0.0
if counter0 is None: counter0 = 0
self.pos = ff.system.pos.copy()
self.rvecs = ff.system.cell.rvecs.copy()
self.timestep = timestep
self.time = time0
else:
# Arguments associated with the unit cell and positions are always retrieved
tgrp = self.restart_h5['trajectory']
self.pos = tgrp['pos'][-1,:,:]
ff.update_pos(self.pos)
if 'cell' in tgrp:
self.rvecs = tgrp['cell'][-1,:,:]
ff.update_rvecs(self.rvecs)
else:
self.rvecs = None
# Arguments which can be provided in the VerletIntegrator object are only
# taken from the restart file if not provided explicitly
if time0 is None:
self.time = tgrp['time'][-1]
else:
self.time = time0
if counter0 is None:
counter0 = tgrp['counter'][-1]
if vel0 is None:
vel0 = tgrp['vel'][-1,:,:]
if timestep is None:
self.timestep = self.restart_h5['/restart/timestep'][()]
self._restart_add_hooks(self.restart_h5, ff)
# Verify the hooks: combine thermostat and barostat if present
self._verify_hooks()
# The integrator needs masses. If not available, take default values.
if ff.system.masses is None:
ff.system.set_standard_masses()
self.masses = ff.system.masses
# Set random initial velocities if needed.
if vel0 is None:
self.vel = get_random_vel(temp0, scalevel0, self.masses)
else:
self.vel = vel0.copy()
# Working arrays
self.gpos = np.zeros(self.pos.shape, float)
self.delta = np.zeros(self.pos.shape, float)
self.vtens = np.zeros((3, 3), float)
# Tracks quality of the conserved quantity
self._cons_err_tracker = ConsErrTracker(restart_h5)
Iterative.__init__(self, ff, state, self.hooks, counter0)
