示例#1
0
文件: builder.py 项目: jlmaccal/meld
    def build_system_from_molecules(self, molecules, patchers=None,
                                    leap_header_cmds=None):
        if patchers is None:
            patchers = []
        if leap_header_cmds is None:
            leap_header_cmds = []
        if isinstance(leap_header_cmds, string_types):
            leap_header_cmds = [leap_header_cmds]

        with util.in_temp_dir():
            leap_cmds = []
            mol_ids = []
            leap_cmds.extend(self._generate_leap_header())
            leap_cmds.extend(leap_header_cmds)
            for index, mol in enumerate(molecules):
                mol_id = 'mol_{}'.format(index)
                mol_ids.append(mol_id)
                mol.prepare_for_tleap(mol_id)
                leap_cmds.extend(mol.generate_tleap_input(mol_id))
            leap_cmds.extend(self._generate_leap_footer(mol_ids))
            with open('tleap.in', 'w') as tleap_file:
                tleap_string = '\n'.join(leap_cmds)
                tleap_file.write(tleap_string)
            subprocess.check_call('tleap -f tleap.in > tleap.out', shell=True)

            return load_amber_system('system.top', 'system.mdcrd', patchers)
示例#2
0
    def build_system_from_molecules(self,
                                    molecules,
                                    patchers=None,
                                    leap_header_cmds=None):
        if patchers is None:
            patchers = []
        if leap_header_cmds is None:
            leap_header_cmds = []
        if isinstance(leap_header_cmds, string_types):
            leap_header_cmds = [leap_header_cmds]

        with util.in_temp_dir():
            leap_cmds = []
            mol_ids = []
            leap_cmds.extend(self._generate_leap_header())
            leap_cmds.extend(leap_header_cmds)
            for index, mol in enumerate(molecules):
                mol_id = 'mol_{}'.format(index)
                mol_ids.append(mol_id)
                mol.prepare_for_tleap(mol_id)
                leap_cmds.extend(mol.generate_tleap_input(mol_id))
            leap_cmds.extend(self._generate_leap_footer(mol_ids))
            with open('tleap.in', 'w') as tleap_file:
                tleap_string = '\n'.join(leap_cmds)
                tleap_file.write(tleap_string)
            subprocess.check_call('tleap -f tleap.in > tleap.out', shell=True)

            return load_amber_system('system.top', 'system.mdcrd', patchers)
示例#3
0
 def setUp(self):
     with in_temp_dir():
         with open("pdb.pdb", "w") as outfile:
             outfile.write(pdb_string)
         p = subsystem.SubSystemFromPdbFile("pdb.pdb")
         b = builder.SystemBuilder(explicit_solvent=True)
         self.system = b.build_system([p])
示例#4
0
文件: builder.py 项目: cing/meld
    def build_system_from_molecules(self,
                                    molecules,
                                    patchers=None,
                                    leap_header_cmds=None):
        if patchers is None:
            patchers = []
        if leap_header_cmds is None:
            leap_header_cmds = []
        if isinstance(leap_header_cmds, str):
            leap_header_cmds = [leap_header_cmds]

        with util.in_temp_dir():
            leap_cmds = []
            mol_ids = []
            leap_cmds.extend(self._generate_leap_header())
            leap_cmds.extend(leap_header_cmds)
            for index, mol in enumerate(molecules):
                mol_id = f"mol_{index}"
                mol_ids.append(mol_id)
                mol.prepare_for_tleap(mol_id)
                leap_cmds.extend(mol.generate_tleap_input(mol_id))
            if self._explicit_solvent:
                leap_cmds.extend(self._generate_solvent(mol_ids))
                leap_cmds.extend(self._generate_leap_footer([f"solute"]))
            else:
                leap_cmds.extend(self._generate_leap_footer(mol_ids))

            with open("tleap.in", "w") as tleap_file:
                tleap_string = "\n".join(leap_cmds)
                tleap_file.write(tleap_string)
            subprocess.check_call("tleap -f tleap.in > tleap.out", shell=True)

            return load_amber_system("system.top", "system.mdcrd", patchers)
示例#5
0
    def patch(self, top_string, crd_string):
        INTOP = 'in.top'
        INRST = 'in.rst'
        OUTTOP = 'out.top'
        OUTRST = 'out.rst'

        with util.in_temp_dir():
            with open(INTOP, 'wt') as outfile:
                outfile.write(top_string)
            with open(INRST, 'wt') as outfile:
                outfile.write(crd_string)

            topol = pmd.load_file(INTOP)
            crd = pmd.load_file(INRST)
            topol.coordinates = crd.coordinates

            self._add_particles(topol)

            topol.write_parm(OUTTOP)
            topol.write_rst7(OUTRST)
            with open(OUTTOP, 'rt') as infile:
                top_string = infile.read()
            with open(OUTRST, 'rt') as infile:
                crd_string = infile.read()
        return top_string, crd_string
示例#6
0
    def patch(self, top_string, crd_string):
        INTOP = "in.top"
        INRST = "in.rst"
        OUTTOP = "out.top"
        OUTRST = "out.rst"

        with util.in_temp_dir():
            with open(INTOP, "wt") as outfile:
                outfile.write(top_string)
            with open(INRST, "wt") as outfile:
                outfile.write(crd_string)

            topol = pmd.load_file(INTOP)
            crd = pmd.load_file(INRST)
            topol.coordinates = crd.coordinates

            self._add_particles(topol)

            topol.write_parm(OUTTOP)
            topol.write_rst7(OUTRST)
            with open(OUTTOP, "rt") as infile:
                top_string = infile.read()
            with open(OUTRST, "rt") as infile:
                crd_string = infile.read()
        return top_string, crd_string
示例#7
0
    def build_system_from_molecules(
        self, molecules, patchers=None, leap_header_cmds=None
    ):
        if patchers is None:
            patchers = []
        if leap_header_cmds is None:
            leap_header_cmds = []
        if isinstance(leap_header_cmds, str):
            leap_header_cmds = [leap_header_cmds]

        with util.in_temp_dir():
            leap_cmds = []
            mol_ids = []
            leap_cmds.extend(self._generate_leap_header())
            leap_cmds.extend(leap_header_cmds)
            for index, mol in enumerate(molecules):
                mol_id = f"mol_{index}"
                mol_ids.append(mol_id)
                mol.prepare_for_tleap(mol_id)
                leap_cmds.extend(mol.generate_tleap_input(mol_id))
            if self._explicit_solvent:
                leap_cmds.extend(self._generate_solvent(mol_ids))
                leap_cmds.extend(self._generate_leap_footer([f"solute"]))
            else:
                leap_cmds.extend(self._generate_leap_footer(mol_ids))

            with open("tleap.in", "w") as tleap_file:
                tleap_string = "\n".join(leap_cmds)
                tleap_file.write(tleap_string)
            subprocess.check_call("tleap -f tleap.in > tleap.out", shell=True)

            return load_amber_system("system.top", "system.mdcrd", patchers)
示例#8
0
    def test_init_mode_w_creates_results(self):
        "calling initialize should create the results.h5 file"
        with in_temp_dir():
            pdb_writer = object()  # dummy pdb writer; can't use a mock because they can't be pickled
            store = vault.DataStore(self.N_ATOMS, self.N_REPLICAS, pdb_writer)
            store.initialize(mode='w')

            self.assertTrue(os.path.exists('Data/Blocks/block_000000.nc'), 'results_000000.nc not created')
示例#9
0
    def test_load_datastore(self):
        "should call load the datastore"
        with in_temp_dir():
            os.mkdir("Logs")

            launch.launch("Reference", self.log_handler)

            self.MockDataStore.load_data_store.assert_called_once_with()
示例#10
0
    def test_should_init_store(self):
        "should initialize the store"
        with in_temp_dir():
            os.mkdir("Logs")

            launch.launch("Reference", self.log_handler)

            self.mock_store.initialize.assert_called_once_with(mode="a")
示例#11
0
    def test_should_init_comm(self):
        "should initialize the communicator"
        with in_temp_dir():
            os.mkdir("Logs")

            launch.launch("Reference", self.log_handler)

            self.mock_comm.initialize.assert_called_once_with()
示例#12
0
    def test_init_mode_w_creates_directories(self):
        "calling initialize should create the Data and Data/Backup directories"
        with in_temp_dir():
            pdb_writer = object()  # dummy pdb writer; can't use a mock because they can't be pickled
            store = vault.DataStore(self.N_ATOMS, self.N_REPLICAS, pdb_writer)
            store.initialize(mode='w')

            self.assertTrue(os.path.exists('Data'), 'Data directory does not created')
            self.assertTrue(os.path.exists('Data/Backup'), 'Backup directory not created')
示例#13
0
    def test_should_run(self):
        "should run remd runner with correct parameters"
        with in_temp_dir():
            os.mkdir("Logs")

            launch.launch("Reference", self.log_handler)

            self.mock_remd_leader.run.assert_called_once_with(
                self.mock_comm, self.mock_runner, self.mock_store)
示例#14
0
    def test_init_mode_w_raises_when_dirs_exist(self):
        "calling initialize should raise RuntimeError when Data and Data/Backup directories exist"
        with in_temp_dir():
            os.mkdir('Data')
            os.mkdir('Data/Backup')
            pdb_writer = object()  # dummy pdb writer; can't use a mock because they can't be pickled
            store = vault.DataStore(self.N_ATOMS, self.N_REPLICAS, pdb_writer)

            with self.assertRaises(RuntimeError):
                store.initialize(mode='w')
示例#15
0
    def test_init_mode_w_creates_results(self):
        "calling initialize should create the results.h5 file"
        with in_temp_dir():
            # dummy pdb writer; can't use a mock because they can't be pickled
            pdb_writer = object()
            store = vault.DataStore(self.N_ATOMS, self.N_REPLICAS, pdb_writer)
            store.initialize(mode='w')

            self.assertTrue(os.path.exists('Data/Blocks/block_000000.nc'),
                            'results_000000.nc not created')
示例#16
0
    def test_init_mode_w_raises_when_dirs_exist(self):
        "calling initialize should raise RuntimeError when Data directories exist"
        with in_temp_dir():
            os.mkdir("Data")
            os.mkdir("Data/Backup")
            # dummy pdb writer; can't use a mock because they can't be pickled
            pdb_writer = object()
            store = vault.DataStore(self.N_ATOMS, self.N_REPLICAS, pdb_writer)

            with self.assertRaises(RuntimeError):
                store.initialize(mode="w")
示例#17
0
    def test_save_and_load_run_options(self):
        "should be able to save and load run options"
        with in_temp_dir():
            pdb_writer = object()  # dummy pdb writer; can't use a mock because they can't be pickled
            store = vault.DataStore(self.N_ATOMS, self.N_REPLICAS, pdb_writer)
            store.initialize(mode='w')
            fake_run_options = object()

            store.save_run_options(fake_run_options)
            store.load_run_options()

            self.assertTrue(os.path.exists('Data/run_options.dat'))
示例#18
0
    def test_init_mode_w_creates_directories(self):
        "calling initialize should create the Data and Data/Backup directories"
        with in_temp_dir():
            # dummy pdb writer; can't use a mock because they can't be pickled
            pdb_writer = object()
            store = vault.DataStore(self.N_ATOMS, self.N_REPLICAS, pdb_writer)
            store.initialize(mode="w")

            self.assertTrue(os.path.exists("Data"),
                            "Data directory does not created")
            self.assertTrue(os.path.exists("Data/Backup"),
                            "Backup directory not created")
示例#19
0
    def test_save_and_load_run_options(self):
        "should be able to save and load run options"
        with in_temp_dir():
            # dummy pdb writer; can't use a mock because they can't be pickled
            pdb_writer = object()
            store = vault.DataStore(self.N_ATOMS, self.N_REPLICAS, pdb_writer)
            store.initialize(mode="w")
            fake_run_options = system.RunOptions()

            store.save_run_options(fake_run_options)
            store.load_run_options()

            self.assertTrue(os.path.exists("Data/run_options.dat"))
示例#20
0
    def test_save_and_load_system(self):
        "should be able to save and load a System"
        with in_temp_dir():
            # dummy pdb writer; can't use a mock because they can't be pickled
            pdb_writer = object()
            store = vault.DataStore(self.N_ATOMS, self.N_REPLICAS, pdb_writer)
            store.initialize(mode='w')
            fake_system = object()

            store.save_system(fake_system)
            store.load_system()

            self.assertTrue(os.path.exists('Data/system.dat'))
示例#21
0
    def test_save_and_load_system(self):
        "should be able to save and load a System"
        with in_temp_dir():
            # dummy pdb writer; can't use a mock because they can't be pickled
            pdb_writer = object()
            store = vault.DataStore(self.state_template, self.N_REPLICAS, pdb_writer)
            store.initialize(mode="w")
            fake_system = object()

            store.save_system(fake_system)
            store.load_system()

            self.assertTrue(os.path.exists("Data/system.dat"))
示例#22
0
    def test_save_and_load_data_store(self):
        "should be able to save and then reload the DataStore"
        with in_temp_dir():
            pdb_writer = object()  # dummy pdb writer; can't use a mock because they can't be pickled
            store = vault.DataStore(self.N_ATOMS, self.N_REPLICAS, pdb_writer)
            store.initialize(mode='w')

            store.save_data_store()
            store2 = vault.DataStore.load_data_store()

            self.assertEqual(store.n_atoms, store2.n_atoms)
            self.assertEqual(store.n_replicas, store2.n_replicas)
            self.assertIsNone(store2._cdf_data_set)
            self.assertTrue(os.path.exists('Data/data_store.dat'))
示例#23
0
    def test_save_and_load_data_store(self):
        "should be able to save and then reload the DataStore"
        with in_temp_dir():
            # dummy pdb writer; can't use a mock because they can't be pickled
            pdb_writer = object()
            store = vault.DataStore(self.N_ATOMS, self.N_REPLICAS, pdb_writer)
            store.initialize(mode="w")

            store.save_data_store()
            store2 = vault.DataStore.load_data_store()

            self.assertEqual(store.n_atoms, store2.n_atoms)
            self.assertEqual(store.n_replicas, store2.n_replicas)
            self.assertIsNone(store2._cdf_data_set)
            self.assertTrue(os.path.exists("Data/data_store.dat"))
示例#24
0
    def test_save_and_load_remd_runner(self):
        "should be able to save and reload an remd runner"
        with in_temp_dir():
            pdb_writer = object()  # dummy pdb writer; can't use a mock because they can't be pickled
            store = vault.DataStore(self.N_ATOMS, self.N_REPLICAS, pdb_writer)
            store.initialize(mode='w')
            l = ladder.NearestNeighborLadder(n_trials=100)
            policy = adaptor.AdaptationPolicy(1.0, 50, 100)
            a = adaptor.EqualAcceptanceAdaptor(n_replicas=self.N_REPLICAS, adaptation_policy=policy)
            runner = master_runner.MasterReplicaExchangeRunner(self.N_REPLICAS, max_steps=100, ladder=l, adaptor=a)

            store.save_remd_runner(runner)
            runner2 = store.load_remd_runner()

            self.assertEqual(runner.n_replicas, runner2.n_replicas)
            self.assertTrue(os.path.exists('Data/remd_runner.dat'))
示例#25
0
    def test_save_and_load_communicator(self):
        "should be able to save and reload the communicator"
        with in_temp_dir():
            pdb_writer = object()  # dummy pdb writer; can't use a mock because they can't be pickled
            store = vault.DataStore(self.N_ATOMS, self.N_REPLICAS, pdb_writer)
            store.initialize(mode='w')
            c = comm.MPICommunicator(self.N_ATOMS, self.N_REPLICAS)
            # set _mpi_comm to something
            # this should not be saved
            c._mpi_comm = 'foo'

            store.save_communicator(c)
            c2 = store.load_communicator()

            self.assertEqual(c.n_atoms, c2.n_atoms)
            self.assertEqual(c.n_replicas, c2.n_replicas)
            self.assertIsNone(c2._mpi_comm, '_mpi_comm should not be saved')
            self.assertTrue(os.path.exists('Data/communicator.dat'))
示例#26
0
    def test_save_and_load_communicator(self):
        "should be able to save and reload the communicator"
        with in_temp_dir():
            # dummy pdb writer; can't use a mock because they can't be pickled
            pdb_writer = object()
            store = vault.DataStore(self.N_ATOMS, self.N_REPLICAS, pdb_writer)
            store.initialize(mode="w")
            c = comm.MPICommunicator(self.N_ATOMS, self.N_REPLICAS)
            # set _mpi_comm to something
            # this should not be saved
            c._mpi_comm = "foo"

            store.save_communicator(c)
            c2 = store.load_communicator()

            self.assertEqual(c.n_atoms, c2.n_atoms)
            self.assertEqual(c.n_replicas, c2.n_replicas)
            self.assertTrue(os.path.exists("Data/communicator.dat"))
示例#27
0
    def test_save_and_load_remd_runner(self):
        "should be able to save and reload an remd runner"
        with in_temp_dir():
            # dummy pdb writer; can't use a mock because they can't be pickled
            pdb_writer = object()
            store = vault.DataStore(self.N_ATOMS, self.N_REPLICAS, pdb_writer)
            store.initialize(mode="w")
            l = ladder.NearestNeighborLadder(n_trials=100)
            policy = adaptor.AdaptationPolicy(1.0, 50, 100)
            a = adaptor.EqualAcceptanceAdaptor(n_replicas=self.N_REPLICAS,
                                               adaptation_policy=policy)
            runner = master_runner.MasterReplicaExchangeRunner(self.N_REPLICAS,
                                                               max_steps=100,
                                                               ladder=l,
                                                               adaptor=a)

            store.save_remd_runner(runner)
            runner2 = store.load_remd_runner()

            self.assertEqual(runner.n_replicas, runner2.n_replicas)
            self.assertTrue(os.path.exists("Data/remd_runner.dat"))
示例#28
0
 def build_system_from_molecules(self, molecules):
     with util.in_temp_dir():
         leap_cmds = []
         mol_ids = []
         leap_cmds.extend(self._generate_leap_header())
         for index, mol in enumerate(molecules):
             mol_id = 'mol_{}'.format(index)
             mol_ids.append(mol_id)
             mol.prepare_for_tleap(mol_id)
             leap_cmds.extend(mol.generate_tleap_input(mol_id))
         leap_cmds.extend(self._generate_leap_footer(mol_ids))
         with open('tleap.in', 'w') as tleap_file:
             tleap_string = '\n'.join(leap_cmds)
             tleap_file.write(tleap_string)
             print tleap_string
         subprocess.check_call('tleap -f tleap.in > tleap.out', shell=True)
         with open('system.top') as top_file:
             top = top_file.read()
         with open('system.mdcrd') as crd_file:
             crd = crd_file.read()
         return System(top, crd)
示例#29
0
文件: builder.py 项目: ccccclw/meld
    def build_system(
        self,
        subsystems: List[subsystem._SubSystem],
        patchers: Optional[List[patchers.PatcherBase]] = None,
        leap_header_cmds: Optional[List[str]] = None,
    ) -> interfaces.ISystem:
        """
        Build the system from SubSystems

        Args:
            subsystems: component subsystems that make up the system
            patchers: an optional list of patchers to modify system
            leap_header_cmds: an optional list of leap commands

        Returns:
            the MELD system
        """
        if not subsystems:
            raise ValueError("len(subsystems) must be > 0")

        if patchers is None:
            patchers = []
        if leap_header_cmds is None:
            leap_header_cmds = []
        if isinstance(leap_header_cmds, str):
            leap_header_cmds = [leap_header_cmds]

        with util.in_temp_dir():
            mol_ids = []
            chains = []
            current_res_index = 0
            leap_cmds = []
            leap_cmds.extend(self._generate_leap_header())
            leap_cmds.extend(leap_header_cmds)
            for index, sub in enumerate(subsystems):
                # First we'll update the indexing for this subsystem
                for chain in sub._info.chains:
                    residues_with_offset = {
                        k: v + current_res_index
                        for k, v in chain.residues.items()
                    }
                    chains.append(indexing._ChainInfo(residues_with_offset))
                current_res_index += sub._info.n_residues

                # now add the leap commands for this subsystem
                mol_id = f"mol_{index}"
                mol_ids.append(mol_id)
                sub.prepare_for_tleap(mol_id)
                leap_cmds.extend(sub.generate_tleap_input(mol_id))

            if self._explicit_solvent:
                leap_cmds.extend(self._generate_solvent(mol_ids))
                leap_cmds.extend(self._generate_leap_footer([f"solute"]))
            else:
                leap_cmds.extend(self._generate_leap_footer(mol_ids))

            with open("tleap.in", "w") as tleap_file:
                tleap_string = "\n".join(leap_cmds)
                tleap_file.write(tleap_string)
            try:
                subprocess.check_call("tleap -f tleap.in > tleap.out",
                                      shell=True)
            except subprocess.CalledProcessError:
                print("Call to tleap failed.")
                print()
                print()
                print()
                print("=========")
                print("tleap.in")
                print("=========")
                print(open("tleap.in").read())
                print()
                print()
                print()
                print("=========")
                print("tleap.out")
                print("=========")
                print(open("tleap.out").read())
                print()
                print()
                print()
                print("========")
                print("leap.log")
                print("========")
                print(open("leap.log").read())
                print()
                print()
                print()
                raise

            return meld_system._load_amber_system("system.top", "system.mdcrd",
                                                  chains, patchers)
示例#30
0
文件: patchers.py 项目: zhenglz/meld
    def patch(self, top_string, crd_string):
        INTOP = "in.top"
        INRST = "in.rst"
        OUTTOP = "out.top"
        OUTRST = "out.rst"

        with util.in_temp_dir():
            with open(INTOP, "wt") as outfile:
                outfile.write(top_string)
            with open(INRST, "wt") as outfile:
                outfile.write(crd_string)

            base = pmd.load_file(INTOP)
            crd = pmd.load_file(INRST)
            base.coordinates = crd.coordinates

            # create a new structure to add our dummy atoms to
            parm = pmd.Structure()

            # add in atom type for our dummy particles
            atype = pmd.AtomType("SDUM", 0, mass=12.0, charge=0.0)
            atype.set_lj_params(0.0, 0.0)

            for i in range(self.n_tensors):
                a1 = pmd.Atom(
                    name="S1",
                    atomic_number=atype.atomic_number,
                    type=str(atype),
                    charge=atype.charge,
                    mass=atype.mass,
                    solvent_radius=1.0,
                    screen=0.5,
                )
                a1.atom_type = atype

                a2 = pmd.Atom(
                    name="S2",
                    atomic_number=atype.atomic_number,
                    type=str(atype),
                    charge=atype.charge,
                    mass=atype.mass,
                    solvent_radius=1.0,
                    screen=0.5,
                )
                a2.atom_type = atype

                parm.add_atom(a1, resname="SDM", resnum=i)
                parm.add_atom(a2, resname="SDM", resnum=i)

            # we add noise here because we'll get NaN if the particles ever
            # end up exactly on top of each other
            parm.positions = np.zeros((2 * self.n_tensors, 3))

            # combine the old system with the new dummy atoms
            comb = base + parm
            last_index = comb.residues[-1].idx
            self.resids = list(range(last_index - self.n_tensors + 2, last_index + 2))

            comb.write_parm(OUTTOP)
            comb.write_rst7(OUTRST)
            with open(OUTTOP, "rt") as infile:
                top_string = infile.read()
            with open(OUTRST, "rt") as infile:
                crd_string = infile.read()
        return top_string, crd_string