bfee2 2.5.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

BFEE2/postTreatment.py

@@ -500,3 +500,159 @@ class postTreatment:
         errors[5] = math.sqrt(errors[0]**2 + errors[1]**2 +errors[2]**2 + errors[3]**2 + errors[4]**2)
 
         return contributions, errors
+
+    def _LDDMReadColvarsTmp(self, file_path):
+        """ Read an Colvars Tmp file in binding free energy calculations,
+            get the force constants and centers constants of restraints for LDDM
+
+        Args:
+            file_path (str): path to the Colvars.tmp file
+
+        Returns:
+            Tuple[List, List]: lists of force constants and centers
+        """
+
+        force_constants = []
+        centers = []
+
+        with open(file_path, 'r') as colvars_tmp_file:
+            center_line = False
+            for line in colvars_tmp_file.readlines():
+                splited_line = line.strip().split()
+
+                if len(splited_line) < 2:
+                    center_line = False
+                    continue
+
+                if splited_line[1].startswith('$afc_'):
+                    force_constants.append(float(splited_line[1].replace('$afc_', '')))
+                    center_line = True
+                    continue
+
+                if center_line:
+                    centers.append(float(splited_line[1]))
+
+                continue
+        
+        return force_constants, centers
+
+    def _LDDMBoundStateFreeEnergy(
+            self,
+            colvars_tmp_path,
+            cvtrj_path,
+            fepout_path,
+            steps_per_window,
+            equilbration_steps_per_window,
+            num_windows,
+            temperature = 300,
+            jobtype = 'fep'
+        ):
+        """ Calculate bound state free-energy contribution and error
+
+        Args:
+            colvars_tmp_path (str): path to colvars tmp file
+            cvtrj_path (str): path to colvars.traj file
+            fepout_path (str): path to fepout file
+            steps_per_window (int): steps per FEP window
+            equilbration_steps_per_window (int): equilibration steps per FEP window
+            num_windows (int): number of windows
+            temperature (float): temperature of the simulation, defaults to 300
+            jobType (str, optional): Type of the post-treatment method. 'fep' or 'bar'. 
+                                      Defaults to 'fep'.
+
+        Returns:
+            Tuple[float, float, float]: free-energy contribution of decoupling the molecule,
+                                        error, and contribution of the restraints
+        """
+        force_contants, centers = self._LDDMReadColvarsTmp(colvars_tmp_path)
+        colvars_parser = py_bar.ColvarsParser(cvtrj_path, steps_per_window, equilbration_steps_per_window, 
+                                    force_contants, centers,
+                                    np.linspace(0, 1, num_windows))
+        window, deltaU = colvars_parser.get_data()
+        b = py_bar.FEPAnalyzer(window, deltaU, temperature)
+
+        window2, deltaU2 = py_bar.NAMDParser(fepout_path).get_data()
+        success = b.MergeData(window2, deltaU2)
+        if not success:
+            raise RuntimeError('Failed in merging fepout and colvars.traj! Probably wrong number of windows or crupted simulations!')
+        
+        if jobtype == 'fep':
+            result = b.FEP_free_energy()
+        else:
+            result = b.BAR_free_energy(block_size=50, n_bootstrap=20)
+
+        #windows = b.Window_boundaries()
+        #with open(fepout_path + ".convergence.data", "w") as convergence_file:
+        #    convergence_file.write(f"    lambda      dA      stdev_A   \n")
+        #    for window, dA, stdA in zip(windows, result[1], resul[2]):
+        #        convergence_file.write(f" {window}      {dA:.4f}      {stdA:.4f}   \n")
+
+        return -np.sum(result[1]), np.sqrt(np.sum(np.power(result[2], 2))), colvars_parser.get_restraint_contribution()
+
+    def _LDDMFreeStateFreeEnergy(self, fepout_path, temperature = 300, jobtype = 'fep'):
+        """ Calculate free state free-energy contribution and error
+
+        Args:
+            fepout_path (str): path to fepout file
+            temperature (float, optional): temperature of the simulation. Defaults to 300.
+            jobType (str, optional): Type of the post-treatment method. 'fep' or 'bar'. 
+                                      Defaults to 'fep'.
+
+        Returns:
+            Tuple[float, float]: free-energy contribution and the error of decoupling the molecule
+        """
+        window, deltaU = py_bar.NAMDParser(fepout_path).get_data()
+        b = py_bar.FEPAnalyzer(window, deltaU, temperature)
+
+        if jobtype == 'fep':
+            result = b.FEP_free_energy()
+        else:
+            result = b.BAR_free_energy(block_size=50, n_bootstrap=20)
+
+        # convergence file
+        #windows = b.Window_boundaries()
+        #with open(fepout_path + "convergence.data", "w") as convergence_file:
+        #    convergence_file.write(f"    lambda      dA      stdev_A   \n")
+        #    for window, dA, stdA in zip(windows, result_fep[1], result_fep[2]):
+        #        convergence_file.write(f" {window}      {dA:.4f}      {stdA:.4f}   \n")
+
+        return np.sum(result[1]), np.sqrt(np.sum(np.power(result[2], 2)))
+    
+    def LDDMBindingFreeEnergy(
+            self, 
+            colvars_tmp_path,
+            cvtrj_path,
+            step1_fepout_path,
+            steps_per_window,
+            equilbration_steps_per_window,
+            num_windows,
+            step3_fepout_path,
+            temperature = 300, 
+            jobType = 'fep'):
+        """calculate binding free energy for LDDM
+
+        Args:
+            colvars_tmp_path (str): path to colvars tmp file of step 1
+            cvtrj_path (str): path to colvars.traj file of step 1
+            step1_fepout_path (str): path to fepout file of step 1
+            steps_per_window (int): steps per FEP window of step 1
+            equilbration_steps_per_window (int): equilibration steps per FEP window of step 1
+            num_windows (int): number of windows of step 1
+            step3_fepout_path (str): path to fepout file of step 3
+            temperature (float): temperature of the simulation, defaults to 300
+            jobType (str, optional): Type of the post-treatment method. 'fep' or 'bar'. 
+                                      Defaults to 'fep'.
+
+        Returns:
+            tuple:
+                np.array, float, 2: (contributions for step1, and step 3)
+                np.array, float, 2: errors corresponding each contribution
+        """
+
+        step1_dG, step1_error, step3_dG_restraint = self._LDDMBoundStateFreeEnergy(
+            colvars_tmp_path, cvtrj_path, step1_fepout_path, steps_per_window, equilbration_steps_per_window,
+            num_windows, temperature, jobType
+        )
+        step3_dG_molecule, step3_error = self._LDDMFreeStateFreeEnergy(step3_fepout_path, temperature, jobType)
+
+        return np.array([step1_dG, step1_error]), np.array([step3_dG_molecule + step3_dG_restraint, step3_error])

BFEE2/templates_namd/configTemplate.py

@@ -37,7 +37,8 @@ class configTemplate:
                             OPLSMixingRule = False,
                             GaWTM = False,
                             CUDASOAIntegrator = False,
-                            timestep = 2.0
+                            timestep = 2.0,
+                            LDDMStep1 = False
                             ):
         """the namd config file template
 
@@ -68,6 +69,7 @@ class configTemplate:
             GaWTM (bool, optional): Whether this is an GaWTM-eABF simulation. Default to False
             CUDASOAIntegrator (bool, optional): Whether CUDASOA integrator is used. Default to False
             timestep (float, optional): timestep of the simulation. Default to 2.0
+            LDDMStep1 (bool, optional): whether this is the 1st step of a LDDM simulation. Default to False.
             
         Returns:
             str: a NAMD config string if succeed, and empty string otherwise
@@ -259,8 +261,13 @@ run norepeat   {numSteps}                              \n'
         else:
             # currently the alchemical route is somewhat hard-coded
             # this will be improved in the future
+            if LDDMStep1:
+                configString += f'\
+source ./fep_lddm.tcl                           \n'
+            else:
+                configString += f'\
+source ../fep.tcl                               \n'  
             configString += f'\
-source ../fep.tcl                                  \n\
 alch on                                         \n\
 alchType FEP                                    \n\
 alchFile {fepFile}                              \n\
@@ -269,6 +276,7 @@ alchOutFile {outputPrefix}.fepout               \n\
 alchOutFreq 50                                  \n\
 alchVdwLambdaEnd 0.7                            \n\
 alchElecLambdaStart 0.5                         \n\
+alchDecouple   on                               \n\
 alchEquilSteps 100000                           \n'
 
             if fepForward:
@@ -566,7 +574,6 @@ colvar {{                              \n\
             indexGroup  ligand                 \n\
             centerReference    on              \n\
             rotateReference    on              \n\
-	        enableFitGradients no              \n\
             fittingGroup {{                    \n\
                 indexGroup  protein            \n\
             }}                                 \n\
@@ -637,7 +644,6 @@ colvar {{                                   \n\
             indexGroup  reference           \n\
             centerReference    on           \n\
             rotateReference    on           \n\
-            enableFitGradients no           \n\
             fittingGroup {{                 \n\
                 indexGroup  protein         \n\
             }}                              \n\
@@ -647,7 +653,6 @@ colvar {{                                   \n\
             indexGroup  ligand              \n\
             centerReference    on           \n\
             rotateReference    on           \n\
-            enableFitGradients no           \n\
             fittingGroup {{                 \n\
                 indexGroup  protein         \n\
             }}                              \n\
@@ -707,7 +712,6 @@ colvar {{                              \n\
             centerReference    on              \n\
             rotateReference    on              \n\
             centerToOrigin     on              \n\
-	        enableFitGradients on              \n\
             fittingGroup {{                    \n\
                 indexGroup  protein            \n\
             }}                                 \n\

BFEE2/templates_namd/fep_lddm.tcl

@@ -0,0 +1,312 @@
+##############################################################
+# LDDM variant FEP SCRIPT
+# Haohao Fu <fhh2626@gmail.com>
+# Jerome Henin <henin@ibpc.fr>
+#
+# Important: This version should only be used for the LDDM strategy!
+#            Use the NAMD version of fep.tcl for other simulations.
+#
+# Changes:
+# 2020-05-03: added prev_lambda option to runFEP, improved doc
+# 2018-04-18: added interleaved double-wide sampling (IDWS)
+# 2010-04-24: added runFEPmin
+# 2009-11-17: changed for NAMD 2.7 keywords
+# 2008-06-25: added TI routines
+# 2007-11-01: fixed runFEP to handle backwards transformations
+#             (i.e. dLambda < 0)
+# 2024-11-04: support LDDM version of runFEP
+##############################################################
+
+##############################################################
+## Example NAMD input: calculation with smaller windows at
+## the ends
+#
+# source fep.tcl
+#
+# alch                  on
+# alchFile              system.fep
+# alchCol               B
+# alchOutFreq           10
+# alchOutFile           system.fepout
+# alchEquilSteps        500
+#
+# set nSteps      5000
+#
+## A) Simple schedule: 20 windows from 0 to 1, in a single run
+#
+# runFEP 0.0 1.0 0.05 $nSteps
+#
+## B) Same thing, in two NAMD separate runs with a restart
+#
+## First run
+# runFEP 0.0 0.5 0.05 $nSteps
+#
+## Restart
+# runFEP 0.5 1.0 0.05 $nSteps
+#
+## C) Lambda schedule with narrower windows at the end points
+## Using two explicit lists of lambda points
+#
+# set init {0.0 0.05 0.1}
+# set end {0.9 0.95 1.0}
+#
+# runFEPlist $init $nSteps
+# runFEP 0.1 0.9 0.1 $nSteps
+# runFEPlist $end $nSteps
+#
+## Alternately, in one step:
+#
+# runFEPlist [concat $init [FEPlist 0.1 0.9 0.1] $end] $nSteps
+#
+##############################################################
+
+##############################################################
+## Special usage for Interleaved Double-Wide sampling
+## A) Simple schedule: 20 windows from 0 to 1, in a single run
+#
+# runFEP 0.0 1.0 0.05 $nSteps true
+#
+## B) Same thing, in two NAMD separate runs with a restart
+#
+## First run
+# runFEP 0.0 0.5 0.05 $nSteps true
+#
+## Restart - need to tell the script the previous lambda point: 0.45
+# runFEP 0.5 1.0 0.05 $nSteps true 0.45
+#
+## C) Example of a piecewise calculation with restarts
+# and a nonlinear lambda schedule
+#
+## Run individual points 0, 0.05 then the series from 0.1 to 0.5
+#
+# runFEPlist [concat {0. 0.05} [FEPlist 0.1 0.5 0.1]] $numSteps true
+#
+## Continue series from 0.5 to 0.9, sampling backward dE from 0.4
+#
+# runFEPlist [FEPlist 0.5 0.9 0.1] $numSteps true 0.4
+#
+## Add two values 0.95 and 1, sampling backward dE from 0.9
+## (automatically adds final backward window from 1. to 0.95)
+#
+# runFEPlist {0.95 1.} $numSteps true 0.9
+#
+##############################################################
+
+##############################################################
+# proc runFEPlist { lambdaList nSteps {IDWS} {prev_lambda} }
+#
+# Run n FEP windows joining (n + 1) lambda-points
+# Provide prev_lambda value if continuing a sequential
+# transformation and using IDWS
+##############################################################
+
+proc runFEPlist { lambdaList nSteps { IDWS false } { prev_lambda -1 } } {
+    set epsilon 1e-12
+
+    # Keep track of window number
+    global win
+    if {![info exists win]} {
+      set win 1
+    }
+
+    set l1 [lindex $lambdaList 0]
+    foreach l2 [lrange $lambdaList 1 end] {
+      print [format "Running FEP window %3s: Lambda1 %-6s Lambda2 %-6s \[dLambda %-6s\]"\
+        $win $l1 $l2 [expr $l2 - $l1]]
+      firsttimestep 0
+      alchLambda       $l1
+      alchLambda2      $l2
+
+      if { $IDWS && ($prev_lambda >= 0.) } {
+        alchLambdaIDWS $prev_lambda
+      }
+	  
+	  cv reset
+	  cv configfile "./colvars_files/colvars_[expr $win - 1].in"
+	  
+      run $nSteps
+
+      # Keep track of previous value to set is as target for backward calculation in IDWS
+      set prev_lambda $l1
+      set l1 $l2
+      incr win
+    }
+
+    if { $IDWS && ($l1 > [expr {1. - $epsilon}] || $l1 < $epsilon)} {
+      # If the list ends at 1 or zero, we add a final window, which is backward from the end point
+      # to complete double-wide sampling
+      # this will be look like "forward" sampling in the fepout file ("FepEnergy:" keyword)
+      print [format "Running FEP window %3s: Lambda1 %-6s Lambda2 %-6s \[dLambda %-6s\]"\
+        $win $l1 $l2 [expr $l2 - $l1]]
+      firsttimestep 0
+      alchLambda       $l1
+      alchLambda2      $prev_lambda
+      alchLambdaIDWS   -1
+	  
+	  cv reset
+	  cv configfile "./colvars_files/colvars_[expr $win - 1].in"
+	  
+      run $nSteps
+    }
+}
+
+
+##############################################################
+# proc runFEP { start stop dLambda nSteps {IDWS} {prev_lambda} }
+#
+# run FEP windows of width dLambda between values start and stop
+##############################################################
+
+proc runFEP { start stop dLambda nSteps { IDWS false } { prev_lambda -1 } } {
+
+    runFEPlist [FEPlist $start $stop $dLambda] $nSteps $IDWS $prev_lambda
+}
+
+
+##############################################################
+# proc FEPlist { start stop dLambda nSteps }
+#
+# Create list of FEP windows
+##############################################################
+
+proc FEPlist { start stop dLambda } {
+    set epsilon 1e-15
+
+    if { ($stop < $start) && ($dLambda > 0) } {
+      set dLambda [expr {-$dLambda}]
+    }
+
+    if { $start == $stop } {
+      set ll [list $start $start]
+    } else {
+      set ll [list $start]
+      set l2 [increment $start $dLambda]
+
+      if { $dLambda > 0} {
+        # A small workaround for numerical rounding errors
+        while { [expr {$l2 <= ($stop + $epsilon) } ] } {
+          lappend ll $l2
+          set l2 [increment $l2 $dLambda]
+        }
+      } else {
+        while { [expr {$l2 >= ($stop - $epsilon) } ] } {
+          lappend ll $l2
+          set l2 [increment $l2 $dLambda]
+        }
+      }
+    }
+
+    return $ll
+}
+
+
+##############################################################
+##############################################################
+
+proc runFEPmin { start stop dLambda nSteps nMinSteps temp} {
+    set epsilon 1e-15
+
+    if { ($stop < $start) && ($dLambda > 0) } {
+      set dLambda [expr {-$dLambda}]
+    }
+
+    if { $start == $stop } {
+      set ll [list $start $start]
+    } else {
+      set ll [list $start]
+      set l2 [increment $start $dLambda]
+
+      if { $dLambda > 0} {
+        # A small workaround for numerical rounding errors
+        while { [expr {$l2 <= ($stop + $epsilon) } ] } {
+          lappend ll $l2
+          set l2 [increment $l2 $dLambda]
+        }
+      } else {
+        while { [expr {$l2 >= ($stop - $epsilon) } ] } {
+          lappend ll $l2
+          set l2 [increment $l2 $dLambda]
+        }
+      }
+    }
+
+    if { $nMinSteps > 0 } {
+      alchLambda       $start
+      alchLambda2      $start
+      minimize $nMinSteps
+      reinitvels $temp
+    }
+
+    runFEPlist $ll $nSteps
+}
+
+##############################################################
+##############################################################
+
+proc runTIlist { lambdaList nSteps } {
+    # Keep track of window number
+    global win
+    if {![info exists win]} {
+	    set win 1
+    }
+
+    foreach l $lambdaList {
+	    print [format "Running TI window %3s: Lambda %-6s "	$win $l ]
+	    firsttimestep 0
+	    alchLambda       $l
+	    run $nSteps
+	    incr win
+    }
+}
+
+
+##############################################################
+##############################################################
+
+proc runTI { start stop dLambda nSteps } {
+    set epsilon 1e-15
+
+    if { ($stop < $start) && ($dLambda > 0) } {
+      set dLambda [expr {-$dLambda}]
+    }
+
+    if { $start == $stop } {
+      set ll [list $start $start]
+    } else {
+      set ll [list $start]
+      set l2 [increment $start $dLambda]
+
+      if { $dLambda > 0} {
+        # A small workaround for numerical rounding errors
+        while { [expr {$l2 <= ($stop + $epsilon) } ] } {
+          lappend ll $l2
+          set l2 [increment $l2 $dLambda]
+        }
+      } else {
+        while { [expr {$l2 >= ($stop - $epsilon) } ] } {
+          lappend ll $l2
+          set l2 [increment $l2 $dLambda]
+        }
+      }
+    }
+
+    runTIlist $ll $nSteps
+}
+
+##############################################################
+# Increment lambda and try to correct truncation errors around
+# 0 and 1
+##############################################################
+
+proc increment { lambda dLambda } {
+    set epsilon 1e-15
+    set new [expr { $lambda + $dLambda }]
+
+    if { [expr $new > - $epsilon && $new < $epsilon] } {
+      return 0.0
+    }
+    if { [expr ($new - 1) > - $epsilon && ($new - 1) < $epsilon] } {
+      return 1.0
+    }
+    return $new
+}

BFEE2/templates_namd/scriptTemplate.py

@@ -146,4 +146,159 @@ amberToGromacs(
     pbcVector[0],
     '${inputPrefix}_gmx',
 )
+''')
+
+genarateLDDMFilesTemplate = string.Template('''
+import numpy as np
+import os, sys
+
+TEMPERATURE = ${temperature}
+WINDOWS = ${windows}
+BOLTZMANN = 0.0019872041
+
+def parseDat(filename, temperature=300.0):
+    """Parse a dat (histogram) file, return the most probable CV value
+       and the corresponding force constant for restraints
+
+    Args:
+        filename (str): the dat file to be parsed with
+        temperature (float): the temperature of the simulation
+        
+    Returns:
+        Tuple(float, float): the most probable CV value and the force constant
+    """
+    
+    data = np.loadtxt(filename)
+    CVs = data[:,0]
+    counts = data[:,1]
+
+    beta = 1 / (-BOLTZMANN * temperature)
+    
+    maxCV = -1
+    maxCount = -1
+    maxIndex = -1
+    for index, (i, j) in enumerate(zip(CVs, counts)):
+        if j > maxCount:
+            maxCV = i
+            maxCount = j
+            maxIndex = index
+    
+    # fitting
+    assert (maxIndex - 2 >=0 and maxIndex + 2 < len(counts)), f"maxIndex is: {maxIndex}, length is: {len(counts)}"
+    X = [CVs[maxIndex - 2], CVs[maxIndex], CVs[maxIndex + 2]]
+    y = [beta * np.log(counts[maxIndex - 2]), beta * np.log(counts[maxIndex]), beta * np.log(counts[maxIndex + 2])]
+
+    forceConstant = np.polyfit(X, y, 2)
+
+    return maxCV, forceConstant[0]
+
+def showForceConstant(temperature=300):
+    """ Print force constants obtained from histogram.dat files
+
+    Args:
+        temperature (int, optional): _description_. Defaults to 300.
+    """
+    #print(parseDat("eq.histogram1.dat", temperature))
+    print(parseDat("../000_eq/output/eq.histogram2.dat", temperature))
+    print(parseDat("../000_eq/output/eq.histogram3.dat", temperature))
+    print(parseDat("../000_eq/output/eq.histogram4.dat", temperature))
+    print(parseDat("../000_eq/output/eq.histogram5.dat", temperature))
+    print(parseDat("../000_eq/output/eq.histogram6.dat", temperature))
+    print(parseDat("../000_eq/output/eq.histogram7.dat", temperature))
+
+def updateForceConstant(filename, CVs, newForceConstants):
+    """ Update force constant of the CVs in a colvars file named filename. 
+        Generates a new files named filename.tmp.
+
+    Args:
+        filename (str): path to the colvars files
+        CVs (list[str]): list of CVs
+        newForceConstants (List[float]): new force constants
+    """
+    # whether parsing a harmonic block
+    # either None or the index of the corresponding CV
+    inBlock = None
+    with open(filename, 'r') as oldColvarsFile:
+        # Python cannot modify text file in place
+        with open(filename + '.tmp', 'w') as newColvarsFile:
+            for line in oldColvarsFile.readlines():
+                if line.strip().lower().startswith('colvarstrajfrequency'):
+                    newColvarsFile.write(f'colvarsTrajFrequency      50\\n')
+                    continue
+
+                splitedLine = line.strip().split()
+                
+                if inBlock is None:
+                    newColvarsFile.write(line)
+                else:
+                    if not line.strip().lower().startswith('forceconstant'):
+                        newColvarsFile.write(line)
+                    else:
+                        # 'colvars' not in CVs
+                        if inBlock == -1:
+                            newColvarsFile.write(line)
+                        else:
+                            newColvarsFile.write(f'    ForceConstant    $$afc_{newForceConstants[inBlock]}\\n')
+                    
+                    if len(splitedLine) > 0:
+                        if splitedLine[0] == '}':
+                            inBlock = None
+                        
+                if line.strip().lower().startswith('harmonic'):
+                    inBlock = -1
+                        
+                if line.strip().lower().startswith('colvars'):
+                    for index, CV in enumerate(CVs):
+                        if splitedLine[1].lower() == CV.lower():
+                            inBlock = index
+
+def updateAllForceConstants(temperature=300):
+    """ update all the force constants of the colvars.in file,
+        based on histogram.dat files
+
+    Args:
+        temperature (int, optional): temperature. Defaults to 300.
+    """
+    newForceConstants = []
+    newForceConstants.append(parseDat("../000_eq/output/eq.histogram2.dat", temperature)[1])
+    newForceConstants.append(parseDat("../000_eq/output/eq.histogram3.dat", temperature)[1])
+    newForceConstants.append(parseDat("../000_eq/output/eq.histogram4.dat", temperature)[1])
+    newForceConstants.append(parseDat("../000_eq/output/eq.histogram5.dat", temperature)[1])
+    newForceConstants.append(parseDat("../000_eq/output/eq.histogram6.dat", temperature)[1])
+    newForceConstants.append(parseDat("../000_eq/output/eq.histogram7.dat", temperature)[1])
+
+    updateForceConstant("./colvars.in", 
+                        ["eulerTheta", "eulerPhi", "eulerPsi", "polarTheta", "polarPhi", "r"],
+                        newForceConstants)
+
+def generateColvarsFiles(template_file, windows, prefix):
+
+    if os.path.exists(f"./{prefix}"):
+        print(f"Error, ./{prefix} exists!")
+        sys.exit(1)
+    
+    os.mkdir(prefix)
+
+    with open(template_file, "r") as inputFile:
+        lines = inputFile.readlines()
+
+    for i in range(windows):
+        with open(f"./{prefix}/colvars_{i}.in", "w") as new_colvars_file:
+            for j in range(len(lines)):
+                splitedLine = lines[j].strip().split()
+                if len(splitedLine) < 2 or (not splitedLine[1].startswith("$$afc_")):
+                    new_colvars_file.write(lines[j])
+                else:
+                    new_colvars_file.write(f"    forceConstant  {float(splitedLine[1].split('_')[1]) * (float(i) / windows)}\\n")
+    
+    with open(f"./{prefix}/colvars_{windows}.in", "w") as new_colvars_file:
+        for j in range(len(lines)):
+            splitedLine = lines[j].strip().split()
+            if len(splitedLine) < 2 or (not splitedLine[1].startswith("$$afc_")):
+                new_colvars_file.write(lines[j])
+            else:
+                new_colvars_file.write(f"    forceConstant  {float(splitedLine[1].split('_')[1])}\\n")
+
+updateAllForceConstants(TEMPERATURE)
+generateColvarsFiles("colvars.in.tmp", WINDOWS, "colvars_files")
 ''')