bfee2 3.1.1.post1__py3-none-any.whl

BFEE2/commonTools/commonSlots.py

@@ -0,0 +1,48 @@
+# simple and general slots called by gui.py
+
+from PySide6.QtWidgets import QLineEdit, QFileDialog, QMessageBox
+
+def openFileDialog(fileType, lineEdit):
+    """return a openFile function that opens special type of files
+       the openFile dialog is connected with a lineEdit widget
+
+    Args:
+        fileType (str): the file type for opening
+        lineEdit (QLineEdit): the QLineEdit that connects to the QFileDialog
+
+    Returns:
+        function obj: slot function opening special type of files
+    """    
+    
+    def openFile():
+        fileName, _ = QFileDialog.getOpenFileName(
+            None,
+            f'Choose {fileType} file',
+            '',
+            f'All Files (*)'
+        )
+        lineEdit.setText(fileName)
+    return openFile
+
+def openFilesDialog(fileType, listWidget):
+    """return a openFile function that opens a series of files
+       the openFile dialog is connected with a QListWidget
+
+    Args:
+        fileType (str): the file type for opening
+        listWidget (QListWidget): the QListWidget that connects to the QFileDialog
+
+    Returns:
+        function obj: slot function opening a series of files
+    """    
+
+    def openFiles():
+
+        fileNames, _ = QFileDialog.getOpenFileNames(
+            None,
+            f'Choose {fileType} files',
+            '',
+            f'All Files (*)'
+        )
+        listWidget.addItems(fileNames)
+    return openFiles

BFEE2/commonTools/fileParser.py

@@ -0,0 +1,327 @@
+# file parser used in bfee
+
+import math
+import os
+import shutil
+import sys
+
+import MDAnalysis
+import numpy as np
+import parmed
+from MDAnalysis import transformations
+
+
+# an runtime error
+# selection corresponding to nothing
+class SelectionError(RuntimeError):
+    def __init__(self, arg):
+        self.args = arg
+
+class fileParser:
+    """topology and coordinate parser,
+       this class implements basic method for the topology and
+       coordinate file, used by BFEE
+    """    
+
+    def __init__(self, topFile, coorFile=''):
+        """initialize fileParser, on coorFile is not provided, then 
+           topFile is considered as a top-coor file, such as mol2
+
+        Args:
+            topFile (str): path of the topology (psf, parm) file
+            coorFile (str): path of the coordinate (pdb, rst) file. Defaults to ''.
+        """        
+
+        coorPostfix = os.path.splitext(coorFile)[-1]
+        if coorPostfix == '.rst7' or coorPostfix == '.rst' or coorPostfix == '.inpcrd':
+            coorType = 'inpcrd'
+
+        if coorFile == '':
+            self.uObject = MDAnalysis.Universe(topFile)
+        else:
+            # MDAnalysis does not well recognize amber file type by postfix
+            coorPostfix = os.path.splitext(coorFile)[-1]
+            if coorPostfix == '.rst7' or coorPostfix == '.rst' or coorPostfix == '.inpcrd':
+                coorType = 'INPCRD'
+                self.uObject = MDAnalysis.Universe(topFile, coorFile, format=coorType)
+            else:
+                self.uObject = MDAnalysis.Universe(topFile, coorFile)
+        self.uObject.add_TopologyAttr('tempfactors')
+        self.topPath = topFile
+
+    def saveFile(self, selection, targetPath, targetType, saveTop=False, topPath=''):
+        """save the coordinate file to the target type 
+           this function cannot really 'save' the topology file,
+           it can only copy the original topology to the target path
+
+        Args:
+            selection (str): selection of atoms to save
+            targetPath (str): path for the coor file to be saved
+            targetType (str): type of the coor file (pdb, xyz)
+            saveTop (bool): whether the topology file will be saved. Defaults to False.
+            topPath (str, optional): path for the topology file to be saved. Defaults to ''.
+
+        Raises:
+            SelectionError: if the selection corresponds to nothing
+        """ 
+
+        atoms = self.uObject.select_atoms(selection)
+
+        if len(atoms) == 0:
+            raise SelectionError('Empty selection!')
+
+        atoms.write(targetPath, targetType, bonds=None)
+        if saveTop:
+            assert(selection == 'all')
+            shutil.copyfile(self.topPath, topPath)
+
+    def saveNDX(self, selections, names, targetPath, nonHydrogen=True):
+        """save an ndx file, including the selections
+
+        Args:
+            selections (list of str): the selections for the ndx file
+            names (list of str): the name in ndx of each selection
+            targetPath (str): path for the file to be saved
+            nonHydrogen (bool, optional): whether only non-H atoms are considered. Defaults to True.
+
+        Raises:
+            SelectionError: if the selection corresponds to nothing
+        """
+
+        assert(len(selections) == len(names))
+
+        if nonHydrogen == True:
+            HString = 'and not (name H*)'
+        else:
+            HString = ''
+
+        for selection, name in zip(selections, names):
+            atoms = self.uObject.select_atoms(f'{selection} {HString}')
+            
+            if len(atoms) == 0:
+                raise SelectionError('Empty selection!')
+        
+            atoms.write(targetPath, 'ndx', name=name, mode='a')
+
+    def getResid(self, selection):
+        """return a string listing the resid of the selection
+           may be used to generate amber masks
+
+        Args:
+            selection (str): MDAnalysis selection
+
+        Raises:
+            SelectionError: if the selection corresponds to nothing
+
+        Returns:
+            str: a list of resid, e.g. (4,5,6,7,8,9,10)
+        """        
+
+        atoms = self.uObject.select_atoms(selection)
+        
+        if len(atoms) == 0:
+            raise SelectionError('Empty selection!')
+        
+        return ','.join([str(num+1) for num in atoms.residues.ix])
+
+    def measureMinmax(self, selection):
+        """mimic VMD measure minmax
+
+        Args:
+            selection (str): selection of atoms
+
+        Raises:
+            SelectionError: if the selection corresponds to nothing
+            
+        Returns:
+            np.array (2*3, float): ((minX, minY, minZ), (maxX, maxY, maxZ))
+        """        
+
+        atoms = self.uObject.select_atoms(selection)
+        
+        if len(atoms) == 0:
+            raise SelectionError('Empty selection!')
+        
+        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([[min_x, min_y, min_z],[max_x, max_y, max_z]])
+
+    def measureCenter(self, selection):
+        """mimic vmd measure center
+
+        Args:
+            selection (str): selection of atoms
+            
+        Raises:
+            SelectionError: if the selection corresponds to nothing
+
+        Returns:
+            np.array (3, float): (x, y, z)
+        """        
+
+        atoms = self.uObject.select_atoms(selection)
+        
+        if len(atoms) == 0:
+            raise SelectionError('Empty selection!')
+        
+        atomPositions = atoms.positions
+        xyz_array = np.transpose(atomPositions)
+        center_x = np.average(xyz_array[0])
+        center_y = np.average(xyz_array[1])
+        center_z = np.average(xyz_array[2])
+
+        return np.array([center_x, center_y, center_z])
+
+    def measureDistance(self, selection1, selection2):
+        """measure the distance between the center of mass
+           of two atom groups
+
+        Args:
+            selection1 (str): selection of atom group 1
+            selection2 (str): selection of atom group 2
+
+        Returns:
+            float: distance between the center of mass of the two atom groups
+        """        
+
+        center1 = self.measureCenter(selection1)
+        center2 = self.measureCenter(selection2)
+        return round(np.linalg.norm(center2 - center1), 1)
+
+    def measurePBC(self):
+        """measure periodic boundary condition of the file
+
+        Returns:
+            np.array (2*3, float): ((lengthX, lengthY, lengthZ), (centerX, centerY, centerZ))
+        """        
+
+        minmaxArray = self.measureMinmax('all')
+        vec = minmaxArray[1] - minmaxArray[0]
+        center = self.measureCenter('all')
+
+        return np.array((vec, center))
+
+    def measurePolarAngles(self, selectionPro, selectionLig):
+        """calculation the polar angles based on selectionPro and selectionLig
+
+        Args:
+            selectionPro (str): selection of the host molecule
+            selectionLig (str): selection of the ligand molecule
+
+        Returns:
+            np.array (2, float): (theta, phi) in degrees
+        """        
+        
+        vector = self.measureCenter(selectionLig) - self.measureCenter(selectionPro)
+        vector /= np.linalg.norm(vector)
+
+        return (float(int(math.degrees(np.arccos(-vector[1])))), float(int(math.degrees(np.arctan2(vector[2], vector[0])))))
+
+    def setBeta(self, selection, beta):
+        """set beta for the selected atoms
+
+        Args:
+            selection (str): selection of atoms to change beta
+            beta (int): beta value
+
+        Raises:
+            SelectionError: if the selection corresponds to nothing
+        """        
+
+        atoms = self.uObject.select_atoms(selection)
+        
+        if len(atoms) == 0:
+            raise SelectionError('Empty selection!')
+        
+        atoms.tempfactors = beta
+
+    def moveSystem(self, moveVector):
+        """move all the atoms in the loaded file
+
+        Args:
+            moveVector (np.array, 3, float): the vector of moving
+        """        
+
+        allAtoms = self.uObject.select_atoms('all')
+        transformations.translate(moveVector)(allAtoms)
+
+    def rotateSystem(self, axis, degrees):
+        """rotate all the atoms in the loaded file
+
+        Args:
+            axis (str): 'x' or 'y' or 'z'
+            degrees (float): degrees to move by
+        """        
+
+        assert(axis == 'x' or axis == 'y' or axis == 'z')
+
+        allAtoms = self.uObject.select_atoms('all')
+        if axis == 'x':
+            axisVector = (1,0,0)
+        elif axis == 'y':
+            axisVector = (0,1,0)
+        else:
+            axisVector = (0,0,1)
+        transformations.rotate.rotateby(degrees, axisVector, ag=allAtoms)(allAtoms)
+
+    def centerSystem(self):
+        """move all the atoms in the loaded file, 
+           such that the center of system be (0,0,0)
+        """
+
+        vec = self.measurePBC()[1] * -1.0
+        self.moveSystem(vec)
+        
+def charmmToGromacs(psfFile, pdbFile, prmFiles, PBC, outputPrefix):
+    """convert a set of CHARMM files (psf + pdb + prm + pbc) into the Gromacs format
+
+    Args:
+        psfFile (str): path of the psf file
+        pdbFile (str): path of the pdb file
+        prmFiles (list of str): pathes of the prm files
+        PBC (list of flost): pbc information
+        outputPrefix (str): path + prefix of the output file
+    """
+    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')
+
+def amberToGromacs(parmFile, rstFile, PBC, outputPrefix):
+    """convert a set of Amber files (parm7 + rst7) into the Gromacs format
+
+    Args:
+        parmFile (str): path of the parm7 file
+        rstFile (str): path of the rst7 file
+        PBC (list of flost): pbc information
+        outputPrefix (str): path + prefix of the output file
+    """
+    struct = parmed.load_file(parmFile, xyz=rstFile)
+    struct.box = [PBC[0], PBC[1], PBC[2], 90, 90, 90]
+    struct.save(f'{outputPrefix}.top', format='gromacs')
+    struct.save(f'{outputPrefix}.gro')
+
+def gromacsToAmber(topFile, groFile, PBC, outputPrefix):
+    """convert a set of Gromacs files (top + gro/pdb) into the Amber format
+
+    Args:
+        topFile (str): path of the top file
+        groFile (str): path of the gro file
+        PBC (list of flost): pbc information
+        outputPrefix (str): path + prefix of the output file
+    """
+    struct = parmed.load_file(topFile, xyz=groFile)
+    struct.box = [PBC[0], PBC[1], PBC[2], 90, 90, 90]
+    struct.save(f'{outputPrefix}.parm7', format='amber')
+    struct.save(f'{outputPrefix}.rst7', format='rst7') 

BFEE2/commonTools/ploter.py

@@ -0,0 +1,218 @@
+# plot figures
+
+import math
+import os
+import pathlib
+
+import matplotlib
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy import interpolate
+
+
+# an runtime error
+# does not have corresponding correction for a pmf
+class NoCorrectionFileError(RuntimeError):
+    def __init__(self, arg):
+        self.args = arg
+
+def isGaWTM(pmfFiles):
+    """determine whether the input PMFs indicate Gs-WTM simulations
+
+    Args:
+        pmfFiles (list[str]): path to a set of PMFs (and pmf corrections)
+    
+    Returns:
+        bool: GaWTM simulation or not
+    """
+
+    for file in pmfFiles:
+        if ''.join(pathlib.Path(file).suffixes) == '.reweightamd1.cumulant.pmf':
+            return True
+    return False
+
+def correctGaWTM(pmfFile):
+    """read a 1D namd PMF file and correct it using cumulant.pmf file
+
+    Args:
+        pmfFile (str): path to the pmf File
+    
+    Returns:
+        np.array (N*2): 1D PMF
+    """
+
+    pmf = np.loadtxt(pmfFile)
+    correction_pmfFile = pmfFile.replace('.czar.pmf', '') + '.reweightamd1.cumulant.pmf'
+
+    if not os.path.exists(correction_pmfFile):
+        raise NoCorrectionFileError(f'{pmfFile} does not have a corresponding correction!')
+
+    correction_data = np.loadtxt(correction_pmfFile)
+    correction_interpolate = interpolate.interp1d(correction_data[:,0], correction_data[:,1], fill_value="extrapolate")
+
+    pmf[:,1] += correction_interpolate(pmf[:,0])
+
+    return pmf
+
+def readPMF(pmfFile):
+    """read a 1D namd PMF file
+
+    Args:
+        pmfFile (str): path to the pmf File
+
+    Returns:
+        np.array (N*2): 1D PMF
+    """
+
+    return np.loadtxt(pmfFile)
+
+def mergePMF(pmfFiles):
+    """merge several PMF files
+
+    Args:
+        pmfFiles (list of np.arrays): list of 1D pmfs
+
+    Returns:
+        np.array (N*2): merged PMF if the PMFs overlap, pmfFiles[0] otherwise
+    """    
+    
+    numPmfs = len(pmfFiles)
+    assert(numPmfs > 0)
+    
+    # sort pmfs
+    pmfSort = [i for i in range(numPmfs)]
+    pmfSort.sort(key=lambda x: pmfFiles[x][0][0])
+    
+    finalPMF = pmfFiles[pmfSort[0]]
+    
+    if len(pmfFiles) > 1:
+        for i in range(1, len(pmfFiles)):
+            for j in range(len(finalPMF)):
+                if finalPMF[j][0] == pmfFiles[pmfSort[i]][0][0]:
+                    # overlapped region
+                    avgDifference = np.average(finalPMF[j:,1:] - pmfFiles[pmfSort[i]][0:len(finalPMF)-j,1:])
+                    pmfFiles[pmfSort[i]][:,1:] += avgDifference
+                    finalPMF[j:,1:] = (finalPMF[j:,1:] + pmfFiles[pmfSort[i]][0:len(finalPMF)-j,1:]) / 2
+                    # other region
+                    finalPMF = np.append(finalPMF, pmfFiles[pmfSort[i]][len(finalPMF)-j:], axis=0)
+                    break
+
+    finalPMF[:,1] -= finalPMF[:,1].min()
+
+    return finalPMF
+
+def writePMF(pmfFile, pmf):
+    """write a 1D namd PMF file
+
+    Args:
+        pmfFile (str): path to the pmf File
+        pmf (np.array, N*2): pmf to be written
+    """
+
+    np.savetxt(pmfFile, pmf, fmt='%g')
+
+def plotPMF(pmf):
+    """plot a pmf
+
+    Args:
+        pmf (np.array, N*2): pmf to be plotted
+    """
+    
+    plt.plot(pmf[:,0], pmf[:,1])
+    plt.xlabel('Transition coordinate')
+    plt.ylabel('ΔG (kcal/mol)')
+    plt.show()
+
+def plotHysteresis(forwardProfile, backwardProfile):
+    """plot the profile describing the hysteresis between forward and backward
+       simulations
+
+    Args:
+        forwardProfile (np.array, N*2): forward free-energy profile to be plotted
+        backwardProfile (np.array, N*2): backward free-energy profile to be plotted
+    """
+    
+    plt.plot(forwardProfile[:,0], forwardProfile[:,1], label='Forward')
+    plt.plot(backwardProfile[:,0], backwardProfile[:,1], label='Backward')
+    plt.xlabel('Lambda')
+    plt.ylabel('ΔG (kcal/mol)')
+    plt.legend()
+    plt.show()
+
+def calcRMSD(inputArray):
+    """calculate RMSD of a np.array with respect to (0,0,0,...0)
+
+    Args:
+        inputArray (1D np.array): the input array
+
+    Returns:
+        float: RMSD of a np.array with respect to (0,0,0,...0)
+    """    
+
+    sumG2 = sum(map(lambda x: x * x, inputArray))
+    return math.sqrt(sumG2 / len(inputArray))
+
+def readFrame(input):
+    """read a frame of Colvars hist file and calculate its RMSD with respect to zero array
+
+    Args:
+        input (python file object): input object
+
+    Returns:
+        float: RMSD with respect to zero array
+    """
+
+    G = []
+    while True:
+        line = input.readline()
+        
+        # end of file
+        if not line:
+            return False
+            
+        splitedLine = line.strip().split()
+        if splitedLine == []:
+            if G == []:
+                continue
+            else:
+                break
+        if splitedLine[0].startswith('#'):
+            continue
+
+        G.append(float(splitedLine[1]))
+
+    if G != []:
+        return calcRMSD(G)
+    else:
+        return None
+
+def parseHistFile(histPath):
+    """parse a hist.czar.pmf file and return frame-RMSD list
+
+    Args:
+        histPath (str): path to a hist.czar.pmf file
+
+    Returns:
+        1D np.array: time evolution of RMSD with respect to zero array
+    """    
+    
+    rmsd = []
+    with open(histPath, 'r') as ifile:
+        while True:
+            rmsdPerFrame = readFrame(ifile)
+            if rmsdPerFrame is False:
+                break
+            rmsd.append(rmsdPerFrame)
+    return rmsd
+
+def plotConvergence(rmsdList):
+    """plot the time evolution of PMF rmsd
+
+    Args:
+        rmsdList (list or 1D np.array, float): time evolution of RMSD with respect to zero array
+    """    
+
+    plt.plot(range(1, len(rmsdList) + 1), rmsdList)
+    plt.xlabel('Frame')
+    plt.ylabel('RMSD (Colvars Unit)')
+    plt.show()

BFEE2/doc/__init__.py

@@ -0,0 +1 @@
+