def test_plumed_md():
with tmpdir(__name__, 'test_plumed_md') as dirname:
ff = get_ff_water32()
kappa, V0 = 1.6 * kjmol / angstrom**6, ff.system.cell.volume
# PLUMED input commands
commands = "vol: VOLUME\n"
commands += "RESTRAINT ARG=vol AT=%.20f KAPPA=%.20f LABEL=restraint\n"%\
(V0/nanometer**3,kappa/kjmol*nanometer**6)
commands += "PRINT STRIDE=1 ARG=vol FILE=%s\n" % (os.path.join(
dirname, 'cv.log'))
commands += "FLUSH STRIDE=1\n"
# Write PLUMED commands to file
fn = os.path.join(dirname, 'plumed.dat')
with open(fn, 'w') as f:
f.write(commands)
# Setup Plumed
timestep = 1.0 * femtosecond
plumed = ForcePartPlumed(ff.system, timestep=timestep, fn=fn)
ff.add_part(plumed)
# Setup integrator with a barostat, so plumed has to compute forces
# more than once per timestep
tbc = TBCombination(MTKBarostat(ff, 300, 1 * bar), NHCThermostat(300))
verlet = VerletIntegrator(ff, timestep, hooks=[tbc, plumed])
# Run a short MD simulation, keeping track of the CV (volume in this case)
cvref = [ff.system.cell.volume]
for i in range(4):
verlet.run(1)
cvref.append(ff.system.cell.volume)
# Read the PLUMED output and compare with reference
cv = np.loadtxt(os.path.join(dirname, 'cv.log'))
assert cv.shape[0] == 5
assert np.allclose(cv[:, 0] * picosecond, np.arange(5) * timestep)
assert np.allclose(cv[:, 1] * nanometer**3, cvref)
def test_basic_langevin_nvt():
thermostat = LangevinThermostat(300)
nvt = VerletIntegrator(get_ff_water32(),
1.0 * femtosecond,
hooks=thermostat)
nvt.run(5)
assert nvt.counter == 5
def test_spectrum_online_blind():
# Setup a test FF
ff = get_ff_water32()
spectrum = Spectrum(bsize=2)
nve = VerletIntegrator(ff, 1.0 * femtosecond, hooks=spectrum)
nve.run(5)
assert nve.counter == 5
def test_spectrum_online():
for bsize in 2, 4, 5:
# Setup a test FF
ff = get_ff_water32()
# Run a test simulation
f = h5.File(
'yaff.analysis.test.test_spectrum.test_spectrum_online_%i.h5' %
bsize,
driver='core',
backing_store=False)
try:
hdf5 = HDF5Writer(f)
spectrum0 = Spectrum(f, bsize=bsize)
nve = VerletIntegrator(ff,
1.0 * femtosecond,
hooks=[hdf5, spectrum0])
nve.run(5)
assert nve.counter == 5
# Also run an off-line spectrum and compare
spectrum1 = Spectrum(f, bsize=bsize)
assert abs(spectrum0.timestep - spectrum1.timestep) < 1e-10
assert abs(spectrum0.amps - spectrum1.amps).max() < 1e-10
assert abs(spectrum0.freqs - spectrum1.freqs).max() < 1e-10
assert abs(spectrum0.ac - spectrum1.ac).max() < 1e-10
assert abs(spectrum0.time - spectrum1.time).max() < 1e-10
assert f['trajectory/vel_spectrum'].attrs['nfft'] == 3 * 3 * 32 * (
6 / bsize)
finally:
f.close()
def test_qn_5steps():
opt = QNOptimizer(CartesianDOF(get_ff_water32()))
epot0 = opt.epot
opt.run(5)
epot1 = opt.epot
assert opt.counter == 5
assert epot1 < epot0
def test_xyz():
xyz = XYZWriter('/dev/null')
nve = VerletIntegrator(get_ff_water32(), 1.0*femtosecond, hooks=[xyz])
com_vel = np.dot(nve.masses, nve.vel)/nve.masses.sum()
nve.run(15)
com_vel = np.dot(nve.masses, nve.vel)/nve.masses.sum()
assert nve.counter == 15
def test_spectrum_online_blind():
# Setup a test FF
ff = get_ff_water32()
spectrum = Spectrum(bsize=2)
nve = VerletIntegrator(ff, 1.0*femtosecond, hooks=spectrum)
nve.run(5)
assert nve.counter == 5
def test_xyz():
xyz = XYZWriter('/dev/null')
nve = VerletIntegrator(get_ff_water32(), 1.0 * femtosecond, hooks=[xyz])
com_vel = np.dot(nve.masses, nve.vel) / nve.masses.sum()
nve.run(15)
com_vel = np.dot(nve.masses, nve.vel) / nve.masses.sum()
assert nve.counter == 15
def test_amb():
nve = VerletIntegrator(get_ff_water32(),
1.0 * femtosecond,
hooks=TBCombination(McDonaldBarostat(300, 1 * bar),
AndersenThermostat(300)))
nve.run(5)
assert nve.counter == 5
def test_qn_5steps():
opt = QNOptimizer(CartesianDOF(get_ff_water32()))
epot0 = opt.epot
opt.run(5)
epot1 = opt.epot
assert opt.counter == 5
assert epot1 < epot0
def test_h5_flush():
# Test if we can read intermediate hdf5 files that are flushed
# This test relies on the `h5ls` command being available in the command line.
# Make a temporary directory
dn_tmp = tempfile.mkdtemp(suffix="yaff", prefix="nve_water_32")
# Setup a test FF
ff = get_ff_water32()
# Make two different hdf5 hooks
f = h5.File("%s/output.h5" % dn_tmp)
hdf5 = HDF5Writer(f)
f_flushed = h5.File("%s/output_flushed.h5" % dn_tmp)
hdf5_flushed = HDF5Writer(f_flushed, flush=4)
# Run a test simulation
nve = VerletIntegrator(ff, 1.0 * femtosecond, hooks=[hdf5, hdf5_flushed])
nve.run(5)
try: # Actual test
# Check that we can read the h5 files from the command line
# This should not work
p = Popen(["h5ls", "%s/output.h5" % dn_tmp], stdout=PIPE, stderr=PIPE)
result = p.communicate()
assert "unable" in result[1]
# This should work
p = Popen(["h5ls", "%s/output_flushed.h5" % dn_tmp], stdout=PIPE, stderr=PIPE)
result = p.communicate()
assert "trajectory" in result[0]
finally: # Cleanup
f.close()
f_flushed.close()
shutil.rmtree(dn_tmp)
def test_diff_bsize():
ff = get_ff_water32()
select = ff.system.get_indexes('O')
diff = Diffusion(None, select=select, bsize=3, mult=2)
nve = VerletIntegrator(ff, 1.0 * femtosecond, hooks=diff)
nve.run(10)
assert diff.msdcounters[0] == 7
assert diff.msdcounters[1] == 2
def test_diff_bsize():
ff = get_ff_water32()
select = ff.system.get_indexes('O')
diff = Diffusion(None, select=select, bsize=3, mult=2)
nve = VerletIntegrator(ff, 1.0*femtosecond, hooks=diff)
nve.run(10)
assert diff.msdcounters[0] == 7
assert diff.msdcounters[1] == 2
def test_spectrum_online_weights():
# Setup a test FF
ff = get_ff_water32()
ff.system.set_standard_masses()
weights = np.array([ff.system.masses] * 3).T
spectrum = Spectrum(bsize=2, weights=weights)
nve = VerletIntegrator(ff, 1.0 * femtosecond, hooks=spectrum)
nve.run(5)
assert nve.counter == 5
def test_cg_5steps():
dof = CartesianDOF(get_ff_water32())
dof.check_delta()
opt = CGOptimizer(dof)
epot0 = opt.epot
opt.run(5)
epot1 = opt.epot
assert opt.counter == 5
assert epot1 < epot0
def test_cg_5steps_partial():
dof = CartesianDOF(get_ff_water32(), select=[0, 1, 2, 3, 4, 5])
dof.check_delta()
opt = CGOptimizer(dof)
epot0 = opt.epot
opt.run(5)
epot1 = opt.epot
assert opt.counter == 5
assert epot1 < epot0
def test_hdf5_start():
with h5.File('yaff.sampling.test.test_verlet.test_hdf5_start.h5', driver='core', backing_store=False) as f:
hdf5 = HDF5Writer(f, start=2)
nve = VerletIntegrator(get_ff_water32(), 1.0*femtosecond, hooks=hdf5)
nve.run(5)
assert nve.counter == 5
check_hdf5_common(hdf5.f)
assert get_last_trajectory_row(f['trajectory']) == 4
assert f['trajectory/counter'][3] == 5
def test_qn_5steps_initial_hessian():
ff = get_ff_water32()
hessian = estimate_cart_hessian(ff)
opt = QNOptimizer(CartesianDOF(ff), hessian0=hessian)
epot0 = opt.epot
opt.run(5)
epot1 = opt.epot
assert opt.counter == 5
assert epot1 < epot0
def test_spectrum_online_weights():
# Setup a test FF
ff = get_ff_water32()
ff.system.set_standard_masses()
weights = np.array([ff.system.masses]*3).T
spectrum = Spectrum(bsize=2, weights=weights)
nve = VerletIntegrator(ff, 1.0*femtosecond, hooks=spectrum)
nve.run(5)
assert nve.counter == 5
def test_cg_iso_cell_5steps():
dof = IsoCellDOF(get_ff_water32())
dof.check_delta
opt = CGOptimizer(dof)
epot0 = opt.epot
opt.run(5)
epot1 = opt.epot
assert opt.counter == 5
assert epot1 < epot0
def test_cg_iso_cell_5steps():
dof = IsoCellDOF(get_ff_water32())
dof.check_delta
opt = CGOptimizer(dof)
epot0 = opt.epot
opt.run(5)
epot1 = opt.epot
assert opt.counter == 5
assert epot1 < epot0
def test_cg_5steps_partial():
dof = CartesianDOF(get_ff_water32(), select=[0, 1, 2, 3, 4, 5])
dof.check_delta()
opt = CGOptimizer(dof)
epot0 = opt.epot
opt.run(5)
epot1 = opt.epot
assert opt.counter == 5
assert epot1 < epot0
def test_cg_5steps():
dof = CartesianDOF(get_ff_water32())
dof.check_delta()
opt = CGOptimizer(dof)
epot0 = opt.epot
opt.run(5)
epot1 = opt.epot
assert opt.counter == 5
assert epot1 < epot0
def test_qn_5steps_initial_hessian():
ff = get_ff_water32()
hessian = estimate_cart_hessian(ff)
opt = QNOptimizer(CartesianDOF(ff), hessian0=hessian)
epot0 = opt.epot
opt.run(5)
epot1 = opt.epot
assert opt.counter == 5
assert epot1 < epot0
def test_cg_hdf5():
with h5.File(__name__ + '.test_cg_hdf5.h5', driver='core', backing_store=False) as f:
hdf5 = HDF5Writer(f)
opt = CGOptimizer(CartesianDOF(get_ff_water32()), hooks=hdf5)
opt.run(15)
assert opt.counter == 15
check_hdf5_common(hdf5.f)
assert get_last_trajectory_row(f['trajectory']) == 16
assert f['trajectory/counter'][15] == 15
def test_rdf2_online_blind():
# Setup a test FF and run simulation without any HDF5 file
ff = get_ff_water32()
select0 = ff.system.get_indexes('O')
select1 = ff.system.get_indexes('H')
rdf = RDF(4.5*angstrom, 0.1*angstrom, select0=select0, select1=select1)
nve = VerletIntegrator(ff, 1.0*femtosecond, hooks=rdf)
nve.run(5)
assert nve.counter == 5
assert rdf.nsample == 6
def test_rdf2_online_blind():
# Setup a test FF and run simulation without any HDF5 file
ff = get_ff_water32()
select0 = ff.system.get_indexes('O')
select1 = ff.system.get_indexes('H')
rdf = RDF(4.5*angstrom, 0.1*angstrom, select0=select0, select1=select1)
nve = VerletIntegrator(ff, 1.0*femtosecond, hooks=rdf)
nve.run(5)
assert nve.counter == 5
assert rdf.nsample == 6
def test_cg_until_converged():
opt = CGOptimizer(CartesianDOF(get_ff_water32(), gpos_rms=1e-1, dpos_rms=None))
assert opt.dof.th_gpos_rms == 1e-1
assert opt.dof.th_dpos_rms is None
opt.run()
assert opt.dof.conv_count == 0
assert opt.dof.conv_val < 1
assert opt.dof.conv_worst.startswith('gpos_')
assert opt.dof.gpos_max < 1e-1*3
assert opt.dof.gpos_rms < 1e-1
def test_cg_hdf5():
with h5.File(__name__ + '.test_cg_hdf5.h5',
driver='core',
backing_store=False) as f:
hdf5 = HDF5Writer(f)
opt = CGOptimizer(CartesianDOF(get_ff_water32()), hooks=hdf5)
opt.run(15)
assert opt.counter == 15
check_hdf5_common(hdf5.f)
assert get_last_trajectory_row(f['trajectory']) == 16
assert f['trajectory/counter'][15] == 15
def test_cg_until_converged():
opt = CGOptimizer(
CartesianDOF(get_ff_water32(), gpos_rms=1e-1, dpos_rms=None))
assert opt.dof.th_gpos_rms == 1e-1
assert opt.dof.th_dpos_rms is None
opt.run()
assert opt.dof.conv_count == 0
assert opt.dof.conv_val < 1
assert opt.dof.conv_worst.startswith('gpos_')
assert opt.dof.gpos_max < 1e-1 * 3
assert opt.dof.gpos_rms < 1e-1
def test_xyz_select():
with tmpdir(__name__, 'test_xyz_select') as dn:
fn_xyz = os.path.join(dn, 'foobar.xyz')
xyz = XYZWriter(fn_xyz, select=[0,1,2])
nve = VerletIntegrator(get_ff_water32(), 1.0*femtosecond, hooks=[xyz])
nve.run(15)
assert os.path.isfile(fn_xyz)
assert nve.counter == 15
## Ugly hack to make tests pass on Windows. The root cause is that the SliceReader
## in molmod.io.common is poorly written.
xyz.xyz_writer._auto_close = False
xyz.xyz_writer._f.close()
def test_hdf5_step():
f = h5.File('yaff.sampling.test.test_verlet.test_hdf5_step.h5', driver='core', backing_store=False)
try:
hdf5 = HDF5Writer(f, step=2)
nve = VerletIntegrator(get_ff_water32(), 1.0*femtosecond, hooks=hdf5)
nve.run(5)
assert nve.counter == 5
check_hdf5_common(hdf5.f)
assert get_last_trajectory_row(f['trajectory']) == 3
assert f['trajectory/counter'][2] == 4
finally:
f.close()
def run_nve_water32(suffix, prefix):
# Work in a temporary directory
with tmpdir(suffix, prefix) as dn_tmp:
# Setup a test FF
ff = get_ff_water32()
# Run a test simulation
with h5.File('%s/output.h5' % dn_tmp) as f:
hdf5 = HDF5Writer(f)
nve = VerletIntegrator(ff, 1.0*femtosecond, hooks=hdf5)
nve.run(5)
assert nve.counter == 5
yield dn_tmp, nve, f
def get_opt_water32():
# Make a temporary directory
dn_tmp = tempfile.mkdtemp(suffix='yaff', prefix='opt_water_32')
# Setup a test FF
ff = get_ff_water32()
# Run a test simulation
f = h5.File('%s/output.h5' % dn_tmp)
hdf5 = HDF5Writer(f)
opt = CGOptimizer(FullCellDOF(ff), hooks=hdf5)
opt.run(5)
assert opt.counter == 5
return dn_tmp, opt, hdf5.f
def run_opt_water32(suffix, prefix):
# Work in a temporary directory
with tmpdir(suffix, prefix) as dn_tmp:
# Setup a test FF
ff = get_ff_water32()
# Run a test simulation
with h5.File('%s/output.h5' % dn_tmp) as f:
hdf5 = HDF5Writer(f)
opt = CGOptimizer(FullCellDOF(ff), hooks=hdf5)
opt.run(5)
assert opt.counter == 5
yield dn_tmp, opt, f
def run_opt_water32(suffix, prefix):
# Work in a temporary directory
with tmpdir(suffix, prefix) as dn_tmp:
# Setup a test FF
ff = get_ff_water32()
# Run a test simulation
with h5.File('%s/output.h5' % dn_tmp) as f:
hdf5 = HDF5Writer(f)
opt = CGOptimizer(FullCellDOF(ff), hooks=hdf5)
opt.run(5)
assert opt.counter == 5
yield dn_tmp, opt, f
def get_nve_water32():
# Make a temporary directory
dn_tmp = tempfile.mkdtemp(suffix='yaff', prefix='nve_water_32')
# Setup a test FF
ff = get_ff_water32()
# Run a test simulation
f = h5.File('%s/output.h5' % dn_tmp)
hdf5 = HDF5Writer(f)
nve = VerletIntegrator(ff, 1.0*femtosecond, hooks=hdf5)
nve.run(5)
assert nve.counter == 5
return dn_tmp, nve, hdf5.f
def test_cg_hdf5():
f = h5.File('yaff.sampling.test.test_opt.test_cg_hdf5.h5', driver='core', backing_store=False)
try:
hdf5 = HDF5Writer(f)
opt = CGOptimizer(CartesianDOF(get_ff_water32()), hooks=hdf5)
opt.run(15)
assert opt.counter == 15
check_hdf5_common(hdf5.f)
assert get_last_trajectory_row(f['trajectory']) == 16
assert f['trajectory/counter'][15] == 15
finally:
f.close()
def run_nve_water32(suffix, prefix):
# Work in a temporary directory
with tmpdir(suffix, prefix) as dn_tmp:
# Setup a test FF
ff = get_ff_water32()
# Run a test simulation
with h5.File('%s/output.h5' % dn_tmp) as f:
hdf5 = HDF5Writer(f)
nve = VerletIntegrator(ff, 1.0 * femtosecond, hooks=hdf5)
nve.run(5)
assert nve.counter == 5
yield dn_tmp, nve, f
def run_nvt_water32(suffix, prefix):
# Work in a temporary directory
with tmpdir(suffix, prefix) as dn_tmp:
# Setup a test FF
ff = get_ff_water32()
# Run a test simulation
with h5.File('%s/output.h5' % dn_tmp) as f:
hdf5 = HDF5Writer(f)
thermostat = LangevinThermostat(temp=300)
nvt = VerletIntegrator(ff, 1.0*femtosecond, hooks=[hdf5, thermostat])
nvt.run(5)
assert nvt.counter == 5
yield dn_tmp, nvt, f
def get_nvt_water32():
# Make a temporary directory
dn_tmp = tempfile.mkdtemp(suffix='yaff', prefix='nvt_water_32')
# Setup a test FF
ff = get_ff_water32()
# Run a test simulation
f = h5.File('%s/output.h5' % dn_tmp)
hdf5 = HDF5Writer(f)
thermostat = LangevinThermostat(temp=300)
nvt = VerletIntegrator(ff, 1.0*femtosecond, hooks=[hdf5, thermostat])
nvt.run(5)
assert nvt.counter == 5
return dn_tmp, nvt, hdf5.f
def test_cg_hdf5():
f = h5.File('yaff.sampling.test.test_opt.test_cg_hdf5.h5',
driver='core',
backing_store=False)
try:
hdf5 = HDF5Writer(f)
opt = CGOptimizer(CartesianDOF(get_ff_water32()), hooks=hdf5)
opt.run(15)
assert opt.counter == 15
check_hdf5_common(hdf5.f)
assert get_last_trajectory_row(f['trajectory']) == 16
assert f['trajectory/counter'][15] == 15
finally:
f.close()
def test_hdf5():
f = h5.File('yaff.sampling.test.test_verlet.test_hdf5.h5',
driver='core',
backing_store=False)
try:
hdf5 = HDF5Writer(f)
nve = VerletIntegrator(get_ff_water32(), 1.0 * femtosecond, hooks=hdf5)
nve.run(15)
assert nve.counter == 15
check_hdf5_common(hdf5.f)
assert get_last_trajectory_row(f['trajectory']) == 16
assert f['trajectory/counter'][15] == 15
finally:
f.close()
def run_nvt_water32(suffix, prefix):
# Work in a temporary directory
with tmpdir(suffix, prefix) as dn_tmp:
# Setup a test FF
ff = get_ff_water32()
# Run a test simulation
with h5.File('%s/output.h5' % dn_tmp) as f:
hdf5 = HDF5Writer(f)
thermostat = LangevinThermostat(temp=300)
nvt = VerletIntegrator(ff,
1.0 * femtosecond,
hooks=[hdf5, thermostat])
nvt.run(5)
assert nvt.counter == 5
yield dn_tmp, nvt, f
def test_rdf1_online():
# Setup a test FF
ff = get_ff_water32()
# Run a test simulation
with h5.File(__name__ + 'test_rdf1_online.h5', driver='core', backing_store=False) as f:
hdf5 = HDF5Writer(f)
select = ff.system.get_indexes('O')
rdf0 = RDF(4.5*angstrom, 0.1*angstrom, f, select0=select)
nve = VerletIntegrator(ff, 1.0*femtosecond, hooks=[hdf5, rdf0])
nve.run(5)
assert nve.counter == 5
# Also run an off-line rdf and compare
rdf1 = RDF(4.5*angstrom, 0.1*angstrom, f, select0=select)
assert rdf0.nsample == rdf1.nsample
assert abs(rdf0.d - rdf1.d).max() < 1e-10
assert abs(rdf0.rdf - rdf1.rdf).max() < 1e-10
def test_rdf1_online():
# Setup a test FF
ff = get_ff_water32()
# Run a test simulation
with h5.File(__name__ + 'test_rdf1_online.h5', driver='core', backing_store=False) as f:
hdf5 = HDF5Writer(f)
select = ff.system.get_indexes('O')
rdf0 = RDF(4.5*angstrom, 0.1*angstrom, f, select0=select)
nve = VerletIntegrator(ff, 1.0*femtosecond, hooks=[hdf5, rdf0])
nve.run(5)
assert nve.counter == 5
# Also run an off-line rdf and compare
rdf1 = RDF(4.5*angstrom, 0.1*angstrom, f, select0=select)
assert rdf0.nsample == rdf1.nsample
assert abs(rdf0.d - rdf1.d).max() < 1e-10
assert abs(rdf0.rdf - rdf1.rdf).max() < 1e-10
def test_h5_flush():
# Test if we can read intermediate hdf5 files that are flushed.
# Make a temporary directory
dn_tmp = tempfile.mkdtemp(suffix='yaff', prefix='nve_water_32')
try:
# Setup a test FF
ff = get_ff_water32()
# Make two different hdf5 hooks
with h5.File('%s/output.h5' % dn_tmp) as f, \
h5.File('%s/output_flushed.h5' % dn_tmp) as f_flushed:
hdf5 = HDF5Writer(f)
hdf5_flushed = HDF5Writer(f_flushed, flush=4)
# Run a test simulation
nve = VerletIntegrator(ff,
1.0 * femtosecond,
hooks=[hdf5, hdf5_flushed])
nve.run(5)
# Actual tests
# 1) Check that we can't read the trajectory group in the h5 file without flushing.
# This must be done in a subprocess, otherwise the HDF5 library will fake
# flushing while it does not really flush to disk.
command = [
'python', '-c',
'import h5py as h5; f = h5.File(\'%s/output.h5\', '
r'); f.close()' % dn_tmp
]
p = Popen(command, stdout=PIPE, stderr=STDOUT)
output = p.communicate()[0]
assert 'IOError' in output
assert p.returncode != 0
# 2) This should work in a subprocess.
command = [
'python', '-c',
'import h5py as h5; f = h5.File(\'%s/output_flushed.h5\', '
r'); f.close()' % dn_tmp
]
p = Popen(command, stdout=PIPE, stderr=STDOUT)
output = p.communicate()[0]
assert 'IOError' not in output
assert p.returncode == 0
finally:
shutil.rmtree(dn_tmp)
def test_spectrum_online():
for bsize in 2, 4, 5:
# Setup a test FF
ff = get_ff_water32()
# Run a test simulation
with h5.File('yaff.analysis.test.test_spectrum.test_spectrum_online_%i.h5' % bsize, driver='core', backing_store=False) as f:
hdf5 = HDF5Writer(f)
spectrum0 = Spectrum(f, bsize=bsize)
nve = VerletIntegrator(ff, 1.0*femtosecond, hooks=[hdf5, spectrum0])
nve.run(5)
assert nve.counter == 5
# Also run an off-line spectrum and compare
spectrum1 = Spectrum(f, bsize=bsize)
assert abs(spectrum0.timestep - spectrum1.timestep) < 1e-10
assert abs(spectrum0.amps - spectrum1.amps).max() < 1e-10
assert abs(spectrum0.freqs - spectrum1.freqs).max() < 1e-10
assert abs(spectrum0.ac - spectrum1.ac).max() < 1e-10
assert abs(spectrum0.time - spectrum1.time).max() < 1e-10
assert f['trajectory/vel_spectrum'].attrs['nfft'] == 3*3*32*(6//bsize)
def test_diff_online():
# Setup a test FF
ff = get_ff_water32()
# Run a test simulation
with h5.File('yaff.analysis.test.test_diffusion.test_diff_online.h5', driver='core', backing_store=False) as f:
hdf5 = HDF5Writer(f)
select = ff.system.get_indexes('O')
diff0 = Diffusion(f, select=select)
nve = VerletIntegrator(ff, 1.0*femtosecond, hooks=[hdf5, diff0])
nve.run(5)
assert nve.counter == 5
# Also run an off-line rdf and compare
diff1 = Diffusion(f, select=select)
assert abs(diff0.A - diff1.A) < 1e-10
assert abs(diff0.B - diff1.B) < 1e-10
assert abs(diff0.time - diff1.time).max() < 1e-10
assert abs(diff0.msds - diff1.msds).max() < 1e-10
assert abs(diff0.msdsums - diff1.msdsums).max() < 1e-10
assert abs(diff0.msdcounters - diff1.msdcounters).max() < 1e-10
def test_rdf2_online():
# Setup a test FF
ff = get_ff_water32()
# Run a test simulation
f = h5.File('yaff.analysis.test.test_rdf.test_rdf2_online.h5', driver='core', backing_store=False)
try:
hdf5 = HDF5Writer(f)
select0 = ff.system.get_indexes('O')
select1 = ff.system.get_indexes('H')
rdf0 = RDF(4.5*angstrom, 0.1*angstrom, f, select0=select0, select1=select1)
nve = VerletIntegrator(ff, 1.0*femtosecond, hooks=[hdf5, rdf0])
nve.run(5)
assert nve.counter == 5
# Also run an off-line rdf and compare
rdf1 = RDF(4.5*angstrom, 0.1*angstrom, f, select0=select0, select1=select1)
assert rdf0.nsample == rdf1.nsample
assert abs(rdf0.d - rdf1.d).max() < 1e-10
assert abs(rdf0.rdf - rdf1.rdf).max() < 1e-10
finally:
f.close()
def test_diff_online():
# Setup a test FF
ff = get_ff_water32()
# Run a test simulation
with h5.File('yaff.analysis.test.test_diffusion.test_diff_online.h5',
driver='core',
backing_store=False) as f:
hdf5 = HDF5Writer(f)
select = ff.system.get_indexes('O')
diff0 = Diffusion(f, select=select)
nve = VerletIntegrator(ff, 1.0 * femtosecond, hooks=[hdf5, diff0])
nve.run(5)
assert nve.counter == 5
# Also run an off-line rdf and compare
diff1 = Diffusion(f, select=select)
assert abs(diff0.A - diff1.A) < 1e-10
assert abs(diff0.B - diff1.B) < 1e-10
assert abs(diff0.time - diff1.time).max() < 1e-10
assert abs(diff0.msds - diff1.msds).max() < 1e-10
assert abs(diff0.msdsums - diff1.msdsums).max() < 1e-10
assert abs(diff0.msdcounters - diff1.msdcounters).max() < 1e-10
def test_h5_flush():
# Test if we can read intermediate hdf5 files that are flushed.
# Make a temporary directory
dn_tmp = tempfile.mkdtemp(suffix='yaff', prefix='nve_water_32')
try:
# Setup a test FF
ff = get_ff_water32()
# Make two different hdf5 hooks
with h5.File('%s/output.h5' % dn_tmp) as f, \
h5.File('%s/output_flushed.h5' % dn_tmp) as f_flushed:
hdf5 = HDF5Writer(f)
hdf5_flushed = HDF5Writer(f_flushed, flush=4)
# Run a test simulation
nve = VerletIntegrator(ff, 1.0*femtosecond, hooks=[hdf5,hdf5_flushed])
nve.run(5)
# Actual tests
# 1) Check that we can't read the trajectory group in the h5 file without flushing.
# This must be done in a subprocess, otherwise the HDF5 library will fake
# flushing while it does not really flush to disk.
command = ['python', '-c', 'import h5py as h5; f = h5.File(\'%s/output.h5\', 'r'); f.close()' % dn_tmp]
p = Popen(command, stdout=PIPE, stderr=STDOUT)
output = p.communicate()[0]
assert 'IOError' in output
assert p.returncode != 0
# 2) This should work in a subprocess.
command = ['python', '-c', 'import h5py as h5; f = h5.File(\'%s/output_flushed.h5\', 'r'); f.close()' % dn_tmp]
p = Popen(command, stdout=PIPE, stderr=STDOUT)
output = p.communicate()[0]
assert 'IOError' not in output
assert p.returncode == 0
finally:
shutil.rmtree(dn_tmp)
def test_amb():
nve = VerletIntegrator(get_ff_water32(), 1.0*femtosecond, hooks=TBCombination(McDonaldBarostat(300, 1*bar), AndersenThermostat(300)))
nve.run(5)
assert nve.counter == 5
def test_amb():
nve = VerletIntegrator(get_ff_water32(), 1.0 * femtosecond, hooks=AndersenMcDonaldBarostat(300, 1 * bar))
nve.run(5)
assert nve.counter == 5
def test_elastic_water32():
ff = get_ff_water32()
elastic = estimate_elastic(ff, do_frozen=True)
assert elastic.shape == (6, 6)
def test_hessian_partial_water32():
ff = get_ff_water32()
select = [1, 2, 3, 14, 15, 16]
hessian = estimate_cart_hessian(ff, select=select)
assert hessian.shape == (18, 18)