diff --git a/.gitignore b/.gitignore index f3ead9c..6f51459 100644 --- a/.gitignore +++ b/.gitignore @@ -31,6 +31,7 @@ docs/_build/ # Data output directories */structures/ +report/* */*_test/ structures/ structures*/ diff --git a/PyCEC/analysis/analysis.py b/PyCEC/analysis/analysis.py index c57a5a5..1f37e50 100644 --- a/PyCEC/analysis/analysis.py +++ b/PyCEC/analysis/analysis.py @@ -8,6 +8,7 @@ from tqdm import tqdm from matplotlib import pyplot as plt +import seaborn as sns import numpy as np @@ -23,6 +24,7 @@ def __init__(self, universe, initial_resid, target_resid, self.initial_resid = initial_resid self.target_resid = target_resid self.other_resids = other_resids + self.all_resids = initial_resid + target_resid + other_resids self.ligand = ligand self.cyzone_dim = cyzone_dim self.frame_n = frame_n @@ -89,6 +91,7 @@ def __init__(self, universe, initial_resid, target_resid, other_resids, self.initial_resid = initial_resid self.target_resid = target_resid self.other_resids = other_resids + self.all_resids = [initial_resid] + [target_resid] + other_resids self.ligand = ligand self.cyzone_dim = cyzone_dim self.frame_n = frame_n # TODO: is frame relevant here? @@ -125,6 +128,9 @@ def get_hydrogen_bonds(self, donors_sel=None, hydrogens_sel=None, """ # Create the HBA object + # hba = HBA(universe=self.u, donors_sel=donors_sel, + # hydrogens_sel=hydrogens_sel, acceptors_sel=acceptors_sel, + # d_h_cutoff=distance_cutoff, d_h_a_angle_cutoff=angle_cutoff) hba = HBA(universe=self.u, donors_sel=donors_sel, hydrogens_sel=hydrogens_sel, acceptors_sel=acceptors_sel, d_h_cutoff=distance_cutoff, d_h_a_angle_cutoff=angle_cutoff) @@ -133,35 +139,253 @@ def get_hydrogen_bonds(self, donors_sel=None, hydrogens_sel=None, # Get counts counts = hba.count_by_time() - def get_water_h_bonds(self, distance_cutoff=3.5, angle_cutoff=120.0): + return counts + + + def get_water_h_bonds(self, distance_cutoff=3.5, angle_cutoff=120.0, waters_only=True): """ Get the hydrogen bonds between the water molecules. """ # Get the hydrogen bonds - counts = self.get_hydrogen_bonds(donors_sel=self.waters_sele_str, - hydrogens_sel=self.waters_sele_str, - acceptors_sel=self.waters_sele_str, - distance_cutoff=distance_cutoff, - angle_cutoff=angle_cutoff) + if waters_only: + counts = self.get_hydrogen_bonds(donors_sel=self.cv.waters_sele_str, + hydrogens_sel=self.cv.waters_sele_str, + acceptors_sel=self.cv.waters_sele_str, + distance_cutoff=distance_cutoff, + angle_cutoff=angle_cutoff) + else: + counts = self.get_hydrogen_bonds(donors_sel=self.cv.qm_all_sele_br_str, + hydrogens_sel=self.cv.qm_all_sele_br_str, + acceptors_sel=self.cv.qm_all_sele_br_str, + distance_cutoff=distance_cutoff, + angle_cutoff=angle_cutoff) + + print(len(counts)) return counts - def plot_hbond_counts(self, counts, save=False): + def plot_hbond_counts(self, counts, save=False, filename=None, title=None): """ Plot the hydrogen bond counts. - """ fig, ax = plt.subplots() - ax.plot(self.times, counts) + ax.plot(self.times, counts, color='black', lw=1) ax.set_ylabel("Number of hydrogen bonds") ax.set_xlabel("Frame number") - ax.set_title("Hydrogen bond counts over time") + if title: + ax.set_title(title) + else: + ax.set_title("Hydrogen bond counts over time") + ax.ticklabel_format(style='plain') + + if save: + if filename: + fig.savefig(filename, dpi=300) + else: + fig.savefig('hbond_counts.png', dpi=300) + + plt.show() + + def plot_multiple_hbond_counts_grid( + self, + parameter='cyzone_dim', + ncols=2, + values=[[9, 8, -8], [9, 8, -8]], + save=False, + filename=None, + title=None, + distance_cutoff=3.5, + angle_cutoff=120.0, + waters_only=True + ): + """ + Plot multiple hydrogen bond counts in a grid. + """ + + import math + num_plots = len(values) + nrows = math.ceil(num_plots / ncols) # Calculate the required number of rows + + # Create subplots with nrows and ncols + fig, axes = plt.subplots( + nrows=nrows, + ncols=ncols, + figsize=(6 * ncols, 4 * nrows), + sharey=True + ) + + # Flatten axes if it's a 2D array for easier indexing + axes = axes.flatten() + + for i, value in enumerate(values): + if parameter == 'cyzone_dim': + print(f"Setting cyzone_dim to {value}") + self.cv.set_cyzone_dim(value) + print(f"{len(self.cv.waters.atoms)} waters selected.") + print(f"{len(self.cv.qm_all.atoms)} atoms selected.\n") + counts = self.get_water_h_bonds( + distance_cutoff=distance_cutoff, + angle_cutoff=angle_cutoff, + waters_only=waters_only + ) + _, _ = self.get_max_hbond_counts(counts) + + else: + pass + ax = axes[i] + ax.plot(self.times, counts, color='black', lw=1) + ax.set_ylabel("Number of hydrogen bonds") + ax.set_xlabel("Frame number") + + if waters_only: + ax.set_title(f"Water H-bond counts: {parameter} = {value}, {len(self.cv.waters.atoms)} waters") + else: + ax.set_title(f"H-bond counts: {parameter} = {value}, {len(self.cv.qm_all.atoms)} atoms") + ax.ticklabel_format(style='plain') + + # Hide any unused subplots (if num_plots < nrows * ncols) + for j in range(num_plots, len(axes)): + axes[j].set_visible(False) + + # Adjust layout + plt.tight_layout() + + # Save the figure if needed + if save: + if filename: + fig.savefig(filename, dpi=300) + else: + fig.savefig('multiple_hbond_counts_grid.png', dpi=300) + + plt.show() + def plot_multiple_hbond_counts_overlay( + self, + parameter='cyzone_dim', + values=[[9, 8, -8], [9, 8, -8]], + save=False, + filename=None, + title=None, + distance_cutoff=3.5, + angle_cutoff=120.0, + waters_only=True + ): + """ + Plot and overlay multiple hydrogen bond counts. + """ + # Create subplots with nrows and ncols + fig, ax = plt.subplots() + all_counts = [] + for i, value in enumerate(values): + if parameter == 'cyzone_dim': + print(f"Setting cyzone_dim to {value}") + self.cv.set_cyzone_dim(value) + print(f"{len(self.cv.waters.atoms)} waters selected.") + print(f"{len(self.cv.qm_all.atoms)} atoms selected.\n") + counts = self.get_water_h_bonds( + distance_cutoff=distance_cutoff, + angle_cutoff=angle_cutoff, + waters_only=waters_only + ) + _, _ = self.get_max_hbond_counts(counts) + all_counts.append(counts) + + else: + pass + if waters_only: + ax.plot(self.times, counts, lw=1, label=f"{parameter} = {value}, {len(self.cv.waters.atoms)} waters") + else: + ax.plot(self.times, counts, lw=1, label=f"{parameter} = {value}, {len(self.cv.qm_all.atoms)} atoms") + + ax.legend(frameon=False) + ax.set_ylabel("Number of hydrogen bonds") + ax.set_xlabel("Time [ns]") + + if waters_only: + ax.set_title(f"Water H-bond counts: Variable {parameter}") + else: + ax.set_title(f"H-bond counts: Variable {parameter}") + ax.ticklabel_format(style='plain') + + + # Adjust layout + plt.tight_layout() + + # Save the figure if needed if save: - fig.savefig("hbond_counts.png", dpi=300) + if filename: + fig.savefig(filename, dpi=300) + else: + fig.savefig('multiple_hbond_counts_grid.png', dpi=300) plt.show() + return np.array(all_counts) + + def plot_standard_deviation(self, counts): + """ + Plot the standard deviation of the hydrogen bond counts. + """ + fig, ax = plt.subplots() + ax.plot(self.times, np.std(counts, axis=0), color='black', lw=1) + ax.set_ylabel("Standard deviation of hydrogen bond counts") + ax.set_xlabel("Frame number") + ax.set_title("Standard deviation of hydrogen bond counts over time") + ax.ticklabel_format(style='plain') + plt.tight_layout() + plt.show() + + def plot_autocorrelation(self, counts): + """ + Plot the autocorrelation of the hydrogen bond counts. + """ + from statsmodels.graphics.tsaplots import plot_acf + fig, ax = plt.subplots() + plot_acf(counts, ax=ax, lags=10, zero=False, bartlett_confint=False) + ax.set_title("Autocorrelation of hydrogen bond counts") + plt.tight_layout() + plt.show() + + def water_bridge_analysis(self): + """ + Analyse the water bridges between the water molecules. + MDAnalysis.analysis.hydrogenbonds.WaterBridgeAnalysis() + Very slow and not super useful. + """ + pass + + def hydrogen_bond_lifetimes(self): + """ + Get the hydrogen bond lifetimes. + """ + palette = sns.color_palette("flare", n_colors=len(self.all_resids)) + fig, ax = plt.subplots() + for i, resid in enumerate(self.all_resids): + + hba = HBA( + universe=self.u, + donors_sel=self.cv.waters_sele_str + ' or ' + f'resid {resid}', + hydrogens_sel=self.cv.waters_sele_str + ' or ' + f'resid {resid}', + acceptors_sel=self.cv.waters_sele_str + ' or ' + f'resid {resid}' + ) + hba.run() # run the analysis + + # Get counts + # counts = hba.count_by_time() + tau_timeseries, timeseries = hba.lifetime(intermittency=5) + print(f"\nHydrogen bond tau: {tau_timeseries}") + print(f"Timeseries: {timeseries}") + + ax.plot(tau_timeseries, timeseries, color=palette[i], lw=1, label=f"Resid {resid}") + + ax.set_ylabel("Autocorrelation") + ax.set_xlabel("Tau") + ax.set_title("Hydrogen bond lifetimes") + ax.ticklabel_format(style='plain') + ax.legend(frameon=False) + plt.tight_layout() + plt.show() + def get_max_hbond_counts(self, counts): """ Get the frames and times of the 10 frames with the most hydrogen bonds. @@ -216,6 +440,12 @@ def get_residence_times(self): ligand=[1, 2], cyzone_dim=[8, 8, -8], frame_n=160) - counts = wa.get_water_h_bonds() + # counts = wa.get_water_h_bonds() + # wa.plot_autocorrelation(counts) + + # # wa.plot_hbond_counts(counts, save=True) + # # wa.plot_multiple_hbond_counts_grid(parameter='cyzone_dim', values=[[7, 8, -8], [10, 8, -8]], save=False, waters_only=False) + # all_counts = wa.plot_multiple_hbond_counts_overlay(parameter='cyzone_dim', values=[[7, 8, -8], [8, 8, -8], [9, 8, -8], [10, 8, -8]], save=False, waters_only=False) + # wa.plot_standard_deviation(all_counts) - wa.plot_hbond_counts(counts, save=True) + wa.hydrogen_bond_lifetimes() \ No newline at end of file diff --git a/PyCEC/cec_system.py b/PyCEC/cec_system.py index ae8237c..3c52675 100644 --- a/PyCEC/cec_system.py +++ b/PyCEC/cec_system.py @@ -100,8 +100,8 @@ def __init__(self, universe, initial_resid, target_resid, self.protein = self.universe.select_atoms('protein') # protein # QM atoms - self.qm_all, self.qm_heavy, self.qm_light, self.waters, \ - self.waters_sele_str = self.select_QM_atoms() + self.qm_all, self.qm_heavy, self.qm_light, self.qm_all_sele_str, \ + self.qm_all_sele_br_str, self.waters, self.waters_sele_str = self.select_QM_atoms() def generate_cv_selection(self): """ @@ -186,9 +186,12 @@ def select_QM_atoms(self): qm_heavy = ha_sele + ha_water_sele qm_light = la_sele + la_water_sele qm_all = ha_sele + ha_water_sele + la_sele + la_water_sele + qm_all_sele_str = f'({ha_sele_str}) or ({ha_wat_sele_str}) or ({la_sele_str}) or ({la_wat_sele_str})' + qm_all_sele_br_str = f'byres (({ha_sele_str}) or ({ha_wat_sele_str}) or ({la_sele_str}) or ({la_wat_sele_str}))' + # Return the selections - return qm_all, qm_heavy, qm_light, waters, waters_sele_str + return qm_all, qm_heavy, qm_light, qm_all_sele_str, qm_all_sele_br_str, waters, waters_sele_str def set_frame(self, frame_n=None): """ @@ -209,6 +212,20 @@ def set_frame(self, frame_n=None): # Update qm selections waters) every time the frame is updated self.qm_all, self.qm_heavy, self.qm_light, self.waters = self.select_QM_atoms() + def set_cyzone_dim(self, cyzone_dim): + """ + Function to set the cyzone dimensions. + + Parameters + ---------- + cyzone_dim : list of int + Dimensions of the cyzone around the protein. + """ + self.cyzone_dim = cyzone_dim + # QM atoms + self.qm_all, self.qm_heavy, self.qm_light, self.qm_all_sele_str, \ + self.qm_all_sele_br_str, self.waters, self.waters_sele_str = self.select_QM_atoms() + def create_dir(self, dir_name): """ Function to create a directory. diff --git a/PyCEC/notebooks/playground.ipynb b/PyCEC/notebooks/playground.ipynb index 61a3b31..ceb9cd8 100644 --- a/PyCEC/notebooks/playground.ipynb +++ b/PyCEC/notebooks/playground.ipynb @@ -12,7 +12,8 @@ "#print(module_path)\n", "if module_path not in sys.path:\n", " sys.path.append(module_path)\n", - "from PyCEC.cv.collective_variable import CECCollectiveVariable\n", + "from PyCEC.cv.collective_variable import mCECCollectiveVariable\n", + "from PyCEC.cec_system import CECSystem\n", "from PyCEC.analysis.analysis import WaterAnalysis, CVAnalysis\n", "from PyCEC.analysis.residue_analysis import ResidueAnalysis\n", "from PyCEC.analysis.plotting import CVPlotting\n", @@ -27,15 +28,16 @@ "source": [ "# Directory and title\n", "dir1 = '/biggin/b222/catz0163/pept/dynamics/pept_holo/pept_AF_H87P_D342P_v2/qmmm'\n", + "dir1 = '/Users/nfo24278/Documents/dphil/proton_transfer/PyCEC/simulations/pept_AF_H87P_D342P'\n", "title1 = 'PepT2 with AF H87P D342P'\n", "\n", "# Load the universe\n", - "u1 = mda.Universe(f'{dir1}/prod-s100.pdb', f'{dir1}/prod-s100.xtc')" + "u1 = mda.Universe(f'{dir1}/prod-s200.pdb', f'{dir1}/prod-s200.xtc')" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -47,42 +49,45 @@ "\n", "Number of atoms: 78\n", "Number of residues: 13\n", - "Residue names: LYS, ASH, GLU, THR, TYR, GLN, PHE, HIP, ARG, ALA\n", - "Atom names: NE2, NH1, NE, C, O, CE2, OC2, OD1, CD2, CZ, NZ, OE2, CG, CB, CD, OC1, OG1, CA, CE, CE1, OH, CD1, CG2, ND1, NH2, OE1, N, OD2\n", + "Residue names: ARG, GLN, GLU, LYS, PHE, HIP, ALA, ASH, TYR, THR\n", + "Atom names: CG, C, N, CB, OD1, NH1, ND1, NE, CE2, CE, OC2, CD1, OD2, CG2, OG1, CD2, NZ, CD, O, OE1, NE2, OE2, CA, OC1, CE1, OH, NH2, CZ\n", "\n", "--- QM ATOMS ---\n", "\n", - "Number of QM atoms: 107\n", - "Number of QM residues: 35\n", - "Residue names: HIP, SOL, GLU\n", - "Atom names: HE2, NE2, HD2, OW, ND1, HD1, HE1, HW2, OE1, HW1, OE2\n", + "Number of QM atoms: 95\n", + "Number of QM residues: 31\n", + "Residue names: SOL, GLU, HIP\n", + "Atom names: HE2, NE2, HE1, HW1, OE2, HD2, HD1, OW, ND1, HW2, OE1\n", "\n", "--- WATERS ---\n", "\n", - "Number of water atoms: 99\n", - "Number of water residues: 33\n", + "Number of water atoms: 87\n", + "Number of water residues: 29\n", "Residue names: SOL\n", - "Atom names: HW1, HW2, OW\n", + "Atom names: HW1, OW, HW2\n", + "\n", "\n", - "\n" + "function write_pdb (cv-selection, structures, , 88, True, CV-atoms) took 0.02s to run.\n", + "function write_pdb (qm-selection, structures, , 88, True, QM-atoms) took 0.00s to run.\n", + "function write_pdb (protein, structures, , 88, True, Protein) took 0.08s to run.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/biggin/b222/catz0163/miniconda3/envs/md/lib/python3.12/site-packages/MDAnalysis/coordinates/PDB.py:1153: UserWarning: Found no information for attr: 'formalcharges' Using default value of '0'\n", + "/Users/nfo24278/miniconda3/envs/chem/lib/python3.12/site-packages/MDAnalysis/coordinates/PDB.py:1153: UserWarning: Found no information for attr: 'formalcharges' Using default value of '0'\n", " warnings.warn(\"Found no information for attr: '{}'\"\n", - "/biggin/b222/catz0163/miniconda3/envs/md/lib/python3.12/site-packages/MDAnalysis/coordinates/PDB.py:1200: UserWarning: Found missing chainIDs. Corresponding atoms will use value of 'X'\n", + "/Users/nfo24278/miniconda3/envs/chem/lib/python3.12/site-packages/MDAnalysis/coordinates/PDB.py:1200: UserWarning: Found missing chainIDs. Corresponding atoms will use value of 'X'\n", " warnings.warn(\"Found missing chainIDs.\"\n" ] } ], "source": [ - "frame_test = 166\n", + "frame_test = 88\n", "\n", "# Initialise class\n", - "cv = CECCollectiveVariable(u1, initial_resid=87, target_resid=56,\n", + "cv = CECSystem(u1, initial_resid=87, target_resid=56,\n", " other_resids=[53, 57, 61, 622, 324, 345, 161, 60, 342],\n", " ligand=[1, 2], cyzone_dim=[9, 8, -8],\n", " frame_n=frame_test)\n", @@ -94,12 +99,25 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 6, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "101\n", + "[102 88 88 58 78 62 78 74 92 52 88 154 88 70 144 112 150 110\n", + " 108 62 118 114 100 100 136 126 104 136 114 126 120 112 90 126 128 200\n", + " 96 98 118 124 162 104 132 172 130 56 108 132 146 108 122 76 170 160\n", + " 168 146 114 158 106 108 124 84 86 116 100 208 114 118 122 176 188 156\n", + " 172 110 174 220 284 144 186 136 152 178 140 136 202 240 162 222 152 180\n", + " 196 174 128 68 104 66 94 140 150 168 148]\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -116,18 +134,26 @@ " frame_n=160)\n", "\n", "counts = wa.get_water_h_bonds()\n", + "print(counts)\n", "\n", "wa.plot_hbond_counts(counts, save=True)" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 7, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "101\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -206,7 +232,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.0" + "version": "3.12.2" } }, "nbformat": 4,