def parse2new( self, source, ref, traj=None ):
"""
Replace content of a new Trajectory from the source.
Args:
source (str): file name or other input object
ref (str or PDBModel): reference structure instance or file
traj (Biskit.md.Trajectory): existing instance to be updated
Returns:
Biskit.Trajectory: new Trajectory instance
"""
r = traj
if traj is None:
import biskit.md
r = biskit.md.Trajectory()
ref = B.PDBModel(ref)
src = AmberMdcrd(source, natom=ref.lenAtoms(),hasbox=self.hasbox)
r.frames = src.coordinates
r.setRef(ref)
r.resIndex = r.ref.resMap()
assert N.shape(r.frames) == (src.frame, src.natom, 3)
assert r.lenAtoms() == src.natom
return r
def test_reporters_pbc(self):
""" Test NetCDF and ASCII restart and trajectory reporters (w/ PBC) """
systemsolv = load_file(self.get_fn('ildn.solv.top'),
xyz=self.get_fn('ildn.solv.gro'))
system = systemsolv.createSystem(nonbondedMethod=app.PME,
nonbondedCutoff=8 * u.angstroms)
integrator = mm.LangevinIntegrator(300 * u.kelvin, 5.0 / u.picoseconds,
1.0 * u.femtoseconds)
sim = app.Simulation(systemsolv.topology, system, integrator, CPU)
sim.context.setPositions(systemsolv.positions)
sim.reporters.extend([
NetCDFReporter(self.get_fn('traj.nc', written=True),
1,
vels=True,
frcs=True),
MdcrdReporter(self.get_fn('traj.mdcrd', written=True), 1),
RestartReporter(self.get_fn('restart.ncrst', written=True),
1,
netcdf=True),
RestartReporter(self.get_fn('restart.rst7', written=True), 1),
StateDataReporter(self.get_fn('state.o', written=True),
1,
volume=True,
density=True,
systemMass=1)
])
sim.step(5)
for reporter in sim.reporters:
reporter.finalize()
ntraj = NetCDFTraj.open_old(self.get_fn('traj.nc', written=True))
atraj = AmberMdcrd(self.get_fn('traj.mdcrd', written=True),
len(systemsolv.atoms),
True,
mode='r')
nrst = NetCDFRestart.open_old(
self.get_fn('restart.ncrst', written=True))
arst = AmberAsciiRestart(self.get_fn('restart.rst7', written=True),
'r')
self.assertEqual(ntraj.frame, 5)
self.assertEqual(atraj.frame, 5)
self.assertTrue(ntraj.hasvels)
self.assertTrue(ntraj.hasfrcs)
for i in range(ntraj.frame):
for x1, x2 in zip(ntraj.box[i], atraj.box[i]):
self.assertAlmostEqual(x1, x2, places=3)
self.assertEqual(len(nrst.box), 6)
self.assertEqual(len(arst.box), 6)
# Make sure the EnergyMinimizerReporter does not fail
f = StringIO()
rep = EnergyMinimizerReporter(f, volume=True)
rep.report(sim)
rep.finalize()
def xyz2mdcrd(xyz, mdcrd):
xyzF = open(xyz, 'r')
line = xyzF.readline()
atomsNo = int(line)
mdcrdTraj = AmberMdcrd(mdcrd, atomsNo, hasbox=False, mode='w')
while line:
coordsFrame = []
xyzF.readline()
for i in range(atomsNo):
line = xyzF.readline()
for c in line.split()[-3:]:
coordsFrame.append(float(c))
mdcrdTraj.add_coordinates(coordsFrame)
line = xyzF.readline()
xyzF.close()
mdcrdTraj.close()
if __name__=="__main__":
parser=arg.ArgumentParser(description='Grep qm area from an Amber MDcrd trajory to make training dataset!')
parser.add_argument('-i','--input')
args=parser.parse_args()
jsonfile=args.input
UpdateGPARAMS(jsonfile)
os.environ["CUDA_VISIBLE_DEVICES"]=List2str(GPARAMS.Compute_setting.Gpulist,',')
print (os.environ["CUDA_VISIBLE_DEVICES"])
TMMSET=MSet(GPARAMS.Dataset_setting.Outputdataset)
for i in range(len(GPARAMS.System_setting)):
Strucdict=GPARAMS.System_setting[i].Strucdict
sys=Qmmm.QMMM_FragSystem(GPARAMS.System_setting[i].Systemparm,\
GPARAMS.System_setting[i].Initstruc,\
Strucdict)
natom=sys.natom
crd=AmberMdcrd(GPARAMS.System_setting[i].Traj,natom,False)
sys.Create_DisMap()
for i in range(crd.frame):
sys.step=i+1
tmpcrd=crd.coordinates[i]
sys.coords=tmpcrd
sys.Update_DisMap()
sys.update_crd()
tmpmol=sys.Create_QMarea()
print (tmpmol)
TMMSET.mols.append(tmpmol)
TMMSET.Save()
def test_reporters(self):
""" Test NetCDF and ASCII restart and trajectory reporters (no PBC) """
with self.assertRaises(ValueError):
NetCDFReporter(self.get_fn('blah', written=True), 1, crds=False)
with self.assertRaises(ValueError):
MdcrdReporter(self.get_fn('blah', written=True), 1, crds=False)
with self.assertRaises(ValueError):
MdcrdReporter(self.get_fn('blah', written=True),
1,
crds=True,
vels=True)
system = self.amber_gas.createSystem()
integrator = mm.LangevinIntegrator(300 * u.kelvin, 5.0 / u.picoseconds,
1.0 * u.femtoseconds)
sim = app.Simulation(self.amber_gas.topology,
system,
integrator,
platform=CPU)
sim.context.setPositions(self.amber_gas.positions)
sim.reporters.extend([
NetCDFReporter(self.get_fn('traj1.nc', written=True), 10),
NetCDFReporter(self.get_fn('traj2.nc', written=True),
10,
vels=True),
NetCDFReporter(self.get_fn('traj3.nc', written=True),
10,
frcs=True),
NetCDFReporter(self.get_fn('traj4.nc', written=True),
10,
vels=True,
frcs=True),
NetCDFReporter(self.get_fn('traj5.nc', written=True),
10,
crds=False,
vels=True),
NetCDFReporter(self.get_fn('traj6.nc', written=True),
10,
crds=False,
frcs=True),
NetCDFReporter(self.get_fn('traj7.nc', written=True),
10,
crds=False,
vels=True,
frcs=True),
MdcrdReporter(self.get_fn('traj1.mdcrd', written=True), 10),
MdcrdReporter(self.get_fn('traj2.mdcrd', written=True),
10,
crds=False,
vels=True),
MdcrdReporter(self.get_fn('traj3.mdcrd', written=True),
10,
crds=False,
frcs=True),
RestartReporter(self.get_fn('restart.ncrst', written=True),
10,
write_multiple=True,
netcdf=True),
RestartReporter(self.get_fn('restart.rst7', written=True), 10),
])
sim.step(500)
for reporter in sim.reporters:
reporter.finalize()
self.assertEqual(len(os.listdir(self._temporary_directory.name)), 61)
ntraj = [
NetCDFTraj.open_old(self.get_fn('traj1.nc', written=True)),
NetCDFTraj.open_old(self.get_fn('traj2.nc', written=True)),
NetCDFTraj.open_old(self.get_fn('traj3.nc', written=True)),
NetCDFTraj.open_old(self.get_fn('traj4.nc', written=True)),
NetCDFTraj.open_old(self.get_fn('traj5.nc', written=True)),
NetCDFTraj.open_old(self.get_fn('traj6.nc', written=True)),
NetCDFTraj.open_old(self.get_fn('traj7.nc', written=True))
]
atraj = [
AmberMdcrd(self.get_fn('traj1.mdcrd', written=True),
self.amber_gas.ptr('natom'),
hasbox=False,
mode='r'),
AmberMdcrd(self.get_fn('traj2.mdcrd', written=True),
self.amber_gas.ptr('natom'),
hasbox=False,
mode='r'),
AmberMdcrd(self.get_fn('traj3.mdcrd', written=True),
self.amber_gas.ptr('natom'),
hasbox=False,
mode='r'),
]
for traj in ntraj:
self.assertEqual(traj.frame, 50)
self.assertEqual(traj.Conventions, 'AMBER')
self.assertEqual(traj.ConventionVersion, '1.0')
self.assertEqual(traj.application, 'AmberTools')
self.assertEqual(traj.program, 'ParmEd')
self.assertFalse(traj.hasbox)
self.assertTrue(ntraj[0].hascrds)
self.assertFalse(ntraj[0].hasvels)
self.assertFalse(ntraj[0].hasfrcs)
self.assertTrue(ntraj[1].hascrds)
self.assertTrue(ntraj[1].hasvels)
self.assertFalse(ntraj[1].hasfrcs)
self.assertTrue(ntraj[2].hascrds)
self.assertFalse(ntraj[2].hasvels)
self.assertTrue(ntraj[2].hasfrcs)
self.assertTrue(ntraj[3].hascrds)
self.assertTrue(ntraj[3].hasvels)
self.assertTrue(ntraj[3].hasfrcs)
self.assertFalse(ntraj[4].hascrds)
self.assertTrue(ntraj[4].hasvels)
self.assertFalse(ntraj[4].hasfrcs)
self.assertFalse(ntraj[5].hascrds)
self.assertFalse(ntraj[5].hasvels)
self.assertTrue(ntraj[5].hasfrcs)
self.assertFalse(ntraj[6].hascrds)
self.assertTrue(ntraj[6].hasvels)
self.assertTrue(ntraj[6].hasfrcs)
for i in (0, 2, 3, 4, 5, 6):
ntraj[i].close() # still need the 2nd
for traj in atraj:
traj.close()
# Now test the NetCDF restart files
fn = self.get_fn('restart.ncrst.%d', written=True)
for i, j in enumerate(range(10, 501, 10)):
ncrst = NetCDFRestart.open_old(fn % j)
self.assertEqual(ncrst.coordinates.shape, (1, 25, 3))
self.assertEqual(ncrst.velocities.shape, (1, 25, 3))
np.testing.assert_allclose(ncrst.coordinates[0],
ntraj[1].coordinates[i])
np.testing.assert_allclose(ncrst.velocities[0],
ntraj[1].velocities[i],
rtol=1e-6)
# Now test the ASCII restart file
f = AmberAsciiRestart(self.get_fn('restart.rst7', written=True), 'r')
# Compare to ncrst and make sure it's the same data
np.testing.assert_allclose(ncrst.coordinates, f.coordinates, atol=1e-3)
np.testing.assert_allclose(ncrst.velocities, f.velocities, rtol=1e-3)
# Make sure the EnergyMinimizerReporter does not fail
f = StringIO()
rep = EnergyMinimizerReporter(f)
rep.report(sim, frame=10)
rep.finalize()
def MD(self, QMQueue=None):
self.sys.Create_DisMap()
self.sys.Update_DisMap()
self.sys.update_crd()
f, e, AVG_ERR, ERROR_mols, EGCMlist, chargestr = self.sys.Cal_EFQ()
self.EPot0 = e
self.EPot = e
self.EnergyStat = OnlineEstimator(self.EPot0)
self.RealPot = 0.0
self.t = 0.0
self.KE = 0.0
self.atoms = self.sys.atoms
self.m = np.array(list(map(lambda x: ATOMICMASSES[x - 1], self.atoms)))
self.x = self.sys.coords - self.sys.coords[self.center]
self.v = np.zeros(self.x.shape)
self.a = np.zeros(self.x.shape)
self.f = f
self.md_log = None
if self.format == "Amber":
self.trajectory = AmberMdcrd(self.path + self.name +
'_%d.mdcrd' % self.stageindex,
natom=self.sys.natom,
hasbox=False,
mode='w')
self.restart = Rst7(natom=len(self.atoms))
self.trajectory.add_coordinates(self.x)
if self.MDV0 == "Random":
np.random.seed()
self.v = np.random.randn(*self.x.shape)
Tstat = Thermostat(self.m, self.v, self.T, self.dt)
elif self.MDV0 == "Thermal":
self.v = np.random.normal(size=self.x.shape) * np.sqrt(
1.38064852e-23 * self.T / self.m)[:, None]
self.Tstat = None
if (self.MDThermostat == "Rescaling"):
self.Tstat = Thermo(self.m, self.v, self.T, self.dt)
elif (self.MDThermostat == "Andersen"):
self.Tstat = Andersen(self.m, self.v, self.T, self.dt)
self.a = pow(10.0, -10.0) * np.einsum("ax,a->ax", self.f, 1.0 / self.m)
if self.format == "Amber":
self.restart.coordinates = self.x
self.restart.vels = self.v
step = 0
self.md_log = np.zeros((self.maxstep + 1, 7))
res_order = np.array(range(1, self.sys.nres))
ERROR = 0
ERROR_record = []
method_record = 0
Temp_record = []
MD_Flag = True
while step < self.maxstep and MD_Flag:
self.t += self.dt
t1 = time.time()
x_new = self.x + self.v * self.dt + 0.5 * self.a * self.dt**2
#if self.icap==True:
# x_new=x_new-x_new[self.center]
self.sys.coords = x_new
f = x_new
EPot = 0
ERROR_mols = []
self.sys.Update_DisMap()
self.sys.update_crd()
f, EPot, ERROR, ERROR_mols, EGCMlist, chargestr = self.sys.Cal_EFQ(
)
ERROR_record.append(ERROR)
if self.sys.stepmethod == 'Gaussian' and self.sys.Theroylevel == 'NN':
method_record += 1
if self.MODE == 'Train':
if QMQueue != None:
QMQueue.put(ERROR_mols)
self.EPot = EPot
distozero = np.sqrt(np.sum(self.sys.coords**2, axis=1))
if self.icap == True:
#Vec=(self.sys.Distance_Matrix[self.center]-self.radius)/self.radius
Vec = (distozero - self.radius) / self.radius
for i in range(len(x_new)):
if Vec[i] > 0:
tmpvec = (x_new[i])
tmpvec = tmpvec / np.sqrt(np.sum(tmpvec**2))
f[i] = f[i] - tmpvec * self.fcap * Vec[
i] * JOULEPERHARTREE / 627.51
f[self.
center] = f[self.center] - x_new[self.center] * 10 * Vec[
self.center] * JOULEPERHARTREE / 627.51
a_new = pow(10.0, -10.0) * np.einsum("ax,a->ax", f, 1.0 / self.m)
v_new = self.v + 0.5 * (self.a + a_new) * self.dt
if self.MDThermostat != None and step % 1 == 0:
v_new = self.Tstat.step(self.m, v_new, self.dt)
self.a = a_new
self.v = v_new
self.x = x_new
self.f = f
self.md_log[step, 0] = self.t
self.md_log[step, 4] = self.KE
self.md_log[step, 5] = self.EPot
self.md_log[
step, 6] = self.KE + (self.EPot - self.EPot0) * JOULEPERHARTREE
avE, Evar = self.EnergyStat(self.EPot)
self.KE = KineticEnergy(self.v, self.m)
Teff = (2. / 3.) * self.KE / IDEALGASR
Temp_record.append(Teff)
if (step % 50 == 0):
if self.format == "Amber":
self.trajectory.add_coordinates(self.x)
step += 1
AVG_ERR = np.mean(np.array(ERROR_record[-1000:-1]))
AVG_TEMP = np.mean(np.array(Temp_record[-1000:-1]))
#if AVG_ERR>GPARAMS.Train_setting.rmse**2*GPARAMS.Train_setting.Modelnumperpoint*4:
# MD_Flag=False
#if method_record>2:
# MD_Flag=False
if AVG_TEMP > 350:
MD_Flag = False
if (step % self.Nprint == 0):
if self.format == "Amber":
if MD_Flag:
self.restart.coordinates = self.x
self.restart.vels = self.v
self.restart.write(self.path + self.name +
'_%d.rst7' % self.stageindex)
self.steprecord = step
else:
file = open(
'%straj%d.trajin' % (self.path, self.stageindex),
'w')
file.write('trajin %s %d %d 1\n' %
(self.name + '_%d.mdcrd' % self.stageindex,
0, math.ceil(self.steprecord, 10)))
file.write('trajout %s\n' %
(self.name + '_%d.mdcrd' % self.stageindex))
os.system(
"cd %s && cpptraj -p %s < traj%d.trajin > traj%d.out && cd .."
% (self.path, self.name + '.prmtop',
self.stageindex, self.stageindex))
if MD_Flag == True:
self.Outfile.write("%s Step: %i time: %.1f(fs) KE(kJ): %.5f PotE(Eh): %.5f ETot(kJ/mol): %.5f Teff(K): %.5f MAX ERROR: %.3f Method: %s AVG_ERR: %f AVG_TEMP: %f \n"\
%(self.name, step, self.t, self.KE*len(self.m)/1000.0, self.EPot, self.KE*len(self.m)/1000.0+(self.EPot)*KJPERHARTREE, Teff,ERROR,self.sys.stepmethod,AVG_ERR,AVG_TEMP))
self.Outfile.flush()
self.Respfile.write(chargestr)
self.Respfile.write(chargestr)
else:
self.Outfile.write("AVG ERR: %.3f , MD will stop~~!!" %
AVG_ERR)
self.Outfile.flush()
self.Outfile.close()
self.Respfile.close()
return