def __init__(self, file, modifications=[]):
if isinstance(file, basestring):
file = TextFile(file)
title = file.readline()[:-1]
self.atom_types = DictWithDefault(None)
self._readAtomTypes(file)
format = FortranFormat('20(A2,2X)')
done = False
while not done:
l = FortranLine(file.readline()[:-1], format)
for entry in l:
name = _normalizeName(entry)
if len(name) == 0:
done = True
break
try: # ignore errors for now
self.atom_types[name].hydrophylic = True
except: pass
self.bonds = {}
self._readBondParameters(file)
self.bond_angles = {}
self._readAngleParameters(file)
self.dihedrals = {}
self.dihedrals_2 = {}
self._readDihedralParameters(file)
self.impropers = {}
self.impropers_1 = {}
self.impropers_2 = {}
self._readImproperParameters(file)
self.hbonds = {}
self._readHbondParameters(file)
self.lj_equivalent = {}
format = FortranFormat('20(A2,2X)')
while True:
l = FortranLine(file.readline()[:-1], format)
if l.isBlank(): break
name1 = _normalizeName(l[0])
for s in l[1:]:
name2 = _normalizeName(s)
self.lj_equivalent[name2] = name1
self.ljpar_sets = {}
while True:
l = FortranLine(file.readline()[:-1], 'A4,6X,A2')
if l[0] == 'END ': break
set_name = _normalizeName(l[0])
ljpar_set = AmberLJParameterSet(set_name, l[1])
self.ljpar_sets[set_name] = ljpar_set
self._readLJParameters(file, ljpar_set)
file.close()
for mod, ljname in modifications:
if isinstance(mod, basestring):
file = TextFile(mod)
else:
file = mod
title = file.readline()[:-1]
blank = file.readline()[:-1]
while True:
keyword = file.readline()
if not keyword: break
keyword = keyword.strip()[:4]
if keyword == 'MASS':
self._readAtomTypes(file)
elif keyword == 'BOND':
self._readBondParameters(file)
elif keyword == 'ANGL':
self._readAngleParameters(file)
elif keyword == 'DIHE':
self._readDihedralParameters(file)
elif keyword == 'IMPR':
self._readImproperParameters(file)
elif keyword == 'HBON':
self._readHbondParameters(file)
elif keyword == 'NONB':
self._readLJParameters(file, self.ljpar_sets[ljname])
def __init__(self, file, modifications=[]):
if isinstance(file, str):
file = TextFile(file)
title = file.readline()[:-1]
self.atom_types = DictWithDefault(None)
self._readAtomTypes(file)
format = FortranFormat('20(A2,2X)')
done = 0
while not done:
l = FortranLine(file.readline()[:-1], format)
for entry in l:
name = _normalizeName(entry)
if len(name) == 0:
done = 1
break
try: # ignore errors for now
self.atom_types[name].hydrophylic = 1
except:
pass
self.bonds = {}
self._readBondParameters(file)
self.bond_angles = {}
self._readAngleParameters(file)
self.dihedrals = {}
self.dihedrals_2 = {}
self._readDihedralParameters(file)
self.impropers = {}
self.impropers_1 = {}
self.impropers_2 = {}
self._readImproperParameters(file)
self.hbonds = {}
self._readHbondParameters(file)
self.lj_equivalent = {}
format = FortranFormat('20(A2,2X)')
while 1:
l = FortranLine(file.readline()[:-1], format)
if l.isBlank(): break
name1 = _normalizeName(l[0])
for s in l[1:]:
name2 = _normalizeName(s)
self.lj_equivalent[name2] = name1
self.ljpar_sets = {}
while 1:
l = FortranLine(file.readline()[:-1], 'A4,6X,A2')
if l[0] == 'END ': break
set_name = _normalizeName(l[0])
ljpar_set = AmberLJParameterSet(set_name, l[1])
self.ljpar_sets[set_name] = ljpar_set
self._readLJParameters(file, ljpar_set)
file.close()
for mod, ljname in modifications:
if isinstance(mod, str):
file = TextFile(mod)
else:
file = mod
title = file.readline()[:-1]
blank = file.readline()[:-1]
while 1:
keyword = file.readline()
if not keyword: break
keyword = string.strip(keyword)[:4]
if keyword == 'MASS':
self._readAtomTypes(file)
elif keyword == 'BOND':
self._readBondParameters(file)
elif keyword == 'ANGL':
self._readAngleParameters(file)
elif keyword == 'DIHE':
self._readDihedralParameters(file)
elif keyword == 'IMPR':
self._readImproperParameters(file)
elif keyword == 'HBON':
self._readHbondParameters(file)
elif keyword == 'NONB':
self._readLJParameters(file, self.ljpar_sets[ljname])
class PDBFile:
"""PDB file with access at the record level
Constructor: PDBFile(|filename|, |mode|='"r"'), where |filename|
is the file name and |mode| is '"r"' for reading and '"w"' for writing,
The low-level file access is handled by the module
Scientific.IO.TextFile, therefore compressed files and URLs
(for reading) can be used as well.
"""
def __init__(self, filename, mode='r', subformat=None):
self.file = TextFile(filename, mode)
self.output = string.lower(mode[0]) == 'w'
self.export_filter = None
if subformat is not None:
export = export_filters.get(subformat, None)
if export is not None:
self.export_filter = export()
self.open = 1
if self.output:
self.data = {
'serial_number': 0,
'residue_number': 0,
'chain_id': '',
'segment_id': ''
}
self.het_flag = 0
self.chain_number = -1
def readLine(self):
"""Returns the contents of the next non-blank line (= record).
The return value is a tuple whose first element (a string)
contains the record type. For supported record types (HEADER,
ATOM, HETATM, ANISOU, TERM, MODEL, CONECT), the items from the
remaining fields are put into a dictionary which is returned
as the second tuple element. Most dictionary elements are
strings or numbers; atom positions are returned as a vector,
and anisotropic temperature factors are returned as a rank-2
tensor, already multiplied by 1.e-4. White space is stripped
from all strings except for atom names, whose correct
interpretation can depend on an initial space. For unsupported
record types, the second tuple element is a string containing
the remaining part of the record.
"""
while 1:
line = self.file.readline()
if not line: return ('END', '')
if line[-1] == '\n': line = line[:-1]
line = string.strip(line)
if line: break
line = string.ljust(line, 80)
type = string.strip(line[:6])
if type == 'ATOM' or type == 'HETATM':
line = FortranLine(line, atom_format)
data = {
'serial_number': line[1],
'name': line[2],
'alternate': string.strip(line[3]),
'residue_name': string.strip(line[4]),
'chain_id': string.strip(line[5]),
'residue_number': line[6],
'insertion_code': string.strip(line[7]),
'position': Vector(line[8:11]),
'occupancy': line[11],
'temperature_factor': line[12],
'segment_id': string.strip(line[13]),
'element': string.strip(line[14]),
'charge': string.strip(line[15])
}
return type, data
elif type == 'ANISOU':
line = FortranLine(line, anisou_format)
data = {
'serial_number':
line[1],
'name':
line[2],
'alternate':
string.strip(line[3]),
'residue_name':
string.strip(line[4]),
'chain_id':
string.strip(line[5]),
'residue_number':
line[6],
'insertion_code':
string.strip(line[7]),
'u':
1.e-4 * Tensor([[line[8], line[11], line[12]],
[line[11], line[9], line[13]],
[line[12], line[13], line[10]]]),
'segment_id':
string.strip(line[14]),
'element':
string.strip(line[15]),
'charge':
string.strip(line[16])
}
return type, data
elif type == 'TER':
line = FortranLine(line, ter_format)
data = {
'serial_number': line[1],
'residue_name': string.strip(line[2]),
'chain_id': string.strip(line[3]),
'residue_number': line[4],
'insertion_code': string.strip(line[5])
}
return type, data
elif type == 'CONECT':
line = FortranLine(line, conect_format)
data = {
'serial_number': line[1],
'bonded': filter(lambda i: i > 0, line[2:6]),
'hydrogen_bonded': filter(lambda i: i > 0, line[6:10]),
'salt_bridged': filter(lambda i: i > 0, line[10:12])
}
return type, data
elif type == 'MODEL':
line = FortranLine(line, model_format)
data = {'serial_number': line[1]}
return type, data
elif type == 'HEADER':
line = FortranLine(line, header_format)
data = {'compound': line[1], 'date': line[2], 'pdb_code': line[3]}
return type, data
else:
return type, line[6:]
def writeLine(self, type, data):
"""Writes a line using record type and data dictionary in the
same format as returned by readLine(). Default values are
provided for non-essential information, so the data dictionary
need not contain all entries.
"""
if self.export_filter is not None:
type, data = self.export_filter.processLine(type, data)
if type is None:
return
line = [type]
if type == 'ATOM' or type == 'HETATM':
format = atom_format
position = data['position']
line = line + [
data.get('serial_number', 1),
data.get('name'),
data.get('alternate', ''),
string.rjust(data.get('residue_name', ''), 3),
data.get('chain_id', ''),
data.get('residue_number', 1),
data.get('insertion_code', ''), position[0], position[1],
position[2],
data.get('occupancy', 0.),
data.get('temperature_factor', 0.),
data.get('segment_id', ''),
string.rjust(data.get('element', ''), 2),
data.get('charge', '')
]
elif type == 'ANISOU':
format = anisou_format
u = 1.e4 * data['u']
u = [
int(u[0, 0]),
int(u[1, 1]),
int(u[2, 2]),
int(u[0, 1]),
int(u[0, 2]),
int(u[1, 2])
]
line = line + [data.get('serial_number', 1),
data.get('name'),
data.get('alternate', ''),
string.rjust(data.get('residue_name'), 3),
data.get('chain_id', ''),
data.get('residue_number', 1),
data.get('insertion_code', '')] \
+ u \
+ [data.get('segment_id', ''),
string.rjust(data.get('element', ''), 2),
data.get('charge', '')]
elif type == 'TER':
format = ter_format
line = line + [
data.get('serial_number', 1),
string.rjust(data.get('residue_name'), 3),
data.get('chain_id', ''),
data.get('residue_number', 1),
data.get('insertion_code', '')
]
elif type == 'CONECT':
format = conect_format
line = line + [data.get('serial_number')]
line = line + (data.get('bonded', []) + 4 * [None])[:4]
line = line + (data.get('hydrogen_bonded', []) + 4 * [None])[:4]
line = line + (data.get('salt_bridged', []) + 2 * [None])[:2]
elif type == 'MODEL':
format = model_format
line = line + [data.get('serial_number')]
elif type == 'HEADER':
format = header_format
line = line + [
data.get('compound', ''),
data.get('date', ''),
data.get('pdb_code')
]
else:
format = generic_format
line = line + [data]
self.file.write(str(FortranLine(line, format)) + '\n')
def writeComment(self, text):
"""Writes |text| into one or several comment lines.
Each line of the text is prefixed with 'REMARK' and written
to the file.
"""
while text:
eol = string.find(text, '\n')
if eol == -1:
eol = len(text)
self.file.write('REMARK %s \n' % text[:eol])
text = text[eol + 1:]
def writeAtom(self,
name,
position,
occupancy=0.0,
temperature_factor=0.0,
element=''):
"""Writes an ATOM or HETATM record using the |name|, |occupancy|,
|temperature| and |element| information supplied. The residue and
chain information is taken from the last calls to the methods
nextResidue() and nextChain().
"""
if self.het_flag:
type = 'HETATM'
else:
type = 'ATOM'
name = string.upper(name)
if element != '' and len(element) == 1 and name and name[0] == element:
name = ' ' + name
self.data['name'] = name
self.data['position'] = position
self.data['serial_number'] = (self.data['serial_number'] + 1) % 100000
self.data['occupancy'] = occupancy
self.data['temperature_factor'] = temperature_factor
self.data['element'] = element
self.writeLine(type, self.data)
def nextResidue(self, name, number=None, terminus=None):
"""Signals the beginning of a new residue, starting with the
next call to writeAtom(). The residue name is |name|, and a
|number| can be supplied optionally; by default residues in a
chain will be numbered sequentially starting from 1. The
value of |terminus| can be 'None', '"C"', or '"N"'; it is passed
to export filters that can use this information in order to
use different atom or residue names in terminal residues.
"""
name = string.upper(name)
if self.export_filter is not None:
name, number = self.export_filter.processResidue(
name, number, terminus)
self.het_flag = not (name in amino_acids or name in nucleic_acids)
self.data['residue_name'] = name
self.data['residue_number'] = (self.data['residue_number'] + 1) % 10000
self.data['insertion_code'] = ''
if number is not None:
if type(number) is type(0):
self.data['residue_number'] = number % 10000
else:
self.data['residue_number'] = number.number % 10000
self.data['insertion_code'] = number.insertion_code
def nextChain(self, chain_id=None, segment_id=''):
"""Signals the beginning of a new chain. A chain identifier
(string of length one) can be supplied as |chain_id|, by
default consecutive letters from the alphabet are used.
The equally optional |segment_id| defaults to an empty string.
"""
if chain_id is None:
self.chain_number = (self.chain_number + 1) % len(self._chain_ids)
chain_id = self._chain_ids[self.chain_number]
if self.export_filter is not None:
chain_id, segment_id = \
self.export_filter.processChain(chain_id, segment_id)
self.data['chain_id'] = (chain_id + ' ')[:1]
self.data['segment_id'] = (segment_id + ' ')[:4]
self.data['residue_number'] = 0
_chain_ids = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def terminateChain(self):
"Signals the end of a chain."
if self.export_filter is not None:
self.export_filter.terminateChain()
self.data['serial_number'] = (self.data['serial_number'] + 1) % 100000
self.writeLine('TER', self.data)
self.data['chain_id'] = ''
self.data['segment_id'] = ''
def close(self):
"""Closes the file. This method *must* be called for write mode
because otherwise the file will be incomplete.
"""
if self.open:
if self.output:
self.file.write('END\n')
self.file.close()
self.open = 0
def __del__(self):
self.close()
class PDBFile:
"""PDB file with access at the record level
Constructor: PDBFile(|filename|, |mode|='"r"'), where |filename|
is the file name and |mode| is '"r"' for reading and '"w"' for writing,
The low-level file access is handled by the module
Scientific.IO.TextFile, therefore compressed files and URLs
(for reading) can be used as well.
"""
def __init__(self, filename, mode = 'r', subformat = None):
self.file = TextFile(filename, mode)
self.output = string.lower(mode[0]) == 'w'
self.export_filter = None
if subformat is not None:
export = export_filters.get(subformat, None)
if export is not None:
self.export_filter = export()
self.open = 1
if self.output:
self.data = {'serial_number': 0,
'residue_number': 0,
'chain_id': '',
'segment_id': ''}
self.het_flag = 0
self.chain_number = -1
def readLine(self):
"""Returns the contents of the next non-blank line (= record).
The return value is a tuple whose first element (a string)
contains the record type. For supported record types (HEADER,
ATOM, HETATM, ANISOU, TERM, MODEL, CONECT), the items from the
remaining fields are put into a dictionary which is returned
as the second tuple element. Most dictionary elements are
strings or numbers; atom positions are returned as a vector,
and anisotropic temperature factors are returned as a rank-2
tensor, already multiplied by 1.e-4. White space is stripped
from all strings except for atom names, whose correct
interpretation can depend on an initial space. For unsupported
record types, the second tuple element is a string containing
the remaining part of the record.
"""
while 1:
line = self.file.readline()
if not line: return ('END','')
if line[-1] == '\n': line = line[:-1]
line = string.strip(line)
if line: break
line = string.ljust(line, 80)
type = string.strip(line[:6])
if type == 'ATOM' or type == 'HETATM':
line = FortranLine(line, atom_format)
data = {'serial_number': line[1],
'name': line[2],
'alternate': string.strip(line[3]),
'residue_name': string.strip(line[4]),
'chain_id': string.strip(line[5]),
'residue_number': line[6],
'insertion_code': string.strip(line[7]),
'position': Vector(line[8:11]),
'occupancy': line[11],
'temperature_factor': line[12],
'segment_id': string.strip(line[13]),
'element': string.strip(line[14]),
'charge': string.strip(line[15])}
return type, data
elif type == 'ANISOU':
line = FortranLine(line, anisou_format)
data = {'serial_number': line[1],
'name': line[2],
'alternate': string.strip(line[3]),
'residue_name': string.strip(line[4]),
'chain_id': string.strip(line[5]),
'residue_number': line[6],
'insertion_code': string.strip(line[7]),
'u': 1.e-4*Tensor([[line[8], line[11], line[12]],
[line[11], line[9] , line[13]],
[line[12], line[13], line[10]]]),
'segment_id': string.strip(line[14]),
'element': string.strip(line[15]),
'charge': string.strip(line[16])}
return type, data
elif type == 'TER':
line = FortranLine(line, ter_format)
data = {'serial_number': line[1],
'residue_name': string.strip(line[2]),
'chain_id': string.strip(line[3]),
'residue_number': line[4],
'insertion_code': string.strip(line[5])}
return type, data
elif type == 'CONECT':
line = FortranLine(line, conect_format)
data = {'serial_number': line[1],
'bonded': filter(lambda i: i > 0, line[2:6]),
'hydrogen_bonded': filter(lambda i: i > 0, line[6:10]),
'salt_bridged': filter(lambda i: i > 0, line[10:12])}
return type, data
elif type == 'MODEL':
line = FortranLine(line, model_format)
data = {'serial_number': line[1]}
return type, data
elif type == 'HEADER':
line = FortranLine(line, header_format)
data = {'compound': line[1],
'date': line[2],
'pdb_code': line[3]}
return type, data
else:
return type, line[6:]
def writeLine(self, type, data):
"""Writes a line using record type and data dictionary in the
same format as returned by readLine(). Default values are
provided for non-essential information, so the data dictionary
need not contain all entries.
"""
if self.export_filter is not None:
type, data = self.export_filter.processLine(type, data)
if type is None:
return
line = [type]
if type == 'ATOM' or type == 'HETATM':
format = atom_format
position = data['position']
line = line + [data.get('serial_number', 1),
data.get('name'),
data.get('alternate', ''),
string.rjust(data.get('residue_name', ''), 3),
data.get('chain_id', ''),
data.get('residue_number', 1),
data.get('insertion_code', ''),
position[0], position[1], position[2],
data.get('occupancy', 0.),
data.get('temperature_factor', 0.),
data.get('segment_id', ''),
string.rjust(data.get('element', ''), 2),
data.get('charge', '')]
elif type == 'ANISOU':
format = anisou_format
u = 1.e4*data['u']
u = [int(u[0,0]), int(u[1,1]), int(u[2,2]),
int(u[0,1]), int(u[0,2]), int(u[1,2])]
line = line + [data.get('serial_number', 1),
data.get('name'),
data.get('alternate', ''),
string.rjust(data.get('residue_name'), 3),
data.get('chain_id', ''),
data.get('residue_number', 1),
data.get('insertion_code', '')] \
+ u \
+ [data.get('segment_id', ''),
string.rjust(data.get('element', ''), 2),
data.get('charge', '')]
elif type == 'TER':
format = ter_format
line = line + [data.get('serial_number', 1),
string.rjust(data.get('residue_name'), 3),
data.get('chain_id', ''),
data.get('residue_number', 1),
data.get('insertion_code', '')]
elif type == 'CONECT':
format = conect_format
line = line + [data.get('serial_number')]
line = line + (data.get('bonded', [])+4*[None])[:4]
line = line + (data.get('hydrogen_bonded', [])+4*[None])[:4]
line = line + (data.get('salt_bridged', [])+2*[None])[:2]
elif type == 'MODEL':
format = model_format
line = line + [data.get('serial_number')]
elif type == 'HEADER':
format = header_format
line = line + [data.get('compound', ''), data.get('date', ''),
data.get('pdb_code')]
else:
format = generic_format
line = line + [data]
self.file.write(str(FortranLine(line, format)) + '\n')
def writeComment(self, text):
"""Writes |text| into one or several comment lines.
Each line of the text is prefixed with 'REMARK' and written
to the file.
"""
while text:
eol = string.find(text,'\n')
if eol == -1:
eol = len(text)
self.file.write('REMARK %s \n' % text[:eol])
text = text[eol+1:]
def writeAtom(self, name, position, occupancy=0.0, temperature_factor=0.0,
element=''):
"""Writes an ATOM or HETATM record using the |name|, |occupancy|,
|temperature| and |element| information supplied. The residue and
chain information is taken from the last calls to the methods
nextResidue() and nextChain().
"""
if self.het_flag:
type = 'HETATM'
else:
type = 'ATOM'
name = string.upper(name)
if element != '' and len(element) == 1 and name and name[0] == element:
name = ' ' + name
self.data['name'] = name
self.data['position'] = position
self.data['serial_number'] = (self.data['serial_number'] + 1) % 100000
self.data['occupancy'] = occupancy
self.data['temperature_factor'] = temperature_factor
self.data['element'] = element
self.writeLine(type, self.data)
def nextResidue(self, name, number = None, terminus = None):
"""Signals the beginning of a new residue, starting with the
next call to writeAtom(). The residue name is |name|, and a
|number| can be supplied optionally; by default residues in a
chain will be numbered sequentially starting from 1. The
value of |terminus| can be 'None', '"C"', or '"N"'; it is passed
to export filters that can use this information in order to
use different atom or residue names in terminal residues.
"""
name = string.upper(name)
if self.export_filter is not None:
name, number = self.export_filter.processResidue(name, number,
terminus)
self.het_flag = not (name in amino_acids or name in nucleic_acids)
self.data['residue_name'] = name
self.data['residue_number'] = (self.data['residue_number'] + 1) % 10000
self.data['insertion_code'] = ''
if number is not None:
if type(number) is type(0):
self.data['residue_number'] = number % 10000
else:
self.data['residue_number'] = number.number % 10000
self.data['insertion_code'] = number.insertion_code
def nextChain(self, chain_id = None, segment_id = ''):
"""Signals the beginning of a new chain. A chain identifier
(string of length one) can be supplied as |chain_id|, by
default consecutive letters from the alphabet are used.
The equally optional |segment_id| defaults to an empty string.
"""
if chain_id is None:
self.chain_number = (self.chain_number + 1) % len(self._chain_ids)
chain_id = self._chain_ids[self.chain_number]
if self.export_filter is not None:
chain_id, segment_id = \
self.export_filter.processChain(chain_id, segment_id)
self.data['chain_id'] = (chain_id+' ')[:1]
self.data['segment_id'] = (segment_id+' ')[:4]
self.data['residue_number'] = 0
_chain_ids = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def terminateChain(self):
"Signals the end of a chain."
if self.export_filter is not None:
self.export_filter.terminateChain()
self.data['serial_number'] = (self.data['serial_number'] + 1) % 100000
self.writeLine('TER', self.data)
self.data['chain_id'] = ''
self.data['segment_id'] = ''
def close(self):
"""Closes the file. This method *must* be called for write mode
because otherwise the file will be incomplete.
"""
if self.open:
if self.output:
self.file.write('END\n')
self.file.close()
self.open = 0
def __del__(self):
self.close()
Oxy = out_dict["O"]
print "Read in atom positions. There are %d H atoms and %s O atoms." % (len(Hyd), len(Oxy))
###############################################################################
# Read in the Cage Centre locations
###############################################################################
large_cages = []
small_cages = []
# Open input file
xyz_file = TextFile(xyz_cageFilename)
# Ignore first two lines of the file
junk = xyz_file.readline()
junk = xyz_file.readline()
while 1:
line = xyz_file.readline()
if not line:
break
x, y, z = map(float, string.split(line)[1:]) # ignore atom label
cage_type = string.split(line)[0] # get the atom type
# Convert coordinates based on atom type
if cage_type == "Ar(Small)":
# Convert coordinates to vectors for the Small Cages
"""argon.py"""
# Constant-temperature constant-pressure MD simulation of Argon
from MMTK import *
from MMTK.ForceFields import LennardJonesForceField
from MMTK.Environment import NoseThermostat, AndersenBarostat
from MMTK.Trajectory import Trajectory, TrajectoryOutput, LogOutput
from MMTK.Dynamics import VelocityVerletIntegrator, Velocity Scaler, \
TranslationRemover, BarostatReset
import string
from Scientific.IO.TextFile import TextFile
# Open the config file and read box size
conf_file = TextFile('argon.conf.gz')
lx, ly, lz = map(string.atof, string.split(conf_file.readline()))
# Construct periodic universe using Lennard-Jones (noble gas) force field
# with cutoff of 15 Angstroms
universe = OrthorhombicPeriodicUniverse((lx*Units.Ang, ly*Units.Ang, lz*Units.Ang),
LennardJonesForceField(15.*Units.Ang))
# Read the atom positions and construct the atoms
while 1:
line = conf_file.readline()
if not line:
break
x, y, z, = map(string.atof, string.split(line))
universe.addObject(Atom('Ar', position=Vector(x*Units.Ang, y*Units.Ang, z*Units.Ang)))
# Define thermodynamic parameters
# Constant-temperature constant-pressure MD simulation of Argon.
#
from MMTK import *
from MMTK.ForceFields import LennardJonesForceField
from MMTK.Environment import NoseThermostat, AndersenBarostat
from MMTK.Trajectory import Trajectory, TrajectoryOutput, LogOutput
from MMTK.Dynamics import VelocityVerletIntegrator, VelocityScaler, \
TranslationRemover, BarostatReset
import string
from Scientific.IO.TextFile import TextFile
# Open the configuration file and read the box size.
conf_file = TextFile('argon.conf.gz')
lx, ly, lz = map(string.atof, string.split(conf_file.readline()))
# Construct a periodic universe using a Lennard-Jones (noble gas) force field
# with a cutoff of 15 Angstrom.
universe = OrthorhombicPeriodicUniverse(
(lx * Units.Ang, ly * Units.Ang, lz * Units.Ang),
LennardJonesForceField(15. * Units.Ang))
# Read the atom positions and construct the atoms.
while 1:
line = conf_file.readline()
if not line: break
x, y, z = map(string.atof, string.split(line))
universe.addObject(
Atom('Ar',
position=Vector(x * Units.Ang, y * Units.Ang, z * Units.Ang)))
# Define thermodynamic parameters.
Oxy = out_dict["O"]
print "Read in atom positions. There are %d H atoms and %s O atoms." % (len(Hyd), len(Oxy))
###############################################################################
#Read in the Cage Centre locations
###############################################################################
large_cages = []
small_cages = []
#Open input file
xyz_file = TextFile(xyz_cageFilename)
#Ignore first two lines of the file
junk = xyz_file.readline()
junk = xyz_file.readline()
while 1:
line = xyz_file.readline()
if not line: break
x, y, z = map(float, string.split(line)[1:]) #ignore atom label
cage_type = string.split(line)[0] #get the atom type
#Convert coordinates based on atom type
if (cage_type == "Ar(Small)"):
#Convert coordinates to vectors for the Small Cages
small_cages.append(Geo.Vector(x,y,z))
