def getCurrentFreeEnergy(self):
self.colvars_FreeE = -self.p["kb"] * self.p["temperature"] * np.log(
self._probability())
self.colvars_FreeE[np.isneginf(
self.colvars_FreeE)] = 0.0 # deal with -inf
self.colvars_FreeE[np.isinf(
self.colvars_FreeE)] = 0.0 # deal with inf
self.colvars_FreeE = paddingRightMostBin(self.colvars_FreeE)
def getCurrentFreeEnergy(self):
if self.p["nnCheckFlag"] == "no":
self.colvars_force_tmp = copy.deepcopy(self.colvars_force /
self.colvars_count)
self.colvars_force_tmp[np.isnan(self.colvars_force_tmp)] = 0
self.colvars_force_tmp = paddingRightMostBin(
self.colvars_force_tmp)
else:
self.colvars_force_tmp = copy.deepcopy(self.colvars_force_NN)
self.colvars_force_tmp[np.isnan(self.colvars_force_tmp)] = 0
self.colvars_force_tmp = paddingRightMostBin(
self.colvars_force_tmp)
self.colvars_FreeE = integrator(self.p["ndims"], self.colvars_coord,
self.colvars_force_tmp,
self.p["half_boxboundary"],
self.p["init_frame"],
self.p["shiftConst"], "tempFreeE.dat")
def _learningProxy(self):
if self.p["nnCheckFlag"] == "yes":
output = trainingANN("loss.dat", "hyperparam.dat", self.p["ndims"],
len(self.bins))
self.colvars_force = (self.colvars_force / self.colvars_count)
self.colvars_force[np.isnan(
self.colvars_force)] = 0 # 0/0 = nan n/0 = inf
self.colvars_force = paddingRightMostBin(self.colvars_force)
if self.p["init_frame"] < self.p["earlyStopCheck"] * self.p[
"switchSteps"]:
self.colvars_force_NN = \
output.training(self.colvars_coord, self.colvars_force, self.p["earlyLearningRate"], self.p["earlyRegularCoeff"], self.p["earlyEpoch"], self.p["nnOutputFreq"])
else:
self.colvars_force_NN = \
output.training(self.colvars_coord, self.colvars_force, self.p["lateLearningRate"], self.p["lateRegularCoeff"], self.p["lateEpoch"], self.p["nnOutputFreq"])
self.colvars_force = (self.colvars_force * self.colvars_count)
def mdrun(self):
init_real_world_time = time.time()
# PRE-PROCESSING
lammpstrj = open(
"m%.1f_T%.3f_gamma%.4f_len_%d_%s_%s.lammpstrj" %
(self.p["mass"], self.p["temperature"], self.p["frictCoeff"],
self.p["total_frame"], self.p["abfCheckFlag"],
self.p["nnCheckFlag"]), "w")
forceOnCVs = open(
"Force_m%.1fT%.3f_gamma%.4f_len_%d_%s_%s.dat" %
(self.p["mass"], self.p["temperature"], self.p["frictCoeff"],
self.p["total_frame"], self.p["abfCheckFlag"],
self.p["nnCheckFlag"]), "w")
histogramOnCVs = open(
"Hist_m%.1fT%.3f_gamma%.4f_len_%d_%s_%s.dat" %
(self.p["mass"], self.p["temperature"], self.p["frictCoeff"],
self.p["total_frame"], self.p["abfCheckFlag"],
self.p["nnCheckFlag"]), "w")
withANN = open("instantForceWANN_" + str(self.p["ndims"]) + "D.dat",
"a")
woANN = open("instantForceWOANN_" + str(self.p["ndims"]) + "D.dat",
"a")
earlyFreeE = open("earlyFreeE.dat", "a")
FinalFE = open("FreeE.dat", "w")
# START of the simulation
self.IO.writeParams(self.p)
self.IO.lammpsFormatColvarsOutput(self.p["ndims"], self.p["nparticle"],
self.p["half_boxboundary"],
self.p["init_frame"],
self.current_coord, lammpstrj,
self.p["writeFreq"])
self.IO.printCurrentStatus(self.p["init_frame"], init_real_world_time)
while self.p["init_frame"] < self.p["total_frame"]:
self.p["init_frame"] += 1
self.IO.printCurrentStatus(self.p["init_frame"],
init_real_world_time)
self.mdInitializer.checkTargetTemperature(self.current_vel,
self.p["init_frame"],
self.p["total_frame"])
if self.p["init_frame"] % self.p["earlyStopCheck"] == 0 and self.p[
"init_frame"] != 0 and self.p["abfCheckFlag"] == "yes":
self.criteriaCounter += 1
self._criteriaModCurr()
if self._criteriaCheck(self.criteria_hist, self.criteria_prev,
self.criteria_curr,
self.p["trainingCriteria"]):
if self.p["nnCheckFlag"] == "no":
self.getCurrentFreeEnergy()
self.IO.certainFrequencyOutput(self.colvars_coord,
self.colvars_FreeE,
self.colvars_hist,
self.p["init_frame"],
earlyFreeE)
self.temp = paddingRightMostBin(self.colvars_force /
self.colvars_count)
self.IO.certainFrequencyOutput(self.colvars_coord,
self.temp,
self.colvars_count,
self.p["init_frame"],
woANN)
else:
self._learningProxy()
self.getCurrentFreeEnergy()
self.IO.certainFrequencyOutput(self.colvars_coord,
self.colvars_FreeE,
self.colvars_hist,
self.p["init_frame"],
earlyFreeE)
self.IO.certainFrequencyOutput(self.colvars_coord,
self.colvars_force_NN,
self.colvars_count,
self.p["init_frame"],
withANN)
# retrieve FE
if self.criteriaFEBool % 2 == 0:
self.colvars_FreeE_prev = copy.deepcopy(
self.colvars_FreeE)
else:
self.colvars_FreeE_curr = copy.deepcopy(
self.colvars_FreeE)
self.criteriaFEBool += 1
# To clean invalid data (inf, nan), we let some data == 0, this would cause issues when evaluating criteria, so we should at least do twice
if self._criteriaCheck(
self.criteria_FreeE, self.colvars_FreeE_prev,
self.colvars_FreeE_curr, self.p["simlEndCriteria"]
) and self.criteriaFEBool >= 2:
break
# retrieve FE
if self.criteriaCounter > 1:
self._criteriaModPrev()
self.mdInitializer.velocityVerletSimple(self.current_coord,
self.current_vel)
self._accumulateColvarsHist()
self.IO.lammpsFormatColvarsOutput(self.p["ndims"],
self.p["nparticle"],
self.p["half_boxboundary"],
self.p["init_frame"],
self.current_coord, lammpstrj,
self.p["writeFreq"])
# END of the simulation
# POST-PROCESSING
probability = copy.deepcopy(
(self.colvars_hist / np.sum(self.colvars_hist)))
probability = paddingRightMostBin(probability)
self.IO.propertyOnColvarsOutput(self.bins, probability,
self.colvars_hist, histogramOnCVs)
self.IO.propertyOnColvarsOutput(self.bins, self.colvars_FreeE,
self.colvars_hist, FinalFE)
if self.p["nnCheckFlag"] == "yes":
self.IO.propertyOnColvarsOutput(self.bins, self.colvars_force_NN,
self.colvars_count, forceOnCVs)
else:
self.colvars_force = (self.colvars_force / self.colvars_count)
self.colvars_force[np.isnan(self.colvars_force)] = 0
self.colvars_force = paddingRightMostBin(self.colvars_force)
self.IO.propertyOnColvarsOutput(self.bins, self.colvars_force,
self.colvars_count, forceOnCVs)
# ndims >= 2 -> plot using matplotlib
if self.p["ndims"] == 2:
s = rendering(self.p["ndims"], self.p["half_boxboundary"],
self.p["binNum"], self.p["temperature"])
s.render(
probability,
name=str(self.p["abfCheckFlag"] + "_" + self.p["nnCheckFlag"] +
"_" + "boltzDist" + str(self.p["ndims"]) + "D"))
s.render(
self.colvars_FreeE,
name=str(self.p["abfCheckFlag"] + "_" + self.p["nnCheckFlag"] +
"_" + "FEsurface" + str(self.p["ndims"]) + "D"))
if self.p["nnCheckFlag"] == "yes":
try:
s.render(self.colvars_force_NN[0],
name=str(self.p["abfCheckFlag"] + "_" +
self.p["nnCheckFlag"] + "_" + "forcex" +
str(self.p["ndims"]) + "D"))
s.render(self.colvars_force_NN[1],
name=str(self.p["abfCheckFlag"] + "_" +
self.p["nnCheckFlag"] + "_" + "forcey" +
str(self.p["ndims"]) + "D"))
except: # no chance to train
pass
else:
s.render(self.colvars_force[0],
name=str(self.p["abfCheckFlag"] + "_" +
self.p["nnCheckFlag"] + "_" + "forcex" +
str(self.p["ndims"]) + "D"))
s.render(self.colvars_force[1],
name=str(self.p["abfCheckFlag"] + "_" +
self.p["nnCheckFlag"] + "_" + "forcey" +
str(self.p["ndims"]) + "D"))
# Close files, mkdir and mv files
self.IO.closeAllFiles(lammpstrj, forceOnCVs, histogramOnCVs, withANN,
woANN, earlyFreeE, FinalFE)
self.IO.makeDirAndMoveFiles(self.p["ndims"], self.p["mass"], self.p["temperature"], self.p["frictCoeff"], self.p["total_frame"],\
self.p["abfCheckFlag"], self.p["nnCheckFlag"], __class__.__name__)
def integrator(ndims, cv, force, half_boxboundary, frame, shiftConst, outputfile):
cv = np.array(cv)
force = np.array(force)
intg_interval = abs(cv[0] - cv[1])
if ndims == 1:
accIntg = 0
FE = np.zeros(force.shape[0])
factor = intg_interval * 0.5
for i in range(len(force) - 1):
accIntg -= (force[i] + force[i+1]) # freeE = -Sf(x)dx
FE[i] = accIntg * factor
FE += shiftConst
FE = paddingRightMostBin(FE)
with open(outputfile, "a") as fout:
fout.write("#" + " " + str(frame) + "\n")
for i, j in zip(cv, FE):
fout.write(str(i) + " " + str(j) + "\n")
fout.write("\n")
#---------------------------------------------------------------------#
if ndims == 2:
factor = intg_interval * 0.5
FE_X = 0
FE_Y = 0
acc_at_x = np.zeros((force.shape[1]))
acc_at_y = np.zeros((force.shape[1], force.shape[2]))
FE = np.zeros((force.shape[1], force.shape[2]))
for i in range(force.shape[1] - 1):
FE_X = (force[0][i][0] + force[0][i+1][0])
acc_at_x[i] -= FE_X
for j in range(force.shape[2]- 1):
FE_Y -= (force[1][i][j] + force[1][i][j+1])
acc_at_y[i][j] = FE_Y
FE_Y = 0
acc_at_x = np.append(acc_at_x, acc_at_x[-1])
for i in range(force.shape[1]):
for j in range(force.shape[2]):
FE[i][j] = (acc_at_x[i] + acc_at_y[i][j]) * factor
FE += shiftConst
FE = paddingRightMostBin(FE)
with open(outputfile, "a") as fout:
fout.write("#" + " " + str(frame) + "\n")
for i in range(force.shape[1]):
for j in range(force.shape[2]):
fout.write(str(cv[i]) + " ")
fout.write(str(cv[j]) + " " + str(FE[i][j]) + "\n")
fout.write("\n")
s = rendering(ndims, half_boxboundary, force.shape[1] - 1)
s.render(FE, name="FreeE_2D")
return FE
def mdrun(self):
init_real_world_time = time.time()
# PRE-PROCESSING
lammpstrj = open(
"m%.1f_T%.3f_gamma%.4f_len_%d_%s_%s.lammpstrj" %
(self.p["mass"], self.p["temperature"], self.p["frictCoeff"],
self.p["total_frame"], self.p["abfCheckFlag"],
self.p["nnCheckFlag"]), "w")
forceOnCVs = open(
"Force_m%.1fT%.3f_gamma%.4f_len_%d_%s_%s.dat" %
(self.p["mass"], self.p["temperature"], self.p["frictCoeff"],
self.p["total_frame"], self.p["abfCheckFlag"],
self.p["nnCheckFlag"]), "w")
histogramOnCVs = open(
"Hist_m%.1fT%.3f_gamma%.4f_len_%d_%s_%s.dat" %
(self.p["mass"], self.p["temperature"], self.p["frictCoeff"],
self.p["total_frame"], self.p["abfCheckFlag"],
self.p["nnCheckFlag"]), "w")
withANN = open("instantForceWANN_" + str(self.p["ndims"]) + "D.dat",
"a")
woANN = open("instantForceWOANN_" + str(self.p["ndims"]) + "D.dat",
"a")
# START of the simulation
self.IO.writeParams(self.p)
self.IO.lammpsFormatColvarsOutput(self.p["ndims"], self.p["nparticle"],
self.p["half_boxboundary"],
self.p["init_frame"],
self.current_coord, lammpstrj,
self.p["writeFreq"])
self.IO.printCurrentStatus(self.p["init_frame"], init_real_world_time)
while self.p["init_frame"] < self.p["total_frame"]:
self.p["init_frame"] += 1
self.IO.printCurrentStatus(self.p["init_frame"],
init_real_world_time)
self.mdInitializer.checkTargetTemperature(self.current_vel,
self.p["init_frame"],
self.p["total_frame"])
if self.p["init_frame"] % self.p["trainingFreq"] == 0 and self.p[
"init_frame"] != 0 and self.p[
"abfCheckFlag"] == "yes" and self.p[
"nnCheckFlag"] == "yes":
self._learningProxy()
self.colvars_force = (self.colvars_force / self.colvars_count)
self.colvars_force[np.isnan(self.colvars_force)] = 0
self.IO.certainFrequencyOutput(self.colvars_coord,
self.colvars_force_NN,
self.colvars_count,
self.p["init_frame"],
self.p["certainOutFreq"],
withANN)
self.IO.certainFrequencyOutput(self.colvars_coord,
self.colvars_force,
self.colvars_count,
self.p["init_frame"],
self.p["certainOutFreq"], woANN)
self.colvars_force = (self.colvars_force * self.colvars_count)
if self.p["init_frame"] % self.p["certainOutFreq"] == 0 and self.p[
"init_frame"] != 0 and self.p["nnCheckFlag"] == "no":
self.colvars_force = (self.colvars_force / self.colvars_count)
self.colvars_force[np.isnan(self.colvars_force)] = 0
self.IO.certainFrequencyOutput(self.colvars_coord,
self.colvars_force,
self.colvars_count,
self.p["init_frame"],
self.p["certainOutFreq"], woANN)
self.colvars_force = (self.colvars_force * self.colvars_count)
self.mdInitializer.velocityVerletSimple(self.current_coord,
self.current_vel)
self.IO.lammpsFormatColvarsOutput(self.p["ndims"],
self.p["nparticle"],
self.p["half_boxboundary"],
self.p["init_frame"],
self.current_coord, lammpstrj,
self.p["writeFreq"])
# END of the simulation
# POST-PROCESSING
probability = self.colvars_count / (
np.sum(self.colvars_count) / self.p["ndims"]
) # both numerator and denominator should actually be divided by two but this would be cacncelled
probability = paddingRightMostBin(probability)
self.IO.propertyOnColvarsOutput(self.bins, probability,
self.colvars_count / 2, histogramOnCVs)
if self.p["nnCheckFlag"] == "yes":
self.IO.propertyOnColvarsOutput(self.bins, self.colvars_force_NN,
self.colvars_count, forceOnCVs)
else:
self.colvars_force = (self.colvars_force / self.colvars_count)
self.colvars_force[np.isnan(self.colvars_force)] = 0
self.colvars_force = paddingRightMostBin(self.colvars_force)
self.IO.propertyOnColvarsOutput(self.bins, self.colvars_force,
self.colvars_count, forceOnCVs)
# ndims >= 2 -> plot using matplotlib
if self.p["ndims"] == 2:
s = rendering(self.p["ndims"], self.p["half_boxboundary"],
self.p["binNum"], self.p["temperature"])
s.render(
probability[0],
name=str(self.p["abfCheckFlag"] + "_" + self.p["nnCheckFlag"] +
"_" + "boltzDist" + str(self.p["ndims"]) + "D"))
if self.p["nnCheckFlag"] == "yes":
s.render(self.colvars_force_NN[0],
name=str(self.p["abfCheckFlag"] + "_" +
self.p["nnCheckFlag"] + "_" + "forcex" +
str(self.p["ndims"]) + "D"))
s.render(self.colvars_force_NN[1],
name=str(self.p["abfCheckFlag"] + "_" +
self.p["nnCheckFlag"] + "_" + "forcey" +
str(self.p["ndims"]) + "D"))
else:
s.render(self.colvars_force[0],
name=str(self.p["abfCheckFlag"] + "_" +
self.p["nnCheckFlag"] + "_" + "forcex" +
str(self.p["ndims"]) + "D"))
s.render(self.colvars_force[1],
name=str(self.p["abfCheckFlag"] + "_" +
self.p["nnCheckFlag"] + "_" + "forcey" +
str(self.p["ndims"]) + "D"))
# Close files, mkdir and mv files
self.IO.closeAllFiles(lammpstrj, forceOnCVs, histogramOnCVs, withANN,
woANN)
self.IO.makeDirAndMoveFiles(self.p["ndims"], self.p["mass"], self.p["temperature"], self.p["frictCoeff"], self.p["total_frame"],\
self.p["abfCheckFlag"], self.p["nnCheckFlag"], __class__.__name__)
def mdrun(self):
init_real_world_time = time.time()
# PRE-PROCESSING
lammpstrj = open(
"m%.1f_T%.5f_gamma%.1f_len_%d.lammpstrj" %
(self.p["mass"], self.p["temperature"], self.p["frictCoeff"],
self.p["total_frame"]), "w")
forceOnCVs = open(
"Force_m%.1fT%.5f_gamma%.1f_len_%d.dat" %
(self.p["mass"], self.p["temperature"], self.p["frictCoeff"],
self.p["total_frame"]), "w")
freeEOnCVs = open(
"FreeE_m%.1fT%.5f_gamma%.1f_len_%d.dat" %
(self.p["mass"], self.p["temperature"], self.p["frictCoeff"],
self.p["total_frame"]), "w")
histogramOnCVs = open(
"Hist_m%.1fT%.5f_gamma%.1f_len_%d.dat" %
(self.p["mass"], self.p["temperature"], self.p["frictCoeff"],
self.p["total_frame"]), "w")
annABP = open("instantFreeEWANN_" + str(self.p["ndims"]) + "D.dat",
"a")
convABP = open("instantFreeEWOANN_" + str(self.p["ndims"]) + "D.dat",
"a")
tempHist = open("tempHist.dat", "a")
tempBsp = open("tempBsp.dat", "a")
# START of the simulation
self.IO.writeParams(self.p)
self.IO.lammpsFormatColvarsOutput(self.p["ndims"], self.p["nparticle"],
self.p["half_boxboundary"],
self.p["init_frame"],
self.current_coord, lammpstrj,
self.p["writeFreq"])
self.IO.printCurrentStatus(self.p["init_frame"], init_real_world_time)
while self.p["init_frame"] < self.p["total_frame"]:
self.p["init_frame"] += 1
self.IO.printCurrentStatus(self.p["init_frame"],
init_real_world_time)
self.mdInitializer.checkTargetTemperature(self.current_vel,
self.p["init_frame"],
self.p["total_frame"])
if self.p["init_frame"] % self.p["trainingFreq"] == 0 and self.p[
"init_frame"] != 0 and self.p[
"abfCheckFlag"] == "yes" and self.p[
"nnCheckFlag"] == "yes": # for ANN-ABP
self.getCurrentFreeEnergy()
self._learningProxy()
self._updateBiasingPotential()
self.IO.certainFrequencyOutput(self.colvars_coord,
self.colvars_FreeE_NN,
self.colvars_hist,
self.p["init_frame"],
self.p["certainOutFreq"],
annABP)
self.IO.certainFrequencyOutput(
self.colvars_coord, self.colvars_FreeE, self.colvars_hist,
self.p["init_frame"], self.p["certainOutFreq"], convABP)
self.IO.certainFrequencyOutput(
self.colvars_coord,
self.colvars_hist / np.sum(self.colvars_hist),
self.colvars_hist, self.p["init_frame"],
self.p["certainOutFreq"], tempHist)
self.IO.certainFrequencyOutput(self.colvars_coord,
self.biasingPotentialFromNN,
self.colvars_hist,
self.p["init_frame"],
self.p["certainOutFreq"],
tempBsp)
if self.p["init_frame"] != self.p["total_frame"]:
self._resetColvarsHist()
if self.p["init_frame"] % self.p["trainingFreq"] == 0 and self.p[
"abfCheckFlag"] == "yes" and self.p[
"nnCheckFlag"] == "no" and self.p[
"init_frame"] != 0: # for regular ABP
self.getCurrentFreeEnergy()
self._updateBiasingPotential()
self.IO.certainFrequencyOutput(
self.colvars_coord, self.colvars_FreeE, self.colvars_hist,
self.p["init_frame"], self.p["certainOutFreq"], convABP)
self.IO.certainFrequencyOutput(
self.colvars_coord,
self.colvars_hist / np.sum(self.colvars_hist),
self.colvars_hist, self.p["init_frame"],
self.p["certainOutFreq"], tempHist)
self.IO.certainFrequencyOutput(self.colvars_coord,
self.biasingPotentialConv,
self.colvars_hist,
self.p["init_frame"],
self.p["certainOutFreq"],
tempBsp)
if self.p["init_frame"] != self.p["total_frame"]:
self._resetColvarsHist()
if self.p["init_frame"] == self.p["total_frame"]:
self.getCurrentFreeEnergy()
self.mdInitializer.velocityVerletSimple(self.current_coord,
self.current_vel)
self._accumulateColvarsHist()
self.IO.lammpsFormatColvarsOutput(self.p["ndims"],
self.p["nparticle"],
self.p["half_boxboundary"],
self.p["init_frame"],
self.current_coord, lammpstrj,
self.p["writeFreq"])
# END of the simulation
# POST-PROCESSING
probability = copy.deepcopy(
(self.colvars_hist / np.sum(self.colvars_hist)))
probability = paddingRightMostBin(probability)
self.IO.propertyOnColvarsOutput(self.bins, probability,
self.colvars_hist, histogramOnCVs)
self.colvars_force = (self.colvars_force / self.colvars_count)
self.colvars_force[np.isnan(self.colvars_force)] = 0
self.colvars_force = paddingRightMostBin(self.colvars_force)
self.IO.propertyOnColvarsOutput(self.bins, self.colvars_force,
self.colvars_count, forceOnCVs)
if self.p["abfCheckFlag"] == "yes" and self.p["nnCheckFlag"] == "yes":
self.IO.propertyOnColvarsOutput(self.bins, self.colvars_FreeE_NN,
self.colvars_hist, freeEOnCVs)
else:
self.IO.propertyOnColvarsOutput(self.bins, self.colvars_FreeE,
self.colvars_hist, freeEOnCVs)
if self.p["ndims"] == 2:
s = rendering(self.p["ndims"], self.p["half_boxboundary"],
self.p["binNum"], self.p["temperature"])
s.render(
self.colvars_FreeE,
name=str(self.p["abfCheckFlag"] + "_" + self.p["nnCheckFlag"] +
"_" + "FEsurface_Original" + str(self.p["ndims"]) +
"D"))
s.render(
self.colvars_force[0],
name=str(self.p["abfCheckFlag"] + "_" + self.p["nnCheckFlag"] +
"_" + "forceX_UnderABP" + str(self.p["ndims"]) + "D"))
s.render(
self.colvars_force[1],
name=str(self.p["abfCheckFlag"] + "_" + self.p["nnCheckFlag"] +
"_" + "forceY_UnderABP" + str(self.p["ndims"]) + "D"))
s.render(
probability,
name=str(self.p["abfCheckFlag"] + "_" + self.p["nnCheckFlag"] +
"_" + "boltzDistr_NN" + str(self.p["ndims"]) + "D"))
if self.p["abfCheckFlag"] == "yes" and self.p[
"nnCheckFlag"] == "yes":
s.render(self.colvars_FreeE_NN,
name=str(self.p["abfCheckFlag"] + "_" +
self.p["nnCheckFlag"] + "_" +
"FEsurface_NN" + str(self.p["ndims"]) + "D"))
# Close files, mdkir and mv files
self.IO.closeAllFiles(lammpstrj, forceOnCVs, freeEOnCVs,
histogramOnCVs, annABP, convABP, tempHist,
tempBsp)
self.IO.makeDirAndMoveFiles(self.p["ndims"], self.p["mass"], self.p["temperature"], self.p["frictCoeff"], self.p["total_frame"],\
self.p["abfCheckFlag"], self.p["nnCheckFlag"], __class__.__name__)