In this tutorial, we demonstrate how to use the HTMD code for analysing a protein-ligand binding process.

To analyze, one needs MD trajectories first, which can be generated with
HTMD. Here, we already provide the trajectories (data) to analyze. You
can download the data from
here.
(**Warning: 3GB filesize**)

Alternatively, you can download the dataset using `wget`

.

```
import os
assert os.system('wget -rcN -np -nH -q --cut-dirs=2 -R index.html* http://pub.htmd.org/tutorials/ligand-binding-analysis/datasets/') == 0
```

First we import the modules we are going to need for the tutorial:

```
%pylab inline
from htmd.ui import *
config(viewer='webgl')
```

```
Populating the interactive namespace from numpy and matplotlib
Please cite HTMD: Doerr et al.(2016)JCTC,12,1845.
https://dx.doi.org/10.1021/acs.jctc.6b00049
Documentation: http://software.acellera.com/
To update: conda update htmd -c acellera -c psi4
You are on the latest HTMD version (unpackaged : /home/joao/maindisk/software/repos/Acellera/htmd/htmd).
```

For the purposes of an analysis, full atom information is required by
HTMD. Therefore each simulation trajectory has to be associated with a
corresponding PDB file. Additionally, if you plan to run adaptive, each
trajectory needs to be associated with an input directory which contains
the files used to run the simulations. The `simlist`

function allows
us to make these associations

```
sims = simlist(glob('data/*/'), glob('input/*/structure.pdb'), glob('input/*/'))
```

Typically waters are removed from the trajectories as they are not used in the analysis and it helps speed up further calculations. These filtered trajectories are written into a new directory. The advantage of filtering is that if your input structures only differ in the number of water molecules, you can produce a single unique pdb file for all simulations once you remove the waters, which will speed up calculations. This step is not necessary for the analysis and you can skip it if you don’t mind the slowdown in calculations. In that case replace in the following commands the fsims variable with sims.

```
fsims = simfilter(sims, './filtered/', filtersel='not water')
```

In this tutorial, in order for the trajectories to be downloaded in a timely manner, we provide only the filtered trajectories, which are stored in three separate dataset folders. Therefore we will skip the above two commands and construct the simulation list directly from the filtered trajectories:

```
sets = glob('datasets/*/')
sims = []
for s in sets:
fsims = simlist(glob(s + '/filtered/*/'), 'datasets/1/filtered/filtered.pdb')
sims = simmerge(sims, fsims)
```

```
Creating simlist: 100%|██████████| 314/314 [00:00<00:00, 2849.42it/s]
Creating simlist: 100%|██████████| 309/309 [00:00<00:00, 2941.33it/s]
Creating simlist: 100%|██████████| 230/230 [00:00<00:00, 2940.73it/s]
```

To build a Markov state model we need to project the atom coordinates onto a lower dimensional space which can be used for clustering the conformations into a set of states. For protein systems we typically use the binary contact map between the carbon alpha atoms of the protein. This will calculate contacts between all carbon-alpha atoms.

```
metr = Metric(sims)
metr.set(MetricDistance('protein and name CA', 'resname MOL and noh', metric='contacts'))
data = metr.project()
```

```
Projecting trajectories: 100%|██████████| 852/852 [00:15<00:00, 55.03it/s]
2018-03-19 23:17:49,465 - htmd.projections.metric - INFO - Frame step 9.999999974752427e-07ns was read from the trajectories. If it looks wrong, redefine it by manually setting the MetricData.fstep property.
```

Here, we also provide the frame-step in nanoseconds i.e. the time that passes between two consecutive frames in a trajectory. This should be automatically read from the trajectories, but some simulation software does not contain the correct fstep in the trajectories, so it can be useful to manually define it:

```
data.fstep = 0.1
```

Sometimes the set of trajectories can contain trajectories of incorrect length. These are typically corrupted trajectories and are removed.

The `plotTrajSizes`

method plots all trajectory lengths, sorted:

```
data.plotTrajSizes()
```

The `dropTraj`

method has multiple options for removing simulations
from the dataset. Here, we use it to remove all trajectories whose
length is not equal to the mode length:

```
data.dropTraj()
```

```
2018-03-19 23:18:00,335 - htmd.metricdata - INFO - Dropped 2 trajectories from 852 resulting in 850
```

```
array([496, 562])
```

TICA is a method that can be used to improve the clustering of the conformations. This is done by projecting the data onto a lower-dimensional space which separates well the metastable minima and places clusters on the transition regions.

```
tica = TICA(data, 2, units='ns')
dataTica = tica.project(3)
```

```
/home/joao/maindisk/SANDBOX/miniconda3/miniconda3/lib/python3.6/site-packages/pyemma/__init__.py:91: UserWarning: You are not using the latest release of PyEMMA. Latest is 2.5.1, you have 2.4.
.format(latest=latest, current=current), category=UserWarning)
```

```
A Jupyter Widget
```

```
A Jupyter Widget
```

If we want to bootstrap our calculations we can at this point drop a random 20% of the trajectories and do the rest of the analysis multiple times to see if the results are consistent. Alternatively we can keep on using dataTica in the following commands.

```
dataBoot = dataTica.bootstrap(0.8)
```

Once we have cleaned the dataset we proceed to cluster the conformations.

Here we use the mini-batch kmeans clustering algorithm to produce 1000 clusters.

```
dataBoot.cluster(MiniBatchKMeans(n_clusters=1000))
```

After clustering it is time to build the Markov model.

```
model = Model(dataBoot)
```

Before constructing the Markov model, we need to choose the lag-time at which it will be built. The lag-time is typically chosen by looking at the implied timescale (ITS) plot and selecting a lag-time at which the top timescales start converging. By constructing Markov models at various lag times HTMD creates a plot which shows the slowest implied timescales of each Markov model at various lag times. If a model is Markovian at a specific lag time, the implied timescales should stay unchanged for any higher lag times. Therefore, given an implied timescales plot, the user can monitor the convergence and choose the lag time at which to construct his Markov model, typically the Markov time which is the shortest lag time at which the timescales converge. Too large lag times can reduce the temporal resolution of the Markov model and can create more statistical uncertainty due to fewer transition counts and thus instability in the implied timescales.

```
model.plotTimescales()
```

```
A Jupyter Widget
```

After seeing the ITS plot we decided on a lag-time of 50 frames (5ns). Additionally the ITS plot showed us that there is a separation between 4 slow timescales and the rest of the timescales which are fast. Therefore we choose to lump our microstates together into 5 macrostates.

```
model.markovModel(5, 5, units='ns')
```

```
2018-03-19 23:38:49,319 - htmd.model - INFO - 100.0% of the data was used
2018-03-19 23:38:49,359 - htmd.model - INFO - Number of trajectories that visited each macrostate:
2018-03-19 23:38:49,360 - htmd.model - INFO - [156 101 117 363 226]
```

Once we have a Markov model we can plot the free energy surface by projecting it on any of our projected coordinates. For example to plot it on the first two TICA coordinates we call it like this.

```
model.plotFES(0, 1, temperature=298)
```

```
/home/joao/maindisk/software/repos/Acellera/htmd/htmd/metricdata.py:786: MatplotlibDeprecationWarning: The griddata function was deprecated in version 2.2.
zi = griddata(x, y, z, xi, yi, interp='linear')
```

We can also plot the micro and macrostates on top of the FES by setting
`states=True`

```
model.plotFES(0, 1, temperature=298, states=True)
```

```
/home/joao/maindisk/software/repos/Acellera/htmd/htmd/metricdata.py:786: MatplotlibDeprecationWarning: The griddata function was deprecated in version 2.2.
zi = griddata(x, y, z, xi, yi, interp='linear')
```

To see what the states look like we can use the `viewStates`

method.
We load the macrostates and add a ligand representation using the ligand
atomselection.

```
model.viewStates(ligand='resname MOL and noh')
```

```
Getting state Molecules: 100%|██████████| 5/5 [00:06<00:00, 1.38s/it]
```

```
A Jupyter Widget
```

```
A Jupyter Widget
```

One of the major advantages of Markov state models is that they can provide quantitative results about the kinetics between states.

Provide the `Kinetics`

class with the system temperature and ligand
concentration. It automatically then calculates the source and sink
states.

```
kin = Kinetics(model, temperature=298, concentration=0.0037)
```

```
2018-03-19 23:39:40,195 - htmd.kinetics - INFO - Detecting source state...
2018-03-19 23:39:41,168 - htmd.kinetics - INFO - Guessing the source state as the state with minimum contacts.
2018-03-19 23:39:41,170 - htmd.kinetics - INFO - Source macro = 3
2018-03-19 23:39:41,171 - htmd.kinetics - INFO - Detecting sink state...
2018-03-19 23:39:41,210 - htmd.kinetics - INFO - Sink macro = 4
```

To see the rates between the source and sink states we use the getRates method.

```
r = kin.getRates()
print(r)
```

```
2018-03-19 23:39:51,759 - htmd.kinetics - INFO - Calculating rates between source: [3] and sink: [4] states.
2018-03-19 23:39:52,074 - htmd.kinetics - INFO - Concentration correction of -3.32 kcal/mol.
```

```
mfpton = 9.84E+02 (ns)
mfptoff = 4.35E+03 (ns)
kon = 2.75E+08 (1/M 1/s)
koff = 2.30E+05 (1/s)
koff/kon = 8.37E-04 (M)
kdeq = 6.26E-04 (M)
g0eq = -4.37 (kcal/M)
```

To plot the free energies and mean first passage times of all state
relative to the source state, use the `plotRates`

method:

```
kin.plotRates()
```

To visualize the kinetic flux pathways between the source and sink
states, use the `plotFluxPathways`

method:

```
kin.plotFluxPathways()
```

```
/home/joao/maindisk/SANDBOX/miniconda3/miniconda3/lib/python3.6/site-packages/pyemma/plots/networks.py:544: FutureWarning: elementwise comparison failed; returning scalar instead, but in the future will perform elementwise comparison
if state_labels == 'auto':
/home/joao/maindisk/SANDBOX/miniconda3/miniconda3/lib/python3.6/site-packages/matplotlib/figure.py:459: UserWarning: matplotlib is currently using a non-GUI backend, so cannot show the figure
"matplotlib is currently using a non-GUI backend, "
```

```
Path flux %path %of total path
1.3443951293549833e-05 66.3% 66.3% [3 4]
6.107254749717703e-06 30.1% 96.4% [3 2 4]
7.357397291918617e-07 3.6% 100.0% [3 1 4]
```

And this concludes the ligand binding tutorial.