def __init__(self, numbers, coordinates, masses, energy, gradient, hessian, multiplicity=None, symmetry_number=None, periodic=False, title=None, graph=None, symbols=None, unit_cell=None):
"""
Arguments:
| ``numbers`` -- The atom numbers (integer numpy array with shape N)
| ``coordinates`` -- the atom coordinates in Bohr (float numpy array
with shape Nx3)
| ``masses`` -- The atomic masses in atomic units (float numpy array
with shape N)
| ``energy`` -- The molecular energy in Hartree
| ``gradient`` -- The gradient of the energy, i.e. the derivatives
towards Cartesian coordinates, in atomic units
(float numpy array with shape Nx3)
| ``hessian`` -- The hessian of the energy, i.e. the matrix with
second order derivatives towards Cartesian
coordinates, in atomic units (float numpy array
with shape 3Nx3N)
| ``multiplicity`` -- The spin multiplicity of the electronic system
Optional arguments:
| ``symmetry_number`` -- The rotational symmetry number, None when
not known or computed [default=None]
| ``periodic`` -- True when the system is periodic in three
dimensions [default=False]
| ``title`` -- The title of the system
| ``graph`` -- The molecular graph of the system
| ``symbols`` -- A list with atom symbols
| ``unit_cell`` -- The unit cell vectors for periodic structures
"""
BaseMolecule.__init__(self, numbers, coordinates, title, masses, graph, symbols, unit_cell)
self.energy = energy
self.gradient = gradient
self.hessian = hessian
self.multiplicity = multiplicity
self.symmetry_number = symmetry_number
self.periodic = periodic
def __init__(self,
numbers,
coordinates,
masses,
energy,
gradient,
hessian,
multiplicity=None,
symmetry_number=None,
periodic=False,
title=None,
graph=None,
symbols=None,
unit_cell=None,
fixed=None):
"""
Arguments:
| ``numbers`` -- The atom numbers (integer numpy array with shape N)
| ``coordinates`` -- the atom coordinates in Bohr (float numpy array
with shape Nx3)
| ``masses`` -- The atomic masses in atomic units (float numpy array
with shape N)
| ``energy`` -- The molecular energy in Hartree
| ``gradient`` -- The gradient of the energy, i.e. the derivatives
towards Cartesian coordinates, in atomic units
(float numpy array with shape Nx3)
| ``hessian`` -- The hessian of the energy, i.e. the matrix with
second order derivatives towards Cartesian
coordinates, in atomic units (float numpy array
with shape 3Nx3N)
| ``multiplicity`` -- The spin multiplicity of the electronic system
Optional arguments:
| ``symmetry_number`` -- The rotational symmetry number, None when
not known or computed [default=None]
| ``periodic`` -- True when the system is periodic in three
dimensions [default=False]
| ``title`` -- The title of the system
| ``graph`` -- The molecular graph of the system
| ``symbols`` -- A list with atom symbols
| ``unit_cell`` -- The unit cell vectors for periodic structures
| ``fixed`` -- An array with indices of fixed atoms
"""
BaseMolecule.__init__(self, numbers, coordinates, title, masses, graph,
symbols, unit_cell)
self.energy = energy
self.gradient = gradient
self.hessian = hessian
self.multiplicity = multiplicity
self.symmetry_number = symmetry_number
self.periodic = periodic
self.fixed = fixed
def create_molecule(selected_nodes, parent=None):
numbers = []
coordinates = []
atoms = list(iter_atoms(selected_nodes))
for atom in atoms:
numbers.append(atom.number)
if parent is None:
coordinates.append(atom.get_absolute_frame().t)
else:
coordinates.append(atom.get_frame_relative_to(parent).t)
result = Molecule(numbers, coordinates)
result.atoms = atoms
return result
def create_molecule(selected_nodes, parent=None):
numbers = []
coordinates = []
atoms = list(iter_atoms(selected_nodes))
for atom in atoms:
numbers.append(atom.number)
if parent is None:
coordinates.append(atom.get_absolute_frame().t)
else:
coordinates.append(atom.get_frame_relative_to(parent).t)
result = Molecule(numbers, coordinates)
result.atoms = atoms
return result
def collect_molecules(self, parent, universe=None):
Atom = context.application.plugins.get_node("Atom")
Bond = context.application.plugins.get_node("Bond")
Frame = context.application.plugins.get_node("Frame")
if universe==None:
universe = parent
atom_to_index = {}
atoms_extra = {}
counter = 0
numbers = []
coordinates = []
for child in parent.children:
if isinstance(child, Atom):
atom_to_index[child] = counter
if len(child.extra) > 0:
atoms_extra[counter] = child.extra
counter += 1
numbers.append(child.number)
coordinates.append(child.get_frame_relative_to(universe).t)
if len(numbers) > 0:
molecule = Molecule(numbers, coordinates, parent.name)
molecule.extra = parent.extra
molecule.atoms_extra = atoms_extra
molecule.bonds_extra = {}
pairs = set([])
for child in parent.children:
if isinstance(child, Bond):
atoms = child.get_targets()
pair = frozenset([atom_to_index[atoms[0]], atom_to_index[atoms[1]]])
if len(child.extra) > 0:
molecule.bonds_extra[pair] = child.extra
pairs.add(pair)
if len(pairs) > 0:
molecule.graph = MolecularGraph(pairs, molecule.numbers)
else:
molecule.graph = None
result = [molecule]
else:
result = []
for child in parent.children:
if isinstance(child, Frame):
result.extend(self.collect_molecules(child, universe))
return result
def get_mol(self, state, root):
if self.name == "opt":
# load the initial geometry
mol = Molecule.from_file("init/%s.xyz" % state.name)
else:
# load the optimized geometry
fn_fchk = "%s/%s__opt/gaussian.fchk" % (root, state.name)
mol = FCHKFile(fn_fchk, field_labels=[]).molecule
with open("init/%s.fragments" % state.name) as f:
mol.charge_mult = f.readline().split()
mol.tags = f.readline().split()
return mol
def collect_molecules(self, parent, universe=None):
Atom = context.application.plugins.get_node("Atom")
Bond = context.application.plugins.get_node("Bond")
Frame = context.application.plugins.get_node("Frame")
if universe == None:
universe = parent
atom_to_index = {}
atoms_extra = {}
counter = 0
numbers = []
coordinates = []
for child in parent.children:
if isinstance(child, Atom):
atom_to_index[child] = counter
if len(child.extra) > 0:
atoms_extra[counter] = child.extra
counter += 1
numbers.append(child.number)
coordinates.append(child.get_frame_relative_to(universe).t)
if len(numbers) > 0:
molecule = Molecule(numbers, coordinates, parent.name)
molecule.extra = parent.extra
molecule.atoms_extra = atoms_extra
molecule.bonds_extra = {}
pairs = set([])
for child in parent.children:
if isinstance(child, Bond):
atoms = child.get_targets()
pair = frozenset([atom_to_index[atoms[0]], atom_to_index[atoms[1]]])
if len(child.extra) > 0:
molecule.bonds_extra[pair] = child.extra
pairs.add(pair)
if len(pairs) > 0:
molecule.graph = MolecularGraph(pairs, molecule.numbers)
else:
molecule.graph = None
result = [molecule]
else:
result = []
for child in parent.children:
if isinstance(child, Frame):
result.extend(self.collect_molecules(child, universe))
return result
def test_opbend_ethene():
mol = Molecule.from_file("input/ethene.xyz")
c = mol.coordinates.copy()
assert abs(ic.opbend_cos([c[0], c[5], c[4], c[3]])[0] - 1.0) < 1e-5
assert abs(ic.opbend_angle([c[0], c[5], c[4], c[3]])[0]) < 1e-5
for i in xrange(1000):
angle = np.random.uniform(-np.pi/2, np.pi/2)
radius = np.random.uniform(0, 5*angstrom)
#offset = np.random.uniform(0, 5*angstrom)
c[3] = [
radius*np.cos(angle),
0.0,
radius*np.sin(angle),
]
assert abs(ic.opbend_cos([c[0], c[5], c[4], c[3]])[0] - np.cos(angle)) < 1e-5
assert abs(ic.opbend_angle([c[0], c[5], c[4], c[3]])[0] - angle) < 1e-5
def test_dihedral_ethene():
mol = Molecule.from_file("input/ethene.xyz")
c = mol.coordinates.copy()
assert abs(ic.dihed_cos([c[2], c[0], c[3], c[5]])[0] - 1.0) < 1e-5
assert abs(ic.dihed_angle([c[2], c[0], c[3], c[5]])[0]) < 1e-5
for i in xrange(1000):
angle = np.random.uniform(-np.pi, np.pi)
radius = np.random.uniform(0, 5*angstrom)
offset = np.random.uniform(0, 5*angstrom)
c[5] = [
offset,
-radius*np.cos(angle),
-radius*np.sin(angle),
]
assert abs(ic.dihed_cos([c[2], c[0], c[3], c[5]])[0] - np.cos(angle)) < 1e-5
assert abs(ic.dihed_angle([c[2], c[0], c[3], c[5]])[0] - angle) < 1e-5
def load_xyz(fn_xyz, temp, masses=None):
"""Create a system and state from a simple XYZ file and a temperature.
Arguments:
| ``fn_xyz`` -- The filename of the XYZ file.
| ``temp`` -- The temperature for the initial velocities.
Optional argument:
| ``masses`` -- An array with masses to override the IUPAC 2005
values from the MolMod package.
"""
molecule = Molecule.from_file(fn_xyz)
if masses is None:
molecule.set_default_masses()
else:
molecule.masses = masses
vel = numpy.zeros(molecule.coordinates.shape, float)
system = System(molecule.symbols, molecule.masses, molecule.numbers)
state = State(molecule.coordinates, vel)
set_boltzmann_velocities(temp, system, state)
return system, state
def __init__(self, filename):
"""
Arguments:
| ``filename`` -- The file to load.
"""
self.filename = filename
# auxiliary skip function
def skip_to(f, linestart):
while True:
line = f.readline()
if line.startswith(linestart):
return line
if len(line) == 0:
return
with open(filename) as f:
# Unit cell parameters
line = skip_to(f, ' DIRECT LATTICE VECTOR COMPONENTS (BOHR)')
if line is None:
raise FileFormatError('Could not find the lattice vectors')
f.readline()
f.readline()
vectors = []
for i in range(3):
line = f.readline()
vectors.append([float(word) for word in line.split()[1:]])
vectors = np.array(vectors)
self.unit_cell = UnitCell(vectors.transpose())
# Atomic numbers and coordinates
line = skip_to(f, ' ATOM CARTESIAN COORDINATES (BOHR)')
if line is None:
raise FileFormatError('Could not find the atomic coordinates')
f.readline()
f.readline()
f.readline()
numbers = []
symbols = []
coordinates = []
while True:
line = f.readline()
if line.startswith(' *****'):
break
words = line.split()
numbers.append(int(words[1]))
symbols.append(words[2])
coordinates.append(
[float(words[3]),
float(words[4]),
float(words[5])])
self.mol = Molecule(np.array(numbers),
np.array(coordinates),
symbols=symbols,
unit_cell=self.unit_cell)
# Basis set specification
line = skip_to(f, ' VARIATIONAL BASIS SET')
if line is None:
raise FileFormatError('Could not find the basis set')
f.readline()
f.readline()
f.readline()
f.readline()
f.readline()
f.readline()
self.basisset = {}
last_basis = None
last_contraction = None
while True:
line = f.readline()
if line.startswith(' *****'):
break
if line.startswith(' '):
# add info to the last atomic basis set
assert last_basis is not None
subshell = line[36:40].strip()
if len(subshell) == 0:
subshell = last_contraction[0]
# add a primitive to the contraction
exponent = float(line[40:50])
if subshell == 'S':
values = exponent, float(line[50:60])
elif subshell == 'SP':
values = exponent, float(line[50:60]), float(
line[60:70])
else:
values = exponent, float(line[70:80])
last_contraction[1].append(values)
else:
# define a new contraction
last_contraction = (subshell, [])
last_basis.append(last_contraction)
else:
# add new atoms
symbol = line.split()[1]
if symbol not in self.basisset:
last_basis = []
self.basisset[symbol] = last_basis
# Compute the total number of basis functions (and orbitals).
self.num_basis = 0
subshell_counts = {'S': 1, 'P': 3, 'SP': 4, 'D': 5, 'F': 7, 'G': 9}
for symbol, basis in self.basisset.items():
symbol_count = symbols.count(symbol)
for subshell, contraction in basis:
self.num_basis += symbol_count * subshell_counts[subshell]
# Density matrix.
line = skip_to(f, ' DENSITY MATRIX DIRECT LATTICE')
if line is None:
raise FileFormatError('Could not find the density matrix')
f.readline()
f.readline()
f.readline()
self.density_matrix = np.zeros((self.num_basis, self.num_basis),
float)
j0 = 0
while j0 < self.num_basis:
f.readline()
f.readline()
f.readline()
for i in range(self.num_basis):
line = f.readline()
words = line.split()[1:]
for j1, word in enumerate(words):
self.density_matrix[i, j0 + j1] = float(word)
j0 += 10
def from_file(cls, *fns, **user_kwargs):
"""Construct a new System instance from one or more files
**Arguments:**
fn1, fn2, ...
A list of filenames that are read in order. Information in later
files overrides information in earlier files.
**Optional arguments:**
Any argument from the default constructor ``__init__``. These must be
given with keywords.
**Supported file formats**
.xyz
Standard Cartesian coordinates file (in angstroms). Atomic
positions and atomic numbers are read from this file. If the
title consists of 3, 6 or 9 numbers, each group of three numbers
is interpreted as a cell vector (in angstroms). A guess of the
bonds will be made based on inter-atomic distances.
.psf
Atom types and bonds are read from this file
.chk
Internal text-based checkpoint format. It just contains a
dictionary with the constructor arguments.
"""
with log.section('SYS'):
kwargs = {}
for fn in fns:
if fn.endswith('.xyz'):
from molmod import Molecule
mol = Molecule.from_file(fn)
kwargs['numbers'] = mol.numbers.copy()
kwargs['pos'] = mol.coordinates.copy()
elif fn.endswith('.psf'):
from molmod.io import PSFFile
psf = PSFFile(fn)
kwargs['ffatypes'] = psf.atom_types
kwargs['bonds'] = np.array(psf.bonds, copy=False)
kwargs['charges'] = np.array(psf.charges, copy=False)
elif fn.endswith('.chk'):
from molmod.io import load_chk
allowed_keys = [
'numbers', 'pos', 'scopes', 'scope_ids', 'ffatypes',
'ffatype_ids', 'bonds', 'rvecs', 'charges', 'radii',
'dipoles','radii2','masses',
]
for key, value in load_chk(fn).iteritems():
if key in allowed_keys:
kwargs.update({key: value})
elif fn.endswith('.h5'):
with h5.File(fn, 'r') as f:
return cls.from_hdf5(f)
else:
raise IOError('Can not read from file \'%s\'.' % fn)
if log.do_high:
log('Read system parameters from %s.' % fn)
kwargs.update(user_kwargs)
return cls(**kwargs)
def run_GCMC(self, N_iterations, N_sample):
A = Acceptance()
if rank == 0:
if not (os.path.isdir('results')):
try:
os.mkdir('results')
except:pass
if self.write_traj:
ftraj = open('results/traj_%.8f.xyz'%(self.P/bar), 'w')
e = 0
t_it = time()
N_samples = []
E_samples = []
pressures = []
traj = []
q0s = []
if rank == 0:
print('\n Iteration inst. N inst. E inst. V time [s]')
print('--------------------------------------------------------')
for iteration in range(N_iterations+1):
if self.ads_ei:
sfac_init = deepcopy(self.sfac)
pos_init = deepcopy(self.pos)
rvecs_init = deepcopy(self.rvecs)
rvecs_flat_init = deepcopy(self.rvecs_flat)
V_init = self.V
e_el_real_init = self.e_el_real
e_vdw_init = self.e_vdw
switch = np.random.rand()
acc = 0
# Insertion / deletion
if(switch < self.prob[0] and not self.Z_ads == self.fixed_N):
if(switch < self.prob[0]/2):
new_pos = random_ads(self.pos_ads, self.rvecs)
e_new = self.insertion(new_pos)
exp_value = self.beta * (-e_new + e)
if(exp_value > 100):
acc = 1
elif(exp_value < -100):
acc = 0
else:
acc = min(1, self.V*self.beta*self.fugacity/self.Z_ads * np.exp(exp_value))
# Reject monte carlo move
if np.random.rand() > acc:
self.pos = pos_init
if self.ads_ei:
self.sfac = sfac_init
self.e_el_real = e_el_real_init
self.e_vdw = e_vdw_init
self.Z_ads -= 1
else:
e = e_new
elif(self.Z_ads > 0):
deleted_coord, e_new = self.deletion()
exp_value = -self.beta * (e_new - e)
if(exp_value > 100):
acc = 1
else:
acc = min(1, (self.Z_ads+1)/self.V/self.beta/self.fugacity * np.exp(exp_value))
# Reject monte carlo move
if np.random.rand() > acc:
self.pos = pos_init
if self.ads_ei:
self.sfac = sfac_init
self.e_el_real = e_el_real_init
self.e_vdw = e_vdw_init
self.Z_ads += 1
else:
e = e_new
elif(switch < self.prob[1]):
if self.Z_ads != 0:
trial = np.random.randint(self.Z_ads)
if((switch < self.prob[0] + (self.prob[1]-self.prob[0])/2) or self.nads == 1):
# Calculate translation energy as deletion + insertion of molecule
deleted_coord, e_new = self.deletion()
deleted_coord += self.step * (np.random.rand(3) - 0.5)
e_new = self.insertion(deleted_coord)
else:
# Calculate rotation energy as deletion + insertion of molecule
deleted_coord, e_new = self.deletion()
deleted_coord = random_rot(deleted_coord, circlefrac=0.1)
e_new = self.insertion(deleted_coord)
exp_value = -self.beta * (e_new - e)
if(exp_value > 0):
exp_value = 0
acc = min(1, np.exp(exp_value))
# Reject monte carlo move
if np.random.rand() > acc:
self.pos = pos_init
if self.ads_ei:
self.sfac = sfac_init
self.e_el_real = e_el_real_init
self.e_vdw = e_vdw_init
else:
e = e_new
else:
# Construct system and forcefield class for the MD engine
from yaff import System, ForceField, XYZWriter, VerletScreenLog, MTKBarostat, \
NHCThermostat, TBCombination, VerletIntegrator, HDF5Writer, log
log.set_level(0)
n = np.append(self.data.numbers_MOF, np.tile(self.data.numbers_ads, self.Z_ads))
ffa_MOF = self.data.system.ffatypes[self.data.system.ffatype_ids]
ffa_ads = self.data.system_ads.ffatypes[self.data.system_ads.ffatype_ids]
ffa = np.append(ffa_MOF, np.tile(ffa_ads, self.Z_ads))
assert len(self.pos) == len(ffa)
s = System(n, self.pos, ffatypes = ffa, rvecs=self.rvecs)
s.detect_bonds()
ff = ForceField.generate(s, self.ff_file,
rcut=self.rcut,
alpha_scale=self.alpha_scale,
gcut_scale=self.gcut_scale,
tailcorrections=True)
ff_lammps = swap_noncovalent_lammps(ff, fn_system='system_%.8f.dat'%(self.P/bar),
fn_table='table.dat',
nrows=5000,
kspace='pppm',
kspace_accuracy=1e-7,
scalings_ei = [1.0, 1.0, 1.0],
move_central_cell=False,
fn_log="none",
overwrite_table=False, comm=comm)
# Setup and NPT MD run
if rank == 0:
vsl = VerletScreenLog(step=50)
if self.write_h5s:
if self.fixed_N:
hdf5_writer = HDF5Writer(h5.File('results/temp_%d.h5'%self.fixed_N, mode='w'), step=101)
else:
hdf5_writer = HDF5Writer(h5.File('results/temp_%.8f.h5'%(self.P/bar), mode='w'), step=101)
ensemble_hook = NHCThermostat(temp=self.T, timecon=100*femtosecond, chainlength=3)
if self.barostat:
mtk = MTKBarostat(ff_lammps, temp=self.T, press=self.P, \
timecon=1000*femtosecond, vol_constraint = self.vol_constraint, anisotropic = True)
ensemble_hook = TBCombination(ensemble_hook, mtk)
if self.meta:
cv = CVVolume(ff_lammps.system)
sigma = 1000*angstrom**3
K = 20*kjmol
step = 498
# Run MD
t = time()
if self.write_h5s:
if rank == 0:
verlet = VerletIntegrator(ff_lammps, self.timestep, hooks=[ensemble_hook, vsl, hdf5_writer], temp0=self.T)
else:
verlet = VerletIntegrator(ff_lammps, self.timestep, hooks=[ensemble_hook], temp0=self.T)
else:
if rank == 0:
hooks = [ensemble_hook, vsl]
if self.meta:
meta = MTDHook(ff_lammps, cv, sigma, K, start=step, step=step)
for q0 in q0s:
meta.hills.add_hill(q0, K)
hooks.append(meta)
verlet = VerletIntegrator(ff_lammps, self.timestep, hooks=hooks, temp0=self.T)
else:
hooks = [ensemble_hook]
if self.meta:
meta = MTDHook(ff_lammps, cv, sigma, K, start=step, step=step)
for q0 in q0s:
meta.hills.add_hill(q0, K)
hooks.append(meta)
verlet = VerletIntegrator(ff_lammps, self.timestep, hooks=hooks, temp0=self.T)
e0_tot = verlet._compute_ekin() + ff_lammps.compute()
verlet.run(600)
ef_tot = verlet._compute_ekin() + ff_lammps.compute()
if not self.vol_constraint:
Vn = np.linalg.det(ff_lammps.system.cell.rvecs)
exp_value = -self.beta * (ef_tot - e0_tot + self.P * (Vn - self.V) - len(self.pos)/self.beta * np.log(Vn/self.V))
else:
exp_value = -self.beta * (ef_tot - e0_tot)
if(exp_value > 0):
exp_value = 0
acc = min(1, np.exp(exp_value))
# Accept monte carlo move
if np.random.rand() < acc:
if self.write_h5s:
# Append MD data to previous data
self.append_h5()
# Rebuild data for MC
pos_total = ff_lammps.system.pos
self.pos = pos_total[:self.N_frame]
pos_molecules = pos_total[self.N_frame:]
self.rvecs = ff_lammps.system.cell.rvecs
self.rvecs_flat = self.rvecs.reshape(9)
self.V = np.linalg.det(self.rvecs)
if self.meta:
q0s.append(self.V)
if self.ads_ei:
self.sfac = Sfac(self.pos, self.N_frame, self.rvecs_flat, \
self.charges, self.alpha, self.gcut)
self.e_el_real = 0
self.e_vdw = 0
if self.Z_ads > 0:
for p in np.split(pos_molecules, self.Z_ads):
e_new = self.insertion(p)
self.Z_ads -= 1
e = e_new
else:
e = 0
else:
self.pos = pos_init
self.rvecs = rvecs_init
self.rvecs_flat = rvecs_flat_init
self.V = V_init
if rank == 0:
log.set_level(log.medium)
if(iteration % N_sample == 0 and iteration > 0):
eprint = e
if np.abs(eprint) < 1e-10:
eprint = 0
if rank == 0:
print(' {:7.7} {:7.7} {:7.7} {:7.7} {:7.4}'.format(
str(iteration),str(self.Z_ads),str(eprint/kjmol),str(self.V/angstrom**3),time()-t_it)
)
t_it = time()
N_samples.append(self.Z_ads)
E_samples.append(e)
if self.Z_ads == self.fixed_N:
traj.append(self.pos)
if rank == 0 and self.write_traj:
natom = self.N_frame + self.nads * self.Z_ads
rv = self.rvecs_flat/angstrom
ffa_MOF = self.data.system.ffatypes[self.data.system.ffatype_ids]
ffa_ads = self.data.system_ads.ffatypes[self.data.system_ads.ffatype_ids]
ffa = np.append(ffa_MOF, np.tile(ffa_ads, self.Z_ads))
ftraj.write('%d\n%f %f %f %f %f %f %f %f %f\n'%(natom, rv[0], rv[1], rv[2], rv[3], rv[4], rv[5], rv[6], rv[7], rv[8]))
for s, p in zip(ffa, self.pos/angstrom):
ftraj.write('%s %f %f %f\n'%(s, p[0], p[1], p[2]))
if rank == 0:
print('Average N: %.3f'%np.average(N_samples))
if self.fixed_N:
np.save('results/N_%d.npy'%self.fixed_N, np.array(N_samples))
np.save('results/E_%d.npy'%self.fixed_N, np.array(E_samples))
else:
np.save('results/N_%.8f.npy'%(self.P/bar), np.array(N_samples))
np.save('results/E_%.8f.npy'%(self.P/bar), np.array(E_samples))
if self.fixed_N:
from yaff import System
n = np.append(self.data.numbers_MOF, np.tile(self.data.numbers_ads, self.Z_ads))
s = System(n, self.pos, rvecs=self.rvecs)
s.to_file('results/end_%d.xyz'%self.fixed_N)
mol = Molecule.from_file('results/end_%d.xyz'%self.fixed_N)
symbols = mol.symbols
self.write_traj(traj, symbols)
os.remove('results/end_%d.xyz'%self.fixed_N)
if self.write_traj:
ftraj.close()
def from_file(cls, *fns, **user_kwargs):
"""Construct a new System instance from one or more files
**Arguments:**
fn1, fn2, ...
A list of filenames that are read in order. Information in later
files overrides information in earlier files.
**Optional arguments:**
Any argument from the default constructor ``__init__``. These must be
given with keywords.
**Supported file formats**
.xyz
Standard Cartesian coordinates file (in angstroms). Atomic
positions and atomic numbers are read from this file. If the
title consists of 3, 6 or 9 numbers, each group of three numbers
is interpreted as a cell vector (in angstroms). A guess of the
bonds will be made based on inter-atomic distances.
.psf
Atom types and bonds are read from this file
.chk
Internal text-based checkpoint format. It just contains a
dictionary with the constructor arguments.
"""
with log.section('SYS'):
kwargs = {}
for fn in fns:
if fn.endswith('.xyz'):
from molmod import Molecule
mol = Molecule.from_file(fn)
kwargs['numbers'] = mol.numbers.copy()
kwargs['pos'] = mol.coordinates.copy()
elif fn.endswith('.psf'):
from molmod.io import PSFFile
psf = PSFFile(fn)
kwargs['ffatypes'] = psf.atom_types
kwargs['bonds'] = np.array(psf.bonds, copy=False)
kwargs['charges'] = np.array(psf.charges, copy=False)
elif fn.endswith('.chk'):
from molmod.io import load_chk
allowed_keys = [
'numbers',
'pos',
'scopes',
'scope_ids',
'ffatypes',
'ffatype_ids',
'bonds',
'rvecs',
'charges',
'radii',
'valence_charges',
'dipoles',
'radii2',
'masses',
]
for key, value in load_chk(fn).items():
if key in allowed_keys:
kwargs.update({key: value})
elif fn.endswith('.h5'):
with h5.File(fn, 'r') as f:
return cls.from_hdf5(f)
else:
raise IOError('Can not read from file \'%s\'.' % fn)
if log.do_high:
log('Read system parameters from %s.' % fn)
kwargs.update(user_kwargs)
return cls(**kwargs)
