def InitSystem(Natoms):
NeighborsList = hoomd.md.nlist.cell()
mypot = "KAshort" if Natoms < 500 else "KA"
potential = pot.LJ(NeighborsList, type=mypot)
analyzer = hoomd.analyze.log(filename=None,
quantities=[
'temperature', 'potential_energy',
'kinetic_energy', 'momentum'
],
period=None,
header_prefix='#',
overwrite=True,
phase=0)
return potential, analyzer
def CalculateRidge(snapT1, snapT2, Eis1, Eis2, L):
''' Calculates energy at the ridge between two snapshots '''
print("--- Calculate Ridge ---\n- Eis1:",Eis1,' Eis2:',Eis2)
dmax=0.0001 #0.004 is about the typical distance between confs at subsequent time steps with dt=0.0025
nsteps=1
niter=10000
snapT1.particles.velocity[:]=np.zeros((Natoms, 3))
snapT2.particles.velocity[:]=np.zeros((Natoms, 3))
#snapis are not inherent structures, but the gradually approach them
snapis1,snapis2,snapis12,Eis1,Eis2,Eis12,dist12=ConfBisect(snapT1, snapT2, Eis1, Eis2, L, dmax=dmax)
print("- Eis1=%.8f;\tEis2= %.8f (after ConfBisect)"%(Eis1,Eis2))
context1 = hoomd.context.SimulationContext();
with context1:
system1 = hoomd.init.read_snapshot(snapis1)
modeFire1=md.integrate.mode_minimize_fire(dt=dtFIRE, alpha_start=alphaFIRE, ftol=ftolFIRE, Etol=EtolFIRE, wtol=wtolFIRE)
integrator1 = md.integrate.nve(group=hoomd.group.all())
analyzerFire1=SetupAnalyzer(logname=None, period='None')
md.update.zero_momentum(phase=2, period=10)
pair=pot.LJ(md.nlist.cell(),type="KAshort")
context2 = hoomd.context.SimulationContext();
with context2:
system2 = hoomd.init.read_snapshot(snapis2)
modeFire2=md.integrate.mode_minimize_fire(dt=dtFIRE, alpha_start=alphaFIRE, ftol=ftolFIRE, Etol=EtolFIRE, wtol=wtolFIRE)
integrator2 = md.integrate.nve(group=hoomd.group.all())
analyzerFire2=SetupAnalyzer(logname=None, period='None')
md.update.zero_momentum(phase=2, period=10)
pair=pot.LJ(md.nlist.cell(),type="KAshort")
modeFire1.reset()
modeFire2.reset()
for iter in range(niter):
with context1:
system1.restore_snapshot(snapis1)
hoomd.run(nsteps)
eis1=analyzerFire1.query('potential_energy')
snapis1=system1.take_snapshot(dtype='double')
with context2:
system2.restore_snapshot(snapis2)
hoomd.run(nsteps)
eis2=analyzerFire2.query('potential_energy')
snapis2=system2.take_snapshot(dtype='double')
dist12=med.PeriodicDistance(snapis1.particles.position, snapis2.particles.position, L).sum()/Natoms
print("iter: ",iter," dist12=",dist12,"eis1: %.14f"%eis1," eis2: %.14f"%eis2)
if dist12>dmax:
'''
With the linear interpolations the found barrier is occasionally lower than one of the ISs, because of nonlinearities in the path.
# snapRidge=LinearConfInterpolation(snapis1_old, snapis2_old, L)
# Eridge=potential.CalculateEnergySlower(snapRidge)
For this reason, I just take the energy of one of the two confs at the previous step.
'''
if eis1>eis2:
Eridge=ConsistentRidge(eis1_old,Eis1,Eis2,args.deltaE)
snapRidge=snapis1_old
else :
Eridge=ConsistentRidge(eis2_old,Eis1,Eis2,args.deltaE)
snapRidge=snapis2_old
print("Eridge = ",Eridge)
break
snapis1_old=snapis1
snapis2_old=snapis2
eis1_old=eis1
eis2_old=eis2
if iter==niter-1: sys.exit('CalculateRidge did not converge after '+str(niter)+' steps')
return Eridge,snapRidge
# ################################################################ system = hoomd.init.read_gsd(filename=filename) snapT_old=system.take_snapshot() snapT_old.particles.position[:]=posizioni[0] snapT_old.particles.velocity[:] = np.zeros((Natoms,3)) snapT=system.take_snapshot() snapT.particles.velocity[:] = np.zeros((Natoms,3)) ################################################################ # # Set potential and analyzer # ################################################################ NeighborsList = md.nlist.cell() potential=pot.LJ(NeighborsList,type="KAshort") analyzer_quantities = ['temperature', 'pressure', 'potential_energy', 'kinetic_energy', 'momentum'] #, 'volume', 'num_particles'] analyzer = hoomd.analyze.log(filename=None, quantities=analyzer_quantities, period=None) ################################################################ # # Functions # ################################################################ def Minimize(snap): system.restore_snapshot(snap) fire.cpp_integrator.reset() if not integrator_fire.enabled: integrator_fire.enable() while not(fire.has_converged()):
#If it's the first chunk, there is no list of energies.
#Otherwise, we open it and make sure that the time step is consistent.
if(ichunk>0):
elist_old=np.loadtxt('elistIS.txt',skiprows=skiprows)
assert(int(elist_old[len(elist_old)-1][0])==t0-1)
################################################################
#
# Set potential
#
################################################################
NeighborsListLJ = md.nlist.cell()
print(" *** KApotentialShort *** ")
potential=pot.LJ(NeighborsListLJ,type="KAshort") #myLJpair is now an attribute of potential. To call it: potential.GetLJpair()
################################################################
#
# Set analyzer
#
################################################################
print("\n\n\nSET UP ANALYZER\n")
analyzer_quantities = ['temperature', 'pressure', 'potential_energy', 'kinetic_energy', 'momentum'] #, 'volume', 'num_particles']
analyzer = hoomd.analyze.log(filename=None, quantities=analyzer_quantities, period=1)
################################################################
#
# Function declaration
F[t]=np.array(snap.particles.acceleration[:],dtype=np.float64)
return
################################################################
# OBSERVABLES
################################################################
P=np.ndarray( (args.Ntraj, Natoms, 3), dtype=np.float64)
F=np.ndarray( (args.Ntraj, Natoms, 3), dtype=np.float64)
################################################################
# INTEGRATE
################################################################
NeighborsList = md.nlist.cell()
potential=pot.LJ(NeighborsList,type="LJmono")
modeT=md.integrate.mode_standard(dt=args.dt)
md.update.zero_momentum(phase=0, period=int(1./args.dt))
#Thermalize
extraThermalizing=False
if extraThermalizing:
print('Thermalizing with NVT')
integratorNVT = md.integrate.nvt(group=hoomd.group.all(), kT=args.temperature, tau=args.tauT)
hoomd.run(int(10./args.dt), quiet=False)
hoomd.dump.gsd(filename='./sample-states/rotenberg.gsd', overwrite=True, truncate=True, period=None, time_step=0, group=hoomd.group.all())
integratorNVT.disable()
#The trajectory
print('Measurement trajectory')
system = hoomd.init.read_gsd(filename=filename,
restart=backupname,
frame=iframe)
assert (Natoms == len(system.particles))
iniStep = hoomd.get_step()
print("iframe: ", iframe)
print("Initial step: ", iniStep)
################################################################
#
# SET UP POTENTIAL
#
################################################################
NeighborsList = md.nlist.cell()
if Natoms < 500:
myLjPair = pot.LJ(NeighborsList, type="KAshort")
else:
myLjPair = pot.LJ(NeighborsList, type="KA")
################################################################
#
# SET UP ANALYZER
#
################################################################
print("\n\n\nSET UP ANALYZER\n")
#Name of the log
logname = label + ".txt"
#These are the observables we want to log
analyzerManyVariables_quantities = [
snap=system.take_snapshot()
P[t]=np.array(snap.particles.velocity[:],dtype=np.float64)
F[t]=np.array(snap.particles.acceleration[:],dtype=np.float64)
return
################################################################
# OBSERVABLES
################################################################
P=np.ndarray( (args.Ntraj, Natoms, 3), dtype=np.float64)
F=np.ndarray( (args.Ntraj, Natoms, 3), dtype=np.float64)
################################################################
# INTEGRATE
################################################################
NeighborsList = md.nlist.cell()
potential=pot.LJ(NeighborsList,type="KA") if Natoms > 500 else pot.LJ(NeighborsList,type="KAshort")
modeT=md.integrate.mode_standard(dt=args.dt)
md.update.zero_momentum(phase=0, period=int(1./args.dt))
#Thermalize
if args.extraThermalizing:
print('Thermalizing with NVT')
integratorNVT = md.integrate.nvt(group=hoomd.group.all(), kT=args.temperature, tau=args.tauT)
hoomd.run(int(10./args.dt), quiet=False)
hoomd.dump.gsd(filename='./sample-states/rotenbergKA_T'+str(args.temperature)+'_N'+str(Natoms)+'.gsd', overwrite=True, truncate=True, period=None, time_step=0, group=hoomd.group.all())
integratorNVT.disable()
#The trajectory
print('Measurement trajectory')
'The two configurations do not have the same particle indices')
#Same space dimensionality
if snap.box.dimensions != s2.configuration.dimensions:
raise ValueError(
'The two configurations live in different spatial dimensions (%d and %d)'
% (snap.box.dimensions, s2.configuration.dimensions))
#Same box size
if L == s2.configuration.box[0] == False:
raise ValueError(
'Either the two boxes are different (Lx1=%g and Lx2=%g), or you should make a decent floating point comparison'
% (snap.box.Lx, s2.configuration.box[0]))
#Neighborlist, Potential and Analyzer
NeighborsList = md.nlist.cell()
mypot = "KAshort" if Natoms < 500 else "KA"
potential = pot.LJ(NeighborsList, type=mypot)
analyzer = hoomd.analyze.log(filename=None,
quantities=[
'temperature', 'potential_energy',
'kinetic_energy', 'momentum'
],
period=None,
header_prefix='#',
overwrite=True,
phase=0)
def Minimize(snap):
system.restore_snapshot(snap)
fire.cpp_integrator.reset()
while not (fire.has_converged()):
return snap1, snap2, snap12, eis1, eis2, eis12, dist12
################################################################
#
# INITIALIZE
#
################################################################
backupname = label + "_backup.gsd"
simT = hoomd.context.SimulationContext()
simIS = hoomd.context.SimulationContext()
with simT:
systemT = hoomd.init.read_gsd(filename=filename, restart=None)
assert (Natoms == len(systemT.particles))
myLjPair = pot.LJ(md.nlist.cell(), type="KAshort")
analyzerStandard = SetupAnalyzer(logname=None, period=None)
modeStandard = md.integrate.mode_standard(dt=dt)
md.update.zero_momentum(phase=2, period=10)
integrator = md.integrate.nvt(group=hoomd.group.all(),
kT=temperature,
tau=tauT)
hoomd.run(5 / dt)
snapT = systemT.take_snapshot(dtype='double')
boxParamsT = snapT.box
with simIS:
systemIS = hoomd.init.read_gsd(filename=filename, restart=None)
assert (Natoms == len(systemIS.particles))
myLjPair = pot.LJ(md.nlist.cell(), type="KAshort")
analyzerFire = SetupAnalyzer(logname=None, period='None')
def InitPotential(self): self.NeighborsList = md.nlist.cell() if self.params.Natoms<500: assert(self.params.potential=='KAshort') self.pair=pot.LJ(self.NeighborsList, type=self.params.potential) return
context = hoomd.context.initialize()
#PARAMETERS
T = 2.0
Natoms = 1080
maindir = '../../OUTPUT/T' + str(T) + '/N' + str(Natoms) + '/'
samples = range(10)
nsamples = len(samples)
EPS = 1e-8
#READ THERMALIZED SYSTEM (for copying particle types and creating snapshots) AND POTENTIAL
sam = 0
system = hoomd.init.read_gsd(filename=maindir + '/S' + str(sam) +
'/thermalized.gsd')
L = system.box.Lx
pair = pot.LJ(md.nlist.cell(), type='KAshort')
#READ HEAVY TRAJECTORY
#Make sure that L and dt are consistent
for isam in range(nsamples):
sam = samples[isam]
name = maindir + '/S' + str(sam) + '/heavyTraj/L.txt'
f = open(name, 'rt')
Ltemp = np.float64(f.readline())
if 0 == isam:
dt = np.float64(f.readline())
else:
dttemp = np.float64(f.readline())
if np.abs(dt - dttemp) > EPS:
raise ValueError(