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)