Structure of the lecture

In this lecture, we will first give an overview of the use of git.

In the second part of the lecture, we will deal with the setup of a Molecular Dynamics simulation with a cell membrane, as needed for the simulation of a membrane protein.

1. Using GIT

What is git? Why should I care?

To avoid this.

Note: the following is compact and quite dense overview of git. If you are unfamiliar with it, you are strongly encouraged to complete software carpentry’s tutorials.

Git, like all serious version control systems, tries to solve two main problems.

1. Keeping track of all changes to files.
2. Let people collaborate on complex projects effectively.

A Version Control System (VCS) allows you to:

• revert selected files back to a previous state,
• revert the entire project back to a previous state,
• compare changes over time,
• work in two or more people on the same project,
• see who last modified something that might be causing a problem,
• …

Using a VCS also generally means that if you screw things up or lose files, you can easily recover.

Version control

A basic version of a VCS would be to simply have a local database in which you store subsequent versions of the same file(s).

The old idea: keep track of your changes

In practice, this often become just the same file saved with the suffix.. _v2, _v3,…, _final1, _final2, _final_final…Entropy definitely increases in a file system with time, as everywhere else.

The idea is to use a VCS like git to reduce the entropy as much as possible with the minimum energy input, i.e. the minimum effort on your side. i Plus, you want to cooperate with people!

And how it is usually done…

A way to have something cooperative could be to put the whole DB (the “repository” ) on a single server accessible by all contributors. This has some problems though: i) if the server crashes, you can not work. ii) If the server gets lost, your work gets lost as well. iii) lag times!

Distributed version control

To solve the issues above, git implements what is known as distributed version control. This means that the copy of the repository storing all the history of changes is stored on the computer of each contributor, as well as on the server.

And how it is usually done…

• Each contributor is on the same page.
• Even if the server is done for, you can retrieve the data.
• You can do a lot of work locally, then push things on the remote repository only in a second time.
• If possible, git will merge the changes from different people automatically.

adapted from software-carpentry.org

How git saves your project

Git creates a mini file-system, saving “snapshots” of your project directory each time you “commit” your changes. Each snapshots stores all the data in the directory. To save space, git substitutes unchanged files with links to their latest version.

Git version control. Unchanged files (links) are represented with dashed contours.

Strong points of git

1. All operations are local -> fast!
2. It is possible to perform large changes without messing up everything.
3. It is impossible to change something on the repository without git knowing it!
4. Snapshots are additive: no data is lost (of course you can make it useless, but not lose it).

Git three states

To allow git to do its job, you need to tell it what changes you want to push to the repository!

You need to tell git what changes you want to save.

To give you flexibility in deciding what to save and what not to save, git implements three “areas”, to which correspond four possible file states.

area	file state	description
working directory	untracked	Files unknown to git.
working directory	modified	Files known to git that have been modified on your pc, not yet staged to enter a snapshot.
Staging area	staged	Files whose changes will enter the next snapshot to be committed
Local repository (.git directory)	committed	Latest local snapshot of your project

The staging area stores incremental changes before you commit them to a snapshot.

Note the arrow back from the repository. That means that you canretrieve changes from your local repository to correct some error, or to go back to a previous version of a file and experiment some different change.

The figure above only considers files that are already known to git. You can include unknown files to the staging area with git add. A typical situation looks like this:

The lifecycle on a file on git. commit adds a file to the local repository. Therefore, after that, there will be no difference between the copy on the snapshot and your local copy, which is then marked as unmodified.

You can see the status of various files whenever you wish, by writing git status. Here is an example from the git-project we use to prepare your lectures.

a practical example: a step during the preparation of this lecture

There is then the remote repository which is shared with others; to this you can push only snapshots that are in your local repository.

Using branches to collaborate effectively

The nice things about version control, and in particular modern VCS is that they can manage co-editing. I.e. when two people do modify the same file, the VCS is usually able to merge the changes from both of them in a seamless way. That is, until both tried to modify the same line in a file. That results in a conflict.

A and B both modified the same region in the file. Which one should be picked?

Once you encounter a conflict -git will tell you, trust me- you will have to instruct what version to pick by yourself. On the incriminated file(s) you will find regions marked as follow:

<<<<<<< HEAD:file.txt
Hello world
=======
Goodbye
>>>>>>> 77976da35.....:file.txt

Where: <<<<< HEAD means your local copy and everything from ==== to >>>> 77976da... means their copy, the one you pulled from the remote repo. You will have to choose which one to choose by removing the other one AND the markers.

How to avoid conflicts in the first place?

By using branches.

adapted from software-carpentry.org

Git has the wonderful characteristic that it makes it extremely easy to create a new snapshot of your data, called a branch, which is independent from the others. Consider it as a second directory for your project, in which you can play without modifying what was stored in the first one. With the plus that git is still keeping track of all changes between your “branched directory” and the “master directory”.

adapted from here

How should one structure branches?

Branches are effective if you use them in a structured way. A successful git workflow introduce by Vincent Driessen in 2010 and widely adopted. You can find it explained in detail here.

a successful git branching model](https://nvie.com/posts/a-successful-git-branching-model/)

There is another trick to it then, but we will see it later..

Registering on gitlab + installing git on your machine.

We have set up a virtual machine to host gitlab at the physics department. You can organize yourselves to use other hosts, but we strongly recommend using this one instead.

1. Register on our internal gitlab host.

Go to the Physics (unofficial) gitlab host and register using your unitn email and name.surname as user account. Should this not work, just use gitlab.com.

Gitlab welcome page

2. I will add you to the group cbp2022-2023.

3. Create a project on gitlab

We will see how to create a project from gitlab. Create only ONE project per each group. The projects should be called with a sensible name, e.g. cbp23_<mutation_name> where <mutation_name> has to be substituted with the code for the mutation assigned to your group.

4. Link the project

Link the project you created to the project folder on hpc2 (and on your laptop: you can create the folder there too!!). Normally you can follow the instructions on gitlab, but in your case you already have the same files written in the template folder, so we need to be sure to avoid conflicts. There is a bit of an issue since we should have introduced git before the template folder..We will follow these steps:

1. One person in your group will create the repo, from the empty template folder.
2. Both members of the group will copy what relevant in the newly created folder, pushing to different branches.
3. We will try to merge your changes to a common branch, and see what happens..

4.1 linking and initializing the repo

First let git know who you are

git config --global user.name "name surname"
git config --global user.email "name.surname@studenti.unitn.it"

Initialing the remote repo. ONE person only (example for group1)

# Create the folder with cookiecutter
# ...
# create master branch
cd <folder>
git init
git remote add origin  <repo-address>
git add .
git commit -m "Initial commit"
git push -u origin master

The second member of the group will have to choose an empty folder and run the following command to obtain the repository.

git clone  <repo-address>

4.2 Adding your data

The data folders are setup in such a way to avoid uploading large files to the git repository. We suggest coping (or even better, linking) these folders to the university google-drive.

After that, we want to add the files to the repository. Avoiding conflicts if possible. We will try to do that by using branches. After you copied your data, go to the directory in which the data is stored and run the following.

git checkout -b your_name # of course substitute your_name appropriately.. :) This will create a branch named after you.
git add .
git status # what is git status showing?
git commit -m "write a proper message here!" # do it!
git push -u origin your_name # again, subsistute appropriately..

The above commands will switch git from the master branch to a branch named after you, where you can play without the fear of losing something important. You can manage branches with the following commands:

git branch  # show all local branches
git branch -a # show all branches, including remote ones
git checkout -b branch_name # create branch 'branch_name'
git checkout branch_name # switch to branch 'branch_name'
git branch -D branch_name # DELETE branch 'branch_name' locally

4.3 Collaborating effectively

Now go to gitlab and update the project page, we will work on that.

Let’s take a look at our repository. On the left bar, click repository, branches. You should see three branches: two personal ones and master. Now, click on new branch to create a new one. Of course, just one of you should do it. Call the new branch develop and select create from master.

An example screen..

Now that you have a develop branch, use the interface to merge one of your branches to develop. Go to merge anche choose develop as a target instead of master. Do all the procedure and describe your merge request properly.

Finally, we want to merge the second personal branch, let’s say pippo if the first was ciccio onto develop. ciccio contents are now already in develop. Now, do you remember all our discussions about avoiding conflicts? This is the extra trick. Pippo will have to do the following before submitting a merge request to develop:

git fetch # update all branches locally, without pulling the changes
git checkout develop
git checkout pippo # again, use the correct name..
git merge develop # !!! this will merge develop INTO pippo
# solve any conflict that should arise, and commit again.
git status
git commit -m "merged develop into pippo"
git push

Only after doing this, Pippo can follow the same procedure as above to merge into develop from the web interface. Why this? Because this way pippo who knows better what changes he introduced can quickly solve any possible issues, before asking for a merge request which might incur in larger conflicts (e.g. if something changed on develop while he was working).

Remember the following golden rules:

• Create a branch for any change you want to implement.
• Do commit frequently.
• Merge from the starting branch (should be develop) back to your branch before pushing a merge request.
• Comment commits and merge requests exhaustively.
• Link branch names to tickets in gitlab…

keep track of things with gitlab.

Gitlab supports among other things the creation of issues. These are wonderful to organize your work, particularly when you have to collaborate. Even better if you start calling the branches by referencing the issue number..

An example screen from our course preparation

Summary of git basic commands.

command	effect	example
git help	Get help on git commands!	git help [command]
git clone	Clone a remote repository in the current dir.	git clone <git@>
git init	Initialize the current directory as a repo	git init
git add	Add one or more files to the staging area	git add file1 file2 file3..
git commit	Add the files in the staging area to the local repository	git commit [-m "commit message..."]
git checkout	Recover a file from the repo or switch branches	* git checkout myfile #get file "myfile", * git checkout mybranch #get branch "mybranch", * git checkout -b newbranch #create new branch "newbranch"
git rm	remove files from the repository (same options as normal rm)	git rm file or git rm -r dir
git mv	move files inside the repository (same as normal mv)	git mv fileA fileB
git pull	Integrate changes from a remote repository into the local branch	git pull
git push	Push local changes to a remote repository	git push

2. Membranes in a nutshell

As you may imagine, the cell membrane separates the inner part of the cell, the cytoplasm, from the extracellular space, the so-called extracellular matrix (ECM). As usual, biology is complicated, so there are many other membranes in your body and in the cell. One example is the nuclear membrane, which separates the chromosomes from the rest of the cell.

The cell membrane is made mainly by a lipid bilayer, that is two arrays of lipids stacked one on the other. With such an arrangement the hydrophilic lipidic heads are exposed to the solvent on both sides of the membrane, while the hydrophobic tails are separated from water in the inner region. Lipid molecules can diffuse in the membrane and the membrane itself can be deformed.

a bilayer

Membranes are formed principally by glycerophospholipids, but other type of lipids are present as well. Different cells and/or organisms can have a different concentration of those lipids in their membranes, resulting in different physical and chemical properties (e.g. more rigidity).

As usual, biology is complicated (2.0).

The cell membrane controls the inward and outward flux of substances, including ions (concept of selective permeability). This is possible thanks to the presence of proteins. Indeed, there are two main categories of proteins interacting with the membranes: the integral proteins, which are completely embedded in the membrane. Among them, transmembrane proteins cover the whole length of the lipid bilayer. Ion channels are an example of integral protein. They allow the flux of ions from and to the cell. Peripheral proteins play a different role, being only loosely attached to the membrane. These structures are usually involved in maintaining the shape of the bilayer or in signalling processes. Proteins can also diffuse on the membrane.

a typical membrane protein

In molecular modelling of membrane proteins we usually restrict our analysis to a limited portion of the lipid bilayer (typically from 10 to 30 nanometers) in order to save computational time. In simulations we tend to neglect the curvature of the membrane, therefore modelling it as a perfect square.

An artistic rendering of the protein recoverin attached to a membrane patch (Crespi & Mazza, comp. biophys report 2019-2020)

The force field

Nowadays, standard force fields model the lipid-lipid interactions and the potentials between lipids and proteins in a pretty accurate way. Nonetheless, there can be differences, in general. Even without the membrane, different ff can make some regions of a folded protein more or less stable.

Different force fields can give different results

The image was taken by this nice article by Lindorff-Larsen and coworkers.

VMD Membrane builder extension

VMD has an extension that allows the user to build a custom squared lipid bilayer. If you have it (it is indeed an extension) try to build a 50x50 membrane with POPC lipids.

Launch VMD. Go to Extensions->Modeling->Membrane builder. There you can define the chemical composition and the size of your brand new membrane. The most important parameter here is the topology, which asks for which topology you are building this object. As you already know, it is better not to mess up with topologies and force fields so you should not mix them randomly.

If you are not able to locate the extension don’t worry, there are better ways to build membranes.

The G Protein Coupled Receptor

In this tutorial we will analyse a G Protein Coupled Receptor (GPCR) a member of this class of transmembrane protein that is involved in a huge variety of cellular processes. In normal conditions this receptor is in the inactive form, but when it is activated by external agents in the extracellular space it becomes active and triggers a huge variety of cellular responses and signalling cascades in the cytoplasm.

“108 G-protein-coupled receptors (GPCRs) are the targets of 475 (∼34%) Food and Drug Administration (FDA)-approved drugs and account for a global sales volume of over 180 billion US dollars annually” (source).

From an experimental perspective, obtaining structures of transmembrane proteins is an authentic nightmare. The pdb we are about to download was the first example of GPCR protein that was crystallised by structural biologists, thus paving the way to a new era of experimental structure determination.

Download the pdb 4GBR and load it in VMD

If we look at the protein structure (and at the pdb Id, never forget to do so) we can immediately see that the pdb was obtained with the help of a ligand and of an extracellular protein. Specifically, the experimentalists made a lisozyme bind to the extracellular domain of GPCR, while a small ligand CAU is attached to the core region of the protein.

You can convince yourself of this by creating the following representations in VMD (Graphics->Representations->Create New):

1. with only the lysozime protein, selecting the chain B and New Cartoon as Drawing method. Select the Coloring Method that you think it’s more suitable to this part of the structure;

2. with the GPCR protein, that is chain A and not resname CAU. I recommend using New Cartoon and Secondary structure as Drawing and Coloring methods, respectively;

3. the small ligand CAU can be visualized in Licorice. I think you know how to see only this pretty little guy.

4. let’s highlight now the atoms that have chain A and not resname CAU and resid > 301 and draw them in red (see Color id) selecting again New Cartoon as Drawing method. This alpha helix is the main actor of the cellular response: when the receptor receives a signal from the extracellular space the GPCR undergoes a conformational rearrangement to the active form that causes the exposition of this small helix. The alpha helix, once exposed, can bind to the G protein and then trigger the overall cellular response, which is specific to the type of signal received. As usual, biology is complicated but also amazing.

Our aim now is to save only the pdb with the transmembrane protein, neglecting the two ligands. In order to do so, let’s go to the VMD main window. Go to File->Save Coordinates. Here you can decide to save one of the current selections to a new file. It is not necessary to have a pdb in output but you can select the format you like the most. Here we will choose the pdb format for the output and the second representation. Let’s call the output file 4GBR_alone.pdb.

Load the new pdb in VMD and check that you actually saved the right coordinates

Now let’s inspect a bit the differences between the file. Open both of them with your favourite text editor. You will see that saving the visualization with VMD is not optimal, since it makes you lose a lot of experimental information about the system.

For example, its experimentally determined disulfide bond network. Let’s retrieve the data about S-S bonds from our original pdb:

grep -rn 4GBR.pdb -e SSBOND

Save the Cysteine residues that are involved in disulfide bonds in a separate text file.

Charmm-gui

Charmm-gui is not a guy with a lot of charm, rather it is a platform that is appositely designed to perform interactive setups of complex Molecular Dynamics simulations. It is written in order to produce input parameters for all the main MD engines. Although it is based on Charmm (and on the charmm force field), it also includes the possibility of generating input files that employ AMBER potentials. In this part of the tutorial we will stick to the Charmm force field.

From the main page of Charmm-gui go to the section called Input Generator: here you can see all the possible Charmm-gui workflows to generate input files for a huge variety of computational experiments. Among them, it is worth mentioning the following:

• Glycolipid Modeler, which deals with glycolipids;
• Ligand Reader & Modeler to read ligand structures and parametrise them with the Charmm force field;
• Membrane builder (all the possible flavors of membrane available);
• Martini input generators and backmapper, to perform Coarse-grained simulations with the Martini force field.

We are going to use the Membrane/Bilayer Builder to create the correct setup for our GPCR protein.

It will be a six-step process:

1. Read protein coordinates: here you are supposed to provide your input file to Charmm-gui, either in form of a pdb or using an already oriented OPM file;
2. Protein-membrane orientation: in this crucial step Charmm-gui should orient the membrane and the protein in the correct way, depending on user’s input;
3. system size selection: how many molecules do we want in our system? the bigger the membrane the better, except for the computational overhead!
4. system build, where the fundamental constituents of the system (protein, membrane bilayer, water and ions) are created;
5. system assembly: everything is assembled together, like in LEGOs;
6. Equilibration: Charmm-gui provides six files for progressive equilibration of the membrane-protein-water system. We will analyse them more in detail later.

Let’s start!

Retrieve the pdb file 4gbr_alone.pdb that you generated before

If you lost it or if you were not able to generate it from VMD you can find a copy inside the tutorial folder available here.

1. Read coordinates

Upload the pdb file in the Membrane builder input cell, making sure you are selecting Protein/Membrane system as system type. Check the pdb box. Press the red arrow on the bottom right of the page to proceed to the next step.

In the next page you can select the model you want to use in your setup. This may be useful if you’re submitting a pdb extracted with NMR method, which can contain up to tens of different input structures, or if you have multiple snapshots of your protein obtained, for instance, with Molecular Dynamics.

Leave everything with default values and go to the next page

We don’t have multiple models in our pdb and we don’t want to cut it here (we already did it!).

Check the job id on the top right side of the page

With the job id you can retrieve your job easily using the Job Retriever.

Proceed to the next page. Here we can see many different PDB Manipulation Options. We could mutate the protein, add phosphoryl groups to some residues and so on and so forth. We leave the N-terminal patching as it is, so that the N-terminal and C-terminal regions are modelled with Charmm default parameters.

Select the disulfide bonds box and fill the network with the bonds present in 4gbr.pdb

Let’s proceed to the next step. We are almost at the end of the first part, we have only to decide how to orient our protein.

Here you will have few files wrapping up all what you’ve done so far.

In the psf file you can see the charmm topology of the protein, while step1_pdbreader.pdb contains the preprocessed pdb file.

Let’s check that the disulfide bonds are correctly included in the topology

In order to do so, retrieve the atom ID of the sulphur atoms involved in S-S bonds. Then go at the end of the bonds section to see if they have been included correctly.

2. Protein orientation

If everything looks fine to you, it’s time to select the orientation of our protein. We would like to have our GPCR axis parallel to the z axis, so that the lipid bilayer can be built in the xy plane.

Check the Align the First Principal Axis Along Z box and go to the next page

However, for proteins with a more complicated (less symmetric) shape, it might be more difficult to find the correct orientation of the protein in the membrane: in such cases you are adviced to use the PPM Web Server.

Here you can visualize the properly aligned protein in step2_orient.pdb file. In the page you should see the calculated Cross Sectional Area of the protein, with two bumps corresponding to the two pores on the sides of the membrane. You can even download all the information about cross sectional areas from the files box.

It’s time to choose the chemical composition of our membrane!

3. Lipid composition of the membrane

In this tutorial we are going to use a two-components lipid bilayer: specifically, we will include phosphatidylcholine (POPC) and Cholesterol in ratio 7:3. As you can see, you have the possibility to design your membrane with the ratio of lipids that mimics in the most realistic way the environment you’re simulating.

We are going to use a symmetric bilayer (the outer and inner layers have the same composition); however, in some cases, it might be more appropriate to use a more realistic model that takes into account different compositions between the two layers.

Take home message: always talk to experimentalists or read a lot of articles before choosing the composition of your cell membrane

Select 100 (Angstroms) as xy size of the membrane and locate the lipids you want to include, specifying the desired ratios for both sides of the bilayer.

Once you have specified the desired chemical composition click on the Show System Info panel: it will show you some parameters of your membrane.

Let’s go to the next page: Determine system size.

4. Build components

Download the file step3_packing.pdb

Don’t get scared!

This is only the pdb of the protein with the positions of the lipids, that are going to be added in the following step.

Choose the replacement method to embed the protein in the membrane. Then leave 0.15 M as ion concentration.

Calculate the number of ions that will be present in the box.

Let’s proceed: Build Component!

5. Assemble components

Here you can see the assembled protein-mebrane system you just built in the previous step (step4_lipid.pdb). i

Download the pdb file and load it in VMD.

At this point of the setup Charmm-gui automatically checks for Protein surface penetration and Lipid ring penetration. In the first case the engine checks for the presence of lipid tails that enter deeply inside the protein structure, while in the second one Charmm-gui monitors if any tail penetrates through a chemical ring structure. This ring can either be located on the protein (aromatic amino acids such as tryptophan) or on other lipids (cholesterol).

Charmm-gui developers say: Protein surface penetration and Lipid ring penetration are unphysical and will cause unstable simulations, and it is also very difficult to identify such penetrations solely by visual inspection.

If you do not have such artifacts you can proceed to the next step!

Assemble components!

6.Equilibration

Load in VMD the step5_assembly.pdb file.

Play around with it, checking that all the elements have been correctly included and patched together.

It’s time to select the desired force-field with which you want to simulate your system. As we said before you can choose between charmm36 and AMBER.

Check the Charmm36m force field.

Then you’re asked to specify the desired format (i.e. MD engine) for your simulation files.

Check the GROMACS format.

Leave the other options unchanged: we will do a NPT equilibration. However, set the temperature to 310K (which is the normal human body temperature).

(Since we really care about the health of your laptops, we won’t make you run any of these steps on your PC.)

Proceed to the next page. You should have reached the end of your interactive setup! Here you can download a zip file with all the pieces of your system.

Some fundamental concepts and a bit of analysis

Open all the mdp files you retrieved from charmm-gui

Their structure is more or less the same, but they contain some differences. Here we are going to highlight the most important ones

diff step6.1_equilibration.mdp step6.2_equilibration.mdp

This command shows you the difference between the first two mdp files. Both have position restraints (see the first line), but with different constants, which are higher in the first equilibration.

Do you have an explanation for this choice?

The other difference is that in the first file the velocities are generated (gen_vel = yes), while the second simulation is supposed to be a continuation of the first (continuation = yes) and there’s no gen_vel.

Both simulations do not have pressure coupling but only temperature coupling (NVT).

diff step6.2_equilibration.mdp step6.3_equilibration.mdp

Again, the position restraints are weaker. pcoupl = berendsen means that we are coupling the system to the Berendsen barostat, with a reference pressure (ref_p) of 1.0 bar.

The most important parameter for pressure coupling in membrane is pcoupltype = semiisotropic. This means that the pressure coupling is not completely isotropic, rather we impose an uniform scaling of x-y box vectors, while the z component is independent. We deal with a squared membrane, so we don’t want to obtain a rectangular one at the end of our setup.

In most simulations of membranes the pressure coupling is limited to the z component, thus keeping fixed the x-y shape of the system.

diff step6.3_equilibration.mdp step6.4_equilibration.mdp

The constraints are weakened and we have a change of the timestep (dt = 0.002 instead of dt = 0.001). The system is stable enough to switch to the standard (2 femtoseconds) timestep. The number of steps is also doubled.

diff step6.4_equilibration.mdp step6.5_equilibration.mdp

diff step6.5_equilibration.mdp step6.6_equilibration.mdp

Only the constraints are weakened.

Let’s see the differences between the last equilibration file and the production mdp:

diff step6.6_equilibration.mdp step7_production.mdp

Here the situation changed:

1. No constraints anymore (but those on bonds containing hydrogen atoms are always present);

2. Weak coupling Berendsen thermostat is substituted by Nose-Hoover temperature coupling, which correctly samples the canonical ensemble;

3. Weak coupling Berendsen barostat is replaced by Parrinello-Rhaman pressure coupling, which correctly samples the isothermal-isobaric ensemble.

Never use the Berendsen barostat for actual data production!

Analysis

In the tutorial folder you can find equilibrated the system for you (step6.6_equilibration.gro) and a few steps of simulation of the equilibrated system (step7_production_noPBC.xtc).

Load the gro file in VMD

You can see the equilibrated system. You can make a visual comparison with the output file you got from charmm-gui. This file has been through different steps of minimisation, NVT equilibration and NPT, so it is more realistic than the first. Nonetheless, with such big systems it is common practice to consider the first nanoseconds of the production run as a further equilibration phase, thus starting actual data collection later on.

Load the trajecory on the gro file in VMD

As usual you can do it going to File/Load Data Into Molecule and selecting the file step7_production_noPBC.xtc.

Let’s create a nice representation of our system by removing the water and highlighting the protein and lipids in a different way. Create a new representation (Graphics/Representations/Create Rep):

• select the atoms of the protein (protein) using New Cartoon and Secondary Structure as Drawing and Coloring method respectively;

• draw the lipid bilayer using Polyedra as Drawing method;

• draw the ions (ions) using VdW as Drawing method.

Now we will see how to save to disk only a fraction of the atoms of the system directly from VMD. In this case let’s say that we want to save only the atoms of our protein.

1. Make sure you selected your trajectory;

2. Go to File/Save Coordinates;

3. save the first frame of your trajectory (First = Last = 0) writing only the protein atoms. Save it in a gro format (you can call it step6.6_equilibration_protein.gro);

4. write the binary trajectory keeping the same selection but changing the Last parameter to the number of frames and selecting dcd as Output format. Call it step7_production_protein.dcd

Analyse the behavior of the RMSD with respect to frame 0 using MDAnalysis or VMD

Further Notes

1. Charmm-gui 2016 article

---

Notes