def test_write_xml_parameters_amber_write_unused(self): """Test the write_unused argument in writing XML files""" params = openmm.OpenMMParameterSet.from_parameterset( pmd.amber.AmberParameterSet( get_fn('amino12.lib'), os.path.join(get_fn('parm'), 'parm10.dat'), os.path.join(get_fn('parm'), 'frcmod.ff14SB'))) ffxml = StringIO() params.write(ffxml) ffxml.seek(0) self.assertEqual(len(ffxml.readlines()), 2178) ffxml = StringIO() params.write(ffxml, write_unused=False) ffxml.seek(0) self.assertEqual(len(ffxml.readlines()), 1646) params = openmm.OpenMMParameterSet.from_parameterset( pmd.amber.AmberParameterSet( get_fn('atomic_ions.lib'), os.path.join(get_fn('parm'), 'frcmod.ionsjc_tip3p'))) ffxml = StringIO() warnings.filterwarnings('ignore', category=exceptions.ParameterWarning) params.write(ffxml) ffxml.seek(0) self.assertEqual(len(ffxml.readlines()), 222) ffxml = StringIO() params.write(ffxml, write_unused=False) ffxml.seek(0) self.assertEqual(len(ffxml.readlines()), 57)
def test_pp_regex(self): """ Tests CPreProcessor processing with whitespace """ f = StringIO("# define MY_DEFINE Something\nMY_DEFINE") self.assertEqual(CPreProcessor(f).read().strip(), "Something") f = StringIO("# ifdef MY_VAR \nMY_VAR\n#endif\n" "#\t\tdefine MY_VAR NoSpaces \n" "# ifdef MY_VAR \nMY_VAR\n#endif") f.seek(0) self.assertEqual(CPreProcessor(f).read().strip(), 'NoSpaces')
def test_not_implemented(self): """ Test error catching for PP features not implemented """ f = StringIO('#define MYVAR 1\n#if (MYVAR == 1)\nCORRECT\n#endif') pp = CPreProcessor(f) self.assertRaises(NotImplementedError, lambda: pp.seek(10)) self.assertRaises(NotImplementedError, pp.read) f = StringIO( '#ifdef MYVAR\n#elif defined(NOTMYVAR)\n#else\nline\#endif') pp = CPreProcessor(f) self.assertRaises(NotImplementedError, pp.read)
def test_bad_ifdef(self): """ Tests CPreProcessor error processing of bad #ifdef/#ifndef """ f = StringIO("#ifdef\n#endif") with CPreProcessor(f) as pp: self.assertRaises(PreProcessorError, pp.read) f = StringIO("#ifndef\n#endif") with CPreProcessor(f) as pp: self.assertRaises(PreProcessorError, pp.read) f = StringIO("#ifdef SOME_VAR\ndangling ifdef\n\n\n") with CPreProcessor(f) as pp: self.assertRaises(PreProcessorError, pp.read) warnings.filterwarnings('error', category=PreProcessorWarning) f = StringIO("#ifdef SOME_VAR misplaced comments\n#endif\n") with CPreProcessor(f) as pp: self.assertRaises(PreProcessorWarning, pp.read) f = StringIO("#ifdef SOME_VAR\n#endif misplaced comments\n") with CPreProcessor(f) as pp: self.assertRaises(PreProcessorWarning, pp.read) f = StringIO('#else\nNOVAR\n#endif') with CPreProcessor(f) as pp: self.assertRaises(PreProcessorError, pp.read) f = StringIO('#ifdef MYVAR\nline1\n#else extra tokens\nline2\n#endif') with CPreProcessor(f) as pp: self.assertRaises(PreProcessorWarning, pp.read) f = StringIO('#ifdef MYVAR\nline1\n#else\nline2\n#else\nline3\n#endif') with CPreProcessor(f) as pp: self.assertRaises(PreProcessorError, pp.read) f = StringIO('#endif\nline1\nline2') with CPreProcessor(f) as pp: self.assertRaises(PreProcessorError, pp.read)
def test_conservative_defines(self): """ Tests CPreProcessor #define token replacement """ # Check that it does not replace tokens inside quotes f = StringIO("'MY_VAR' is MY_VAR\n\"MY_VAR\" is MY_VAR still\n") pp = CPreProcessor(f, defines=dict(MY_VAR='set')) self.assertEqual(pp.read().strip(), "'MY_VAR' is set\n\"MY_VAR\" is set still") f = StringIO("This is NOT_MY_VAR, but 'MY_VAR' is MY_VAR\n") pp = CPreProcessor(f, defines=dict(MY_VAR='taken')) self.assertEqual(pp.read().strip(), "This is NOT_MY_VAR, but 'MY_VAR' is taken")
def test_bad_define_undef(self): """ Tests CPreProcessor error processing of bad #define/#undef """ f = StringIO("#define\n") pp = CPreProcessor(f) self.assertRaises(PreProcessorError, lambda: pp.read()) f = StringIO("#undef\n") pp = CPreProcessor(f) self.assertRaises(PreProcessorError, lambda: pp.read()) warnings.filterwarnings('error', category=PreProcessorWarning) f = StringIO('#undef VAR1 misplaced comments\n') pp = CPreProcessor(f) self.assertRaises(PreProcessorWarning, lambda: pp.read())
def test_undef(self): """ Tests CPreProcessor #undef preprocessing """ # This tests undef-ing both a defined and not-defined variable. f = StringIO("MY_DEFINE\n#define MY_DEFINE Changed\nMY_DEFINE\n" "#undef MY_DEFINE\nMY_DEFINE\n#undef NO_VARIABLE\n") pp = CPreProcessor(f) self.assertEqual(pp.read().strip(), "MY_DEFINE\nChanged\nMY_DEFINE") # Make sure undef does not occur where it shouldn't f = StringIO('#define MYVAR something\n#ifdef NOVAR\n#undef MYVAR\n' '#endif\nMYVAR') with CPreProcessor(f) as pp: self.assertEqual(pp.read().strip(), 'something')
def test_define_inside_ifdef(self): """ Tests CPreProcessor #define inside #ifdef/#ifndef """ f = StringIO("#ifdef MY_DEFINE\n#define MY_DEFINE " "Something\n#endif\nMY_DEFINE") pp = CPreProcessor(f) self.assertEqual(pp.read().strip(), "MY_DEFINE") f = StringIO("#ifdef MY_DEFINE\n# define MY_DEFINE Something\n" "#endif\nMY_DEFINE\n#ifndef MY_DEFINE\n" "# define MY_DEFINE Something special\n#endif\n" "MY_DEFINE") pp = CPreProcessor(f) self.assertEqual(pp.read().strip(), "MY_DEFINE\nSomething special")
def test_if1_if0(self): """ Tests CPreProcessor use of #if 1 and #if 0 to serve as comments """ f = StringIO('#if 1\n#ifdef MY_DEFINE\nPPVAR is set to MY_DEFINE\n' '#else\nMY_DEFINE is not set\n#endif\n#endif\n') pp = CPreProcessor(f) # no defines self.assertEqual(pp.read().strip(), 'MY_DEFINE is not set') f.seek(0) pp = CPreProcessor(f, defines=dict(MY_DEFINE='SUCCESS')) self.assertEqual(pp.read().strip(), 'PPVAR is set to SUCCESS') f = StringIO('#if 0\n#ifdef MY_DEFINE\nPPVAR is set to MY_DEFINE\n' '#else\nMY_DEFINE is not set\n#endif\n#endif\n') pp = CPreProcessor(f) # no defines self.assertFalse(pp.read().strip()) f.seek(0) pp = CPreProcessor(f, defines=dict(MY_DEFINE='SUCCESS')) self.assertFalse(pp.read().strip())
def test_write_xml_parameters_amber_write_unused(self): """ Test writing XML parameters loaded from part of the ff14SB forcefield files, using the write_unused argument""" params = openmm.OpenMMParameterSet.from_parameterset( pmd.amber.AmberParameterSet( get_fn('amino12.lib'), os.path.join(get_fn('parm'), 'parm10.dat'), os.path.join(get_fn('parm'), 'frcmod.ff14SB'))) ffxml = StringIO() params.write(ffxml) ffxml.seek(0) self.assertEqual(len(ffxml.readlines()), 2178) ffxml = StringIO() params.write(ffxml, write_unused=False) ffxml.seek(0) self.assertEqual(len(ffxml.readlines()), 1646)
def test_ifndef(self): """ Tests CPreProcessor #ifndef/#else#endif preprocessing """ f = StringIO('#ifndef MY_DEFINE\nMY_DEFINE is not set\n' '#else\nPPVAR is set to MY_DEFINE\n#endif\n') pp = CPreProcessor(f) # no defines self.assertEqual(pp.read().strip(), 'MY_DEFINE is not set') f.seek(0) pp = CPreProcessor(f, defines=dict(MY_DEFINE='SUCCESS')) self.assertEqual(pp.read().strip(), 'PPVAR is set to SUCCESS')
def test_missing_include(self): """ Tests CPreProcessor controllable behavior of missing #includes """ warnings.filterwarnings('error', category=PreProcessorWarning) f = StringIO("#include \"nofile.h\"\n") pp = CPreProcessor(f) self.assertRaises(PreProcessorError, lambda: pp.read()) f.seek(0) pp = CPreProcessor(f, notfound_fatal=False) self.assertRaises(PreProcessorWarning, lambda: pp.read())
def test_define(self): """ Tests CPreProcessor #define preprocessing """ f = StringIO('#ifdef MY_DEFINE\nPPVAR is set to MY_DEFINE\n' '#else\nMY_DEFINE is not set\n#endif\n' '#define MY_DEFINE SUCCESS\n#ifdef MY_DEFINE\n' 'PPVAR is set to MY_DEFINE\n#else\nMY_DEFINE is not set\n' '#endif\n') pp = CPreProcessor(f) self.assertEqual(pp.read().strip(), 'MY_DEFINE is not set\nPPVAR is set to SUCCESS') warnings.filterwarnings('error', category=PreProcessorWarning) f = StringIO('#define MYVAR something\nMYVAR\n#define MYVAR ' 'something_else\nMYVAR') with CPreProcessor(f) as pp: self.assertRaises(PreProcessorWarning, pp.read) warnings.filterwarnings('ignore', category=PreProcessorWarning) f.seek(0) with CPreProcessor(f) as pp: self.assertEqual(pp.read().strip(), 'something\nsomething_else')
def test_include_dir(self): """ Tests CPreProcessor passing include directories to search """ f = StringIO('#include "pptest1.h"') pp = CPreProcessor(f, includes=[get_fn('pptest1')]) self.assertEqual( pp.read().strip(), """\ pptest1 line 1 pptest2 line 1 pptest3 line 1 pptest2 line 2 pptest1 line 2 pptest3 line 1 pptest1 line 3""")
def test_reporters_pbc(self): """ Test NetCDF and ASCII restart and trajectory reporters (w/ PBC) """ systemsolv = load_file(get_fn('ildn.solv.top'), xyz=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, Reference) sim.context.setPositions(systemsolv.positions) sim.reporters.extend([ NetCDFReporter(get_fn('traj.nc', written=True), 1, vels=True, frcs=True), MdcrdReporter(get_fn('traj.mdcrd', written=True), 1), RestartReporter(get_fn('restart.ncrst', written=True), 1, netcdf=True), RestartReporter(get_fn('restart.rst7', written=True), 1), StateDataReporter(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(get_fn('traj.nc', written=True)) atraj = AmberMdcrd(get_fn('traj.mdcrd', written=True), len(systemsolv.atoms), True, mode='r') nrst = NetCDFRestart.open_old(get_fn('restart.ncrst', written=True)) arst = AmberAsciiRestart(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_nested_ifs(self): """ Tests CPreProcessor nested #ifdef and #if """ f = StringIO(""" #ifdef MY_VAR line 1 # if 1 line 2 # endif /* 1 */ #else /* ! MY_VAR */ # if 0 line 3 # else /* ! 0 */ line 4 # endif /* 0 */ #endif /* MY_VAR */ """) pp = CPreProcessor(f) self.assertEqual(pp.read().strip(), "line 4") f.seek(0) pp = CPreProcessor(f, defines=dict(MY_VAR=1)) self.assertEqual(pp.read().strip(), "line 1\nline 2") f = StringIO(""" #ifdef MY_VAR # ifndef MY_VAR_2 MY_VAR defined... MY_VAR_2 not # else MY_VAR defined... MY_VAR_2 also # endif #endif """) pp = CPreProcessor(f) self.assertEqual(pp.read().strip(), '') f.seek(0) pp = CPreProcessor(f, defines=dict(MY_VAR=1)) self.assertEqual(pp.read().strip(), '1 defined... MY_VAR_2 not') f.seek(0) pp = CPreProcessor(f, defines=dict(MY_VAR=1, MY_VAR_2=2)) self.assertEqual(pp.read().strip(), '1 defined... 2 also')
def test_write_xml_parameters_gaff(self): """ Test writing XML parameters loaded from Amber GAFF parameter files """ leaprc = StringIO("""\ parm10 = loadamberparams gaff.dat """) params = openmm.OpenMMParameterSet.from_parameterset( pmd.amber.AmberParameterSet.from_leaprc(leaprc)) citations = """\ Wang, J., Wang, W., Kollman P. A.; Case, D. A. "Automatic atom type and bond type perception in molecular mechanical calculations". Journal of Molecular Graphics and Modelling , 25, 2006, 247260. Wang, J., Wolf, R. M.; Caldwell, J. W.;Kollman, P. A.; Case, D. A. "Development and testing of a general AMBER force field". Journal of Computational Chemistry, 25, 2004, 1157-1174. """ params.write(get_fn('gaff.xml', written=True), provenance=dict(OriginalFile='gaff.dat', Reference=citations))
def test_not_write_residues_with_same_templhash(self): """Test that no identical residues are written to XML, using the templhasher function.""" # TODO add testing for multiatomic residues when support for those added params = openmm.OpenMMParameterSet.from_parameterset( pmd.amber.AmberParameterSet(get_fn('atomic_ions.lib'))) new_residues = OrderedDict() for name in ('K', 'K+', 'NA', 'Na+', 'CL', 'Cl-'): new_residues[name] = params.residues[name] params.residues = new_residues ffxml = StringIO() params.write(ffxml) ffxml.seek(0) self.assertEqual(len(ffxml.readlines()), 16)
def test_override_level(self): """Test correct support for the override_level attribute of ResidueTemplates and correct writing to XML tag""" params = openmm.OpenMMParameterSet.from_parameterset( pmd.amber.AmberParameterSet(get_fn('atomic_ions.lib'))) new_residues = OrderedDict() new_residues['K'] = params.residues['K'] new_residues['NA'] = params.residues['NA'] new_residues['K'].override_level = 1 params.residues = new_residues ffxml = StringIO() params.write(ffxml) ffxml.seek(0) output_lines = ffxml.readlines() control_line1 = ' <Residue name="K" override="1">\n' control_line2 = ' <Residue name="NA">\n' self.assertEqual(output_lines[5], control_line1) self.assertEqual(output_lines[8], control_line2)
def parse(filename): """ Parses XML file and returns deserialized object. The return value depends on the serialized object, summarized below - System : returns simtk.openmm.System - State : returns simtk.openmm.State - Integrator : returns simtk.openmm.Integrator subclass - ForceField : returns simtk.openmm.app.ForceField Parameters ---------- filename : str or file-like The file name or file object containing the XML-serialized object Returns ------- obj : System, State, Integrator, or ForceField The deserialized object Notes ----- OpenMM requires the entire contents of this file read into memory. As a result, this function may require a significant amount of memory. """ import simtk.openmm as mm from simtk.openmm import app if isinstance(filename, string_types): with closing(genopen(filename, 'r')) as f: contents = f.read() else: contents = filename.read() # ForceField is not handled by XmlSerializer if '<ForceField' in contents: obj = StringIO() obj.write(contents) obj.seek(0) return app.ForceField(obj) obj = mm.XmlSerializer.deserialize(contents) if isinstance(obj, mm.State): return _OpenMMStateContents(obj) return obj
def load(rmol): """ Load a :class:`Mol` object and return a populated :class:`Structure` instance Parameters ---------- rmol: :class:`Mol` RDKit :class:`Mol` object to convert Examples -------- >>> from rdkit import Chem >>> import parmed as pmd >>> mol = Chem.MolFromSmiles('Cc1ccccc1') >>> struct = pmd.load_rdkit(mol) """ from rdkit import Chem fh = StringIO(Chem.MolToPDBBlock(rmol)) return PDBFile.parse(fh)
def test_reporters(self): """ Test NetCDF and ASCII restart and trajectory reporters (no PBC) """ self.assertRaises(ValueError, lambda: NetCDFReporter(get_fn('blah', written=True), 1, crds=False)) self.assertRaises(ValueError, lambda: MdcrdReporter(get_fn('blah', written=True), 1, crds=False)) self.assertRaises(ValueError, lambda: MdcrdReporter(get_fn('blah', written=True), 1, crds=True, vels=True)) system = amber_gas.createSystem() integrator = mm.LangevinIntegrator(300*u.kelvin, 5.0/u.picoseconds, 1.0*u.femtoseconds) sim = app.Simulation(amber_gas.topology, system, integrator, platform=CPU) sim.context.setPositions(amber_gas.positions) sim.reporters.extend([ NetCDFReporter(get_fn('traj1.nc', written=True), 10), NetCDFReporter(get_fn('traj2.nc', written=True), 10, vels=True), NetCDFReporter(get_fn('traj3.nc', written=True), 10, frcs=True), NetCDFReporter(get_fn('traj4.nc', written=True), 10, vels=True, frcs=True), NetCDFReporter(get_fn('traj5.nc', written=True), 10, crds=False, vels=True), NetCDFReporter(get_fn('traj6.nc', written=True), 10, crds=False, frcs=True), NetCDFReporter(get_fn('traj7.nc', written=True), 10, crds=False, vels=True, frcs=True), MdcrdReporter(get_fn('traj1.mdcrd', written=True), 10), MdcrdReporter(get_fn('traj2.mdcrd', written=True), 10, crds=False, vels=True), MdcrdReporter(get_fn('traj3.mdcrd', written=True), 10, crds=False, frcs=True), RestartReporter(get_fn('restart.ncrst', written=True), 10, write_multiple=True, netcdf=True), RestartReporter(get_fn('restart.rst7', written=True), 10) ]) sim.step(500) for reporter in sim.reporters: reporter.finalize() self.assertEqual(len(os.listdir(get_fn('writes'))), 61) ntraj = [NetCDFTraj.open_old(get_fn('traj1.nc', written=True)), NetCDFTraj.open_old(get_fn('traj2.nc', written=True)), NetCDFTraj.open_old(get_fn('traj3.nc', written=True)), NetCDFTraj.open_old(get_fn('traj4.nc', written=True)), NetCDFTraj.open_old(get_fn('traj5.nc', written=True)), NetCDFTraj.open_old(get_fn('traj6.nc', written=True)), NetCDFTraj.open_old(get_fn('traj7.nc', written=True))] atraj = [AmberMdcrd(get_fn('traj1.mdcrd', written=True), amber_gas.ptr('natom'), hasbox=False, mode='r'), AmberMdcrd(get_fn('traj2.mdcrd', written=True), amber_gas.ptr('natom'), hasbox=False, mode='r'), AmberMdcrd(get_fn('traj3.mdcrd', written=True), 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 = 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(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()
def test_write_xml_parameters(self): """ Test writing XML parameters loaded from Amber files """ leaprc = StringIO("""\ logFile leap.log # # ----- leaprc for loading the ff14SB force field # ----- NOTE: this is designed for PDB format 3! # Uses frcmod.ff14SB for proteins; ff99bsc0 for DNA; ff99bsc0_chiOL3 for RNA # # load atom type hybridizations # addAtomTypes { { "H" "H" "sp3" } { "HO" "H" "sp3" } { "HS" "H" "sp3" } { "H1" "H" "sp3" } { "H2" "H" "sp3" } { "H3" "H" "sp3" } { "H4" "H" "sp3" } { "H5" "H" "sp3" } { "HW" "H" "sp3" } { "HC" "H" "sp3" } { "HA" "H" "sp3" } { "HP" "H" "sp3" } { "HZ" "H" "sp3" } { "OH" "O" "sp3" } { "OS" "O" "sp3" } { "O" "O" "sp2" } { "O2" "O" "sp2" } { "OP" "O" "sp2" } { "OW" "O" "sp3" } { "CT" "C" "sp3" } { "CX" "C" "sp3" } { "C8" "C" "sp3" } { "2C" "C" "sp3" } { "3C" "C" "sp3" } { "CH" "C" "sp3" } { "CS" "C" "sp2" } { "C" "C" "sp2" } { "CO" "C" "sp2" } { "C*" "C" "sp2" } { "CA" "C" "sp2" } { "CB" "C" "sp2" } { "CC" "C" "sp2" } { "CN" "C" "sp2" } { "CM" "C" "sp2" } { "CK" "C" "sp2" } { "CQ" "C" "sp2" } { "CD" "C" "sp2" } { "C5" "C" "sp2" } { "C4" "C" "sp2" } { "CP" "C" "sp2" } { "CI" "C" "sp3" } { "CJ" "C" "sp2" } { "CW" "C" "sp2" } { "CV" "C" "sp2" } { "CR" "C" "sp2" } { "CA" "C" "sp2" } { "CY" "C" "sp2" } { "C0" "Ca" "sp3" } { "MG" "Mg" "sp3" } { "N" "N" "sp2" } { "NA" "N" "sp2" } { "N2" "N" "sp2" } { "N*" "N" "sp2" } { "NP" "N" "sp2" } { "NQ" "N" "sp2" } { "NB" "N" "sp2" } { "NC" "N" "sp2" } { "NT" "N" "sp3" } { "NY" "N" "sp2" } { "N3" "N" "sp3" } { "S" "S" "sp3" } { "SH" "S" "sp3" } { "P" "P" "sp3" } { "LP" "" "sp3" } { "EP" "" "sp3" } { "F" "F" "sp3" } { "Cl" "Cl" "sp3" } { "Br" "Br" "sp3" } { "I" "I" "sp3" } { "F-" "F" "sp3" } { "Cl-" "Cl" "sp3" } { "Br-" "Br" "sp3" } { "I-" "I" "sp3" } { "Li+" "Li" "sp3" } { "Na+" "Na" "sp3" } { "K+" "K" "sp3" } { "Rb+" "Rb" "sp3" } { "Cs+" "Cs" "sp3" } { "Mg+" "Mg" "sp3" } # glycam { "OG" "O" "sp3" } { "OL" "O" "sp3" } { "AC" "C" "sp3" } { "EC" "C" "sp3" } } # # Load the main parameter set. # parm10 = loadamberparams parm10.dat frcmod14SB = loadamberparams frcmod.ff14SB # # Load main chain and terminating amino acid libraries, nucleic acids # loadOff amino12.lib loadOff aminoct12.lib loadOff aminont12.lib loadOff nucleic12.lib # # Load water and ions # #loadOff atomic_ions.lib #loadOff solvents.lib #HOH = TP3 #WAT = TP3 # # Define the PDB name map for the amino acids and nucleic acids # addPdbResMap { { 0 "HYP" "NHYP" } { 1 "HYP" "CHYP" } { 0 "ALA" "NALA" } { 1 "ALA" "CALA" } { 0 "ARG" "NARG" } { 1 "ARG" "CARG" } { 0 "ASN" "NASN" } { 1 "ASN" "CASN" } { 0 "ASP" "NASP" } { 1 "ASP" "CASP" } { 0 "CYS" "NCYS" } { 1 "CYS" "CCYS" } { 0 "CYX" "NCYX" } { 1 "CYX" "CCYX" } { 0 "GLN" "NGLN" } { 1 "GLN" "CGLN" } { 0 "GLU" "NGLU" } { 1 "GLU" "CGLU" } { 0 "GLY" "NGLY" } { 1 "GLY" "CGLY" } { 0 "HID" "NHID" } { 1 "HID" "CHID" } { 0 "HIE" "NHIE" } { 1 "HIE" "CHIE" } { 0 "HIP" "NHIP" } { 1 "HIP" "CHIP" } { 0 "ILE" "NILE" } { 1 "ILE" "CILE" } { 0 "LEU" "NLEU" } { 1 "LEU" "CLEU" } { 0 "LYS" "NLYS" } { 1 "LYS" "CLYS" } { 0 "MET" "NMET" } { 1 "MET" "CMET" } { 0 "PHE" "NPHE" } { 1 "PHE" "CPHE" } { 0 "PRO" "NPRO" } { 1 "PRO" "CPRO" } { 0 "SER" "NSER" } { 1 "SER" "CSER" } { 0 "THR" "NTHR" } { 1 "THR" "CTHR" } { 0 "TRP" "NTRP" } { 1 "TRP" "CTRP" } { 0 "TYR" "NTYR" } { 1 "TYR" "CTYR" } { 0 "VAL" "NVAL" } { 1 "VAL" "CVAL" } { 0 "HIS" "NHIS" } { 1 "HIS" "CHIS" } { 0 "G" "G5" } { 1 "G" "G3" } { 0 "A" "A5" } { 1 "A" "A3" } { 0 "C" "C5" } { 1 "C" "C3" } { 0 "U" "U5" } { 1 "U" "U3" } { 0 "DG" "DG5" } { 1 "DG" "DG3" } { 0 "DA" "DA5" } { 1 "DA" "DA3" } { 0 "DC" "DC5" } { 1 "DC" "DC3" } { 0 "DT" "DT5" } { 1 "DT" "DT3" } # some old Amber residue names for RNA: { 0 "RA5" "A5" } { 1 "RA3" "A3"} {"RA" "A" } { 0 "RC5" "C5" } { 1 "RC3" "C3"} {"RC" "C" } { 0 "RG5" "G5" } { 1 "RG3" "G3"} {"RG" "G" } { 0 "RU5" "U5" } { 1 "RU3" "U3"} {"RU" "U" } # some really old Amber residue names, assuming DNA: { 0 "GUA" "DG5" } { 1 "GUA" "DG3" } { "GUA" "DG" } { 0 "ADE" "DA5" } { 1 "ADE" "DA3" } { "ADE" "DA" } { 0 "CYT" "DC5" } { 1 "CYT" "DC3" } { "CYT" "DC" } { 0 "THY" "DT5" } { 1 "THY" "DT3" } { "THY" "DT" } # uncomment out the following if you have this old style RNA files: # { 0 "GUA" "G5" } { 1 "GUA" "G3" } { "GUA" "G" } # { 0 "ADE" "A5" } { 1 "ADE" "A3" } { "ADE" "A" } # { 0 "CYT" "C5" } { 1 "CYT" "C3" } { "CYT" "C" } # { 0 "URA" "R5" } { 1 "URA" "R3" } { "URA" "R" } } # try to be good about reading in really old atom names as well: addPdbAtomMap { { "O5*" "O5'" } { "C5*" "C5'" } { "C4*" "C4'" } { "O4*" "O4'" } { "C3*" "C3'" } { "O3*" "O3'" } { "C2*" "C2'" } { "O2*" "O2'" } { "C1*" "C1'" } { "C5M" "C7" } { "H1*" "H1'" } { "H2*1" "H2'" } { "H2*2" "H2''" } { "H2'1" "H2'" } { "H2'2" "H2''" } { "H3*" "H3'" } { "H4*" "H4'" } { "H5*1" "H5'" } { "H5*2" "H5''" } { "H5'1" "H5'" } { "H5'2" "H5''" } { "HO'2" "HO2'" } { "H5T" "HO5'" } { "H3T" "HO3'" } { "O1'" "O4'" } { "OA" "OP1" } { "OB" "OP2" } { "O1P" "OP1" } { "O2P" "OP2" } } # # assume that most often proteins use HIE # NHIS = NHIE HIS = HIE CHIS = CHIE """) params = openmm.OpenMMParameterSet.from_parameterset( pmd.amber.AmberParameterSet.from_leaprc(leaprc)) params.write(get_fn('amber_conv.xml', written=True), provenance=dict(OriginalFile='leaprc.ff14SB', Reference=[ 'Maier & Simmerling', 'Simmerling & Maier' ], Source=dict(Source='leaprc.ff14SB', sourcePackage='AmberTools', sourcePackageVersion='15')))
def test_nested_defines(self): """ Tests CPreProcessor nested #define token replacement """ f = StringIO("#define MY_VAR replace1\n#define MY_VAR2 MY_VAR\n" "MY_VAR2\n") pp = CPreProcessor(f) self.assertEqual(pp.read().strip(), 'replace1')
def test_bad_include(self): """ Tests bad #include syntax in CPreProcessor """ f = StringIO('#include bad syntax gremlin\nline 1') with CPreProcessor(f) as pp: self.assertRaises(PreProcessorError, pp.read)
def test_multiword_define(self): """ Tests CPreProcessor #define with multiple words """ f = StringIO("#define MY_DEFINE Changed to a sentence\nMY_DEFINE") self.assertEqual( CPreProcessor(f).read().strip(), "Changed to a sentence")
def test_warnings(self): """ Test CPreProcessor warnings """ warnings.filterwarnings('error', category=PreProcessorWarning) f = StringIO('#ifndef MYVAR extra tokens\nline\n#endif') with CPreProcessor(f) as f: self.assertRaises(PreProcessorWarning, f.read)