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)