def getEffectiveEnergy(self, totalEnergy, groupEnergy):
"""Given the actual potential energy of the system, return the value of the effective potential.
Parameters
----------
totalEnergy : energy
the actual potential energy of the whole system
groupEnergy : energy
the actual potential energy of the boosted force group
Returns
-------
energy
the value of the effective potential
"""
alphaTotal = self.getAlphaTotal()
ETotal = self.getETotal()
alphaGroup = self.getAlphaGroup()
EGroup = self.getEGroup()
if not is_quantity(totalEnergy):
totalEnergy = totalEnergy * kilojoules_per_mole # Assume kJ/mole
if not is_quantity(groupEnergy):
groupEnergy = groupEnergy * kilojoules_per_mole # Assume kJ/mole
dE = 0.0 * kilojoules_per_mole
if (totalEnergy < ETotal):
dE = dE + (ETotal - totalEnergy) * (ETotal - totalEnergy) / (
alphaTotal + ETotal - totalEnergy)
if (groupEnergy < EGroup):
dE = dE + (EGroup - groupEnergy) * (EGroup - groupEnergy) / (
alphaGroup + EGroup - groupEnergy)
return totalEnergy + dE
def testCollectionQuantityOperations(self):
""" Tests that Quantity collections behave correctly """
# Tests that __getitem__ returns a unit
s = [1, 2, 3, 4] * u.angstroms
self.assertTrue(u.is_quantity(s[0]))
for i, val in enumerate(s):
self.assertTrue(u.is_quantity(val))
self.assertEqual(val, (i+1) * u.angstroms)
# Tests that __setitem__ fails when an incompatible type is added
def fail(s): s[0] = 5
self.assertRaises(AttributeError, lambda: fail(s))
def fail(s): s[0] = 5 * u.joules
self.assertRaises(TypeError, lambda: fail(s))
def fail(s): s[0] /= 10 * u.meters
self.assertRaises(AttributeError, lambda: fail(s))
# Tests that __setitem__ converts to the unit of the container
s[0] = 1 * u.nanometers
self.assertEqual(s[0]._value, 10)
# Tests standard unit conversions
x = [1, 2, 3] * u.centimeters
self.assertEqual(x / u.millimeters, [10, 20, 30])
# Test the construction of a container in which each element is a
# Quantity, passed to the Quantity constructor
x = u.Quantity([1*u.angstrom, 2*u.nanometer, 3*u.angstrom])
self.assertEqual(x._value, [1, 20, 3])
self.assertEqual(x.unit, u.angstrom)
x = u.Quantity((1, 2, 3))
self.assertTrue(u.is_quantity(x))
self.assertTrue(x.unit.is_dimensionless())
x = u.Quantity(([1*u.angstrom, 2*u.nanometer, 3*u.angstrom],
[1*u.angstrom, 4*u.nanometer, 3*u.angstrom]))
self.assertEqual(x._value, ([1, 20, 3], [1, 40, 3]))
self.assertEqual(x.unit, u.angstrom)
self.assertTrue(u.is_quantity(u.Quantity([])))
def testNumpyDeepCopy(self):
""" Check that deepcopy on numpy array does not strip units """
x = u.Quantity(np.zeros((2, 3)), u.nanometer)
y = copy.deepcopy(x)
self.assertTrue(np.all(x == y))
self.assertTrue(u.is_quantity(x))
self.assertTrue(u.is_quantity(y))
def getEffectiveEnergy(self, totalEnergy, groupEnergy):
"""Given the actual potential energy of the system, return the value of the effective potential.
Parameters
----------
totalEnergy : energy
the actual potential energy of the whole system
groupEnergy : energy
the actual potential energy of the boosted force group
Returns
-------
energy
the value of the effective potential
"""
alphaTotal = self.getAlphaTotal()
ETotal = self.getETotal()
alphaGroup = self.getAlphaGroup()
EGroup = self.getEGroup()
if not is_quantity(totalEnergy):
totalEnergy = totalEnergy*kilojoules_per_mole # Assume kJ/mole
if not is_quantity(groupEnergy):
groupEnergy = groupEnergy*kilojoules_per_mole # Assume kJ/mole
dE = 0.0*kilojoules_per_mole
if (totalEnergy < ETotal):
dE = dE + (ETotal-totalEnergy)*(ETotal-totalEnergy)/(alphaTotal+ETotal-totalEnergy)
if (groupEnergy < EGroup):
dE = dE + (EGroup-groupEnergy)*(EGroup-groupEnergy)/(alphaGroup+EGroup-groupEnergy)
return totalEnergy+dE
def testScalarQuantityConstructor(self):
""" Tests creating a Quantity using the Quantity constructor """
self.assertTrue(u.is_quantity(u.Quantity(5, u.centimeters)))
self.assertTrue(u.is_quantity(u.Quantity(5, u.centimeters**-1)))
x = u.Quantity(value=5.0, unit=100.0*u.meters)
self.assertTrue(u.is_quantity(x))
self.assertEqual(x, 500*u.meters)
def testCollectionQuantities(self):
""" Tests the use of collections as Quantity values """
s = [1, 2, 3] * u.centimeters
self.assertEqual(str(s), '[1, 2, 3] cm')
self.assertTrue(u.is_quantity(s))
s2 = s / u.millimeters
self.assertEqual(s2, [10.0, 20.0, 30.0])
self.assertEqual(s2, s.value_in_unit(u.millimeters))
# Test 2-D list
s = [[1, 2, 3], [4, 5, 6]]
s *= u.centimeters
self.assertTrue(u.is_quantity(s))
s2 = s / u.millimeters
self.assertEqual(s2, [[10.0, 20.0, 30.0], [40.0, 50.0, 60.0]])
self.assertEqual(s.value_in_unit(u.millimeters), s2)
# Test tuples
s = (1, 2, 3) * u.centimeters
self.assertTrue(u.is_quantity(s))
self.assertEqual(str(s), '(1, 2, 3) cm')
s2 = s / u.millimeters
self.assertEqual(s2, (10, 20, 30))
self.assertIsInstance(s2, tuple)
self.assertEqual(s.value_in_unit(u.millimeters), s2)
self.assertIsInstance(s.value_in_unit(u.millimeters), tuple)
x = [1, 2, 3] * u.centimeters
x *= u.meters
self.assertEqual(x, [100, 200, 300] * u.centimeters**2)
def writeModel(self, positions, unitCellDimensions=None, periodicBoxVectors=None):
"""Write out a model to the DCD file.
The periodic box can be specified either by the unit cell dimensions (for a rectangular box), or the full set of box
vectors (for an arbitrary triclinic box). If neither is specified, the box vectors specified in the Topology will be
used. Regardless of the value specified, no dimensions will be written if the Topology does not represent a periodic system.
Parameters:
- positions (list) The list of atomic positions to write
- unitCellDimensions (Vec3=None) The dimensions of the crystallographic unit cell.
- periodicBoxVectors (tuple of Vec3=None) The vectors defining the periodic box.
"""
if len(list(self._topology.atoms())) != len(positions):
raise ValueError('The number of positions must match the number of atoms')
if is_quantity(positions):
positions = positions.value_in_unit(nanometers)
if any(math.isnan(norm(pos)) for pos in positions):
raise ValueError('Particle position is NaN')
if any(math.isinf(norm(pos)) for pos in positions):
raise ValueError('Particle position is infinite')
file = self._file
# Update the header.
self._modelCount += 1
file.seek(8, os.SEEK_SET)
file.write(struct.pack('<i', self._modelCount))
file.seek(20, os.SEEK_SET)
file.write(struct.pack('<i', self._firstStep+self._modelCount*self._interval))
# Write the data.
file.seek(0, os.SEEK_END)
boxVectors = self._topology.getPeriodicBoxVectors()
if boxVectors is not None:
if periodicBoxVectors is not None:
boxVectors = periodicBoxVectors
elif unitCellDimensions is not None:
if is_quantity(unitCellDimensions):
unitCellDimensions = unitCellDimensions.value_in_unit(nanometers)
boxVectors = (Vec3(unitCellDimensions[0], 0, 0), Vec3(0, unitCellDimensions[1], 0), Vec3(0, 0, unitCellDimensions[2]))*nanometers
(a_length, b_length, c_length, alpha, beta, gamma) = computeLengthsAndAngles(boxVectors)
a_length = a_length * 10. # computeLengthsAndAngles returns unitless nanometers, but need angstroms here.
b_length = b_length * 10. # computeLengthsAndAngles returns unitless nanometers, but need angstroms here.
c_length = c_length * 10. # computeLengthsAndAngles returns unitless nanometers, but need angstroms here.
angle1 = math.sin(math.pi/2-gamma)
angle2 = math.sin(math.pi/2-beta)
angle3 = math.sin(math.pi/2-alpha)
file.write(struct.pack('<i6di', 48, a_length, angle1, b_length, angle2, angle3, c_length, 48))
length = struct.pack('<i', 4*len(positions))
for i in range(3):
file.write(length)
data = array.array('f', (10*x[i] for x in positions))
data.tofile(file)
file.write(length)
def testAngleQuantities(self):
""" Tests angle measurements """
self.assertEqual(1.0*u.radians / u.degrees, 180 / math.pi)
self.assertTrue(u.is_quantity(1.0*u.radians))
self.assertTrue(u.is_quantity(1.0*u.degrees))
self.assertEqual((1.0*u.radians).in_units_of(u.degrees),
(180 / math.pi)*u.degrees)
self.assertEqual(90*u.degrees/u.radians, math.pi/2)
q = 90 * u.degrees + 0.3 * u.radians
self.assertEqual(q._value, 90 + 180*0.3/math.pi)
self.assertEqual(q.unit, u.degrees)
def _writeModel(topology,
positions,
file=sys.stdout,
subset=None,
velocities=None):
"""Write out a model to a PDB file.
Parameters
----------
topology : Topology
The Topology defining the model to write
positions : list
The list of atomic positions to write
file : file=stdout
A file to write the model to
subset : list(int)=None
If not None, only the selected atoms will be written
"""
atoms = list(topology.atoms())
if len(atoms) != len(positions):
raise ValueError(
'The number of positions must match the number of atoms')
if is_quantity(positions):
positions = positions.value_in_unit(nanometer)
if velocities is not None:
if len(atoms) != len(velocities):
raise ValueError(
'The number of velocities must match the number of atoms')
if is_quantity(velocities):
velocities = velocities.value_in_unit(nanometer / picosecond)
if subset is None:
subset = list(range(len(atoms)))
print('%i' % len(subset), file=file)
for ii, i in enumerate(subset):
atom = atoms[i]
residue = atom.residue
coords = positions[i]
# writing atom symbol instead of name makes visualization easier
if atom.element is not None:
name = atom.element.symbol
else:
name = ''.join(i for i in atom.name if not i.isdigit())
line = '%5i%5s%5s%5i%8.3f%8.3f%8.3f' % (
(residue.index + 1) % 100000, residue.name[:5], name[:5],
(atom.index + 1) % 100000, coords[0], coords[1], coords[2])
if velocities is not None:
vel = velocities[i]
line += '%8.4f%8.4f%8.4f' % (vel[0], vel[1], vel[2])
print(line, file=file)
def runForClockTime(self,
time,
checkpointFile=None,
stateFile=None,
checkpointInterval=None):
"""Advance the simulation by integrating time steps until a fixed amount of clock time has elapsed.
This is useful when you have a limited amount of computer time available, and want to run the longest simulation
possible in that time. This method will continue taking time steps until the specified clock time has elapsed,
then return. It also can automatically write out a checkpoint and/or state file before returning, so you can
later resume the simulation. Another option allows it to write checkpoints or states at regular intervals, so
you can resume even if the simulation is interrupted before the time limit is reached.
Parameters
----------
time : time
the amount of time to run for. If no units are specified, it is
assumed to be a number of hours.
checkpointFile : string or file=None
if specified, a checkpoint file will be written at the end of the
simulation (and optionally at regular intervals before then) by
passing this to saveCheckpoint().
stateFile : string or file=None
if specified, a state file will be written at the end of the
simulation (and optionally at regular intervals before then) by
passing this to saveState().
checkpointInterval : time=None
if specified, checkpoints and/or states will be written at regular
intervals during the simulation, in addition to writing a final
version at the end. If no units are specified, this is assumed to
be in hours.
"""
if unit.is_quantity(time):
time = time.value_in_unit(unit.hours)
if unit.is_quantity(checkpointInterval):
checkpointInterval = checkpointInterval.value_in_unit(unit.hours)
endTime = datetime.now() + timedelta(hours=time)
while (datetime.now() < endTime):
if checkpointInterval is None:
nextTime = endTime
else:
nextTime = datetime.now() + timedelta(hours=checkpointInterval)
if nextTime > endTime:
nextTime = endTime
self._simulate(endTime=nextTime)
if checkpointFile is not None:
self.saveCheckpoint(checkpointFile)
if stateFile is not None:
self.saveState(stateFile)
def testDimensionless(self):
""" Tests the properties of unit.dimensionless """
x = 5 * u.dimensionless
y = u.Quantity(5, u.dimensionless)
self.assertTrue(u.is_quantity(x))
self.assertTrue(u.is_quantity(y))
self.assertNotEqual(x, 5)
self.assertNotEqual(y, 5)
self.assertEqual(x, y)
self.assertEqual(x.value_in_unit_system(u.si_unit_system), 5)
self.assertEqual(x.value_in_unit_system(u.cgs_unit_system), 5)
self.assertEqual(x.value_in_unit_system(u.md_unit_system), 5)
x = u.Quantity(1.0, u.dimensionless)
y = u.Quantity(1.0, u.dimensionless)
self.assertIsNot(x, y)
self.assertEqual(x, y)
def _initializeConstants(self, context_state):
"""Initialize a set of constants required for the reports
Parameters
----------
context_state : :class:`openmm.State`
The current state of the context
"""
system = context_state.system
if self._temperature:
# Compute the number of degrees of freedom.
dof = 0
for i in range(system.getNumParticles()):
if system.getParticleMass(i) > 0 * unit.dalton:
dof += 3
dof -= system.getNumConstraints()
if any(
type(system.getForce(i)) == openmm.CMMotionRemover
for i in range(system.getNumForces())):
dof -= 3
self._dof = dof
if self._density:
if self._totalMass is None:
# Compute the total system mass.
self._totalMass = 0 * unit.dalton
for i in range(system.getNumParticles()):
self._totalMass += system.getParticleMass(i)
elif not unit.is_quantity(self._totalMass):
self._totalMass = self._totalMass * unit.dalton
def __init__(self, file, topology, dt, firstStep=0, interval=1):
"""Create a DCD file and write out the header.
Parameters:
- file (file) A file to write to
- topology (Topology) The Topology defining the molecular system being written
- dt (time) The time step used in the trajectory
- firstStep (int=0) The index of the first step in the trajectory
- interval (int=1) The frequency (measured in time steps) at which states are written to the trajectory
"""
self._file = file
self._topology = topology
self._firstStep = firstStep
self._interval = interval
self._modelCount = 0
if is_quantity(dt):
dt = dt.value_in_unit(picoseconds)
dt /= 0.04888821
boxFlag = 0
if topology.getUnitCellDimensions() is not None:
boxFlag = 1
header = struct.pack('<i4c9if', 84, 'C', 'O', 'R', 'D', 0, firstStep,
interval, 0, 0, 0, 0, 0, 0, dt)
header += struct.pack('<13i', boxFlag, 0, 0, 0, 0, 0, 0, 0, 0, 24, 84,
164, 2)
header += struct.pack('<80s', 'Created by OpenMM')
header += struct.pack(
'<80s', 'Created ' + time.asctime(time.localtime(time.time())))
header += struct.pack('<4i', 164, 4, len(list(topology.atoms())), 4)
file.write(header)
def __init__(self, file, topology, dt, firstStep=0, interval=1):
"""Create a DCD file and write out the header.
Parameters:
- file (file) A file to write to
- topology (Topology) The Topology defining the molecular system being written
- dt (time) The time step used in the trajectory
- firstStep (int=0) The index of the first step in the trajectory
- interval (int=1) The frequency (measured in time steps) at which states are written to the trajectory
"""
self._file = file
self._topology = topology
self._firstStep = firstStep
self._interval = interval
self._modelCount = 0
if is_quantity(dt):
dt = dt.value_in_unit(picoseconds)
dt /= 0.04888821
boxFlag = 0
if topology.getUnitCellDimensions() is not None:
boxFlag = 1
header = struct.pack('<i4c9if', 84, b'C', b'O', b'R', b'D', 0, firstStep, interval, 0, 0, 0, 0, 0, 0, dt)
header += struct.pack('<13i', boxFlag, 0, 0, 0, 0, 0, 0, 0, 0, 24, 84, 164, 2)
header += struct.pack('<80s', b'Created by OpenMM')
header += struct.pack('<80s', b'Created '+time.asctime(time.localtime(time.time())).encode('ascii'))
header += struct.pack('<4i', 164, 4, len(list(topology.atoms())), 4)
file.write(header)
def _initializeConstants(self, simulation):
"""Initialize a set of constants required for the reports
Parameters
- simulation (Simulation) The simulation to generate a report for
"""
system = simulation.system
if self._temperature:
# Compute the number of degrees of freedom.
dof = 0
for i in range(system.getNumParticles()):
if system.getParticleMass(i) > 0*unit.dalton:
dof += 3
dof -= system.getNumConstraints()
if any(type(system.getForce(i)) == mm.CMMotionRemover for i in range(system.getNumForces())):
dof -= 3
self._dof = dof
if self._density:
if self._totalMass is None:
# Compute the total system mass.
self._totalMass = 0*unit.dalton
for i in range(system.getNumParticles()):
self._totalMass += system.getParticleMass(i)
elif not unit.is_quantity(self._totalMass):
self._totalMass = self._totalMass*unit.dalton
def writeModel(topology,
positions,
file=sys.stdout,
modelIndex=1,
keepIds=False):
"""Write out a model to a PDBx/mmCIF file.
Parameters
----------
topology : Topology
The Topology defining the model to write
positions : list
The list of atomic positions to write
file : file=stdout
A file to write the model to
modelIndex : int=1
The model number of this frame
keepIds : bool=False
If True, keep the residue and chain IDs specified in the Topology
rather than generating new ones. Warning: It is up to the caller to
make sure these are valid IDs that satisfy the requirements of the
PDBx/mmCIF format. Otherwise, the output file will be invalid.
"""
if len(list(topology.atoms())) != len(positions):
raise ValueError(
'The number of positions must match the number of atoms')
if is_quantity(positions):
positions = positions.value_in_unit(angstroms)
if any(math.isnan(norm(pos)) for pos in positions):
raise ValueError('Particle position is NaN')
if any(math.isinf(norm(pos)) for pos in positions):
raise ValueError('Particle position is infinite')
atomIndex = 1
posIndex = 0
for (chainIndex, chain) in enumerate(topology.chains()):
if keepIds:
chainName = chain.id
else:
chainName = chr(ord('A') + chainIndex % 26)
residues = list(chain.residues())
for (resIndex, res) in enumerate(residues):
if keepIds:
resId = res.id
else:
resId = resIndex + 1
for atom in res.atoms():
coords = positions[posIndex]
if atom.element is not None:
symbol = atom.element.symbol
else:
symbol = '?'
line = "ATOM %5d %-3s %-4s . %-4s %s ? %5s . %10.4f %10.4f %10.4f 0.0 0.0 ? ? ? ? ? . %5s %4s %s %4s %5d"
print(line %
(atomIndex, symbol, atom.name, res.name, chainName,
resId, coords[0], coords[1], coords[2], resId,
res.name, chainName, atom.name, modelIndex),
file=file)
posIndex += 1
atomIndex += 1
def _strip_optunit(thing, unit):
"""
Strips optional units, converting to specified unit type. If no unit
present, it just returns the number
"""
if u.is_quantity(thing):
return thing.value_in_unit(unit)
return thing
def _strip_optunit(thing, unit):
"""
Strips optional units, converting to specified unit type. If no unit
present, it just returns the number
"""
if u.is_quantity(thing):
return thing.value_in_unit(unit)
return thing
def writeModel(topology, positions, file=sys.stdout, modelIndex=None):
"""Write out a model to a PDB file.
Parameters:
- topology (Topology) The Topology defining the model to write
- positions (list) The list of atomic positions to write
- file (file=stdout) A file to write the model to
- modelIndex (int=None) If not None, the model will be surrounded by MODEL/ENDMDL records with this index
"""
if len(list(topology.atoms())) != len(positions):
raise ValueError(
'The number of positions must match the number of atoms')
if is_quantity(positions):
positions = positions.value_in_unit(angstroms)
if any(math.isnan(norm(pos)) for pos in positions):
raise ValueError('Particle position is NaN')
if any(math.isinf(norm(pos)) for pos in positions):
raise ValueError('Particle position is infinite')
atomIndex = 1
posIndex = 0
if modelIndex is not None:
print >> file, "MODEL %4d" % modelIndex
for (chainIndex, chain) in enumerate(topology.chains()):
chainName = chr(ord('A') + chainIndex % 26)
residues = list(chain.residues())
for (resIndex, res) in enumerate(residues):
if len(res.name) > 3:
resName = res.name[:3]
else:
resName = res.name
for atom in res.atoms():
if len(atom.name) < 4 and atom.name[:1].isalpha() and (
atom.element is None
or len(atom.element.symbol) < 2):
atomName = ' ' + atom.name
elif len(atom.name) > 4:
atomName = atom.name[:4]
else:
atomName = atom.name
coords = positions[posIndex]
if atom.element is not None:
symbol = atom.element.symbol
else:
symbol = ' '
line = "ATOM %5d %-4s %3s %s%4d %s%s%s 1.00 0.00 %2s " % (
atomIndex % 100000, atomName, resName, chainName,
(resIndex + 1) % 10000, _format_83(coords[0]),
_format_83(coords[1]), _format_83(coords[2]), symbol)
assert len(line) == 80, 'Fixed width overflow detected'
print >> file, line
posIndex += 1
atomIndex += 1
if resIndex == len(residues) - 1:
print >> file, "TER %5d %3s %s%4d" % (
atomIndex, resName, chainName, resIndex + 1)
atomIndex += 1
if modelIndex is not None:
print >> file, "ENDMDL"
def __init__(self,
file,
topology,
dt,
firstStep=0,
interval=1,
append=False):
"""Create a DCD file and write out the header, or open an existing file to append.
Parameters
----------
file : file
A file to write to
topology : Topology
The Topology defining the molecular system being written
dt : time
The time step used in the trajectory
firstStep : int=0
The index of the first step in the trajectory
interval : int=1
The frequency (measured in time steps) at which states are written
to the trajectory
append : bool=False
If True, open an existing DCD file to append to. If False, create a new file.
"""
self._file = file
self._topology = topology
self._firstStep = firstStep
self._interval = interval
self._modelCount = 0
if is_quantity(dt):
dt = dt.value_in_unit(picoseconds)
dt /= 0.04888821
self._dt = dt
boxFlag = 0
if topology.getUnitCellDimensions() is not None:
boxFlag = 1
if append:
file.seek(8, os.SEEK_SET)
self._modelCount = struct.unpack('<i', file.read(4))[0]
file.seek(268, os.SEEK_SET)
numAtoms = struct.unpack('<i', file.read(4))[0]
if numAtoms != len(list(topology.atoms())):
raise ValueError(
'Cannot append to a DCD file that contains a different number of atoms'
)
else:
header = struct.pack('<i4c9if', 84, b'C', b'O', b'R', b'D', 0,
firstStep, interval, 0, 0, 0, 0, 0, 0, dt)
header += struct.pack('<13i', boxFlag, 0, 0, 0, 0, 0, 0, 0, 0, 24,
84, 164, 2)
header += struct.pack('<80s', b'Created by OpenMM')
header += struct.pack(
'<80s', b'Created ' +
time.asctime(time.localtime(time.time())).encode('ascii'))
header += struct.pack('<4i', 164, 4, len(list(topology.atoms())),
4)
file.write(header)
def runForClockTime(self, time, checkpointFile=None, stateFile=None, checkpointInterval=None):
"""Advance the simulation by integrating time steps until a fixed amount of clock time has elapsed.
This is useful when you have a limited amount of computer time available, and want to run the longest simulation
possible in that time. This method will continue taking time steps until the specified clock time has elapsed,
then return. It also can automatically write out a checkpoint and/or state file before returning, so you can
later resume the simulation. Another option allows it to write checkpoints or states at regular intervals, so
you can resume even if the simulation is interrupted before the time limit is reached.
Parameters
----------
time : time
the amount of time to run for. If no units are specified, it is
assumed to be a number of hours.
checkpointFile : string or file=None
if specified, a checkpoint file will be written at the end of the
simulation (and optionally at regular intervals before then) by
passing this to saveCheckpoint().
stateFile : string or file=None
if specified, a state file will be written at the end of the
simulation (and optionally at regular intervals before then) by
passing this to saveState().
checkpointInterval : time=None
if specified, checkpoints and/or states will be written at regular
intervals during the simulation, in addition to writing a final
version at the end. If no units are specified, this is assumed to
be in hours.
"""
if unit.is_quantity(time):
time = time.value_in_unit(unit.hours)
if unit.is_quantity(checkpointInterval):
checkpointInterval = checkpointInterval.value_in_unit(unit.hours)
endTime = datetime.now()+timedelta(hours=time)
while (datetime.now() < endTime):
if checkpointInterval is None:
nextTime = endTime
else:
nextTime = datetime.now()+timedelta(hours=checkpointInterval)
if nextTime > endTime:
nextTime = endTime
self._simulate(endTime=nextTime)
if checkpointFile is not None:
self.saveCheckpoint(checkpointFile)
if stateFile is not None:
self.saveState(stateFile)
def getEffectiveEnergy(self, energy):
"""Given the actual potential energy of the system, return the value of the effective potential."""
alpha = self.getAlpha()
E = self.getE()
if not is_quantity(energy):
energy = energy*kilojoules_per_mole # Assume kJ/mole
if (energy > E):
return energy
return energy+(E-energy)*(E-energy)/(alpha+E-energy)
def getEffectiveEnergy(self, energy):
"""Given the actual potential energy of the system, return the value of the effective potential."""
alpha = self.getAlpha()
E = self.getE()
if not is_quantity(energy):
energy = energy * kilojoules_per_mole # Assume kJ/mole
if (energy > E):
return energy
return energy + (E - energy) * (E - energy) / (alpha + E - energy)
def testNumpyDivision(self):
""" Tests that division of numpy Quantities works correctly """
x = u.Quantity(np.asarray([1., 2.]), u.nanometers)
y = u.Quantity(np.asarray([3., 4.]), u.picoseconds)
xy = x / y
self.assertTrue(u.is_quantity(xy))
self.assertEqual(xy.unit, u.nanometers/u.picoseconds)
self.assertEqual(xy[0].value_in_unit(u.nanometers/u.picoseconds), 1/3)
self.assertEqual(xy[1].value_in_unit(u.nanometers/u.picoseconds), 0.5)
def testNumpyFunctions(self):
""" Tests various numpy attributes that they result in Quantities """
a = u.Quantity(np.arange(10), u.seconds)
self.assertEqual(a.max(), 9*u.seconds)
self.assertEqual(a.min(), 0*u.seconds)
self.assertEqual(a.mean(), 4.5*u.seconds)
self.assertAlmostEqualQuantities(a.std(), 2.8722813232690143*u.seconds)
b = a.reshape((5, 2))
self.assertTrue(u.is_quantity(b))
def setUnitCellDimensions(self, dimensions):
"""Set the dimensions of the crystallographic unit cell.
This method is an alternative to setPeriodicBoxVectors() for the case of a rectangular box. It sets
the box vectors to be orthogonal to each other and to have the specified lengths."""
if dimensions is None:
self._periodicBoxVectors = None
else:
if is_quantity(dimensions):
dimensions = dimensions.value_in_unit(nanometers)
self._periodicBoxVectors = (Vec3(dimensions[0], 0, 0), Vec3(0, dimensions[1], 0), Vec3(0, 0, dimensions[2]))*nanometers
def writeModel(topology, positions, file=sys.stdout, modelIndex=None):
"""Write out a model to a PDB file.
Parameters:
- topology (Topology) The Topology defining the model to write
- positions (list) The list of atomic positions to write
- file (file=stdout) A file to write the model to
- modelIndex (int=None) If not None, the model will be surrounded by MODEL/ENDMDL records with this index
"""
if len(list(topology.atoms())) != len(positions):
raise ValueError('The number of positions must match the number of atoms')
if is_quantity(positions):
positions = positions.value_in_unit(angstroms)
if any(math.isnan(norm(pos)) for pos in positions):
raise ValueError('Particle position is NaN')
if any(math.isinf(norm(pos)) for pos in positions):
raise ValueError('Particle position is infinite')
atomIndex = 1
posIndex = 0
if modelIndex is not None:
print >>file, "MODEL %4d" % modelIndex
for (chainIndex, chain) in enumerate(topology.chains()):
chainName = chr(ord('A')+chainIndex%26)
residues = list(chain.residues())
for (resIndex, res) in enumerate(residues):
if len(res.name) > 3:
resName = res.name[:3]
else:
resName = res.name
for atom in res.atoms():
if len(atom.name) < 4 and atom.name[:1].isalpha() and (atom.element is None or len(atom.element.symbol) < 2):
atomName = ' '+atom.name
elif len(atom.name) > 4:
atomName = atom.name[:4]
else:
atomName = atom.name
coords = positions[posIndex]
if atom.element is not None:
symbol = atom.element.symbol
else:
symbol = ' '
line = "ATOM %5d %-4s %3s %s%4d %s%s%s 1.00 0.00 %2s " % (
atomIndex%100000, atomName, resName, chainName,
(resIndex+1)%10000, _format_83(coords[0]),
_format_83(coords[1]), _format_83(coords[2]), symbol)
assert len(line) == 80, 'Fixed width overflow detected'
print >>file, line
posIndex += 1
atomIndex += 1
if resIndex == len(residues)-1:
print >>file, "TER %5d %3s %s%4d" % (atomIndex, resName, chainName, resIndex+1)
atomIndex += 1
if modelIndex is not None:
print >>file, "ENDMDL"
def _standardized(quantity):
"""
Returns the numerical value of a quantity in a unit of measurement compatible with the
Molecular Dynamics unit system (mass in Da, distance in nm, time in ps, temperature in K,
energy in kJ/mol, angle in rad).
"""
if unit.is_quantity(quantity):
return quantity.value_in_unit_system(unit.md_unit_system)
else:
return quantity
def setUnitCellDimensions(self, dimensions):
"""Set the dimensions of the crystallographic unit cell.
This method is an alternative to setPeriodicBoxVectors() for the case of a rectangular box. It sets
the box vectors to be orthogonal to each other and to have the specified lengths."""
if dimensions is None:
self._periodicBoxVectors = None
else:
if is_quantity(dimensions):
dimensions = dimensions.value_in_unit(nanometers)
self._periodicBoxVectors = (Vec3(dimensions[0], 0, 0), Vec3(0, dimensions[1], 0), Vec3(0, 0, dimensions[2]))*nanometers
def setPeriodicBoxVectors(self, vectors):
"""Set the vectors defining the periodic box."""
if vectors is not None:
if not is_quantity(vectors[0][0]):
vectors = vectors*nanometers
if vectors[0][1] != 0*nanometers or vectors[0][2] != 0*nanometers:
raise ValueError("First periodic box vector must be parallel to x.");
if vectors[1][2] != 0*nanometers:
raise ValueError("Second periodic box vector must be in the x-y plane.");
if vectors[0][0] <= 0*nanometers or vectors[1][1] <= 0*nanometers or vectors[2][2] <= 0*nanometers or vectors[0][0] < 2*abs(vectors[1][0]) or vectors[0][0] < 2*abs(vectors[2][0]) or vectors[1][1] < 2*abs(vectors[2][1]):
raise ValueError("Periodic box vectors must be in reduced form.");
self._periodicBoxVectors = deepcopy(vectors)
def writeModel(topology, positions, file=sys.stdout, modelIndex=1, keepIds=False):
"""Write out a model to a PDBx/mmCIF file.
Parameters
----------
topology : Topology
The Topology defining the model to write
positions : list
The list of atomic positions to write
file : file=stdout
A file to write the model to
modelIndex : int=1
The model number of this frame
keepIds : bool=False
If True, keep the residue and chain IDs specified in the Topology
rather than generating new ones. Warning: It is up to the caller to
make sure these are valid IDs that satisfy the requirements of the
PDBx/mmCIF format. Otherwise, the output file will be invalid.
"""
if len(list(topology.atoms())) != len(positions):
raise ValueError('The number of positions must match the number of atoms')
if is_quantity(positions):
positions = positions.value_in_unit(angstroms)
if any(math.isnan(norm(pos)) for pos in positions):
raise ValueError('Particle position is NaN')
if any(math.isinf(norm(pos)) for pos in positions):
raise ValueError('Particle position is infinite')
atomIndex = 1
posIndex = 0
for (chainIndex, chain) in enumerate(topology.chains()):
if keepIds:
chainName = chain.id
else:
chainName = chr(ord('A')+chainIndex%26)
residues = list(chain.residues())
for (resIndex, res) in enumerate(residues):
if keepIds:
resId = res.id
resIC = (res.insertionCode if len(res.insertionCode) > 0 else '.')
else:
resId = resIndex + 1
resIC = '.'
for atom in res.atoms():
coords = positions[posIndex]
if atom.element is not None:
symbol = atom.element.symbol
else:
symbol = '?'
line = "ATOM %5d %-3s %-4s . %-4s %s ? %5s %s %10.4f %10.4f %10.4f 0.0 0.0 ? ? ? ? ? . %5s %4s %s %4s %5d"
print(line % (atomIndex, symbol, atom.name, res.name, chainName, resId, resIC, coords[0], coords[1], coords[2],
resId, res.name, chainName, atom.name, modelIndex), file=file)
posIndex += 1
atomIndex += 1
def setPeriodicBoxVectors(self, vectors):
"""Set the vectors defining the periodic box."""
if vectors is not None:
if not is_quantity(vectors[0][0]):
vectors = vectors*nanometers
if vectors[0][1] != 0*nanometers or vectors[0][2] != 0*nanometers:
raise ValueError("First periodic box vector must be parallel to x.");
if vectors[1][2] != 0*nanometers:
raise ValueError("Second periodic box vector must be in the x-y plane.");
if vectors[0][0] <= 0*nanometers or vectors[1][1] <= 0*nanometers or vectors[2][2] <= 0*nanometers or vectors[0][0] < 2*abs(vectors[1][0]) or vectors[0][0] < 2*abs(vectors[2][0]) or vectors[1][1] < 2*abs(vectors[2][1]):
raise ValueError("Periodic box vectors must be in reduced form.");
self._periodicBoxVectors = deepcopy(vectors)
def __init__(self, topology, positions):
"""Create a new Modeller object
Parameters:
- topology (Topology) the initial Topology of the model
- positions (list) the initial atomic positions
"""
## The Topology describing the structure of the system
self.topology = topology
if not is_quantity(positions):
positions = positions*nanometer
## The list of atom positions
self.positions = positions
def testUnitMathModule(self):
""" Tests the unit_math functions on Quantity objects """
self.assertEqual(u.sqrt(1.0*u.kilogram*u.joule),
1.0*u.kilogram*u.meter/u.second)
self.assertEqual(u.sqrt(1.0*u.kilogram*u.calorie),
math.sqrt(4.184)*u.kilogram*u.meter/u.second)
self.assertEqual(u.sqrt(9), 3) # Test on a scalar
self.assertEqual(u.sin(90*u.degrees), 1)
self.assertEqual(u.sin(math.pi/2*u.radians), 1)
self.assertEqual(u.sin(math.pi/2), 1)
self.assertEqual(u.cos(180*u.degrees), -1)
self.assertEqual(u.cos(math.pi*u.radians), -1)
self.assertEqual(u.cos(math.pi), -1)
self.assertAlmostEqual(u.tan(45*u.degrees), 1)
self.assertAlmostEqual(u.tan(math.pi/4*u.radians), 1)
self.assertAlmostEqual(u.tan(math.pi/4), 1)
acos = u.acos(1.0)
asin = u.asin(1.0)
atan = u.atan(1.0)
self.assertTrue(u.is_quantity(acos))
self.assertTrue(u.is_quantity(asin))
self.assertTrue(u.is_quantity(atan))
self.assertEqual(acos.unit, u.radians)
self.assertEqual(asin.unit, u.radians)
self.assertEqual(atan.unit, u.radians)
self.assertEqual(acos.value_in_unit(u.degrees), 0)
self.assertEqual(acos / u.radians, 0)
self.assertEqual(asin.value_in_unit(u.degrees), 90)
self.assertEqual(asin / u.radians, math.pi/2)
self.assertAlmostEqual(atan.value_in_unit(u.degrees), 45)
self.assertAlmostEqual(atan / u.radians, math.pi/4)
# Check some sequence maths
seq = [1, 2, 3, 4] * u.meters
self.assertEqual(u.sum(seq), 10*u.meters)
self.assertEqual(u.dot(seq, seq), (1+4+9+16)*u.meters**2)
self.assertEqual(u.norm(seq), math.sqrt(30)*u.meters)
def getEffectiveEnergy(self, groupEnergy):
"""Given the actual group energy of the system, return the value of the effective potential.
Parameters:
- groupEnergy (energy): the actual potential energy of the boosted force group
Returns: the value of the effective potential
"""
alphaGroup = self.getAlphaGroup()
EGroup = self.getEGroup()
if not is_quantity(groupEnergy):
groupEnergy = groupEnergy*kilojoules_per_mole # Assume kJ/mole
dE = 0.0*kilojoules_per_mole
if (groupEnergy < EGroup):
dE = dE + (EGroup-groupEnergy)*(EGroup-groupEnergy)/(alphaGroup+EGroup-groupEnergy)
return groupEnergy+dE
def writeModel(topology, positions, file=sys.stdout):
"""Write out a model to a PDB file.
Parameters
----------
topology : Topology
The Topology defining the model to write
positions : list
The list of atomic positions to write
file : file=stdout
A file to write the model to
modelIndex : int=None
If not None, the model will be surrounded by MODEL/ENDMDL records
with this index
keepIds : bool=False
If True, keep the residue and chain IDs specified in the Topology
rather than generating new ones. Warning: It is up to the caller to
make sure these are valid IDs that satisfy the requirements of the
PDB format. No guarantees are made about what will happen if they
are not, and the output file could be invalid.
extraParticleIdentifier : string=' '
String to write in the element column of the ATOM records for atoms whose element is None (extra particles)
"""
if len(list(topology.atoms())) != len(positions):
raise ValueError(
'The number of positions must match the number of atoms')
if is_quantity(positions):
positions = positions.value_in_unit(nanometer)
if any(math.isnan(norm(pos)) for pos in positions):
raise ValueError('Particle position is NaN')
if any(math.isinf(norm(pos)) for pos in positions):
raise ValueError('Particle position is infinite')
print('%i' % len(positions), file=file)
atomIndex = 1
for (chainIndex, chain) in enumerate(topology.chains()):
residues = list(chain.residues())
for (resIndex, res) in enumerate(residues):
resName = res.name[:4]
resId = res.id
for atom in res.atoms():
atomName = atom.name[:5]
coords = positions[atomIndex - 1]
line = '%5i%5s%5s%5i%8.3f%8.3f%8.3f' % (
int(resId), resName, atomName, atomIndex, coords[0],
coords[1], coords[2])
print(line, file=file)
atomIndex += 1
def _writeHeader(time=None, file=sys.stdout):
"""Write out the header for a PDB file.
Parameters
----------
topology : Topology
The Topology defining the molecular system being written
file : file=stdout
A file to write the file to
"""
if time is None:
time = 0.0
elif is_quantity(time):
time = time.value_in_unit(picosecond)
print("written by openmm t = %.3f ps" % time, file=file)
def computeLengthsAndAngles(periodicBoxVectors):
"""Convert periodic box vectors to lengths and angles.
Lengths are returned in nanometers and angles in radians.
"""
if is_quantity(periodicBoxVectors):
(a, b, c) = periodicBoxVectors.value_in_unit(nanometers)
else:
a, b, c = periodicBoxVectors
a_length = norm(a)
b_length = norm(b)
c_length = norm(c)
alpha = math.acos(dot(b, c) / (b_length * c_length))
beta = math.acos(dot(c, a) / (c_length * a_length))
gamma = math.acos(dot(a, b) / (a_length * b_length))
return (a_length, b_length, c_length, alpha, beta, gamma)
def getEffectiveEnergy(self, groupEnergy):
"""Given the actual group energy of the system, return the value of the effective potential.
Parameters:
- groupEnergy (energy): the actual potential energy of the boosted force group
Returns: the value of the effective potential
"""
alphaGroup = self.getAlphaGroup()
EGroup = self.getEGroup()
if not is_quantity(groupEnergy):
groupEnergy = groupEnergy * kilojoules_per_mole # Assume kJ/mole
dE = 0.0 * kilojoules_per_mole
if (groupEnergy < EGroup):
dE = dE + (EGroup - groupEnergy) * (EGroup - groupEnergy) / (
alphaGroup + EGroup - groupEnergy)
return groupEnergy + dE
def computeLengthsAndAngles(periodicBoxVectors):
"""Convert periodic box vectors to lengths and angles.
Lengths are returned in nanometers and angles in radians.
"""
if is_quantity(periodicBoxVectors):
(a, b, c) = periodicBoxVectors.value_in_unit(nanometers)
else:
a, b, c = periodicBoxVectors
a_length = norm(a)
b_length = norm(b)
c_length = norm(c)
alpha = math.acos(dot(b, c)/(b_length*c_length))
beta = math.acos(dot(c, a)/(c_length*a_length))
gamma = math.acos(dot(a, b)/(a_length*b_length))
return (a_length, b_length, c_length, alpha, beta, gamma)
def writeModel(self, positions, unitCellDimensions=None):
"""Write out a model to the DCD file.
Parameters:
- positions (list) The list of atomic positions to write
- unitCellDimensions (Vec3=None) The dimensions of the crystallographic unit cell. If None, the dimensions specified in
the Topology will be used. Regardless of the value specified, no dimensions will be written if the Topology does not
represent a periodic system.
"""
if len(list(self._topology.atoms())) != len(positions):
raise ValueError(
'The number of positions must match the number of atoms')
if is_quantity(positions):
positions = positions.value_in_unit(nanometers)
if any(math.isnan(norm(pos)) for pos in positions):
raise ValueError('Particle position is NaN')
if any(math.isinf(norm(pos)) for pos in positions):
raise ValueError('Particle position is infinite')
file = self._file
# Update the header.
self._modelCount += 1
file.seek(8, os.SEEK_SET)
file.write(struct.pack('<i', self._modelCount))
file.seek(20, os.SEEK_SET)
file.write(
struct.pack('<i',
self._firstStep + self._modelCount * self._interval))
# Write the data.
file.seek(0, os.SEEK_END)
boxSize = self._topology.getUnitCellDimensions()
if boxSize is not None:
if unitCellDimensions is not None:
boxSize = unitCellDimensions
size = boxSize.value_in_unit(angstroms)
file.write(
struct.pack('<i6di', 48, size[0], 0, size[1], 0, 0, size[2],
48))
length = struct.pack('<i', 4 * len(positions))
for i in range(3):
file.write(length)
data = array.array('f', (10 * x[i] for x in positions))
data.tofile(file)
file.write(length)
def testQuantityMaths(self):
""" Tests dimensional analysis & maths on and b/w Quantity objects """
x = 1.3 * u.meters
y = 75.2 * u.centimeters
self.assertEqual((x + y) / u.meters, 2.052)
self.assertEqual((x - y) / u.meters, 0.548)
self.assertEqual(x / y, 1.3 / 0.752)
self.assertEqual(x * y, 1.3 * 0.752 * u.meters**2)
d1 = 2.0 * u.meters
d2 = 2.0 * u.nanometers
self.assertEqual(d1 + d2, (2 + 2e-9) * u.meters)
self.assertAlmostEqual((d2 + d1 - (2e9 + 2) * u.nanometers)._value,
0,
places=6)
self.assertEqual(d1 + d1, 4.0 * u.meters)
self.assertEqual(d1 - d1, 0.0 * u.meters)
self.assertEqual(d1 / d1, 1.0)
self.assertEqual(d1 * u.meters, 2.0 * u.meters**2)
self.assertEqual(u.kilograms * (d1 / u.seconds) * (d1 / u.seconds),
4 * u.kilograms * u.meters**2 / u.seconds**2)
self.assertEqual(u.kilograms * (d1 / u.seconds)**2,
4 * u.kilograms * u.meters**2 / u.seconds**2)
self.assertEqual(d1**3, 8.0 * u.meters**3)
x = d1**(3 / 2)
self.assertAlmostEqual(x._value, math.sqrt(2)**3)
self.assertEqual(x.unit, u.meters**(3 / 2))
self.assertAlmostEqual((d1**0.5)._value, math.sqrt(2))
self.assertEqual((d1**0.5).unit, u.meters**0.5)
comp = (3.0 + 4.0j) * u.meters
self.assertTrue(u.is_quantity(comp))
self.assertEqual(comp.unit, u.meters)
self.assertEqual(str(comp), '(3+4j) m')
self.assertEqual(comp + comp, (6.0 + 8.0j) * u.meters)
self.assertEqual(comp - comp, 0 * u.meters)
self.assertEqual(comp * comp, (3.0 + 4.0j)**2 * u.meters**2)
self.assertAlmostEqual(comp / comp, 1)
self.assertAlmostEqual(1.5 * u.nanometers / u.meters,
1.5e-9,
places=15)
self.assertEqual((2.3 * u.meters)**2, 2.3**2 * u.meters**2)
x = 4.3 * u.meters
self.assertEqual(x / u.centimeters, 430)
self.assertEqual(str(x / u.seconds), '4.3 m/s')
self.assertEqual(str(8.4 / (4.2 * u.centimeters)), '2.0 /cm')
x = 1.2 * u.meters
self.assertEqual(x * 5, u.Quantity(6.0, u.meters))
def reducePeriodicBoxVectors(periodicBoxVectors):
""" Reduces the representation of the PBC. periodicBoxVectors is expected to
be an unpackable iterable of length-3 iterables
"""
if is_quantity(periodicBoxVectors):
a, b, c = periodicBoxVectors.value_in_unit(nanometers)
else:
a, b, c = periodicBoxVectors
a = Vec3(*a)
b = Vec3(*b)
c = Vec3(*c)
c = c - b * round(c[1] / b[1])
c = c - a * round(c[0] / a[0])
b = b - a * round(b[0] / a[0])
return (a, b, c) * nanometers
def reducePeriodicBoxVectors(periodicBoxVectors):
""" Reduces the representation of the PBC. periodicBoxVectors is expected to
be an unpackable iterable of length-3 iterables
"""
if is_quantity(periodicBoxVectors):
a, b, c = periodicBoxVectors.value_in_unit(nanometers)
else:
a, b, c = periodicBoxVectors
a = Vec3(*a)
b = Vec3(*b)
c = Vec3(*c)
c = c - b*round(c[1]/b[1])
c = c - a*round(c[0]/a[0])
b = b - a*round(b[0]/a[0])
return (a, b, c) * nanometers
def __init__(self, file, topology, dt, firstStep=0, interval=1, append=False):
"""Create a DCD file and write out the header, or open an existing file to append.
Parameters
----------
file : file
A file to write to
topology : Topology
The Topology defining the molecular system being written
dt : time
The time step used in the trajectory
firstStep : int=0
The index of the first step in the trajectory
interval : int=1
The frequency (measured in time steps) at which states are written
to the trajectory
append : bool=False
If True, open an existing DCD file to append to. If False, create a new file.
"""
self._file = file
self._topology = topology
self._firstStep = firstStep
self._interval = interval
self._modelCount = 0
if is_quantity(dt):
dt = dt.value_in_unit(picoseconds)
dt /= 0.04888821
self._dt = dt
boxFlag = 0
if topology.getUnitCellDimensions() is not None:
boxFlag = 1
if append:
file.seek(8, os.SEEK_SET)
self._modelCount = struct.unpack('<i', file.read(4))[0]
file.seek(268, os.SEEK_SET)
numAtoms = struct.unpack('<i', file.read(4))[0]
if numAtoms != len(list(topology.atoms())):
raise ValueError('Cannot append to a DCD file that contains a different number of atoms')
else:
header = struct.pack('<i4c9if', 84, b'C', b'O', b'R', b'D', 0, firstStep, interval, 0, 0, 0, 0, 0, 0, dt)
header += struct.pack('<13i', boxFlag, 0, 0, 0, 0, 0, 0, 0, 0, 24, 84, 164, 2)
header += struct.pack('<80s', b'Created by OpenMM')
header += struct.pack('<80s', b'Created '+time.asctime(time.localtime(time.time())).encode('ascii'))
header += struct.pack('<4i', 164, 4, len(list(topology.atoms())), 4)
file.write(header)
def getByMass(mass):
"""
Get the element whose mass is CLOSEST to the requested mass. This method
should not be used for repartitioned masses
Parameters
----------
mass : float or Quantity
Mass of the atom to find the element for. Units assumed to be
daltons if not specified
Returns
-------
element : Element
The element whose atomic mass is closest to the input mass
"""
# Assume masses are in daltons if they are not units
if is_quantity(mass):
mass = mass.value_in_unit(daltons)
if mass < 0:
raise ValueError('Invalid Higgs field')
# If this is our first time calling getByMass (or we added an element
# since the last call), re-generate the ordered by-mass dict cache
if Element._elements_by_mass is None:
Element._elements_by_mass = OrderedDict()
for elem in sorted(Element._elements_by_symbol.values(),
key=lambda x: x.mass):
Element._elements_by_mass[elem.mass.value_in_unit(daltons)] = elem
diff = mass
best_guess = None
for elemmass, element in _iteritems(Element._elements_by_mass):
massdiff = abs(elemmass - mass)
if massdiff < diff:
best_guess = element
diff = massdiff
if elemmass > mass:
# Elements are only getting heavier, so bail out early
return best_guess
# This really should only happen if we wanted ununoctium or something
# bigger... won't really happen but still make sure we return an Element
return best_guess
def _box_vectors_from_lengths_angles(a, b, c, alpha, beta, gamma):
"""
This method takes the lengths and angles from a unit cell and creates unit
cell vectors.
Parameters:
- a (unit, dimension length): Length of the first vector
- b (unit, dimension length): Length of the second vector
- c (unit, dimension length): Length of the third vector
- alpha (float): Angle between b and c in degrees
- beta (float): Angle between a and c in degrees
- gamma (float): Angle between a and b in degrees
Returns:
Tuple of box vectors (as Vec3 instances)
"""
if not (u.is_quantity(a) and u.is_quantity(b) and u.is_quantity(c)):
raise TypeError('a, b, and c must be units of dimension length')
if u.is_quantity(alpha): alpha = alpha.value_in_unit(u.degree)
if u.is_quantity(beta): beta = beta.value_in_unit(u.degree)
if u.is_quantity(gamma): gamma = gamma.value_in_unit(u.degree)
a = a.value_in_unit(u.angstrom)
b = b.value_in_unit(u.angstrom)
c = c.value_in_unit(u.angstrom)
if alpha <= 2 * pi and beta <= 2 * pi and gamma <= 2 * pi:
raise ValueError('box angles must be given in degrees')
alpha *= pi / 180
beta *= pi / 180
gamma *= pi / 180
av = Vec3(a, 0.0, 0.0) * u.angstrom
bx = b * cos(gamma)
by = b * sin(gamma)
bz = 0.0
cx = c * cos(beta)
cy = c * (cos(alpha) - cos(beta) * cos(gamma))
cz = sqrt(c * c - cx * cx - cy * cy)
# Make sure any components that are close to zero are set to zero exactly
if abs(bx) < TINY: bx = 0.0
if abs(by) < TINY: by = 0.0
if abs(cx) < TINY: cx = 0.0
if abs(cy) < TINY: cy = 0.0
if abs(cz) < TINY: cz = 0.0
bv = Vec3(bx, by, bz) * u.angstrom
cv = Vec3(cx, cy, cz) * u.angstrom
return (av, bv, cv)
def getByMass(mass):
"""
Get the element whose mass is CLOSEST to the requested mass. This method
should not be used for repartitioned masses
"""
# Assume masses are in daltons if they are not units
if not is_quantity(mass):
mass = mass * daltons
diff = mass
best_guess = None
for key in Element._elements_by_atomic_number:
element = Element._elements_by_atomic_number[key]
massdiff = abs(element.mass - mass)
if massdiff < diff:
best_guess = element
diff = massdiff
return best_guess
def testQuantityMaths(self):
""" Tests dimensional analysis & maths on and b/w Quantity objects """
x = 1.3 * u.meters
y = 75.2 * u.centimeters
self.assertEqual((x + y) / u.meters, 2.052)
self.assertEqual((x - y) / u.meters, 0.548)
self.assertEqual(x / y, 1.3 / 0.752)
self.assertEqual(x * y, 1.3*0.752*u.meters**2)
d1 = 2.0*u.meters
d2 = 2.0*u.nanometers
self.assertEqual(d1 + d2, (2+2e-9)*u.meters)
self.assertAlmostEqual((d2+d1-(2e9+2)*u.nanometers)._value, 0, places=6)
self.assertEqual(d1 + d1, 4.0*u.meters)
self.assertEqual(d1 - d1, 0.0*u.meters)
self.assertEqual(d1 / d1, 1.0)
self.assertEqual(d1 * u.meters, 2.0*u.meters**2)
self.assertEqual(u.kilograms*(d1/u.seconds)*(d1/u.seconds),
4*u.kilograms*u.meters**2/u.seconds**2)
self.assertEqual(u.kilograms*(d1/u.seconds)**2,
4*u.kilograms*u.meters**2/u.seconds**2)
self.assertEqual(d1**3, 8.0*u.meters**3)
x = d1**(3/2)
self.assertAlmostEqual(x._value, math.sqrt(2)**3)
self.assertEqual(x.unit, u.meters**(3/2))
self.assertAlmostEqual((d1**0.5)._value, math.sqrt(2))
self.assertEqual((d1**0.5).unit, u.meters**0.5)
comp = (3.0 + 4.0j) * u.meters
self.assertTrue(u.is_quantity(comp))
self.assertEqual(comp.unit, u.meters)
self.assertEqual(str(comp), '(3+4j) m')
self.assertEqual(comp + comp, (6.0 + 8.0j)*u.meters)
self.assertEqual(comp - comp, 0*u.meters)
self.assertEqual(comp * comp, (3.0 + 4.0j)**2 * u.meters**2)
self.assertAlmostEqual(comp / comp, 1)
self.assertAlmostEqual(1.5*u.nanometers / u.meters, 1.5e-9, places=15)
self.assertEqual((2.3*u.meters)**2, 2.3**2*u.meters**2)
x = 4.3 * u.meters
self.assertEqual(x / u.centimeters, 430)
self.assertEqual(str(x / u.seconds), '4.3 m/s')
self.assertEqual(str(8.4 / (4.2*u.centimeters)), '2.0 /cm')
x = 1.2 * u.meters
self.assertEqual(x * 5, u.Quantity(6.0, u.meters))
def writeModel(self, positions, unitCellDimensions=None):
"""Write out a model to the DCD file.
Parameters:
- positions (list) The list of atomic positions to write
- unitCellDimensions (Vec3=None) The dimensions of the crystallographic unit cell. If None, the dimensions specified in
the Topology will be used. Regardless of the value specified, no dimensions will be written if the Topology does not
represent a periodic system.
"""
if len(list(self._topology.atoms())) != len(positions):
raise ValueError('The number of positions must match the number of atoms')
if is_quantity(positions):
positions = positions.value_in_unit(nanometers)
if any(math.isnan(norm(pos)) for pos in positions):
raise ValueError('Particle position is NaN')
if any(math.isinf(norm(pos)) for pos in positions):
raise ValueError('Particle position is infinite')
file = self._file
# Update the header.
self._modelCount += 1
file.seek(8, os.SEEK_SET)
file.write(struct.pack('<i', self._modelCount))
file.seek(20, os.SEEK_SET)
file.write(struct.pack('<i', self._firstStep+self._modelCount*self._interval))
# Write the data.
file.seek(0, os.SEEK_END)
boxSize = self._topology.getUnitCellDimensions()
if boxSize is not None:
if unitCellDimensions is not None:
boxSize = unitCellDimensions
size = boxSize.value_in_unit(angstroms)
file.write(struct.pack('<i6di', 48, size[0], 0, size[1], 0, 0, size[2], 48))
length = struct.pack('<i', 4*len(positions))
for i in range(3):
file.write(length)
data = array.array('f', (10*x[i] for x in positions))
data.tofile(file)
file.write(length)
