def main(steps, steps_eq):
log.set_level(log.medium)
# Initial density
rho0 = 420 * kilogram / meter**3
system = get_system(nmol, rho0=rho0)
# Values of rcut for which a simulation will be performed
rcuts = np.linspace(10.0, 20.0, 6) * angstrom
results = []
for ircut, rcut in enumerate(rcuts):
row = [rcut]
for tailcorr in [False, True]:
fn_suffix = '_%04d_switch3_%03d' % (nmol, ircut)
if tailcorr: fn_suffix += '_tailcorr'
rho = run_md(system,
rcut,
tailcorr,
steps=steps,
steps_eq=steps_eq,
fn_suffix=fn_suffix)
row.append(rho)
results.append(row)
# Print summary
print("%20s %20s %20s" % ("rcut [AA]", "rho [kg/meter**3]",
"rho with tail corrections [kg/meter**3]"))
print("=" * 100)
for rcut, rho0, rho1 in results:
print("%20.2f %20.12f %20.12f" %
(rcut / angstrom, rho0 / kilogram * meter**3,
rho1 / kilogram * meter**3))
def main(steps, steps_eq):
log.set_level(log.medium)
# Initial density
rho0 = 420*kilogram/meter**3
system = get_system(nmol, rho0=rho0)
# Values of rcut for which a simulation will be performed
rcuts = np.linspace(10.0,20.0,6)*angstrom
results = []
for ircut, rcut in enumerate(rcuts):
row = [rcut]
for tailcorr in [False,True]:
fn_suffix = '_%04d_switch3_%03d'%(nmol,ircut)
if tailcorr: fn_suffix += '_tailcorr'
rho = run_md(system, rcut, tailcorr, steps=steps, steps_eq=steps_eq,fn_suffix=fn_suffix)
row.append(rho)
results.append(row)
# Print summary
print("%20s %20s %20s"%("rcut [AA]","rho [kg/meter**3]","rho with tail corrections [kg/meter**3]"))
print("="*100)
for rcut, rho0, rho1 in results:
print("%20.2f %20.12f %20.12f"%(rcut/angstrom,rho0/kilogram*meter**3,rho1/kilogram*meter**3))
def simulate():
T = 298.0*kelvin
# Input files
fn_guest = 'CO2.chk'
fn_host = 'MIL53.chk'
fn_pars = ['pars.txt']
host = System.from_file(fn_host).supercell(1,1,1)
# Description of allowed MC moves and their corresponding probabilities
mc_moves = {'insertion':1.0, 'deletion':1.0,
'translation':1.0, 'rotation':1.0}
# Construct equation of state to link pressure, fugacity and chemical potential
eos = PREOS.from_name('carbondioxide')
# Loop over pressures to construct isotherm
pressures = np.array([0.1,0.5,1.0,3.0,5.0,10.0])*bar
uptake = np.zeros(pressures.shape)
for iP, P in enumerate(pressures):
fugacity = eos.calculate_fugacity(T,P)
mu = eos.calculate_mu(T,P)
# Screen logger
screenlog = MCScreenLog(step=10000)
# HDF5 logger
fh5 = h5.File('trajectory_%d.h5'%iP,'w')
hdf5writer = MCHDF5Writer(fh5, step=10000)
# Setup the GCMC calculation, this generates a lot of output so when
# force fields are generated, so we silence the logging for a while.
log.set_level(log.silent)
gcmc = GCMC.from_files(fn_guest, fn_pars, host=host,
rcut=12.0*angstrom, tr=None, tailcorrections=True, hooks=[screenlog, hdf5writer],
reci_ei='ewald_interaction', nguests=30)
log.set_level(log.medium)
# Set the external conditions
gcmc.set_external_conditions(T, fugacity)
# Run MC simulation
gcmc.run(1000000, mc_moves=mc_moves)
uptake[iP] = gcmc.Nmean
fh5.close()
np.save('results.npy', np.array([pressures,uptake]).T)
# QuickFF is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, see <http://www.gnu.org/licenses/> # #-- '''QuickFF is a code to quickly derive accurate force fields from ab initio input. ''' from yaff import System from yaff import log as yafflog yafflog.set_level(yafflog.silent) from quickff.reference import * from quickff.valence import * from quickff.perturbation import * from quickff.program import * from quickff.cost import * from quickff.io import * from quickff.tools import * from quickff.log import * from quickff.settings import * from quickff.scripts import * import numpy numpy.set_printoptions(linewidth=170)
#!/usr/bin/env python
import numpy as np
import os
import h5py
from mpi4py import MPI
from glob import glob
from yaff import *
from mylammps import *
from yaff import ForceField, System, NeighborList, Scalings, PairPotLJ, ForcePartPair, ForcePart, log
log.set_level(log.low)
# Setup MPI
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
# Set random seed, important to get the same velocities for all processes
np.random.seed(5)
# Turn off logging for all processes, it can be turned on for one selected process later on
log.set_level(log.silent)
if rank==0: log.set_level(log.medium)
if __name__=='__main__':
f_res = h5py.File('restart_8.h5', mode='r')
system = System.from_hdf5(f_res)
ff = ForceField.generate(system, 'pars.txt', rcut=15*angstrom, alpha_scale=3.2, gcut_scale=1.5, smooth_ei=True)
# of the License, or (at your option) any later version.
#
# YAFF is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>
#
# --
'''Conversion to RASPA input files'''
from __future__ import division
from __future__ import print_function
from yaff.external.raspa import write_raspa_input
from yaff import log
log.set_level(log.medium)
if __name__ == '__main__':
fn_guests = ['CO2.chk']
fn_host = 'MIL53.chk'
fn_pars = ['pars.txt']
write_raspa_input(fn_guests,
fn_pars,
host=fn_host,
guestdata=[('carbondioxide', )],
hostname='MIL53',
workdir='raspa')
name = '%s-%s' % (ffa0, ffa1)
else:
name = '%s-%s' % (ffa1, ffa0)
ftab.write("%s\nN %d R %f %f\n\n" %
(name, energies.shape[0], distances[0], distances[-1]))
for irow, row in enumerate(energies):
ftab.write("%05d %+13.8f %+21.12f %+21.12f\n" %
(irow + 1, row[0], row[1], row[2]))
print name
#break
if __name__ == '__main__':
sys = System.from_file('init.chk')
system = sys.supercell(1, 2, 1)
log.set_level(log.silent)
fns = []
for fn in os.listdir(os.getcwd()):
if fn.startswith('pars') and fn.endswith('.txt'):
fns.append(fn)
ff = ForceField.generate(system,
fns,
rcut=15.0 * angstrom,
alpha_scale=3.2,
gcut_scale=1.5,
smooth_ei=True)
log.set_level(log.low)
write_lammps_data(system)
write_lammps_table_jelle(ff)
# as published by the Free Software Foundation; either version 3 # of the License, or (at your option) any later version. # # QuickFF is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, see <http://www.gnu.org/licenses/> # #-- '''QuickFF is a code to quickly derive accurate force fields from ab initio input. ''' from yaff import System from yaff import log as yafflog yafflog.set_level(yafflog.silent) from quickff.reference import * from quickff.valence import * from quickff.perturbation import * from quickff.program import * from quickff.cost import * from quickff.io import * from quickff.tools import * from quickff.log import * import numpy numpy.set_printoptions(linewidth=170)
Unit and regression test for the osmotic_mcmd package.
"""
# Import package, test suite, and other packages as needed
import osmotic_mcmd
import pytest
import sys
import pkg_resources
import numpy as np
from osmotic_mcmd.mcmd import MCMD
from osmotic_mcmd.utilities import Acceptance, Parse_data, random_ads, random_rot
from wrapper_forceparts import MM3, MM3_insert, LJ, LJ_insert
from molmod.units import kelvin, bar, kjmol, angstrom
from yaff import log
log.set_level(0)
# Test the mm3 energy of the insertion of 2 particles
def test_mm3_insert():
system_file = pkg_resources.resource_filename(__name__, '../data/lp_avg.chk')
ff_file = pkg_resources.resource_filename(__name__, '../data/pars.txt')
adsorbate_file = pkg_resources.resource_filename(__name__, '../data/argon.chk')
T = 87 * kelvin
P = 1 * bar
MD_trial_fraction = 0.000
rcut = 15 * angstrom
fugacity = P
# Try 10 configurations
# ApplyBCI is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>
#
#--
import argparse
import numpy as np
from yaff import System, log, angstrom
from collections import namedtuple
log.set_level(log.silent)
def parse_arguments():
'''Parse command-line arguments'''
parser = argparse.ArgumentParser(description='Tool to compute charges with '
'bond-charge increments')
parser.add_argument('filename_system', metavar='XYZ',
help='an XYZ or CUBE file with the atomic structure (and '
'periodic boundary conditions).')
parser.add_argument('filename_rules', metavar='RULES',
help='A filename with atom type '
'rules. In-line comments start with a #. Empty lines are '
'ignored. On a non-empty line, the first word as the name of the '
'atom type. The rest of the line is a rule written in the '
'ATSELECT atom typing language.')
#!/usr/bin/env python
import numpy as np
import os
from datetime import datetime
import h5py
import sys
from mpi4py import MPI
from yaff import *
from mylammps import *
from yaff import ForceField, System, NeighborList, Scalings, PairPotLJ, ForcePartPair, ForcePart, log
log.set_level(log.low)
# Setup MPI
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
# Set random seed, important to get the same velocities for all processes
np.random.seed(5)
# Turn off logging for all processes, it can be turned on for one selected process later on
if __name__ == '__main__':
f_res = h5py.File('restart_5.h5', mode='r')
system = System.from_hdf5(f_res)
ff = ForceField.generate(system,
'pars.txt',
rcut=15 * angstrom,
alpha_scale=3.2,
from pyiron import Project
from pyiron.base.generic.parameters import GenericParameters
from pyiron.atomistics.structure.atoms import Atoms
from pyiron.atomistics.job.atomistic import AtomisticGenericJob
from pyiron.base.settings.generic import Settings
from collections import OrderedDict
from yaff import System, log as Yafflog, ForceField
Yafflog.set_level(Yafflog.silent)
from quickff import read_abinitio
from quickff.tools import set_ffatypes
from quickff.settings import key_checks
from molmod.units import *
from molmod.constants import *
from molmod.io.chk import load_chk, dump_chk
from molmod.periodic import periodic as pt
import os, posixpath, numpy as np, h5py, matplotlib.pyplot as pp
def write_chk(input_dict, working_directory='.'):
# collect data and initialize Yaff system
if 'cell' in input_dict.keys() and input_dict['cell'] is not None:
system = System(input_dict['numbers'], input_dict['pos']*angstrom, rvecs=input_dict['cell']*angstrom, ffatypes=input_dict['ffatypes_man'], ffatype_ids=input_dict['ffatype_ids_man'])
else:
system = System(input_dict['numbers'], input_dict['pos']*angstrom, ffatypes=input_dict['ffatypes_man'], ffatype_ids=input_dict['ffatype_ids_man'])
# determine masses, bonds and ffaypes from ffatype_rules
system.detect_bonds()
system.set_standard_masses()
# write dictionnairy to MolMod CHK file
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()
from yaff.external.lammps_generator import *
from yaff.external.lammpsio import *
from yaff.external.liblammps import *
from yaff import log
from yaff.pes.colvar import CVVolume
from yaff.sampling.enhanced import *
from yaff import System, ForceField, XYZWriter, VerletScreenLog, MTKBarostat, \
NHCThermostat, TBCombination, VerletIntegrator, HDF5Writer, log
from mpi4py import MPI
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
if rank==0:
log.set_level(log.medium)
else:
log.set_level(log.silent)
class MCMD():
def __init__(self, system_file, adsorbate_file, ff_file, T, P, fugacity, MD_trial_fraction, rcut, fixed_N = None, write_h5s = False, barostat = True, vol_constraint = False, write_traj = False, meta = False, timestep = 0.5*femtosecond):
self.ff_file = ff_file
self.T = T
self.beta = 1/(boltzmann*T)
self.P = P
self.fugacity = fugacity
self.prob = np.array([0.5, 0.5, MD_trial_fraction], dtype=float)
self.prob = np.cumsum(self.prob)/sum(self.prob)
