bfee2 3.1.1.post1__py3-none-any.whl

BFEE2/templates_namd/scriptTemplate.py

@@ -0,0 +1,304 @@
+import string
+
+removeProteinTemplate = string.Template('''
+mol new ${path}.psf
+mol addfile ${path}.pdb
+set aa [atomselect top "not $selectionPro"]
+$$aa writepsf ${outputPath}.psf
+$$aa writepdb ${outputPath}.pdb
+exit
+''')
+
+removeMemProteinTemplate = string.Template('''
+mol new ${path}.psf
+mol addfile ${path}.pdb
+set aa [atomselect top "$selectionLig"]
+$$aa writepsf ${outputPath}_base.psf
+$$aa writepdb ${outputPath}_base.pdb
+mol delete top
+package require solvate
+solvate ${outputPath}_base.psf ${outputPath}_base.pdb -x 20 -y 20 -z 20 +x 20 +y 20 +z 20 -o ${outputPath} -s WT -b 2.2
+mol delete top
+mol new ${outputPath}.psf
+mol addfile ${outputPath}.pdb
+set aa [atomselect top all]
+$$aa writexyz ${outputPath}.xyz
+exit
+''')
+
+removeMemProteinFepTemplate = string.Template('''
+package require autoionize
+mol new ${path}.psf
+mol addfile ${path}.pdb
+set aa [atomselect top "$selectionLig"]
+$$aa writepsf ${outputPath}_base.psf
+$$aa writepdb ${outputPath}_base.pdb
+mol delete top
+package require solvate
+solvate ${outputPath}_base.psf ${outputPath}_base.pdb -x 20 -y 20 -z 20 +x 20 +y 20 +z 20 -o ${outputPath} -s WT -b 2.2
+mol delete top
+mol new ${outputPath}.psf
+mol addfile ${outputPath}.pdb
+set aa [atomselect top all]
+$$aa writexyz ${outputPath}.xyz
+$$aa set beta 0
+set solute [atomselect top "not water"]
+$$solute set beta 1
+$$aa writepdb ${outputFepPath}.pdb
+exit
+''')
+
+removeProteinAmberTemplate = string.Template('''
+parm ${path}.parm7
+trajin ${path}.pdb
+strip :$residueNum parmout ${outputPath}.parm7
+trajout ${outputPath}.pdb
+go
+''')
+
+neutralizeSystempTemplate = string.Template('''
+package require autoionize
+autoionize -psf ${path}.psf -pdb ${path}.pdb -neutralize -cation ${cationName} -anion ${anionName} -seg IO2 -o ${path}
+mol new ${path}.psf
+mol addfile ${path}.pdb
+set aa [atomselect top all]
+$$aa set beta 0
+set solute [atomselect top "not water and not ion"]
+$$solute set beta 1
+$$aa writexyz ${path}.xyz
+${extraCommand}
+exit
+''')
+
+def charmmToGromacsTemplate(inputPrefix, forceFieldList):
+    return f'''
+import numpy as np
+import parmed, MDAnalysis
+from MDAnalysis import transformations
+def measurePBC(uObject):
+    atoms = uObject.select_atoms('all')
+    atomPositions = atoms.positions
+    xyz_array = np.transpose(atomPositions)
+    min_x = np.min(xyz_array[0])
+    max_x = np.max(xyz_array[0])
+    min_y = np.min(xyz_array[1])
+    max_y = np.max(xyz_array[1])
+    min_z = np.min(xyz_array[2])
+    max_z = np.max(xyz_array[2])
+    return [
+        np.array([max_x, max_y, max_z]) - np.array([min_x, min_y, min_z]),
+        (np.array([min_x, min_y, min_z]) + np.array([max_x, max_y, max_z])) / 2
+    ]
+def charmmToGromacs(psfFile, pdbFile, prmFiles, PBC, outputPrefix):
+    struct = parmed.load_file(psfFile)
+    struct.load_parameters(
+        parmed.charmm.CharmmParameterSet(*prmFiles)
+    )
+    struct.coordinates = parmed.load_file(pdbFile).coordinates
+    struct.box = [PBC[0], PBC[1], PBC[2], 90, 90, 90]
+    struct.save(f'{{outputPrefix}}.top', format='gromacs')
+    struct.save(f'{{outputPrefix}}.gro')
+uObject = MDAnalysis.Universe('{inputPrefix}.psf', '{inputPrefix}.pdb')
+pbcVector = measurePBC(uObject)
+allAtoms = uObject.select_atoms('all')
+transformations.translate((-pbcVector[1] + pbcVector[0] / 2))(allAtoms)
+allAtoms.write('{inputPrefix}.pdb', 'pdb', bonds=None)
+charmmToGromacs(
+    '{inputPrefix}.psf', 
+    '{inputPrefix}.pdb',
+    {forceFieldList},
+    pbcVector[0],
+    '{inputPrefix}_gmx'
+)'''
+
+amberToGromacsTemplate = string.Template('''
+import numpy as np
+import parmed, MDAnalysis
+from MDAnalysis import transformations
+def measurePBC(uObject):
+    atoms = uObject.select_atoms('all')
+    atomPositions = atoms.positions
+    xyz_array = np.transpose(atomPositions)
+    min_x = np.min(xyz_array[0])
+    max_x = np.max(xyz_array[0])
+    min_y = np.min(xyz_array[1])
+    max_y = np.max(xyz_array[1])
+    min_z = np.min(xyz_array[2])
+    max_z = np.max(xyz_array[2])
+    return [
+        np.array([max_x, max_y, max_z]) - np.array([min_x, min_y, min_z]),
+        (np.array([min_x, min_y, min_z]) + np.array([max_x, max_y, max_z])) / 2
+    ]
+def amberToGromacs(parmFile, rstFile, PBC, outputPrefix):
+    struct = parmed.load_file(parmFile, xyz=rstFile)
+    struct.coordinates = parmed.load_file(rstFile).coordinates
+    struct.box = [PBC[0], PBC[1], PBC[2], 90, 90, 90]
+    struct.save(f'{outputPrefix}.top', format='gromacs')
+    struct.save(f'{outputPrefix}.gro')
+uObject = MDAnalysis.Universe('${inputPrefix}.parm7', '${inputPrefix}.pdb')
+pbcVector = measurePBC(uObject)
+allAtoms = uObject.select_atoms('all')
+transformations.translate((-pbcVector[1] + pbcVector[0] / 2))(allAtoms)
+allAtoms.write('${inputPrefix}.pdb', 'pdb', bonds=None)
+amberToGromacs(
+    '${inputPrefix}.parm7',
+    '${inputPrefix}.pdb',
+    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")
+''')

BFEE2/templates_namd/solvate.tcl

@@ -0,0 +1,9 @@
+package require solvate
+solvate ../complex.psf ../complex.pdb -x 12 -y 12 -z 12 +x 12 +y 12 +z 12 -o complex_largeBox -s W2 -b 2.2
+mol addfile complex_largeBox.psf
+mol addfile complex_largeBox.pdb
+set all [atomselect top "all"]
+$all writexyz complex_largeBox.xyz
+$all delete
+mol delete top
+exit

BFEE2/templates_namd/solvate_mem.tcl

@@ -0,0 +1,9 @@
+package require solvate
+solvate ../complex.psf ../complex.pdb -x 0 -y 0 -z 16 +x 0 +y 0 +z 16 -o complex_largeBox -s W2 -b 2.2
+mol addfile complex_largeBox.psf
+mol addfile complex_largeBox.pdb
+set all [atomselect top "all"]
+$all writexyz complex_largeBox.xyz
+$all delete
+mol delete top
+exit

BFEE2/templates_namd/updateCenters.py

@@ -0,0 +1,312 @@
+# Read eq.histogramX.dat and update Centers in *.in files
+# This step is optional but may improve the convergence
+
+import os, sys, re
+import numpy as np
+
+def isGeometric():
+    """Check the route of the simulation, True for geometric,
+       False for alchemical.
+       
+    Returns:
+        bool: the route of the free-energy calculation. True for geometric,
+              False for alchemical
+    """
+    
+    if os.path.exists('../fep.tcl'):
+        return False
+    else:
+        return True
+    
+    
+def parseDat(filename):
+    """Parse a dat (histogram) file and return the most probable CV value
+
+    Args:
+        filename (str): the dat file to be parsed with
+        
+    Returns:
+        float: the most probable CV value
+    """
+    
+    data = np.loadtxt(filename)
+    CVs = data[:,0]
+    counts = data[:,1]
+    
+    maxCV = -1
+    maxCount = -1
+    for i, j in zip(CVs, counts):
+        if j > maxCount:
+            maxCV = i
+            maxCount = j
+    return maxCV
+
+def findOptimalCVs():
+    """ read *.dat files generated through equilibration
+        and find out the most probable values of CVs
+        
+    Returns:
+        list[Float]: the most probable values of RMSD, eulerTheta, eulerPhi, eulerPsi, polarTheta, polarPhi, r
+    """
+    
+    optimalCVs = []
+    files = [
+        'output/eq.histogram1.dat',
+        'output/eq.histogram2.dat',
+        'output/eq.histogram3.dat',
+        'output/eq.histogram4.dat',
+        'output/eq.histogram5.dat',
+        'output/eq.histogram6.dat',
+        'output/eq.histogram7.dat'
+    ]
+    
+    for file in files:
+        optimalCVs.append(parseDat(file))
+    
+    return optimalCVs
+ 
+def readCenters(filename, CVs):
+    """ find the value of centers of provided CVs in a *.in file
+
+    Args:
+        filename (str): a Colvars config file
+        CVs (List[str]): a list, showing the CVs whose centers are to be get
+        
+    Returns:
+        List[float]: centers of the provided CVs
+    """
+    
+    # whether parsing a harmonic block
+    # either None or the index of the corresponding CV
+    inBlock = None
+    
+    # the CV values
+    CVValues = [0 for i in range(len(CVs))]
+    
+    with open(filename, 'r') as colvarsFile:
+        for line in colvarsFile.readlines():
+            splitedLine = line.strip().split()
+                
+            if inBlock is not None:
+                if line.strip().lower().startswith('centers'):
+                    if inBlock != -1:
+                        CVValues[inBlock] = float(splitedLine[1])
+                    
+                    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
+    
+    return CVValues
+ 
+def changeCenters(filename, CVs, newCenters):
+    """ change Centers of harmonic restraints in a *.in file
+
+    Args:
+        filename (str): a Colvars config file
+        CVs (List[str]): a list, showing the Centers of which harmonic blocks are to be replaced
+        newCenters (List[float]): a list, containing the new values of Centers
+    """
+    
+    # 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():
+                splitedLine = line.strip().split()
+                
+                if inBlock is None:
+                    newColvarsFile.write(line)
+                else:
+                    if not line.strip().lower().startswith('centers'):
+                        newColvarsFile.write(line)
+                    else:
+                        # 'colvars' not in CVs
+                        if inBlock == -1:
+                            newColvarsFile.write(line)
+                        else:
+                            newColvarsFile.write(f'    Centers    {newCenters[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
+    
+    os.remove(filename)
+    os.rename(filename + '.tmp', filename)
+    
+def changeABFRange(filename, CVs, newCenters, originalCenters):
+    """ change lowerboundary, upperboundary, lowerWalls, upperWalls of ABF in a *.in file
+
+    Args:
+        filename (str): a Colvars config file
+        CVs (List[str]): a list, showing the corresponding options of which CV blocks are to be replaced
+        newCenters (List[float]): a list, containing the new values of Centers of these CVs
+        originalCenters (List[float]): a list, containing the original values of Centers of these CVs
+    """
+    
+    # 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():
+                splitedLine = line.strip().split()
+                
+                if inBlock is None:
+                    newColvarsFile.write(line)
+                else:
+                    if (not line.strip().lower().startswith('lowerboundary')) and \
+                        (not line.strip().lower().startswith('upperboundary')) and \
+                        (not line.strip().lower().startswith('lowerwalls')) and \
+                        (not line.strip().lower().startswith('upperwalls')):
+                        newColvarsFile.write(line)
+                    else:
+                        # 'name' not in CVs
+                        if inBlock == -1:
+                            newColvarsFile.write(line)
+                        else:
+                            if line.strip().lower().startswith('lowerboundary'):
+                                newColvarsFile.write(
+                                    f'    Lowerboundary    {float(splitedLine[1]) + newCenters[inBlock] - originalCenters[inBlock]}\n'
+                                )
+                            elif line.strip().lower().startswith('upperboundary'):
+                                newColvarsFile.write(
+                                    f'    Upperboundary    {float(splitedLine[1]) + newCenters[inBlock] - originalCenters[inBlock]}\n'
+                                    )
+                            elif line.strip().lower().startswith('lowerwalls'):
+                                newColvarsFile.write(
+                                    f'    LowerWalls    {float(splitedLine[1]) + newCenters[inBlock] - originalCenters[inBlock]}\n'
+                                    )
+                            elif line.strip().lower().startswith('upperwalls'):
+                                newColvarsFile.write(
+                                    f'    UpperWalls    {float(splitedLine[1]) + newCenters[inBlock] - originalCenters[inBlock]}\n'
+                                    )
+                            else:
+                                print("Selected CV(s) not for free-energy calculation!")
+                    
+                    if len(splitedLine) > 0:
+                        if splitedLine[0] == '}':
+                            inBlock = None
+                
+                if len(splitedLine) > 0:
+                    if splitedLine[0].lower() == 'colvar' or line.strip().lower().startswith('harmonicwalls'):
+                        inBlock = -1
+                    
+                    if line.strip().lower().startswith('name') or splitedLine[0].lower() == 'colvars':
+                        for index, CV in enumerate(CVs):
+                            if splitedLine[1].lower() == CV.lower():
+                                inBlock = index
+    
+    os.remove(filename)
+    os.rename(filename + '.tmp', filename)
+
+def updateAlchemicalFiles():
+    """Update the Centers of *.in files based on equilibration
+    """
+    
+    files = [
+        './colvars2.in',
+        '../001_MoleculeBound/colvars.in',
+        '../002_RestraintBound/colvars_forward.in',
+        '../002_RestraintBound/colvars_backward.in'
+    ]
+    
+    for file in files:
+        if not os.path.exists(file):
+            print(f'File {file} does not exist!')
+            continue
+        changeCenters(
+            file, 
+            [
+                'eulerTheta', 'eulerPhi', 'eulerPsi', 'polarTheta', 'polarPhi', 'r'
+            ], 
+            findOptimalCVs()[1:]
+        )
+        print(f'File {file} updated!')
+
+    # if re-eqilibrated
+    if os.path.exists('./000.1_eq2_re-eq.conf'):
+        confFiles = [
+            '../001_MoleculeBound/001.1_fep_backward.conf',
+            '../001_MoleculeBound/001_fep_doubleWide.conf',
+            '../001_MoleculeBound/001_lambdaABF.conf',
+            '../002_RestraintBound/002.1_ti_backward.conf',
+        ]
+        for confFile in confFiles:
+            if not os.path.exists(confFile):
+                print(f'File {confFile} does not exist!')
+                continue
+            with open(confFile,'r') as readFile:
+                data=readFile.read()
+            data = re.sub('../000_eq/output/eq.coor', '../000_eq/output/eq2.coor', data)
+            data = re.sub('../000_eq/output/eq.vel', '../000_eq/output/eq2.vel', data)
+            data = re.sub('../000_eq/output/eq.xsc', '../000_eq/output/eq2.xsc', data)
+            with open(confFile,'w') as writeFile:
+                writeFile.write(data)
+            print(f'File {confFile} updated!')
+        
+def updateGeometricFiles():
+    """Update the Centers of *.in files based on equilibration
+    """
+    
+    CVNames = ['eulerTheta', 'eulerPhi', 'eulerPsi', 'polarTheta', 'polarPhi']
+    optimalCVValues = findOptimalCVs()[1:6]
+    originalCVValues = readCenters('../007_r/colvars_eq.in', CVNames)
+    
+    # in geometrical route, there may be many windows
+    folders = [
+        '../002_EulerTheta',
+        '../003_EulerPhi',
+        '../004_EulerPsi',
+        '../005_PolarTheta',
+        '../006_PolarPhi',
+        '../007_r'
+    ]
+    
+    for fIndex, folder in enumerate(folders):
+        # *.in in folder 
+        files = []
+        for file in os.listdir(folder):
+            if file.endswith('.in') or file.endswith('.in.amd'):
+                files.append(os.path.join(folder, file))
+                
+        for inFile in files:
+            changeCenters(
+                inFile, 
+                CVNames[:fIndex], 
+                optimalCVValues[:fIndex]
+            )
+            
+            changeABFRange(
+                inFile,
+                CVNames[:fIndex+1],
+                optimalCVValues[:fIndex+1],
+                originalCVValues[:fIndex+1]
+            )
+            print(f'File {inFile} updated!')
+        
+if __name__ == '__main__':
+    
+    if isGeometric():
+        updateGeometricFiles()
+        print('All the *.in files updated for the Geometrical route!')
+    else:
+        updateAlchemicalFiles()
+        print('All the *.in files updated for the Alchemical route!')

BFEE2/templates_readme/Readme_Gromacs_Geometrical.txt

@@ -0,0 +1,25 @@
+To calculate the binding free energy:
+
+1.1.  run 000_eq/000_generate_tpr.sh
+1.2.  run 000_eq/000_eq.tpr
+2.1.  run 001_RMSD_bound/001_generate_tpr.sh
+2.2.  run 001_RMSD_bound/001_RMSD_bound.tpr
+3.1.  run 002_euler_theta/002_generate_tpr.sh
+3.2.  run 002_euler_theta/002_euler_theta.tpr
+4.1.  run 003_euler_phi/003_generate_tpr.sh
+4.2.  run 003_euler_phi/003_euler_phi.tpr
+5.1.  run 004_euler_psi/004_generate_tpr.sh
+5.2.  run 004_euler_psi/004_euler_psi.tpr
+6.1.  run 005_polar_theta/005_generate_tpr.sh
+6.2.  run 005_polar_theta/005_polar_theta.tpr
+7.1.  run 006_polar_phi/006_generate_tpr.sh
+7.2.  run 006_polar_phi/006_polar_phi.tpr
+8.1.  run 007_r/007.1_generate_eq_tpr.sh
+8.2.  run 007_r/007_r.eq.tpr
+8.3.  run 007_r/007.2_generate_tpr.sh
+8.4   run 007_r/007_r.tpr
+9.1.  run 008_RMSD_unbound/008.1_generate_eq_tpr.sh
+9.2.  run 008_RMSD_unbound/008_RMSD_unbound.eq.tpr
+9.3.  run 008_RMSD_unbound/008.2_generate_tpr.sh
+9.4.  run 008_RMSD_unbound/008_RMSD_unbound.tpr
+10.   do post-treatment using BFEE

BFEE2/templates_readme/Readme_NAMD_Alchemical.txt

@@ -0,0 +1,20 @@
+To calculate the binding free energy:
+
+1.1.  run 000_eq/000.1_eq.conf
+1.2.  (optionally) run 000_eq/000.3_updateCenters.py
+2.1.  run 001_MoleculeBound/001.1_fep_backward.conf
+2.2.  run 001_MoleculeBound/001.2_fep_forward.conf
+3.1.  run 002_RestraintBound/002.1_ti_backward.conf
+3.2.  run 002_RestraintBound/002.2_ti_forward.conf
+4.1.  CHARMM user:
+        (if you didn't link BFEE with VMD before generating inputs)
+        run 002.3_removeProtein.tcl using VMD
+      Amber user:
+        run 002.3_removeProtein.cpptraj using cpptraj
+4.2   run 000_eq/000.2_eq_ligandOnly.conf
+4.3.  run 003_MoleculeUnbound/003.1_fep_backward.conf
+4.4.  run 003_MoleculeUnbound/003.2_fep_forward.conf
+5.1.  run 004_RestraintUnbound/004.1_ti_backward.conf
+5.2.  run 004_RestraintUnbound/004.2_ti_forward.conf
+(steps 2-5 can be done in parallel)
+6.    do post-treatment using BFEE