def setX(self, xVec): currentParams = AmberParm(self.currentPrmtop) for x, p in zip(xVec, self.parameter2optimize): if p.kind == "bond": for b in currentParams.bonds: if set([b.atom1.type, b.atom2.type]) == p.atomMask: if p.valueType == "req": b.type.req = x elif p.valueType == "kr": b.type.k = x break elif p.kind == "angle": for a in currentParams.angles: angleTypes = [a.atom1.type, a.atom2.type, a.atom3] angleTypesRev = reversed(angleTypes) if angleTypes == p.atomMask or angleTypesRev == p.atomMask: if p.valueType == "kt": a.type.k = x elif p.valueType == "theq": a.type.theteq = x break currentParams.write_parm(self.currentPrmtop)
def test_gas_energy_conf_2(self): """ Compare Amber and OpenMM gas phase energies and forces (topology 2) """ parm = AmberParm(get_fn('hydrogen-peroxide_T0_2.prmtop'), get_fn('hydrogen-peroxide_T0_2.rst7')) self.assertEqual(parm.combining_rule, 'lorentz') system = parm.createSystem() # Default, no cutoff integrator = mm.VerletIntegrator(1.0*u.femtoseconds) sim = app.Simulation(parm.topology, system, integrator, platform=CPU) sim.context.setPositions(parm.positions) energies = energy_decomposition(parm, sim.context) #BOND = 0.0319 ANGLE = 2.1690 DIHED = -2.7931 #VDWAALS = 0.0000 EEL = 0.0000 HBOND = 0.0000 #1-4 VDW = 0.0000 1-4 EEL = 0.0000 RESTRAINT = 0.0000 # Compare OpenMM energies with the Amber energies (above) self.assertAlmostEqual(energies['bond'], 0.0319, places=4) self.assertAlmostEqual(energies['angle'], 2.1690, places=4) self.assertAlmostEqual(energies['dihedral'],-2.7931, places=4) self.assertRelativeEqual(energies['nonbonded'], 0.0, places=3) # Now test the forces to make sure that they are computed correctly in # the presence of extra points pstate = sim.context.getState(getForces=True) pf = pstate.getForces().value_in_unit(u.kilojoule_per_mole/u.nanometer) # gmx forces: # f[ 0]={ 3.14357e+02, -5.90363e+02, 2.11410e+02} # f[ 1]={-3.14357e+02, 5.90363e+02, 2.11410e+02} # f[ 2]={ 2.70641e+02, 5.90363e+02, -2.11410e+02} # f[ 3]={-2.70641e+02, -5.90363e+02, -2.11410e+02} gf = [ ( 3.14357e+02, -5.90363e+02, 2.11410e+02), (-3.14357e+02, 5.90363e+02, 2.11410e+02), ( 2.70641e+02, 5.90363e+02, -2.11410e+02), (-2.70641e+02, -5.90363e+02, -2.11410e+02)] for p, s in zip(pf, gf): for x1, x2 in zip(p, s): self.assertAlmostEqual(x1, x2, places=3)
def setup_hmr(self): if not SETTINGS["md"]["use_hmr"]: return top_file = SETTINGS["data_files"]["top_file"] logger.info(f"Applying HMR on topology file {top_file}") parm = AmberParm(top_file) HMassRepartition(parm).execute() parm.write_parm(top_file) logger.info("HMR applied")
def main(): prmtop_filename = '<topology>' crd_filename = '<coordinate>' prmtop = AmberParm(prmtop_filename, crd_filename) system = prmtop.createSystem(nonbondedMethod=app.PME, nonbondedCutoff=10*unit.angstrom, constraints=app.HBonds, switchDistance=8*unit.angstrom) temperature = 300 * unit.kelvin pressure = 1 * unit.atmosphere collision_rate = 5 / unit.picosecond timestep = 2 * unit.femtosecond integrator = openmm.LangevinIntegrator(temperature, collision_rate, timestep) barostat = openmm.MonteCarloBarostat(temperature, pressure) system.addForce(barostat) system.setDefaultPeriodicBoxVectors(*prmtop.box_vectors) simulation = app.Simulation(prmtop.topology, system, integrator) simulation.context.setPositions(prmtop.positions) simulation.context.setVelocitiesToTemperature(temperature) print('System contains {} atoms.'.format(system.getNumParticles())) print('Using platform "{}".'.format(simulation.context.getPlatform().getName())) print('Minimizing energy to avoid clashes.') simulation.minimizeEnergy(maxIterations=100) print('Initial potential energy is {}'.format(simulation.context.getState(getEnergy=True).getPotentialEnergy())) # Warm up the integrator to compile kernels, etc print('Warming up integrator to trigger kernel compilation...') simulation.step(10) # Time integration print('Benchmarking...') nsteps = <numsteps> initial_time = time.time() integrator.step(nsteps) final_time = time.time() elapsed_time = (final_time - initial_time) * unit.seconds simulated_time = nsteps * timestep performance = (simulated_time / elapsed_time) print('Completed {} steps in {}.'.format(nsteps, elapsed_time)) print('Performance is {} ns/day'.format(performance / (unit.nanoseconds/unit.day))) print('Final potential energy is {}'.format(simulation.context.getState(getEnergy=True).getPotentialEnergy()))
def perturb_parameters(perturb, hmr, prmtop): """ Use ParmEd to make parameter perturbations """ new_param = prmtop parm = AmberParm(prmtop + '.prmtop') logfile = open('parmed.log', 'w') if perturb == 'yes': # Parsing the input file that includes new parameters with open('new_params.dat') as fr: lines = fr.read().splitlines() lines = list(line for line in lines if line) # Remove blank lines for line in lines: if not line[0] == ';': splitline = line.split() if len(splitline) < 4: print 'Aborted. Wrong format! Please provide atom type(e.g.,OW), parameter type(e.g.,vdw), and the corresponding radius/epsilon parameters ' print '(separated with spaces.)\n' atom_type = splitline[0] param_type = splitline[1] radius = splitline[2] epsilon = splitline[3] if param_type.lower() == 'vdw': action = changeLJSingleType(parm, "@%" + atom_type, radius, epsilon) action.execute() logfile.write(('%s\n' % action)) else: print 'Aborted. Only the feauture of perturbing vdW parameters is supported for now.\n' sys.exit(1) new_param += '.perturbed' if os.path.isfile(new_param + '.prmtop'): os.remove(new_param + '.prmtop') Structure.save(parm, new_param + '.prmtop') if hmr == 'yes': parm = AmberParm(new_param + '.prmtop') # Use the ParmEd API, which is more stable than calling a subprocess action = HMassRepartition(parm) action.execute() logfile.write(('%s\n' % action)) new_param += '.hmr' if os.path.isfile(new_param + '.prmtop'): os.remove(new_param + '.prmtop') Structure.save(parm, new_param + '.prmtop') return new_param
def test_gas_energy_conf_4(self): """ Compare Amber and OpenMM gas phase energies and forces (topology 4) """ parm = AmberParm(get_fn('ethanol_T0.prmtop'), get_fn('ethanol_T0.rst7')) self.assertEqual(parm.combining_rule, 'geometric') system = parm.createSystem() # Default, no cutoff integrator = mm.VerletIntegrator(1.0 * u.femtoseconds) sim = app.Simulation(parm.topology, system, integrator, platform=CPU) sim.context.setPositions(parm.positions) energies = energy_decomposition(parm, sim.context) #BOND = 0.0239 ANGLE = 0.0298 DIHED = 0.0093 #VDWAALS = 0.0000 EEL = 6.7526 HBOND = 0.0000 #1-4 VDW = 0.0492 1-4 EEL = -6.0430 RESTRAINT = 0.0000 # Compare OpenMM energies with the Amber energies (above) self.assertAlmostEqual(energies['bond'], 0.0239, places=4) self.assertAlmostEqual(energies['angle'], 0.0298, places=4) self.assertAlmostEqual(energies['dihedral'], 0.0093, places=4) self.assertRelativeEqual(energies['nonbonded'], 0.0000 + 6.7526 + 0.0492 - 6.0430, places=3) # Now test the forces to make sure that they are computed correctly in # the presence of extra points pstate = sim.context.getState(getForces=True) pf = pstate.getForces().value_in_unit(u.kilojoule_per_mole / u.nanometer) # gmx forces: # f[ 0]={ 1.73101e+02, 5.67250e+01, -4.02950e+01} # f[ 1]={-8.13704e+00, -1.79612e+01, 9.88537e+01} # f[ 2]={-2.83120e+01, 6.23352e+00, -5.47393e+00} # f[ 3]={-1.03312e+01, -1.00966e+01, -5.12129e+00} # f[ 4]={-1.69636e+02, 3.34850e+01, -1.73612e+02} # f[ 5]={ 4.19932e+00, -2.58283e+00, 1.29999e+02} # f[ 6]={ 3.02865e+01, -6.68331e+00, -2.99153e+01} # f[ 7]={ 1.00113e+02, -5.22480e+01, 4.80526e+01} # f[ 8]={-9.12828e+01, -6.87157e+00, -2.24877e+01} gf = [(1.73101e+02, 5.67250e+01, -4.02950e+01), (-8.13704e+00, -1.79612e+01, 9.88537e+01), (-2.83120e+01, 6.23352e+00, -5.47393e+00), (-1.03312e+01, -1.00966e+01, -5.12129e+00), (-1.69636e+02, 3.34850e+01, -1.73612e+02), (4.19932e+00, -2.58283e+00, 1.29999e+02), (3.02865e+01, -6.68331e+00, -2.99153e+01), (1.00113e+02, -5.22480e+01, 4.80526e+01), (-9.12828e+01, -6.87157e+00, -2.24877e+01)] for p, s in zip(pf, gf): for x1, x2 in zip(p, s): self.assertAlmostEqual(x1, x2, places=3)
def readX(self): currentParams = AmberParm(self.currentPrmtop) x = [] for p in self.parameter2optimize: if p.kind == "bond": for b in currentParams.bonds: if set([b.atom1.type, b.atom2.type]) == p.atomMask: if p.valueType == "req": value = b.type.req elif p.valueType == "kr": value = b.type.k x.append(value) break elif p.kind == "angle": for a in currentParams.angles: angleTypes = [a.atom1.type, a.atom2.type, a.atom3] angleTypesRev = reversed(angleTypes) if angleTypes == p.atomMask or angleTypesRev == p.atomMask: if p.valueType == "kt": value = a.type.k elif p.valueType == "theq": value = a.type.theteq x.append(value) break return x
def solvate(self, solvent, suffix=None, tmp=True): """ Solvate system in OFF using solvent *solvent*. A PRMTOP and PRMCRD files will be saved and paths stored to :attr:`top` and :attr:`crd`. :arg solvent: Solvent Instance or Name to fetch the Solvent Instance in the database. :type: str or :class:`~Solvents.Solvent` :arg str suffix: Suffix for output files. Prefix will be the system name. E.g.: ``systemname_suffix.prmtop`` and ``systemname_suffix.prmcrd``. :arg bool tmp: Work in temporary folder. """ if not self.amberOFF: raise SystemError, "Can not solvate if no Amber Object File is assigned." if isinstance(solvent, str): solvent = Solvents.getSolvent(solvent) if not solvent: raise SystemError, 'Invalid solvent instance or name.' # Build a loger just for this method log = logging.getLogger("SystemLogger") log.info("Solvating %s with solvent mixture %s"%(self.name, solvent.name)) suffix = suffix or solvent.name name = '{0}_{1}'.format(self.name, suffix) prmtop = name+'.prmtop' prmcrd = name+'.prmcrd' if tmp: if isinstance(tmp, str): path = tmp else: path = T.tempDir() prmtop = osp.join(path, prmtop) prmcrd = osp.join(path, prmcrd) # Initiate AmberCreateSystem with loaded AmberOFF # Solvate, neutralize self.__initCreate() self.create.solvateOrganic(self.unitName, solvent=solvent) # It will work even if its water self.create.saveAmberParm(self.unitName, prmtop, prmcrd) # Added by Xiaofeng 01/12/2016 parm = AmberParm(prmtop) action = HMassRepartition(parm) action.execute() log.info(str(action)) parm.write_parm(prmtop) # self.__cleanCreate() s = SolvatedSystem(name, prmtop, prmcrd, solvent=solvent.name, ref=self.ref) return s
def test_gas_energy_conf_4(self): """ Compare Amber and OpenMM gas phase energies and forces (topology 4) """ parm = AmberParm(get_fn('ethanol_T0.prmtop'), get_fn('ethanol_T0.rst7')) self.assertEqual(parm.combining_rule, 'geometric') system = parm.createSystem() # Default, no cutoff integrator = mm.VerletIntegrator(1.0*u.femtoseconds) sim = app.Simulation(parm.topology, system, integrator, platform=CPU) sim.context.setPositions(parm.positions) energies = energy_decomposition(parm, sim.context) #BOND = 0.0239 ANGLE = 0.0298 DIHED = 0.0093 #VDWAALS = 0.0000 EEL = 6.7526 HBOND = 0.0000 #1-4 VDW = 0.0492 1-4 EEL = -6.0430 RESTRAINT = 0.0000 # Compare OpenMM energies with the Amber energies (above) self.assertAlmostEqual(energies['bond'], 0.0239, places=4) self.assertAlmostEqual(energies['angle'], 0.0298, places=4) self.assertAlmostEqual(energies['dihedral'], 0.0093, places=4) self.assertRelativeEqual(energies['nonbonded'], 0.0000+6.7526+0.0492-6.0430, places=3) # Now test the forces to make sure that they are computed correctly in # the presence of extra points pstate = sim.context.getState(getForces=True) pf = pstate.getForces().value_in_unit(u.kilojoule_per_mole/u.nanometer) # gmx forces: # f[ 0]={ 1.73101e+02, 5.67250e+01, -4.02950e+01} # f[ 1]={-8.13704e+00, -1.79612e+01, 9.88537e+01} # f[ 2]={-2.83120e+01, 6.23352e+00, -5.47393e+00} # f[ 3]={-1.03312e+01, -1.00966e+01, -5.12129e+00} # f[ 4]={-1.69636e+02, 3.34850e+01, -1.73612e+02} # f[ 5]={ 4.19932e+00, -2.58283e+00, 1.29999e+02} # f[ 6]={ 3.02865e+01, -6.68331e+00, -2.99153e+01} # f[ 7]={ 1.00113e+02, -5.22480e+01, 4.80526e+01} # f[ 8]={-9.12828e+01, -6.87157e+00, -2.24877e+01} gf = [ ( 1.73101e+02, 5.67250e+01, -4.02950e+01), (-8.13704e+00, -1.79612e+01, 9.88537e+01), (-2.83120e+01, 6.23352e+00, -5.47393e+00), (-1.03312e+01, -1.00966e+01, -5.12129e+00), (-1.69636e+02, 3.34850e+01, -1.73612e+02), ( 4.19932e+00, -2.58283e+00, 1.29999e+02), ( 3.02865e+01, -6.68331e+00, -2.99153e+01), ( 1.00113e+02, -5.22480e+01, 4.80526e+01), (-9.12828e+01, -6.87157e+00, -2.24877e+01)] for p, s in zip(pf, gf): for x1, x2 in zip(p, s): self.assertAlmostEqual(x1, x2, places=3)
def oemol_to_openmm_system_amber(oemol, molecule_name): """ Create an openmm system out of an oemol Returns ------- system : openmm.System object the system from the molecule positions : [n,3] np.array of floats """ _ , tripos_mol2_filename = openmoltools.openeye.molecule_to_mol2(oemol, tripos_mol2_filename=molecule_name + '.tripos.mol2', conformer=0, residue_name='MOL') gaff_mol2, frcmod = openmoltools.amber.run_antechamber(molecule_name, tripos_mol2_filename) prmtop_file, inpcrd_file = openmoltools.amber.run_tleap(molecule_name, gaff_mol2, frcmod) from parmed.amber import AmberParm prmtop = AmberParm(prmtop_file) system = prmtop.createSystem(implicitSolvent=None, removeCMMotion=False) crd = app.AmberInpcrdFile(inpcrd_file) return system, crd.getPositions(asNumpy=True), prmtop.topology
def test_gas_energy_conf_3(self): """ Compare Amber and OpenMM gas phase energies and forces (topology 3) """ parm = AmberParm(get_fn('methanol_T0.prmtop'), get_fn('methanol_T0.rst7')) self.assertEqual(parm.combining_rule, 'geometric') system = parm.createSystem() # Default, no cutoff integrator = mm.VerletIntegrator(1.0 * u.femtoseconds) sim = app.Simulation(parm.topology, system, integrator, platform=CPU) sim.context.setPositions(parm.positions) energies = energy_decomposition(parm, sim.context) #BOND = 0.0224 ANGLE = 0.0469 DIHED = 0.0039 #VDWAALS = 0.0000 EEL = 0.0000 HBOND = 0.0000 #1-4 VDW = 0.0000 1-4 EEL = 3.3789 RESTRAINT = 0.0000 # Compare OpenMM energies with the Amber energies (above) self.assertAlmostEqual(energies['bond'], 0.0224, places=4) self.assertAlmostEqual(energies['angle'], 0.0469, places=4) self.assertAlmostEqual(energies['dihedral'], 0.0039, places=4) self.assertRelativeEqual(energies['nonbonded'], 3.3789, places=3) # Now test the forces to make sure that they are computed correctly in # the presence of extra points pstate = sim.context.getState(getForces=True) pf = pstate.getForces().value_in_unit(u.kilojoule_per_mole / u.nanometer) # gmx forces: # f[ 0]={ 2.19935e+01, 8.60143e+01, 1.77895e+02} # f[ 1]={ 5.25347e+01, 3.46119e+01, -9.73738e+01} # f[ 2]={ 1.76138e+01, -7.13778e+01, -1.08807e+00} # f[ 3]={-3.74994e+01, -5.39602e+01, -6.75679e+01} # f[ 4]={-8.35142e+01, -7.86616e+01, -1.60611e+02} # f[ 5]={ 2.88716e+01, 8.33735e+01, 1.48746e+02} gf = [(2.19935e+01, 8.60143e+01, 1.77895e+02), (5.25347e+01, 3.46119e+01, -9.73738e+01), (1.76138e+01, -7.13778e+01, -1.08807e+00), (-3.74994e+01, -5.39602e+01, -6.75679e+01), (-8.35142e+01, -7.86616e+01, -1.60611e+02), (2.88716e+01, 8.33735e+01, 1.48746e+02)] for p, s in zip(pf, gf): for x1, x2 in zip(p, s): self.assertAlmostEqual(x1, x2, places=3)
def test_gas_energy_conf_3(self): """ Compare Amber and OpenMM gas phase energies and forces (topology 3) """ parm = AmberParm(get_fn('methanol_T0.prmtop'), get_fn('methanol_T0.rst7')) self.assertEqual(parm.combining_rule, 'geometric') system = parm.createSystem() # Default, no cutoff integrator = mm.VerletIntegrator(1.0*u.femtoseconds) sim = app.Simulation(parm.topology, system, integrator, platform=CPU) sim.context.setPositions(parm.positions) energies = energy_decomposition(parm, sim.context) #BOND = 0.0224 ANGLE = 0.0469 DIHED = 0.0039 #VDWAALS = 0.0000 EEL = 0.0000 HBOND = 0.0000 #1-4 VDW = 0.0000 1-4 EEL = 3.3789 RESTRAINT = 0.0000 # Compare OpenMM energies with the Amber energies (above) self.assertAlmostEqual(energies['bond'], 0.0224, places=4) self.assertAlmostEqual(energies['angle'], 0.0469, places=4) self.assertAlmostEqual(energies['dihedral'], 0.0039, places=4) self.assertRelativeEqual(energies['nonbonded'], 3.3789, places=3) # Now test the forces to make sure that they are computed correctly in # the presence of extra points pstate = sim.context.getState(getForces=True) pf = pstate.getForces().value_in_unit(u.kilojoule_per_mole/u.nanometer) # gmx forces: # f[ 0]={ 2.19935e+01, 8.60143e+01, 1.77895e+02} # f[ 1]={ 5.25347e+01, 3.46119e+01, -9.73738e+01} # f[ 2]={ 1.76138e+01, -7.13778e+01, -1.08807e+00} # f[ 3]={-3.74994e+01, -5.39602e+01, -6.75679e+01} # f[ 4]={-8.35142e+01, -7.86616e+01, -1.60611e+02} # f[ 5]={ 2.88716e+01, 8.33735e+01, 1.48746e+02} gf = [ ( 2.19935e+01, 8.60143e+01, 1.77895e+02), ( 5.25347e+01, 3.46119e+01, -9.73738e+01), ( 1.76138e+01, -7.13778e+01, -1.08807e+00), (-3.74994e+01, -5.39602e+01, -6.75679e+01), (-8.35142e+01, -7.86616e+01, -1.60611e+02), ( 2.88716e+01, 8.33735e+01, 1.48746e+02)] for p, s in zip(pf, gf): for x1, x2 in zip(p, s): self.assertAlmostEqual(x1, x2, places=3)
def main(): parser = argparse.ArgumentParser( description="Create CVs file from amber masks") parser.add_argument("top", help="Topology file") parser.add_argument("defs", help="CV definitions") args = parser.parse_args() top = AmberParm(args.top) with open(args.defs, 'r') as f: cv_defs = f.readlines() print('{}'.format(len(cv_defs))) for cv_def in cv_defs: write_cv(top, cv_def)
def read_amber_prm(pfile, cfile): prmtop = AmberParm(pfile) crds = read_rstf(cfile) atids = list(range(1, len(prmtop.parm_data['ATOM_NAME']) + 1)) resids = list(range(1, len(prmtop.parm_data['RESIDUE_LABEL']) + 1)) if len(prmtop.parm_data['ATOM_NAME']) != len(crds): raise ReadError('The toplogy and coordinates file are not \ consistent in the atom numbers.') residues = {} atoms = {} for i in range(0, len(prmtop.parm_data['RESIDUE_LABEL'])): resid = i + 1 resname = prmtop.parm_data['RESIDUE_LABEL'][i] if i < len(prmtop.parm_data['RESIDUE_LABEL']) - 1: resconter = list(range(prmtop.parm_data['RESIDUE_POINTER'][i], \ prmtop.parm_data['RESIDUE_POINTER'][i+1])) else: resconter = list(range(prmtop.parm_data['RESIDUE_POINTER'][i], \ len(prmtop.parm_data['ATOM_NAME'])+1)) residues[resid] = Residue(resid, resname, resconter) for j in resconter: gtype = 'ATOM' atid = j atname = prmtop.parm_data['ATOM_NAME'][j - 1] element = prmtop.parm_data['ATOMIC_NUMBER'][j - 1] atomtype = prmtop.parm_data['AMBER_ATOM_TYPE'][j - 1] crd = crds[j - 1] charge = prmtop.parm_data['CHARGE'][j - 1] try: element = AtnumRev[element] except: print(resname, atname, atomtype) element = 'X' atoms[j] = Atom(gtype, atid, atname, element, atomtype, crd, charge, \ resid, resname) mol = Molecule(atoms, residues) return prmtop, mol, atids, resids
def test_gas_energy_conf_2(self): """ Compare Amber and OpenMM gas phase energies and forces (topology 2) """ parm = AmberParm(get_fn('hydrogen-peroxide_T0_2.prmtop'), get_fn('hydrogen-peroxide_T0_2.rst7')) self.assertEqual(parm.combining_rule, 'lorentz') system = parm.createSystem() # Default, no cutoff integrator = mm.VerletIntegrator(1.0 * u.femtoseconds) sim = app.Simulation(parm.topology, system, integrator, platform=CPU) sim.context.setPositions(parm.positions) energies = energy_decomposition(parm, sim.context) #BOND = 0.0319 ANGLE = 2.1690 DIHED = -2.7931 #VDWAALS = 0.0000 EEL = 0.0000 HBOND = 0.0000 #1-4 VDW = 0.0000 1-4 EEL = 0.0000 RESTRAINT = 0.0000 # Compare OpenMM energies with the Amber energies (above) self.assertAlmostEqual(energies['bond'], 0.0319, places=4) self.assertAlmostEqual(energies['angle'], 2.1690, places=4) self.assertAlmostEqual(energies['dihedral'], -2.7931, places=4) self.assertRelativeEqual(energies['nonbonded'], 0.0, places=3) # Now test the forces to make sure that they are computed correctly in # the presence of extra points pstate = sim.context.getState(getForces=True) pf = pstate.getForces().value_in_unit(u.kilojoule_per_mole / u.nanometer) # gmx forces: # f[ 0]={ 3.14357e+02, -5.90363e+02, 2.11410e+02} # f[ 1]={-3.14357e+02, 5.90363e+02, 2.11410e+02} # f[ 2]={ 2.70641e+02, 5.90363e+02, -2.11410e+02} # f[ 3]={-2.70641e+02, -5.90363e+02, -2.11410e+02} gf = [(3.14357e+02, -5.90363e+02, 2.11410e+02), (-3.14357e+02, 5.90363e+02, 2.11410e+02), (2.70641e+02, 5.90363e+02, -2.11410e+02), (-2.70641e+02, -5.90363e+02, -2.11410e+02)] for p, s in zip(pf, gf): for x1, x2 in zip(p, s): self.assertAlmostEqual(x1, x2, places=3)
def get_total_energy(agls): # get the coor from pyrosetta inp_coor=generate_coord(agls) # initialize the object topology with coordinates parm=AmberParm("tpp-1.prmtop",inp_coor) # set up the input options inp=sander.gas_input() sander.setup (parm, parm.coordinates, None, inp) # compute the energy and force eney, frc=sander.energy_forces() # print('sander',eney.tot,eney.gb,eney.vdw, eney.elec, eney.dihedral,eney.angle, eney.bond) # clean and finish sander.cleanup() return eney.tot
def main(): parser = argparse.ArgumentParser( description="Create CVs file for unbinding") parser.add_argument("top", help="Topology file") parser.add_argument("masks", help="Masks file (with masks for 6 centers (P1..L3") args = parser.parse_args() top = AmberParm(args.top) masks = read_masks(args.masks) centers = {name: get_center(top, mask) for name, mask in masks.items()} with open('CVs', 'w') as f: f.write('6\n\n') for cv in CVS: compile_cv(f, centers, *cv)
def Get_prmtop_info(self): self.prmtop=AmberParm(self.prmname) self.natom=len(self.prmtop.atoms) self.nres=len(self.prmtop.residues) atomname=self.prmtop.parm_data["ATOM_NAME"] eleindex=self.prmtop.parm_data['ATOMIC_NUMBER'] atomcrg=self.prmtop.parm_data['CHARGE'] self.totalcharge=round(np.sum(atomcrg)) self.atoms=np.array(eleindex) self.respts=np.array(self.prmtop.parm_data['RESIDUE_POINTER'])-1 respte=self.prmtop.parm_data['RESIDUE_POINTER'][1:] respte.append(self.natom+1) self.respte=np.array(respte)-2 self.rescrg=np.zeros(self.nres) for i in range(self.nres): self.rescrg[i]=round(np.sum(atomcrg[self.respts[i]:self.respte[i]+1])) print (self.rescrg)
def test_add_amber_parm(self): """ Test adding AmberParm-derived instances to ParmList """ parms = ParmList() amber = AmberParm(get_fn('tip4p.parm7')) chamber = ChamberParm(get_fn('ala_ala_ala.parm7')) amoeba = AmoebaParm(get_fn('nma.parm7')) parms.add_parm(amber) parms.add_parm(chamber) parms.add_parm(amoeba) self.assertEqual(len(parms), 3) # Test int indexing self.assertIs(parms[0], amber) self.assertIs(parms[1], chamber) self.assertIs(parms[2], amoeba) self.assertRaises(IndexError, lambda: parms[3]) # Test name indexing self.assertIs(parms[get_fn('tip4p.parm7')], amber) self.assertIs(parms[get_fn('ala_ala_ala.parm7')], chamber) self.assertIs(parms[get_fn('nma.parm7')], amoeba) self.assertRaises(IndexError, lambda: parms['noparm']) # Check that the last added parm is active self.assertIs(parms.parm, amoeba) # Set a new active topology parms.set_new_active(0) self.assertIs(parms.parm, amber) parms.set_new_active(get_fn('ala_ala_ala.parm7')) self.assertIs(parms.parm, chamber) self.assertRaises(IndexError, lambda: parms.set_new_active(3)) self.assertIs(parms.parm, chamber) self.assertRaises(exc.DuplicateParm, lambda: parms.add_parm(get_fn('ala_ala_ala.parm7'))) self.assertRaises( exc.DuplicateParm, lambda: parms.add_parm(load_file(get_fn('ala_ala_ala.parm7')))) self.assertRaises( exc.ParmError, lambda: parms.add_parm( os.path.join(get_fn('pptest1'), 'pptest1.h'))) self.assertRaises(exc.ParmError, lambda: parms.add_parm(get_fn('amino12.lib'))) self.assertRaises(exc.ParmError, lambda: parms.add_parm(object()))
def prepare_prefinal_topology(self): import os # self.path_to_final_struct from runmd2.MD import TleapInput from parmed.amber import AmberParm, AmberMask from parmed.topologyobjects import Atom final_tleap = TleapInput() final_tleap.source(os.environ["PRMTOP_HOME"] + "/cmd/leaprc.protein.chlorolys.ff14SB") final_tleap.source(os.environ["PRMTOP_HOME"] + "/cmd/leaprc.water.tip3p") final_tleap.add_command("loadamberparams frcmod.ionsjc_tip3p") final_tleap.load_pdb("./input2.pdb") #final_tleap.add_command("bond wbox.32.SG wbox.69.C2 ") final_tleap.solvate_oct("TIP3PBOX", 15.0) final_tleap.add_ions("Na+", target_charge=0) final_tleap.save_params(output_name=MD._build_dir + "/prefinal_box") final_tleap.save_pdb(output_name=MD._build_dir + "/prefinal_box") final_tleap.add_command("quit") final_tleap.write_commands_to(MD._build_dir + "/prefinal_tleap.rc") self.call_cmd( ["tleap", "-s", "-f", MD._build_dir + "/prefinal_tleap.rc"]) # strip redundant water molecules parm_old = AmberParm(MD._build_dir + "/box.prmtop") parm_new = AmberParm(MD._build_dir + "/prefinal_box.prmtop") old_res = set() new_res = set() for r in parm_old.residues: old_res.add(r.number) number = r.number old_res.add(number + 1) for r in parm_new.residues: new_res.add(r.number) residues_to_delete = sorted(list(new_res - old_res)) res_mask = ":" + ','.join(list(map(str, residues_to_delete))) parm_new.strip(res_mask) parm_new.write_parm(MD._build_dir + "/prefinal_box.mod.prmtop")
def get_rmsd(initparas): global idxs, mcresids2, atompairs #Modify the C4 terms in the prmtop file for i in range(0, len(idxs)): prmtop.parm_data['LENNARD_JONES_CCOEF'][idxs[i]] = initparas[i] #Overwrite the prmtop file prmtop.write_parm('OptC4.top') #Perform the OpenMM optimization #Use AmberParm function to transfer the topology and #coordinate file to the object OpenMM can use Ambermol = AmberParm('OptC4.top', options.cfile) # Create the OpenMM system print('Creating OpenMM System') if options.simupha == 'gas': system = Ambermol.createSystem(nonbondedMethod=app.NoCutoff) elif options.simupha == 'liquid': system = Ambermol.createSystem( nonbondedMethod=app.PME, nonbondedCutoff=8.0 * u.angstroms, constraints=app.HBonds, ) #Add restraints force = mm.CustomExternalForce("k*((x-x0)^2+(y-y0)^2+(z-z0)^2)") force.addGlobalParameter("k", 200.0) force.addPerParticleParameter("x0") force.addPerParticleParameter("y0") force.addPerParticleParameter("z0") #for i in range(0, len(Ambermol.atoms)): for i, atom_crd in enumerate(Ambermol.positions): #if (Ambermol.atoms[i].residue.number+1 not in mcresids2) and \ if (i+1 not in mcresids2) and \ (Ambermol.atoms[i].residue.name not in ['WAT', 'HOH']) and \ (Ambermol.atoms[i].name in ['CA', 'C', 'N']): force.addParticle(i, atom_crd.value_in_unit(u.nanometers)) system.addForce(force) # Create the integrator to do Langevin dynamics # Temperature of heat bath, Friction coefficient, Time step integrator = mm.LangevinIntegrator( 300 * u.kelvin, 1.0 / u.picoseconds, 1.0 * u.femtoseconds, ) # Define the platform to use; CUDA, OpenCL, CPU, or Reference. Or do not # specify the platform to use the default (fastest) platform # Create the Simulation object if options.platf == 'ref': platform = mm.Platform.getPlatformByName('Reference') sim = app.Simulation(Ambermol.topology, system, integrator, platform) elif options.platf == 'cpu': platform = mm.Platform.getPlatformByName('CPU') sim = app.Simulation(Ambermol.topology, system, integrator, platform) elif options.platf == 'cuda': platform = mm.Platform.getPlatformByName('CUDA') prop = dict(CudaPrecision=options.presn) sim = app.Simulation(Ambermol.topology, system, integrator, platform, prop) elif options.platf == 'opencl': platform = mm.Platform.getPlatformByName('OpenCL') prop = dict(OpenCLPrecision=options.presn) sim = app.Simulation(Ambermol.topology, system, integrator, platform, prop) # Set the particle positions sim.context.setPositions(Ambermol.positions) # Output the rst file restrt = RestartReporter(options.rfile, 100, write_velocities=False) sim.reporters.append(restrt) # Minimize the energy print('Minimizing energy ' + str(options.maxsteps) + ' steps.') sim.minimizeEnergy(maxIterations=options.maxsteps) # Overwrite the final file state = sim.context.getState(getPositions=True, enforcePeriodicBox=True) restrt.report(sim, state) val_aft_min = [] crds_aft_min = read_rstf(options.rfile) for i in atompairs: if len(i) == 2: crd1 = crds_aft_min[i[0] - 1] crd2 = crds_aft_min[i[1] - 1] bond = calc_bond(crd1, crd2) val_aft_min.append(('bond', bond)) elif len(i) == 3: crd1 = crds_aft_min[i[0] - 1] crd2 = crds_aft_min[i[1] - 1] crd3 = crds_aft_min[i[2] - 1] angle = calc_angle(crd1, crd2, crd3) val_aft_min.append(('angle', angle)) elif len(i) == 4: crd1 = crds_aft_min[i[0] - 1] crd2 = crds_aft_min[i[1] - 1] crd3 = crds_aft_min[i[2] - 1] crd4 = crds_aft_min[i[3] - 1] dih = calc_dih(crd1, crd2, crd3, crd4) val_aft_min.append(('dih', dih)) valdiffs = [] for i in range(0, len(atompairs)): if val_bf_min[i][0] == 'bond': valdiff = abs(val_aft_min[i][1] - val_bf_min[i][1]) * 1.0 / 100.0 elif val_bf_min[i][0] == 'angle': valdiff = abs(val_aft_min[i][1] - val_bf_min[i][1]) * 1.0 / 2.0 elif val_bf_min[i][0] == 'dih': valdiff = abs(val_aft_min[i][1] - val_bf_min[i][1]) if (360.0 - valdiff < valdiff): valdiff = 360.0 - valdiff valdiffs.append(valdiff) fnldiff = numpy.sum(valdiffs) print(fnldiff) return fnldiff
def main(opt): # Check all of the arguments if not os.path.exists(opt.prmtop): raise AmberError('prmtop file (%s) is missing' % opt.prmtop) # Process the arguments that take multiple args resstates = process_arglist(opt.resstates, int) resnums = process_arglist(opt.resnums, int) notresnums = process_arglist(opt.notresnums, int) resnames = process_arglist(opt.resnames, str) notresnames = process_arglist(opt.notresnames, str) minpka = opt.minpka maxpka = opt.maxpka if not opt.igb in (1, 2, 5, 7, 8): raise AmberError('-igb must be 1, 2, 5, 7, or 8!') if resnums is not None and notresnums is not None: raise AmberError('Cannot specify -resnums and -notresnums together') if resnames is not None and notresnames is not None: raise AmberError('Cannot specify -resnames and -notresnames together') if opt.intdiel != 1 and opt.intdiel != 2: raise AmberError('-intdiel must be either 1 or 2 currently') # Print warning about old format if opt.oldfmt: sys.stderr.write('Warning: The old format of the CPIN file can only be used for simulations with temp0=300.0!\n' ' You should use the new format for simulations with temperatures other than 300.0 Kelvins\n') # Set the list of residue names we will be willing to titrate titratable_residues = [] if notresnames is not None: for resname in residues.titratable_residues: if resname in notresnames: continue titratable_residues.append(resname) elif resnames is not None: for resname in resnames: if not resname in residues.titratable_residues: raise AmberError('%s is not a titratable residue!' % resname) elif not getattr(residues, resname).typ == "ph": raise AmberError('%s is not a pH-active titratable residue!' % resname) titratable_residues.append(resname) else: for resname in residues.titratable_residues: if getattr(residues, resname).typ == "ph": titratable_residues.append(resname) solvent_ions = ['WAT', 'Na+', 'Br-', 'Cl-', 'Cs+', 'F-', 'I-', 'K+', 'Li+', 'Mg+', 'Rb+', 'CIO', 'IB', 'MG2'] # Filter titratable residues based on min and max pKa new_reslist = [] for res in titratable_residues: # @jaimergp: If None values are not filtered out, comparisons # will fail in Py3k. This patch was discussed and approved in # GitLab issue 122 (@vwcruzeiro, @swails) # Error obtained in serial tests in conda-forge builds: # Traceback (most recent call last): # File "/home/conda/amber/bin/cpinutil.py", line 325, in <module> # main(opt) # File "/home/conda/amber/bin/cpinutil.py", line 191, in main # if getattr(residues, res).pKa < minpka: continue # TypeError: '<' not supported between instances of 'NoneType' and 'int' # ./Run.cpin: Program error # make[1]: *** [test.cpinutil] Error 1 if getattr(residues, res).pKa is None: continue # /@jaimergp if getattr(residues, res).pKa < minpka: continue if getattr(residues, res).pKa > maxpka: continue new_reslist.append(res) titratable_residues = new_reslist del new_reslist # Make sure we still have a couple residues if len(titratable_residues) == 0: raise AmberError('No titratable residues fit your criteria!') # Load the topology file parm = AmberParm(opt.prmtop) # Replace an un-set notresnums with an empty list so we get __contains__() if notresnums is None: notresnums = [] # If we have a list of residue numbers, check that they're all titratable if resnums is not None: for resnum in resnums: if resnum > parm.ptr('nres'): raise AmberError('%s only has %d residues. (%d chosen)' % (parm, parm.ptr('nres'), resnum)) if resnum <= 0: raise AmberError('Cannot select negative residue numbers.') resname = parm.parm_data['RESIDUE_LABEL'][resnum-1] if not resname in titratable_residues: raise AmberError('Residue number %s [%s] is not titratable' % (resnum, resname)) else: # Select every residue except those in notresnums resnums = [] for resnum in range(1, parm.ptr('nres') + 1): if resnum in notresnums: continue resnums.append(resnum) solvated = False first_solvent = 0 if 'WAT' in parm.parm_data['RESIDUE_LABEL']: solvated = True for i, res in enumerate(parm.parm_data['RESIDUE_LABEL']): if res in solvent_ions: first_solvent = parm.parm_data['RESIDUE_POINTER'][i] break main_reslist = TitratableResidueList(system_name=opt.system, solvated=solvated, first_solvent=first_solvent) trescnt = 0 for resnum in resnums: resname = parm.parm_data['RESIDUE_LABEL'][resnum-1] if not resname in titratable_residues: continue res = getattr(residues, resname) # Filter out termini (make sure the residue in the prmtop has as many # atoms as the titratable residue defined in residues.py) if resnum == parm.ptr('nres'): natoms = (parm.ptr('natom') + 1 - parm.parm_data['RESIDUE_POINTER'][resnum-1]) else: natoms = (parm.parm_data['RESIDUE_POINTER'][resnum] - parm.parm_data['RESIDUE_POINTER'][resnum-1]) if natoms != len(res.atom_list): continue # If we have gotten this far, add it to the list. main_reslist.add_residue(res, resnum, parm.parm_data['RESIDUE_POINTER'][resnum-1]) trescnt += 1 # Prints a warning if the number of titratable residues is larger than 50 if trescnt > 50: sys.stderr.write('Warning: Your CPIN file has more than 50 titratable residues! pmemd and sander have a\n' ' default limit of 50 titrable residues, thus this CPIN file can only be used\n' ' if the definitions for this limit are modified at the top of\n' ' $AMBERHOME/src/pmemd/src/constantph.F90 or $AMBERHOME/AmberTools/src/sander/constantph.F90.\n' ' AMBER needs to be recompilied after these files are modified.\n') # Set the states if requested if resstates is not None: main_reslist.set_states(resstates) # Open the output file if opt.output is None: output = sys.stdout else: output = open(opt.output, 'w') main_reslist.write_cpin(output, opt.igb, opt.intdiel, opt.oldfmt, "ph") if opt.output is not None: output.close() if solvated: if opt.outparm is None: has_carboxylate = False for res in main_reslist: if res is residues.AS4 or res is residues.GL4 or res is residues.PRN: has_carboxylate = True break if has_carboxylate: sys.stderr.write( 'Warning: Carboxylate residues in explicit solvent ' 'simulations require a modified topology file!\n' ' Use the -op flag to print one.\n' ) else: changeRadii(parm, 'mbondi2').execute() change(parm, 'RADII', ':AS4,GL4,PRN@OD=,OE=,O1=,O2=', 1.3).execute() parm.overwrite = True parm.write_parm(opt.outparm) else: if opt.outparm is not None: sys.stderr.write( 'A new prmtop is only necessary for explicit solvent ' 'CpHMD/pH-REMD simulations.\n' ) sys.stderr.write('CPIN generation complete!\n')
def main(opt): # Check all of the arguments if not os.path.exists(opt.prmtop): raise AmberError('prmtop file (%s) is missing' % opt.prmtop) # Process the arguments that take multiple args resstates = process_arglist(opt.resstates, int) resnums = process_arglist(opt.resnums, int) notresnums = process_arglist(opt.notresnums, int) resnames = process_arglist(opt.resnames, str) notresnames = process_arglist(opt.notresnames, str) minpka = opt.minpka maxpka = opt.maxpka if not opt.igb in (2, 5, 8): raise AmberError('-igb must be 2, 5, or 8!') if resnums is not None and notresnums is not None: raise AmberError('Cannot specify -resnums and -notresnums together') if resnames is not None and notresnames is not None: raise AmberError('Cannot specify -resnames and -notresnames together') if opt.intdiel != 1 and opt.intdiel != 2: raise AmberError('-intdiel must be either 1 or 2 currently') # Set the list of residue names we will be willing to titrate titratable_residues = [] if notresnames is not None: for resname in residues.titratable_residues: if resname in notresnames: continue titratable_residues.append(resname) elif resnames is not None: for resname in resnames: if not resname in residues.titratable_residues: raise AmberError('%s is not a titratable residue!' % resname) titratable_residues.append(resname) else: titratable_residues = residues.titratable_residues[:] solvent_ions = ['WAT', 'Na+', 'Br-', 'Cl-', 'Cs+', 'F-', 'I-', 'K+', 'Li+', 'Mg+', 'Rb+', 'CIO', 'IB', 'MG2'] # Filter titratable residues based on min and max pKa new_reslist = [] for res in titratable_residues: if getattr(residues, res).pKa < minpka: continue if getattr(residues, res).pKa > maxpka: continue new_reslist.append(res) titratable_residues = new_reslist del new_reslist # Make sure we still have a couple residues if len(titratable_residues) == 0: raise AmberError('No titratable residues fit your criteria!') # Load the topology file parm = AmberParm(opt.prmtop) # Replace an un-set notresnums with an empty list so we get __contains__() if notresnums is None: notresnums = [] # If we have a list of residue numbers, check that they're all titratable if resnums is not None: for resnum in resnums: if resnum > parm.ptr('nres'): raise AmberError('%s only has %d residues. (%d chosen)' % (parm, parm.ptr('nres'), resnum)) if resnum <= 0: raise AmberError('Cannot select negative residue numbers.') resname = parm.parm_data['RESIDUE_LABEL'][resnum-1] if not resname in titratable_residues: raise AmberError('Residue number %s [%s] is not titratable' % (resnum, resname)) else: # Select every residue except those in notresnums resnums = [] for resnum in range(1, parm.ptr('nres') + 1): if resnum in notresnums: continue resnums.append(resnum) solvated = False first_solvent = 0 if 'WAT' in parm.parm_data['RESIDUE_LABEL']: solvated = True for i, res in enumerate(parm.parm_data['RESIDUE_LABEL']): if res in solvent_ions: first_solvent = parm.parm_data['RESIDUE_POINTER'][i] break main_reslist = TitratableResidueList(system_name=opt.system, solvated=solvated, first_solvent=first_solvent) for resnum in resnums: resname = parm.parm_data['RESIDUE_LABEL'][resnum-1] if not resname in titratable_residues: continue res = getattr(residues, resname) # Filter out termini (make sure the residue in the prmtop has as many # atoms as the titratable residue defined in residues.py) if resnum == parm.ptr('nres'): natoms = (parm.ptr('natom') + 1 - parm.parm_data['RESIDUE_POINTER'][resnum-1]) else: natoms = (parm.parm_data['RESIDUE_POINTER'][resnum] - parm.parm_data['RESIDUE_POINTER'][resnum-1]) if natoms != len(res.atom_list): continue # If we have gotten this far, add it to the list. main_reslist.add_residue(res, resnum, parm.parm_data['RESIDUE_POINTER'][resnum-1]) # Set the states if requested if resstates is not None: main_reslist.set_states(resstates) # Open the output file if opt.output is None: output = sys.stdout else: output = open(opt.output, 'w') main_reslist.write_cpin(output, opt.igb, opt.intdiel) if opt.output is not None: output.close() if solvated: if opt.outparm is None: has_carboxylate = False for res in main_reslist: if res is residues.AS4 or res is residues.GL4: has_carboxylate = True break if has_carboxylate: sys.stderr.write( 'Warning: Carboxylate residues in explicit solvent ' 'simulations require a modified topology file!\n' 'Use the -op flag to print one.\n' ) else: changeRadii(parm, 'mbondi2').execute() change(parm, 'RADII', ':AS4,GL4@OD=,OE=', 1.3).execute() parm.overwrite = True parm.writeParm(opt.outparm) else: if opt.outparm is not None: sys.stderr.write( 'A new prmtop is only necessary for explicit solvent ' 'CpHMD/pH-REMD simulations.\n' )
from msmbuilder.io import save_generic import parmed as pmd from parmed.amber import AmberParm struct = AmberParm('proc_traj/2agy-as1.prmtop') angles = [(x.atom1.idx, x.atom2.idx, x.atom3.idx) for x in struct.angles] bonds = [(x.atom1.idx, x.atom2.idx) for x in struct.bonds] dihedrals = [(x.atom1.idx, x.atom2.idx, x.atom3.idx, x.atom4.idx) for x in struct.dihedrals] print('Number of angles {}'.format(len(angles))) print('Number of bonds {}'.format(len(bonds))) print('Number of dihedrals {}'.format(len(dihedrals))) # save_generic(bonds, 'proc_traj/2agy_as-1_bonds.pickl') # save_generic(angles, 'proc_traj/2agy_as-1_angles.pickl') # save_generic(dihedrals, 'proc_traj/2agy_as-1_dihedrals.pickl') struct2 = AmberParm('proc_traj/2agy-as2.prmtop') angles2 = [(x.atom1.idx, x.atom2.idx, x.atom3.idx) for x in struct2.angles] bonds2 = [(x.atom1.idx, x.atom2.idx) for x in struct2.bonds] dihedrals2 = [(x.atom1.idx, x.atom2.idx, x.atom3.idx, x.atom4.idx) for x in struct2.dihedrals] tuples = [bonds, angles, dihedrals] tuples2 = [bonds2, angles2, dihedrals2] for k in range(len(tuples)): tuple1 = tuples[k] tuple2 = tuples2[k] for i in range(len(tuple1)): print('Testing {0} and {1}'.format(tuple1[i], tuple2[i])) for j in range(len(tuple1[i])):
def parmed_topology(top_file, param_type, param_list, TIP3P_param_list, index): """ Use ParmEd to edit water parameters """ parm = AmberParm(top_file) local_param_list = TIP3P_param_list ow_charge_column = hw_charge_column = ow_rad_column = ow_eps_column = 999 # Write a log file for parmEd f = open('waterbot_parmed.log', 'w') logfile = open('parmed.log', 'w') for i, nonbonded_term in enumerate(param_type): if 'charge' in nonbonded_term.lower() and 'ow' in nonbonded_term.lower( ): ow_charge_column = i f.write('The partial charge of water oxygen will be perturbed; ') f.write('the value of the new parameter is %.4f.\n' % (param_list[i][index])) local_param_list[2] = param_list[i][index] elif 'charge' in nonbonded_term.lower( ) and 'hw' in nonbonded_term.lower(): hw_charge_column = i f.write('The partial charge of water hydrogen will be perturbed; ') f.write('the value of the new parameter is %.4f.\n' % (param_list[i][index])) local_param_list[3] = param_list[i][index] elif 'radius' in nonbonded_term.lower(): ow_rad_column = i f.write( 'The radii parameter of water hydrogen will be perturbed; ') f.write('the value of the new parameter is %.4f.\n' % (param_list[i][index])) local_param_list[0] = param_list[i][index] elif 'epsilon' in nonbonded_term.lower(): ow_eps_column = i f.write( 'The epsilon parameter of water hydrogen will be perturbed; ') f.write('the value of the new parameter is %.4f.\n' % (param_list[i][index])) local_param_list[1] = param_list[i][index] # if only one of the charges were provided: if ow_charge_column == 999 and hw_charge_column != 999: f.write('\nThe charge of water oxygen was not provided.') local_param_list[2] = -2.0 * local_param_list[3] f.write( 'A value of %.4f was computed and used to make sure this water model is neutral.' % (local_param_list[2])) elif hw_charge_column == 999 and ow_charge_column != 999: f.write('\nThe charge of water hydrogen was not provided.') local_param_list[3] = -local_param_list[2] / 2.0 f.write( 'A value of %.4f was computed and used to make sure this water model is neutral.' % (local_param_list[3])) # Check whether the water model has a neutral charge if (local_param_list[2] + 2 * local_param_list[3]) != 0: f.write('\nAborted.The new water model is not neutral!!!\n') sys.exit(1) if ow_rad_column != 999 or ow_eps_column != 999: # It looks like there is no way to only change radius or epsilon action = changeLJSingleType(parm, "@%OW", local_param_list[0], local_param_list[1]) action.execute() logfile.write(('%s\n' % action)) if ow_charge_column != 999 or hw_charge_column != 999: action = change(parm, 'CHARGE', "@%OW", local_param_list[2]) action.execute() logfile.write(('%s\n' % action)) Structure.save(parm, 'solvated_perturbed.prmtop')
def prepare_prmtop(args, name): """ Places appropriate prmtop file into the calculation folder and scales it's charges if necessary. Parameters ---------- args : Namespace Command line arguments Returns ------- out : string Path to prmtop file. """ # The atom specification in ParmedActions is terrible and requires the use # of masks. A good description of what it is can be found in Amber14 manual # section 28.2.3 if args.file.endswith('.prmtop'): prmtop_name = args.file else: prmtop_name = generate_prmtop(name, args) if args.new_name: new_name = args.new_name else: new_name = prmtop_name if args.minimize: minimize_solute(name, prmtop_name, args) if args.nomod: # we are done return 0 parm = AmberParm(prmtop_name) if args.charge_model == 'opls' or args.lennard_jones == 'opls': opls_radii, opls_epss, opls_chgs = get_opls_parameters(args, name) # account for scenario when charge_f is submitted along with existing prmtop if args.charge_f and args.file.endswith('.prmtop'): chargef_charges = get_chargef_charges(args.charge_f) #iterate over atoms for i, atom in enumerate(parm.atoms): attyp, atname, attchg = atom.type, atom.name, float(atom.charge) #print(attchg) nbidx = parm.LJ_types[attyp] lj_r = float(parm.LJ_radius[nbidx - 1]) lj_eps = float(parm.LJ_depth[nbidx - 1]) # change attyp to atnmae act = pact.change(parm, '@{} AMBER_ATOM_TYPE {}'.format(atname, atname)) act.execute() # deal with chgs if args.input_chg: print() attchg = get_usr_input('charge', atname, attchg) elif args.charge_model == 'opls': attchg = opls_chgs[i] elif args.charge_f and args.file.endswith('.prmtop'): attchg = float(chargef_charges[i]) attchg = attchg * args.scale_chg act = pact.change(parm, '@{} charge {:f}'.format(atname, float(attchg))) act.execute() # deal with lj if args.input_lj: if args.lj_radius_type == 'sigma': lj_r = lj_r*2./(2**(1./6)) # convert to sigma lj_r = get_usr_input('lj_r', atname, lj_r) if args.lj_radius_type == 'sigma': lj_r = lj_r/2.*(2**(1./6)) lj_eps = get_usr_input('lj_eps', atname, lj_eps) elif args.lennard_jones== 'opls': lj_r = opls_radii[i] lj_eps = opls_epss[i] lj_r = lj_r * args.scale_r lj_eps = lj_eps * args.scale_eps #print(lj_r, lj_eps) act = pact.changeLJSingleType(parm, '@{} {:f} {:f}'.format(atname, lj_r, lj_eps)) act.execute() #parm.overwrite = True parm.write_parm(new_name)
if len(sys.argv) < 2: print("Args: <mol.topo> ") print("Aborted. Please specify the name of the topology file.") sys.exit() elif len(sys.argv) > 2: print("Args: <mol.topo> ") print("Aborted. Too many arguments!") sys.exit() topfile = sys.argv[1] if not os.path.isfile(topfile): print('The input file %s does not exist.' % topfile) sys.exit() parm = AmberParm(topfile) bondedInfoFile = open('moleculeInfo', 'w') action = summary(parm) action.execute() bondedInfoFile.write('%s\n' % action) # Print out force field parameters action = writeFrcmod(parm, 'FFparameters.dat') action.execute() # Generate the "dry" topology file action = strip(parm, ':WAT') action.execute() # Print out the connectivity (bond, angle, torsion) from the dry topology
def write(self, prmtop_name): """ Creates a prmtop with either AMBER or CHARMM parameters. """ self.prmtop_name = prmtop_name # Charmm forcefield if "charmm" in self.forcefield: psfgen = CharmmWriter(molid=self.molid, tmp_dir=self.tmp_dir, lipid_sel=self.lipid_sel, extra_topos=self.extra_topos, override_defaults=self.override) self.topologies = psfgen.write(self.prmtop_name) self._psf_to_charmm_amber() # Amber forcefield elif "amber" in self.forcefield: # Initialize the matcher self.matcher = AmberMatcher(self.topologies) print("Using the following topologies:") for top in self.topologies: print(" - %s" % top.split("/")[-1]) top = os.path.abspath(top) for par in self.parameters: par = os.path.abspath(par) # Assign atom types print("Assigning AMBER atom types...") conect = self._rename_atoms_amber() # Create temporary pdb files that will be leap inputs pdbs = [] pdbs.append(self._write_lipids()) prot_pdbseqs = self._write_protein() pdbs.extend(self._write_solvent()) ligfiles = self._write_ligands() # Now invoke leap to create the prmtop and inpcrd outfile = self._run_leap(ligfiles, prot_pdbseqs, pdbs, conect) # Repartion hydrogen masses if requested if self.hmr: print("\nRepartitioning hydrogen masses...") parm = AmberParm(prm_name=outfile + ".prmtop", xyz=outfile + ".inpcrd") action = HMassRepartition(parm, "dowater") action.execute() write = parmout(action.parm, "%s.prmtop" % self.prmtop_name) #self.prmtop_name)) write.execute() parm = write.parm # Check validity of output prmtop using parmed parm = AmberParm(prm_name=self.prmtop_name + ".prmtop", xyz=self.prmtop_name + ".inpcrd") print("\nChecking for problems with the prmtop...") print(" Verify all warnings!") action = checkValidity(parm) action.execute() else: raise DabbleError("Unhandled forcefield: %s" % self.forcefield)
def _psf_to_charmm_amber(self): """ Runs the chamber command of ParmEd to produce AMBER format input files. Returns: True if successful """ # Ask the user for additional parameter files if self.prompt_params: sys.stdout.flush() print("\nCurrently using the following parameter files:") for prm in self.parameters: print(" - %s" % prm.split("/")[-1]) print( "Enter the path to the filename(s) from the current working " "directory, separated by a comma, of any additional prm or str files " "you wish to use.\n") sys.stdout.flush() try: input = raw_input except NameError: pass inp = input('> ') if inp: self.parameters.extend(inp.split(',')) else: print("Using the following parameter files:") for prm in self.parameters: print(" - %s" % prm.split("/")[-1]) print("\n") # Begin assembling chamber input string args = "-crd %s.pdb -psf %s.psf" % (self.prmtop_name, self.prmtop_name) # Add topology and parameter arguments for inp in set(self.topologies + self.parameters): args += ' -toppar %s' % inp # Add box information since it is not in the pdb box = molecule.get_periodic(molid=self.molid) args += " -box %f,%f,%f" % (box['a'], box['b'], box['c']) args += " nosettle" print("Running chamber. This may take a while...") sys.stdout.flush() parm = AmberParm() with warnings.catch_warnings(record=True) as w: action = chamber(parm, args) action.execute() w = [i for i in w if issubclass(i.category, ParameterWarning)] # Do hydrogen mass repartitioning if requested if self.hmr: print("Repartitioning hydrogen masses...") parm = action.parm action = HMassRepartition(parm, "dowater") print(action) action.execute() print("\tRan chamber") write = parmout( action.parm, "%s.prmtop %s.inpcrd" % (self.prmtop_name, self.prmtop_name)) write.execute() print("\nWrote output prmtop and inpcrd") return True
def setUp(self): super().setUp() self.amber_gas = AmberParm(self.get_fn('ash.parm7'), self.get_fn('ash.rst7'))
class TestStateDataReporter(FileIOTestCase): def setUp(self): super().setUp() self.amber_gas = AmberParm(self.get_fn('ash.parm7'), self.get_fn('ash.rst7')) def test_state_data_reporter(self): """ Test StateDataReporter with various options """ system = self.amber_gas.createSystem() integrator = mm.LangevinIntegrator(300 * u.kelvin, 5.0 / u.picoseconds, 1.0 * u.femtoseconds) sim = app.Simulation(self.amber_gas.topology, system, integrator, platform=CPU) sim.context.setPositions(self.amber_gas.positions) f = open(self.get_fn('akma5.dat', written=True), 'w') sim.reporters.extend([ StateDataReporter(self.get_fn('akma1.dat', written=True), 10), StateDataReporter(self.get_fn('akma2.dat', written=True), 10, time=False, potentialEnergy=False, kineticEnergy=False, totalEnergy=False, temperature=False), StateDataReporter(self.get_fn('akma3.dat', written=True), 10, volume=True, density=True), StateDataReporter(self.get_fn('akma4.dat', written=True), 10, separator='\t'), StateDataReporter(self.get_fn('units.dat', written=True), 10, volume=True, density=True, energyUnit=u.kilojoules_per_mole, volumeUnit=u.nanometers**3), StateDataReporter(f, 10) ]) sim.step(500) f.close() # Now open all of the reporters and check that the information in there # is what we expect it to be akma1 = open(self.get_fn('akma1.dat', written=True), 'r') akma2 = open(self.get_fn('akma2.dat', written=True), 'r') akma3 = open(self.get_fn('akma3.dat', written=True), 'r') akma4 = open(self.get_fn('akma4.dat', written=True), 'r') akma5 = open(self.get_fn('akma5.dat', written=True), 'r') units = open(self.get_fn('units.dat', written=True), 'r') # AKMA 1 first header = akma1.readline().strip()[1:].split(',') self.assertEqual(len(header), 6) for i, label in enumerate( ('Step', 'Time', 'Potential Energy', 'Kinetic Energy', 'Total Energy', 'Temperature')): self.assertTrue(label in header[i]) for i, line in enumerate(akma1): words = line.replace('\n', '').split(',') self.assertEqual(i * 10 + 10, int(words[0])) # step akma1.close() # AKMA 2 header = akma2.readline().strip()[1:].split(',') self.assertEqual(len(header), 1) self.assertTrue('Step' in header[0]) for i, line in enumerate(akma2): self.assertEqual(int(line.replace('\n', '').split(',')[0]), 10 * i + 10) akma2.close() # AKMA 3 -- save energies so we can compare to the file with different # units header = akma3.readline().strip()[1:].split(',') self.assertEqual(len(header), 8) for i, label in enumerate( ('Step', 'Time', 'Potential Energy', 'Kinetic Energy', 'Total Energy', 'Temperature', 'Box Volume', 'Density')): self.assertTrue(label in header[i]) akma_energies = [[0.0 for i in range(8)] for j in range(50)] for i, line in enumerate(akma3): words = line.replace('\n', '').split(',') akma_energies[i][0] = int(words[0]) for j in range(1, 8): akma_energies[i][j] = float(words[j]) akma3.close() # AKMA 4 -- tab delimiter header = akma4.readline().strip()[1:].split('\t') self.assertEqual(len(header), 6) for i, label in enumerate( ('Step', 'Time', 'Potential Energy', 'Kinetic Energy', 'Total Energy', 'Temperature')): self.assertTrue(label in header[i]) for i, line in enumerate(akma4): words = line.replace('\n', '').split('\t') self.assertEqual(i * 10 + 10, int(words[0])) # step akma4.close() # AKMA 5 -- write to open file handle header = akma5.readline().strip()[1:].split(',') self.assertEqual(len(header), 6) for i, label in enumerate( ('Step', 'Time', 'Potential Energy', 'Kinetic Energy', 'Total Energy', 'Temperature')): self.assertTrue(label in header[i]) for i, line in enumerate(akma5): words = line.replace('\n', '').split(',') self.assertEqual(i * 10 + 10, int(words[0])) # step akma5.close() # UNITS -- compare other units ene = u.kilojoule_per_mole.conversion_factor_to(u.kilocalorie_per_mole) volume = u.nanometers.conversion_factor_to(u.angstroms)**3 conversions = [1, 1, ene, ene, ene, 1, volume, 1] headers = units.readline().strip()[1:].split(',') self.assertEqual(len(headers), 8) for i, line in enumerate(units): words = line.replace('\n', '').split(',') self.assertEqual(int(words[0]), akma_energies[i][0]) for j in range(1, 8): self.assertAlmostEqual(float(words[j]) * conversions[j], akma_energies[i][j], places=5) units.close() def test_progress_reporter(self): """ Test ProgressReporter with various options """ self.assertRaises(ValueError, lambda: ProgressReporter(sys.stdout, 1, 5)) system = self.amber_gas.createSystem() integrator = mm.LangevinIntegrator(300 * u.kelvin, 5.0 / u.picoseconds, 1.0 * u.femtoseconds) sim = app.Simulation(self.amber_gas.topology, system, integrator, platform=CPU) sim.context.setPositions(self.amber_gas.positions) sim.reporters.append( ProgressReporter(self.get_fn('progress_reporter.dat', written=True), 10, 500, step=True, time=True, potentialEnergy=True, kineticEnergy=True, totalEnergy=True, temperature=True, volume=True, density=True, systemMass=None)) sim.step(500) self.assertEqual(len(os.listdir(self._temporary_directory.name)), 1) text = open(self.get_fn('progress_reporter.dat', written=True), 'r').read() self.assertTrue('Estimated time to completion' in text) self.assertTrue('Total Energy' in text) self.assertTrue('Potential Energy' in text) self.assertTrue('Kinetic Energy' in text) self.assertTrue('Temperature' in text)
class TestTrajRestartReporter(FileIOTestCase): def setUp(self): super().setUp() self.amber_gas = AmberParm(self.get_fn('ash.parm7'), self.get_fn('ash.rst7')) def test_reporters(self): """ Test NetCDF and ASCII restart and trajectory reporters (no PBC) """ with self.assertRaises(ValueError): NetCDFReporter(self.get_fn('blah', written=True), 1, crds=False) with self.assertRaises(ValueError): MdcrdReporter(self.get_fn('blah', written=True), 1, crds=False) with self.assertRaises(ValueError): MdcrdReporter(self.get_fn('blah', written=True), 1, crds=True, vels=True) system = self.amber_gas.createSystem() integrator = mm.LangevinIntegrator(300 * u.kelvin, 5.0 / u.picoseconds, 1.0 * u.femtoseconds) sim = app.Simulation(self.amber_gas.topology, system, integrator, platform=CPU) sim.context.setPositions(self.amber_gas.positions) sim.reporters.extend([ NetCDFReporter(self.get_fn('traj1.nc', written=True), 10), NetCDFReporter(self.get_fn('traj2.nc', written=True), 10, vels=True), NetCDFReporter(self.get_fn('traj3.nc', written=True), 10, frcs=True), NetCDFReporter(self.get_fn('traj4.nc', written=True), 10, vels=True, frcs=True), NetCDFReporter(self.get_fn('traj5.nc', written=True), 10, crds=False, vels=True), NetCDFReporter(self.get_fn('traj6.nc', written=True), 10, crds=False, frcs=True), NetCDFReporter(self.get_fn('traj7.nc', written=True), 10, crds=False, vels=True, frcs=True), MdcrdReporter(self.get_fn('traj1.mdcrd', written=True), 10), MdcrdReporter(self.get_fn('traj2.mdcrd', written=True), 10, crds=False, vels=True), MdcrdReporter(self.get_fn('traj3.mdcrd', written=True), 10, crds=False, frcs=True), RestartReporter(self.get_fn('restart.ncrst', written=True), 10, write_multiple=True, netcdf=True), RestartReporter(self.get_fn('restart.rst7', written=True), 10), ]) sim.step(500) for reporter in sim.reporters: reporter.finalize() self.assertEqual(len(os.listdir(self._temporary_directory.name)), 61) ntraj = [ NetCDFTraj.open_old(self.get_fn('traj1.nc', written=True)), NetCDFTraj.open_old(self.get_fn('traj2.nc', written=True)), NetCDFTraj.open_old(self.get_fn('traj3.nc', written=True)), NetCDFTraj.open_old(self.get_fn('traj4.nc', written=True)), NetCDFTraj.open_old(self.get_fn('traj5.nc', written=True)), NetCDFTraj.open_old(self.get_fn('traj6.nc', written=True)), NetCDFTraj.open_old(self.get_fn('traj7.nc', written=True)) ] atraj = [ AmberMdcrd(self.get_fn('traj1.mdcrd', written=True), self.amber_gas.ptr('natom'), hasbox=False, mode='r'), AmberMdcrd(self.get_fn('traj2.mdcrd', written=True), self.amber_gas.ptr('natom'), hasbox=False, mode='r'), AmberMdcrd(self.get_fn('traj3.mdcrd', written=True), self.amber_gas.ptr('natom'), hasbox=False, mode='r'), ] for traj in ntraj: self.assertEqual(traj.frame, 50) self.assertEqual(traj.Conventions, 'AMBER') self.assertEqual(traj.ConventionVersion, '1.0') self.assertEqual(traj.application, 'AmberTools') self.assertEqual(traj.program, 'ParmEd') self.assertFalse(traj.hasbox) self.assertTrue(ntraj[0].hascrds) self.assertFalse(ntraj[0].hasvels) self.assertFalse(ntraj[0].hasfrcs) self.assertTrue(ntraj[1].hascrds) self.assertTrue(ntraj[1].hasvels) self.assertFalse(ntraj[1].hasfrcs) self.assertTrue(ntraj[2].hascrds) self.assertFalse(ntraj[2].hasvels) self.assertTrue(ntraj[2].hasfrcs) self.assertTrue(ntraj[3].hascrds) self.assertTrue(ntraj[3].hasvels) self.assertTrue(ntraj[3].hasfrcs) self.assertFalse(ntraj[4].hascrds) self.assertTrue(ntraj[4].hasvels) self.assertFalse(ntraj[4].hasfrcs) self.assertFalse(ntraj[5].hascrds) self.assertFalse(ntraj[5].hasvels) self.assertTrue(ntraj[5].hasfrcs) self.assertFalse(ntraj[6].hascrds) self.assertTrue(ntraj[6].hasvels) self.assertTrue(ntraj[6].hasfrcs) for i in (0, 2, 3, 4, 5, 6): ntraj[i].close() # still need the 2nd for traj in atraj: traj.close() # Now test the NetCDF restart files fn = self.get_fn('restart.ncrst.%d', written=True) for i, j in enumerate(range(10, 501, 10)): ncrst = NetCDFRestart.open_old(fn % j) self.assertEqual(ncrst.coordinates.shape, (1, 25, 3)) self.assertEqual(ncrst.velocities.shape, (1, 25, 3)) np.testing.assert_allclose(ncrst.coordinates[0], ntraj[1].coordinates[i]) np.testing.assert_allclose(ncrst.velocities[0], ntraj[1].velocities[i], rtol=1e-6) # Now test the ASCII restart file f = AmberAsciiRestart(self.get_fn('restart.rst7', written=True), 'r') # Compare to ncrst and make sure it's the same data np.testing.assert_allclose(ncrst.coordinates, f.coordinates, atol=1e-3) np.testing.assert_allclose(ncrst.velocities, f.velocities, rtol=1e-3) # Make sure the EnergyMinimizerReporter does not fail f = StringIO() rep = EnergyMinimizerReporter(f) rep.report(sim, frame=10) rep.finalize() @unittest.skipUnless(HAS_GROMACS, 'Cannot test without GROMACS') def test_reporters_pbc(self): """ Test NetCDF and ASCII restart and trajectory reporters (w/ PBC) """ systemsolv = load_file(self.get_fn('ildn.solv.top'), xyz=self.get_fn('ildn.solv.gro')) system = systemsolv.createSystem(nonbondedMethod=app.PME, nonbondedCutoff=8 * u.angstroms) integrator = mm.LangevinIntegrator(300 * u.kelvin, 5.0 / u.picoseconds, 1.0 * u.femtoseconds) sim = app.Simulation(systemsolv.topology, system, integrator, CPU) sim.context.setPositions(systemsolv.positions) sim.reporters.extend([ NetCDFReporter(self.get_fn('traj.nc', written=True), 1, vels=True, frcs=True), MdcrdReporter(self.get_fn('traj.mdcrd', written=True), 1), RestartReporter(self.get_fn('restart.ncrst', written=True), 1, netcdf=True), RestartReporter(self.get_fn('restart.rst7', written=True), 1), StateDataReporter(self.get_fn('state.o', written=True), 1, volume=True, density=True, systemMass=1) ]) sim.step(5) for reporter in sim.reporters: reporter.finalize() ntraj = NetCDFTraj.open_old(self.get_fn('traj.nc', written=True)) atraj = AmberMdcrd(self.get_fn('traj.mdcrd', written=True), len(systemsolv.atoms), True, mode='r') nrst = NetCDFRestart.open_old( self.get_fn('restart.ncrst', written=True)) arst = AmberAsciiRestart(self.get_fn('restart.rst7', written=True), 'r') self.assertEqual(ntraj.frame, 5) self.assertEqual(atraj.frame, 5) self.assertTrue(ntraj.hasvels) self.assertTrue(ntraj.hasfrcs) for i in range(ntraj.frame): for x1, x2 in zip(ntraj.box[i], atraj.box[i]): self.assertAlmostEqual(x1, x2, places=3) self.assertEqual(len(nrst.box), 6) self.assertEqual(len(arst.box), 6) # Make sure the EnergyMinimizerReporter does not fail f = StringIO() rep = EnergyMinimizerReporter(f, volume=True) rep.report(sim) rep.finalize() def test_private_functions(self): """ Tests private helper functions for OMM reporters """ self.assertEqual(_format_time(7200), (2, 'hr.')) self.assertEqual(_format_time(3600), (60, 'min.')) self.assertEqual(_format_time(40), (40, 'sec.'))
def main(opt): # Check all of the arguments if not os.path.exists(opt.prmtop): raise AmberError('prmtop file (%s) is missing' % opt.prmtop) # Process the arguments that take multiple args resstates = process_arglist(opt.resstates, int) resnums = process_arglist(opt.resnums, int) notresnums = process_arglist(opt.notresnums, int) resnames = process_arglist(opt.resnames, str) notresnames = process_arglist(opt.notresnames, str) minpka = opt.minpka maxpka = opt.maxpka if not opt.igb in (1, 2, 5, 7, 8): raise AmberError('-igb must be 1, 2, 5, 7, or 8!') if resnums is not None and notresnums is not None: raise AmberError('Cannot specify -resnums and -notresnums together') if resnames is not None and notresnames is not None: raise AmberError('Cannot specify -resnames and -notresnames together') if opt.intdiel != 1 and opt.intdiel != 2: raise AmberError('-intdiel must be either 1 or 2 currently') # Print warning about old format if opt.oldfmt: sys.stderr.write( 'Warning: The old format of the CPIN file can only be used for simulations with temp0=300.0!\n' ' You should use the new format for simulations with temperatures other than 300.0 Kelvins\n' ) # Set the list of residue names we will be willing to titrate titratable_residues = [] if notresnames is not None: for resname in residues.titratable_residues: if resname in notresnames: continue titratable_residues.append(resname) elif resnames is not None: for resname in resnames: if not resname in residues.titratable_residues: raise AmberError('%s is not a titratable residue!' % resname) elif not getattr(residues, resname).typ == "ph": raise AmberError('%s is not a pH titratable residue!' % resname) titratable_residues.append(resname) else: for resname in residues.titratable_residues: if getattr(residues, resname).typ == "ph": titratable_residues.append(resname) solvent_ions = [ 'WAT', 'Na+', 'Br-', 'Cl-', 'Cs+', 'F-', 'I-', 'K+', 'Li+', 'Mg+', 'Rb+', 'CIO', 'IB', 'MG2' ] # Filter titratable residues based on min and max pKa new_reslist = [] for res in titratable_residues: if getattr(residues, res).pKa < minpka: continue if getattr(residues, res).pKa > maxpka: continue new_reslist.append(res) titratable_residues = new_reslist del new_reslist # Make sure we still have a couple residues if len(titratable_residues) == 0: raise AmberError('No titratable residues fit your criteria!') # Load the topology file parm = AmberParm(opt.prmtop) # Replace an un-set notresnums with an empty list so we get __contains__() if notresnums is None: notresnums = [] # If we have a list of residue numbers, check that they're all titratable if resnums is not None: for resnum in resnums: if resnum > parm.ptr('nres'): raise AmberError('%s only has %d residues. (%d chosen)' % (parm, parm.ptr('nres'), resnum)) if resnum <= 0: raise AmberError('Cannot select negative residue numbers.') resname = parm.parm_data['RESIDUE_LABEL'][resnum - 1] if not resname in titratable_residues: raise AmberError('Residue number %s [%s] is not titratable' % (resnum, resname)) else: # Select every residue except those in notresnums resnums = [] for resnum in range(1, parm.ptr('nres') + 1): if resnum in notresnums: continue resnums.append(resnum) solvated = False first_solvent = 0 if 'WAT' in parm.parm_data['RESIDUE_LABEL']: solvated = True for i, res in enumerate(parm.parm_data['RESIDUE_LABEL']): if res in solvent_ions: first_solvent = parm.parm_data['RESIDUE_POINTER'][i] break main_reslist = TitratableResidueList(system_name=opt.system, solvated=solvated, first_solvent=first_solvent) for resnum in resnums: resname = parm.parm_data['RESIDUE_LABEL'][resnum - 1] if not resname in titratable_residues: continue res = getattr(residues, resname) # Filter out termini (make sure the residue in the prmtop has as many # atoms as the titratable residue defined in residues.py) if resnum == parm.ptr('nres'): natoms = (parm.ptr('natom') + 1 - parm.parm_data['RESIDUE_POINTER'][resnum - 1]) else: natoms = (parm.parm_data['RESIDUE_POINTER'][resnum] - parm.parm_data['RESIDUE_POINTER'][resnum - 1]) if natoms != len(res.atom_list): continue # If we have gotten this far, add it to the list. main_reslist.add_residue(res, resnum, parm.parm_data['RESIDUE_POINTER'][resnum - 1]) # Set the states if requested if resstates is not None: main_reslist.set_states(resstates) # Open the output file if opt.output is None: output = sys.stdout else: output = open(opt.output, 'w') main_reslist.write_cpin(output, opt.igb, opt.intdiel, opt.oldfmt, "ph") if opt.output is not None: output.close() if solvated: if opt.outparm is None: has_carboxylate = False for res in main_reslist: if res is residues.AS4 or res is residues.GL4 or res is residues.PRN: has_carboxylate = True break if has_carboxylate: sys.stderr.write( 'Warning: Carboxylate residues in explicit solvent ' 'simulations require a modified topology file!\n' 'Use the -op flag to print one.\n') else: changeRadii(parm, 'mbondi2').execute() change(parm, 'RADII', ':AS4,GL4,PRN@OD=,OE=,O1=,O2=', 1.3).execute() parm.overwrite = True parm.write_parm(opt.outparm) else: if opt.outparm is not None: sys.stderr.write( 'A new prmtop is only necessary for explicit solvent ' 'CpHMD/pH-REMD simulations.\n') sys.stderr.write('CPIN generation complete!\n')
def main(opt): # Check all of the arguments if not os.path.exists(opt.prmtop): raise AmberError('prmtop file (%s) is missing' % opt.prmtop) # Process the arguments that take multiple args resstates = process_arglist(opt.resstates, int) resnums = process_arglist(opt.resnums, int) notresnums = process_arglist(opt.notresnums, int) resnames = process_arglist(opt.resnames, str) notresnames = process_arglist(opt.notresnames, str) minpka = opt.minpka maxpka = opt.maxpka if not opt.igb in (1, 2, 5, 7, 8): raise AmberError('-igb must be 1, 2, 5, 7, or 8!') if resnums is not None and notresnums is not None: raise AmberError('Cannot specify -resnums and -notresnums together') if resnames is not None and notresnames is not None: raise AmberError('Cannot specify -resnames and -notresnames together') if opt.intdiel != 1 and opt.intdiel != 2: raise AmberError('-intdiel must be either 1 or 2 currently') # Print warning about old format if opt.oldfmt: sys.stderr.write('Warning: The old format of the CPIN file can only be used for simulations with temp0=300.0!\n' ' You should use the new format for simulations with temperatures other than 300.0 Kelvins\n') # Set the list of residue names we will be willing to titrate titratable_residues = [] if notresnames is not None: for resname in residues.titratable_residues: if resname in notresnames: continue titratable_residues.append(resname) elif resnames is not None: for resname in resnames: if not resname in residues.titratable_residues: raise AmberError('%s is not a titratable residue!' % resname) elif not getattr(residues, resname).typ == "ph": raise AmberError('%s is not a pH-active titratable residue!' % resname) titratable_residues.append(resname) else: for resname in residues.titratable_residues: if getattr(residues, resname).typ == "ph": titratable_residues.append(resname) solvent_ions = ['WAT', 'Na+', 'Br-', 'Cl-', 'Cs+', 'F-', 'I-', 'K+', 'Li+', 'Mg+', 'Rb+', 'CIO', 'IB', 'MG2'] # Filter titratable residues based on min and max pKa new_reslist = [] for res in titratable_residues: if getattr(residues, res).pKa < minpka: continue if getattr(residues, res).pKa > maxpka: continue new_reslist.append(res) titratable_residues = new_reslist del new_reslist # Make sure we still have a couple residues if len(titratable_residues) == 0: raise AmberError('No titratable residues fit your criteria!') # Load the topology file parm = AmberParm(opt.prmtop) # Replace an un-set notresnums with an empty list so we get __contains__() if notresnums is None: notresnums = [] # If we have a list of residue numbers, check that they're all titratable if resnums is not None: for resnum in resnums: if resnum > parm.ptr('nres'): raise AmberError('%s only has %d residues. (%d chosen)' % (parm, parm.ptr('nres'), resnum)) if resnum <= 0: raise AmberError('Cannot select negative residue numbers.') resname = parm.parm_data['RESIDUE_LABEL'][resnum-1] if not resname in titratable_residues: raise AmberError('Residue number %s [%s] is not titratable' % (resnum, resname)) else: # Select every residue except those in notresnums resnums = [] for resnum in range(1, parm.ptr('nres') + 1): if resnum in notresnums: continue resnums.append(resnum) solvated = False first_solvent = 0 if 'WAT' in parm.parm_data['RESIDUE_LABEL']: solvated = True for i, res in enumerate(parm.parm_data['RESIDUE_LABEL']): if res in solvent_ions: first_solvent = parm.parm_data['RESIDUE_POINTER'][i] break main_reslist = TitratableResidueList(system_name=opt.system, solvated=solvated, first_solvent=first_solvent) trescnt = 0 for resnum in resnums: resname = parm.parm_data['RESIDUE_LABEL'][resnum-1] if not resname in titratable_residues: continue res = getattr(residues, resname) # Filter out termini (make sure the residue in the prmtop has as many # atoms as the titratable residue defined in residues.py) if resnum == parm.ptr('nres'): natoms = (parm.ptr('natom') + 1 - parm.parm_data['RESIDUE_POINTER'][resnum-1]) else: natoms = (parm.parm_data['RESIDUE_POINTER'][resnum] - parm.parm_data['RESIDUE_POINTER'][resnum-1]) if natoms != len(res.atom_list): continue # If we have gotten this far, add it to the list. main_reslist.add_residue(res, resnum, parm.parm_data['RESIDUE_POINTER'][resnum-1]) trescnt += 1 # Prints a warning if the number of titratable residues is larger than 50 if trescnt > 50: sys.stderr.write('Warning: Your CPIN file has more than 50 titratable residues! pmemd and sander have a\n' ' default limit of 50 titrable residues, thus this CPIN file can only be used\n' ' if the definitions for this limit are modified at the top of\n' ' $AMBERHOME/src/pmemd/src/constantph.F90 or $AMBERHOME/AmberTools/src/sander/constantph.F90.\n' ' AMBER needs to be recompilied after these files are modified.\n') # Set the states if requested if resstates is not None: main_reslist.set_states(resstates) # Open the output file if opt.output is None: output = sys.stdout else: output = open(opt.output, 'w') main_reslist.write_cpin(output, opt.igb, opt.intdiel, opt.oldfmt, "ph") if opt.output is not None: output.close() if solvated: if opt.outparm is None: has_carboxylate = False for res in main_reslist: if res is residues.AS4 or res is residues.GL4 or res is residues.PRN: has_carboxylate = True break if has_carboxylate: sys.stderr.write( 'Warning: Carboxylate residues in explicit solvent ' 'simulations require a modified topology file!\n' ' Use the -op flag to print one.\n' ) else: changeRadii(parm, 'mbondi2').execute() change(parm, 'RADII', ':AS4,GL4,PRN@OD=,OE=,O1=,O2=', 1.3).execute() parm.overwrite = True parm.write_parm(opt.outparm) else: if opt.outparm is not None: sys.stderr.write( 'A new prmtop is only necessary for explicit solvent ' 'CpHMD/pH-REMD simulations.\n' ) sys.stderr.write('CPIN generation complete!\n')
def main(opt): # Check all of the arguments if not os.path.exists(opt.prmtop): raise AmberError('prmtop file (%s) is missing' % opt.prmtop) # Process the arguments that take multiple args resstates = process_arglist(opt.resstates, int) resnums = process_arglist(opt.resnums, int) notresnums = process_arglist(opt.notresnums, int) resnames = process_arglist(opt.resnames, str) notresnames = process_arglist(opt.notresnames, str) mineo = opt.mineo maxeo = opt.maxeo if not opt.igb in (1, 2, 5, 7, 8): raise AmberError('-igb must be 1, 2, 5, 7, or 8!') if resnums is not None and notresnums is not None: raise AmberError('Cannot specify -resnums and -notresnums together') if resnames is not None and notresnames is not None: raise AmberError('Cannot specify -resnames and -notresnames together') if opt.intdiel != 1 and opt.intdiel != 2: raise AmberError('-intdiel must be either 1 or 2 currently') # Set the list of residue names we will be willing to titrate titratable_residues = [] if notresnames is not None: for resname in residues.titratable_residues: if resname in notresnames: continue titratable_residues.append(resname) elif resnames is not None: for resname in resnames: if not resname in residues.titratable_residues: raise AmberError('%s is not a titratable residue!' % resname) elif not getattr(residues, resname).typ == "redox": raise AmberError( '%s is not a redox-active titratable residue!' % resname) titratable_residues.append(resname) else: for resname in residues.titratable_residues: if getattr(residues, resname).typ == "redox": titratable_residues.append(resname) solvent_ions = [ 'WAT', 'Na+', 'Br-', 'Cl-', 'Cs+', 'F-', 'I-', 'K+', 'Li+', 'Mg+', 'Rb+', 'CIO', 'IB', 'MG2' ] # Filter titratable residues based on min and max pKa new_reslist = [] for res in titratable_residues: if getattr(residues, res).Eo < mineo: continue if getattr(residues, res).Eo > maxeo: continue new_reslist.append(res) titratable_residues = new_reslist del new_reslist # Make sure we still have a couple residues if len(titratable_residues) == 0: raise AmberError('No titratable residues fit your criteria!') # Load the topology file parm = AmberParm(opt.prmtop) # Replace an un-set notresnums with an empty list so we get __contains__() if notresnums is None: notresnums = [] # If we have a list of residue numbers, check that they're all titratable if resnums is not None: for resnum in resnums: if resnum > parm.ptr('nres'): raise AmberError('%s only has %d residues. (%d chosen)' % (parm, parm.ptr('nres'), resnum)) if resnum <= 0: raise AmberError('Cannot select negative residue numbers.') resname = parm.parm_data['RESIDUE_LABEL'][resnum - 1] if not resname in titratable_residues: raise AmberError('Residue number %s [%s] is not titratable' % (resnum, resname)) else: # Select every residue except those in notresnums resnums = [] for resnum in range(1, parm.ptr('nres') + 1): if resnum in notresnums: continue resnums.append(resnum) solvated = False first_solvent = 0 if 'WAT' in parm.parm_data['RESIDUE_LABEL']: solvated = True for i, res in enumerate(parm.parm_data['RESIDUE_LABEL']): if res in solvent_ions: first_solvent = parm.parm_data['RESIDUE_POINTER'][i] break main_reslist = TitratableResidueList(system_name=opt.system, solvated=solvated, first_solvent=first_solvent) trescnt = 0 for resnum in resnums: resname = parm.parm_data['RESIDUE_LABEL'][resnum - 1] if not resname in titratable_residues: continue res = getattr(residues, resname) # Filter out termini (make sure the residue in the prmtop has as many # atoms as the titratable residue defined in residues.py) if resnum == parm.ptr('nres'): natoms = (parm.ptr('natom') + 1 - parm.parm_data['RESIDUE_POINTER'][resnum - 1]) else: natoms = (parm.parm_data['RESIDUE_POINTER'][resnum] - parm.parm_data['RESIDUE_POINTER'][resnum - 1]) if natoms != len(res.atom_list): continue # If we have gotten this far, add it to the list. main_reslist.add_residue(res, resnum, parm.parm_data['RESIDUE_POINTER'][resnum - 1]) trescnt += 1 # Prints a warning if the number of titratable residues is larger than 50 if trescnt > 50: sys.stderr.write( 'Warning: Your CEIN file has more than 50 titratable residues! pmemd and sander have a\n' ' default limit of 50 titrable residues, thus this CEIN file can only be used\n' ' if the definitions for this limit are modified at the top of\n' ' $AMBERHOME/src/pmemd/src/constante.F90 or $AMBERHOME/AmberTools/src/sander/constante.F90.\n' ' AMBER needs to be recompilied after these files are modified.\n' ) # Set the states if requested if resstates is not None: main_reslist.set_states(resstates) # Open the output file if opt.output is None: output = sys.stdout else: output = open(opt.output, 'w') main_reslist.write_cpin(output, opt.igb, opt.intdiel, False, "redox") if opt.output is not None: output.close() sys.stderr.write('CEIN generation complete!\n')
def main(opt): # Check all of the arguments if not os.path.exists(opt.prmtop): raise AmberError('prmtop file (%s) is missing' % opt.prmtop) # Process the arguments that take multiple args resstates = process_arglist(opt.resstates, int) resnums = process_arglist(opt.resnums, int) notresnums = process_arglist(opt.notresnums, int) resnames = process_arglist(opt.resnames, str) notresnames = process_arglist(opt.notresnames, str) mineo = opt.mineo maxeo = opt.maxeo if not opt.igb in (1, 2, 5, 7, 8): raise AmberError('-igb must be 1, 2, 5, 7, or 8!') if resnums is not None and notresnums is not None: raise AmberError('Cannot specify -resnums and -notresnums together') if resnames is not None and notresnames is not None: raise AmberError('Cannot specify -resnames and -notresnames together') if opt.intdiel != 1 and opt.intdiel != 2: raise AmberError('-intdiel must be either 1 or 2 currently') # Set the list of residue names we will be willing to titrate titratable_residues = [] if notresnames is not None: for resname in residues.titratable_residues: if resname in notresnames: continue titratable_residues.append(resname) elif resnames is not None: for resname in resnames: if not resname in residues.titratable_residues: raise AmberError('%s is not a titratable residue!' % resname) elif not getattr(residues, resname).typ == "redox": raise AmberError('%s is not a redox-active titratable residue!' % resname) titratable_residues.append(resname) else: for resname in residues.titratable_residues: if getattr(residues, resname).typ == "redox": titratable_residues.append(resname) solvent_ions = ['WAT', 'Na+', 'Br-', 'Cl-', 'Cs+', 'F-', 'I-', 'K+', 'Li+', 'Mg+', 'Rb+', 'CIO', 'IB', 'MG2'] # Filter titratable residues based on min and max pKa new_reslist = [] for res in titratable_residues: if getattr(residues, res).Eo < mineo: continue if getattr(residues, res).Eo > maxeo: continue new_reslist.append(res) titratable_residues = new_reslist del new_reslist # Make sure we still have a couple residues if len(titratable_residues) == 0: raise AmberError('No titratable residues fit your criteria!') # Load the topology file parm = AmberParm(opt.prmtop) # Replace an un-set notresnums with an empty list so we get __contains__() if notresnums is None: notresnums = [] # If we have a list of residue numbers, check that they're all titratable if resnums is not None: for resnum in resnums: if resnum > parm.ptr('nres'): raise AmberError('%s only has %d residues. (%d chosen)' % (parm, parm.ptr('nres'), resnum)) if resnum <= 0: raise AmberError('Cannot select negative residue numbers.') resname = parm.parm_data['RESIDUE_LABEL'][resnum-1] if not resname in titratable_residues: raise AmberError('Residue number %s [%s] is not titratable' % (resnum, resname)) else: # Select every residue except those in notresnums resnums = [] for resnum in range(1, parm.ptr('nres') + 1): if resnum in notresnums: continue resnums.append(resnum) solvated = False first_solvent = 0 if 'WAT' in parm.parm_data['RESIDUE_LABEL']: solvated = True for i, res in enumerate(parm.parm_data['RESIDUE_LABEL']): if res in solvent_ions: first_solvent = parm.parm_data['RESIDUE_POINTER'][i] break main_reslist = TitratableResidueList(system_name=opt.system, solvated=solvated, first_solvent=first_solvent) trescnt = 0 for resnum in resnums: resname = parm.parm_data['RESIDUE_LABEL'][resnum-1] if not resname in titratable_residues: continue res = getattr(residues, resname) # Filter out termini (make sure the residue in the prmtop has as many # atoms as the titratable residue defined in residues.py) if resnum == parm.ptr('nres'): natoms = (parm.ptr('natom') + 1 - parm.parm_data['RESIDUE_POINTER'][resnum-1]) else: natoms = (parm.parm_data['RESIDUE_POINTER'][resnum] - parm.parm_data['RESIDUE_POINTER'][resnum-1]) if natoms != len(res.atom_list): continue # If we have gotten this far, add it to the list. main_reslist.add_residue(res, resnum, parm.parm_data['RESIDUE_POINTER'][resnum-1]) trescnt += 1 # Prints a warning if the number of titratable residues is larger than 50 if trescnt > 50: sys.stderr.write('Warning: Your CEIN file has more than 50 titratable residues! pmemd and sander have a\n' ' default limit of 50 titrable residues, thus this CEIN file can only be used\n' ' if the definitions for this limit are modified at the top of\n' ' $AMBERHOME/src/pmemd/src/constante.F90 or $AMBERHOME/AmberTools/src/sander/constante.F90.\n' ' AMBER needs to be recompilied after these files are modified.\n') # Set the states if requested if resstates is not None: main_reslist.set_states(resstates) # Open the output file if opt.output is None: output = sys.stdout else: output = open(opt.output, 'w') main_reslist.write_cpin(output, opt.igb, opt.intdiel, False, "redox") if opt.output is not None: output.close() sys.stderr.write('CEIN generation complete!\n')