def __init__(self,
mol,
nsteps=20,
force_tolerance=data.DEFAULT_FORCE_TOLERANCE,
frame_interval=None,
_restart_from=0,
_restart_energy=None):
self.mol = mol
self.nsteps = nsteps - _restart_from
self.force_tolerance = force_tolerance
self.frame_interval = mdt.utils.if_not_none(frame_interval,
max(nsteps / 10, 1))
self._restart_from = _restart_from
# Set up the trajectory to track the minimization
self.traj = mdt.Trajectory(mol)
self.current_step = _restart_from
if _restart_energy is None:
self.traj.new_frame(
minimization_step=0,
annotation='minimization steps:%d (energy=%s)' %
(0, mol.calc_potential_energy()))
self._initial_energy = _restart_energy
self._last_energy = None
self._last_grad = None
# Figure out whether we'll use gradients
self.request_list = ['potential_energy']
if 'forces' in mol.energy_model.ALL_PROPERTIES:
self.gradtype = 'analytical'
self.request_list.append('forces')
else:
self.gradtype = 'approximate'
assert len(mol.constraints) == 0, \
'Constrained minimization only available with analytical gradients'
def __init__(self, mol, report_interval):
self.mol = mol
self.report_interval = report_interval
self.trajectory = mdt.Trajectory(mol)
self.annotation = None
self.last_report_time = None
self.logger = mdt.helpers.DynamicsLog()
def __init__(self, mol, report_interval):
self.mol = mol
self.report_interval = report_interval
self.trajectory = mdt.Trajectory(mol)
self.annotation = None
self._row_format = ("{:<%d}" % 10) + 3 * ("{:>%d}" % self.LEN)
self._printed_header = False
self.last_report_time = None
def finish_min(self, job):
# TODO: parse more data than just the final minimization state
properties = self.finish(job)
traj = mdt.Trajectory(self.mol)
traj.new_frame()
self.mol.positions = properties.positions
self.mol.properties = properties
traj.new_frame()
return traj
def h2_wfn_traj(h2):
mol = h2.copy()
mol.set_energy_model(mdt.models.RHF, basis='sto-3g')
traj = mdt.Trajectory(mol)
for i in range(3):
mol.calculate()
traj.new_frame()
mol.atoms[0].x += 0.2 * u.angstrom
return traj
def finish_min(self, job):
# TODO: parse more data than just the final minimization state
traj = mdt.Trajectory(self.mol)
traj.new_frame()
results = json.loads(job.get_output('results.json').read())
new_state = self._json_to_quantities(results['states'][0])
self.mol.positions = new_state['positions']
self.mol.properties = self._process_results(results)
traj.new_frame()
return traj
def finish_min(self, job):
traj = mdt.Trajectory(self.mol)
traj.new_frame()
results = json.loads(job.get_output('results.json').read())
new_state = self._json_to_quantities(results['states'][0])
for iatom in sorted(self.params.qm_indices):
for position in new_state['positions']:
self.mol.atoms[iatom].position = position
properties = self._process_results(results)
properties.positions = self.mol.positions
self.mol.properties = properties
traj.new_frame()
return traj
def precanned_trajectory():
a1 = mdt.Atom(6)
a2 = mdt.Atom(1)
a3 = mdt.Atom(7)
mol = mdt.Molecule([a1, a2, a3])
traj = mdt.Trajectory(mol)
a1.x = 1.0 * u.angstrom
a3.y = 1.0 * u.angstrom
traj.new_frame(somenumber=1, someletter='a')
mol.time = 1.0 * u.fs
a1.x = 2.0 * u.angstrom
traj.new_frame(somenumber=2, someletter='b')
mol.time = 2.0 * u.fs
a2.x = -1.0 * u.angstrom
a3.x = -1.0 * u.angstrom
traj.new_frame(somenumber=3, someletter='c')
return traj