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

BFEE2/third_party/py_bar.py

@@ -1,10 +1,15 @@
+import sys, math
 from typing import List, Literal, Optional, Tuple
 
 import numpy as np
 from numpy.typing import NDArray
 
+# VERSION
+VERSION = 1.0
+
 # boltzmann constant
 BOLTZMANN = 0.0019872041
+CSTAR = 1661
 
 # type of FEP files
 fep_type = Literal['forward', 'backward', 'double-wide']
@@ -191,6 +196,182 @@ class NAMDParser:
         
         return self._windows, self._deltaU_data
 
+class ColvarsParser:
+    """ parse Colvars cvtrj files and get the necessary data
+    """
+    def __init__(self, 
+            cvtrj_file: str, 
+            step_per_window: int, 
+            equilibration_per_window: int,
+            force_constants: List[int],
+            centers: List[int],
+            lambda_list: List[float]) -> None:
+        
+        self._windows, self._deltaU_data = self._read_double_wide_cvtrj(
+                                                    cvtrj_file,
+                                                    step_per_window, 
+                                                    equilibration_per_window,
+                                                    force_constants,
+                                                    centers,
+                                                    lambda_list
+                                                )
+            
+        if len(self._windows) != len(self._deltaU_data):
+            print(len(self._windows))
+            print(len(self._deltaU_data))
+            raise RuntimeError('Internal numbers of windows and deltaU do not match! This is a bug!')
+        
+        self._restaint_contribution = \
+            self._alchemicalRestraintContributionBulk(centers[0], centers[3], centers[5], *force_constants)
+        
+    def _read_double_wide_cvtrj(
+            self, 
+            cvtrj_file: str, 
+            step_per_window: int, 
+            equilibration_per_window: int,
+            force_constants: List[int],
+            centers: List[int],
+            lambda_list: List[float]
+        ) -> Tuple[List[Tuple[float, float]], List[Tuple[NDArray, NDArray]]]:
+        """ Read an Colvars cvtrj file and regard it as double-wide free-energy calculation. 
+            Return the window and bidirectional deltaU information.
+
+        Args:
+            cvtrj_file (str): the path of the fepout file
+            step_per_window (int): total steps of a window 
+            equilibration_per_window (int): steps of equilibration of a window
+            force_constants (List[int]) force constants of each CV.
+            centers (List[int]): the center (lambda=1) of each CV. The first N CVs are considered.
+            lambda_list (List[float]): Lambda schedule [0, ..., 1] or [1, ..., 0]
+            
+        Returns:
+            Tuple[List[Tuple[float, float]], List[Tuple[NDArray, NDArray]]]: recording the boundary and 
+                                                                             deltaU of each window of
+                                                                             bidirectional simulations
+        """
+
+        assert len(force_constants) == len(centers), "Error, The lengths of force_constants of centers are not equal!"
+
+        force_constants = np.array(force_constants)
+        centers = np.array(centers)
+        lambda_list = np.array(lambda_list)
+        
+        windows = []
+        for i in range(len(lambda_list) - 1):
+            windows.append((lambda_list[i], lambda_list[i + 1]))
+
+        deltaU_forward = []
+        deltaU_backward = []
+
+        num_CVs = len(force_constants)
+        num_windows = len(lambda_list)
+
+        with open(cvtrj_file, 'r') as input_fepout:
+            # The first window samples forward only, the last window backward only
+            window_index = 0
+
+            while True:
+                line = input_fepout.readline()
+                if not line:
+                    break
+                if line.startswith("#"):
+                    continue
+                splitedLine = line.strip().split()
+                step = int(splitedLine[0])
+                
+                if step % step_per_window == 0:
+                    # collecting deltaU
+                    deltaU_forward_per_window = []
+                    deltaU_backward_per_window = []
+
+                    while True:
+                        line = input_fepout.readline()
+                        if not line:
+                            break
+                        if line.startswith("#"):
+                            continue
+                        splitedLine = line.strip().split()
+                        step = int(splitedLine[0])
+
+                        if step % step_per_window == 0:
+                            if window_index == 0:
+                                deltaU_forward.append(deltaU_forward_per_window)
+                            elif window_index == num_windows - 1:
+                                deltaU_backward.append(deltaU_backward_per_window)
+                            else:
+                                deltaU_forward.append(deltaU_forward_per_window)
+                                deltaU_backward.append(deltaU_backward_per_window)
+                            window_index += 1
+                            break
+
+                        # equilibration
+                        if step < window_index * step_per_window + equilibration_per_window:
+                            continue
+                        else:
+                            dis = abs(np.array(splitedLine[1:1+num_CVs]).astype(float) - centers)
+                            dis[dis>180] -= 360
+                            if window_index == 0:
+                                deltaU_forward_per_window.append(0.5 * np.sum((lambda_list[window_index + 1] - lambda_list[window_index]) * force_constants * (dis**2)))
+                            elif window_index == num_windows - 1:
+                                deltaU_backward_per_window.append(0.5 * np.sum((lambda_list[window_index - 1] - lambda_list[window_index]) * force_constants * (dis**2)))
+                            else:
+                                deltaU_forward_per_window.append(0.5 * np.sum((lambda_list[window_index + 1] - lambda_list[window_index]) * force_constants * (dis**2)))
+                                deltaU_backward_per_window.append(0.5 * np.sum((lambda_list[window_index - 1] - lambda_list[window_index]) * force_constants * (dis**2)))
+        
+        if len(deltaU_forward) != len(deltaU_backward):
+            raise RuntimeError('Forward and backward data do not match!')
+        
+        deltaU = []
+        for i in range(len(deltaU_forward)):
+            deltaU.append((np.array(deltaU_forward[i]), np.array(deltaU_backward[i])))
+        
+        return windows, deltaU
+    
+    def get_data(self) -> Tuple[List[Tuple[float, float]], List[Tuple[NDArray, NDArray]]]:
+        return self._windows, self._deltaU_data
+    
+    def get_restraint_contribution(self) -> float:
+        return self._restaint_contribution
+    
+    def _alchemicalRestraintContributionBulk(
+        self, eulerTheta, polarTheta, R, 
+        forceConstantTheta=0.1, forceConstantPhi=0.1, forceConstantPsi=0.1,
+        forceConstanttheta=0.1, forceConstantphi=0.1, forceConstantR=10
+    ):
+        """contribution of (standard concentration corrected) rotational 
+           and orienetational restraints in the unbounded state
+
+        Args:
+            eulerTheta (float): restraining center of the Euler angle theta
+            polarTheta (float): restraining center of the polar angle theta
+            R (float): restraining center of anger R
+            forceConstantTheta (float): restraining force constant for euler Theta. Defaults to 0.1.
+            forceConstantPhi (float, optional): restraining force constant for euler Phi. Defaults to 0.1.
+            forceConstantPsi (float, optional): restraining force constant for euler Psi. Defaults to 0.1.
+            forceConstanttheta (float, optional): restraining force constant for polar theta. Defaults to 0.1.
+            forceConstantphi (float, optional): restraining force constant for polar phi. Defaults to 0.1.
+            forceConstantR (int, optional): restraining force constant for distance R. Defaults to 10.
+
+        Returns:
+            float: contribution of the geometric restraint in the unbound state
+        """
+
+        # degrees to rad
+        eulerTheta = math.radians(eulerTheta + 90)
+        polarTheta = math.radians(polarTheta)
+        forceConstantTheta *= (180 / math.pi)**2
+        forceConstantPhi *= (180 / math.pi)**2
+        forceConstantPsi *= (180 / math.pi)**2
+        forceConstanttheta *= (180 / math.pi)**2
+        forceConstantphi *= (180 / math.pi)**2
+
+        contribution = BOLTZMANN * 300 * math.log(
+            8 * (math.pi**2) * CSTAR / ((R**2) * math.sin(eulerTheta) * math.sin(polarTheta)) * \
+            math.sqrt(forceConstantTheta * forceConstantPhi * forceConstantPsi * forceConstanttheta * \
+            forceConstantphi * forceConstantR ) / ((2 * math.pi * BOLTZMANN * 300)**3)
+        )
+        return contribution
+
 class FEPAnalyzer:
     """ Analyze FEP simulations
     """
@@ -214,6 +395,67 @@ class FEPAnalyzer:
         self._temperature = temperature
         if len(self._windows) != len(self._deltaU_data):
             raise RuntimeError('Internal numbers of windows and deltaU do not match! This is a bug!')
+        
+    def MergeData(
+            self, 
+            window_boundaries: List[Tuple[float, float]], 
+            deltaU_data: List[Tuple[NDArray, NDArray]]
+    ) -> bool:
+        """ Merge the exist dU with another one. Used in FEP + Colvars_FEP tasks.
+            window boundaries and the number of deltaU in a window must be the same
+
+        Args:
+            window_boundaries (List[Tuple[float, float]]): boundaries of each window
+            deltaU_data (List[Tuple[NDArray, NDArray]]): deltaU for forward and backward simulations
+                                                         of each window. The two deltaU should be opposite
+                                                         numbers.
+
+        Returns:
+            bool: Whether merge is successful
+        """
+        if len(window_boundaries) != len(self._windows):
+            print(1)
+            return False
+        
+        #for i in range(len(window_boundaries)):
+        #    print(f'FEP: {self._windows[i]}   Colvars: {window_boundaries[i]}')
+        #    print(f'FEP: {len(deltaU_data[i][0])}   Colvars: {len(self._deltaU_data[i][0])}')
+
+        for i in range(len(window_boundaries)):
+            if (len(deltaU_data[i][0]) - 1) != len(self._deltaU_data[i][0]) \
+                and (len(deltaU_data[i][0]) - 1) != len(self._deltaU_data[i][0]) / 2 \
+                and len(deltaU_data[i][0]) != len(self._deltaU_data[i][0]) \
+                and len(deltaU_data[i][0]) != len(self._deltaU_data[i][0]) / 2:
+                return False
+            if (len(deltaU_data[i][1]) - 1) != len(self._deltaU_data[i][1]) \
+                and (len(deltaU_data[i][1]) - 1) != len(self._deltaU_data[i][1]) / 2 \
+                and len(deltaU_data[i][1]) != len(self._deltaU_data[i][1]) \
+                and len(deltaU_data[i][1]) != len(self._deltaU_data[i][1]) / 2:
+                return False
+            if (len(deltaU_data[i][0]) - 1) == len(self._deltaU_data[i][0]):
+                temp_forward = self._deltaU_data[i][0] + deltaU_data[i][0][:-1]
+            elif (len(deltaU_data[i][0]) - 1) == len(self._deltaU_data[i][0]) / 2:
+                temp_forward = self._deltaU_data[i][0][1::2] 
+                temp_forward += deltaU_data[i][0][:-1]
+            elif len(deltaU_data[i][0]) == len(self._deltaU_data[i][0]):
+                temp_forward = self._deltaU_data[i][0] + deltaU_data[i][0]
+            elif len(deltaU_data[i][0]) == len(self._deltaU_data[i][0]) / 2:
+                temp_forward = self._deltaU_data[i][0][1::2] 
+                temp_forward += deltaU_data[i][0]
+
+            if (len(deltaU_data[i][1]) - 1) == len(self._deltaU_data[i][1]):
+                temp_backward = self._deltaU_data[i][1] + deltaU_data[i][1][:-1]
+            elif (len(deltaU_data[i][1]) - 1) == len(self._deltaU_data[i][1]) / 2:
+                temp_backward = self._deltaU_data[i][1][::2] 
+                temp_backward += deltaU_data[i][1][:-1]
+            elif len(deltaU_data[i][1]) == len(self._deltaU_data[i][1]):
+                temp_backward = self._deltaU_data[i][1] + deltaU_data[i][1]
+            elif len(deltaU_data[i][1]) == len(self._deltaU_data[i][1]) / 2:
+                temp_backward = self._deltaU_data[i][1][::2] 
+                temp_backward += deltaU_data[i][1]
+            self._deltaU_data[i] = (temp_forward, temp_backward)
+
+        return True
     
     def FEP_free_energy(self) -> Tuple[List[Tuple[float, float]], List[NDArray], List[NDArray]]:
         """ Calculate and return the free-energy change using the FEP equation
@@ -230,7 +472,7 @@ class FEPAnalyzer:
             backward_free_energy = -BOLTZMANN * self._temperature * \
                 np.log(np.mean(np.exp(-self._deltaU_data[i][1] / (BOLTZMANN * self._temperature))))
             free_energies.append((forward_free_energy - backward_free_energy) / 2)
-            errors.append((forward_free_energy + backward_free_energy) / np.sqrt(2))
+            errors.append(np.abs(forward_free_energy + backward_free_energy) / np.sqrt(2))
         return self._windows, free_energies, errors
     
     def BAR_free_energy(
@@ -260,6 +502,14 @@ class FEPAnalyzer:
             errors.append(err)
         return self._windows, free_energies, errors
     
+    def Window_boundaries(self) -> List[Tuple[float, float]]:
+        """ Get the boundaries of windows
+
+        Returns:
+            List[Tuple[float, float]]: windows boundaries
+        """
+        return self._windows
+    
     def _BAR_estimator(self, deltaU: Tuple[NDArray, NDArray], tolerance: float = 1e-6) -> float:
         """ Estimate the free energy of a window using the BAR estimator
 

BFEE2/version.py

@@ -1,2 +1,2 @@
-__VERSION__ = '2.5.0'
-__NAMD_VERSION__ = '3.0b5'
+__VERSION__ = '3.0.0'
+__NAMD_VERSION__ = '3.0'

{bfee2-2.5.0.data → bfee2-3.0.0.data}/scripts/BFEE2Gui.py

@@ -1,18 +1,19 @@
-#!python
-###################################################
-## binding free energy estimator (BFEE) v2.x
-## by Haohao Fu (fhh2626_at_gmail.com)
-##
-## this is a completely rewritten version of BFEE
-##
-###################################################
-
-import sys
-from PySide2.QtWidgets import QApplication
-import BFEE2.gui as gui
-        
-if __name__ == '__main__':
-    
-    app = QApplication(sys.argv)
-    ex = gui.mainUI()
-    sys.exit(app.exec_())
+#!python
+###################################################
+## binding free energy estimator (BFEE) v2.x
+## by Haohao Fu (fhh2626_at_gmail.com)
+##
+## this is a completely rewritten version of BFEE
+##
+###################################################
+
+import sys
+from PySide6.QtWidgets import QApplication
+from PySide6.QtGui import QAction
+import BFEE2.gui as gui
+        
+if __name__ == '__main__':
+    
+    app = QApplication(sys.argv)
+    ex = gui.mainUI()
+    sys.exit(app.exec())

{bfee2-2.5.0.dist-info → bfee2-3.0.0.dist-info}/METADATA

@@ -1,76 +1,84 @@
-Metadata-Version: 2.1
-Name: bfee2
-Version: 2.5.0
-Summary: Binding Free Energy Estimator 2
-Home-page: https://github.com/fhh2626/BFEE2
-Author: Haohao Fu, Haochuan Chen, Wensheng Cai and Chris Chipot
-Author-email: wscai@nankai.edu.cn
-Maintainer: Haohao Fu
-Maintainer-email: fhh2626@mail.nankai.edu.cn
-License: GPLv3
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: setuptools
-Requires-Dist: pyside2
-Requires-Dist: appdirs
-Requires-Dist: MDAnalysis
-Requires-Dist: matplotlib
-Requires-Dist: numpy
-Requires-Dist: scipy
-Requires-Dist: parmed
-
-# Binding Free Energy Estimator 2
-[![DOI](https://zenodo.org/badge/322234705.svg)](https://zenodo.org/badge/latestdoi/322234705)
-
-Binding free energy estimator (BFEE) is a python-based software that automates absolute binding free energy calculations through either the alchemical or geometric route by molecular dynamics simulations.<br>
-
-## Theoretical backgrounds
-The degrees of freedom of the protein-ligand (or host-guest) system are described by a series of geometric variables (or collective variables), as firstly described by the [Karplus group](https://pubs.acs.org/doi/abs/10.1021/jp0217839). In BFEE, a generalized, best-fit-rotation-based geometric variables are used, making it in principle available to any protein-ligand complex. See [this paper](https://pubs.acs.org/doi/abs/10.1021/acs.jctc.7b00791) for introduction of these variables.<br>
-
-In the [geometric route](https://pubs.acs.org/doi/10.1021/ct3008099), the degrees of freedom is investigated one by one, through one-dimensional free-energy calculations. In BFEE, [WTM-eABF](https://pubs.acs.org/doi/abs/10.1021/acs.accounts.9b00473) is used, while other importance-sampling algorithms such as [plain eABF](https://pubs.acs.org/doi/abs/10.1021/acs.jctc.6b00447) are also acceptable.
-The [alchemical route](https://pubs.acs.org/doi/10.1021/ct3008099) is a variants of the [double decoupling method (DDM)](https://www.sciencedirect.com/science/article/pii/S0006349597787563). A thermodynamic cycle, in which the ligand and the geometric restraints are decoupled independently to guarantee the convergence of the simulations.<br>
-[这里](http://sioc-journal.cn/Jwk_hxxb/CN/10.6023/A20100489)是标准结合自由能计算方法的中文介绍.<br>
-
-## Features
-Generates all the input files for absolute binding free energy calculations;<br>
-Perform post-treatment automatedly;<br>
-Support NAMD (alchemical and geometric route) and Gromacs (geometric route) as molecular dynamics engines;<br>
-Support many file formats for the input complex structure (PSF/PDB/PRM, PRM7/RST7, TOP/PDB);<br>
-Support both rigid (exclude RMSD CV) and flexible (include RMSD CV) ligands and protein-protein complexes (streamlined geometrical route);<br>
-...<br>
-
-## Requirements
-Python 3.6+, PySide 2, numpy, scipy, matplotlib, parmed and MDAnalysis.<br>
-[NAMD 3.0 or later](https://www.ks.uiuc.edu/Development/Download/download.cgi?PackageName=NAMD) / [Colvars patched Gromacs](https://github.com/Colvars/colvars).<br>
-**Note: BFEE2 uses cutting-edge features of NAMD and Colvars. We highly suggest the end-user download the devel branch of NAMD from [here](https://gitlab.com/tcbgUIUC/namd/-/tree/devel) and patch it with [Colvars](https://github.com/Colvars/colvars) to prevent possible problems.**
-
-## Installation
-We suggest to install BFEE2 through conda. It will be safe if conda is install in a new environment<br>
-```
-conda create --name bfee   (optional)
-conda activate bfee        (optional)
-conda install -c conda-forge BFEE2
-```
-
-## Usage
-Simply run BFEE2Gui.py in terminal or PowerShell. One may need to use the absolute path on MS Windows.<br>
-A step-by-step tutorial is provided [here](https://www.nature.com/articles/s41596-021-00676-1).<br>
-A tutorial about new streamlined geometrical route is provided in the SI of [this paper](https://pubs.acs.org/doi/full/10.1021/acs.jcim.3c00487).<br>
-
-## Citations
-When possible, please consider mentioning [Fu et al. Nat. Protoc. 2022, doi:10.1038/s41596-021-00676-1](https://www.nature.com/articles/s41596-021-00676-1#citeas) when BFEE2 is used in your project.
-
-
-Additional references:<br>
-BFEE2: [Fu et al. J. Chem. Inf. Model. 2021, 61, 2116–2123](https://pubs.acs.org/doi/abs/10.1021/acs.jcim.1c00269)<br>
-Alchemical and geometric routes [Gumbart et al. J. Chem. Theory Comput. 2013, 9, 794–802](https://pubs.acs.org/doi/abs/10.1021/ct3008099)<br>
-WTM-eABF: [Fu et al. Acc. Chem. Res. 2019, 52, 3254–3264](https://pubs.acs.org/doi/abs/10.1021/acs.accounts.9b00473) and [Fu et al. J. Phys. Chem. Lett. 2018, 9, 4738–4745](https://pubs.acs.org/doi/abs/10.1021/acs.jpclett.8b01994)<br>
-Collective variables: [Fu et al. J. Chem. Theory Comput. 2017, 13, 5173–5178](https://pubs.acs.org/doi/abs/10.1021/acs.jctc.7b00791)<br>
-Colvars module: [Fiorin et al. Mol. Phys. 2013 111, 3345-3362](https://www.tandfonline.com/doi/full/10.1080/00268976.2013.813594)<br>
-"Mother" of all restraint-based binding free-energy calculations: [Hermans et al. Isr. J. Chem. 1986, 27, 225–227](https://onlinelibrary.wiley.com/doi/abs/10.1002/ijch.198600032)<br>
-
-## Contact us
-Technique issues: Haohao Fu (fhh2626@mail.nankai.edu.cn) and Haochuan Chen (yjcoshc@mail.nankai.edu.cn)<br>
-
-This software is under the [GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html) license. For more information about the copyright of BFEE, contact the corresponding authors of the aforementioned papers (wscai@nankai.edu.cn, Christophe.Chipot@univ-lorraine.fr).
+Metadata-Version: 2.4
+Name: bfee2
+Version: 3.0.0
+Summary: Binding Free Energy Estimator 2
+Home-page: https://github.com/fhh2626/BFEE2
+Author: Haohao Fu, Haochuan Chen, Hengwei Bian, Wensheng Cai, Chris Chipot
+Author-email: fhh2626@nankai.edu.cn
+Maintainer: Haohao Fu
+Maintainer-email: fhh2626@nankai.edu.cn
+License: GPLv3
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: setuptools
+Requires-Dist: pyside6
+Requires-Dist: appdirs
+Requires-Dist: MDAnalysis
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: parmed
+Dynamic: license-file
+
+# Binding Free Energy Estimator 3
+[![DOI](https://zenodo.org/badge/322234705.svg)](https://zenodo.org/badge/latestdoi/322234705)
+[![Downloads](https://static.pepy.tech/badge/bfee2)](https://pepy.tech/project/bfee2)
+
+**Binding free energy estimator 3 (BFEE3) has come! There are three major upgrades in BFEE3: (1) LDDM, a high-throughput alchemical route for absolute binding free-energy calculations; (2) streamlined geometrical route for protein-protien binding free-energy calculations and (3) quick settings for common calculations.**
+
+BFEE is a python-based software that automates absolute binding free energy calculations through either the alchemical or geometric route by molecular dynamics simulations.<br>
+
+## Theoretical backgrounds
+The degrees of freedom of the protein-ligand (or host-guest) system are described by a series of geometric variables (or collective variables), as firstly described by the [Karplus group](https://pubs.acs.org/doi/abs/10.1021/jp0217839). In BFEE, a generalized, best-fit-rotation-based geometric variables are used, making it in principle available to any protein-ligand complex. See [this paper](https://pubs.acs.org/doi/abs/10.1021/acs.jctc.7b00791) for introduction of these variables.<br>
+
+In the [geometric route](https://pubs.acs.org/doi/10.1021/ct3008099), the degrees of freedom is investigated one by one, through one-dimensional free-energy calculations. In BFEE, [WTM-eABF](https://pubs.acs.org/doi/abs/10.1021/acs.accounts.9b00473) is used, while other importance-sampling algorithms such as [plain eABF](https://pubs.acs.org/doi/abs/10.1021/acs.jctc.6b00447) are also acceptable.
+The [alchemical route](https://pubs.acs.org/doi/10.1021/ct3008099) is a variants of the [double decoupling method (DDM)](https://www.sciencedirect.com/science/article/pii/S0006349597787563). A thermodynamic cycle, in which the ligand and the geometric restraints are decoupled independently to guarantee the convergence of the simulations.<br>
+[这里](http://sioc-journal.cn/Jwk_hxxb/CN/10.6023/A20100489)是标准结合自由能计算方法的中文介绍.<br>
+
+## Features
+Generates all the input files for absolute binding free energy calculations;<br>
+Support Protein-protein and protein-ligand complexes;<br>
+Perform post-treatment automatedly;<br>
+Support NAMD (alchemical and geometric route) and Gromacs (geometric route) as molecular dynamics engines;<br>
+Support many file formats for the input complex structure (PSF/PDB/PRM, PRM7/RST7, TOP/PDB);<br>
+Support both rigid (exclude RMSD CV) and flexible (include RMSD CV) ligands and protein-protein complexes (streamlined geometrical route);<br>
+...<br>
+
+## Requirements
+Python 3.6+, PySide 2, numpy, scipy, matplotlib, parmed and MDAnalysis.<br>
+[NAMD 3.0 or later](https://www.ks.uiuc.edu/Development/Download/download.cgi?PackageName=NAMD) / [GROMACS 2024 or later](https://manual.gromacs.org/).<br>
+**Note: Since both NAMD and Gromacs have incorporated Colvars in their latest binaries. Each release of BFEE3 corresponds to a version of NAMD/Gromacs. Please always use
+the corresponding or later versions of the MD engines for free-energy calculations!**
+
+## Installation
+We suggest to install BFEE through conda. It will be safe if conda is install in a new environment<br>
+```
+conda create --name bfee   (optional)
+conda activate bfee        (optional)
+conda install -c conda-forge BFEE2
+```
+
+## Usage
+Simply run BFEE2Gui.py in terminal or PowerShell. One may need to use the absolute path on MS Windows.<br>
+A step-by-step tutorial is provided [here](https://www.nature.com/articles/s41596-021-00676-1).<br>
+A tutorial about new streamlined geometrical route is provided in the SI of [this paper](https://pubs.acs.org/doi/full/10.1021/acs.jcim.3c00487).<br>
+
+## Test files
+One can download the Supplement Data [here](https://www.nature.com/articles/s41596-021-00676-1#Sec47) for testing BFEE3.
+
+## Citations
+When possible, please consider mentioning [Fu et al. Nat. Protoc. 2022, doi:10.1038/s41596-021-00676-1](https://www.nature.com/articles/s41596-021-00676-1#citeas) when BFEE is used in your project.
+
+
+Additional references:<br>
+BFEE2: [Fu et al. J. Chem. Inf. Model. 2021, 61, 2116–2123](https://pubs.acs.org/doi/abs/10.1021/acs.jcim.1c00269)<br>
+BFEE2 for protein-protein binding free energy calculations [Fu et al. J. Chem. Inf. Model. 2023, 63, 2512–2519](https://pubs.acs.org/doi/full/10.1021/acs.jcim.3c00487)<br>
+Alchemical and geometric routes [Gumbart et al. J. Chem. Theory Comput. 2013, 9, 794–802](https://pubs.acs.org/doi/abs/10.1021/ct3008099)<br>
+WTM-eABF: [Fu et al. Acc. Chem. Res. 2019, 52, 3254–3264](https://pubs.acs.org/doi/abs/10.1021/acs.accounts.9b00473) and [Fu et al. J. Phys. Chem. Lett. 2018, 9, 4738–4745](https://pubs.acs.org/doi/abs/10.1021/acs.jpclett.8b01994)<br>
+Collective variables: [Fu et al. J. Chem. Theory Comput. 2017, 13, 5173–5178](https://pubs.acs.org/doi/abs/10.1021/acs.jctc.7b00791)<br>
+Colvars module: [Fiorin et al. Mol. Phys. 2013 111, 3345-3362](https://www.tandfonline.com/doi/full/10.1080/00268976.2013.813594)<br>
+"Mother" of all restraint-based binding free-energy calculations: [Hermans et al. Isr. J. Chem. 1986, 27, 225–227](https://onlinelibrary.wiley.com/doi/abs/10.1002/ijch.198600032)<br>
+
+## Contact us
+This software is under the [GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html) license. For more information about BFEE, contact Haohao Fu (fhh2626@nankai.edu.cn) and Haochuan Chen (yjcoshc@mail.nankai.edu.cn).

{bfee2-2.5.0.dist-info → bfee2-3.0.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
 BFEE2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-BFEE2/gui.py,sha256=RbWeGiuhljYb0CFTiamHrSgBcLEAh5FrjOFKkzfOZ14,101330
-BFEE2/inputGenerator.py,sha256=DjQPNvcB0hlToAxx27hVaLwMslEnx_gekLcEVASz1bE,139316
-BFEE2/postTreatment.py,sha256=lC8nB7xyLODxJcAqVNbmmMKNRGKW4VinXeN5HADFCe4,20408
-BFEE2/version.py,sha256=E7P4nPNcQO652COodOtIHFiQJcyAuN7QsQ2FSFOcGqs,49
+BFEE2/gui.py,sha256=_4sovHYznBzJKN5QMAjAC03lnm9m9UlQPq4mJxpXrdo,117558
+BFEE2/inputGenerator.py,sha256=htPz5agO8Bga-Csh7gTZH4cL945UUy4b-ddRysOy6Xg,141967
+BFEE2/postTreatment.py,sha256=iPnNxkcjdYq6MOdemivUuqn7P5Mk9B3rliXj1KY9Byo,27322
+BFEE2/version.py,sha256=kHkWNpvUvNztsx3fwXyEpOqmNt8Vhb59Vq0xlbR5jAI,47
 BFEE2/commonTools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-BFEE2/commonTools/commonSlots.py,sha256=CQ8ISiF7JNmL0Bl9KujcprufjHz1lSmgHqDu0aVO2e8,1450
+BFEE2/commonTools/commonSlots.py,sha256=8u9WJg12Y98WMArLaekWy3oZqBLzyc1tsRcsim8DrU4,1450
 BFEE2/commonTools/fileParser.py,sha256=0JwDcOx6bNnkl98yB279E0iJv3yHP0Yx9INSc7ZRBWQ,11005
 BFEE2/commonTools/ploter.py,sha256=9m0_sW_sQpuabWML1uHMlsGgRcRtu-dwlJ9vXUPK4SM,5677
 BFEE2/doc/Doc.pdf,sha256=zR_QAUa15IIjbpyyflx4N89NjUN5j2pHXozMaAW7QJE,143522
@@ -45,9 +45,10 @@ BFEE2/templates_gromacs/BFEEGromacs.py,sha256=74eTWo78JL-63uwDz9iV2JISD5YKM3_CUz
 BFEE2/templates_gromacs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 BFEE2/templates_gromacs/find_min_max.awk,sha256=nCbymmZzIhMeEFJFmRD-FoQOASxPyMJDNuubAHBsoks,394
 BFEE2/templates_namd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-BFEE2/templates_namd/configTemplate.py,sha256=I7A6TpUlYLQ-K1kOaVbiH_u79oAfgN2PolU9pIe70H8,45274
+BFEE2/templates_namd/configTemplate.py,sha256=1yU6oENU2BlkhkNDP0IzpKuktlFijJp1WjIe9e3PNKE,45457
 BFEE2/templates_namd/fep.tcl,sha256=cXmnn5VQB-erUXvJktfuDZG-EkMjWjDXVpALYVW7HdA,8601
-BFEE2/templates_namd/scriptTemplate.py,sha256=IJnkdBPo0dfXt2dbW87nHZlbPJYHKgCCudmnEYqHrVU,4809
+BFEE2/templates_namd/fep_lddm.tcl,sha256=Ct_Jg0bKv6BtUVSoJZyL_tKViUzjduq57hp9GqecAbo,8695
+BFEE2/templates_namd/scriptTemplate.py,sha256=d0S4cbFNle-CbN0MpyVYLOWpzxhHBDsPtlujUaQS8GY,11072
 BFEE2/templates_namd/solvate.tcl,sha256=zJj9x0mPGAa9itPWyZLPWtcoN8oVBoRz5lBH3qJEXX8,302
 BFEE2/templates_namd/solvate_mem.tcl,sha256=NcsE04VQV1avszP5KEJyzslkn4k3EqtgFbhXa_vSUK4,298
 BFEE2/templates_namd/updateCenters.py,sha256=oIVba4hkSE4ip1EcNBFDTP3bBSkMO0yq9klbA6q2Fxk,11661
@@ -56,10 +57,10 @@ BFEE2/templates_readme/Readme_NAMD_Alchemical.txt,sha256=ELWMpk7xNq_lVHfm9A5hKWE
 BFEE2/templates_readme/Readme_NAMD_Geometrical.txt,sha256=nE2osdeS94PVHv_cb9Lx3AEItc0ftRXqmUcdqd6T00c,1492
 BFEE2/templates_readme/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 BFEE2/third_party/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-BFEE2/third_party/py_bar.py,sha256=BrlMgcG_LuvyNEk6Y0rUD3bQ-FwqdTuOr1M-EsaQ1ZE,15071
-bfee2-2.5.0.data/scripts/BFEE2Gui.py,sha256=fVwzX2dtqc0_Re3thZq-NRzJtIbA4p9jK8Umx_aXxG4,454
-bfee2-2.5.0.dist-info/LICENSE,sha256=D49NePXWPL2DWuRjzaaLEJCI-g7Td73f4Fn21ixqGQo,35349
-bfee2-2.5.0.dist-info/METADATA,sha256=ER_peJZNJDlIHBrZqrJ_nzP5jXag7wEJCdOmgSHUhho,5540
-bfee2-2.5.0.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-bfee2-2.5.0.dist-info/top_level.txt,sha256=O5qOOi90gwZ9axrUPYy9I-ZiwgfPd-sc6NTQnKWh1LA,6
-bfee2-2.5.0.dist-info/RECORD,,
+BFEE2/third_party/py_bar.py,sha256=xiD1O5OJqTutEKLxHVuJOfFvNcNgK-1GbvAq9VfbHSk,27353
+bfee2-3.0.0.data/scripts/BFEE2Gui.py,sha256=-8au9eZwRLzmID5MFNm8sf6B-0OhgLuDlSTbgKEAmnU,506
+bfee2-3.0.0.dist-info/licenses/LICENSE,sha256=D49NePXWPL2DWuRjzaaLEJCI-g7Td73f4Fn21ixqGQo,35349
+bfee2-3.0.0.dist-info/METADATA,sha256=ZrEpkAVAH9J4RE8-Zi_KzxhIPUczBBTJMZp7p0jPTAk,6204
+bfee2-3.0.0.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+bfee2-3.0.0.dist-info/top_level.txt,sha256=O5qOOi90gwZ9axrUPYy9I-ZiwgfPd-sc6NTQnKWh1LA,6
+bfee2-3.0.0.dist-info/RECORD,,

{bfee2-2.5.0.dist-info → bfee2-3.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.40.0)
+Generator: setuptools (79.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any