def test_CVRangeVolumePeriodicSet(self):
mins = [-1.5, -3.5]
maxs = [2.0, 4.0]
lv0 = volume.PeriodicCVDefinedVolume(op_id, mins[0], maxs[0])
lv1 = volume.PeriodicCVDefinedVolume(op_id, mins[1], maxs[1])
assert_equal([lv0, lv1],
volume.VolumeFactory.CVRangeVolumePeriodicSet(
op_id, mins, maxs))
def test_periodic_xor_combos(self):
assert self.pvolA ^ self.pvolA_ == volume.FullVolume()
assert self.pvolA ^ self.pvolA == volume.EmptyVolume()
assert (self.pvolE ^ self.pvolD == volume.UnionVolume(
volume.PeriodicCVDefinedVolume(op_id, -150, -100),
volume.PeriodicCVDefinedVolume(op_id, 100, 150)))
assert self.pvolB ^ self.pvolC == self.pvolB | self.pvolC
assert (self.pvolB ^ self.pvolD == volume.PeriodicCVDefinedVolume(
op_id, -100, 50))
def test_periodic_xor_combos(self):
assert_equal(self.pvolA ^ self.pvolA_, volume.FullVolume())
assert_equal(self.pvolA ^ self.pvolA, volume.EmptyVolume())
assert_equal(self.pvolE ^ self.pvolD,
volume.UnionVolume(
volume.PeriodicCVDefinedVolume(op_id, -150, -100),
volume.PeriodicCVDefinedVolume(op_id, 100, 150)))
assert_equal(self.pvolB ^ self.pvolC, self.pvolB | self.pvolC)
assert_equal(self.pvolB ^ self.pvolD,
volume.PeriodicCVDefinedVolume(op_id, -100, 50))
def test_periodic_sub_combos(self):
assert self.pvolA - self.pvolA_ is self.pvolA
assert self.pvolA_ - self.pvolA is self.pvolA_
assert (self.pvolD - self.pvolA == volume.PeriodicCVDefinedVolume(
op_id, 75, 100))
assert (self.pvolD - self.pvolA)(80) is True
assert (self.pvolD - self.pvolA)(50) is False
assert self.pvolB - self.pvolC is self.pvolB
assert self.pvolA - self.pvolA == volume.EmptyVolume()
assert (self.pvolE - self.pvolD == volume.UnionVolume(
volume.PeriodicCVDefinedVolume(op_id, -150, -100),
volume.PeriodicCVDefinedVolume(op_id, 100, 150)))
assert (self.pvolE - self.pvolA_ == volume.PeriodicCVDefinedVolume(
op_id, -100, 75))
def test_periodic_sub_combos(self):
assert_equal(self.pvolA - self.pvolA_, self.pvolA)
assert_equal(self.pvolA_ - self.pvolA, self.pvolA_)
assert_equal(self.pvolD - self.pvolA,
volume.PeriodicCVDefinedVolume(op_id, 75, 100))
assert_equal((self.pvolD - self.pvolA)(80), True)
assert_equal((self.pvolD - self.pvolA)(50), False)
assert_equal(self.pvolB - self.pvolC, self.pvolB)
assert_equal(self.pvolA - self.pvolA, volume.EmptyVolume())
assert_equal(self.pvolE - self.pvolD,
volume.UnionVolume(
volume.PeriodicCVDefinedVolume(op_id, -150, -100),
volume.PeriodicCVDefinedVolume(op_id, 100, 150)))
assert_equal(self.pvolE - self.pvolA_,
volume.PeriodicCVDefinedVolume(op_id, -100, 75))
def test_thru_pbc_to_image(self):
'''max in next periodic domain'''
lambda_min = 70
lambda_max = 210
vol = volume.PeriodicCVDefinedVolume(op_id, lambda_min, lambda_max,
-180, 180)
assert_equal(vol.lambda_max, -150)
def test_volume_equals_bounds(self):
'''max-min == pbc_range allows all points'''
vol = volume.PeriodicCVDefinedVolume(op_id, 0, 360, -180, 180)
assert_equal(vol.__str__(),
"{x|(Id(x) - -180) % 360 + -180 in [-180, 180]}")
assert_equal(True, vol(0))
assert_equal(True, vol(360))
assert_equal(True, vol(-180))
assert_equal(True, vol(180))
def test_periodic_and_combos(self):
assert ((self.pvolA & self.pvolB) == volume.PeriodicCVDefinedVolume(
op_id, 50, 75))
assert (self.pvolA & self.pvolB)(60) is True
assert (self.pvolA & self.pvolB)(80) is False
assert (self.pvolB & self.pvolC) == volume.EmptyVolume()
assert (self.pvolC & self.pvolB) == volume.EmptyVolume()
assert (self.pvolA & self.pvolA) is self.pvolA
assert (self.pvolA & self.pvolA_) == volume.EmptyVolume()
assert (self.pvolE & self.pvolD) == self.pvolD
# go to special case for cyclic permutation
assert (self.pvolB & self.pvolD) == self.pvolB
# go to special case
assert ((self.pvolE & self.pvolA_) == volume.UnionVolume(
volume.PeriodicCVDefinedVolume(op_id, -150, -100),
volume.PeriodicCVDefinedVolume(op_id, 75, 150)))
# go to super if needed
assert type(self.pvolA & volA) is volume.IntersectionVolume
def test_periodic_and_combos(self):
assert_equal((self.pvolA & self.pvolB),
volume.PeriodicCVDefinedVolume(op_id, 50, 75))
assert_equal((self.pvolA & self.pvolB)(60), True)
assert_equal((self.pvolA & self.pvolB)(80), False)
assert_equal((self.pvolB & self.pvolC), volume.EmptyVolume())
assert_equal((self.pvolC & self.pvolB), volume.EmptyVolume())
assert_is((self.pvolA & self.pvolA), self.pvolA)
assert_equal((self.pvolA & self.pvolA_), volume.EmptyVolume())
assert_equal((self.pvolE & self.pvolD), self.pvolD)
# go to special case for cyclic permutation
assert_equal((self.pvolB & self.pvolD), self.pvolB)
# go to special case
assert_equal((self.pvolE & self.pvolA_),
volume.UnionVolume(
volume.PeriodicCVDefinedVolume(op_id, -150, -100),
volume.PeriodicCVDefinedVolume(op_id, 75, 150)))
# go to super if needed
assert_equal(type(self.pvolA & volA), volume.IntersectionVolume)
def setup(self):
self.pvolA = volume.PeriodicCVDefinedVolume(op_id, -100, 75)
self.pvolA_ = volume.PeriodicCVDefinedVolume(op_id, 75, -100)
self.pvolB = volume.PeriodicCVDefinedVolume(op_id, 50, 100)
self.pvolC = volume.PeriodicCVDefinedVolume(op_id, -100, -50)
self.pvolD = volume.PeriodicCVDefinedVolume(op_id, -100, 100)
self.pvolE = volume.PeriodicCVDefinedVolume(op_id, -150, 150)
def test_wrapped_volume_implicit(self):
"""max<min, no periodic domain defined"""
lambda_min = 70
lambda_max = -150
vol = volume.PeriodicCVDefinedVolume(op_id, lambda_min, lambda_max)
# out of state
assert_equal(False, vol(lambda_min - 1.0))
assert_equal(False, vol(lambda_max + 1.0))
# in state
assert_equal(True, vol(lambda_min + 1.0))
assert_equal(True, vol(lambda_max - 1.0))
# border
assert_equal(True, vol(lambda_min))
assert_equal(True, vol(lambda_max))
def test_normal_implicit(self):
"""min<max, no periodic domain defined"""
lambda_min = -150
lambda_max = 70
vol = volume.PeriodicCVDefinedVolume(op_id, lambda_min, lambda_max)
assert_equal(vol.__str__(), "{x|Id(x) [periodic] in [-150, 70]}")
# out of state
assert_equal(False, vol(lambda_min - 1.0))
assert_equal(False, vol(lambda_max + 1.0))
# in state
assert_equal(True, vol(lambda_min + 1.0))
assert_equal(True, vol(lambda_max - 1.0))
# border
assert_equal(True, vol(lambda_min))
assert_equal(True, vol(lambda_max))
def test_normal_implicit(self):
"""min<max, no periodic domain defined"""
lambda_min = -150
lambda_max = 70
vol = volume.PeriodicCVDefinedVolume(op_id, lambda_min, lambda_max)
assert vol.__str__() == "{x|Id(x) [periodic] in [-150, 70]}"
# out of state
assert vol(lambda_min - 1.0) is False
assert vol(lambda_max + 1.0) is False
# in state
assert vol(lambda_min + 1.0) is True
assert vol(lambda_max - 1.0) is True
# border
assert vol(lambda_min) is True
assert vol(lambda_max) is False
def test_unit_support(self):
u = unit
vol = volume.CVDefinedVolume(op_id, -0.5 * u.nanometers,
0.25 * u.nanometers)
assert vol(-0.25 * u.nanometers)
assert not vol(-0.75 * u.nanometers)
vol = volume.PeriodicCVDefinedVolume(op_id, -30 * u.nanometers,
90 * u.nanometers,
-180 * u.nanometers,
180 * u.nanometers)
assert vol(50 * u.nanometers)
assert not vol(-70 * u.nanometers)
def test_unit_support(self):
import simtk.unit as u
vol = volume.CVDefinedVolume(op_id, -0.5 * u.nanometers,
0.25 * u.nanometers)
assert (vol(-0.25 * u.nanometers))
assert (not vol(-0.75 * u.nanometers))
vol = volume.PeriodicCVDefinedVolume(op_id, -30 * u.nanometers,
90 * u.nanometers,
-180 * u.nanometers,
180 * u.nanometers)
assert (vol(50 * u.nanometers))
assert (not vol(-70 * u.nanometers))
def test_unit_support(self):
if not paths.integration_tools.HAS_SIMTK_UNIT:
raise SkipTest
u = unit
vol = volume.CVDefinedVolume(op_id, -0.5 * u.nanometers,
0.25 * u.nanometers)
assert (vol(-0.25 * u.nanometers))
assert (not vol(-0.75 * u.nanometers))
vol = volume.PeriodicCVDefinedVolume(op_id, -30 * u.nanometers,
90 * u.nanometers,
-180 * u.nanometers,
180 * u.nanometers)
assert (vol(50 * u.nanometers))
assert (not vol(-70 * u.nanometers))
def test_wrapped_volume(self):
"""max<min and both within periodic domain"""
lambda_min = 70
lambda_max = -150
vol = volume.PeriodicCVDefinedVolume(op_id, lambda_min, lambda_max,
-180, 180)
assert vol.__str__() == ("{x|(Id(x) - -180) % 360 + -180 "
"in [-180, -150] union [70, 180]}")
for periodic_image in [-1, 0, 1]:
# out of state
assert vol(lambda_min - 1.0 + 360 * periodic_image) is False
assert vol(lambda_max + 1.0 + 360 * periodic_image) is False
# in state
assert vol(lambda_min + 1.0 + 360 * periodic_image) is True
assert vol(lambda_max - 1.0 + 360 * periodic_image) is True
# border
assert vol(lambda_min + 360 * periodic_image) is True
assert vol(lambda_max + 360 * periodic_image) is False
def test_normal(self):
"""min<max and both within periodic domain"""
lambda_min = -150
lambda_max = 70
vol = volume.PeriodicCVDefinedVolume(op_id, lambda_min, lambda_max,
-180, 180)
assert_equal(vol._period_len, 360)
assert_equal(vol._period_shift, -180)
assert_equal(vol.__str__(),
"{x|(Id(x) - -180) % 360 + -180 in [-150, 70]}")
for periodic_image in [-1, 0, 1]:
# out of state
assert_equal(False, vol(lambda_min - 1.0 + 360 * periodic_image))
assert_equal(False, vol(lambda_max + 1.0 + 360 * periodic_image))
# in state
assert_equal(True, vol(lambda_min + 1.0 + 360 * periodic_image))
assert_equal(True, vol(lambda_max - 1.0 + 360 * periodic_image))
# border
assert_equal(True, vol(lambda_min + 360 * periodic_image))
assert_equal(False, vol(lambda_max + 360 * periodic_image))
def test_volume_bigger_than_bounds(self):
'''max-min > pbc_range raises Exception'''
with pytest.raises(Exception, match='Range of volume'):
volume.PeriodicCVDefinedVolume(op_id, 90, 720, -180, 180)
def test_volume_bigger_than_bounds(self):
'''max-min > pbc_range raises Exception'''
vol = volume.PeriodicCVDefinedVolume(op_id, 90, 720, -180, 180)
