Guia para aula prática – Modelagem de proteínas

Lucas Bleicher (LBLEICHER@GMAIL.COM)

• IMPORTANTE: O Windows, em geral, é instalado de forma a deixar escondidas

as extensões dos arquivos (ex.: um arquivo chamado "sequencia.txt" aparece
no explorer apenas como "sequencia"), o que além de causar confusão (não é
possível saber imediatamente qual a extensão do arquivo) é perigoso por
facilitar a propagação de vírus (é comum que arquivos contendo vírus usem
duas extensões, por exemplo imagem.jpg.exe, e assim o usuário que deixa a
configuração padrão pode pensar se tratar de uma figura JPG quando na
verdade é um arquivo executável). Recomenda-se que o usuário mude essa
configuração. Abrindo o "Meu computador", clica-se na opção "Opções de
pasta (Folder options)" que está no menu Ferramentas (Tools). Escolhe-se a
segunda aba (View) e procura-se a opção "Ocultar extensões de arquivos
conhecidos (Hide extensions for known file types)". Essa opção deve ser
desmarcada.

1. Busca de uma seqüência de proteína – superóxido dismutase de Leishmania

major
Seqüências de proteínas podem ser obtidas pelo servidor Uniprot, procurando por
trecho da seqüência, código de acesso, palavras chave, etc. Assim, uma busca no
Uniprot por “Leishmania major superoxide dismutase” retornará como resultado a
seqüência da proteína em questão.

Escolhe-se a seqüência Q71S90, que corresponde a uma SOD de ferro. Para obter a
seqüência, clica-se no link Q71S90 e, onde há o campo Sequences, clicar em
FASTA.
2. Converter a seqüência para o formato PIR
O Modeller utiliza seqüências no formato PIR, muito parecido com o formato
FASTA. Cria-se então um arquivo no bloco de notas como o mostrado abaixo,
obtido da página do Modeller (http://salilab.org/modeller/tutorial/basic.html):
>P1;TvLDH
sequence:TvLDH:::::::0.00: 0.00
MSEAAHVLITGAAGQIGYILSHWIASGELYGDRQVYLHLLDIPPAMNRLTALTMELEDCAFPHLAGFVAT
AFKDIDCAFLVASMPLKPGQVRADLISSNSVIFKNTGEYLSKWAKPSVKVLVIGNPDNTNCEIAMLHAKN
FSSLSMLDQNRAYYEVASKLGVDVKDVHDIIVWGNHGESMVADLTQATFTKEGKTQKVVDVLDHDYVFDT
GHRAWDILEHRGFTSAASPTKAAIQHMKAWLFGTAPGEVLSMGIPVPEGNPYGIKPGVVFSFPCNVDKEG
EGFKVNDWLREKLDFTEKDLFHEKEIALNHLAQGG*
Os códigos marcados em amarelo devem ser substituídos pelo código pelo qual se
deseja chamar a proteína a ser modelada. Uma vez decidido esse código, ele deve
 ser usado em todos os outros scripts do Modeller, pois é a partir deste arquivo que
ele irá buscá-la. Deve-se escolher um código curto e sem espaços. Para o caso em
questão, podemos por exemplo usar o código LmSOD (importante: deve-se usar
sempre a mesma combinação de maiúsculas e minúsculas). Lembrar também de
adicionar um asterisco ao fim da seqüência. Assim, o nosso arquivo ficaria como
abaixo:
>P1;LmSOD
sequence:LmSOD:::::::0.00: 0.00
MPFAVQPLPYPHDALASKGMSKEQVTFHHEKHHKGYAVKLTAAAESNSALASKSLVDIIK
SEKGPAFNCAAQIYNHDFFWRCLSPRGGSKPHGEIASAIIDSFGSFSNFKKEFTDAANGH
FGSGWAWLVKDKSSGKLKVFQTHDAGCPLTEPDLVPILACDVWEHAYYIDYRNDRASYVS
AFWNMVNWSHANHCYRAAGGSHYVNSDL*
O arquivo deve ser salvo em um diretório que vai conter os arquivos de entrada e
saída. De forma a deixar os dados mais organizados, é interessante criar um
subdiretório dentro da pasta do Modeller. Quando se roda o modeller pelo
windows, ele abre uma janela de comandos dentro da pasta C:\Arquivos de
Programas\Modeller9v7 (ou C:\Program Files\Modeller9v7, no caso do windows
estar em inglês). Digitando "md sod", cria-se uma subpasta sod. Em seguida,
digitando "cd sod", entra-se nessa pasta. O arquivo texto contendo a seqüência,
como mostrado acima, deve ser salvo então nessa subpasta sod. O nome a ser
escolhido é opcional, mas deve-se lembrá-lo pois também será usado em scripts
subseqüentes. No nosso caso, podemos chamar o arquivo de LmSOD.txt
3. Busca da proteína molde
Para gerar um modelo utilizando a técnica de modelagem por homologia, é
necessário que esteja disponível uma estrutura de proteína homóloga no PDB.
Buscas por estruturas podem ser feitas de três formas:
Diretamente no PDB: A busca avançada no PDB (canto superior direito, botão
“Advanced Search” permite efetuar uma busca por proteínas similares com
estrutura depositada no PDB. Escolhendo o critério “Sequence (Blast/Fasta)”,
pode-se inserir a seqüência da superóxido dismutase de Leishmania major, e ao se
clicar em “Show results” uma lista de estruturas de proteínas com seqüência
parecida será mostrada.
No FASTA: O servidor FASTA permite buscar por proteínas com estrutura
depositada selecionando o banco de dados “Protein structure sequences” na tela
de busca.
No Blast: Ao se escolher a busca por proteínas (protein blast), deve-se escolher
"Protein Data Bank proteins (pdb)" na opção "Databank".
Numa busca feita diretamente no PDB com a seqüência da superóxido dismutase
de Leishmania major, obtém-se um resultado parecido com o abaixo:

Dois parâmetros importantes para a seleção de um molde estão marcados em

vermelho na figura acima: a resolução (2.01Å) e a identidade seqüencial (67%). A
 identidade é o fator mais importante, no caso de mais de uma estrutura disponível
com a mesma identidade, deve-se escolher aquela com a melhor resolução. É
importante também verificar o alinhamento (movendo a barra embaixo das
seqüências) para verificar quanto da seqüência é "coberta" pela estrutura. Quando
há partes no N ou C terminal da proteína a ser modelada que não estão alinhadas
com a seqüência do molde, estas regiões serão modeladas com dificuldade pelo
Modeller. No caso em questão, a estrutura 3ESF é a que tem a melhor combinação
dos valores de identidade, resolução e "cobertura" do alinhamento. Deve-se então
salvar essa estrutura, clicando no seu código para abrir a página da estrutura e
depois clicando em "Download files" (canto superior direito) e PDB file (text). O
arquivo (3ESF.pdb) deve ser salvo então na pasta "sod" criada dentro da pasta do
modeller no passo anterior.
4. Gerar um alinhamento a partir do Modeller
Uma vez que já se tem em mãos a seqüência da proteína a ser modelada e um
molde apropriado, deve-se gerar um alinhamento das duas seqüências. O script,
também disponível na página do tutorial do Modeller, está mostrado abaixo:
from modeller import *

env = environ()
aln = alignment(env)
mdl = model(env, file='1bdm', model_segment=('FIRST:A','LAST:A'))
aln.append_model(mdl, align_codes='1bdmA', atom_files='1bdm.pdb')
aln.append(file='TvLDH.ali', align_codes='TvLDH')
aln.align2d()
aln.write(file='TvLDH-1bdmA.ali', alignment_format='PIR')
aln.write(file='TvLDH-1bdmA.pap', alignment_format='PAP')
Os códigos/arquivos que devem ser modificados estão marcados em amarelo. A
linha que começa com "mdl = ..." tem informações sobre o molde, e o campo
"1bdm" deve ser substituído pelo código do molde a ser utilizado (no nosso caso,
3esf). O campo seguinte diz qual parte do PDB será usado, e deixando como no
original ('FIRST:A','LAST:A') ele considerará toda a cadeia A, do primeiro ao último
resíduo, como o molde a ser utilizado. A linha seguinte informa qual será o código
para o molde a ser inserido no novo alinhamento (1bdmA, que pode ser
substituído por 3esfa para informar que se trata da cadeia A da estrutura 3esf), e
qual o arquivo que contem a estrutura (1bdm.pdb), no nosso caso substituído para
o arquivo baixado (3esf.pdb). A próxima linha informa que deve ser feito um
alinhamento, e a seguinte indica em qual arquivo esse alinhamento deve ser
gravado. Podemos usar o nome LmSOD-3ESF.ali, indicando que é um alinhamento
entre a seqüência de SOD de Leishmania major e a seqüência da estrutura 3ESF. A
última linha é opcional, indicando que deve ser escrito também um alinhamento
no formato PAP (não usado no nosso caso). Para que o Modeller gere o
alinhamento, deve-se então salvar esse arquivo (com um nome informativo como
"alinhar.txt") e, na tela de comandos, digitar mod9v7 alinhar.txt
Caso o programa mostre apenas a mensagem "'import site' failed; use -v for
traceback", o programa rodou normalmente e salvou o alinhamento gerado no
arquivo LmSOD-3ESF.ali
5. Gerar o modelo
Uma vez pronto o alinhamento, basta gerar o modelo usando um script apropriado
- um script básico de modelagem está também disponível na página de tutoriais do
Modeller (http://salilab.org/modeller/tutorial/basic.html):
from modeller import *
from modeller.automodel import *
 env = environ()
a = automodel(env, alnfile='TvLDH-1bdmA.ali',
knowns='1bdmA', sequence='TvLDH',
assess_methods=(assess.DOPE, assess.GA341))
a.starting_model = 1
a.ending_model = 5
a.make()
O script deve ser salvo no notepad com um nome apropriado (ex.: modelar.txt), ao
se modificar os valores marcados em amarelo. O parâmetro alnfile indica o arquivo
de alinhamento a ser utilizado - no nosso caso, é o arquivo LmSOD-3ESF.ali, gerado
no passo anterior. Deve-se informar também o código das seqüências da proteína
de estrutura conhecida (knowns, correspondente ao molde) e daquela a ser
modelada (sequence). No nosso caso, esses códigos, informados nos scripts
anteriores, são respectivamente 3ESF e LmSOD (em caso de dúvida, deve se
consultar o arquivo do alinhamento, LmSOD-3ESF. Os códigos de cada seqüência
aparecem logo após o código P1). Colocando-se o número do modelo inicial e final,
define-se quantos modelos serão gerados. No exemplo acima, são gerados cinco
modelos, o primeiro com número 1 e o último com número 5. Ao se rodar este
script na tela de comandos do Modeller com o comando mod9v7 modelar.txt , são
gerados na pasta SOD, além de vários arquivos com informações sobre o processo
de modelagem, cinco arquivos PDBs (que podem portanto ser abertos no PyMol),
chamados LmSOD.B99990001.pdb, LMSOD.B99990002.pdb e assim por diante.
6. Validação dos modelos
Uma vez que os modelos são gerados, é preciso escolher qual representa a melhor
estrutura. Quando se gera uma quantidade muito grande de modelos (algumas
dezenas), pode-se fazer uma filtragem preliminar escolhendo aqueles que têm o
menor valor da função de energia do Modeller. Para ver este valor, basta abrir o
arquivo PDB no notepad ou wordpad ao invés de um programa gráfico. As
primeiras linhas do arquivo serão como mostrado abaixo:
EXPDTA THEORETICAL MODEL, MODELLER 9v7 2009/09/01 18:00:01
REMARK 6 MODELLER OBJECTIVE FUNCTION: 1047.7017
REMARK 6 MODELLER BEST TEMPLATE % SEQ ID: 65.990
ATOM 1 N MET 1 24.454 -22.204 13.570 1.00164.14 N
ATOM 2 CA MET 1 24.396 -20.788 13.999 1.00164.14 C
ATOM 3 CB MET 1 22.953 -20.265 13.994 1.00164.14 C

Note que as primeiras três linhas indicam que o PDB em questão não é uma
estrutura experimental, mas um modelo gerado pelo Modeller, com a versão e a
data informados na primeira linha. A segunda linha mostra o parâmetro que
procuramos. Como o modelo foi feito com base numa estrutura cuja seqüência
tem alta identidade com a proteína a ser modelada, os modelos gerados são muito
parecidos e terão valores da função muito próximos. Para casos em que a
identidade é mais baixa, vale a pena gerar uma quantidade maior de modelos e
escolher apenas os de valor mais baixo da função para a validação subseqüente
(que leva mais tempo para ser feita).
A validação dos modelos usando o Procheck, Whatcheck e Verify3D pode ser feita
no servidor SAVES (http://nihserver.mbi.ucla.edu/SAVES/)
Ao rodar a validação com o primeiro modelo gerado, observa-se que o item 1 do
Procheck está marcado em vermelho, indicando um erro. Ele corresponde ao
mapa de Ramachandran, que indica que o resíduo Ala197 está em uma região não
favorável. Podemos então abrir o modelo no PyMol e verificar onde está esse
resíduo. Para isso abrimos o arquivo PDB, escolhemos "H (hide), everything" e em
seguida "S (show), cartoon" para mostrar a estrutura de acordo com as estruturas
 secundárias, e em seguida digitamos o comando "color red, resi 197". O resultado
deverá ser semelhante ao da figura abaixo:

Pode-se observar que o resíduo 197 (mostrado em vermelho após o comando para
pintar um resíduo específico) precede uma região totalmente desordenada que
não faz interações com outras partes da proteína, algo muito incomum em
proteínas globulares, o que sugere que esta região pode ter sido mal modelada.
Quando olhamos o alinhamento gerado (no arquivo LmSOD-3ESF.ali, gerado
anteriormente), vemos que de fato essa é uma região sem alinhamento:
>P1;3ESF
structureX:3ESF.pdb: 1 :A:+197 :A:MOL_ID 1; MOLECULE(...) : 2.01:-1.00
MAFSIPPLPWGYDGLAAKGISKEQVTFHYDKHHMGYVTKLNAAANSNPALAAKSVEEIIRTEKGPIFNLAAQIFN
HNFYWESMSPNGGGEPSGKLAEAIRASFGSFAKFKEEFTNAAVGHFGSGWAWLVQDTTTKKLKVFQTHDAGCPLT
EADLKPILTCDVWEHAYYIDYKNDRPAYVQTFWNVVNWDHAENQFTR-----------*

>P1;LmSOD
sequence:LmSOD: : : : ::: 0.00: 0.00
MPFAVQPLPYPHDALASKGMSKEQVTFHHEKHHKGYAVKLTAAAESNSALASKSLVDIIKSEKGPAFNCAAQIYN
HDFFWRCLSPRGGSKPHGEIASAIIDSFGSFSNFKKEFTDAANGHFGSGWAWLVKDKSSGKLKVFQTHDAGCPLT
EPDLVPILACDVWEHAYYIDYRNDRASYVSAFWNMVNWSHANHCYRAAGGSHYVNSDL*

Vê-se que enquanto a seqüência da SOD de Leishmania major (LmSOD) segue até
o final do alinhamento (*), a da estrutura 3ESF termina bem antes, contendo onze
resíduos a menos (representados pelo sinal '-'). Isso significa que todos os últimos
resíduos foram modelados ab initio pelo Modeller, programa não apropriado para
essa tarefa, e portanto não representam um modelo confiável. É mais correto,
portanto, modelar apenas a porção da proteína para a qual existe molde
disponível. Podemos então modificar manualmente o alinhamento eliminando os
onze resíduos finais da seqüência de LmSOD e os onze hífens da seqüência da
estrutura 3ESF:
>P1;3ESF
structureX:3ESF.pdb: 1 :A:+197 :A:MOL_ID 1; MOLECULE(...) : 2.01:-1.00
MAFSIPPLPWGYDGLAAKGISKEQVTFHYDKHHMGYVTKLNAAANSNPALAAKSVEEIIRTEKGPIFNLAAQIFN
HNFYWESMSPNGGGEPSGKLAEAIRASFGSFAKFKEEFTNAAVGHFGSGWAWLVQDTTTKKLKVFQTHDAGCPLT
EADLKPILTCDVWEHAYYIDYKNDRPAYVQTFWNVVNWDHAENQFTR*

>P1;LmSOD
sequence:LmSOD: : : : ::: 0.00: 0.00
MPFAVQPLPYPHDALASKGMSKEQVTFHHEKHHKGYAVKLTAAAESNSALASKSLVDIIKSEKGPAFNCAAQIYN
HDFFWRCLSPRGGSKPHGEIASAIIDSFGSFSNFKKEFTDAANGHFGSGWAWLVKDKSSGKLKVFQTHDAGCPLT
EPDLVPILACDVWEHAYYIDYRNDRASYVSAFWNMVNWSHANHCYRA*

Assim, se rodarmos novamente o script modelar.txt (se o arquivo do alinhamento

for salvo com o mesmo nome, esse script não precisa ser modificado, do contrário
é preciso informar o novo nome na linha que contem a diretiva alnfile='' nesse
script. Rodando então novamente o Modeller com o comando "mod9v7
modelar.txt", cinco modelos novos serão gerados. Testando novamente o modelo
pelo servidor SAVES, vê-se que agora o primeiro item do Procheck não está mais
em vermelho, e clicando-se no mapa de ramachandran em JPG vê-se que, agora,
não há mais resíduos fora do mapa.

Dicas adicionais para modelagem utilizando o Modeller podem ser obtidas na

página principal dos tutoriais (http://www.salilab.org/modeller/tutorial/), que
possui exemplos para tarefas mais complicadas como uso de múltiplos moldes,
modelagem de ligantes, seleção de moldes em casos de baixa identidade, etc.