def test_wrap_partial_compound(self, level, compound, center, is_triclinic):
# get a pristine test universe:
u = UnWrapUniverse(is_triclinic=is_triclinic)
group = u.atoms
ref_wrapped_pos = u.wrapped_coords(compound, center)
# select topology level with one missing item and get expected result:
if level == 'atoms':
# first atom of molecule 12 missing
missing = group[[-8]]
group = group[:-8] + group[-7:]
ref_wrapped_pos = np.concatenate([ref_wrapped_pos[:-8],
ref_wrapped_pos[-7:]])
elif level == 'residues':
group = group.residues
# first residue of molecule 12 missing
missing = group[-2]
group = group[:-2] + group[[-1]]
ref_wrapped_pos = np.concatenate([ref_wrapped_pos[:-8],
ref_wrapped_pos[-4:]])
elif level == 'segments':
group = group.segments
# molecule 12 missing
missing = group[-1]
group = group[:-1]
ref_wrapped_pos = ref_wrapped_pos[:-8]
# store original positions of the missing item:
orig_pos = missing.atoms.positions
# first, do the wrapping out-of-place:
group.wrap(compound=compound, center=center, inplace=True)
# check for correct result:
assert_almost_equal(group.atoms.positions, ref_wrapped_pos,
decimal=self.precision)
# make sure the positions of the missing item are unchanged:
assert_array_equal(missing.atoms.positions, orig_pos)
def test_wrap_com_cog_difference(self, compound, is_triclinic):
# get a pristine test universe:
u = UnWrapUniverse(is_triclinic=is_triclinic)
# select molecule 5:
group = u.atoms[6:9]
# make first atom of molecule 5 much more heavy than the other two.
# That way, the whole molecule's center of geometry will still lie
# inside the first unit cell but its center of mass will lie outside
# the first unit cell in negative x-direction.
group.masses = [100.0, 1.0, 1.0]
# wrap with center='cog':
wrapped_pos_cog = group.wrap(compound=compound, center='cog',
inplace=False)
# get expected result:
ref_wrapped_pos = u.wrapped_coords(compound, 'cog')[6:9]
# check for correctness:
assert_almost_equal(wrapped_pos_cog, ref_wrapped_pos,
decimal=self.precision)
# wrap with center='com':
wrapped_pos_com = group.wrap(compound=compound, center='com',
inplace=False)
# assert that the com result is shifted with respect to the cog result
# by one box length in the x-direction:
shift = np.array([10.0, 0.0, 0.0], dtype=np.float32)
if compound == 'atoms':
# center argument must be ignored for compound='atoms':
shift[0] = 0.0
assert_almost_equal(wrapped_pos_cog, wrapped_pos_com - shift,
decimal=self.precision)
def test_wrap_zero_mass_exception_safety(self, level, compound):
# get a pristine test universe:
u = UnWrapUniverse()
# set masses of molecule 12 to zero:
u.atoms[39:47].masses = 0.0
# select group appropriate for compound:
if compound == 'group':
group = u.atoms[39:47] # molecule 12
else:
group = u.atoms
# select topology level:
if level == 'residues':
group = group.residues
elif level == 'segments':
group = group.segments
# store original positions:
orig_pos = group.atoms.positions
if compound == 'atoms':
# wrap() must not care about masses if compound == 'atoms':
group.wrap(compound=compound, center='com', inplace=True)
ref_wrapped_pos = u.wrapped_coords(compound, 'com')
assert_almost_equal(group.atoms.positions, ref_wrapped_pos,
decimal=self.precision)
else:
# try to wrap:
with pytest.raises(ValueError):
group.wrap(compound=compound, center='com', inplace=True)
# make sure atom positions are unchanged:
assert_array_equal(group.atoms.positions, orig_pos)
def test_unwrap_duplicates(self, level, compound, reference, is_triclinic):
# get a pristine test universe:
u = UnWrapUniverse(is_triclinic=is_triclinic)
# select molecule 12:
group = u.atoms[39:47]
# select the rest of the universe's atoms:
rest = u.atoms[:39]
# select topology level:
if level == 'residues':
group = group.residues
elif level == 'segments':
group = group.segments
# duplicate the group:
group += group
# store original positions of the rest:
orig_rest_pos = rest.positions
# get the expected result with duplicates:
ref_unwrapped_pos = u.unwrapped_coords(compound, reference)[39:47]
ref_unwrapped_pos = np.vstack((ref_unwrapped_pos, ref_unwrapped_pos))
# unwrap:
group.unwrap(compound=compound, reference=reference, inplace=True)
# check for correct result:
assert_almost_equal(group.atoms.positions,
ref_unwrapped_pos,
decimal=self.precision)
# check that the rest of the atoms are kept unmodified:
assert_array_equal(rest.positions, orig_rest_pos)
def test_wrap_duplicates(self, level, compound, center, is_triclinic):
# get a pristine test universe:
u = UnWrapUniverse(is_triclinic=is_triclinic)
# select molecule 12:
group = u.atoms[39:47]
# select the rest of the universe's atoms:
rest = u.atoms[:39]
# select topology level:
if level == 'residues':
group = group.residues
elif level == 'segments':
group = group.segments
# duplicate the group:
group += group
# store original positions of the rest:
orig_rest_pos = rest.positions
# get the expected result with duplicates:
if compound == 'group':
# reference positions of UnWrapUniverse are known to be incorrect
# for compound='group' if the group is not the entire system, so we
# have to correct for that:
ref_wrapped_pos = u.wrapped_coords('segments', center)[39:47]
else:
ref_wrapped_pos = u.wrapped_coords(compound, center)[39:47]
ref_wrapped_pos = np.vstack((ref_wrapped_pos, ref_wrapped_pos))
# wrap:
group.wrap(compound=compound, center=center, inplace=True)
# check for correct result:
assert_almost_equal(group.atoms.positions, ref_wrapped_pos,
decimal=self.precision)
# check that the rest of the atoms are kept unmodified:
assert_array_equal(rest.positions, orig_rest_pos)
def test_wrap_unwrap_cycle(self, level, compound, reference, is_triclinic):
# get a pristine test universe:
u = UnWrapUniverse(is_triclinic=is_triclinic)
# select group appropriate for compound:
if compound == 'group':
group = u.atoms[39:47] # molecule 12
elif compound == 'segments':
group = u.atoms[23:47] # molecules 10, 11, 12
else:
group = u.atoms
# select topology level:
if level == 'residues':
group = group.residues
elif level == 'segments':
group = group.segments
# wrap:
group.wrap()
# store original wrapped positions:
orig_wrapped_pos = group.atoms.positions
# unwrap:
group.unwrap(compound=compound, reference=reference, inplace=True)
# wrap again:
group.wrap()
# make sure wrapped atom positions are as before:
assert_almost_equal(group.atoms.positions,
orig_wrapped_pos,
decimal=self.precision)
def test_unwrap_partial_frags(self, compound, reference, is_triclinic):
# get a pristine test universe:
u = UnWrapUniverse(is_triclinic=is_triclinic)
# select group with one atom missing
group = u.atoms[39:46] # molecule 12 without its last atom
# store original position of last atom of molecule 12:
orig_pos = u.atoms[46].position
# get the expected result:
ref_unwrapped_pos = u.unwrapped_coords(compound, reference)[39:46]
# first, do the unwrapping out-of-place:
group.unwrap(compound=compound, reference=reference, inplace=True)
# check for correct result:
assert_almost_equal(group.positions,
ref_unwrapped_pos,
decimal=self.precision)
# make sure the position of molecule 12's last atom is unchanged:
assert_array_equal(u.atoms[46].position, orig_pos)
def test_accumulate_array_attribute_compounds(self, name, compound, level):
u = UnWrapUniverse()
group = getattr(u, level)
ref = [
np.ones((len(a), 2, 5)).sum(axis=0)
for a in group.atoms.groupby(name).values()
]
assert_equal(
group.accumulate(np.ones((len(group.atoms), 2, 5)),
compound=compound), ref)
def test_unwrap_pass(self, level, compound, reference, is_triclinic):
# get a pristine test universe:
u = UnWrapUniverse(is_triclinic=is_triclinic)
# select group appropriate for compound:
if compound == 'group':
group = u.atoms[39:47] # molecule 12
elif compound == 'segments':
group = u.atoms[23:47] # molecules 10, 11, 12
else:
group = u.atoms
# select topology level:
if level == 'residues':
group = group.residues
elif level == 'segments':
group = group.segments
# store original positions:
orig_pos = group.atoms.positions
# get the expected result:
ref_unwrapped_pos = u.unwrapped_coords(compound, reference)
if compound == 'group':
ref_unwrapped_pos = ref_unwrapped_pos[39:47] # molecule 12
elif compound == 'segments':
ref_unwrapped_pos = ref_unwrapped_pos[23:
47] # molecules 10, 11, 12
# first, do the unwrapping out-of-place:
unwrapped_pos = group.unwrap(compound=compound,
reference=reference,
inplace=False)
# check for correct result:
assert_almost_equal(unwrapped_pos,
ref_unwrapped_pos,
decimal=self.precision)
# make sure atom positions are unchanged:
assert_array_equal(group.atoms.positions, orig_pos)
# now, do the unwrapping inplace:
unwrapped_pos2 = group.unwrap(compound=compound,
reference=reference,
inplace=True)
# check that result is the same as for out-of-place computation:
assert_array_equal(unwrapped_pos, unwrapped_pos2)
# check that unwrapped positions are applied:
assert_array_equal(group.atoms.positions, unwrapped_pos)
def test_wrap_empty_group(self, level, compound, center, is_triclinic):
# get a pristine test universe:
u = UnWrapUniverse(is_triclinic=is_triclinic)
group = u.atoms[[]]
if level == 'residues':
group = group.residues
elif level == 'segments':
group = group.segments
group.wrap(compound=compound, center=center, inplace=True)
# check for correct (empty) result:
assert_array_equal(group.atoms.positions,
np.empty((0, 3), dtype=np.float32))
def test_unwrap_wrap_cycle(self, level, compound, center, is_triclinic):
# get a pristine test universe:
u = UnWrapUniverse(is_triclinic=is_triclinic)
# set wrapped reference coordinates:
u.atoms.positions = u.wrapped_coords('atoms', 'com')
group = u.atoms
# select topology level:
if level == 'residues':
group = group.residues
elif level == 'segments':
group = group.segments
# unwrap:
group.unwrap()
# store original unwrapped positions:
orig_unwrapped_pos = group.atoms.positions
# wrap:
group.wrap(compound=compound, center=center, inplace=True)
# unwrap again:
group.unwrap()
# make sure unwrapped atom positions are as before:
assert_almost_equal(group.atoms.positions, orig_unwrapped_pos,
decimal=self.precision)
def test_wrap_pass(self, level, compound, center, is_triclinic):
# get a pristine test universe:
u = UnWrapUniverse(is_triclinic=is_triclinic)
group = u.atoms
# select topology level:
if level == 'residues':
group = group.residues
elif level == 'segments':
group = group.segments
# store original positions:
orig_pos = group.atoms.positions
# get the expected result:
ref_wrapped_pos = u.wrapped_coords(compound, center)
# first, do the wrapping out-of-place:
wrapped_pos = group.wrap(compound=compound, center=center,
inplace=False)
# check for correct result:
assert_almost_equal(wrapped_pos, ref_wrapped_pos,
decimal=self.precision)
# make sure atom positions are unchanged:
assert_array_equal(group.atoms.positions, orig_pos)
# now, do the wrapping inplace:
wrapped_pos2 = group.wrap(compound=compound, center=center,
inplace=True)
# check that result is the same as for out-of-place computation:
assert_array_equal(wrapped_pos, wrapped_pos2)
# check that wrapped positions are applied:
assert_array_equal(group.atoms.positions, wrapped_pos)
# check that nobody messed with the reference positions,
# centers of compounds must lie within the primary unit cell:
if compound == 'atoms':
assert_in_box(group.atoms.positions, group.dimensions)
elif center == 'com':
compos = group.atoms.center_of_mass(pbc=False, compound=compound)
assert_in_box(compos, group.dimensions)
else:
cogpos = group.atoms.center_of_geometry(pbc=False,
compound=compound)
assert_in_box(cogpos, group.dimensions)
def test_wrap_no_molnums_exception_safety(self, level, compound, center):
# universe without bonds:
u = UnWrapUniverse(have_molnums=False)
group = u.atoms
# select topology level:
if level == 'residues':
group = group.residues
elif level == 'segments':
group = group.segments
if compound == 'molecules':
# store original positions:
orig_pos = group.atoms.positions
# must raise an exception for molecules
with pytest.raises(NoDataError):
group.wrap(compound=compound, center=center, inplace=True)
# make sure atom positions are unchanged:
assert_array_equal(group.atoms.positions, orig_pos)
else:
# must not care about molnums if compound != 'molecules'
group.wrap(compound=compound, center=center, inplace=True)
ref_wrapped_pos = u.wrapped_coords(compound, center)
assert_almost_equal(group.atoms.positions, ref_wrapped_pos,
decimal=self.precision)
def test_unwrap_no_masses_exception_safety(self, level, compound):
# universe without masses:
u = UnWrapUniverse(have_masses=False)
group = u.atoms
# select topology level:
if level == 'residues':
group = group.residues
elif level == 'segments':
group = group.segments
if compound == 'atoms':
# wrap() must not care about mass presence if compound == 'atoms':
group.wrap(compound=compound, center='com', inplace=True)
ref_wrapped_pos = u.wrapped_coords(compound, 'com')
assert_almost_equal(group.atoms.positions, ref_wrapped_pos,
decimal=self.precision)
else:
# store original positions:
orig_pos = group.atoms.positions
# try to wrap:
with pytest.raises(NoDataError):
group.wrap(compound=compound, center='com', inplace=True)
# make sure atom positions are unchanged:
assert_array_equal(group.atoms.positions, orig_pos)
def test_wrap_wrong_center_exception_safety(self, level, compound):
# get a pristine test universe:
u = UnWrapUniverse()
group = u.atoms
# select topology level:
if level == 'residues':
group = group.residues
elif level == 'segments':
group = group.segments
# store original positions:
orig_pos = group.atoms.positions
if compound == 'atoms':
# wrap() must ignore the center argument if compound == 'atoms':
group.wrap(compound=compound, center='com', inplace=True)
ref_wrapped_pos = u.wrapped_coords(compound, 'com')
assert_almost_equal(group.atoms.positions, ref_wrapped_pos,
decimal=self.precision)
else:
# try to wrap:
with pytest.raises(ValueError):
group.wrap(compound=compound, center='wrong', inplace=True)
# make sure atom positions are unchanged:
assert_array_equal(group.atoms.positions, orig_pos)
def test_unwrap_empty_group(self, level, compound, reference,
is_triclinic):
# get a pristine test universe:
u = UnWrapUniverse(is_triclinic=is_triclinic)
if level == 'atoms':
group = mda.AtomGroup([], u)
elif level == 'residues':
group = mda.ResidueGroup([], u)
elif level == 'segments':
group = mda.SegmentGroup([], u)
group.unwrap(compound=compound, reference=reference, inplace=True)
# check for correct (empty) result:
assert_array_equal(group.atoms.positions,
np.empty((0, 3), dtype=np.float32))
def test_wrap_wrong_compound_exception_safety(self, level, center):
# get a pristine test universe:
u = UnWrapUniverse()
group = u.atoms
# select topology level:
if level == 'residues':
group = group.residues
elif level == 'segments':
group = group.segments
# store original positions:
orig_pos = group.atoms.positions
# try to wrap:
with pytest.raises(ValueError):
group.wrap(compound='wrong', center=center, inplace=True)
# make sure atom positions are unchanged:
assert_array_equal(group.atoms.positions, orig_pos)
def test_unwrap_no_molnums_exception_safety(self, level, reference):
# universe without molnums:
u = UnWrapUniverse(have_molnums=False)
group = u.atoms
# select topology level:
if level == 'residues':
group = group.residues
elif level == 'segments':
group = group.segments
# store original positions:
orig_pos = group.atoms.positions
with pytest.raises(NoDataError):
group.unwrap(compound='molecules',
reference=reference,
inplace=True)
assert_array_equal(group.atoms.positions, orig_pos)
def test_unwrap_wrong_reference_exception_safety(self, level, compound):
# get a pristine test universe:
u = UnWrapUniverse()
# select group appropriate for compound:
if compound == 'group':
group = u.atoms[39:47] # molecule 12
elif compound == 'segments':
group = u.atoms[23:47] # molecules 10, 11, 12
else:
group = u.atoms
# select topology level:
if level == 'residues':
group = group.residues
elif level == 'segments':
group = group.segments
# store original positions:
orig_pos = group.atoms.positions
# try to unwrap:
with pytest.raises(ValueError):
group.unwrap(compound=compound, reference='wrong', inplace=True)
# make sure atom positions are unchanged:
assert_array_equal(group.atoms.positions, orig_pos)
def test_unwrap_no_bonds_exception_safety(self, level, compound,
reference):
# universe without bonds:
u = UnWrapUniverse(have_bonds=False)
# select group appropriate for compound:
if compound == 'group':
group = u.atoms[39:47] # molecule 12
elif compound == 'segments':
group = u.atoms[23:47] # molecules 10, 11, 12
else:
group = u.atoms
# select topology level:
if level == 'residues':
group = group.residues
elif level == 'segments':
group = group.segments
# store original positions:
orig_pos = group.atoms.positions
with pytest.raises(NoDataError):
group.unwrap(compound=compound, reference=reference, inplace=True)
# make sure atom positions are unchanged:
assert_array_equal(group.atoms.positions, orig_pos)
def test_accumulate_str_attribute_compounds(self, name, compound, level):
u = UnWrapUniverse()
group = getattr(u, level)
ref = [sum(a.masses) for a in group.atoms.groupby(name).values()]
vals = group.accumulate("masses", compound=compound)
assert_almost_equal(vals, ref, decimal=5)
