def ReadHeader(self):
"""Read the trajectory header."""
header = Unpickle(os.path.join(self.path, _HeaderName + _BlockPostfix))
# . Set some object values.
for (key, value) in header.iteritems():
setattr(self, key, value)
# . Set the number of dimensions.
self.rank = len(self.labels)
# . Return the data.
return header
def ReadBlock(self):
"""Read a block of data."""
if self.currentBlock < self.blocks:
self.data = Unpickle(
os.path.join(
self.path, _BlockPrefix +
"{:d}".format(self.currentBlock) + _BlockPostfix))
self.blockSize = len(self.data) // self.rank
self.current = 0
self.currentBlock += 1
else:
raise IndexError("Invalid block index.")
def ReadFrame(self, frame=None, identifier=None, instance=None):
"""Read a frame."""
if self.isReadable:
data = Unpickle(
os.path.join(
self.path,
_FramePrefix + "{:d}".format(frame) + _FramePostfix))
if (instance is None) or isinstance(data, instance):
return data
else:
for item in data:
if isinstance(item, instance): return item
else: raise IOError("Reading from trajectory that is not readable.")
def runTest(self):
"""The test."""
# . Output setup.
dataPath = os.path.join(os.getenv("PDYNAMO_PMOLECULE"), "data")
log = self.GetLog()
# . Define the molecule.
molecule = XYZFile_ToSystem(
os.path.join(dataPath, "xyz", "serineOctamerZD4L4.xyz"))
molecule.Summary(log=log)
# . Define the randomNumberGenerator so as to have reproducible results.
randomNumberGenerator = RandomNumberGenerator.WithSeed(314159)
# . Do the test - 250000+ trajectories are generally necessary.
observed = HardSphereIonMobilities(
molecule,
nreflections=30,
ntrajectories=100000,
log=log,
randomNumberGenerator=randomNumberGenerator)
# . Remove non-real values.
keys = observed.keys()
for key in keys:
if not isinstance(observed[key], float): del observed[key]
# . Generate the reference data.
if self.generateReferenceData:
referenceData = TestDataSet("Ion Mobilities")
for (key, value) in observed.iteritems():
referenceData.AddDatum(
TestReal(key,
value,
referenceData,
percentErrorTolerance=_percentErrorTolerance))
referenceData.Summary(log=log)
Pickle(self.referenceDataPath, referenceData)
isOK = True
# . Verify the observed data against the reference data.
else:
referenceData = Unpickle(self.referenceDataPath)
results = referenceData.VerifyAgainst(observed)
results.Summary(log=log, fullSummary=self.fullVerificationSummary)
isOK = results.WasSuccessful()
# . Success/failure.
self.assertTrue(isOK)
_ZBox = 60.0
# . Number and type of ions to add.
_NNegative = 27
_NPositive = 24
_NegativeIon = "chloride"
_PositiveIon = "potassium"
# . Reorient option.
_Reorient = False
# . Define the solvent MM and NB models.
mmModel = MMModelOPLS ( "bookSmallExamples" )
# . Get the system.
system = Unpickle ( os.path.join ( outPath, "step7.pkl" ) )
system.Summary ( )
# . Reorient the system if necessary (see the results of GetSolvationInformation.py).
masses = system.atoms.GetItemAttributes ( "mass" )
if _Reorient: system.coordinates3.ToPrincipalAxes ( weights = masses )
# . Get the positive and negative ions.
if _NNegative > 0:
anion = MOLFile_ToSystem ( os.path.join ( dataPath, _NegativeIon + ".mol" ) )
anion.DefineMMModel ( mmModel )
anion.Summary ( )
if _NPositive > 0:
cation = MOLFile_ToSystem ( os.path.join ( dataPath, _PositiveIon + ".mol" ) )
cation.DefineMMModel ( mmModel )
cation.Summary ( )
"""Generate a MM model for a system."""
import os, os.path, sys
sys.path.append(
os.path.join(os.path.dirname(os.path.realpath(__file__)), "..", "data"))
from Definitions import outPath
from pCore import Pickle, Unpickle
from pMolecule import MMModelOPLS
# . Set up a MM model.
mmModel = MMModelOPLS("protein")
# . Get the system.
system = Unpickle(os.path.join(outPath, "step3.pkl"))
system.Summary()
# . Add the energy model.
system.DefineMMModel(mmModel)
system.Summary()
# . Save the system.
mmModel.ClearModelBuildingData()
Pickle(os.path.join(outPath, "step4.pkl"), system)
"""Hand-build coordinates for PKA."""
import os, os.path, sys
sys.path.append ( os.path.join ( os.path.dirname ( os.path.realpath ( __file__ ) ), "..", "data" ) )
from Definitions import outPath
from pCore import Selection, Pickle, Unpickle
from pMolecule import NBModelABFS
from pMoleculeScripts import BuildHydrogenCoordinates3FromConnectivity
# . Define the atoms IDs and the parameters.
_ToBuild = ( ( "A:LYS.8:CB" , "A:LYS.8:CA" , "A:LYS.8:N" , "A:LYS.8:CG" , 1.54, 109.5, 0.0 ), \
( "I:SER.17:OG", "I:SER.17:CB", "I:SER.17:CA", "A:ATP.400:PG", 1.40, 109.5, 0.0 ) )
# . Get the system.
system = Unpickle ( os.path.join ( outPath, "step4.pkl" ) )
system.Summary ( )
# . Build the coordinates of the missing heavy atoms.
for ( id1, id2, id3, id4, r, theta, phi ) in _ToBuild:
i = system.sequence.AtomIndex ( id1 )
j = system.sequence.AtomIndex ( id2 )
k = system.sequence.AtomIndex ( id3 )
l = system.sequence.AtomIndex ( id4 )
system.coordinates3.BuildPointFromDistanceAngleDihedral ( i, j, k, l, r, theta, phi )
# . Build the hydrogen atom coordinates.
BuildHydrogenCoordinates3FromConnectivity ( system )
# . Save the system.
Pickle ( os.path.join ( outPath, "step6.pkl" ), system )
from pBabel import PDBFile_FromSystem from pCore import Clone, NormalDeviateGenerator, Pickle, RandomNumberGenerator, Selection, Unpickle from pMolecule import AtomSelection, MMModelOPLS, NBModelABFS, SoftConstraintContainer, SoftConstraintEnergyModelHarmonic, SoftConstraintMultipleTether from pMoleculeScripts import ConjugateGradientMinimize_SystemGeometry, LangevinDynamics_SystemGeometry, SolvateSystemBySuperposition # . Parameters. # . Refine options. _Optimize = True _Refine = True _Steps = 2000 # . Define the MM and NB models. nbModel = NBModelABFS ( ) # . Get the solute system. solute = Unpickle ( os.path.join ( outPath, "step8_a.pkl" ) ) solute.Summary ( ) # . Get the solvent system. solvent = Unpickle ( os.path.join ( outPath, "waterBox.pkl" ) ) solvent.DefineNBModel ( nbModel ) solvent.Summary ( ) # . Create the solvated system. solution = SolvateSystemBySuperposition ( solute, solvent, reorientSolute = False ) solution.label = "Solvated PKA Simulation System - Chains A and I Only" solution.DefineNBModel ( nbModel ) solution.Summary ( ) # . Refinement. if _Refine:
def runTest ( self ):
"""The test."""
# . Paths.
dataPath = os.path.join ( os.getenv ( "PDYNAMO_PMOLECULE" ), "data", "pdb" )
if self.resultPath is None: outPath = os.path.join ( os.getenv ( "PDYNAMO_SCRATCH" ), _Destination )
else: outPath = os.path.join ( self.resultPath, _Destination )
if not os.path.exists ( outPath ): os.mkdir ( outPath )
log = self.GetLog ( )
# . Models.
mmModel = MMModelCHARMM ( "c36a2" )
# mmModel = MMModelOPLS ( "protein" )
nbModel = NBModelABFS ( )
# . Get all files.
pdbFiles = glob.glob ( os.path.join ( dataPath, "*.pdb" ) )
pdbFiles.sort ( )
# . Read all PDB files.
failures = 0
otherFailures = 0
successes = 0
for pdbFile in pdbFiles:
( head, tail ) = os.path.split ( pdbFile )
tag = tail[0:-4]
if log is not None: log.Text ( "\nProcessing " + pdbFile + ":\n" )
system = PDBFile_ToSystem ( pdbFile, log = log, useComponentLibrary = True )
BuildHydrogenCoordinates3FromConnectivity ( system )
try:
# . Setup.
if system.coordinates3.numberUndefined > 0: raise
system.DefineMMModel ( mmModel, log = log )
system.DefineNBModel ( nbModel )
system.Summary ( log = log )
referenceEnergy = system.Energy ( log = log, doGradients = True )
# . Pickling.
pklFile = os.path.join ( outPath, tag + ".pkl" )
yamlFile = os.path.join ( outPath, tag + ".yaml" )
Pickle ( pklFile , system )
YAMLPickle ( yamlFile, system )
# . Unpickling.
pklSystem = Unpickle ( pklFile )
pklSystem.label += " (Pickled)"
pklSystem.Summary ( log = log )
pklEnergy = pklSystem.Energy ( log = log, doGradients = True )
if math.fabs ( referenceEnergy - pklEnergy <= _Tolerance ): successes += 1
else: failures += 1
yamlSystem = YAMLUnpickle ( yamlFile )
yamlSystem.label += " (YAMLPickled)"
yamlSystem.Summary ( log = log )
yamlEnergy = yamlSystem.Energy ( log = log, doGradients = True )
if math.fabs ( referenceEnergy - yamlEnergy <= _Tolerance ): successes += 1
else: failures += 1
except Exception as e:
otherFailures += 1
if log is not None: log.Text ( "\nError occurred> " + e.args[0] + "\n" )
# . Summary of results.
if log is not None:
summary = log.GetSummary ( )
summary.Start ( "Pickle Tests" )
summary.Entry ( "Pickle Successes", "{:d}".format ( successes ) )
summary.Entry ( "Pickle Failures" , "{:d}".format ( failures ) )
summary.Entry ( "Total Tests" , "{:d}".format ( 2 * len ( pdbFiles ) ) )
summary.Entry ( "Loop Failures" , "{:d}".format ( otherFailures ) )
summary.Stop ( )
# . Success/failure.
self.assertTrue ( ( failures == 0 ) and ( otherFailures == 0 ) )
def runTest(self):
"""The test."""
# . Initialization.
if self.generateReferenceData:
referenceData = TestDataSet("AMBER Test")
else:
observed = {}
# . Output setup.
dataPath = os.path.join(os.getenv("PDYNAMO_PBABEL"), "data", "amber")
log = self.GetLog()
# . Models.
nbModel = NBModelFull()
# . Loop over the molecules.
for label in _SystemLabels:
# . Read the data.
molecule = AmberTopologyFile_ToSystem(os.path.join(
dataPath, label + ".top"),
log=log)
molecule.coordinates3 = AmberCrdFile_ToCoordinates3(os.path.join(
dataPath, label + ".crd"),
log=log)
# . Calculation.
molecule.DefineNBModel(nbModel)
molecule.Summary(log=log)
if log is not None:
log.Text("\nFormula = " + molecule.atoms.FormulaString() +
".\n")
energy = molecule.Energy(doGradients=True, log=log)
# . Get the dictionary of energies.
localObserved = molecule.configuration.energyTerms.Terms(
asDictionary=True)
localObserved["Potential Energy"] = energy
# . Test the gradients.
if len(molecule.atoms) <= _MaximumAtoms:
of = SystemGeometryObjectiveFunction.FromSystem(molecule)
localObserved["Gradient Error"] = of.TestGradients(log=log)
# . Generate reference data.
if self.generateReferenceData:
localData = TestDataSet(label, parent=referenceData)
for (key, value) in localObserved.iteritems():
if key == "Gradient Error":
localData.AddDatum(
TestReal(key,
value,
localData,
absoluteErrorTolerance=
_GradientAbsoluteErrorTolerance))
else:
localData.AddDatum(
TestReal(
key,
value,
localData,
absoluteErrorTolerance=_AbsoluteErrorTolerance,
toleranceFormat="{:.3f}",
valueFormat="{:.3f}"))
referenceData.AddDatum(localData)
# . Accumulate observed data.
else:
observed[label] = localObserved
# . Generate the reference data.
if self.generateReferenceData:
referenceData.Summary(log=log)
Pickle(self.referenceDataPath, referenceData)
isOK = True
# . Verify the observed data against the reference data.
else:
referenceData = Unpickle(self.referenceDataPath)
results = referenceData.VerifyAgainst(observed)
results.Summary(log=log, fullSummary=self.fullVerificationSummary)
isOK = results.WasSuccessful()
# . Success/failure.
self.assertTrue(isOK)
def runTest(self):
"""The test."""
# . Initialization.
log = self.GetLog()
modelResults = {}
numberEnergyTests = 0
numberErrors = 0
numberGradientTests = 0
if self.testGradients:
maximumGradientDeviation = 0.0
# . Energy data.
if self.generateReferenceData:
referenceData = TestDataSet("MNDO RHF Energies")
energyDataSets = {}
for model in self.modelLabels:
energyDataSet = TestDataSet(model, parent=referenceData)
energyDataSets[model] = energyDataSet
referenceData.AddDatum(energyDataSet)
else:
energyResults = {}
# . Loop over systems.
for testSystem in self.testSystems:
# . Get results (if necessary).
modelLabel = testSystem.modelLabel
if not self.generateReferenceData:
energies = energyResults.get(modelLabel, None)
if energies is None:
energies = {}
energyResults[modelLabel] = energies
results = modelResults.get(modelLabel, None)
if results is None:
results = {}
modelResults[modelLabel] = results
cycles = results.get("Cycles", None)
if cycles is None:
cycles = []
results["Cycles"] = cycles
# . Get the molecule.
try:
molecule = testSystem.GetSystem(
log=log, maximumAtoms=self.maximumEnergyAtoms)
except:
molecule = None
results["Undefined"] = results.get("Undefined", 0) + 1
if molecule is None: continue
# . Determine an energy.
try:
try:
e = molecule.Energy(log=log, doGradients=True)
i = molecule.configuration.qcState.GetItem("SCF Cycles")
results["Converged"] = results.get("Converged", 0) + 1
cycles.append(float(i))
# . Generate reference data - converged only.
if self.generateReferenceData:
energyDataSet = energyDataSets[modelLabel]
energyDataSet.AddDatum(
TestReal(
molecule.label,
e,
energyDataSet,
absoluteErrorTolerance=_AbsoluteErrorTolerance,
toleranceFormat="{:.3f}",
valueFormat="{:.3f}"))
# . Accumulate observed data.
else:
energies[molecule.label] = e
except Exception as e:
results["Not Converged"] = results.get("Not Converged",
0) + 1
# . Bond orders.
labels = []
for i in range(len(molecule.atoms)):
labels.append(molecule.atoms[i].path)
(bondOrders, charges, freevalence,
totalvalence) = molecule.energyModel.qcModel.BondOrders(
molecule.configuration)
bondOrders.PrintWithCondition(
(lambda x, i, j:
(i != j) and (math.fabs(x) >= _BondOrderTolerance)),
itemFormat="{:.3f}",
labels=labels,
log=log,
title="Bond Orders")
# . Charges.
charges = molecule.AtomicCharges()
charges.Print(log=log, title="Charges")
if log is not None:
log.Paragraph("Total Charge = {:.3f}".format(sum(charges)))
charges = molecule.AtomicCharges(spinDensities=True)
charges.Print(log=log, title="Spin Densities")
if log is not None:
log.Paragraph("Total Spin Density = {:.3f}".format(
sum(charges)))
# . Dipole moment.
dipole = molecule.DipoleMoment()
dipole.Print(log=log, title="Dipole")
# . Gradient testing.
if self.testGradients and (len(
molecule.atoms) < self.maximumGradientAtoms) and (
numberGradientTests < self.maximumGradientTests):
of = SystemGeometryObjectiveFunction.FromSystem(molecule)
gradientDeviation = of.TestGradients(log=log)
maximumGradientDeviation = max(maximumGradientDeviation,
gradientDeviation)
numberGradientTests += 1
# . Error.
except Exception as e:
numberErrors += 1
if log is not None:
log.Text("\nError occurred> " + e.args[0] + "\n")
# . Check the number of tests.
numberEnergyTests += 1
if numberEnergyTests >= self.maximumEnergyTests: break
# . Print model results.
if log is not None:
models = modelResults.keys()
models.sort()
table = log.GetTable(columns=7 * [_TableModelWidth])
table.Start()
table.Title("Model Results")
table.Heading("Model")
table.Heading("Undefined")
table.Heading("Not Converged")
table.Heading("Converged")
table.Heading("<Cycles>")
table.Heading("Max. Cycles")
table.Heading("Min. Cycles")
for model in models:
results = modelResults[model]
cycles = Statistics(results["Cycles"])
table.Entry(model, alignment="left")
table.Entry("{:d}".format(results.get("Undefined", 0)))
table.Entry("{:d}".format(results.get("Not Converged", 0)))
table.Entry("{:d}".format(results.get("Converged", 0)))
if cycles.size > 0:
table.Entry("{:.1f}".format(cycles.mean))
table.Entry("{:.0f}".format(cycles.maximum))
table.Entry("{:.0f}".format(cycles.minimum))
else:
table.Entry("-")
table.Entry("-")
table.Entry("-")
table.Stop()
# . Energy data.
# . Generate the reference data.
if self.generateReferenceData:
referenceData.Summary(log=log)
Pickle(self.referenceDataPath, referenceData)
isOK = True
# . Verify the observed data against the reference data.
else:
referenceData = Unpickle(self.referenceDataPath)
results = referenceData.VerifyAgainst(energyResults)
results.Summary(log=log, fullSummary=self.fullVerificationSummary)
isOK = results.WasSuccessful()
# . Gradient data set.
if self.testGradients:
# . Get the observed and reference data.
observed = {}
referenceData = TestDataSet("MNDO RHF Gradients")
observed["Gradient Error"] = maximumGradientDeviation
referenceData.AddDatum(
TestReal(
"Gradient Error",
0.0,
referenceData,
absoluteErrorTolerance=_GradientAbsoluteErrorTolerance,
toleranceFormat="{:.3f}",
valueFormat="{:.3f}"))
# . Check for success/failure.
if len(observed) > 0:
results = referenceData.VerifyAgainst(observed)
results.Summary(log=log,
fullSummary=self.fullVerificationSummary)
isOK = isOK and results.WasSuccessful()
# . Finish up.
isOK = isOK and (numberErrors == 0)
self.assertTrue(isOK)
def runTest(self):
"""The test."""
# . Initialization.
if self.generateReferenceData:
referenceData = TestDataSet("Charmm Test")
else:
observed = {}
# . Output setup.
dataPath = os.path.join(os.getenv("PDYNAMO_PBABEL"), "data", "charmm")
outPath = None
if self.resultPath is not None:
outPath = os.path.join(self.resultPath, "pdb")
if not os.path.exists(outPath): os.mkdir(outPath)
log = self.GetLog()
# . Get the parameters.
parameterPaths = []
for parameterPath in _ParameterPaths:
parameterPaths.append(
os.path.join(dataPath, parameterPath + ".prm"))
parameters = CHARMMParameterFiles_ToParameters(parameterPaths, log=log)
# . Generate systems.
for label in _SystemLabels:
if log is not None:
log.Text("\n" + (80 * "=") + "\n")
log.Text(label + "\n")
log.Text(80 * "=" + "\n")
system = CHARMMPSFFile_ToSystem(os.path.join(
dataPath, label + ".psfx"),
isXPLOR=True,
parameters=parameters,
log=log)
system.coordinates3 = CHARMMCRDFile_ToCoordinates3(os.path.join(
dataPath, label + ".chm"),
log=log)
system.label = label
system.DefineNBModel(NBModelFull())
system.Summary(log=log)
energy = system.Energy(log=log)
log.Text("\nEnergy (kcal/mole) = {:.4f}\n".format(
energy /
UNITS_ENERGY_KILOCALORIES_PER_MOLE_TO_KILOJOULES_PER_MOLE))
# . Get the dictionary of energies.
localObserved = system.configuration.energyTerms.Terms(
asDictionary=True)
localObserved["Potential Energy"] = energy
# . Test gradients.
if len(system.atoms) <= _MaximumAtoms:
of = SystemGeometryObjectiveFunction.FromSystem(system)
of.TestGradients(log=log)
localObserved["Gradient Error"] = of.TestGradients(log=log)
# . Write PDB file and do various sequence tests.
if not self.generateReferenceData:
if outPath is not None:
PDBFile_FromSystem(os.path.join(outPath, label + ".pdb"),
system,
useSegmentEntityLabels=True)
system.sequence.PrintComponentSequence(log=log)
log.Text("\nSelections:\n\n")
for pattern in _Patterns[label]:
log.Text("{:<30s} {:5d}\n".format(
pattern,
len(AtomSelection.FromAtomPattern(system, pattern))))
# . Generate reference data.
if self.generateReferenceData:
localData = TestDataSet(label, parent=referenceData)
for (key, value) in localObserved.iteritems():
if key == "Gradient Error":
localData.AddDatum(
TestReal(key,
value,
localData,
absoluteErrorTolerance=
_GradientAbsoluteErrorTolerance))
else:
localData.AddDatum(
TestReal(
key,
value,
localData,
absoluteErrorTolerance=_AbsoluteErrorTolerance,
toleranceFormat="{:.3f}",
valueFormat="{:.3f}"))
referenceData.AddDatum(localData)
# . Accumulate observed data.
else:
observed[label] = localObserved
# . Generate the reference data.
if self.generateReferenceData:
referenceData.Summary(log=log)
Pickle(self.referenceDataPath, referenceData)
isOK = True
# . Verify the observed data against the reference data.
else:
referenceData = Unpickle(self.referenceDataPath)
results = referenceData.VerifyAgainst(observed)
results.Summary(log=log, fullSummary=self.fullVerificationSummary)
isOK = results.WasSuccessful()
# . Success/failure.
self.assertTrue(isOK)
def runTest ( self ):
"""The test."""
# . Initialization.
failures = 0
otherFailures = 0
successes = 0
# . Paths.
dataPath = os.path.join ( os.getenv ( "PDYNAMO_PMOLECULE" ), "data", "pdb" )
if self.resultPath is None: outPath = os.path.join ( os.getenv ( "PDYNAMO_SCRATCH" ), _Destination )
else: outPath = os.path.join ( self.resultPath, _Destination )
if not os.path.exists ( outPath ): os.mkdir ( outPath )
log = self.GetLog ( )
# . Models.
mmModel = MMModelCHARMM ( "c36a2" )
nbModel = NBModelABFS ( )
qcModel = QCModelMNDO ( )
# . Get the file.
pdbFile = os.path.join ( dataPath, "2E4E_folded_solvated.pdb" )
( head, tail ) = os.path.split ( pdbFile )
tag = tail[0:-4]
if log is not None: log.Text ( "\nProcessing " + pdbFile + ":\n" )
system = PDBFile_ToSystem ( pdbFile, log = log, useComponentLibrary = True )
try:
# . Fixed atoms.
fixedAtoms = Selection ( ~ AtomSelection.FromAtomPattern ( system, "A:*:*" ) )
# . QC selection.
indices = set ( )
for atomTag in _Tags:
indices.add ( system.sequence.AtomIndex ( "A:TYR.2:" + atomTag ) )
tyrosine = Selection ( indices )
# . Setup.
system.electronicState = ElectronicState ( charge = 0, multiplicity = 1 )
system.DefineFixedAtoms ( fixedAtoms )
system.DefineSymmetry ( crystalClass = CrystalClassCubic ( ), a = _BoxSize )
system.DefineMMModel ( mmModel, log = log )
system.DefineQCModel ( qcModel, qcSelection = tyrosine )
system.DefineNBModel ( nbModel )
system.Summary ( log = log )
referenceEnergy = system.Energy ( log = log, doGradients = True )
# . Pickling.
pklFile = os.path.join ( outPath, tag + ".pkl" )
yamlFile = os.path.join ( outPath, tag + ".yaml" )
Pickle ( pklFile , system )
YAMLPickle ( yamlFile, system )
# . Unpickling.
pklSystem = Unpickle ( pklFile )
pklSystem.label += " (Pickled)"
pklSystem.Summary ( log = log )
pklEnergy = pklSystem.Energy ( log = log, doGradients = True )
if math.fabs ( referenceEnergy - pklEnergy <= _Tolerance ): successes += 1
else: failures += 1
yamlSystem = YAMLUnpickle ( yamlFile )
yamlSystem.label += " (YAMLPickled)"
yamlSystem.Summary ( log = log )
yamlEnergy = yamlSystem.Energy ( log = log, doGradients = True )
if math.fabs ( referenceEnergy - yamlEnergy <= _Tolerance ): successes += 1
else: failures += 1
except Exception as e:
otherFailures += 1
if log is not None: log.Text ( "\nError occurred> " + e.args[0] + "\n" )
# . Summary of results.
if log is not None:
summary = log.GetSummary ( )
summary.Start ( "Pickle Tests" )
summary.Entry ( "Pickle Successes", "{:d}".format ( successes ) )
summary.Entry ( "Pickle Failures" , "{:d}".format ( failures ) )
summary.Entry ( "Total Tests" , "2" )
summary.Entry ( "Loop Failures" , "{:d}".format ( otherFailures ) )
summary.Stop ( )
# . Success/failure.
self.assertTrue ( ( failures == 0 ) and ( otherFailures == 0 ) )
def runTest(self):
"""The test."""
# . Initialization.
observed = {}
gromacsReference = True
# . We have two references: One for energies obtained with Gromacs; another for pDynamo energies
if gromacsReference:
referenceDataPath = os.path.join(
os.getenv("PDYNAMO_PBABEL"), "data",
"reference/GromacsTopCrdRead_gromacsValues.pkl")
else:
referenceDataPath = os.path.join(
os.getenv("PDYNAMO_PBABEL"), "data",
"reference/GromacsTopCrdRead_pDynamoValues.pkl")
# . Output setup.
dataPath = os.path.join(os.getenv("PDYNAMO_PBABEL"), "data", "gromacs")
outPath = None
self.resultPath = dataPath
if self.resultPath is not None:
outPath = os.path.join(self.resultPath, "pdb")
if not os.path.exists(outPath): os.mkdir(outPath)
log = self.GetLog()
# . Generate systems.
for label in _SystemLabels:
# . Force field.
for ff in _ForceFields:
# . Header.
if log is not None:
log.Text("\n" + (120 * "=") + "\n")
log.Text(label + "-" + ff + "\n")
log.Text(120 * "=" + "\n")
# . Get the parameters.
filename = os.path.join(dataPath, label + "_" + ff)
parameters = GromacsParameters_ToParameters(filename + ".top",
log=log)
system = GromacsDefinitions_ToSystem(filename + ".top",
parameters=parameters,
log=log)
system.coordinates3 = GromacsCrdFile_ToCoordinates3(filename +
".gro",
log=log)
system.label = label
if hasattr(system.configuration, "symmetryParameters"):
system.DefineNBModel(NBModelABFS(**ABFS_options))
else:
system.DefineNBModel(NBModelFull())
system.Summary(log=log)
energy = system.Energy(log=log)
log.Text("\nEnergy (kcal/mole) = {:.4f}\n".format(
energy /
UNITS_ENERGY_KILOCALORIES_PER_MOLE_TO_KILOJOULES_PER_MOLE))
# . Get the dictionary of energies.
localObserved = system.configuration.energyTerms.Terms(
asDictionary=True)
localObserved["Potential Energy"] = energy
# . U-B term in Gromacs includes harmonic angle contribution, but not in pDynamo. Their sum should be equal, though.
if gromacsReference and (ff == "CHARMM"):
localObserved["Harmonic Angle + U-B"] = localObserved[
"Harmonic Angle"] + localObserved["Urey-Bradley"]
del localObserved["Harmonic Angle"]
del localObserved["Urey-Bradley"]
# . Test gradients.
if len(system.atoms) <= _MaximumAtoms:
of = SystemGeometryObjectiveFunction.FromSystem(system)
of.TestGradients(log=log)
localObserved["Gradient Error"] = of.TestGradients(log=log)
# . Write PDB file
if outPath is not None:
PDBFile_FromSystem(os.path.join(outPath, label + ".pdb"),
system)
# . Accumulate current data
dataLabel = label + "-" + ff
observed[dataLabel] = localObserved
# . Verify the observed data against the reference data.
referenceData = Unpickle(referenceDataPath)
results = referenceData.VerifyAgainst(observed)
isOK = results.WasSuccessful()
results.Summary(log=log, fullSummary=True)
# . Success/failure.
self.assertTrue(isOK)
"""Merge systems into one."""
import os, os.path, sys
sys.path.append(
os.path.join(os.path.dirname(os.path.realpath(__file__)), "..", "data"))
from Definitions import outPath
from pCore import Pickle, Unpickle
from pMoleculeScripts import MergeByAtom
# . Specify the file names containing the systems to merge.
pklFiles = ["part1.pkl", "part2.pkl", "part3.pkl"]
# . Recover the systems from the files.
parts = []
for pklFile in pklFiles:
parts.append(Unpickle(os.path.join(outPath, pklFile)))
# . Merge the systems.
system = MergeByAtom(parts)
system.Summary()
# . Save the system.
Pickle(os.path.join(outPath, "step5.pkl"), system)