Пример #1
0
    def test_from_batch(self):
        mols = self._make_molecules()

        system = System()
        with system.batch() as batch:
            [batch.append(mol) for mol in mols]
        self._assert_init(system)
Пример #2
0
    def test_atom_type(self):
        self.s = System.from_arrays(
            type_array=[
                'Cl', 'Cl', 'O', 'H', 'H', 'O', 'H', 'H', 'O', 'H', 'H', 'Na',
                'Na'
            ],
            maps={
                ('atom', 'molecule'): [0, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 6]
            })

        idx = self.s.where(type_array='O')
        assert_npequal(idx['atom'], [
            False, False, True, False, False, True, False, False, True, False,
            False, False, False
        ])
        assert_npequal(idx['molecule'],
                       [False, False, True, True, True, False, False])

        self.s = System.from_arrays(
            type_array=[
                'Cl', 'Cl', 'O', 'H', 'H', 'O', 'H', 'H', 'O', 'H', 'H', 'Na',
                'Na'
            ],
            maps={
                ('atom', 'molecule'): [0, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 6]
            })

        idx = self.s.where(type_array=['Na', 'Cl'])
        assert_npequal(idx['atom'], [
            True, True, False, False, False, False, False, False, False, False,
            False, True, True
        ])
Пример #3
0
 def test_reorder_molecules(self):
     mols = self._make_molecules()
     system = System(mols)
     system.bonds = np.array([[0, 1], [3, 5]])
     # Reordering
     system.reorder_molecules([1, 0, 2, 3])
     assert_eqbonds(system.bonds, [[0, 2], [3, 4]])
Пример #4
0
    def test_from_batch(self):
        mols = self._make_molecules()

        system = System()
        with system.batch() as batch:
            [batch.append(mol) for mol in mols]
        self._assert_init(system)
Пример #5
0
 def test_reorder_molecules(self):
     mols = self._make_molecules()
     system = System(mols)
     system.bonds = np.array([[0, 1], [3, 5]])
     # Reordering
     system.reorder_molecules([1, 0, 2, 3])
     assert_eqbonds(system.bonds, [[0, 2], [3, 4]])
Пример #6
0
    def test_remove_atoms(self):
        # This will remove the first and last molecules
        mols = self._make_molecules()
        system = System(mols)
        system.remove_atoms([0, 1, 11])

        assert_eqbonds(system.bonds, [[0, 1], [0, 2], [3, 4], [3, 5]])
        assert_npequal(system.type_array, np.array(["O", "H", "H", "O", "H", "H"], dtype="object"))
Пример #7
0
    def test_remove_atoms(self):
        # This will remove the first and last molecules
        mols = self._make_molecules()
        system = System(mols)
        system.remove_atoms([0, 1, 11])

        assert_eqbonds(system.bonds, [[0, 1], [0, 2], [3, 4], [3, 5]])
        assert_npequal(
            system.type_array,
            np.array(['O', 'H', 'H', 'O', 'H', 'H'], dtype='object'))
Пример #8
0
def test_bond_orders():
    # Get a molecule with some bonds
    wat = _make_water()
    wat_o = wat.copy()
    # 0,1 0,2
    assert_npequal(wat.bond_orders, np.array([0, 0]))

    # Remove a bond
    wat.bonds = np.array([[0, 1]])
    assert_npequal(wat.bond_orders, np.array([0]))

    wat.bond_orders = np.array([2])

    # Try with a system
    s = System()

    s.add(wat_o)
    s.add(wat)

    assert_npequal(s.bond_orders, np.array([0, 0, 2]))
    s.reorder_molecules([1, 0])
    # Bonds get sorted accordingly
    assert_npequal(s.bond_orders, np.array([2, 0, 0]))

    s.bonds = np.array([[0, 1], [0, 2], [3, 4], [3, 5]])
    assert_npequal(s.bond_orders, np.array([2, 0, 0, 0]))
Пример #9
0
def test_bond_orders():
    # Get a molecule with some bonds
    wat = _make_water()
    wat_o = wat.copy()
    # 0,1 0,2
    assert_npequal(wat.bond_orders, np.array([0, 0]))

    # Remove a bond
    wat.bonds = np.array([[0, 1]])
    assert_npequal(wat.bond_orders, np.array([0]))

    wat.bond_orders = np.array([2])

    # Try with a system
    s = System()

    s.add(wat_o)
    s.add(wat)

    assert_npequal(s.bond_orders, np.array([0, 0, 2]))
    s.reorder_molecules([1, 0])
    # Bonds get sorted accordingly
    assert_npequal(s.bond_orders, np.array([2, 0, 0]))

    s.bonds = np.array([[0, 1], [0, 2], [3, 4], [3, 5]])
    assert_npequal(s.bond_orders, np.array([2, 0, 0, 0]))
Пример #10
0
def test_bond_guessing():
    from chemlab.db import ChemlabDB, CirDB
    from chemlab.graphics import display_molecule
    from chemlab.io import datafile

    mol = datafile('tests/data/3ZJE.pdb').read('molecule')
    print(mol.r_array)
    mol.guess_bonds()
    assert mol.bonds.size > 0

    # We should find the bond guessing also for systems

    # System Made of two benzenes
    bz = datafile("tests/data/benzene.mol").read('molecule')
    bzbonds = bz.bonds
    bz.bonds = np.array([])

    # Separating the benzenes by large amount
    bz2 = bz.copy()
    bz2.r_array += 2.0

    s = System([bz, bz2])
    s.guess_bonds()
    assert_eqbonds(s.bonds, np.concatenate((bzbonds, bzbonds + 6)))

    # Separating benzenes by small amount
    bz2 = bz.copy()
    bz2.r_array += 0.15

    s = System([bz, bz2])
    s.guess_bonds()
    assert_eqbonds(s.bonds, np.concatenate((bzbonds, bzbonds + 6)))
Пример #11
0
def test_bonds():
    # TODO: deprecate this shit
    from chemlab.io import datafile
    bz = datafile("tests/data/benzene.mol").read('molecule')
    na = Molecule([
        Atom('O', [0.0, 0.0, 0.0]),
        Atom('H', [0.0, 0.0, 0.0]),
        Atom('H', [0.0, 0.0, 0.0]),
    ])

    # Adding bonds
    s = System()
    with s.batch() as b:
        b.append(bz)

    assert_npequal(s.bonds, bz.bonds)
    assert_npequal(bz.bond_orders, [1, 2, 2, 1, 1, 2])
    assert_npequal(s.bond_orders, bz.bond_orders)

    s.add(bz)
    assert_npequal(
        s.type_array,
        ['C', 'C', 'C', 'C', 'C', 'C', 'C', 'C', 'C', 'C', 'C', 'C'])
    eq_(s.dimensions['atom'], 12)
    assert_npequal(s.bonds, np.concatenate((bz.bonds, bz.bonds + 7)))

    # Reordering
    s.bonds = np.array([[0, 1], [6, 8]])
    s.reorder_molecules([1, 0])
    assert_eqbonds(s.bonds, np.array([[6, 7], [0, 2]]))

    # Selection
    ss = subsystem_from_molecules(s, [1])
    assert_npequal(ss.bonds, np.array([[0, 1]]))
Пример #12
0
def test_bonds():
    from chemlab.io import datafile
    bz = datafile("tests/data/benzene.mol").read('molecule')
    na = Molecule([Atom('Na', [0.0, 0.0, 0.0])])
    
    s2 = System.empty(2, 2)
    s2.add(na)
    s2.add(na)
    s2.get_bond_array()
    
    s = System.empty(2, 2*bz.n_atoms)
    s.add(bz)
    s.add(bz)
    
    print s.get_bond_array()
Пример #13
0
 def get_system(self):
     self.coordinates = self.interaction_manager.get_coordinates()
     atoms = []
     for index in range(len(self.interaction_manager.atoms)):
         atom = self.interaction_manager.atoms[index]
         type = atom.atom_type
         if type.upper() == "C":
             if atom.get_free_valency()!=0:
                 type = "Ne"
         pos = 3.5 * self.coordinates[index]
         atoms.append(Atom(type,pos))
     mol = Molecule(atoms, self.interaction_manager.get_bonds_array())
     system = System([mol])
     system.bonds = np.array(self.interaction_manager.get_bonds_array())
     return system
Пример #14
0
def test_query():
    type_array = ['Cl', 'Cl', 'O', 'H', 'H', 'O', 'H', 'H', 'Na', 'Na']
    maps = {('atom', 'molecule'): [0, 1, 2, 2, 2, 3, 3, 3, 4, 5]}
    s = System.from_arrays(type_array=type_array, maps=maps)

    assert_npequal(
        s.where(type_array=['Na', 'Cl'])['atom'],
        [True, True, False, False, False, False, False, False, True, True])

    assert_npequal(
        s.where(type_array='Cl')['atom'],
        [True, True, False, False, False, False, False, False, False, False])

    # We move the Cl away
    cl = s.where(type_array='Cl')['atom']
    s.r_array[cl.nonzero()[0]] = [1, 0, 0]
    s.box_vectors = np.diag([3, 3, 3])

    assert_npequal(
        s.where(type_array=['H', 'O'], within_of=(0.2, [8, 9]))['atom'],
        [False, False, True, True, True, True, True, True, False, False])

    assert_npequal(
        s.where(type_array=['H', 'O'], within_of=(0.2, 8))['atom'],
        [False, False, True, True, True, True, True, True, False, False])

    assert_npequal(
        s.where(type_array=['H', 'O'], within_of=(0.2, [8]))['atom'],
        [False, False, True, True, True, True, True, True, False, False])
Пример #15
0
def test_bond_orders():
    # Get a molecule with some bonds
    wat = _make_water()
    wat_o = wat.copy()
    # 0,1 0,2
    assert_npequal(wat.bond_orders, np.array([1, 1]))

    # Remove a bond
    wat.bonds = np.array([[0, 1]])
    assert_npequal(wat.bond_orders, np.array([1]))

    wat.bond_orders = np.array([2])

    # Try with a system
    s = System.empty(2, 6)

    s.add(wat_o)
    s.add(wat)

    assert_npequal(s.bond_orders , np.array([1, 1, 2]))
    s.reorder_molecules([1, 0]) # We don't actually sort bonds again
    assert_npequal(s.bond_orders , np.array([1, 1, 2]))

    s.bonds = np.array([[0, 1], [0, 2], [3, 4], [3, 5]])
    assert_npequal(s.bond_orders, np.array([1, 1, 2, 1]))
Пример #16
0
def test_merge_system():
    # take a protein
    from chemlab.io import datafile
    from chemlab.graphics import display_system

    from chemlab.db import ChemlabDB

    water = ChemlabDB().get("molecule", "example.water")

    prot = datafile("tests/data/3ZJE.pdb").read("system")

    # Take a box of water
    NWAT = 50000
    bsize = 20.0
    pos = np.random.random((NWAT, 3)) * bsize
    wat = water.copy()

    s = System.empty(NWAT, NWAT*3, box_vectors=np.eye(3)*bsize)
    for i in range(NWAT):
        wat.move_to(pos[i])
        s.add(wat)

    prot.r_array += 10
    s = merge_systems(s, prot, 0.5)

    display_system(s, 'ball-and-stick')
Пример #17
0
def test_merge_system():
    # take a protein
    from chemlab.io import datafile
    from chemlab.graphics import display_system

    from chemlab.db import ChemlabDB

    water = ChemlabDB().get("molecule", "example.water")

    prot = datafile("tests/data/3ZJE.pdb").read("system")

    # Take a box of water
    NWAT = 50000
    bsize = 20.0
    pos = np.random.random((NWAT, 3)) * bsize
    wat = water.copy()

    s = System.empty(NWAT, NWAT * 3, box_vectors=np.eye(3) * bsize)
    for i in range(NWAT):
        wat.move_to(pos[i])
        s.add(wat)

    prot.r_array += 10
    s = merge_systems(s, prot, 0.5)

    display_system(s, 'ball-and-stick')
Пример #18
0
def test_write_gromacs():
    water = Molecule(
        [
            Atom("O", [0.0, 0.0, 0.0], export={"grotype": "OW"}),
            Atom("H", [0.1, 0.0, 0.0], export={"grotype": "HW1"}),
            Atom("H", [-0.03333, 0.09428, 0.0], export={"grotype": "HW2"}),
        ],
        export={"groname": "SOL"},
    )

    sys = System.empty(200, 3 * 200, box_vectors=np.eye(3) * 2.0)
    for i in range(200):
        sys.add(water.copy())

    df = datafile("/tmp/dummy.gro", mode="w")
    df.write("system", sys)

    with assert_raises(Exception):
        df = datafile("/tmp/dummy.gro")
        df.write("system", sys)

    df = datafile("/tmp/dummy.gro")
    sread = df.read("system")

    assert all(sread.type_array == sys.type_array)
Пример #19
0
def test_bond_orders():
    # Get a molecule with some bonds
    wat = _make_water()
    wat_o = wat.copy()
    # 0,1 0,2
    assert_npequal(wat.bond_orders, np.array([1, 1]))

    # Remove a bond
    wat.bonds = np.array([[0, 1]])
    assert_npequal(wat.bond_orders, np.array([1]))

    wat.bond_orders = np.array([2])

    # Try with a system
    s = System.empty(2, 6)

    s.add(wat_o)
    s.add(wat)

    assert_npequal(s.bond_orders, np.array([1, 1, 2]))
    s.reorder_molecules([1, 0])  # We don't actually sort bonds again
    assert_npequal(s.bond_orders, np.array([1, 1, 2]))

    s.bonds = np.array([[0, 1], [0, 2], [3, 4], [3, 5]])
    assert_npequal(s.bond_orders, np.array([1, 1, 2, 1]))
Пример #20
0
def test_query():
    type_array = ['Cl', 'Cl', 'O', 'H', 'H', 'O', 'H', 'H', 'Na', 'Na']
    mol_indices = [0, 1, 2, 5, 8, 9]
    s = System.from_arrays(type_array=type_array, mol_indices=mol_indices)
    array_eq_(
        s.where(type_in=['Na', 'Cl']),
        [True, True, False, False, False, False, False, False, True, True])

    array_eq_(
        s.where(type='Cl'),
        [True, True, False, False, False, False, False, False, False, False])

    # We move the Cl away
    cl = s.where(type='Cl')
    s.r_array[cl.nonzero()[0]] = [1, 0, 0]
    s.box_vectors = np.diag([3, 3, 3])

    array_eq_(s.where(type_in=['H', 'O'], within_of=(0.2, [8, 9])),
              [False, False, True, True, True, True, True, True, False, False])

    array_eq_(s.where(type_in=['H', 'O'], within_of=(0.2, 8)),
              [False, False, True, True, True, True, True, True, False, False])

    array_eq_(s.where(type_in=['H', 'O'], within_of=(0.2, [8])),
              [False, False, True, True, True, True, True, True, False, False])
Пример #21
0
def test_attributes():
    coords = [np.random.rand(10, 3) for i in range(10)]
    t = np.arange(0, 10, 0.1)
    traj = Trajectory(coords, t)
    system = System.from_arrays(r_array=coords[0])

    system.update(traj.at(1))
    npeq_(system.r_array, coords[1])
Пример #22
0
def test_attributes():
    coords = [np.random.rand(10, 3) for i in range(10)]
    t = np.arange(0, 10, 0.1)
    traj = Trajectory(coords, t)
    system = System.from_arrays(r_array=coords[0])
    
    system.update(traj.at(1))    
    npeq_(system.r_array, coords[1])
Пример #23
0
def load_molecule(name, format=None):
    '''Read a `~chemlab.core.Molecule` from a file.

    .. seealso:: `chemlab.io.datafile`
    
    '''
    mol = datafile(name, format=format).read('molecule')
    display_system(System([mol]))
Пример #24
0
 def test_subsystem_from_atoms(self):
     mols = self._make_molecules()
     system = System(mols)
     sub = subsystem_from_atoms(
         system,
         np.array(
             [True, True, False, False, False, False, False, False, False]))
     assert_equals(sub.n_mol, 1)
Пример #25
0
def test_bonds():
    # TODO: deprecate this shit
    from chemlab.io import datafile
    bz = datafile("tests/data/benzene.mol").read('molecule')
    na = Molecule([Atom('O', [0.0, 0.0, 0.0]),
                   Atom('H', [0.0, 0.0, 0.0]),
                   Atom('H', [0.0, 0.0, 0.0]), ])

    # Adding bonds
    s = System()
    with s.batch() as b:
        b.append(bz)

    assert_npequal(s.bonds, bz.bonds)
    assert_npequal(bz.bond_orders, [1, 2, 2, 1, 1, 2])
    assert_npequal(s.bond_orders, bz.bond_orders)

    s.add(bz)
    assert_npequal(s.type_array, ['C', 'C', 'C', 'C', 'C', 'C', 'C', 'C', 'C',
                                  'C', 'C', 'C'])
    eq_(s.dimensions['atom'], 12)
    assert_npequal(s.bonds, np.concatenate((bz.bonds, bz.bonds + 7)))

    # Reordering
    s.bonds = np.array([[0, 1], [6, 8]])
    s.reorder_molecules([1, 0])
    assert_eqbonds(s.bonds, np.array([[6, 7], [0, 2]]))

    # Selection
    ss = subsystem_from_molecules(s, [1])
    assert_npequal(ss.bonds, np.array([[0, 1]]))
Пример #26
0
def display_molecule(mol, autozoom=True):
    '''Display a `~chemlab.core.Molecule` instance in the viewer.

    This function wraps the molecule in a system before displaying
    it.

    '''
    s = System([mol])
    display_system(s, autozoom=True)
Пример #27
0
def test_local():
    db = ChemlabDB()
    bz = db.get("molecule", "example.norbornene")

    pre_string = bz.tojson()
    db = LocalDB("/tmp/testdb/")
    db.store("molecule", 'norbornene', bz, nowarn=True)
    
    post_string = db.get('molecule', 'norbornene').tojson()
    assert pre_string == post_string
    
    # Do the same thing for a system of 3 norbornenes
    s = System([bz.copy() for i in range(3)])
    pre_string = s.tojson()
    db.store("system", 'norbornene-3', s, nowarn=True)
    post_string = db.get('system', 'norbornene-3').tojson()
    
    assert pre_string == post_string
Пример #28
0
def test_bonds():
    from chemlab.io import datafile
    bz = datafile("tests/data/benzene.mol").read('molecule')
    na = Molecule([Atom('Na', [0.0, 0.0, 0.0])])

    # Adding bonds
    s = System.empty(2, 2 * bz.n_atoms)
    s.add(bz)
    assert_npequal(s.bonds, bz.bonds)
    assert_npequal(bz.bond_orders, [1, 2, 2, 1, 1, 2])
    assert_npequal(s.bond_orders, bz.bond_orders)

    s.add(bz)
    assert_npequal(s.bonds, np.concatenate((bz.bonds, bz.bonds + 6)))
    #assert_npequal(s.bond_orders)

    # Reordering
    orig = np.array([[0, 1], [6, 8]])
    s.bonds = orig
    s.reorder_molecules([1, 0])
    assert_npequal(s.bonds, np.array([[6, 7], [0, 2]]))
    # This doesn't change the bond_ordering

    # Selection
    ss = subsystem_from_molecules(s, [1])
    assert_npequal(ss.bonds, np.array([[0, 1]]))

    import inspect
    ss2 = System.from_arrays(**dict(inspect.getmembers(ss)))
    ss2.r_array += 10.0

    ms = merge_systems(ss, ss2)
    assert_npequal(ms.bonds, np.array([[0, 1], [6, 7]]))
    assert_npequal(ms.bond_orders, np.array([1, 1]))

    # From_arrays
    s = System.from_arrays(mol_indices=[0], bonds=bz.bonds, **bz.__dict__)
    assert_npequal(s.bonds, bz.bonds)
    assert_npequal(s.bond_orders, bz.bond_orders)

    # Get molecule entry
    # Test the bonds when they're 0
    s.bonds = np.array([])
    assert_equals(s.get_derived_molecule_array('formula'), 'C6')
Пример #29
0
def test_bonds():
    from chemlab.io import datafile
    bz = datafile("tests/data/benzene.mol").read('molecule')
    na = Molecule([Atom('Na', [0.0, 0.0, 0.0])])

    # Adding bonds
    s = System.empty(2, 2*bz.n_atoms)
    s.add(bz)
    assert_npequal(s.bonds, bz.bonds)
    assert_npequal(bz.bond_orders, [1, 2, 2, 1, 1, 2])
    assert_npequal(s.bond_orders, bz.bond_orders)

    s.add(bz)
    assert_npequal(s.bonds, np.concatenate((bz.bonds, bz.bonds + 6)))
    #assert_npequal(s.bond_orders)

    # Reordering
    orig = np.array([[0, 1], [6, 8]])
    s.bonds = orig
    s.reorder_molecules([1, 0])
    assert_npequal(s.bonds, np.array([[6, 7], [0, 2]]))
    # This doesn't change the bond_ordering

    # Selection
    ss = subsystem_from_molecules(s, [1])
    assert_npequal(ss.bonds, np.array([[0, 1]]))

    import inspect
    ss2 = System.from_arrays(**dict(inspect.getmembers(ss)))
    ss2.r_array += 10.0

    ms = merge_systems(ss, ss2)
    assert_npequal(ms.bonds, np.array([[0, 1], [6, 7]]))
    assert_npequal(ms.bond_orders, np.array([1, 1]))

    # From_arrays
    s = System.from_arrays(mol_indices=[0], bonds=bz.bonds, **bz.__dict__)
    assert_npequal(s.bonds, bz.bonds)
    assert_npequal(s.bond_orders, bz.bond_orders)

    # Get molecule entry
    # Test the bonds when they're 0
    s.bonds = np.array([])
    assert_equals(s.get_derived_molecule_array('formula'), 'C6')
Пример #30
0
def test_system():
    wat = Molecule([Atom("O", [-4.99, 2.49, 0.0]),
                    Atom("H", [-4.02, 2.49, 0.0]),
                    Atom("H", [-5.32, 1.98, 1.0])], export={'hello': 1.0})

    wat.r_array *= 0.1
    # Initialization from empty
    s = System.empty(4, 4*3)
    
    mols = []
    for i in xrange(s.n_mol):
        wat.r_array += 0.1
        s.add(wat)
        m  = wat.copy()
        mols.append(wat.copy())
        
    # Printing just to test if there aren't any exception    
    print "Init from Empty"
    print "*" * 72
    _print_sysinfo(s)
    
    print "Init Normal"
    print "*" * 72
    s = System(mols)
    _print_sysinfo(s)
    
    # 3 water molecules
    r_array = np.random.random((9, 3))
    type_array = ['O', 'H', 'H', 'O', 'H', 'H', 'O', 'H', 'H']
    mol_indices = [0, 3, 6]
    mol_n_atoms = [3, 3, 3]
    s2 = System.from_arrays(r_array=r_array, type_array=type_array,
                       mol_indices=mol_indices, mol_n_atoms=mol_n_atoms)
    

    print 'bonds', s2._mol_bonds
    sub2 = subsystem_from_molecules(s2, np.array([0, 2]))
    assert sub2.n_mol == 2
    
    
    sub = subsystem_from_atoms(s2, np.array([True, True, False,
                                             False, False, False,
                                             False, False, False]))
    assert sub.n_mol == 1
Пример #31
0
def test_local():
    db = ChemlabDB()
    bz = db.get("molecule", "example.norbornene")
    pre_dict = bz.to_dict()

    db = LocalDB("/tmp/testdb/")
    db.store("molecule", 'norbornene', bz, nowarn=True)
    
    post_dict = db.get('molecule', 'norbornene').to_dict()
    
    npeq_(pre_dict['r_array'], post_dict['r_array'])
    
    # Do the same thing for a system of 3 norbornenes
    s = System([bz.copy() for i in range(3)])
    pre_dict = s.to_dict()
    db.store("system", 'norbornene-3', s, nowarn=True)
    post_dict = db.get('system', 'norbornene-3').to_dict()
    
    npeq_(pre_dict['r_array'], post_dict['r_array'])
Пример #32
0
def test_residue():

    m = Molecule.from_arrays(type_array=['H', 'H', 'H', 'O', 'O'],
                             residue_name=['VAL', 'ALA'],
                             maps={('atom', 'residue'): [0, 0, 0, 1, 1]})
    assert_npequal(m.sub(residue_index=0).type_array, ['H', 'H', 'H'])

    s = System([m, m])
    assert_npequal(s.maps['atom', 'residue'].value,
                   [0, 0, 0, 1, 1, 2, 2, 2, 3, 3])
Пример #33
0
def test_local():
    db = ChemlabDB()
    bz = db.get("molecule", "example.norbornene")
    pre_dict = bz.to_dict()

    db = LocalDB("/tmp/testdb/")
    db.store("molecule", 'norbornene', bz, nowarn=True)

    post_dict = db.get('molecule', 'norbornene').to_dict()

    npeq_(pre_dict['r_array'], post_dict['r_array'])

    # Do the same thing for a system of 3 norbornenes
    s = System([bz.copy() for i in range(3)])
    pre_dict = s.to_dict()
    db.store("system", 'norbornene-3', s, nowarn=True)
    post_dict = db.get('system', 'norbornene-3').to_dict()

    npeq_(pre_dict['r_array'], post_dict['r_array'])
Пример #34
0
def test_display():
    d = Display('povray')
    s = System.from_arrays(type_array=['O', 'H', 'H'],
                           r_array=[[0.0, 0.0, 0.0], [0.15, 0.0, 0.0], [0.0, 0.15, 0.0]])
    d.system(s)
    
    s.r_array = s.r_array + 0.3
    d.system(s, alpha=0.5)
    
    d.render()
Пример #35
0
 def test_from_arrays(self):
     mols = self._make_molecules()
     system = System.from_arrays(
         r_array=np.concatenate([m.r_array for m in mols]),
         type_array=np.concatenate([m.type_array for m in mols]),
         bonds=np.concatenate([m.bonds + 3 * i
                               for i, m in enumerate(mols)]),
         maps={
             ('atom', 'molecule'): [0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3],
             ('bond', 'molecule'): [0, 0, 1, 1, 2, 2, 3, 3]
         })
     self._assert_init(system)
Пример #36
0
    def _make_molecules(self):
        wat = _make_water()
        wat.r_array *= 0.1
        # Initialization from empty
        s = System.empty(4, 4*3)

        mols = []
        # Array to be compared
        for _ in range(s.n_mol):
            wat.r_array += 0.1
            mols.append(wat.copy())
        return mols
Пример #37
0
def test_system_remove():
        # 3 water molecules
    r_array = np.random.random((9, 3))
    type_array = ['O', 'H', 'H', 'O', 'H', 'H', 'O', 'H', 'H']
    mol_indices = [0, 3, 6]
    mol_n_atoms = [3, 3, 3]
    s2 = System.from_arrays(r_array=r_array, type_array=type_array,
                       mol_indices=mol_indices, mol_n_atoms=mol_n_atoms)

    s2.remove_atoms([0, 1])
    
    print s2.type_array
Пример #38
0
 def test_from_arrays(self):
     mols = self._make_molecules()
     system = System.from_arrays(
         r_array=np.concatenate([m.r_array for m in mols]),
         type_array=np.concatenate([m.type_array for m in mols]),
         bonds=np.concatenate([m.bonds + 3 * i for i, m in enumerate(mols)
                               ]),
         maps={
             ('atom', 'molecule'): [0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3],
             ('bond', 'molecule'): [0, 0, 1, 1, 2, 2, 3, 3]
         })
     self._assert_init(system)
Пример #39
0
    def test_atom_type(self):
        self.s = System.from_arrays(
            type_array=["Cl", "Cl", "O", "H", "H", "O", "H", "H", "O", "H", "H", "Na", "Na"],
            maps={("atom", "molecule"): [0, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 6]},
        )

        idx = self.s.where(atom_type="O")
        assert_npequal(
            idx["atom"], [False, False, True, False, False, True, False, False, True, False, False, False, False]
        )
        assert_npequal(idx["molecule"], [False, False, True, True, True, False, False])

        self.s = System.from_arrays(
            type_array=["Cl", "Cl", "O", "H", "H", "O", "H", "H", "O", "H", "H", "Na", "Na"],
            maps={("atom", "molecule"): [0, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 6]},
        )

        idx = self.s.where(atom_type=["Na", "Cl"])
        assert_npequal(
            idx["atom"], [True, True, False, False, False, False, False, False, False, False, False, True, True]
        )
Пример #40
0
    def _make_molecules(self):
        wat = _make_water()
        wat.r_array *= 0.1
        # Initialization from empty
        s = System.empty(4, 4 * 3)

        mols = []
        # Array to be compared
        for _ in range(s.n_mol):
            wat.r_array += 0.1
            mols.append(wat.copy())
        return mols
Пример #41
0
def test_write_pdb():
    water = Molecule([Atom('O', [0.0, 0.0, 0.0], export={'grotype': 'OW'}),
                      Atom('H', [0.1, 0.0, 0.0], export={'grotype': 'HW1'}),
                      Atom('H', [-0.03333, 0.09428, 0.0], export={'grotype': 'HW2'})],
                      export={'groname': 'SOL'})

    sys = System.empty(200, 3*200, box_vectors = np.eye(3) * 2.0)
    for i in range(200):
        sys.add(water.copy())
    
    df = datafile('/tmp/dummy.gro', mode="w")
    df.write("system", sys)
Пример #42
0
def test_bond_guessing():
    from chemlab.db import ChemlabDB, CirDB
    from chemlab.graphics import display_molecule
    from chemlab.io import datafile

    mol = datafile('tests/data/3ZJE.pdb').read('molecule')
    print(mol.r_array)
    mol.guess_bonds()
    assert mol.bonds.size > 0

    # We should find the bond guessing also for systems

    # System Made of two benzenes
    bz = datafile("tests/data/benzene.mol").read('molecule')
    bzbonds = bz.bonds
    bz.bonds = np.array([])

    # Separating the benzenes by large amount
    bz2 = bz.copy()
    bz2.r_array += 2.0

    s = System([bz, bz2])
    s.guess_bonds()
    assert_eqbonds(s.bonds, np.concatenate((bzbonds, bzbonds + 6)))

    # Separating benzenes by small amount
    bz2 = bz.copy()
    bz2.r_array += 0.15

    s = System([bz, bz2])
    s.guess_bonds()
    assert_eqbonds(s.bonds, np.concatenate((bzbonds, bzbonds + 6)))
Пример #43
0
def test_write_pdb():
    water = Molecule([Atom('O', [0.0, 0.0, 0.0], export={'pdb.type': 'O'}),
                      Atom('H', [0.1, 0.0, 0.0], export={'pdb.type': 'H'}),
                      Atom('H', [-0.03333, 0.09428, 0.0], export={'pdb.type': 'H'})],
                      export={'groname': 'SOL'})

    sys = System.empty(200, 3*200, box_vectors = np.eye(3) * 2.0)
    for i in range(200):
        water.r_array += 0.1
        sys.add(water.copy())
    
    df = datafile('/tmp/dummy.pdb', mode="w")
    df.write("system", sys)
Пример #44
0
def test_serialization():
    cl = Molecule([Atom.from_fields(type='Cl', r=[0.0, 0.0, 0.0])])
    jsonstr =  cl.tojson()
    assert Molecule.from_json(jsonstr).tojson() == jsonstr

    na = Molecule([Atom('Na', [0.0, 0.0, 0.0])])
    cl = Molecule([Atom('Cl', [0.0, 0.0, 0.0])])

    # Fract position of Na and Cl, space group 255
    tsys = crystal([[0.0, 0.0, 0.0],[0.5, 0.5, 0.5]], [na, cl], 225, repetitions=[3,3,3])
    jsonstr = tsys.tojson()

    assert System.from_json(jsonstr).tojson() == jsonstr
Пример #45
0
    def test_from_arrays(self):
        mols = self._make_molecules()
        r_array = np.concatenate([m.r_array for m in mols])
        type_array = np.concatenate([m.type_array for m in mols])
        mol_indices = [0, 3, 6, 9]
        bonds = np.concatenate([m.bonds + 3*i for i, m in enumerate(mols)])

        system = System.from_arrays(r_array=r_array,
                                    type_array=type_array,
                                    mol_indices=mol_indices,
                                    bonds=bonds)

        self._assert_init(system)
Пример #46
0
    def test_from_arrays(self):
        mols = self._make_molecules()
        r_array = np.concatenate([m.r_array for m in mols])
        type_array = np.concatenate([m.type_array for m in mols])
        mol_indices = [0, 3, 6, 9]
        bonds = np.concatenate([m.bonds + 3 * i for i, m in enumerate(mols)])

        system = System.from_arrays(r_array=r_array,
                                    type_array=type_array,
                                    mol_indices=mol_indices,
                                    bonds=bonds)

        self._assert_init(system)
Пример #47
0
def test_write_pdb():
    water = Molecule([Atom('O', [0.0, 0.0, 0.0], export={'pdb.type': 'O'}),
                      Atom('H', [0.1, 0.0, 0.0], export={'pdb.type': 'H'}),
                      Atom('H', [-0.03333, 0.09428, 0.0], export={'pdb.type': 'H'})],
                      export={'groname': 'SOL'})

    sys = System.empty()
    with sys.batch() as b:
        for i in range(200):
            water.r_array += 0.1
            b.append(water.copy())

    df = datafile('/tmp/dummy.pdb', mode="w")
    df.write("system", sys)
Пример #48
0
def test_serialization():
    cl = Molecule([Atom.from_fields(type="Cl", r=[0.0, 0.0, 0.0])])
    jsonstr = cl.to_json()
    m = Molecule.from_json(jsonstr)
    eq_(Molecule.from_json(jsonstr).to_json(), jsonstr)

    na = Molecule([Atom("Na", [0.0, 0.0, 0.0])])
    cl = Molecule([Atom("Cl", [0.0, 0.0, 0.0])])

    # Fract position of Na and Cl, space group 255
    tsys = crystal([[0.0, 0.0, 0.0], [0.5, 0.5, 0.5]], [na, cl], 225, repetitions=[3, 3, 3])
    jsonstr = tsys.to_json()

    eq_(System.from_json(jsonstr).to_json(), jsonstr)
Пример #49
0
def test_write_pdb():
    water = Molecule([Atom('O', [0.0, 0.0, 0.0], export={'pdb.type': 'O'}),
                      Atom('H', [0.1, 0.0, 0.0], export={'pdb.type': 'H'}),
                      Atom('H', [-0.03333, 0.09428, 0.0], export={'pdb.type': 'H'})],
                      export={'groname': 'SOL'})

    sys = System.empty()
    with sys.batch() as b:
        for i in range(200):
            water.r_array += 0.1
            b.append(water.copy())

    df = datafile('/tmp/dummy.pdb', mode="w")
    df.write("system", sys)
Пример #50
0
def test_serialization():
    cl = Molecule([Atom.from_fields(type='Cl', r=[0.0, 0.0, 0.0])])
    jsonstr = cl.tojson()
    assert Molecule.from_json(jsonstr).tojson() == jsonstr

    na = Molecule([Atom('Na', [0.0, 0.0, 0.0])])
    cl = Molecule([Atom('Cl', [0.0, 0.0, 0.0])])

    # Fract position of Na and Cl, space group 255
    tsys = crystal([[0.0, 0.0, 0.0], [0.5, 0.5, 0.5]], [na, cl],
                   225,
                   repetitions=[3, 3, 3])
    jsonstr = tsys.tojson()

    assert System.from_json(jsonstr).tojson() == jsonstr
Пример #51
0
    def test_atom_type(self):
        self.s = System.from_arrays(
            type_array=['Cl', 'Cl', 'O', 'H', 'H', 'O', 'H', 'H', 'O', 'H',
                        'H', 'Na', 'Na'],
            maps=
            {('atom', 'molecule'): [0, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 6]})

        idx = self.s.where(type_array='O')
        assert_npequal(idx['atom'],
                       [False, False, True, False, False, True, False, False,
                        True, False, False, False, False])
        assert_npequal(idx['molecule'], [False, False, True, True, True, False,
                                         False])

        self.s = System.from_arrays(
            type_array=['Cl', 'Cl', 'O', 'H', 'H', 'O', 'H', 'H', 'O', 'H',
                        'H', 'Na', 'Na'],
            maps=
            {('atom', 'molecule'): [0, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 6]})

        idx = self.s.where(type_array=['Na', 'Cl'])
        assert_npequal(idx['atom'],
                       [True, True, False, False, False, False, False, False,
                        False, False, False, True, True])
Пример #52
0
def test_serialization():
    cl = Molecule([Atom.from_fields(type='Cl', r=[0.0, 0.0, 0.0])])
    jsonstr = cl.to_json()
    m = Molecule.from_json(jsonstr)
    eq_(Molecule.from_json(jsonstr).to_json(), jsonstr)

    na = Molecule([Atom('Na', [0.0, 0.0, 0.0])])
    cl = Molecule([Atom('Cl', [0.0, 0.0, 0.0])])

    # Fract position of Na and Cl, space group 255
    tsys = crystal([[0.0, 0.0, 0.0], [0.5, 0.5, 0.5]], [na, cl],
                   225,
                   repetitions=[3, 3, 3])
    jsonstr = tsys.to_json()

    npeq_(System.from_json(jsonstr).r_array, tsys.r_array)
Пример #53
0
def test_write_pdb():
    water = Molecule(
        [
            Atom("O", [0.0, 0.0, 0.0], export={"pdb.type": "O"}),
            Atom("H", [0.1, 0.0, 0.0], export={"pdb.type": "H"}),
            Atom("H", [-0.03333, 0.09428, 0.0], export={"pdb.type": "H"}),
        ],
        export={"groname": "SOL"},
    )

    sys = System.empty(200, 3 * 200, box_vectors=np.eye(3) * 2.0)
    for i in range(200):
        water.r_array += 0.1
        sys.add(water.copy())

    df = datafile("/tmp/dummy.pdb", mode="w")
    df.write("system", sys)
Пример #54
0
def test_write_gromacs():
    water = Molecule([Atom('O', [0.0, 0.0, 0.0], export={'grotype': 'OW'}),
                      Atom('H', [0.1, 0.0, 0.0], export={'grotype': 'HW1'}),
                      Atom('H', [-0.03333, 0.09428, 0.0], export={'grotype': 'HW2'})],
                      export={'groname': 'SOL'})

    sys = System.empty(200, 3*200, box_vectors = np.eye(3)*2.0)
    for i in range(200):
        sys.add(water.copy())
    
    df = datafile('/tmp/dummy.gro', mode="w")
    df.write('system', sys)
    
    df = datafile('/tmp/dummy.gro')
    sread = df.read('system')
    
    assert all(sread.type_array == sys.type_array)
Пример #55
0
def test_write_gromacs():
    water = Molecule([
        Atom('O', [0.0, 0.0, 0.0], export={'grotype': 'OW'}),
        Atom('H', [0.1, 0.0, 0.0], export={'grotype': 'HW1'}),
        Atom('H', [-0.03333, 0.09428, 0.0], export={'grotype': 'HW2'})
    ],
                     export={'groname': 'SOL'})

    sys = System.empty(200, 3 * 200, box_vectors=np.eye(3) * 2.0)
    for i in range(200):
        sys.add(water.copy())

    df = datafile('/tmp/dummy.gro', mode="w")
    df.write('system', sys)

    df = datafile('/tmp/dummy.gro')
    sread = df.read('system')

    assert all(sread.type_array == sys.type_array)
Пример #56
0
def test_write_gromacs():
    water = Molecule([Atom('O', [0.0, 0.0, 0.0], name="OW"),
                      Atom('H', [0.1, 0.0, 0.0], name='HW1'),
                      Atom('H', [-0.03333, 0.09428, 0.0], name='HW2')],
                      name='SOL')

    sys = System.empty()
    with sys.batch() as b:
        for i in range(200):
            b.append(water.copy())
    sys.box_vectors = [[2, 0, 0], [0, 2, 0], [0, 0, 2]]
    
    df = datafile('/tmp/dummy.gro', mode="w")
    df.write('system', sys)

    with assert_raises(Exception):
        df = datafile('/tmp/dummy.gro')
        df.write('system', sys)

    df = datafile('/tmp/dummy.gro')
    sread = df.read('system')
    assert all(sread.type_array == sys.type_array)
Пример #57
0
def test_write_gromacs():
    water = Molecule([Atom('O', [0.0, 0.0, 0.0], name="OW"),
                      Atom('H', [0.1, 0.0, 0.0], name='HW1'),
                      Atom('H', [-0.03333, 0.09428, 0.0], name='HW2')],
                      name='SOL')

    sys = System.empty()
    with sys.batch() as b:
        for i in range(200):
            b.append(water.copy())
    sys.box_vectors = [[2, 0, 0], [0, 2, 0], [0, 0, 2]]
    
    df = datafile('/tmp/dummy.gro', mode="w")
    df.write('system', sys)

    with assert_raises(Exception):
        df = datafile('/tmp/dummy.gro')
        df.write('system', sys)

    df = datafile('/tmp/dummy.gro')
    sread = df.read('system')
    assert all(sread.type_array == sys.type_array)
Пример #58
0
def test_query():
    type_array = ['Cl', 'Cl', 'O', 'H', 'H', 'O', 'H', 'H', 'Na', 'Na']
    mol_indices = [0, 1, 2, 5, 8, 9]
    s = System.from_arrays(type_array = type_array, mol_indices=mol_indices)
    array_eq_(s.where(type_in=['Na', 'Cl']), 
              [True, True, False, False, False, False, False, False, True, True])
    
    array_eq_(s.where(type='Cl'), 
              [True, True, False, False, False, False, False, False, False, False])
    
    # We move the Cl away
    cl = s.where(type='Cl')
    s.r_array[cl.nonzero()[0]] = [1, 0, 0]
    s.box_vectors = np.diag([3, 3, 3])
    
    array_eq_(s.where(type_in=['H', 'O'], within_of=(0.2, [8, 9])),
             [False, False, True, True, True, True, True, True, False, False])

    array_eq_(s.where(type_in=['H', 'O'], within_of=(0.2, 8)),
             [False, False, True, True, True, True, True, True, False, False])

    array_eq_(s.where(type_in=['H', 'O'], within_of=(0.2, [8])),
             [False, False, True, True, True, True, True, True, False, False])
Пример #59
0
 def test_subsystem_from_molecules(self):
     mols = self._make_molecules()
     system = System(mols)
     subsystem = subsystem_from_molecules(system, np.array([0, 2]))
     assert_equals(subsystem.n_mol, 2)