def testForceAgainstDefaultNeighborList(self): atoms = Diamond(symbol="C", pbc=False) builtin = torchani.neurochem.Builtins() calculator = torchani.ase.Calculator(builtin.species, builtin.aev_computer, builtin.models, builtin.energy_shifter) default_neighborlist_calculator = torchani.ase.Calculator( builtin.species, builtin.aev_computer, builtin.models, builtin.energy_shifter, True) atoms.set_calculator(calculator) dyn = Langevin(atoms, 5 * units.fs, 50 * units.kB, 0.002) def test_energy(a=atoms): a = a.copy() a.set_calculator(calculator) e1 = a.get_potential_energy() a.set_calculator(default_neighborlist_calculator) e2 = a.get_potential_energy() self.assertLess(abs(e1 - e2), tol) dyn.attach(test_energy, interval=1) dyn.run(500)
def smash_it(system): """Run a simple NVT molecular dynamics simulation for 0.1 ps at 200 k using the effective medium theory on a supplied system. Parameters ---------- system : `ase.Atoms` The system that is to be simulated. Returns ------- traj : `list` [`ase.Atoms`] A list of `ase.Atoms` objects comprising the system's trajectory. """ # Tell the system to use the EMT calculator system.set_calculator(EMT()) # Set up the NVT simulation using the Langevin thermostat dyn = Langevin(system, 0.01 * units.fs, 200 * units.kB, 0.002) # Create a list to hold the trajectory & a function to populate it traj = [] def update_traj(a=system): traj.append(a.copy()) # Attach the trajectory populator dyn.attach(update_traj, interval=10) # Run the molecular dynamics simulation from 10000 steps dyn.run(10000) # Return the trajectory return traj
def md(molecule, model, device, output, nsteps, temperature, step, friction): start = time.time() mm = Mol2(molecule) pos = mm.get_coordinates() labels = ''.join(mm.get_symbols()) device = torch.device(device) if model.lower() == 'ani1x': model = torchani.models.ANI1x() elif model.lower() == 'ani1ccx': model = torchani.models.ANI1ccx() else: print("unknwon model {:s}".format(model)) sys.exit(1) assert isinstance(model, torchani.models.ANI1x) or isinstance(model, torchani.models.ANI1ccx) atom_group = Atoms(symbols=labels, positions=pos, calculator=model.ase()) print("step {:12d}\tenergy {:12.4f}".format(0, atom_group.get_total_energy())) dyn = Langevin(atom_group, 1*units.fs, temperature*units.kB, friction) for i in range(nsteps): dyn.run(step) print("step {:12d}\tenergy {:12.4f}".format((i + 1)*step, atom_group.get_total_energy())) mm.coordinates = atom_group.get_positions() if output is not None: mm.write(output + '_{:06d}.mol2'.format(i)) print("time {:12.4f}".format(time.time() - start)) sys.exit(0)
def solve(self): #Create the initial particle from the defining string/number atoms self.particle = NanoClass.genParticle(self.definingString, int(self.numberOfAtoms)) self.reCenter() self.bestEnergy = self.particle.get_potential_energy() self.bestParticle = deepcopy(self.particle) # berendsen = NVTBerendsen(self.particle, 2.5 * units.fs, 2000, taut=0.5*100*units.fs) berendsen = Langevin(self.particle, 5 * units.fs, units.kB * 2000, 0.005) dyn = FIRE(atoms=self.particle) MaxwellBoltzmannDistribution(self.particle,2000*units.kB) CALCULATIONS=100 for i in range(CALCULATIONS): if i%1==0: pDone=float(i)/CALCULATIONS self.setStatusDone(str(math.floor(pDone*100))+"% | "+self.remainingTime(pDone)) self.checkTimeout() self.setSolution(self.getAnswer()) MaxwellBoltzmannDistribution(self.particle,2000*units.kB) self.particle.get_potential_energy() berendsen.run(500) dyn.run() self.reCenter() testEnergy = self.particle.get_potential_energy() if (testEnergy < self.bestEnergy): self.bestEnergy = testEnergy self.bestParticle = deepcopy(self.particle) elif ((testEnergy + .5) > self.bestEnergy): self.particle = NanoClass.genParticle(self.definingString, int(self.numberOfAtoms)) MaxwellBoltzmannDistribution(self.particle,2000*units.kB) self.particle.get_potential_energy() if (testEnergy < self.bestEnergy): self.bestEnergy = testEnergy self.bestParticle = deepcopy(self.particle) return self.getAnswer()
def run_md(self, f, Tmax, steps, n_steps, nmfile=None, displacement=0, min_steps=0, sig=0.34, t=0.1, nm=0, record=False): X, S, Na, cm = hdt.readxyz2(f) if nmfile != None: mode=self.get_mode(nmfile, Na, mn=nm) X=X+mode*np.random.uniform(-displacement,displacement) X=X[0] mol=Atoms(symbols=S, positions=X) mol.set_calculator(ANIENS(self.net,sdmx=20000000.0)) f=os.path.basename(f) T_eff = float(random.randrange(5, Tmax, 1)) # random T (random velocities) from 0K to TK minstep_eff = float(random.randrange(1, min_steps, 1)) # random T (random velocities) from 0K to TK dyn = Langevin(mol, t * units.fs, T_eff * units.kB, 0.01) MaxwellBoltzmannDistribution(mol, T_eff * units.kB) # steps=10000 #10000=1picosecond #Max number of steps to run # n_steps = 1 #Number of steps to run for before checking the standard deviation hsdt_Na=[] evkcal=hdt.evtokcal if record==True: #Records the coordinates at every step of the dynamics fname = f + '_record_' + str(T_eff) + 'K' + '.xyz' #name of file to store coodinated in def printenergy(name=fname, a=mol): """Function to print the potential, kinetic and total energy.""" fil= open(name,'a') Na=a.get_number_of_atoms() c = a.get_positions(wrap=True) fil.write('%s \n comment \n' %Na) for j, i in zip(a, c): fil.write(str(j.symbol) + ' ' + str(i[0]) + ' ' + str(i[1]) + ' ' + str(i[2]) + '\n') fil.close() dyn.attach(printenergy, interval=1) e=mol.get_potential_energy() #Calculate the energy of the molecule. Must be done to get the standard deviation s=mol.calc.stddev stddev = 0 tot_steps = 0 failed = False while (tot_steps <= steps): if stddev > sig and tot_steps > minstep_eff: #Check the standard deviation self.hstd.append(stddev) c = mol.get_positions() s = mol.get_chemical_symbols() Na=mol.get_number_of_atoms() self.Na_train.append(Na) self.coor_train.append(c) self.S_train.append(s) failed=True break else: #if the standard deviation is low, run dynamics, then check it again tot_steps = tot_steps + n_steps dyn.run(n_steps) stddev = evkcal*mol.calc.stddev c = mol.get_positions() s = mol.get_chemical_symbols() e=mol.get_potential_energy() #print("{0:.2f}".format(tot_steps*t),':',"{0:.2f}".format(stddev),':',"{0:.2f}".format(evkcal*e)) return c, s, tot_steps*t, stddev, failed, T_eff
def testWithNumericalForceWithPBCEnabled(self): # Run a Langevin thermostat dynamic for 100 steps and after the dynamic # check once that the numerical and analytical force agree to a given # relative tolerance atoms = Diamond(symbol="C", pbc=True) calculator = self.model.ase() atoms.set_calculator(calculator) dyn = Langevin(atoms, 5 * units.fs, 30000000 * units.kB, 0.002) dyn.run(100) f = atoms.get_forces() fn = get_numeric_force(atoms, 0.001) self.assertEqual(f, fn, rtol=0.1, atol=0.1)
def testWithNumericalForceWithPBCEnabled(self): atoms = Diamond(symbol="C", pbc=True) calculator = torchani.models.ANI1x().ase() atoms.set_calculator(calculator) dyn = Langevin(atoms, 5 * units.fs, 30000000 * units.kB, 0.002) dyn.run(100) f = torch.from_numpy(atoms.get_forces()) fn = get_numeric_force(atoms, 0.001) df = (f - fn).abs().max() avgf = f.abs().mean() if avgf > 0: self.assertLess(df / avgf, 0.1)
def hyster_study(edge, folder=None): if folder == None: folder = os.getcwd() print folder for fileC in os.listdir(folder): if fileC[-6:] == '.simul': fileC = folder + fileC _, length, _, _, v, T, dt, fric, dtheta, \ thresZ, interval, deltaY, theta, M, edge = read_simul_params_file(fileC) mdfile = fileC[:-6] + '.traj' traj = PickleTrajectory(mdfile, 'r') atoms_init = traj[0] constraints, _, twist, rend_b, rend_t = get_constraints(atoms_init, edge, \ bond, None, key = 'twist_p') #constraints, _, rend_b, rend_t = get_constraints(atoms_init, edge, \ # bond, None, key = 'twist_p') atoms = traj[-1] atoms.set_constraint(constraints) vels = (traj[-2].positions - traj[-1].positions) / (interval * dt) atoms.set_velocities(vels) calc = LAMMPS(parameters=get_lammps_params()) atoms.set_calculator(calc) view(atoms) dyn = Langevin(atoms, dt * units.fs, T * units.kB, fric) twist.set_angle(theta) dyn.run(10 * interval) view(atoms) traj_new = PickleTrajectory(fileC[:-6] + '_hyst.traj', 'w', atoms) mdlogf = fileC[:-6] + '_hyst.log' do_dynamics(mdlogf, atoms, dyn, rend_b, rend_t, v, dt, deltaY, \ theta, dtheta, length, thresZ, \ interval, traj_new, M, twist) mdhystf = fileC[:-6] + '_hyst.traj' logfile = fileC[:-6] + '.log' append_files(logfile, mdlogf, logfile[:-4] + '_comp.log') call([ 'ase-gui', mdfile, mdhystf, '-o', logfile[:-4] + '_comp.traj' ])
def hyster_study(edge, folder = None): if folder == None: folder = os.getcwd() print folder for fileC in os.listdir(folder): if fileC[-6:] == '.simul': fileC = folder + fileC _, length, _, _, v, T, dt, fric, dtheta, \ thresZ, interval, deltaY, theta, M, edge = read_simul_params_file(fileC) mdfile = fileC[:-6] + '.traj' traj = PickleTrajectory(mdfile, 'r') atoms_init = traj[0] constraints, _, twist, rend_b, rend_t = get_constraints(atoms_init, edge, \ bond, None, key = 'twist_p') #constraints, _, rend_b, rend_t = get_constraints(atoms_init, edge, \ # bond, None, key = 'twist_p') atoms = traj[-1] atoms.set_constraint(constraints) vels = (traj[-2].positions - traj[-1].positions) / (interval * dt) atoms.set_velocities(vels) calc = LAMMPS(parameters=get_lammps_params()) atoms.set_calculator(calc) view(atoms) dyn = Langevin(atoms, dt*units.fs, T*units.kB, fric) twist.set_angle(theta) dyn.run(10 * interval) view(atoms) traj_new= PickleTrajectory(fileC[:-6] + '_hyst.traj', 'w', atoms) mdlogf = fileC[:-6] + '_hyst.log' do_dynamics(mdlogf, atoms, dyn, rend_b, rend_t, v, dt, deltaY, \ theta, dtheta, length, thresZ, \ interval, traj_new, M, twist) mdhystf = fileC[:-6] + '_hyst.traj' logfile = fileC[:-6] + '.log' append_files(logfile, mdlogf, logfile[:-4] + '_comp.log') call(['ase-gui', mdfile, mdhystf, '-o', logfile[:-4] + '_comp.traj'])
def __run_rand_dyn__(self, mid, T1, T2, dt, Nc, Ns, dS): # Setup calculator mol = self.mols[0].copy() # Setup PBC if active if self.pbc: mol.set_cell(([[self.pbl, 0, 0], [0, self.pbl, 0], [0, 0, self.pbl]])) mol.set_pbc((self.pbc, self.pbc, self.pbc)) # Setup calculator mol.set_calculator(ANIENS(self.aens)) #mol.set_calculator(ANI(False)) #mol.calc.setnc(self.ncl[0]) # Set chemical symbols spc = mol.get_chemical_symbols() # Set the velocities corresponding to a boltzmann dist @ T/4.0 MaxwellBoltzmannDistribution(mol, T1 * units.kB) # Set the thermostat dyn = Langevin(mol, dt * units.fs, T1 * units.kB, 0.02) dT = (T2 - T1)/Nc #print('Running...') for i in range(Nc): # Set steps temperature dyn.set_temperature((T1 + dT*i) * units.kB) # Do Ns steps of dynamics dyn.run(Ns) # Return sigma sigma = hdt.evtokcal * mol.calc.stddev ekin = mol.get_kinetic_energy() / len(mol) # Check for dynamics failure if sigma > dS: self.Nbad += 1 self.X.append(mol.get_positions()) #print('Step:', dyn.get_number_of_steps(), 'Sig:', sigma, 'Temp:', # str(ekin / (1.5 * units.kB)) + '(' + str(T1 + dT * i) + ')') return True,dyn.get_number_of_steps() return False,dyn.get_number_of_steps()
def _testForce(self, pbc): atoms = Diamond(symbol="C", pbc=pbc) builtin = torchani.neurochem.Builtins() calculator = torchani.ase.Calculator( builtin.species, builtin.aev_computer, builtin.models, builtin.energy_shifter) atoms.set_calculator(calculator) dyn = Langevin(atoms, 5 * units.fs, 30000000 * units.kB, 0.002) dyn.run(100) f = torch.from_numpy(atoms.get_forces()) fn = get_numeric_force(atoms, 0.001) df = (f - fn).abs().max() avgf = f.abs().mean() if avgf > 0: self.assertLess(df / avgf, 0.1)
def run_static(self): """ Static run function, which uses the ASEAdapter to connect the pyiron interactive reference job with the Langevin thermostat implemented in ASE, by setting the ASEAdapter as a replacement of the ASE atoms object. """ self.status.running = True self.ref_job_initialize() aseadapter = AseAdapter(self.ref_job, self._fast_mode) langevin = Langevin(atoms=aseadapter, timestep=self.input['time_step'] * units.fs, temperature=self.input['temperature'] * units.kB, friction=self.input['friction'], fixcm=True) langevin.run(self.input['ionic_steps']) self.status.collect = True aseadapter.interactive_close() self._finish_job()
def solve(self): #Create the initial particle from the defining string/number atoms temp = 1750 mintemp = 150 self.particle = genParticle(self.definingString,int(self.numberOfAtoms)) if (len(self.particle) < 16): temp = 1250 maxtemp = temp berendsen = Langevin(self.particle, 2.5 * units.fs, units.kB * temp, 0.02) # the 5.0 * units.fs is used instead of 0.1 * units.fs b/c it makes the program run faster MaxwellBoltzmannDistribution(self.particle,units.kB * temp) self.bestEnergy = self.particle.get_potential_energy() self.bestParticle = deepcopy(self.particle) self.reCenter() self.getAnswer() while (temp > mintemp): berendsen = Langevin(self.particle, 2.5 * units.fs, units.kB * temp, 0.02) berendsen.run(100) testEnergy = self.particle.get_potential_energy() self.bestEnergy = self.particle.get_potential_energy() self.bestParticle = deepcopy(self.particle) self.reCenter() self.getAnswer() temp -= 10 if (temp % 50 == 0): self.bestEnergy = self.particle.get_potential_energy() self.bestParticle = deepcopy(self.particle) self.reCenter() self.checkTimeout() self.setSolution(self.getAnswer()) pDone=float(maxtemp - temp)/(maxtemp-mintemp) self.setStatusDone(str(math.floor(pDone*100))+"% | "+self.remainingTime(pDone)) elif (temp <= mintemp): dyn = FIRE(atoms=self.particle) dyn.run(fmax=0.01) self.bestEnergy = self.particle.get_potential_energy() self.bestParticle = deepcopy(self.particle) self.reCenter() self.setSolution(self.getAnswer()) pDone=float(temp)/(maxtemp-mintemp) self.setStatusDone(str(math.floor(pDone*100))+"% | "+self.remainingTime(pDone)) return self.getAnswer()
def run_md(atoms, md_temperature = 1000*kB, md_step_size = 1*fs, md_steps=100, md_interval=100, friction=0.02): natoms=atoms.get_number_of_atoms() #atoms.set_calculator(self.opt_calculator) atoms_md = [] e_log = [] atoms_md.append(atoms.copy()) MaxwellBoltzmannDistribution(atoms=atoms, temp=md_temperature) dyn = Langevin(atoms, md_step_size, md_temperature, friction) def md_log(atoms=atoms): atoms_md.append(atoms.copy()) epot=atoms.get_potential_energy() ekin=atoms.get_kinetic_energy() temp = ekin / (1.5 * kB * natoms) e_log.append([epot, ekin, temp]) traj = Trajectory('Au_md.traj', 'w', atoms) # Output MD trajectory before it is treatment dyn.attach(traj.write, interval=10) dyn.attach(md_log, interval=md_interval) dyn.run(md_steps) return atoms_md, e_log
def md_calculation(fcp_file): from ase import units from ase.io.trajectory import Trajectory from ase.md.velocitydistribution import MaxwellBoltzmannDistribution from ase.md.langevin import Langevin from ase.md import MDLogger if 'fcc' in fcp_file: ref_cell = read(ref_fcc) P = np.array([[-1, 1, 1], [1, -1, 1], [1, 1, -1]]) P *= 3 atoms = make_supercell(ref_cell, P) else: raise ValueError("Unknown phase") fcp = ForceConstantPotential.read(fcp_file) fcs = fcp.get_force_constants(atoms) calc = ForceConstantCalculator(fcs) atoms.set_calculator(calc) temperature = 200 number_of_MD_steps = 100 time_step = 5 # in fs dump_interval = 10 traj_file = "data/md_" + fcp_file.split('.')[0] + '{}.traj'.format( temperature) log_file = "data/md_log_{}.log".format(temperature) dyn = Langevin(atoms, time_step * units.fs, temperature * units.kB, 0.02) logger = MDLogger(dyn, atoms, log_file, header=True, stress=False, peratom=True, mode='w') traj_writer = Trajectory(traj_file, 'w', atoms) dyn.attach(logger, interval=dump_interval) dyn.attach(traj_writer.write, interval=dump_interval) # run MD MaxwellBoltzmannDistribution(atoms, temperature * units.kB) dyn.run(number_of_MD_steps)
def test_usage(self): atoms = fcc111('Al', size=(4, 4, 9), orthogonal=True) atoms.set_pbc(True) atoms.center(axis=2, vacuum=10.0) z = atoms.positions[:, 2] top_mask = z > z[115] - 0.1 bottom_mask = z < z[19] + 0.1 calc = EMT() atoms.calc = calc damping = pc.AutoDamping(C11=500 * GPa, p_c=0.2) Pdir = 2 vdir = 0 P = 5 * GPa v = 100.0 * m / s dt = 1.0 * fs T = 400.0 t_langevin = 75 * fs gamma_langevin = 1. / t_langevin slider = pc.SlideWithNormalPressureCuboidCell(top_mask, bottom_mask, Pdir, P, vdir, v, damping) atoms.set_constraint(slider) MaxwellBoltzmannDistribution(atoms, 2 * kB * T) atoms.arrays['momenta'][top_mask, :] = 0 atoms.arrays['momenta'][bottom_mask, :] = 0 handle = StringIO() beginning = handle.tell() temps = np.zeros((len(atoms), 3)) temps[slider.middle_mask, slider.Tdir] = kB * T gammas = np.zeros((len(atoms), 3)) gammas[slider.middle_mask, slider.Tdir] = gamma_langevin integrator = Langevin(atoms, dt, temps, gammas, fixcm=False) logger = pc.SlideLogger(handle, atoms, slider, integrator) logger.write_header() logger() images = [] integrator.attach(logger) integrator.attach(lambda: images.append(atoms.copy())) integrator.run(50) handle.seek(beginning) pc.SlideLog(handle) handle.close()
def md_run(origin_poscar_path, index): print('%d' % index + ' In directory : %s' % origin_poscar_path) atoms = read(origin_poscar_path) calc = ANNCalculator(potentials={ "Ga": "Ga.10t-10t.nn", "N": "N.10t-10t.nn" }) atoms.set_calculator(calc) MaxwellBoltzmannDistribution(atoms, 1200 * kB) Stationary(atoms) md = NVT(atoms, timestep=2 * fs, temperature=1000 * kB, friction=0.05) logger = MDLogger(md, atoms, '-', stress=True) md.attach(logger, interval=1) traj = Trajectory( "nvt_%s.traj" % (origin_poscar_path.split('/')[-1].split('.xsf')[0]), "w", atoms) md.attach(traj.write, interval=200) md.run(40000)
def MD(): old_stdout = sys.stdout sys.stdout = mystdout = StringIO() orig_stdout = sys.stdout f = open('out.txt', 'w') sys.stdout = f #f = open('out_' + str(temp) + '.txt', 'w') #sys.stdout = f Tmin = 1000 Tmax = 15000 a0 = 5.43 N = 1 atoms = Diamond(symbol='Si', latticeconstant=a0) atoms *= (N, N, N) atoms.set_calculator(model.calculator) MaxwellBoltzmannDistribution(atoms, Tmin * units.kB) ###is this allowed? Stationary(atoms) # zero linear momentum ZeroRotation(atoms) def printenergy(a=atoms): epot = a.get_potential_energy() / len(a) ekin = a.get_kinetic_energy() / len(a) print(ekin) traj = Trajectory('Si.traj', 'w', atoms) for temp in np.linspace(Tmin, Tmax, 5): dyn = Langevin(atoms, 5 * units.fs, units.kB * temp, 0.002) dyn.attach(traj.write, interval=1) dyn.attach(printenergy, interval=1) dyn.run(100) sys.stdout = orig_stdout f.close()
def printenergy(a, it, t0): """Function to print the potential, kinetic and total energy""" epot = a.get_potential_energy() / len(a) ekin = a.get_kinetic_energy() / len(a) t_now = time() print('Step: %4d [%6.2f]: Epot = %.3feV Ekin = %.3feV (T=%3.0fK) ' 'Etot = %.3feV ' % (\ it, t_now-t0, epot, ekin, ekin / (1.5 * units.kB), epot + ekin)) return t_now ff = PyXtal_FF(model={'system': ["Si"]}, logo=False) ff.run(mode='predict', mliap=options.file) calc = PyXtalFFCalculator(ff=ff) si = bulk('Si', 'diamond', a=5.659, cubic=True) si = si * 5 print("MD simulation for ", len(si), " atoms") si.set_calculator(calc) MaxwellBoltzmannDistribution(si, 1000 * units.kB) dyn = Langevin(si, timestep=5 * units.fs, temperature_K=1000, friction=0.02) #dyn = VelocityVerlet(si, 5*units.fs) # 2 fs time step. t0 = time() for i in range(10): dyn.run(steps=1) t_now = printenergy(si, i, t0) t0 = t_now
# Set the momenta corresponding to a temperature T MaxwellBoltzmannDistribution(molecule, temperature * units.kB) # define the algorithm for MD: here Langevin alg. with with a time step of 0.1 fs, # the temperature T and the friction coefficient to 0.02 atomic units. dyn = Langevin(molecule, timestep * units.fs, temperature * units.kB, friction) R_list = [] P_list = [] t = time.time() for i in range(equilibration_steps): dyn.run(1) if i % 100 == 0: print("NVT equilibration at step: " + str(i)) print(time.time() - t, "s") t = time.time() epot = molecule.get_potential_energy() ekin = molecule.get_kinetic_energy() etot = epot + ekin print(etot) pos = molecule.get_positions() mom = molecule.get_momenta() R_list.append(pos) P_list.append(mom)
class clustergenerator(): def __init__(self, cnstfile, saefile, nnfprefix, Nnet, solv_list, solu_list, gpuid=0, sinet=False): # Molecules list self.solv_list = solv_list self.solu_list = solu_list # Number of networks self.Nn = Nnet # Build ANI ensemble self.aens = ensemblemolecule(cnstfile, saefile, nnfprefix, Nnet, gpuid) self.edgepad = 1.0 self.mindist = 2.0 #def closeoutputs(self): # self.mdcrd.close() # self.traj.close() def __generategarbagebox__(self, Nm, Nembed, L, T): self.X = np.empty((0, 3), dtype=np.float32) self.S = [] self.C = np.zeros((Nm, 3), dtype=np.float32) rint = np.random.randint(len(self.solv_list), size=Nm) self.Na = np.zeros(Nm, dtype=np.int32) self.ctd = [] pos = 0 plc = 0 for idx, j in enumerate(rint): if idx < Nembed: ri = np.random.randint(len(self.solu_list), size=1) s = self.solu_list[ri[0]]['species'] xyz = self.solu_list[ri[0]]['coordinates'] nmc = self.solu_list[ri[0]]['nmdisplacements'] frc = self.solu_list[ri[0]]['forceconstant'] nms = nmt.nmsgenerator(xyz, nmc, frc, s, T, minfc=5.0E-2) x = nms.get_Nrandom_structures(1)[0] else: s = self.solv_list[j]['species'] xyz = self.solv_list[j]['coordinates'] nmc = self.solv_list[j]['nmdisplacements'] frc = self.solv_list[j]['forceconstant'] nms = nmt.nmsgenerator(xyz, nmc, frc, s, T, minfc=5.0E-2) x = nms.get_Nrandom_structures(1)[0] # Apply a random rotation M = rand_rotation_matrix() x = np.dot(x, M.T) maxd = hdn.generatedmatsd3(x).flatten().max() / 2.0 Nf = 0 fail = True while fail: ctr = np.random.uniform(2.0 * maxd + self.edgepad, L - 2.0 * maxd - self.edgepad, (3)) fail = False for cid, c in enumerate(self.ctd): if np.linalg.norm(c[0] - ctr) < maxd + c[1] + 10.0: # search for atoms within r angstroms minv = 1000.0 for xi in self.X[c[2]:c[2] + self.Na[cid], :]: for xj in x + ctr: dij = np.linalg.norm(xi - xj) if dij < minv: minv = dij if minv < self.mindist: fail = True Nf += 1 if not fail: plc += 1 #print('Added:',plc) self.ctd.append((ctr, maxd, pos)) self.X = np.vstack([self.X, x + ctr]) self.Na[idx] = len(s) pos += len(s) #print('Placement Complete...',plc,'-',Nf) self.S.extend(s) def init_dynamics(self, Nm, Nembed, V, L, dt, T): self.L = L # Generate the box of junk self.__generategarbagebox__(Nm, Nembed, L, T) # Make mol self.mol = Atoms(symbols=self.S, positions=self.X) # Set box and PBC self.mol.set_cell(([[L, 0, 0], [0, L, 0], [0, 0, L]])) self.mol.set_pbc((True, True, True)) # Set ANI calculator self.mol.set_calculator(ANIENS(self.aens)) # Open MD output #self.mdcrd = open(xyzfile, 'w') # Open MD output #self.traj = open(trjfile, 'w') # Set the velocities corresponding to a boltzmann dist @ T/4.0 MaxwellBoltzmannDistribution(self.mol, 300.0 * units.kB) # Declare Dyn self.dyn = Langevin(self.mol, dt * units.fs, T * units.kB, 0.1) # Define the printer #def printenergy(a=self.mol, d=self.dyn, b=self.mdcrd, t=self.traj): # store a reference to atoms in the definition. # """Function to print the potential, kinetic and total energy.""" # epot = a.get_potential_energy() / len(a) # ekin = a.get_kinetic_energy() / len(a) # # stddev = hdn.evtokcal * a.calc.stddev # # t.write(str(d.get_number_of_steps()) + ' ' + str(ekin / (1.5 * units.kB)) + ' ' + str(epot) + ' ' + str( # ekin) + ' ' + str(epot + ekin) + '\n') # b.write(str(len(a)) + '\n' + str(ekin / (1.5 * units.kB)) + ' Step: ' + str(d.get_number_of_steps()) + '\n') # c = a.get_positions(wrap=True) # for j, i in zip(a, c): # b.write(str(j.symbol) + ' ' + str(i[0]) + ' ' + str(i[1]) + ' ' + str(i[2]) + '\n') # # print('Step: %d Energy per atom: Epot = %.3feV Ekin = %.3feV (T=%3.0fK) ' # 'Etot = %.3feV' ' StdDev = %.3fkcal/mol/sqrt(Na)' % ( # d.get_number_of_steps(), epot, ekin, ekin / (1.5 * units.kB), epot + ekin, stddev)) # Attach the printer #self.dyn.attach(printenergy, interval=1) def run_dynamics(self, Ni): for id, nc in enumerate(self.aens.ncl): nc.setMolecule(coords=np.array(self.mol.get_positions(), dtype=np.float32), types=self.mol.get_chemical_symbols()) self.dyn.run(Ni) # Do Ni steps def __fragmentbox__(self, file, sighat): self.X = self.mol.get_positions() self.frag_list = [] self.Nd = 0 self.Nt = 0 self.maxsig = 0 for i in range(len(self.Na)): si = self.ctd[i][2] di = self.ctd[i][1] Nai = self.Na[i] Xci = np.sum(self.X[si:si + Nai, :], axis=0) / Nai Xi = self.X[si:si + Nai, :] if np.all(Xci > 4.5) and np.all(Xci <= self.L - 4.5): if np.all(Xci > di) and np.all(Xci < self.L - di): Xf = Xi Sf = self.S[si:si + Nai] Nmax = random.randint(2, 14) Nmol = 0 for j in range(len(self.Na)): if i != j: sj = self.ctd[j][2] dj = self.ctd[j][1] Naj = self.Na[j] Xcj = np.sum(self.X[sj:sj + Naj, :], axis=0) / Naj Xj = self.X[sj:sj + Naj, :] if np.all(Xcj > dj) and np.all(Xcj < self.L - dj): dc = np.linalg.norm(Xci - Xcj) if dc < di + dj + 5.0: min = 10.0 for ii in range(Nai): Xiii = Xi[ii] for jj in range(Naj): Xjjj = Xj[jj] v = np.linalg.norm(Xiii - Xjjj) if v < min: min = v if min < 4.5 and min > 0.70: Xf = np.vstack([Xf, Xj]) Sf.extend(self.S[sj:sj + Naj]) Nmol += 1 if Nmol >= Nmax: break Xcf = np.sum(Xf, axis=0) / float(len(Sf)) Xf = Xf - Xcf E = np.empty(5, dtype=np.float64) for id, nc in enumerate(self.aens.ncl): nc.setMolecule(coords=np.array(Xf, dtype=np.float32), types=Sf) E[id] = nc.energy()[0] sig = np.std(hdn.hatokcal * E) / np.sqrt(Nai + Naj) #print('Mol(',i,'): sig=',sig) self.Nt += 1 if sig > sighat: if sig > self.maxsig: self.maxsig = sig self.Nd += 1 hdn.writexyzfile(file + str(i).zfill(4) + '.xyz', Xf.reshape(1, Xf.shape[0], 3), Sf) self.frag_list.append(dict({'coords': Xf, 'spec': Sf})) #print(dc, Sf, sig) def generate_clusters(self, gcmddict, mol_sizes, id): self.edgepad = gcmddict['edgepad'] self.mindist = gcmddict['mindist'] dstore = gcmddict['dstore'] difo = open( dstore + 'info_data_mdcluster-' + str(id).zfill(2) + '.nfo', 'w') difo.write('Beginning dimer generation...\n') Nt = 0 Nd = 0 for i in range(gcmddict['Nr']): self.init_dynamics( mol_sizes[i], gcmddict['Nembed'], gcmddict['V'], gcmddict['L'], gcmddict['dt'], gcmddict['T'], ) for j in range(gcmddict['Ns']): if j is 0: Ni = 0 else: Ni = gcmddict['Ni'] self.run_dynamics(Ni) self.__fragmentbox__( gcmddict['molfile'] + '-' + str(id).zfill(2) + '-' + str(i).zfill(2) + '-' + str(j).zfill(4) + '_', gcmddict['sig']) #print('Step (',i,',',j,') [', str(self.Nd), '/', str(self.Nt),'] generated ',len(self.frag_list),' maxsig: ', self.maxsig,' dimers...') difo.write('Step (' + str(i) + ',' + str(i) + ') [' + str(self.Nd) + '/' + str(self.Nt) + '] generated ' + str(len(self.frag_list)) + ' clusters. ' + ' maxsig: ' + "{:.2f}".format(self.maxsig) + '\n') Nt += self.Nt Nd += self.Nd if self.maxsig > gcmddict['maxsig']: difo.write("Terminated after: " + "{:.2f}".format(Ni * gcmddict['Ns'] * gcmddict['dt']) + 'fs for maxsig\n') break difo.flush() #self.closeoutputs() difo.write('Generated ' + str(Nd) + ' of ' + str(Nt) + ' tested dimers. Percent: ' + "{:.2f}".format(100.0 * Nd / float(Nt))) difo.close()
class dimergenerator(): def __init__(self, cnstfile, saefile, nnfprefix, Nnet, molecule_list, gpuid=0, sinet=False): # Molecules list self.mols = molecule_list # Number of networks self.Nn = Nnet # Build ANI ensemble self.aens = ensemblemolecule(cnstfile, saefile, nnfprefix, Nnet, gpuid) # Construct pyNeuroChem class #self.ncl = [pync.molecule(cnstfile, saefile, nnfprefix+str(i)+'/networks/', gpuid, sinet) for i in range(self.Nn)] def __generategarbagebox__(self, Nm, L, T): self.X = np.empty((0, 3), dtype=np.float32) self.S = [] self.C = np.zeros((Nm, 3), dtype=np.float32) rint = np.random.randint(len(self.mols), size=Nm) self.Na = np.zeros(Nm, dtype=np.int32) self.ctd = [] pos = 0 plc = 0 attempts = 0 for idx, j in enumerate(rint): if attempts >= 10000: break #x = self.mols[j]['coordinates'] #s = self.mols[j]['species'] s = self.mols[j]['species'] xyz = self.mols[j]['coordinates'] nmc = self.mols[j]['nmdisplacements'] frc = self.mols[j]['forceconstant'] nms = nmt.nmsgenerator(xyz, nmc, frc, s, T, minfc=5.0E-2) x = nms.get_Nrandom_structures(1)[0] # Apply a random rotation M = rand_rotation_matrix() x = np.dot(x, M.T) maxd = hdn.generatedmatsd3(x).flatten().max() / 2.0 #print('after:', maxd) fail = True while fail and attempts < 10000: ctr = np.random.uniform(2.0 * maxd + 1.0, L - 2.0 * maxd - 1.0, (3)) fail = False for cid, c in enumerate(self.ctd): if np.linalg.norm(c[0] - ctr) < maxd + c[1] + 10.0: # search for atoms within r angstroms minv = 1000.0 for xi in self.X[c[2]:c[2] + self.Na[cid], :]: for xj in x + ctr: dij = np.linalg.norm(xi - xj) if dij < minv: minv = dij if minv < 1.5: fail = True attempts += 1 if not fail: plc += 1 attempts = 0 #print('Added:',plc) self.ctd.append((ctr, maxd, pos)) self.X = np.vstack([self.X, x + ctr]) self.Na[idx] = len(s) pos += len(s) self.S.extend(s) self.Na = self.Na[0:plc] def init_dynamics(self, Nm, V, L, dt, T): self.L = L # Generate the box of junk self.__generategarbagebox__(Nm, L, T) # Make mol self.mol = Atoms(symbols=self.S, positions=self.X) # Set box and PBC self.mol.set_cell(([[L, 0, 0], [0, L, 0], [0, 0, L]])) self.mol.set_pbc((True, True, True)) # Set ANI calculator # Set ANI calculator self.mol.set_calculator(ANIENS(self.aens)) #self.mol.set_calculator(ANI(False)) #self.mol.calc.setnc(self.ncl[0]) # Give molecules random velocity acc_idx = 0 vel = np.empty_like(self.X) for n in self.Na: rv = np.random.uniform(-V, V, size=(3)) for k in range(n): vel[acc_idx + k, :] = rv acc_idx += n #print(vel) self.mol.set_velocities(vel) # Declare Dyn self.dyn = Langevin(self.mol, dt * units.fs, T * units.kB, 0.1) def run_dynamics(self, Ni): # Open MD output #mdcrd = open(xyzfile, 'w') # Open MD output #traj = open(trajfile, 'w') # Define the printer #def printenergy(a=self.mol, d=self.dyn): # store a reference to atoms in the definition. # """Function to print the potential, kinetic and total energy.""" # epot = a.get_potential_energy() / len(a) # ekin = a.get_kinetic_energy() / len(a) # print('Step: %d Size: %d Energy per atom: Epot = %.3feV Ekin = %.3feV (T=%3.0fK) ' # 'Etot = %.3feV' % (d.get_number_of_steps(), len(a), epot, ekin, ekin / (1.5 * units.kB), epot + ekin)) # Attach the printer #self.dyn.attach(printenergy, interval=4) self.dyn.run(Ni) # Do Ni steps # Open MD output #mdcrd.close() # Open MD output #traj.close() def __fragmentbox__(self, file, sig_cut): self.X = self.mol.get_positions() self.frag_list = [] self.Nd = 0 self.Nt = 0 for i in range(len(self.Na)): si = self.ctd[i][2] di = self.ctd[i][1] Nai = self.Na[i] Xci = np.sum(self.X[si:si + Nai, :], axis=0) / Nai Xi = self.X[si:si + Nai, :] if np.all(Xci > di) and np.all(Xci < self.L - di): for j in range(i + 1, len(self.Na)): sj = self.ctd[j][2] dj = self.ctd[j][1] Naj = self.Na[j] Xcj = np.sum(self.X[sj:sj + Naj, :], axis=0) / Naj Xj = self.X[sj:sj + Naj, :] if np.all(Xcj > dj) and np.all(Xcj < self.L - dj): dc = np.linalg.norm(Xci - Xcj) if dc < di + dj + 6.0: min = 10.0 for ii in range(Nai): Xiii = Xi[ii] for jj in range(Naj): Xjjj = Xj[jj] v = np.linalg.norm(Xiii - Xjjj) if v < min: min = v if min < 4.2 and min > 1.1: Xf = np.vstack([Xi, Xj]) Sf = self.S[si:si + Nai] Sf.extend(self.S[sj:sj + Naj]) Xcf = np.sum(Xf, axis=0) / (Nai + Naj) Xf = Xf - Xcf E = np.empty(5, dtype=np.float64) for id, nc in enumerate(self.aens.ncl): nc.setMolecule(coords=np.array( Xf, dtype=np.float32), types=Sf) E[id] = nc.energy()[0] sig = np.std( hdn.hatokcal * E) / np.sqrt(Nai + Naj) self.Nt += 1 if sig > sig_cut: self.Nd += 1 hdn.writexyzfile( file + str(i).zfill(4) + '-' + str(j).zfill(4) + '.xyz', Xf.reshape(1, Xf.shape[0], 3), Sf) self.frag_list.append( dict({ 'coords': Xf, 'spec': Sf }))
atoms.set_calculator(mixer) dyn = None if md_style == "Langevin": dyn = Langevin(atoms, timestep, 1.5*T*units.kB, 0.002) elif md_style == "Verlet": dyn = VelocityVerlet(atoms, timestep) elif md_style == "TESTING": dyn = DynTesting(atoms, timestep=0.1*units.fs, offset=(0.1, 0., 0.)) energy_file = None def printenergy(a=atoms): epot = a.get_potential_energy() / len(a) ekin = a.get_kinetic_energy() / len(a) energy_file.write("%.5e,%.5e,%.5e,%.5e" % (epot + ekin, epot, ekin, ekin/(1.5*units.kB)) + "\n") # only enable logging for master node where rank == 0 if rank == 0: energy_file = open("mixer_box_energy.csv", "w+b", buffering=0) energy_file.write("total,potential,kinetic,temperature\n") dyn.attach(printenergy, interval=log_interval) traj = PickleTrajectory(output_file, 'w', atoms) dyn.attach(traj.write, interval=log_interval) printenergy() dyn.run(steps)
size=(size, size, size), pbc=True, latticeconstant=3.5646) view(atoms) atoms.set_calculator(calc) # MaxwellBoltzmannDistribution(atoms, 300 * units.kB) # dyn = VelocityVerlet(atoms, 5 * units.fs) T = 10 dyn = Langevin(atoms, 5 * units.fs, T * units.kB, 0.002) traj = Trajectory('md.traj', 'w', atoms) dyn.attach(traj.write, interval=50) def printenergy(a): """Function to print the potential, kinetic and total energy""" epot = a.get_potential_energy() / len(a) ekin = a.get_kinetic_energy() / len(a) print('Energy per atom: Epot = %.3feV Ekin = %.3feV (T=%3.0fK) ' 'Etot = %.3feV' % (epot, ekin, ekin / (1.5 * units.kB), epot + ekin)) printenergy(atoms) for i in range(200): dyn.run(50) printenergy(atoms)
def run_moldy(): KC = False # DEFINE FILES mdfile, mdlogfile = 'md.traj', 'md.log' atoms = make_graphene_slab(a,h,width,4,2, passivate = True)[3] params = {'bond':bond, 'a':a, 'h':h} params['positions'] = atoms.positions.copy() params['pbc'] = atoms.get_pbc() params['cell'] = atoms.get_cell().diagonal() params['ia_dist'] = 14 params['chemical_symbols'] = atoms.get_chemical_symbols() constraints = [] add_kc = KC_potential(params) left = get_ind(atoms.positions.copy(), 'left', 1, bond) rend = get_ind(atoms.positions.copy(), 'rend', atoms.get_chemical_symbols(), 0) ''' # FIX #zset, layer_inds = find_layers(atoms.positions.copy()) add_adh = add_adhesion(params) add_kc = KC_potential(params) #constraints.append(add_adh) # END FIX ''' fix_left = FixAtoms(indices = left) for ind in rend: fix_deform = FixedPlane(ind, (0., 0., 1.)) constraints.append(fix_deform) constraints.append(fix_left) if KC: constraints.append(add_kc) # CALCULATOR LAMMPS parameters = {'pair_style':'rebo', 'pair_coeff':['* * CH.airebo C H'], 'mass' :['1 12.0', '2 1.0'], 'units' :'metal', 'boundary' :'f p f'} calc = LAMMPS(parameters=parameters) atoms.set_calculator(calc) # END CALCULATOR atoms.set_constraint(constraints) #view(atoms) # TRAJECTORY traj = PickleTrajectory(mdfile, 'w', atoms) data = np.zeros((M, 6)) # DYNAMICS dyn = Langevin(atoms, dt*units.fs, T*units.kB, 0.002) n = 0 header = '#t [fs], d [Angstrom], epot_tot [eV], ekin_tot [eV], etot_tot [eV] \n' log_f = open(mdlogfile, 'w') log_f.write(header) log_f.close() for i in range(0, M): #for ind in rend: atoms[3].position[2] -= dz dyn.run(1) va = atoms.get_velocities() vamax = np.linalg.norm(va[3]*0.0982269353) #print vamax epot, ekin = saveAndPrint(atoms, traj, False)[:2] data[n] = [i*dt, i*dz, epot, ekin, epot + ekin, vamax] log_f = open(mdlogfile, 'a') stringi = '' for k,d in enumerate(data[n]): if k == 0: stringi += '%.2f ' %d elif k == 1: stringi += '%.6f ' %d else: stringi += '%.12f ' %d log_f.write(stringi + '\n') log_f.close() np.savetxt(mdlogfile, data, header = header) n += 1 if i%(int(M/100)) == 0: print 'ready = %.1f' %(i/(int(M/100))) + '%'
d = 2.934 for R in r0list: print 'radius',R name=(folder,'%.1f' %R) atoms = fcc111('Au',size=(2,2,1),a=sqrt(2)*d) L = atoms.get_cell().diagonal() atoms. set_cell(L) angle = L[1]/R atoms.rotate('y',pi/2) atoms.translate( (-atoms[0].x,0,0) ) atoms.translate((R,0,0)) atoms = Atoms(atoms=atoms,container='Wedge') atoms.set_container(angle=angle,height=L[0],physical=False,pbcz=True) calc = Hotbit(SCC=False,txt='%s/optimization_%s.cal' %name,kpts=(nk,1,nk),physical_k=False) atoms.set_calculator(calc) traj = PickleTrajectory( 'md_R%.3f-T%.0f.traj' %(R,T),'w',atoms) dyn = Langevin(atoms,dt*units.fs,units.kB*T,fric) dyn.attach(MDLogger(dyn, atoms, path + 'md_R%.3f-T%.0f.log' %(R,T), header=False, stress=False, peratom=True, mode="w"), interval = 1) dyn.run(mdsteps) cohesion = mean([atoms.get_potential_energy() for a in traj]) /len(atoms) savez('%s/data_%s.npz' %name,cohesion=cohesion) io.write('%s/extended_%s.traj' %name,atoms2)
epistemic = atoms.calc.results['epistemic'] / len(atoms) except: aleatoric = -1. epistemic = -1. print('%.4d Energy per atom: Epot = %.3feV Ekin = %.3feV (T=%3.0fK) ' 'Etot = %.3feV Alea = %.3feV Epis = %.3feV' % (step, epot, ekin, ekin / (1.5 * units.kB), epot + ekin, aleatoric, epistemic)) atoms.info['md_step'] += 1 # MD traj = Trajectory("Si.traj", 'w', struc) MaxwellBoltzmannDistribution(struc, temperature_K=temp + 50) # NVT dyn = Langevin(struc, timestep=1 * units.fs, temperature_K=temp, friction=0.08) # NPT #dyn = NPT(struc, 1. * units.fs, externalstress=0., ttime=1000*units.fs, pfactor=1000*units.fs, # temperature_K=300) dyn.attach(printenergy) dyn.attach(traj.write, interval=10) printenergy() dyn.run(steps) #for i in range(1000): # dyn.run(steps=steps) # PrintEnergy(struc, i) # save_to_ASE_db(struc, path=ase_db) #traj.close()
def sphereDynamics(R, T, params): d = params['d'] #2.934 nk = params['nk'] #20 fmax = params['fmax'] #1E-2 fric = params['fric'] #0.002 # equilibration time tau = 10 fs/fric (= mdsteps*dt) dt = params['dt'] #5.0 mdsteps = params['mdsteps'] #int(10/fric/dt) path = params['path'] #'/space/tohekorh/Au_bend/files/' uzsize = params['uz_size'] print 'radius',R name = '%.1f' %R # ATOMS #atoms = fcc111('Au',size=uzsize,a=np.sqrt(2)*d) atoms = get_opmAtomsFlat(T, params) atoms.rotate((0,0,1), -np.pi/6, rotate_cell = True) length1 = np.linalg.norm( atoms.get_cell()[0] ) length2 = np.linalg.norm( atoms.get_cell()[1] ) n1 = ( np.cos(np.pi/3), np.sin(np.pi/3), 0) n2 = (-np.cos(np.pi/3), np.sin(np.pi/3), 0) angle1 = length1/R angle2 = length2/R #view(atoms) # Scale the atoms close to ball Lx = np.linalg.norm(atoms.get_cell()[0] + atoms.get_cell()[1]) Ly = np.linalg.norm(atoms.get_cell()[0] - atoms.get_cell()[1]) phi_max = Ly/R theta_max = Lx/R for a in atoms: r0 = a.position phi = r0[1]/Ly*phi_max theta = r0[0]/Lx*theta_max a.position[0] = R*np.sin(theta) #*np.sin(theta) a.position[1] = R*np.sin(phi) #a.position[1] #R*np.sin(phi) #*np.sin(theta) a.position[2] = R*np.cos(theta) #atoms.translate((0,0,R)) # End scaling atoms = Atoms(atoms=atoms,container='Sphere') atoms.set_container(angle1=angle1,angle2=angle2,n1=n1,n2=n2,mode=4) #view(atoms.extended_copy((2,2,1))) # FOLDERS path_md = path + 'sphere/md_data/T=%.0f/' %T path_opm= path + 'sphere/opm/T=%.0f/' %T checkAndCreateFolder(path_md) checkAndCreateFolder(path_opm) # CALCULATOR calc = Hotbit(SCC=False, kpts=(nk,nk,1),txt= path_opm + 'optimization_%s.cal' %name,) atoms.set_calculator(calc) # RELAX opt = BFGS(atoms, trajectory= path_opm + 'optimization_%s.traj' %name) opt.run(fmax=fmax,steps=1000) #write(path_opm + 'opm_structure_R%.3f' %R, atoms, format='traj') # DYNAMICS traj = PickleTrajectory(path_md + 'md_R%.3f.traj' %R, 'w', atoms) dyn = Langevin(atoms, dt*units.fs, units.kB*T,fric) dyn.attach(MDLogger(dyn, atoms, path_md + 'md_R%.3f.log' %R, header=True, stress=False, peratom=True, mode="w"), interval = 1) dyn.attach(traj.write) dyn.run(mdsteps) traj.close() # load the dynamics back.. To write the extended trajectory traj = PickleTrajectory(path_md + 'md_R%.3f.traj' %R) trajToExtTraj(traj, (2, 2, 1), R, T, angle1, angle2, n1, n2, path)
def test(temp, frict): output = file('Langevin.dat', 'w') # Make a small perturbation of the momenta atoms.set_momenta(1e-6 * np.random.random([len(atoms), 3])) print 'Initializing ...' predyn = VelocityVerlet(atoms, 0.5) predyn.run(2500) dyn = Langevin(atoms, timestep, temp, frict) print '' print ('Testing Langevin dynamics with T = %f eV and lambda = %f' % (temp, frict)) ekin = atoms.get_kinetic_energy()/len(atoms) print ekin output.write('%.8f\n' % ekin) print 'Equilibrating ...' # Initial guesses for least-squares fit a = 0.04 b = 2*frict c = temp params = (a,b,c) fitdata = [(0, 2.0 / 3.0 * ekin)] tstart = time.time() for i in xrange(1,nequil+1): dyn.run(nminor) ekin = atoms.get_kinetic_energy() / len(atoms) fitdata.append((i*nminor*timestep, 2.0/3.0 * ekin)) if usescipy and i % nequilprint == 0: (params, chisq) = leastSquaresFit(targetfunc, params, fitdata) print '%.6f T_inf = %.6f (goal: %f), tau = %.2f, k = %.6f' % \ (ekin, params[2], temp, 1.0/params[1], params[0]) output.write('%.8f\n' % ekin) tequil = time.time() - tstart print 'This took %s minutes.' % (tequil / 60) output.write('&\n') assert abs(temp-params[2]) < 0.25*temp, 'Least-squares fit is way off' assert nequil*nminor*timestep > 3.0/params[1], 'Equiliberation was too short' fitdata = np.array(fitdata) print 'Recording statistical data - this takes ten times longer!' temperatures = [] tstart = time.time() for i in xrange(1,nsteps+1): dyn.run(nminor) ekin = atoms.get_kinetic_energy() / len(atoms) temperatures.append(2.0/3.0 * ekin) if i % nprint == 0: tnow = time.time() - tstart tleft = (nsteps-i) * tnow / i print '%.6f (time left: %.1f minutes)' % (ekin, tleft/60) output.write('%.8f\n' % ekin) output.write('&\n') output.close() temperatures = np.array(temperatures) mean = sum(temperatures) / len(temperatures) print 'Mean temperature:', mean, 'eV' print print 'This test is statistical, and may in rare cases fail due to a' print 'statistical fluctuation.' print assert abs(mean - temp) <= reltol*temp, 'Deviation is too large.' print 'Mean temperature:', mean, ' in ', temp, ' +/- ', reltol*temp return fitdata, params, temperatures
logFile.write(p + " ==> " + str(value) + "\n") logFile.close crack_pos = [] traj = NetCDFTrajectory('.simout/traj' + str(iteration) + '.nc', 'w', c) dyn.attach(traj.write, 10, dyn.atoms, arrays=['stokes', 'momenta']) dyn.attach(find_crack_tip, 10, dyn.atoms, dt=params.dt * 10, store=True, results=crack_pos) # run for 2000 time steps to reach steady state at initial load for i in range(20): dyn.run(100) if extend_strip(dyn.atoms, params.a, params.N, params.M, params.vacuum): set_constraints(dyn.atoms, params.a) # start decreasing strain #set_constraints(dyn.atoms, params.a, delta_strain=delta_strain) strain_atoms = ConstantStrainRate(dyn.atoms.info['OrigHeight'], delta_strain) dyn.attach(strain_atoms.apply_strain, 1, dyn.atoms) for i in range(50): dyn.run(100) if extend_strip(dyn.atoms, params.a, params.N, params.M, params.vacuum): set_constraints(dyn.atoms, params.a) del dyn.observers[-1] # stop increasing the strain
T = 1500 # Kelvin # Set up a crystal atoms = FaceCenteredCubic(directions=[[1,0,0],[0,1,0],[0,0,1]], symbol="Cu", size=(size,size,size), pbc=False) # Describe the interatomic interactions with the Effective Medium Theory atoms.set_calculator(EMT()) # We want to run MD with constant energy using the Langevin algorithm # with a time step of 5 fs, the temperature T and the friction # coefficient to 0.02 atomic units. dyn = Langevin(atoms, 5*units.fs, T*units.kB, 0.002) #Function to print the potential, kinetic and total energy. def printenergy(a=atoms): #store a reference to atoms in the definition. epot = a.get_potential_energy() / len(a) ekin = a.get_kinetic_energy() / len(a) print ("Energy per atom: Epot = %.3feV Ekin = %.3feV (T=%3.0fK) Etot = %.3feV" % (epot, ekin, ekin/(1.5*units.kB), epot+ekin)) dyn.attach(printenergy, interval=50) #We also want to save the positions of all atoms after every 100th time step. traj = PickleTrajectory("moldyn3.traj", 'w', atoms) dyn.attach(traj.write, interval=50) # Now run the dynamics printenergy() dyn.run(5000)
# Now let's set the calculator for ``atoms``: atoms.set_calculator(calculator) # Now let's minimize the structure: print("Begin minimizing...") opt = BFGS(atoms) opt.run(fmax=0.001) print() # Now create a callback function that print interesting physical quantities: def printenergy(a=atoms): """Function to print the potential, kinetic and total energy.""" epot = a.get_potential_energy() / len(a) ekin = a.get_kinetic_energy() / len(a) print('Energy per atom: Epot = %.3feV Ekin = %.3feV (T=%3.0fK) ' 'Etot = %.3feV' % (epot, ekin, ekin / (1.5 * units.kB), epot + ekin)) # We want to run MD with constant energy using the Langevin algorithm # with a time step of 1 fs, the temperature 300K and the friction # coefficient to 0.02 atomic units. dyn = Langevin(atoms, 1 * units.fs, 300 * units.kB, 0.2) dyn.attach(printenergy, interval=50) # Now run the dynamics: print("Beginning dynamics...") printenergy() dyn.run(500)
def runAndStudy(params_set, pot_key, save=False): bond = params_set['bond'] T = params_set['T'] taito = params_set['taito'] dt, fric = params_set['dt'], params_set['fric'] tau = params_set['tau'] width = params_set['width'] ratio = params_set['ratio'] edge = params_set['edge'] ncores = params_set['ncores'] Ld_i = params_set['Ldilde_i'] bend, straight, [matchL_idx, matchR_idx, vec], [L_bend, L_straight], [left_idxs, right_idxs]\ = create_bend_stucture(width, ratio, Ld_i, edge, bond) mdfile, mdlogfile, mdrelax, simulfile, folder, relaxed \ = get_fileName(pot_key, edge + '_corrStick', width, \ L_bend, L_straight, int(T), taito, key = 'corrStick') if relaxed: bend = PickleTrajectory(mdrelax, 'r')[-1] else: relaxBend(bend, left_idxs, right_idxs, edge, bond, mdrelax) bend.set_constraint([]) shift_v = -straight.positions[matchR_idx] + (bend.positions[matchL_idx] + vec) straight.translate(shift_v) atoms = bend + straight cell = [1.5 * (L_bend + L_straight), L_bend + L_straight, 20] atoms.set_cell(cell) atoms.positions[:, 2] = 3.4 trans_vec = trans_atomsKC(straight.positions[matchR_idx], edge, bond) atoms.translate(trans_vec) #plot_posits(atoms, edge, bond) if edge == 'ac': nx = int((cell[0] / 5 - np.min(atoms.positions[:, 0])) / (3 * bond)) ny = int((cell[1] / 5 - np.min(atoms.positions[:, 1])) / (np.sqrt(3) * bond)) atoms.translate([nx * 3. * bond, ny * np.sqrt(3) * bond, 0]) width_f = np.sqrt(3) / 2. * bond * (width - 1) elif edge == 'zz': nx = int((cell[0] / 5 - np.min(atoms.positions[:, 0])) / (np.sqrt(3) * bond)) ny = int((cell[1] / 5 - np.min(atoms.positions[:, 1])) / (3 * bond)) atoms.translate([nx * np.sqrt(3) * bond, ny * 3 * bond, 0]) width_f = (3. / 2. * width - 1) * bond cminx, cmaxx = strip_Hend(atoms, 'right') left_b = get_idxOfEnds(atoms, cminx, cmaxx)[0] # CONSTRAINTS constraints = [] constraints.append(FixAtoms(indices=left_b)) params = {} params['positions'] = atoms.positions params['chemical_symbols'] = atoms.get_chemical_symbols() params['ia_dist'] = 10 params['edge'] = edge params['bond'] = bond params['ncores'] = ncores add_pot = KC_potential_p(params) constraints.append(add_pot) atoms.set_constraint(constraints) ## # CALCULATOR calc = LAMMPS(parameters=get_lammps_params()) atoms.set_calculator(calc) ## # DYNAMICS dyn = Langevin(atoms, dt * units.fs, T * units.kB, fric) header = '#t [fs], shift y [Angstrom], Rad, theta [rad], hmax [A], epot_tot [eV], ekin_tot [eV], etot_tot [eV], F [eV/angst] \n' write_line_own(mdlogfile, header, 'w') traj = PickleTrajectory(mdfile, 'w', atoms) if T != 0: # put initial MaxwellBoltzmann velocity distribution mbd(atoms, T * units.kB) #### # SIMULATION PARAMS nframes = 1000 M = int(20 * tau / dt) interval = int(M / nframes) thres_cancel = 2 * bond stick = 'True' xmax_idx = np.where(atoms.positions[:, 0] == np.max(atoms.positions[:, 0]))[0][0] r_init = atoms.positions[xmax_idx].copy() R = L_bend / np.pi * 3. print '# data_line: width, length bend, length tail, tail/bend, theta' print width_f, L_bend, L_straight, L_straight / L_bend, width_f / (2 * R) # SIMULATION LOOP for i in range(nframes): print float(i) / nframes * 100. dyn.run(interval) epot, ekin = saveAndPrint(atoms, traj, False)[:2] data = [i * interval * dt, epot, ekin, epot + ekin] if save: stringi = '' for k, d in enumerate(data): if k == 0: stringi += '%.2f ' % d elif k == 1 or k == 2: stringi += '%.4f ' % d else: stringi += '%.12f ' % d write_line_own(mdlogfile, stringi + '\n', 'a') #print np.linalg.norm(atoms.positions[xmax_idx] - r_init) if thres_cancel < np.linalg.norm(atoms.positions[xmax_idx] - r_init): stick = 'false' break make_stick_simul_param_file(simulfile, width, L_bend, L_straight, T, \ dt, fric, interval, M, edge, stick) return stick == 'True'
from ase import units ccc = MyCalc(forces) atoms = Atoms( mol.element.tolist(), mol.coords.squeeze(), masses=mol.masses.tolist(), charges=mol.charge.tolist(), pbc=True, cell=mol.box.flatten(), calculator=ccc, ) dyn = Langevin(atoms, 2 * units.fs, units.kB * 300, 0.002) # dyn.run(1000) def printenergy(a): """Function to print the potential, kinetic and total energy""" epot = a.get_potential_energy() / len(a) ekin = a.get_kinetic_energy() / len(a) print("Energy per atom: Epot = %.3feV Ekin = %.3feV (T=%3.0fK) " "Etot = %.3feV" % (epot, ekin, ekin / (1.5 * units.kB), epot + ekin)) # Now run the dynamics printenergy(atoms) for i in range(20): dyn.run(10) printenergy(atoms)
def runAndStudy(params_set, pot_key, save = False): bond = params_set['bond'] T = params_set['T'] taito = params_set['taito'] dt, fric= params_set['dt'], params_set['fric'] tau = params_set['tau'] width = params_set['width'] ratio = params_set['ratio'] edge = params_set['edge'] ncores = params_set['ncores'] Ld_i = params_set['Ldilde_i'] bend, straight, [matchL_idx, matchR_idx, vec], [L_bend, L_straight], [left_idxs, right_idxs]\ = create_bend_stucture(width, ratio, Ld_i, edge, bond) mdfile, mdlogfile, mdrelax, simulfile, folder, relaxed \ = get_fileName(pot_key, edge + '_corrStick', width, \ L_bend, L_straight, int(T), taito, key = 'corrStick') if relaxed: bend = PickleTrajectory(mdrelax, 'r')[-1] else: relaxBend(bend, left_idxs, right_idxs, edge, bond, mdrelax) bend.set_constraint([]) shift_v = -straight.positions[matchR_idx] + (bend.positions[matchL_idx] + vec) straight.translate(shift_v) atoms = bend + straight cell = [1.5*(L_bend + L_straight), L_bend + L_straight, 20] atoms.set_cell(cell) atoms.positions[:,2] = 3.4 trans_vec = trans_atomsKC(straight.positions[matchR_idx], edge, bond) atoms.translate(trans_vec) #plot_posits(atoms, edge, bond) if edge == 'ac': nx = int((cell[0]/5 - np.min(atoms.positions[:,0]))/(3*bond)) ny = int((cell[1]/5 - np.min(atoms.positions[:,1]))/(np.sqrt(3)*bond)) atoms.translate([nx*3.*bond, ny*np.sqrt(3)*bond, 0]) width_f = np.sqrt(3)/2.*bond*(width - 1) elif edge == 'zz': nx = int((cell[0]/5 - np.min(atoms.positions[:,0]))/(np.sqrt(3)*bond)) ny = int((cell[1]/5 - np.min(atoms.positions[:,1]))/(3*bond)) atoms.translate([nx*np.sqrt(3)*bond, ny*3*bond, 0]) width_f = (3./2.*width - 1)*bond cminx, cmaxx = strip_Hend(atoms, 'right') left_b = get_idxOfEnds(atoms, cminx, cmaxx)[0] # CONSTRAINTS constraints = [] constraints.append(FixAtoms(indices = left_b)) params = {} params['positions'] = atoms.positions params['chemical_symbols'] = atoms.get_chemical_symbols() params['ia_dist'] = 10 params['edge'] = edge params['bond'] = bond params['ncores'] = ncores add_pot = KC_potential_p(params) constraints.append(add_pot) atoms.set_constraint(constraints) ## # CALCULATOR calc = LAMMPS(parameters=get_lammps_params()) atoms.set_calculator(calc) ## # DYNAMICS dyn = Langevin(atoms, dt*units.fs, T*units.kB, fric) header = '#t [fs], shift y [Angstrom], Rad, theta [rad], hmax [A], epot_tot [eV], ekin_tot [eV], etot_tot [eV], F [eV/angst] \n' write_line_own(mdlogfile, header, 'w') traj = PickleTrajectory(mdfile, 'w', atoms) if T != 0: # put initial MaxwellBoltzmann velocity distribution mbd(atoms, T*units.kB) #### # SIMULATION PARAMS nframes = 1000 M = int(20*tau/dt) interval = int(M/nframes) thres_cancel= 2*bond stick = 'True' xmax_idx = np.where(atoms.positions[:,0] == np.max(atoms.positions[:,0]))[0][0] r_init = atoms.positions[xmax_idx].copy() R = L_bend/np.pi*3. print '# data_line: width, length bend, length tail, tail/bend, theta' print width_f, L_bend, L_straight, L_straight/L_bend, width_f/(2*R) # SIMULATION LOOP for i in range(nframes): print float(i)/nframes*100. dyn.run(interval) epot, ekin = saveAndPrint(atoms, traj, False)[:2] data = [i*interval*dt, epot, ekin, epot + ekin] if save: stringi = '' for k,d in enumerate(data): if k == 0: stringi += '%.2f ' %d elif k == 1 or k == 2: stringi += '%.4f ' %d else: stringi += '%.12f ' %d write_line_own(mdlogfile, stringi + '\n', 'a') #print np.linalg.norm(atoms.positions[xmax_idx] - r_init) if thres_cancel < np.linalg.norm(atoms.positions[xmax_idx] - r_init): stick = 'false' break make_stick_simul_param_file(simulfile, width, L_bend, L_straight, T, \ dt, fric, interval, M, edge, stick) return stick == 'True' #plot_posits(atoms, edge, bond) #view(atoms)
bottom_mask = np.loadtxt("bottom_mask.txt").astype(bool) top_mask = np.loadtxt("top_mask.txt").astype(bool) damp = pc.AutoDamping(C11, p_c) slider = pc.SlideWithNormalPressureCuboidCell(top_mask, bottom_mask, Pdir, P, vdir, v, damp) atoms.set_constraint(slider) calc = ASE_CALCULATOR_OBJECT # put a specific calculator here atoms.set_calculator(calc) temps = np.zeros((len(atoms), 3)) temps[slider.middle_mask, slider.Tdir] = kB * T gammas = np.zeros((len(atoms), 3)) gammas[slider.middle_mask, slider.Tdir] = gamma_langevin integrator = Langevin(atoms, dt, temps, gammas, fixcm=False) trajectory = Trajectory('slide.traj', 'a', atoms) # append with open('log_slide.txt', 'r', encoding='utf-8') as log_handle: step_offset = pc.SlideLog(log_handle).step[-1] log_handle = open('log_slide.txt', 'a', 1, encoding='utf-8') # line buffered append logger = pc.SlideLogger(log_handle, atoms, slider, integrator, step_offset) integrator.attach(logger) integrator.attach(trajectory) integrator.run(steps_integrate) log_handle.close() trajectory.close()
epistemic = atoms.calc.results['epistemic'] / len(atoms) except: aleatoric = -1. epistemic = -1. print('%.4d Energy per atom: Epot = %.3feV Ekin = %.3feV (T=%3.0fK) ' 'Etot = %.3feV Alea = %.3feV Epis = %.3feV' % (step, epot, ekin, ekin / (1.5 * units.kB), epot + ekin, aleatoric, epistemic)) atoms.info['md_step'] += 1 # MD traj = Trajectory("Si.traj", 'w', struc) MaxwellBoltzmannDistribution(struc, temperature_K=temp + 50) # NVT dyn = Langevin(struc, timestep=1 * units.fs, temperature_K=temp, friction=0.08) # NPT #dyn = NPT(struc, 1. * units.fs, externalstress=0., ttime=1000*units.fs, pfactor=1000*units.fs, # temperature_K=300) #dyn.attach(printenergy) dyn.attach(traj.write, interval=10) #printenergy() #dyn.run(steps) for i in range(1000): dyn.run(steps=10) PrintEnergy(struc) save_to_ASE_db(struc, path=ase_db) traj.close()
' ' + str(epot) + ' ' + str(ekin) + ' ' + str(epot + ekin) + '\n') b.write('\n' + str(len(a)) + '\n') for i in a: b.write( str(i.symbol) + ' ' + str(i.x) + ' ' + str(i.y) + ' ' + str(i.z) + '\n') dyn.attach(printenergy, interval=10) #dyn.attach(MDLogger(dyn, bz, 'bz_md_NVT_10ps_1fs.log', header=True, stress=False, # peratom=False, mode="w"), interval=50) #printenergy() start_time = time.time() dyn.run(2**20) # Do 1ns of MD print('[ANI Total time:', time.time() - start_time, 'seconds]') ''' C = 2.99792E+8 t = 0.25E-15 M = 1.0E+10 distCH = np.array(distCH) distCH = distCH - distCH.mean() dfftCH = np.fft.rfft(distCH) freqCH = (np.fft.rfftfreq(distCH.shape[-1])) print("Shape1: ", len(distCH)," Shape2:", dfftCH.shape," Shape3:", freqCH.shape) distCC = np.array(distCC) distCC = distCC - distCC.mean()
def cylinderDynamics(R, T, params): nk = params['nk'] #20 fmax = params['fmax'] #1E-2 fric = params['fric'] #0.002 dt = params['dt'] #5.0 mdsteps = params['mdsteps'] #int(10/fric/dt) path = params['path'] #'/space/tohekorh/Au_bend/files/' print 'radius',R, '\n' name = '%.1f' %R # Get the optimal flat atoms , unit-cell config for this temperature: atoms = get_opmAtomsFlat(T, params) # Take the diagonal of the cell: L = atoms.get_cell().diagonal() atoms.set_cell(L) # The wedge angle is: angle = L[1]/R # fiddle with atoms: atoms.rotate('y', np.pi/2) atoms.translate((-atoms[0].x, 0, 0) ) #view(atoms) # Initial map for atoms, to get the on surface of cylinder: phi_max = angle for a in atoms: r0 = a.position phi = r0[1]/L[1]*phi_max a.position[0] = R*np.cos(phi) a.position[1] = R*np.sin(phi) #view(atoms) # proper number of kappa points in angle direction, if angle >= 2*pi/3 the use genuine # physical boundary conditions and proper kappa-points. With 64 atoms in unit cell souhld not # happen as the radius -> very small if angle = 2*pi/3 or larger. # Check that the unit-cell angle is 2*pi/integer. This can be removed! if (2*np.pi/angle)%1 > 0: raise # This does not have any effect unless angle >= 2*pi/3: m = int(round(2*np.pi/angle)) physical = False if m <= 3: nk1 = m physical = True else: nk1 = nk # Set up the wedge container: atoms = Atoms(atoms = atoms, container = 'Wedge') atoms.set_container(angle = angle, height = L[0], physical = physical, pbcz = True) # Check that everything looks good: #view(atoms.extended_copy((2,1,2))) # FOLDERS path_opm = path + 'cylinder/opm/T=%.0f/' %T path_md = path + 'cylinder/md_data/T=%.0f/' %T checkAndCreateFolder(path_opm) checkAndCreateFolder(path_md) # CALCULATOR calc = Hotbit(SCC=False, kpts=(nk1, 1, nk), physical_k = physical, \ txt= path_opm + 'optimization_%s.cal' %name) atoms.set_calculator(calc) # RELAX opt = BFGS(atoms, trajectory= path_opm + 'optimization_%s.traj' %name) opt.run(fmax=fmax, steps=1000) # DYNAMICS traj = PickleTrajectory(path_md + 'md_R%.3f.traj' %R,'w',atoms) # Perform dynamics dyn = Langevin(atoms, dt*units.fs, units.kB*T, fric) dyn.attach(MDLogger(dyn, atoms, path_md + 'md_R%.3f.log' %R, header=True, stress=False, peratom=True, mode="w"), interval = 1) dyn.attach(traj.write) dyn.run(mdsteps) traj.close() # load the dynamics back, to make exteded trajectory: traj = PickleTrajectory(path_md + 'md_R%.3f.traj' %R) trajToExtTraj(traj, (2, 1, 2), R, T, angle, L[0], path)