Ministério da Saúde
Fiocruz
Fundação Oswaldo Cruz
INSTITUTO OSWALDO CRUZ
Pós-Graduação em Biologia Computacional e Sistemas
Fábio Bernardo da Silva
Construção de uma biblioteca de módulos para utilização na
composição de workflows para filogenia
Dissertação apresentada ao Instituto Oswaldo Cruz
como parte dos requisitos para obtenção do título de
Mestre em Biologia Computacional e Sistemas
Orientador (es): Profa. Dra. Maria Luiza Campos
Prof. Dr. Alberto Martín Rivera Dávila
RIO DE JANEIRO
2010
i
xxxx xxx
Bernardo, Fábio da Silva
Construção de uma biblioteca de módulos para utilização na
composição de workflows para filogenia./ Fábio Bernardo da
Silva – Rio de Janeiro: 2010.
121 p.; il.
Dissertação (Mestrado) – Instituto Oswaldo Cruz, Biologia
Computacional e Sistemas, 2010.
1. Bioinformática; 2. Experimentos; 3. Workflows Científicos; 4.
Sistema de Gerenciamento de Workflow Científico; 5. Árvores
Filogenéticas
CDD ****
ii
Ministério da Saúde
Fiocruz
Fundação Oswaldo Cruz
INSTITUTO OSWALDO CRUZ
Pós-Graduação em Biologia Computacional e Sistemas
Fábio Bernardo da Silva
Construção de uma biblioteca de módulos para utilização na composição de
workflows para filogenia.
ORIENTADOR (es): Prof. Dra. Maria Luiza Machado Campos
Prof. Dr. Alberto Martín Rivera Dávila
Aprovada em: ____/_____/_______
EXAMINADORES:
Prof. Dr. Antônio Basílio de Miranda (FIOCRUZ) – Presidente
Prof. Dra. Ana Carolina Paulo Vicente (FIOCRUZ) – Membro
Prof. Dra. Maria Claudia Reis Cavalcante (UFRJ) - Membro
Prof. Dr. André Nóbrega Pitaluga (FIOCRUZ) - Suplente
Prof. Dra. Vanessa Braganholo Murta (UFRJ) - Suplente
Rio de Janeiro, 22 de Junho de 2010.
iii
À Deus, que tornou tudo isto possível.
À minha esposa Cátia Marques e à minha filha Thamirys,
que muito contribuíram para a conclusão deste trabalho.
iv
AGRADECIMENTOS
Aos meus orientadores, Drª. Maria Luiza Campos e Alberto Martín
Rivera Dávila, por toda a atenção dada durante o desenvolvimento deste trabalho
e pelas orientações fornecidas para a correta condução do mesmo.
Aos professores Maria Cláudia Reis Cavalcante, Antônio Basílio de
Miranda e Ana Carolina Paulo Vicente pela presença em minha banca de
avaliação.
Ao coordenador do curso de Biologia Computacional e Sistemas da
Fundação Oswaldo Cruz, Dr. Alberto Martín Rivera Dávila, por ter confiado no
meu trabalho e fornecido as informações necessárias ao cumprimento das minhas
atividades como aluno.
Aos professores do curso de Biologia Computacional e Sistemas pelos
conhecimentos repassados e pela excelente didática de ensino durante o meu
período como aluno.
Aos meus pais, Vanderlei Ramos da Silva e Maria de Fátima Bernardo
da Silva, por tudo que representam na minha vida e que sem eles, este trabalho
seria apenas um desejo inalcançável.
Aos amigos Marcelo Pontes, Adriana Froes, Felipe, Monete Rajão
Gomes, Franklin Souza da Silva, Diogo Antônio Tschoeke, Márcia Bezerra, Felipe
Figueiredo, Gilberto, Raphael Cuadrat e Milene Pereira Guimarães os meus
sinceros
agradecimentos
pela
convivência
diária
e
pelas
informações
transmitidas.
Aos amigos Rodrigo Jardim, Kari Ocãna, Monete Rajão Gomes, Fábio
Mota, Franklin Souza da Silva e Diogo Antônio Tschoeke, pela parceria nos
conhecimentos biológicos repassados, pela ajuda nas dificuldades, pelas
atividades realizadas em conjunto e que certamente contribuíram bastante para a
realização deste trabalho.
Ao Professor Sérgio Serra Manuel da Cruz e o aluno Fernando Seabra
Chirigate, ambos da UFRJ, pelos conhecimentos transmitidos sobre workflows e
desenvolvimentos de módulos para o SGWfC VisTrails, um dos principais
conhecimentos para consolidação desta dissertação.
Ao amigo Marcelo Cunha que sempre me apoiou nos momentos mais
difíceis desta jornada. A todos os amigos que contribuíram direta ou indiretamente
nesta dissertação e a amizade feita durante a caminhada da pós-graduação.
v
Ministério da Saúde
Fiocruz
Fundação Oswaldo Cruz
INSTITUTO OSWALDO CRUZ
Construção de uma biblioteca de módulos para utilização na composição de
workflows para Filogenia.
RESUMO
DISSERTAÇÃO DE MESTRADO
Fábio Bernardo da Silva
Com o advento da era pós-genômica, ocorreu uma explosão de informações onde
inúmeras descobertas geraram grande quantidade de dados biológicos, que para
serem analisados, necessitavam da cooperação de várias áreas de
conhecimento. Inicialmente, as atividades de análises destes dados são
suportadas por programas que constituem um fluxo de trabalho, baseado em
scripts, que normalmente são executados por linha de comando, obrigando os
seus usuários a terem domínio de algoritmos e lógica de programação. Tais
scripts auxiliam muito na entrada, processamento e resultado final da análise,
mas ainda apresentam dificuldades em interferir, coletar e armazenar dados ao
longo de sua execução. Além disso, dependendo da especificidade do script, o
seu uso pode ser muito complexo, em função da dificuldade da implementação,
manutenção e reuso. Também, neste tipo de ambiente, o registro de execução
das atividades do fluxo, da origem dos dados utilizados e das transformações
aplicadas aos dados, geralmente, não são mantidos. Para tanto, tem havido o
crescente uso de workflows científicos na execução e condução de experimentos
científicos. Os workflows científicos pressupõem a resolução de problemas
científicos através das técnicas de composição do fluxo de atividades, onde os
passos normalmente são compostos por programas de bioinformática que
recebem, processam e geram um conjunto de dados que podem ser repassados
aos demais passos do workflow. Toda a estrutura de desenvolvimento e execução
desses workflows é apoiada por sistemas específicos, conhecidos como Sistemas
de Gerenciamento de Workflows Científicos (SGWfC), que possuem seus próprios
mecanismos de gerência e linguagem. Considerando as vantagens de uso dos
SGWfC no cenário da Bioinformática, este trabalho apresenta o workflow científico
para reconstrução filogenética denominado PHYLO. Como contribuições deste
trabalho, podemos citar a flexibilidade de composição de novos workflows
científicos a partir dos módulos existentes no PHYLO e os vários programas de
bioinformática disponibilizados em um ambiente de fácil utilização pelo usuário,
permitindo a intervenção do mesmo durante toda a execução do experimento,
além da visualização das árvores filogenéticas geradas.
Palavras-chaves: Bioinformática; experimentos; workflows científicos;
Sistemas Gerenciadores de Workflow Científico; árvores filogenéticas.
vi
Ministério da Saúde
Fiocruz
Fundação Oswaldo Cruz
INSTITUTO OSWALDO CRUZ
Construction of a library of modules for use in the composition of workflows for
phylogeny.
ABSTRACT
DISSERTAÇÃO DE MESTRADO
Fábio Bernardo da Silva
With the advent of post-genomic era, there was an explosion of information where
many discoveries have generated large amounts of biological data, which, to be
analyzed, needed the cooperation of various fields of knowledge. Initially, the to
industrial activities of analysis of these data are supported by programs that
constitute the workflow, based on scripts, that normally run from command line,
forcing users to algorithms and programming logic. Such scripts help much the
input, processing and outcome of the analysis, but still present difficulties for users
to interfere, collect and store data throughout their implementation. Also, according
to the specific use of the script, it can be very complex, depending on the difficulty
of implementation, maintenance and reuse. Also, in this type of environment, the
registration of the execution of the activities of the flow, the source of data used
and the transformations applied to the data are generally not retained. For these,
there has been the growing use of scientific workflows for the implementation and
execution of scientific experiments. Scientific workflows assume scientific
problems solving through techniques of composition of the flow of activities, where
the steps are usually composed of bioinformatics programs that receive, process
and generate a data set that can be passed on to other steps of the workflow. The
structure of development and implementation of these workflows is supported by
specific systems, known as Scientific Workflows Management Systems (SGWfC),
which have their own management mechanisms and language. Considering the
advantages of using the scenario SWfMS in the scientific bioinformatics, this work
presents the scientific workflow PHYLO for phylogenetic reconstruction. As
contributions of this work, we can cite the flexibility for composing new scientific
workflows from existing modules in PHYLO and the various bioinformatics
programs made available in a user-friendly environment, supporting user
intervention throughout the execution of the experiment, besides the visualization
of the generated phylogenetic trees.
Keywords: Bioinformatics; experiments, scientific workflows, Scientific Workflow
Management Systems; phylogenetic trees.
vi
LISTA DE FIGURAS
Figura 1.1 – Árvore da vida, baseada em genes ortólogos mostrando as relações
filogenéticas entre diversos grupos de organismo. Fonte: (Ciccareli et
al.,2006). ....................................................................................................................... 5
Figura 1.2 – Ferramenta e utilitários do servidor WEB Phylemon. Fonte: (Tarrara
et al., 2007). Visão geral da ferramenta Phylemon (A). Visão do Super
Phylemon, onde são armazenados os pipelines desenvolvidos pelos usuários
(B). Área de visualização e exploração de árvores retangulares, circulares e
radiais (C). Arquivos de saída (D). O mapeamento de riscos e topologia dos
resultados dos testes TREE-PUZZLE (E). Detalhes de resultados
emparelhados entre cinco espécies (F). Visão da área de Armazenamento
dos arquivos de entrada e saída em projetos específicos criados pelo usuário
(G). ............................................................................................................................... 11
Figura 1.3 - Visão geral do sistema ARPA. Fonte: Ocaña e colaboradores, 2009.
Visão da tela principal do ARPA, para entrada de arquivos no formato (A).
Visão área de resultados do pipeline (B). Área de visualização de árvores (C).
...................................................................................................................................... 13
Figura 1.4 – Proteína de aquaporina permitindo a passagem de água e
bloqueando a passagem de solutos. Fonte: (Agre e Kozono, 2003) ............... 23
Figura 3.1 - Execuções utilizando o workflow científico PHYLO e reaproveitamento
dos módulos comuns a cada experimento. .......................................................... 27
Figura 3.2 – Diagrama do workflow científico PHYLO, com os seus respectivos
programas .................................................................................................................. 32
Figura 3.3 – Detalhes da implementação dos módulos do workflow científico
PHYLO. ....................................................................................................................... 34
Figura 4.1 – Topologia da árvore filogenética não enraizada das sequências
proteicas de aquaporina 1. Método de máxima verossimilhança, com
programa PhyML, modelo evolutivo JTT, análise de bootstrap com valor 100,
categorias de taxa de substituição com valor 4 , distribuição Gama com valor
1 e proporção de sítios invariáveis = 0. ................................................................. 41
Figura 4.2 - Topologia da árvore filogenética não enraizada das sequências
proteicas de aquaporina 1. Método de agrupamento de vizinhos, com
programa Phylip com bootstrap com valor igual a 100. ...................................... 41
Figura 4.3 - Topologia da árvore filogenética não enraizada das sequências
proteicas de aquaporina 1. Método máxima parcimônia, com programa Phylip
com bootstrap com valor igual a 500. .................................................................... 42
Figura 4.4 – Topologia da árvore filogenética não enraizada das sequências
proteicas de aquaporina 3. Método de máxima verossimilhança, com
programa PhyML, modelo evolutivo JTT, análise de bootstrap com valor 100,
categorias de taxa de substituição com valor 4 , distribuição Gama com valor
1 e proporção de sítios invariáveis = 0. ................................................................. 43
Figura 4.5 - Topologia da árvore filogenética não enraizada das sequências
proteicas de aquaporina 3. Método de agrupamento de vizinhos, com
programa Phylip com bootstrap com valor igual a 100. ...................................... 43
Figura 4.6 - Topologia da árvore filogenética não enraizada das sequências
proteicas de aquaporina 3. Método máxima parcimônia, com programa Phylip
com bootstrap com valor igual a 500. .................................................................... 43
Figura 4.7 - Topologia da árvore filogenética não enraizada das sequências
proteicas de aquaporina 9. Método de máxima verossimilhança, com
programa PhyML, modelo evolutivo JTT, análise de bootstrap com valor 100,
vi
categorias de taxa de substituição com valor 4 , distribuição Gama com valor
1 e proporção de sítios invariáveis = 0. ................................................................. 44
Figura 4.8 - Topologia da árvore filogenética não enraizada das sequências
proteicas de aquaporina 9. Método de agrupamento de vizinhos, com
programa Phylip com bootstrap com valor igual a 100. ...................................... 44
Figura 4.9 - Topologia da árvore filogenética não enraizada das sequências
proteicas de aquaporina 9. Método máxima parcimônia, com programa Phylip
com bootstrap com valor igual a 500. .................................................................... 44
Figura 4.10 - Topologia da árvore filogenética não enraizada das sequências
proteicas de aquaporina 1, 3 e 9. Método de Máxima Verossimilhança, com
programa PhyML, modelo evolutivo JTT, análise de bootstrap com valor 100,
categorias de taxa de substituição com valor 4 , distribuição Gama com valor
1 e proporção de sítios invariáveis = 0. ................................................................. 46
Figura 4.11 - Topologia da árvore filogenética não enraizada das sequências
proteicas de aquaporina 1, 3 e 9. Método de agrupamento de vizinhos, com
programa Phylip com bootstrap com valor igual a 100. ...................................... 47
Figura 4.12 - Topologia da árvore filogenética não enraizada das sequências
proteicas de aquaporina 1, 3 e 9. Método Máxima Parcimônia, com programa
Phylip com bootstrap com valor igual a 500. ........................................................ 48
Figura 8.1– Tela inicial do vistrails para adicionar módulos. ..................................... 97
Figura 8.2 – Tela do Vistrails, opção “preferences” selecionada. ............................. 98
Figura 8.3 – Inserção de módulo no Vistrails 1.3. ....................................................... 98
Figura 8.4 – Tela de execução do Vistrails com módulo adicionado. ...................... 99
LISTA DE TABELAS
Tabela 1.1 - Características desejáveis em workflows científicos. ........................ 17
Tabela 1.2 – Tipos de aquaporinas e locais de maior expressão gênica. ............. 21
Tabela 3.1 - Programas implementados no PHYLO com as respectivas funções,
versão utilizada e referência. ......................................................................... 29
Tabela 3.2 - Experimento 1. .................................................................................. 36
Tabela 3.3 - Experimento 2. .................................................................................. 38
Tabela 3.4 - Experimento 3. .................................................................................. 39
Tabela 4.1 - Número de sequência de isoformas de aquaporinas de diferentes
tipos e organismos. ........................................................................................ 40
Tabela 4.2 – Características do PHYLO, sistema para reconstrução filogenética
ARPA , a ferramenta Phylemon e o ScaFos. ................................................. 50
Tabela 4.3 – Comparação entre os módulos do PHYLO e um pipeline baseado em
script .............................................................................................................. 51
x
LISTA DE ABREVIATURAS
Aligh-m
Alinhamento
divergentes
múltiplo
de
sequências
altamente
AQP
Aquaporinas
AQP1ARATH
Sequência proteica de aquaporina tipo 1 de Arabidopsis
thaliana
AQP1LEIDO
Sequência proteica de aquaporina tipo 1 de Leishmania
donovani
AQP1LEIMA
Sequência proteica de aquaporina tipo 1 de Leishmania
major
AQP1SACE
Sequência proteica de
Saccharomyces cerevisiae
aquaporina
tipo
1
de
AQP3LEIBR
Sequência proteica de aquaporina tipo 3 de Leishmania
braziliensis
AQP3LEIN
Sequência proteica de aquaporina tipo 3 de Leishmania
infantum
AQP3SACE
Sequência proteica de
Saccharomyces cerevisiae
aquaporina
tipo
3
de
AQP3TRYBRU
Sequência proteica
Trypanosoma brucei
aquaporina
tipo
3
de
AQP9LEIBR
Sequência proteica de aquaporina tipo 9 de Leishmania
braziliensis
AQP9LEIDO
Sequência proteica de aquaporina tipo 9 de Leishmania
donovani
AQP9LEIMA
Sequência proteica de aquaporina tipo 9 de Leishmania
major
AQP9LEIN
Sequência proteica de aquaporina tipo 9 de Leishmania
infantum
AQP9SACE
Sequência proteica de
Saccharomyces cerevisiae
aquaporina
tipo
9
de
AQP9TRYBRU
Sequência proteica
Trypanosoma brucei
aquaporina
tipo
9
de
xi
de
de
AQP9TRYCR
Sequência proteica
Trypanosoma cruzi
ARPA
Reconstrução automática e análise filogenética
AV
Agrupamento de vizinhos
AWTY
Um sistema de exploração gráfica de MCMC com
convergência filogenética em Inferência Bayesiana
Blast
Ferramenta básica de procura de alinhamento local
cDNA
Ácido desoxirribonucléico complementar
ClustalW
Programa para alinhamento múltiplo de sequências
Consense
Programa para geração de árvore consensu.
cRNA
Ácido ribonucleico complementar
DNA
Ácido desoxirribonucléico
Garli
Programa que executa a inferência filogenética usando
o algoritmo de máxima verossimilhança.
GARSA
de
aquaporina
tipo
9
de
Recurso de análise genômica para anotação de
sequências.
GBlocks
Seleção de blocos conservados a partir de alinhamentos
múltiplos para utilização em análise filogenética
GenBank
Base de dados de sequências genéticos
Mafft
Programa de alinhamento múltiplo de sequências
baseado em transformação rápida Fourier
Modelgenerator
Programa de seleção de melhor modelo evolutivo.
MP
Máxima parcimônia
MrBayes
Programa de filogenia usando inferência Bayesiana
MUSCLE
Programa para alinhamento múltiplo de sequências
MV
Máxima Verossimilhança
PAUP
Programa filogenético usando máxima parcimônia
PHP
Processador de hipertexto
xii
Phylip
Pacote de inferência filogenética
PhyML
Programa que implementa um algoritmo simples, rápido
e preciso para estimar grandes filogenias por máxima
verossimilhança
PROBCONS
Alinhamento probabilístico baseado na conservação de
sequências múltiplas de aminoácidos
RaxML
Programa para inferência filogenética
algoritmo de máxima verossimilhança
Readseq
Leitura e reformatação de sequências
RNA
Ácido ribonucleico
Seqboot
Bootstrap, Jackknife, ou troca com reaproveitamento de
sequências moleculares, sitio de restrição, frequência do
gen ou caracteres
SGBD
Sistema gerenciador de banco de dados
SGWF
Sistemas Gerenciadores de Workflow
SGWfC
Sistemas Gerenciadores de Workflows Científicos
SWISS-PROT
Banco de dados biológicos curados de sequências
proteicas
T-Coffee
Programa para alinhamento múltiplo de sequências
TREE-PUZZLE
Programa para análise filogenética usando método de
máxima
verossimilhança
e
quartetos
usando
computação paralela
TrimAL
Ferramenta de alinhamento automático com corte em
grande escala para análise filogenética
UniPro
Banco de dados de busca de sequências de proteínas
UPGMA
Método de agrupamento de pae=res com média
aritmética
Weighbor
Programa para reconstrução filogenética
WfMC
Coligação de administração Workflows
xiii
usando
o
SUMÁRIO
1-
INTRODUÇÃO ................................................................................................. 1
1.1 -
Bioinformática e filogenia .............................................................................. 3
1.2 -
Reconstrução filogenética ............................................................................. 5
1.3 -
Pipeline filogenético ...................................................................................... 8
1.4 -
Sistemas para análises filogenéticas ............................................................ 9
1.4.1 -
Phylemon ............................................................................................... 9
1.4.2 -
ARPA ................................................................................................... 12
1.5 1.5.1 -
Workflows ................................................................................................... 14
Sistemas de gerenciamento de workflows científicos e suas
aplicações na biologia computacional e sistemas ..................................................... 14
1.5.2 -
Workflows Científicos .......................................................................... 16
1.5.3 -
Vistrails 1.3 .......................................................................................... 18
1.5.4 -
Kepler .................................................................................................. 18
1.5.5 -
Taverna................................................................................................ 19
1.5.6 -
Workflow filogenético a ser desenvolvido ............................................ 19
1.6 -
As aquaporinas e aquagliceroporinas ......................................................... 20
1.7 -
Organização dos capítulos ......................................................................... 24
2-
OBJETIVOS ................................................................................................... 25
2.1 -
Objetivo geral .............................................................................................. 25
2.2 -
Objetivos Específicos.................................................................................. 25
3-
MATERIAIS E MÉTODOS .............................................................................. 26
3.1 -
Reconstrução filogenética ........................................................................... 26
3.2 -
Ambiente utilizado....................................................................................... 28
3.3 -
Especificação do workflow .......................................................................... 29
3.4 -
Execução e validação do workflow desenvolvido ....................................... 36
4-
RESULTADOS ............................................................................................... 40
4.1 -
Análise Filogenética das proteínas de aquaporinas 1................................. 40
4.2 -
Análise Filogenética das proteínas de aquaporinas 3................................. 42
4.3 -
Análise Filogenética das proteínas de aquaporinas 9................................. 44
4.4 -
Análise Filogenética das proteínas de aquaporinas 1, 3 e 9. ...................... 45
4.5 -
Comparação do PHYLO com outros sistemas de reconstrução
filogenética ................................................................................................................ 49
4.6 -
Comparação entre os módulos do SGWC PHYLO e um Pipeline baseado
em script......................... ........................................................................................... 51
xiv
5-
DISCUSSÃO .................................................................................................. 52
5.1 -
Reconstrução filogenética semiautomática e automática. .......................... 52
5.2 -
Flexibilidade na execução de tarefas no PHYLO,Phylemon e o ARPA ...... 53
5.3 -
Registro das etapas de execução e proveniência de dados ....................... 53
5.4 -
Uso de tecnologia WEB .............................................................................. 54
5.5 -
Reuso de módulos do PHYLO .................................................................... 54
5.6 -
Alteração e manutenção dos módulos ........................................................ 55
5.7 -
Composição de novos workflows científicos a partir do PHYLO. ................ 55
5.8 -
Dificuldades na implementação do workflow científico PHYLO .................. 56
5.9 -
Análises protéicas das aquaporinas. .......................................................... 57
6-
CONCLUSÕES .............................................................................................. 58
6.1 -
Contribuições .............................................................................................. 59
6.2 -
Melhorias e trabalhos futuros ...................................................................... 59
7-
REFERÊNCIAS BIBLIOGRÁFICAS ............................................................... 61
8-
APÊNDICES E ANEXOS ............................................................................... 71
xvi
1 - INTRODUÇÃO
A comunidade científica vem desvendando muitos aspectos da ciência da
vida fazendo uso, principalmente, de tecnologias avançadas. Nos últimos anos, no
âmbito das ciências biológicas, dois campos emergiram: a genômica e a proteômica.
Estes campos estão avançando e gerando dados muito rapidamente e a
bioinformática tem fornecido as ferramentas para análise e interpretação dessa
grande quantidade de dados como complemento às práticas laboratoriais. Os dados
obtidos através de pesquisas em bancadas, como por exemplo, sequências
nucleotídicas ou proteicas, são processados e confrontados utilizando-se softwares
de bioinformática. Os dados processados são compostos de bases de dados locais
ou bases disponibilizadas na internet [1] tendo, como exemplo, os bancos de dados
genômicos curados ou não.
A bioinformática é uma área que está em constante crescimento. Esta área
reúne o conhecimento de várias ciências, tendo como base a computação, biologia,
química,
estatística,
matemática,
física e áreas afins. Utiliza-se destes
conhecimentos para processar dados com softwares cujo objetivo principal é a
solução
de
problemas
biológicos.
Tais
processos
demandam
recursos
computacionais e cálculos matemáticos complexos. Esta prática denomina-se
pesquisa in silico [2].
Um cientista utiliza dos recursos de Bioinformática para gerar e gerenciar as
informações biológicas passa por muitos desafios no desenvolvimento de softwares,
principalmente no que diz respeito a dificuldade de construção de um programa que
possibilite a gerência da entrada/saída de dados do programa ou das atividades de
fluxo de trabalho. Normalmente, este tipo de atividade é desenvolvida utilizando-se a
sequência lógica de execução do experimento e implementada em linguagens
interpretadas, devido à simplicidade de implementação. No entanto, este tipo de
solução é, geralmente, desenvolvido de forma específica, com dificuldade de
reutilização de seus códigos ou scripts [3].
Segundo Taylor [4], pipeline é uma estrutura computacional geralmente
utilizada para combinar vários módulos de programas em um só, onde o fluxo de
trabalho e as atividades envolvidas são encadeados por conjuntos de scripts em
uma determinada linguagem de programação. Com o advento e uso de workflows
científicos, o usuário executa experimentos utilizando-se da composição de
1
programas que operam em regime de fluxo de atividades, podendo ser executado
em ambiente local ou distribuído.
Taylor [4], ao analisar a metodologia utilizada em reconstrução filogenética,
percebe que, para um cientista trabalhar com um pipeline filogenético, é necessário
que esse profissional tenha domínio de lógica de programação e conhecimento da
estrutura da linguagem onde o mesmo foi escrito. Além disso, dependendo do script
desenvolvido, o grau de dificuldade pode ser ainda maior, tornando complexas sua
utilização, flexibilidade e facilidade de reutilização, manutenção e composição de
recursos.
A utilização de Sistemas Gerenciadores de Workflows Científicos (SGWF)
possibilita ao usuário a verificação de erros, a execução total ou parcial do
experimento, bem como o aproveitamento ou reuso dos módulos desenvolvidos em
outros experimentos.
Os Sistemas de Gerência de Workflows Científicos (SGWfC) são sistemas
específicos [5], que possuem seus próprios mecanismos de gerência e linguagem
para definição e execução dos módulos criados nestes ambientes. São normalmente
lineares e centrados em dados, necessitando de estruturas de controle de fluxo [6].
Na tentativa de oferecer maior flexibilidade para a investigação de questões
biológicas, em especial, estudos de filogenia, esta dissertação tem como propósito
desenvolver uma biblioteca de módulos de um workflow científico para filogenia.
Sendo assim, este sistema tem o propósito de disponibilizar um conjunto de módulos
que implementem métodos filogenéticos para facilitar a definição dos fluxos de
atividades e o encadeamento de programas, além de oferecer flexibilidade na
composição de novos workflows filogenéticos, permitindo registrar informações
sobre sua definição e execução.
Esta introdução encontra-se dividida em sete partes. Na primeira parte, serão
abordados conceitos de Bioinformática e Filogenia. Na segunda parte, serão
abordados os conceitos de reconstrução filogenética. Na terceira parte, será descrito
um pipeline filogenético, que motivou o início dos estudos deste trabalho. Na quarta
parte serão discutidos os sistemas para análise filogenética, onde serão abordados
o Phylemon [7] e o pipeline automático para reconstrução filogenética, o ARPA [8].
Na quinta parte serão discutidos os conceitos de Sistemas Gerenciadores de
Workflow (SGWF) e Workflow científico. Na sexta parte, será abordado o alvo da
investigação, que são as aquaporinas e aquagliceroporinas. E na última parte
encontra-se a organização dos capítulos desta dissertação.
2
1.1 - Bioinformática e filogenia
Com o advento da descoberta da estrutura de DNA [9] e o surgimento dos
primeiros sequenciadores por Sanger e Coulson [10], vários métodos de filogenia
têm sido desenvolvidos com o auxílio da biologia molecular para apoiar estudos
filogenéticos. A aplicação desses métodos ampliou o universo de descobertas na
área biológica, especialmente com a utilização de dados moleculares ao invés dos
métodos tradicionais de classificação de organismos, como os baseados em
morfologia, fisiologia e paleontologia. Dados moleculares são poderosos elementos
de estudo da história evolutiva, por possibilitarem a reconstrução da filogenia dos
grupos de organismos vivos.
Baldi e Brunak [11] detectaram que a cada experimento um grande volume de
dados biológicos era gerado e necessitavam da cooperação de várias áreas de
conhecimento
para
serem
analisados.
A
informática,
com
suas
técnicas
computacionais, tem se revelado eficiente através da bioinformática, na resolução de
problemas biológicos como: sequenciamento de DNA e cDNA, análise de
expressões gênicas e determinação de estruturas proteicas, assim como na
inferência de árvores filogenéticas [12],[11].
A evolução da infraestrutura computacional tem contribuído para aprimorar as
formas de experimentação das pesquisas biológicas in silico, que utilizam Sistemas
Gerenciadores de Banco de Dados (SGBD), Sistemas Gerenciadores de Workflows
Científicos (SGWfC), programas biológicos e plataformas gráficas 2D e 3D,
facilitando desvendar os questionamentos sobre o estudo da vida.
Desde o marco fundamental representado pela teoria da evolução de Darwin
[13] a filogenia direciona seus estudos para as relações evolutivas dos seres,
representadas graficamente através de árvores filogenéticas, também conhecidas
como grafos ou cladogramas [14]. No que se refere à filogenia, pode-se ressaltar
duas importantes considerações: a filogenia clássica, que tem como base os
caracteres dos organismos, os fenótipos e os registros paleontológicos [15]; os
estudos filogenéticos, que servem tanto para inferir quanto para validar hipóteses ao
confrontar com bancos de dados genômicos, permitindo a investigação das relações
filogenéticas entre espécies.
O conceito clássico de filogenia é representado por dois segmentos de
pensamento: a escola cladista e a fenética. A cladista, ou filogenia tradicional, é a
filogenia que estuda a relação dos organismos utilizando caracteres morfológicos,
3
fisiológicos ou paleontológicos, que dão origem aos cladogramas ou árvores
filogenéticas. Já a escola fenética utiliza dados moleculares e algoritmos
matemáticos e/ou estatísticos para inferir a ordem de divergência dos táxons, assim
como os comprimentos dos ramos que os conectam, para a construção de árvores
filogenéticas dos organismos estudados [16]. A interpretação destas árvores permite
a inferência de hipóteses sobre os organismos estudados principalmente no que diz
respeito às relações evolutivas entre os dados estudados.
A filogenia tem contribuído para um melhor entendimento de como os
processos evolutivos atuam na estruturação dos seres, sendo evidente que ela é
uma ferramenta potencial de integração de questões evolutivas. Podemos citar
como exemplos de sua utilização a construção da árvore da vida [17], representada
na Figura 1.1, o estudo ecológico de comunidades [18], o entendimento do
funcionamento de ecossistemas [19], o estudo da estrutura e funções das
aquaporinas visando ao desenvolvimento de fármacos [20] e a avaliação da
resistência a fármacos desenvolvida por Tripanossomatídeos [21].
4
Figura 1.1 – Árvore da vida, baseada em genes ortólogos mostrando as relações
filogenéticas entre diversos grupos de organismo. Fonte: (Ciccareli et al.,2006).
1.2 - Reconstrução filogenética
Inicialmente,
todas
as
árvores
filogenéticas
ou
cladogramas
eram
confeccionadas manualmente. Segundo Scheineider [14], os cientistas utilizavam
caracteres morfológicos (medidas corporais, medidas parciais e presença de
estruturas) como base de todo o trabalho de prospecção de dados conceituada
como análise filogenética clássica.
Atualmente, com o surgimento da análise filogenética moderna, os cientistas
passaram a utilizar dados moleculares e métodos estatísticos para construção de
árvores filogenéticas [15]. No entanto, a melhor forma de elucidar problemas
biológicos se constitui na combinação de dados moleculares e morfológicos [22].
Segundo Nahum e Pereira [23], os principais componentes da análise
filogenética molecular incluem: a seleção de genes ou produtos de genes de
interesse, a identificação de potenciais homólogos, a busca através de métodos
baseados em similaridade de sequência, a criação de alinhamentos múltiplos das
5
sequências, a reconstrução de árvores filogenéticas utilizando diferentes métodos de
inferência e o mapeamento de informações disponíveis sobre as árvores.
Coletivamente, esses componentes servem como um quadro para testar uma
hipótese evolutiva, para suportar uma variedade de análises, como, por exemplo,
uma pesquisa na busca por um gene conservado [24], reconstrução da história
evolutiva de sequências (nucleotídicas e protéicas) através de suas relações de
ancestralidade, dentre outras [25].
Com o advento da filogenia moderna, houve a iniciativa de algumas entidades
nacionais e internacionais de unirem esforços para o desenvolvimento de bases de
dados para armazenamento de dados genômicos visando à realização de
pesquisas, sendo o GenBank um dos principais bancos utilizados [26].
Atualmente, várias pesquisas in silico utilizam em suas análises bases de
dados e sistemas para reconstrução e análise filogenética que, em função de suas
características, contribuem para reduzir o tempo e custo na obtenção de resultados.
Além disso, contribuem na identificação de organismos [27], na construção de
árvores filogenéticas e anotação funcional de proteínas [28] e genes [29].
Segundo Page e Holmes [30], os métodos de construção de árvores
filogenéticas podem ser classificados em dois tipos, de acordo com os dados a
serem tratados: métodos de distância e métodos discretos. O primeiro está limitado
à construção de uma matriz de distância na qual a diferença entre sequências é
calculada, utilizando-se um modelo de substituição de nucleotídeos [31] [14]. No
método discreto todos os caracteres são analisados diretamente, considerando o
alinhamento de sequência [30] [14].
Dentre os métodos de distância, o UPGMA (Unweighted Pair Group Method
with Arithmetic Mean) foi desenvolvido para a construção de árvores que refletem o
grau de similaridade entre os táxons estudados [32], [33] e [34], podendo também
ser utilizado para construção de árvores, desde que não ocorra uma grande
variabilidade na taxa de substituição entre as linhagens estudadas, garantindo assim
uma relação aproximada entre a linha da distância evolutiva e o tempo de
divergência [35].
O método de distância de agrupamento de vizinhos é utilizado quando se tem
variação entre as taxas de substituição entre as linhagens. Desenvolvido por Saitou
e Nei [36], este método é amplamente utilizado e tem como principal característica
ser o mais eficiente algoritmo de distância, cujo objetivo é a obtenção da árvore com
menor soma de ramos [37] [31]. Segundo Nei e Kumar [35], o método de
6
agrupamento de vizinhos começa suas análises em uma árvore sem solução. A
cada novo passo, busca-se um par de vizinhos que minimize a soma total dos ramos
da árvore, sendo o mesmo procedimento adotado para todos os ramos da árvore.
Scheineider [14] observou que, ao utilizar o método de distância, deve-se
selecionar o método mais apropriado para confecção da árvore, tendo-se em mente
qual o modelo de substituição nucleotídico mais apropriado para o estudo de um
grupo taxonômico, utilizado para obtenção da matriz de distância.
Dentre os programas existentes para obtenção de árvores filogenéticas existe
um grupo que implementa em seu algoritmo um teste estatístico da razão de
máxima verossimilhança, que compara modelos progressivamente complexos
testando duas hipóteses: a nula, que normalmente está associada a um modelo
simples, e a alternativa, que está relacionada a modelos de maior complexidade.
Nela, o processo deve validar ou rejeitar a hipótese nula que, consequentemente,
auxiliará na escolha do modelo de evolução mais apropriado para os dados
utilizados.
Dentre os métodos classificados como discretos, existe um algoritmo que é
caracterizado por definir como melhor hipótese filogenética a que apresenta menor
número de passos, onde cada passo é definido como uma mudança de estado de
caráter [38]; tal método é conhecido como máxima parcimônia (MP).
Josefh Felsenstein [39] desenvolveu o método de máxima verossimilhança
(Maximum-likelihood - ML), cuja principal característica baseia-se em modelos
probabilísticos evolucionários. O algoritmo associado implementa todas as árvores
possíveis na sua busca por árvores filogenéticas, demandando, assim, maior tempo
computacional e requerendo modelos simples para permitir um tratamento analítico,
normalmente sendo necessário o uso de grandes estruturas computacionais quando
se utiliza grande quantidade de sequências [40].
Os métodos acima citados são implementados em programas e algoritmos
para filogenia, sendo os mais utilizados os listados a seguir, de acordo com seus
objetivos e características:
a) Para alinhamento múltiplo de sequências utiliza-se o Align-m [41], ClustalW
[42], Mafft [43], Muscle [44], Probcons [45] e T-coffee [46];
b) Para limpeza de alinhamento, o Gblocks [47] e o TrimAL [48];
c) Para seleção do melhor modelo evolutivo o Modelgenerator [49];
d) Para conversão de arquivos do formato “fasta” para os formatos comumente
utilizados como PhyML e Nexus, utiliza-se o Readseq [50];
7
e) Para programas filogenéticos que implementam algoritmo baseado em
máxima parcimônia, o Phylip [51] e o Paup [52];
f) Para programas que implementam algoritmos baseados e inferência
bayesiana, temos os MrBayes [53];
g) Para os métodos de agrupamento de vizinhos, usam-se os programas Phylip
[51] e Paup [52];
h) Para algoritmos filogenéticos de máxima verossimilhança, temos os
programas Weighbor [54], Garli [55], RaxML [56], Paup [52] e Phylip [51].
Os programas para análises filogenéticas disponíveis baseiam-se em
diferentes métodos e algoritmos com conceitos e princípios diferentes que auxiliam
na reconstrução filogenética. A utilização desses programas permite a geração de
várias árvores através de diferentes abordagens que, ao serem analisadas
graficamente, permitem a inferência da árvore que melhor se aplica à solução do
problema.
1.3 - Pipeline filogenético
Um pipeline filogenético deve apresentar uma resposta à demanda por
análise de dados, possibilitando a integração de diferentes softwares filogenéticos
[7] e contendo uma interface gráfica amigável, podendo, assim, ser utilizada por
usuários que não tenham formação em lógica e programação de scripts ou
conhecimento específico em determinada linguagem de programação. Além disso,
deve permitir o uso de valores padrões e/ou ser configurável, não exigindo, por parte
do usuário, conhecimentos específicos de cada software que o componha. O
pipeline deve ter um processamento interno transparente para o usuário, de forma
que seja possível fazer uso de um ambiente computacional gráfico, de fácil acesso.
O ideal é que possa ser executado em grids ou clusters, para minimizar o tempo de
resposta às análises.
O uso de pipeline é muito comum em pesquisas biológicas, demandando a
integração de vários programas. Os pipelines correspondem a um conjunto de
programas que compõem uma sequência de atividades idealizadas pelo cientista.
Como exemplo de pipelines, podemos citar: o pipeline para análise de sequências
ESTs de formigas Attini [57]; o TargetTB, para construção e análise de redes de
interação entre proteínas [58]; e o JCSG MR pipeline, para pesquisa otimizada de
alinhamento em paralelo para vários modelos de arquivos [59].
8
1.4 - Sistemas para análises filogenéticas
Existem vários métodos de construção de árvores filogenéticas que, em
função de seus algoritmos e parâmetros, produzem diferentes tipos de árvores. Este
fato é totalmente desejável, pois o objetivo dos estudos em filogenia é a
possibilidade de criação e comparação entre árvores filogenéticas. O conjunto de
árvores é obtido a partir de sequências nucleotídicas ou protéicas por diferentes
métodos visando à obtenção da melhor árvore.
Embora muitos dos métodos existentes para comparação de árvores
filogenéticas tenham sido descritos, poucos foram implementados para sua
utilização em um único programa, além da inexistência de um programa com um
conjunto abrangente de métodos para serem executados [60]. Por esta razão, faz-se
necessário o desenvolvimento de sistemas que possibilitem o uso de múltiplos
programas filogenéticos, centralizados em uma única ferramenta. Normalmente,
estas ferramentas são plataformas desenvolvidas utilizando recursos da WEB, onde
são integrados diferentes programas objetivando a análise filogenética e evolutiva de
organismos.
Entre os vários sistemas para análises filogenéticas disponíveis na literatura,
encontramos o Phylemon [7], que consiste em um conjunto de ferramentas WEB
que comporta vários programas para estudar evolução molecular, filogenia e
filogenômica,
(disponível em
reconstrução
automática
e
http://phylemon.bioinfo.cipf.es/), o
para
análise
filogenética
[8]
ARPA, para
(disponível
em
http://kineto2.biowebdb.org/arpa/) e o PhyloPattern, utilizado para identificação de
padrões complexos em árvores filogenéticas [61].
1.4.1 - Phylemon
O Phylemon foi desenvolvido como uma ferramenta que integra um conjunto
de programas filogenéticos (Figura 1.2), em resposta à crescente demanda de
análise de dados experimentais, com foco em análises de filogenia molecular.
As ferramentas no Phylemon incluem os seguintes programas:
• Para alinhamento múltiplo de sequências é utilizado o Clustalw
v1.83 [42] e MUSCLE v3.52 [44];
• Para métodos estatísticos de reconstrução filogenética são
utilizados o Phyml v2.4.5 [62], o TreePuzle v5.2 [63], o MrBayes
9
v3.1.12 [53] e o Phylip v3.65 [51], composto pelos seguintes
pacotes: o Seqboot [64], o Consense [64], o DNAdist [64], o
PROTdist [64], o DNAml [64], o PROml [64], o DNAPars [64] e o
PROTPars [64];
• Para métodos de análise evolutiva e adaptação molecular, são
utilizados o ModelTest [65], ProtTest [64], RRTree v1.1.11 [66],
Yn00 [67], SRL [68] e o CodeML [69].
Segundo Tarrara e colaboradores [7], a Figura 1.2 mostra as ferramentas e
utilitários do servidor WEB Phylemon (A). O Super Phylemon mostra as opções
definidas pelo usuário (entre três), com três análises alternativas provenientes de
dois arquivos no formato FASTA (B). Logo em seguida, árvores retangulares,
circulares e radiais feitas no ambiente de exploração de árvores (C). A figura mostra
os arquivos de saída e o diagrama de aumento de probabilidade (D), o mapeamento
de risco e topologia dos resultados dos testes TREE-PUZZLE (E), o detalhamento
dos resultados emparelhados entre cinco espécies (F) e o registro de arquivos de
entrada e saída em projetos específicos (G).
10
Figura 1.2 – Ferramenta e utilitários do servidor WEB Phylemon. Fonte: (Tarrara et
al., 2007). Visão geral da ferramenta Phylemon (A). Visão do Super Phylemon, onde
são armazenados os pipelines desenvolvidos pelos usuários (B). Área de
visualização e exploração de árvores retangulares, circulares e radiais (C). Arquivos
de saída (D). O mapeamento de riscos e topologia dos resultados dos testes TREEPUZZLE (E). Detalhes de resultados emparelhados entre cinco espécies (F). Visão
da área de armazenamento dos arquivos de entrada e saída em projetos específicos
criados pelo usuário (G).
11
O Phylemon possui várias características que o diferencia de outras
ferramentas:
• Oferece um ambiente integrado que permite a concatenação de
análises evolutivas, o armazenamento de resultados e opções
de conversão de formato;
• Uma vez produzido o arquivo de saída, o Phylemon sugere as
próximas análises possíveis, permitindo, assim, a integração de
várias atividades na análise;
• Os usuários podem definir e salvar passos necessários para
determinadas análises filogenéticas a serem automaticamente
usadas em muitos genes nas seções subsequentes ou múltiplos
genes em uma única sessão [7].
Como característica negativa do Phylemon, tem-se o fato do usuário ter que
estar a todo o momento interagindo com a aplicação durante a execução do
experimento, pois as atividades a serem desenvolvidas são feitas uma após a outra,
sendo os dados de saída de uma atividade usados como dados de entrada em
outra. Entretanto, o usuário deve aguardar longos períodos entre as interações para
a inserção dos parâmetros do experimento, ao invés de aguardar somente o
resultado final.
1.4.2 - ARPA
O ARPA (Figura 1.3) é um sistema composto por pipeline em scripts e
tecnologia WEB para realização de análises filogenéticas de dados moleculares. As
técnicas filogenéticas usadas no pipeline incluem limpeza de alinhamento, escolha
do modelo evolutivo com o programa modelgenerator [49] e matrizes de distância
(agrupamento de vizinhos), máxima parcimônia e métodos de inferência Bayesiana
e máxima verossimilhança.
O ARPA pode ser usado para análise filogenética de um ou de múltiplos
genes ou proteínas. Neste sistema, assim como no Phylemon, estão implementados
os programas filogenéticos mais utilizados nesta área de pesquisa, sendo eles: o
PHYLIP [51], PAUP [52], PHYML [62], WEIGHBOR [54], TREE-PUZZLE [63],
RAXML [56], GARLI [55] e MRBAYES [53]. Uma das características do ARPA é que
o sistema foi desenvolvido tanto para ser usado na WEB como em linha de
comando.
12
C
A
C
Figura 1.3 - Visão geral do sistema ARPA. Fonte: Ocaña e colaboradores, 2009.
Visão da tela principal do ARPA, para entrada de arquivos no formato (A). Visão
área de resultados do pipeline (B). Área de visualização de árvores (C).
O sistema ARPA, na sua versão WEB, disponibiliza para o usuário uma
interface configurável, incluindo como parâmetros o tipo de alinhamento, limpeza de
sequência e programas filogenéticos com seus respectivos valores de configuração
a serem implementados na análise. Após este passo, o usuário executa a análise e
só precisa esperar a disponibilização do resultado final através de links para
visualização das diversas árvores geradas. Este fato o diferencia em muito do
Phylemon, onde em cada etapa do experimento o usuário deve aguardar o resultado
de uma atividade, para usá-lo como dado de entrada de outra, para um novo
processamento.
13
1.5 - Workflows
O termo workflow tem sua origem associada ao processo de automação de
escritórios, sendo idealizado na década de 70 [70]. É definido como a automação do
fluxo de trabalho ou de um processo de negócio, em parte ou como um todo, onde
documentos, informações e tarefas são passadas de um participante ao outro, de
acordo com um conjunto de regras definidas [71].
Os workflows são importantes no sentido de executar um conjunto de
atividades e/ou programas computacionais objetivando experimentos científicos,
bem como a gestão das informações ao longo da execução da análise, provendo um
ambiente robusto de resolução de problemas e promovendo a otimização de
recursos computacionais [71].
Existem várias definições para workflows. A definição mais recente remete à
execução controlada de múltiplas tarefas ou atividades em um ambiente de
elementos processados, ou seja, workflow é um conjunto de atividades que podem
ser executadas com suas relações interdependentes, suas entradas e saídas [72].
Para o desenvolvimento de um workflow, podem-se destacar duas grandes
fases: a fase de definição ou modelagem do workflow e a fase de execução do
mesmo [73]. Durante a definição de um workflow é especificado como ocorrerá o
fluxo de execução, indicando-se os passos envolvidos, as restrições existentes, a
ordem de execução das atividades do workflow, o tratamento das informações, a
existência de possíveis desvios no fluxo normal da execução e tratamento de erros.
Na fase de execução são processadas todas as atividades definidas na etapa de
modelagem, seguindo a sequência estabelecida na sua definição. A execução
considera a ordem definida para as atividades do workflow, transformação de dados
na transferência entre atividades, execução de tarefas de modo automático ou
manual e, ainda, ferramentas ou recursos que permitam o monitoramento da
execução.
1.5.1 - Sistemas de gerenciamento de workflows científicos e suas aplicações
na biologia computacional e sistemas
Os Sistemas de Gerenciamento de Workflows Científicos (SGWfCs) visam
apoiar a descrição de workflows voltados para as aplicações científicas de quaisquer
áreas de pesquisa, como biologia, física, química, geologia, entre outras, que
14
tenham a necessidade de modelar computacionalmente seus experimentos. Os
SGWfCs são responsáveis por invocar as aplicações, locais ou externas, que
participam de um workflow científico, coordenando a transferência de dados entre
elas.
O workflow científico GARSA [86] tem como finalidade produzir conjuntos de
sequências anotadas que tenham algum significado biológico. Outro exemplo é o
OrthoSearch [2], workflow desenvolvido para busca de homologias distantes em vias
metabólicas de Tripanossomatídeos.
Para atender às necessidades científicas, um SGWfC deve apresentar as
seguintes características [74]:
1. Processos, dados e recursos – deve contemplar processos, dados
e recursos comumente usados e permitir a extensibilidade, visando acomodar novos
processos, dados e recursos.
2. Definição - deve auxiliar o usuário na definição e redefinição do
workflow. A redefinição é um passo importante quando os resultados obtidos não
forem considerados úteis ou interessantes pelos usuários
3. Validação - deve oferecer mecanismos para validação de
workflows. Durante a validação, o sistema deve verificar se as entradas e saídas
definidas pelos usuários para cada processo são consistentes, além de incluir, caso
necessário, processos que possam converter os formatos dos dados e processos
que verifiquem se os resultados gerados pelos programas são ou não os esperados.
4. Otimização, monitoramento e execução – deve ser capaz de
otimizar e executar o workflow definido pelo usuário. A execução do workflow pode
ser monitorada e deve permitir a intervenção do usuário em qualquer ponto, o que é
necessário se o usuário quiser avaliar os resultados intermediários para decidir se
continua, ou não, com a execução, ou para fazer alguma modificação na definição
das próximas atividades do workflow.
5. Agendamento – deve apoiar o agendamento da execução do
workflow, permitindo que um workflow seja executado uma única vez em um
determinado dia ou de tempos em tempos.
6. Dados e metadados - armazenar dados e metadados produzidos e
que tenha suporte para acesso aos mesmos de forma eficiente, permitindo a gestão
destes dados [75].
Na área da biologia computacional e sistemas, os workflows científicos são
utilizados em experimentos biológicos que requerem análise e processamento
15
computacional, através da composição de uma diversidade de programas biológicos,
onde cada programa compõe uma atividade ou parte específica do workflow e a
saída de dados de um módulo compõe a entrada de dados do módulo seguinte.
Cabe ao mecanismo de suporte ao workflow organizar a execução destas etapas,
além de gerenciar os dados processados por cada um deles dentro do mesmo.
Os workflows científicos têm foco nos dados, normalmente são lineares, com
alto volume de processamento de informações, elevada frequência de mudanças.
Necessita de validações intermediárias, suporte a proveniência e reuso, permitindo a
intervenção do usuário.
1.5.2 - Workflows Científicos
Inicialmente, os workflows tiveram sua contextualização original na área
comercial, objetivando ambientes de negócios [76]. Áreas como biologia, química,
física, geografia, engenharia, entre outras, passaram a utilizá-los para auxiliar suas
pesquisas através da simulação de experimentos em ambientes computacionais.
Em 2005, Singh e Vouk [77] definiram workflows científicos como sendo a
resolução de problemas científicos através de técnicas tradicionais de workflows. O
conceito de execução de um grupo de atividades em uma determinada sequência foi
aproveitado na área científica para a realização de estudos e experimentos
científicos.
No meio científico, o uso de workflows tem sido adotado para descrever e
executar análises in silico, onde estes são modelados através da composição de
recursos computacionais em uma sequência de execução. É comum o uso de
scripts que definam a sequência completa de execução e os parâmetros de
execução do fluxo de trabalho, chamados de pipelines. Os scripts consistem em
aplicações, normalmente desenvolvidas em PHP (Linguagem de script altamente
difundida no meio científico) ou em qualquer outra linguagem. A grande
especificidade de um script pode dificultar sua manutenção e reduzir a capacidade
de reutilização. Além disso, registrar as execuções dos programas, a origem dos
dados utilizados, as transformações aplicadas aos dados, os resultados obtidos,
entre outras, é, muitas vezes, impossível.
A Tabela 1.1 resume as principais características de workflows científicos:
16
Tabela 1.1 - Características desejáveis em workflows científicos.
Características
Interface
Reutilização
Transformação de dados
Interações e processamento em lote
Execução parcial
Localidade
Complexibilidade
Dependência
Verificação e Validação
Alterações dinâmicas
Descrição
A modelagem do workflow deve ser
intuitiva e o ambiente de execução
voltado para o usuário final. Detalhes de
implementação não devem ser expostos,
permitindo que o usuário concentre-se
apenas no nível conceitual do workflow.
Os
componentes
deverão
ser
reutilizáveis e intercambiáveis. Deve ser
possível adicionar ou remover processos
dinamicamente.
Deve permitir transformações de dados
entre as atividades de um processo.
Deverá suportar “Process steering” (play,
pause e stop) durante a execução de um
processo, permitindo monitoramento do
experimento.
Oferecer suporte à execução parcial.
Apenas parte do experimento poderá ser
executada.
Deverá suportar processamento local e
distribuído do workflow.
Deverá ser capaz de manipular
complexos fluxos de dados, controles e
eventos.
Deverá estar associado a um sistema de
gerência
confiável,
de
alta
disponibilidade e tolerante a falhas.
Deverá verificar e validar a construção
ou importação de workflows.
Permitir alterações na definição do
workflow durante a execução, pois a
definição do workflow pode ser
influenciada
pelos
resultados
intermediários.
Atualmente existem inúmeros Sistemas Gerenciadores de Workflow Científico
disponíveis para uso, entretanto por uma questão de objetividade selecionamos
17
apenas algumas dessas ferramentas que ilustram satisfatoriamente os conceitos
mais relevantes. As ferramentas selecionadas são Vistrails [78] e [79], Kepler [80] e
Taverna [81] e [82].
1.5.3 - Vistrails 1.3
O Vistrails [78] é um software de gerenciamento de workflow científico,
concebido na Universidade de UTAH. Seu principal objetivo é prover suporte e
visualização de dados, fazendo uso de uma interface chamada Vistrails Builder, que
além de ser muito intuitiva permite o projeto de workflows, sua reutilização e também
a consulta de informações. Tem como objetivo principal prover suporte à exploração
e visualização de dados.
Uma das principais características deste software é a disponibilização do
mesmo para múltiplas plataformas, ou seja, existem versões para vários sistemas
operacionais, como o Windows, Linux e até plataformas gráficas Mac OS X.
Sua interface gráfica possui três áreas principais: área de módulos ou objetos
que compõem os workflows, a área de design, onde é desenhado o workflow, e uma
área especifica para exibir as propriedades dos módulos desenvolvidos para um
determinado workflow.
Toda atividade ou workflow desenvolvido no Vistrails é versionado,
possibilitando, assim, o reaproveitamento dos mesmos em novas execuções. Para a
comparação dos resultados, este possui um mecanismo que permite a visualização
múltipla de resultados do workflow executado.
Ao final da execução dos workflows ou atividades do processo, é gerado um
arquivo no formato XML, que possibilita a integração dos resultados com vários
sistemas e bases de dados existentes, evidenciando assim a versatilidade de
portabilidade de resultados, tendo em vista que o formato XML é reconhecido por
várias linguagens de programação e sistemas gerenciadores de banco de dados.
Possui também uma infraestrutura que pode ser utilizada com qualquer sistema de
visualização.
1.5.4 - Kepler
O Kepler [80] é um software desenvolvido e mantido a partir de uma
colaboração entre os projetos SEEK (Science Environment for Ecological
18
Knowledge), SDM Center/SPA (SDM Center/Scientific Process Automation), Ptolemy
II (Heterogeneous Modeling and Design), entre outros. Este software permite
desenhar workflows científicos e executá-los de forma eficiente e distribuída através
da abordagem baseada no padrão Grid. [83].
O Kepler [80] opera com uma grande variedade de formatos, localmente e/ou
através da internet, e é um meio eficaz para integração de componentes de
diferentes softwares. O Kepler ajuda os usuários a compartilhar e reutilizar dados,
fluxos de trabalho e componentes desenvolvidos pela comunidade científica para
atender às necessidades comuns.
O Kepler [80] é um software desenvolvido utilizando-se o conceito de software
livre. A linguagem de programação utilizada no seu desenvolvimento é o Java [84] e
está disponível para instalação nos sistemas operacionais Windows, Linux e Mac
OS X.
1.5.5 - Taverna
O Taverna é um projeto que apesar de ser usado por várias áreas científicas,
tem o seu principal foco no gerenciamento de workflows voltados para experimentos
de bioinformática [81]. O projeto é mantido pelo EPSRC (Engineering and Physical
Sciences Research Council), por alguns colaboradores da indústria privada, por
universidades do Reino Unido e pelo grupo European Bioinformatics. Este software
foi desenvolvido para ser utilizado em plataformas com sistemas operacionais
Windows ou Linux. Seu código é aberto e foi desenvolvido na linguagem de
programação JAVA [84], sendo orientado a serviços. Possui uma interface gráfica,
onde o usuário modela o seu workflow científico [85].
Provê uma série de recursos, objetivando facilitar a definição de workflows,
dentre eles: serviços pré-definidos, estruturas de dados específicas, suporte
semântico através de ontologias e serviços de proveniência dos dados.
1.5.6 - Workflow filogenético a ser desenvolvido
Este trabalho visa o desenvolvimento de pacote de módulos de um workflow
científico denominado PHYLO usando um sistema de gerenciamento de workflow
científico. O workflow desenvolvido é uma ferramenta visual para reconstrução
filogenética em apoio ao pipeline ARPA, permitindo a concatenação de programas
19
filogenéticos. O acompanhamento da execução do workflow possibilitará verificar a
ocorrência de erros de experimento em função dos dados intermediários gerados na
execução total ou parcial do workflow. Esses dados são essenciais para comprovar
ou negar as hipóteses e postulados determinados no início do experimento.
O workflow filogenético está dividido em módulos, cujo objetivo principal é
permitir ao usuário uma facilidade no uso deste e uma flexibilidade para
aproveitamento dos módulos desenvolvidos na confecção de outros workflows, além
da facilidade de modificação e composição de recursos distribuídos.
Assim, contribuirá para a identificação de espécies e auxiliar nos estudos da
história evolutiva de organismos, epidemiologia, transferência horizontal de genes,
genética de populações e filogeografia de espécie. Pode ser empregado na área
biomédica, contribuindo para inferência de organismos, além de detectar a
resistência dos mesmos a medicamentos, em função da estrutura evolutiva dos
organismos patogênicos e auxiliar a proposição de alvos para novos fármacos.
1.6 - As aquaporinas e aquagliceroporinas
Após um século de discussão sobre conceitos relacionados ao movimento de
água, através das membranas celulares, as principais teorias foram: (i) a idéia de
canais ou poros nas membranas biológicas através de vias especializadas para
passagem de água e hidrofílicos; (ii) a mecânica da osmose em termos de pressão
através dos poros nas membranas; (iii) a existência de uma rede de transporte de
água na ausência de qualquer força propulsora; (iv) a existência de uma carga
estagnada de solutos que poderia ter efeitos no transporte de água na membrana
[86].
Em 1991, Preston e colaboradores [87] e Preston e Agre [88] isolaram e
clonaram o gene CHIP29 da célula precursora do eritrócito no fígado fetal e
demonstraram sua função após isolar seu DNA complementar (cDNA). A expressão
do gene conferiu à célula o aumento aproximado de 20 vezes no coeficiente de
permeabilidade de água. O gene CHIP29 foi então associado ao primeiro canal de
água descoberto que mais tarde foi denominado aquaporina 1 (AQP1).
As aquaporinas (Figura 1.4) são canais de proteínas que atravessam a
membrana celular e permitem a entrada e saída de água, como descrito em Peter
Agre [89].
20
Segundo Borgnia e colaboradores [90], as aquaporinas são classificadas em
dois tipos:
• As aquaporinas (AQP): transportam especificamente água, excluindo
solutos.
• As aquagliceroporinas: transportam glicerol e pequenos solutos além
de água.
As aquaporinas fazem parte de uma superfamília de proteínas encontradas
em todos os tipos de organismos incluindo bactérias, arqueas, fungos, plantas e
animais [91]. Atualmente existem vários tipos de aquaporinas conhecidas em
mamíferos e humanos, expressas em uma variedade de tecidos [92]. Sendo que,
para cada tecido, existe uma expressão de um gene de aquaporina específica. A
Tabela 1.2 resume os principais tipos de aquaporina e locais onde são expressas.
Tabela 1.2 – Tipos de aquaporinas e locais de maior expressão gênica.
AQUAPORINA
LOCALIZAÇÃO
AQP 0
Cristalino dos olhos
AQP1
Vasos sanguíneos, túbulos renais proximais, orelha e olhos
AQP2
Localizada nos túbulos coletores para concentração da urina
AQP3
Túbulos coletores, epiderme, tratos respiratório e digestivo
AQP4
AQP5
Membrana perivascular de astrócitos, olhos, orelha, músculo
esquelético, estômago e túbulos coletores
Córnea, glândulas salivares serosas, sudoríparas e células
epiteliais pulmonares
AQP6
Túbulos coletores
AQP7
Adipócitos, testículos e rins
AQP8
Rins, testículos e fígado
AQP9
Fígado e leucócitos
21
AQP10
Intestino, dúctulos eferentes
As aquaporinas e aquagliceroporinas são canais predominantes nos cinco
reinos e tendo funcionalidades semelhantes em diversos organismos não seria
novidade que muitos parasitas pudessem expressar isoformas de aquaporinas nas
regulações osmótica e nutricionais no que diz respeito à relação parasita e
hospedeiro [92].
Segundo Beitz [20], os protozoários patogênicos são uma grande ameaça
para a saúde humana. A prova disto está no fato do crescente número de pessoas
infectadas e, principalmente, nos mais de dois milhões de óbitos anuais causados
por estes microrganismos. Além disso, a rápida disseminação de cepas resistentes
tem causado uma preocupação aos órgãos de saúde pública global [93].
Este quadro mundial, provocando ônus na saúde e na econômia, foi o gatilho
para as iniciativas de projetos de sequenciamento dos genomas desses patógenos
visando, principalmente, a elucidação da biologia e do metabolismo deles, e
também, acelerar a identificação de novos alvos para fármacos [94].
As aquaporinas são o alvo deste estudo, por estarem presentes em todos os
organismos vivos e por sua participação nas funções vitais para o organismo do
parasita. Além do fato que em função de suas características, podem ser
reconhecidas como um potencial alvo para construção de fármacos ou rota de
transporte de dos mesmos [95], [96].
As aquaporinas e aquagliceroporinas são alvos promissores para fármacos,
pelo fato de terem como interferir e prejudicar substancialmente a sobrevivência de
parasitas. Mais especificamente, elas podem interferir na proteção osmótica, síntese
lipídica e de glicose [97]. Um exemplo seria o agente causador da malária, o
Plasmodium falciparum, que possui uma aquagliceroporina localizada na membrana
do parasita para o transporte de água e glicerol [92].
Beitz [20] afirma que a estrutura das aquaporinas humanas são diferentes se
comparadas a dos parasitas. Assim, os fármacos a serem desenvolvidas devem ser
adaptados à supressão das aquaporinas parasitárias, evitando interação com a
aquaporina humana [92].
Dependendo do tipo e da expressão gênica da aquaporina em determinados
organismos, esta pode ser vista como potencial condutor de fármacos ou como fator
22
regulador de resistência aos mesmos, pois se uma aquaporina tiver uma maior
expressão e assim permitir somente a passagem de água, esta não permitirá
passagem de solutos que normalmente são a base do funcionamento de alguns
medicamentos [20].
Figura 1.4 – Proteína de aquaporina permitindo a passagem de água e bloqueando
a passagem de solutos. Fonte: (Agre e Kozono, 2003).
A relação entre a expressão do gene de aquaporina e sua função na invasão
de um parasita, tendo como exemplo as vias biliares pela malária [98], oferece um
possível alvo para o desenvolvimento de fármacos. O tratamento terapêutico deve
interferir no processo de invasão do parasita, através da supressão da aquaporina
no parasita ou função de ligação do parasita com o hospedeiro. Através de análises
in silico, pressupõe-se que possam ser projetados fármacos que modifiquem a
seletividade dos poros, por exemplo, da aquaporina parasitária, bloqueando assim a
passagem de água ou glicerol em parasitas específicos, neste caso o do P.
falciparum, causador da malária, mantendo a integridade das aquaporinas humanas
[92].
Como exemplo de experimentos in silico, podemos citar Beitz [95] e Kalinina e
colaboradores [99] que fizeram uso de scripts para alinhamento de suas sequências
e em seguida, geraram árvores, objetivando inferências filogenéticas sobre as
23
aquaporinas. Krane e Goldstein [100], Hamdi e colaboradores [101] e Leprohon e
colaboradores [102] realizaram seus experimentos utilizando-se de programas
disponibilizados na WEB, ou seja, softwares on-line para teste de suas hipóteses,
enquanto Pontincasa e colaboradores [80], Kalilina e colaboradores [81] e Zardoya e
colaboradores [103] construíram a base de seus experimentos em pipelines,
compostos por vários programas com alto grau de complexidade, que envolviam
vários métodos filogenéticos.
1.7 - Organização dos capítulos
Para facilitar a compreensão desta dissertação, o segundo capítulo descreve
os objetivos gerais e específicos deste trabalho. No terceiro capítulo abordaremos o
material e método, onde abordaremos os requisitos necessários para a
implementação do workflow científico, os softwares filogenéticos necessários e
também o desenvolvimento e disponibilização dos módulos desenvolvidos no
sistema gerenciador de workflow científico.
O quarto capítulo apresenta os resultados obtidos com a execução do
workflow científico PHYLO, realizando a filogenia dos genes de aquaporinas e as
respectivas árvores geradas.
No quinto capítulo, discutiremos as dificuldades de implementação do
workflow científico, os resultados obtidos e vantagens com relação à literatura
disponível, sua flexibilidade para compor novos workflows, reuso dos módulos e uma
comparação entre workflows científicos e pipeline desenvolvido fazendo uso de
scripts.
No último capítulo, concluiremos esta dissertação, resumindo seu conteúdo,
listando as contribuições obtidas pela pesquisa e apontando melhorias para futuros
trabalhos.
24
2 - OBJETIVOS
2.1 - Objetivo geral
A presente dissertação tem como objetivo geral o desenvolvimento e
implementação da biblioteca de módulos para utilização na composição de
workflows científicos (módulos PHYLO) para reconstrução filogenética no sistema de
gerenciamento de workflows científicos Vistrails 1.3.
2.2 - Objetivos Específicos
I. Aplicação dos módulos de biblioteca no desenvolvimento e implementação
de um workflow científico utilizando um sistema de gerenciamento de workflow
científico para reconstrução filogenética.
II. Aplicar o workflow a vários segmentos da área biológica que tenham como
objetivo a inferência de hipóteses e pesquisas usando filogenia.
III. Avaliar a funcionalidade do workflow ARPA usando a biblioteca PHYLO
quanto a sua utilização na composição de workflows científicos.
25
3 - MATERIAIS E MÉTODOS
O desenvolvimento da biblioteca de módulos para utilização na composição de
workflows científicos para reconstrução filogenética (PHYLO) foi baseado no pipeline
ARPA [8].
O ARPA é um pipeline de reconstrução filogenética que utiliza de tecnologias
da WEB para disponibilizar ao usuário um sistema com a possibilidade de uso de
vários programas de alinhamento múltiplo, limpeza de sequências alinhadas e
diversos métodos de reconstrução filogenéticos. Tais métodos utilizam algoritmos de
Inferência Bayesiana, agrupamento de vizinhos, máxima verossimilhança e máxima
parcimônia, além de possuir também uma versão funcional através de linha de
comando.
O workflow PHYLO desenvolvido nesta dissertação foi inteiramente baseado
no pipeline do ARPA e possui as mesmas características de disponibilização de
programas para reconstrução filogenética. Tem como diferencial a vantagem de ser
suportado por um SGWfC que permite ao usuário: (i) a intervenção durante a
execução do processo do experimento; (ii) suporte à proveniência de dados; (iii)
flexibilidade de uso dos módulos; (iv) execução parcial de tarefas; e (v)
monitoramento de execução do experimento.
A seção 3.1 aborda um plano de problemas biológicos para a condução de
experimentos. A seção 3.2 descreve o ambiente de hardware e software necessário
para a instalação e execução do módulo PHYLO. A seção 3.3 inclui a especificação
do workflow. Ao final, na seção 3.4, abordamos a execução e validação do PHYLO
tendo como base o plano de testes elaborado na seção 3.1.
3.1 - Reconstrução filogenética
Neste trabalho, realizamos análises filogenéticas dos genes das aquaporinas
envolvidas no transporte osmótico em células eucarióticas e procarióticas.
Os ensaios in silico foram realizados com 26 sequências de proteínas de
aquaporinas obtidas no banco de dados UniProtKB [104], acessado em 29 de abril
2010. Por se tratar de um banco curado de sequências protéicas, tal característica
foi importante pois proporcionou confiança na anotação das proteínas obtidas (como
a descrição da função da proteína, a sua estrutura e domínio, etc.), além de possuir
um nível mínimo de redundância e alto nível de integração com outros bancos de
26
dados. Sendo assim pode-se afirmar que os experimentos foram realizados com
dados confiáveis.
A obtenção dessas sequências foi realizada da seguinte forma: (i) conexão
com o site do UniProt [105]; (ii) pesquisa no banco do UniProtKb utilizando a
palavra-chave “aquaporina”; (iii) com base nos resultados obtidos, as sequências de
proteínas foram reunidas em um único arquivo de formato “fasta”.
De posse das sequências destas proteínas, foi estruturado um plano de
execução do experimento ilustrado na Figura 3.1.
Figura 3.1 – Execuções utilizando o workflow científico PHYLO e reaproveitamento
dos módulos comuns a cada experimento.
27
Nos três experimentos, foram usadas as mesmas 26 sequências proteicas de
aquaporinas. Todas foram alocadas em um arquivo em formato “multifasta e foi
utilizado o programa MAFFT [43] para o alinhamento múltiplo das mesmas. Foram
também utilizados vários métodos de geração de árvores filogenéticas utilizando os
programas disponíveis no módulo PHYLO, além da visualização das árvores
geradas. A versão de cada um dos programas utilizados encontra-se listada na
Tabela 3.1.
No experimento 1 foi gerada uma árvore filogenética utilizando o método de
máxima verossimilhança, tendo como entrada de dados um arquivo multifasta
contendo as 26 sequências de aminoácidos das aquaporinas, obtidas no banco de
dados UniProtKB [104]. Após o alinhamento múltiplo com o Mafft [43], a limpeza das
sequências alinhadas foi realizada com o programa TrimAL [48]. O arquivo foi
convertido no formato Phylip usando o programa Readseq [50] e a árvore
filogenética foi criada usando o programa PhyML [62].
No experimento 2 foi gerada uma árvore filogenética utilizando o método de
agrupamento de vizinhos. A entrada de dados foi um arquivo no formato Nexus. O
alinhamento múltiplo das sequências foi realizado com o programa Mafft [43]. A
limpeza das sequências alinhadas foi realizada com o programa TrimAL [48] e a
árvore filogenética foi reconstruída usando o programa Phylip[51].
Já no experimento 3 foi gerada uma árvore filogenética utilizando-se o método
de máxima parcimônia. O alinhamento múltiplo das sequências foi realizado com o
programa Mafft [43]. A limpeza das sequências alinhadas foi realizada com o
programa TrimAL [48]. O arquivo multifasta de entrada foi convertido no formato
Phylip usando o programa Readseq [50] e a árvore filogenética foi reconstruída
usando o programa Phylip [51].
A Figura 3.1 mostra a sequência de atividades dos respectivos experimentos,
bem como os módulos reaproveitados durante a execução dos mesmos.
3.2 - Ambiente utilizado
O workflow PHYLO foi desenvolvido para ser um sistema flexível, de fácil
utilização e que faz uso eficiente dos recursos de um sistema gerenciador de
workflow científico na concepção e execução dos experimentos. O ambiente de
hardware e software necessariamente precisava ser robusto o suficiente para
28
processar grande quantidade de dados e ter uma boa capacidade de
armazenamento.
O workflow PHYLO foi executado em um servidor Xeon Biprocessado Intel,
com 4GB de memória RAM, HD de 250 GB, sistema operacional Linux (Ubuntu
8.04) [106], servidor WEB Apache 2.0 [107], sistema gerenciador de workflow
científico Vistrails 1.3 [78] e linguagem de programação Python 2.6 [108]. Quanto
aos critérios para seleção dos softwares levou-se em consideração fatores como o
uso de softwares livres, a facilidade de instalação e configuração dos mesmos. O
fator preponderante para a escolha do Vistrails 1.3 [78] como Sistema Gerenciador
de Workflows Científicos deste trabalho foi, principalmente, a facilidade de
construção de módulos e o acesso à comunidade de desenvolvimento do software.
Além disso, levou-se em conta a facilidade de desenvolvimento neste sistema
gerenciador, pois o mesmo faz uso da linguagem Python para a implementação dos
seus módulos. Tal linguagem de programação é altamente difundida no mundo
científico e com uma comunidade bastante ativa de desenvolvedores no Brasil.
3.3 - Especificação do workflow
O PHYLO é um workflow científico composto de 21 programas de
bioinformática desenvolvidos para serem executados no SGWfC Vistrails 1.3 [78].
Na Tabela 3.1 estão relacionados todos os programas que irão compor os módulos
do SGWC, bem como a sua versão e respectiva função.
Tabela 3.1 - Programas implementados no PHYLO com as respectivas funções,
versão utilizada e referência.
Programas
Função
Versão Referência
Aligh-m
Alinhamento múltiplo de sequências
2.03
[41]
ClustalW
Alinhamento múltiplo de sequências
1.83
[42]
Consense
Programa para gerar um consenso a partir de um
alinhamento múltiplo
3.5c
[64]
Garli
Filogenia implementando o método de máxima
verossimilhança
0.96
[55]
29
GBlocks
Programa para seleção de blocos conservados de
sequências alinhadas
0.91b
[47]
Inwt
É um sistema de exploração gráfica da cadeia de
Markov que utiliza o algoritmo de Monte Carlo
(MCMC) para busca de convergência em
inferência filogenética Bayesiana
–x--
[109]
Mafft
Alinhamento múltiplo de sequências
6.17
[43]
Modelgenerator
Geração do melhor modelo evolutivo
0.85
[49]
MrBayes
Filogenia usando inferência Bayesiana
3.1.2
[53]
Muscle
Alinhamento múltiplo de sequências
3.7
[44]
PAUP
Filogenia usando máxima verossimilhança,
Máxima parcimônia e agrupamento de vizinhos
dependem do parâmetro utilizado
4.0b10
[52]
Phylip
Filogenia usando máxima verossimilhança,
Máxima parcimônia e agrupamento de vizinhos
dependem do parâmetro utilizado
3.0
[51]
PhyML
Filogenia implementando o método de máxima
verossimilhança
2.4.4
[62]
ProbCons
Alinhamento múltiplo de sequências
1.12
[45]
Puzzle
A reconstrução da árvore de dados da sequência
por meio de análise de máxima verossimilhança
5.2
[63]
RaxML
Filogenia usando máxima verossimilhança
7.0.4
[56]
Readseq
Para conversão do formato FASTA para os
formatos Nexus e Phylip
2.1
[50]
Seqboot
Bootstrap geral
3.5c
[64]
T-Coffee
Alinhamento múltiplo de sequências
6.85
[46]
30
TrimAL
Remoção
alinhadas
de
sequências
espúrias
ou
mal
Weighbor
Filogenia implementando o método de máxima
verossimilhança
1.2
[48]
1.2.1
[54]
Tendo como base a pesquisa exploratória realizada no pipeline ARPA, foi
desenvolvido um diagrama como ilustrado a Figura 3.2, que detalha a
implementação do workflow PHYLO, com os seus possíveis fluxos de atividades e
programas de bioinformática.
31
Figura 3.2 – Diagrama do workflow científico PHYLO, com os seus respectivos programas.
32
A condução de um experimento com o PHYLO tem início com a conexão do
usuário com o servidor de aplicação (i). Em seguida, obtém-se o diretório [105] onde
está o arquivo com as sequências a serem processadas nos seguintes formatos:
Phylip (iii), Fasta (v) ou Nexus [2]. Sendo selecionado um arquivo no formato Fasta
(v), é realizada a limpeza do mesmo com o módulo removepipe (vi), cujo objetivo é
realizar a limpeza do arquivo de caracteres que possam vir a comprometer o
processamento das sequências. O alinhamento múltiplo da sequência é executado
com um dos seguintes programas: Alig-m [41], ClustalW [42], Mafft [43], Muscle [44],
ProbCons [45] ou T-coffee [46] (vii). A limpeza das sequências alinhadas é realizada
usando os programas Gblocks [47] ou TrimAL [48], de acordo com as necessidades
do usuário (vii). Após a limpeza das sequências, o usuário pode executar o
programa modelgenerator [49] para inferir o melhor modelo evolutivo (x) ou executar
o programa Readseq [50] (ix). Caso opte por executar o programa modelgenerator
[49], então poderá gerar árvores filogenéticas utilizando-se dos seguintes programas
filogenéticos: o PhyML [62] (xxiv), o RaxML [56](xxv), o MrBayes [53] (xxvi), o Garli
[55] (xxvii), o Paup [52] (xi) e o Phylip [51] (xii). O programa Readseq [50] (ix) é
utilizado para converter o arquivo do formato Fasta para os formatos Phylip e Nexus.
A partir destes formatos, pode-se iniciar o processo de geração de árvores com os
programas filogenéticos. Utilizando-se o arquivo no formato Phylip pode ser
executado o programa InAwt [109] (xxii), seguido da geração de árvores consenso
com o programa Consense [64](xxiii), ou obter um bootstrap com o programa
Seqboot [64] (xix), seguido da execução do programa Puzzle [61] (xx), Weighbor [69]
(xxi) e ao final, o programa Consense [64] (xxiii). É possível, ainda, executar os
programas que implementam o algoritmo de máxima verossimilhança, o Phyml [62]
(xxiv) e o RaxML [56] (xxv). O uso do arquivo no formato Nexus permite ao usuário
executar os programas MrBayes [53](xxvi), Paup [52] (xi), o Phylip [51] (xii) e o Garli
[55] (xxvii). Em qualquer dos casos, ao final do processamento do experimento, o
usuário deverá visualizar as árvores filogenéticas geradas no módulo visualizador de
árvores que por sua vez utiliza o programa archaeopteryx, que é um applet
desenvolvido em Java (xxviii).
Para a implementação no Vistrails 1.3, o pacote PHYLO foi dividido em sete
módulos
(Figura
PHYLO_3_Trimming,
3.3):
PHYLO_1_Connection,
PHYLO_4_Basic,
PHYLO_7_View.
33
PHYLO_5_Amino,
PHYLO_2_Alignment,
PHYLO_6_Dna
e
Figura 3.3 – Detalhes da implementação dos módulos do workflow científico PHYLO.
34
O módulo PHYLO_1_Connection é composto por três submódulos: o
SCPCOMMAND, responsável por fazer a cópia do arquivo a ser processado pelo
servidor para o mesmo; o SSHCOMMAND, que monta a linha de comando para
executar os programas no servidor e o SSHCONNECTION, utilizado para criar uma
conexão com o servidor. O código deste submódulo encontra-se no Apêndice A.
O módulo PHYLO_2_Alignment é composto por seis submódulos e
compreende as alternativas para realização de alinhamentos múltiplos das
sequências, possibilitando ao usuário utilizar o programa de alinhamento que melhor
se aplica ao seu experimento, de acordo com o método que melhor atenda as suas
necessidades. Os programas disponíveis são: Alig-m [41], ClustalW [42], Mafft [43],
Muscle [44], ProbCons [45] e T-coffee [46]. O código deste submódulo encontra-se
no Apêndice B.
O
módulo
PHYLO_3_Trimming
é
composto
por
dois
submódulos
responsáveis pela limpeza de sequências, onde estão disponíveis os programas
Gblocks [47] e o TrimAL [48]. O primeiro é utilizado para seleção de blocos
conservados e para análise de grandes sequências de DNA ou proteínas. O
segundo realiza a remoção automática de sequências espúrias ou regiões mal
alinhadas. O código deste submódulo encontra-se no Apêndice C.
O módulo PHYLO_4_Basic possui oito submódulos, três para leitura de
arquivo, sendo um para o formato Fasta (File_fasta), outro para o formato Nexus e o
terceiro para o formato Phylip (File_Phylip). O submódulo Modelgenerator_aa foi
projetado com o objetivo de eleger o melhor modelo evolutivo na confecção das
árvores filogenéticas. Os submódulos Readseq_aa e Readseq_dna são utilizados
para converter o arquivo do formato Fasta para o formato Nexus e/ou no formato
Phylip. Os submódulos Remove_pipe_aa e Remove_pipe_bb foram desenvolvidos
para limpeza dos arquivos de entrada, retirando caracteres indesejáveis que possam
vir a comprometer o processamento do arquivo. O código deste submódulo
encontra-se no Apêndice D.
O módulo PHYLO_5_Amino disponibiliza os submódulos responsáveis pela
geração das árvores filogenéticas usando vários métodos e algoritmos filogenéticos.
Este módulo é usado para processamento de sequências de aminoácidos. Possui
onze submódulos, sendo disponibilizados os seguintes programas filogenéticos:
Garli, MrBayes, Paup_ML, Paup_MP, Paup_NJ, PhyML, Phylip_ML, Phylip_MP,
Phylip_NJ, RaxML e Weighbor. O código deste submódulo encontra-se no Apêndice
E.
35
O módulo PHYLO_6_DNA disponibiliza os submódulos responsáveis pela
geração das árvores filogenéticas usando vários métodos e algoritmos filogenéticos.
Este módulo é usado para processamento de sequências de DNA. Possui onze
submódulos, sendo disponibilizados os seguintes programas filogenéticos: Garli,
MrBayes,
Paup_ML,
Paup_MP,
Paup_NJ,
PhyML,
Phylip_ML,
Phylip_MP,
Phylip_NJ, RaxML e Weighbor. O código deste submódulo encontra-se no Apêndice
F.
O módulo PHYLO_7_View possui um único submódulo, responsável pela
visualização das árvores geradas pelos vários métodos disponíveis de reconstrução
de árvores filogenéticas. O código deste submódulo encontra-se no Apêndice G.
3.4 - Execução e validação do workflow desenvolvido
Para validação do workflow PHYLO, foram executados três experimentos,
conforme Figura 3.1, e sua execução deu-se no ambiente descrito na seção 3.2. Os
experimentos foram executados seguindo a seguinte especificação:
Tabela 3.2 - Experimento 1.
Experimento 1
Fases
Parâmetros
1 – Formato do arquivo: Multifasta
2 – Nome do Arquivo: exp1.fasta
3 – Alinhamento de sequência: Mafft
mafft --quiet --localpair --maxiterate
1000 " exp2.nxs > exp2.mafft"
4 – Limpeza das sequências: TrimAl
trimal -in " + path_alignment + " -out " +
path_alignment + ".trimal -gt 0.9 -cons
60
5 – Conversão de arquivo: Readseq
readseq
-all
-f=12
"
exp1.aln
>
exp1._phy “
6 – Programa filogenético: PhyML
Evolutionary model : “JTT”, Bootstrap =
100, Substitution Rate Categories = 4,
Gamma distribution = 1, proportion of
invariable sites = 0
7 – Visualização da árvore
Observação:
1 – O comando para o alinhamento realizado com o programa Mafft foi
36
executado com os seguintes parâmetros: --quiet - parâmetro usado para suprimir o
relatório de progresso de execução; --localpair - parâmetro usado para alinhamento
de sequência de aminoácidos de tamanho de no máximo 200pb, usado para
alinhamento de sequências localmente; --maxiterate - determina o número de ciclos
executados de refinamento iterativo.
2 - O comando para o alinhamento realizado com o programa TrimAl foi
executado com os seguintes parâmetros : -in - este parâmetro determina o formato
do arquivo de entrada de dados; -out determina o formato do arquivo de saída de
dados; - gt determina a fração de gaps permitidos na sequência; e -cons determina
o percentual mínimo de conservação de posições do alinhamento original.
3 - O programa Readseq utilizou os seguintes parâmetros: -all - parâmetro usado
para selecionar todas as sequências a serem alinhadas; e -f = 12 - parâmetro usado
para determinar o formato de saída do arquivo, neste caso 12, número previsto para
saída de arquivos no formato Phylip.
4 – O programa PhyML, programa para inferência filogenética, foi executado com
os seguintes parâmetros: Evolutionary model (protmodel) = “JTT” - usado para o
modelo de evolução de proteínas, sendo “JTT” o valor que indica que se deve usar
o modelo de Jones-Taylor Thornton; Bootstrap = 100 é o método de inferência
estatística, onde os conjuntos de dados são gerados através do uso de amostragem
com reposição; Substitution Rate Categories (Ncat) = 4 determina o número de
categorias da taxa de substituição, sendo que neste caso foi usado o valor padrão;
Gamma distribution (gama) = 1 é usado para determinar o parâmetro gamma de
distribuição e reflete a taxa de variação de substituições (quanto maior a taxa de
gama, menor será a variação e substituição); proportion of invariable sites
(Sitestats) = 0 - usado para determinar a probabilidade de bases individuais em
aminoácidos.
37
Tabela 3.3 - Experimento 2.
Experimento 2
Fases
Parâmetros
1 – Formato do arquivo: Nexus
2 – Nome do Arquivo: exp2.nxs
3 – Alinhamento de sequência: Mafft
mafft --quiet --localpair --maxiterate
1000 " exp2.nxs > exp2.mafft"
4 – Limpeza das sequências: TrimAl
trimal -in " + path_alignment + " -out " +
path_alignment + ".trimal -gt 0.9 -cons
60
5 – Conversão de arquivo: Readseq
readseq
-all
-f=17
"
exp1.aln
>
exp1._phy “
6 – Programa filogenético: Phylip
Bootstrap = 100
7 – Visualização da árvore
Observação:
1 – O comando para o alinhamento realizado com o programa Mafft foi
executado com os seguintes parâmetros: --quiet, parâmetro usado para suprimir o
relatório de progresso de execução; --localpair, usado para alinhamento de
sequência de aminoácidos de tamanho no máximo 200pb e também para
alinhamento de sequências localmente; e --maxiterate, que determina o número de
ciclos executados de refinamento iterativo.
2 - O comando para o alinhamento realizado com o programa TrimAl foi
executado com os seguintes parâmetros : -in, que determina o formato do arquivo
de entrada de dados; -out, que determina o formato do arquivo de saída de dados; gt, que define a fração de gaps permitidos na sequência; e -cons, determina o
percentual mínimo de conservação de posições do alinhamento original.
3 - O programa Readseq utilizou os seguintes parâmetros: -all, parâmetro usado
para selecionar todas as sequências a serem alinhadas; e -f = 17, usado para
determinar o formato de saída do arquivo, neste caso 17, número previsto para
saída de arquivos no formato Nexus.
4 - O programa Phylip, programa para inferência filogenética usando o método
de agrupamento de vizinhos, foi executado com o seguinte parâmetro: Bootstrap =
100 que é um método de inferência estatística, onde os conjuntos de dados são
gerados através do uso de amostragem com reposição.
38
Tabela 3.4 - Experimento 3.
Experimento 3
Fases
Parâmetros
1 – Formato do arquivo: Fasta
2 – Nome do Arquivo: exp3.fasta
3 – Alinhamento de sequência: Mafft
mafft --quiet --localpair --maxiterate
1000 " exp2.nxs > exp2.mafft"
4 – Limpeza das sequências: TrimAl
trimal -in " + path_alignment + " -out " +
path_alignment + ".trimal -gt 0.9 -cons
60
5 – Conversão de arquivo: Readseq
readseq -all -f=17 exp3.muscle + " >
exp3._nxs"
6 – Programa filogenético: Phylip
Bootstrap = 500
7 – Visualização da árvore
Observação:
1 – O comando para o alinhamento realizado com o programa Mafft foi
executado com os seguintes parâmetros: --quiet, utilizado para suprimir o relatório
de progresso de execução; --localpair, para alinhamento de sequência de
aminoácidos de tamanho no máximo 200pb, também usado para alinhamento de
sequências localmente; e --maxiterate, que determina o número de ciclos
executados de refinamento iterativo.
2 – O comando para o alinhamento realizado com o programa TrimAl foi
executado com os seguintes parâmetros: -in, que determina o formato do arquivo de
entrada de dados; -out, que define o formato do arquivo de saída de dados; - gt, que
determina a fração de gaps permitidos na sequência; e -cons, que determina o
percentual mínimo de conservação de posições do alinhamento original.
3 - O programa Readseq utilizou os seguintes parâmetros: -all, parâmetro usado
para selecionar todas as sequências a serem alinhadas; e -f = 17 parâmetro usado
para determinar o formato de saída do arquivo, neste caso 17, número previsto para
saída de arquivos no formato Nexus.
4 - O programa Phylip, programa para inferência filogenética usando o método
de agrupamento de vizinhos, foi executado com o seguinte parâmetro: Bootstrap =
500, que é um método de inferência estatística, onde os conjuntos de dados são
gerados através do uso de amostragem com reposição.
39
4 - RESULTADOS
Os resultados foram obtidos através da execução dos três experimentos
propostos. Para cada experimento de reconstrução filogenética foram utilizados os
seguintes métodos: máxima verossimilhança - MV com o programa PhyML,
agrupamento de vizinhos - AV com o programa Phylip e máxima parcimônia - MP
com o programa Phylip.
Tabela 4.1 - Número de sequência de isoformas de aquaporinas de diferentes tipos e
organismos.
Organismo
AQP1
Arabidopsis thaliana
AQP3
AQP9
1
1
5
Leishmania braziliensis
Leishmania donovani
2
Leishmania infantum
1
1
Leishmania major
2
Saccharomyces cerevisiae
4
Trypanosoma brucei
1
1
1
1
3
1
Trypanosoma cruzi
1
4.1 - Análise Filogenética das proteínas de aquaporinas 1.
As topologias de árvores filogenéticas não enraizadas, resultantes do
experimento são formadas por sequências de aquaporinas 1, constantes no Anexo
A, sendo as mesmas pertencentes aos seguintes organismos: A. thaliana, S.
cerevisiae, L. donovani e L. major.
40
Figura 4.1 – Topologia
proteicas de aquaporina
PhyML, modelo evolutivo
taxa de substituição com
sítios invariáveis = 0.
da árvore filogenética não enraizada das sequências
1. Método de máxima verossimilhança, com programa
JTT, análise de bootstrap com valor 100, categorias de
valor 4 , distribuição Gama com valor 1 e proporção de
Figura 4.2 - Topologia da árvore filogenética não enraizada das sequências
proteicas de aquaporina 1. Método de agrupamento de vizinhos, com programa
Phylip com bootstrap com valor igual a 100.
41
Figura 4.3 - Topologia da árvore filogenética não enraizada das sequências
proteicas de aquaporina 1. Método máxima parcimônia, com programa Phylip com
bootstrap com valor igual a 500.
A análise filogenética das proteínas de aquaporinas 1, cujas árvores são
exibidas nas figuras 4.1, 4.2 e 4.3, mostrou como resultado, independente do
método empregado para construção filogenética, grupos monofiléticos para o gênero
de Leishmania e Saccharomyces, que são suportados por altos graus de bootstrap
dos três métodos. A topologia obtida com os métodos de MV e AV foram mais
semelhantes entre si e ambos mostram grupos monofiléticos para os gêneros de
Saccharomyces cerevisiae e Leishmania. Por outro lado, o método de MP mostrou
uma parafilia (P) do gênero das Arabidopsis thaliana. Para os gêneros existentes na
árvore, existem ancestrais hipotéticos para os grupos Saccharomyces cerevisiae (i),
Leishmania (ii) e Arabidopsis thaliana (iii).
4.2 - Análise Filogenética das proteínas de aquaporinas 3.
As topologias de árvores filogenéticas não enraizadas, resultantes do
experimento, são formadas por sequências proteicas de aquaporinas 3, presentes
no Anexo B, sendo as mesmas pertencentes aos seguintes organismos: L.
braziliensis, T. brucei, S. cerevisiae e L. infantum.
42
Figura 4.4 – Topologia
proteicas de aquaporina
PhyML, modelo evolutivo
taxa de substituição com
sítios invariáveis = 0.
da árvore filogenética não enraizada das sequências
3. Método de máxima verossimilhança, com programa
JTT, análise de bootstrap com valor 100, categorias de
valor 4 , distribuição Gama com valor 1 e proporção de
Figura 4.5 - Topologia da árvore filogenética não enraizada das sequências
proteicas de aquaporina 3. Método de agrupamento de vizinhos, com programa
Phylip com bootstrap com valor igual a 100.
Figura 4.6 - Topologia da árvore filogenética não enraizada das sequências
proteicas de aquaporina 3. Método máxima parcimônia, com programa Phylip com
bootstrap com valor igual a 500.
A análise filogenética das aquaporinas 3, exibidas nas figuras 4.4, 4.5 e 4.6
mostraram que embora os métodos mostrem árvores diferentes, todos eles
suportam a hipótese de grupos monofiléticos (M) para os gêneros de Leishmania,
Trypanossoma e Saccharomyces, com a presença de ancestrais hipotéticos em
comum em todas as árvores, sendo sustentadas com valores de 98% de bootstrap.
43
4.3 - Análise Filogenética das proteínas de aquaporinas 9.
As topologias de árvores filogenéticas não enraizadas, resultantes do
experimento, são formadas por sequências proteicas de aquaporinas 9, presentes
no Anexo C, sendo as mesmas pertencentes aos seguintes organismos: S.
cerevisiae, L. major, L. infantum, L. donovani, L. braziliensis, T. cruzi e T. brucei.
Figura 4.7 - Topologia da árvore filogenética não enraizada das sequências
proteicas de aquaporina 9. Método de máxima verossimilhança, com programa
PhyML, modelo evolutivo JTT, análise de bootstrap com valor 100, categorias de
taxa de substituição com valor 4 , distribuição Gama com valor 1 e proporção de
sítios invariáveis = 0.
Figura 4.8 - Topologia da árvore filogenética não enraizada das sequências
proteicas de aquaporina 9. Método de agrupamento de vizinhos, com programa
Phylip com bootstrap com valor igual a 100.
Figura 4.9 - Topologia da árvore filogenética não enraizada das sequências
proteicas de aquaporina 9. Método máxima parcimônia, com programa Phylip com
bootstrap com valor igual a 500.
44
A análise filogenética das aquaporinas 9, exibidas nas figuras 4.7, 4.8 e 4.9
mostraram que não há valor de bootstrap para diferenciar as espécies de grupos de
Trypanossoma das Saccharomyces para os métodos de MV e AV. A topologia das
árvores para os métodos de AV e MP são similares, entretanto, no método de MP é
observado um nó de bootstrap igual a 100, que suporta a monofilia do gênero das
Saccaharomyces. Além disso, pode-se observar um alto valor de bootstrap em todas
as árvores geradas, o que evidencia a confiabilidade das árvores geradas.
4.4 - Análise Filogenética das proteínas de aquaporinas 1, 3 e 9.
As topologias de árvores filogenéticas não enraizadas, resultantes do
experimento 3, são formadas por sequências proteicas de aquaporinas 1, 3 e 9,
constantes no Anexo D, sendo as mesmas pertencentes aos seguintes organismos:
A. thaliana, S. cerevisiae, L. major, L. braziliensis, L. infantum, L. donovani, T. brucei
e T. cruzi.
45
Figura 4.10 - Topologia da árvore filogenética não enraizada das sequências
proteicas de aquaporina 1, 3 e 9. Método de Máxima Verossimilhança, com
programa PhyML, modelo evolutivo JTT, análise de bootstrap com valor 100,
categorias de taxa de substituição com valor 4 , distribuição Gama com valor 1 e
proporção de sítios invariáveis = 0.
46
Figura 4.11 - Topologia da árvore filogenética não enraizada das sequências
proteicas de aquaporina 1, 3 e 9. Método de agrupamento de vizinhos, com
programa Phylip com bootstrap com valor igual a 100.
47
Figura 4.12 - Topologia da árvore filogenética não enraizada das sequências
proteicas de aquaporina 1, 3 e 9. Método Máxima Parcimônia, com programa Phylip
com bootstrap com valor igual a 500.
A análise filogenética das sequências proteicas das aquaporinas 1, 3 e 9,
exibida nas figuras 4.10, 4.11 e 4.12, mostraram que, independente do método de
reconstrução utilizado, a topologia dos grupos foi semelhante. A primeira vista não
houve uma separação clara entre tipo de aquaporina relacionado ao tipo de
organismo. Entretanto, alguns grupos podem ser destacados como os mostrados na
figura 4.12 nas cores marrom, azul, vermelho e verde. As aquaporinas do tipo 3
(Aqp3) são encontradas somente no grupo A. Nos tritryps (Trypanosoma spp. e
Leishmania sp.), as Aqp1 e Aqp3 parecem possuir a mesma origem comum. Por
outro lado, as Aqp9 de T. cruzi e T. brucei parecem possuir origens bastante
distintas, sendo a sequência de T. cruzi próximas de Leishmania e as de Aqp9 de T.
brucei próximas às sequências de Aqp3.
48
4.5 - Comparação
do
PHYLO
com
outros
sistemas
de
reconstrução
filogenética
A Tabela 4.2 resume as principais características do PHYLO, em relação ao
ARPA, ferramenta Phylemon e SCaFos, apresentando uma comparação entre eles.
As características de monitoramento de execução do experimento, flexibilidade de
uso de módulos, intervenção durante a execução do processo de experimento,
suporte a proveniência de dados, suporte a ambientes distribuídos, execução parcial
de tarefas e reuso de módulos está associado diretamente ao ambiente gráfico
utilizado no ambiente de um Sistema Gerenciador de Workflow Científico no qual os
módulos do Phylo são executados, no caso, o VisTrails.
49
Tabela 4.2 – Características do PHYLO, sistema para reconstrução filogenética
ARPA , a ferramenta Phylemon e o ScaFos.
Características
PHYLO
ARPA
Uso de tecnologia WEB
--
x
x
x
Sistema Cliente Servidor
x
x
x
x
x
x
x
x
--
--
x
x
Interface amigável
x
x
x
x
Disponível em linha de comando
--
x
--
x
Processamento local
x
--
--
--
Parametrização dos programas
x
x
x
x
x
x
x
x
x
--
x
--
x
--
--
--
x
--
--
--
Suporte a proveniência de dados (*)
x
--
--
--
Suporte a ambiente distribuído (*)
x
x
--
--
Execução parcial de tarefas (*)
x
--
--
--
Visualização de árvores (*)
x
x
x
--
Reuso de módulos (*)
x
--
--
--
Armazenamento de dados baseado em
arquivos
Armazenamento de dados em banco de
dados
Implementação de vários métodos de
filogenia
Monitoramento de Execução do
experimento (*)
Flexibilidade de uso dos módulos (*)
Intervenção durante a execução do
processo do experimento (*)
(*) Características herdadas do SGWfC – Vistrails ver 1.3.
50
Phylemon SCaFos
4.6 - Comparação entre os módulos do SGWC PHYLO e um Pipeline baseado
em script.
Tabela 4.3 – Comparação entre os módulos do PHYLO e um pipeline baseado em
script
Comparação
Módulos PHYLO
Pipeline baseado em script
Uma única caixa com
Módulo
entrada e saída com
suas
funcionalidades
encapsuladas no módulo
Arrastar
Manuseio
e
soltar
o
módulo e fazer ligação
visual entre os mesmos
para compor o workflow.
Composto de várias linhas de
código para comportar a lógica a
ser executada. Em média, 150
linhas por função desenvolvida
ou módulo.
Conhecimento
de
lógica
e
programação de script, visando o
entendimento dos programas e
parâmetros de manuseio dos
módulos.
Utiliza-se de tela não-gráfica e de
Interface
Totalmente
gráfica
e editores
amigável.
Operação
Conhecimentos
Vistrails
necessários
linguagem
de
texto
pouco
amigáveis e intuitivos.
básica
1.3.
de
Python.
51
do
e
a
script
Conhecimento da linguagem de
programação na qual o módulo
foi desenvolvido.
5 - DISCUSSÃO
5.1 - Reconstrução filogenética semiautomática e automática
A realização de experimentos para reconstrução filogenética pode ser feita de
forma
semiautomática
ou
automática.
Os
experimentos
conduzidos
semiautomaticamente são concebidos através de um pipeline, implementado através
de scripts, que compreende todos os procedimentos a serem realizados até a
obtenção dos resultados. Este tipo de experimento leva o usuário a executar cada
passo do seu pipeline utilizando diversos programas em diferentes sites via internet
ou executando diversos programas em um servidor ou estação de trabalho
localmente.
Neste tipo de análise, o usuário utiliza-se de programas executáveis que
normalmente exigem a elaboração de extensos comandos. Isto requer do mesmo
alguma habilidade com o sistema operacional e conhecimento do funcionamento de
cada programa com os seus respectivos parâmetros e formatos de entrada e saída
de dados. O uso desses programas e a diversidade de formato de dados gerados
[110], normalmente exigem adaptações para que os dados de saída de um
programa possam ser utilizados como entrada em outro programa, dificultando a
condução do experimento.
A condução automática de um experimento facilita sua execução pelo
usuário, pois não se faz necessário o conhecimento da forma de execução de cada
programa e nem dos detalhes sobre como cada um deles deve ser executado por
linhas de comando, devendo o mesmo apenas avaliar e analisar os resultados do
seu experimento.
O uso de programas para realização de experimentos através de
processamento automático para reconstrução filogenética vem sendo amplamente
difundido pela comunidade científica. Estes compõem ferramentas ou sistemas de
reconstrução filogenética, entre os quais podemos citar o PhyloPattern [61], o
SCaFoS [111], o Phylocom [112], o Phylemon [7] e o ARPA[8]. Portanto, o principal
objetivo da implementação da biblioteca de módulos PHYLO foi facilitar a condução
de experimentos e a construção de árvores filogenéticas de forma automatizada
utilizando-se de um sistema gerenciador de workflow científico, onde estão
disponibilizados 21 programas de bioinformática amplamente utilizados pela
comunidade científica (Tabela 3.1). Além disso, permite ao usuário a configuração
52
de cada um dos programas, tornando o PHYLO flexível para atender as
necessidades de cada experimento.
5.2 - Flexibilidade na execução de tarefas no PHYLO, Phylemon e o ARPA
Na execução de experimentos científicos, a flexibilidade é uma das
características mais desejáveis nos sistemas. O ARPA [8], na sua versão WEB,
permite ao usuário realizar todas as configurações no início do experimento, através
da escolha dos métodos e parametrização dos programas para alinhamento,
limpeza e confecção de árvores filogenéticas. Porém, durante a execução do
experimento, o usuário não tem nenhum tipo de interação com o sistema a não ser a
obtenção dos resultados e visualização das árvores geradas.
O PHYLO, assim como o ARPA [8], permite ao usuário a parametrização dos
seus módulos no início do experimento, mas pelo suporte dado ao PHYLO em
função da sua implementação em um Sistema de Gerência de Workflows, o mesmo
tem a flexibilidade de permitir a intervenção do usuário durante o experimento. Além
disso, modificações dinâmicas são possíveis de serem efetuadas durante o mesmo,
também disponibilizando os dados e uma interface para visualização das árvores
geradas.
O Phylemon [7] tem o grande diferencial de sugerir ao usuário o próximo
passo a ser executado durante a condução de um experimento, facilitando, assim, a
integração dos vários passos da análise em execução.
5.3 - Registro das etapas de execução e proveniência de dados
Uma das principais vantagens do uso de SGWfC está no recurso de
armazenamento de informações complexas sobre o experimento, também
chamados
de
metadados
de
proveniência
[114].
Estas
informações
são
fundamentais na condução de tarefas. O registro das etapas e parâmetros de cada
momento da execução do experimento é uma particularidade existente nos módulos
do PHYLO, pelo fato do mesmo usar um ambiente gerenciado por um SGWfC.
Esta funcionalidade permite ao usuário verificar os processos e dados que
levaram a um determinado resultado ou qual o parâmetro que melhor se aplica a um
determinado passo do experimento.
53
5.4 - Uso de tecnologia WEB
O ARPA e o Phylemon, diferentemente do workflow PHYLO, tem sua
estrutura disponibilizada numa página WEB, enquanto o workflow PHYLO foi
projetado para ser executado em uma infraestrutura cliente – servidor. A vantagem
do uso dessa estrutura está na disponibilidade de grande capacidade de
processamento e armazenamento de dados no servidor, pois muitos dos programas
de bioinformática disponíveis no workflow científico PHYLO necessitam de uma
grande capacidade computacional para execução de seus algoritmos, o que
normalmente não está disponível em máquinas clientes (estação de trabalho). Um
exemplo prático deste caso é a geração de árvores filogenéticas utilizando o
programa de inferência bayesiana MrBayes [53].
A arquitetura tradicional de workflows científicos prevê a execução de um
conjunto de programas científicos em uma determinada sequência e seguindo um
fluxo lógico de execução. Os módulos do PHYLO podem ser estendidos para um
conjunto de serviços WEB, podendo ser uma estrutura distribuída em arquiteturas
heterogêneas ou serem implementados em uma determinada linguagem de
programação. A disponibilização do PHYLO na WEB geraria um ganho na interação
de aplicações participantes de um workflow científico, conferindo ao mesmo uma
melhor capacidade de reutilização para diferentes experimentos que necessitem
utilizá-lo.
Um exemplo de workflow científico que faz uso de serviços WEB é o
MHOLline [113], que inclui quatro serviços WEB, disponibilizando a execução dos
programas (i) Blast [115], (ii) Bats [116], (iii) Modeller [117] e (iv) Procheck [118].
5.5 - Reuso de módulos do PHYLO
O workflow PHYLO tem por característica o encapsulamento de suas
funcionalidades internas, que compõem a estrutura de seus módulos. Esta
característica permite ao usuário utilizar os módulos existentes para compor novos
workflows científicos. O usuário que necessite de um determinado módulo não
precisa ter domínio do código interno do mesmo, devendo apenas conhecer sua
função e os parâmetros de entrada e saída. Logo em seguida, deve selecionar o
módulo desejado e fazer a ligação visual entre os módulos do workflow.
54
O Phylemon [7] e o ARPA [8], por serem baseado em uma interface WEB não
flexível, não permitem ao usuário o reuso ou reaproveitamento de seus módulos
internos. No entanto, o Phylemon [7] possui um módulo chamado SuperPhylemon
que permite ao usuário o armazenamento e reaproveitamento dos pipelines
definidos por este durante um experimento. Os pipelines são então armazenados
para serem posteriormente utilizados em novos experimentos.
O ARPA [8] e o SCaFoS [111], mesmo sendo implementados em uma
interface WEB, também foram implementados para serem usados em linha de
comando, permitindo, assim, que os mesmos possam ser implementados em um
workflow, onde cada linha de comando possa ser executada através de uma
chamada do módulo do workflow [78].
O Phylemon [7], o ARPA [8] e o SCaFoS [111] podem ter os seus módulos
reaproveitados na composição de outros sistemas, desde que o usuário tenha
acesso aos códigos internos dos sistemas, que estão mascarados pela interface
WEB, e tenham entendimento do funcionamento da lógica de programação dos
módulos, bem como a linguagem de programação de implementação dos mesmos.
5.6 - Alteração e manutenção dos módulos
Os módulos do workflow PHYLO, assim como os módulos internos do ARPA
[8], Phylemon [7] e do SCaFoS [111], não são de fácil alteração e manutenção, pois
são implementados em uma linguagem de programação baseada em scripts. Para o
usuário executar qualquer alteração ou manutenção nos módulos internos do
PHYLO, deverá possuir conhecimento de lógica de programação, além de ter
condições de realizar desenvolvimento de módulos no Vistrails 1.3 [78], conforme
Apêndice H. O grau de dificuldade na realização da alteração e manutenção dos
módulos internos do aplicativo é inversamente proporcional ao conhecimento que o
usuário tenha do código do módulo. Para realização destas tarefas, faz-se
necessário o suporte de um profissional de informática.
5.7 - Composição de novos workflows científicos a partir do PHYLO.
Uma das características mais importantes do módulo PHYLO é a sua
capacidade de reuso, pois a partir da combinação dos módulos, tem-se uma grande
flexibilidade e variabilidade na composição de novos workflows.
55
O Phylemon [7] e o ARPA [8] não permitem a composição de novos
programas em sua interface WEB.
O SCaFoS [111] e o ARPA [8], ambos em sua versão em linha de comando,
podem compor um novo workflow, desde que as funcionalidades necessárias sejam
adicionadas via script na composição do módulo.
O PHYLO, para composição de novos workflows científicos em comparação
com os sistemas anteriormente citados, se mostrou melhor que os outros, pois o
usuário não precisa ter domínio de nenhuma linguagem de programação. Este deve
apenas dominar as características do módulo, os parâmetros e os formatos dos
dados de entrada e saída do mesmo, devendo em seguida arrastá-lo e soltá-lo na
área de edição do workflow. Após a interligação dos módulos, os mesmos estarão
prontos para ser executados. Este processo pode ser feito por qualquer usuário que
possua conhecimentos básicos de composição de workflows em um sistema
gerenciador de workflow científico, neste caso o Vistrails 1.3 [78].
5.8 - Dificuldades na implementação do workflow científico PHYLO
Os principais problemas encontrados no planejamento, programação e
implementação do workflow científico foram:
1. Seleção dos softwares devido as suas características, tendo inicialmente
como premissa os mais confiáveis e os mais utilizados. Os fatores
complicadores neste caso são as interfaces destes softwares, que em muitos
casos, são pouco amigáveis em virtude de serem baseadas em linguagens de
scripts, gerando um fator altamente laborioso para usuários que não estão
habituados com estruturas de linguagem de programação.
2. O entendimento do funcionamento dos diversos softwares escolhidos e os
respectivos algoritmos filogenéticos implementados por eles, envolvidos na
execução do pipeline, bem como o levantamento e os testes dos melhores
parâmetros a serem utilizados, tendo em vista a obtenção da melhor árvore.
3. A adequação da interação dos diversos formatos de saída de dados, em
função dos vários softwares utilizados no workflow; tornando necessária a
criação de passos intermediários para formatação e adaptação das saídas em
determinados formatos que pudessem ser utilizados como entrada em outros
softwares e vice-versa.
56
4. A complexa obtenção de resultados, através do elevado custo computacional
e o tempo necessário para a execução dos programas. Isto pode ser
melhorado com o uso de grids e clusters computacionais, com a redução do
tempo de resposta na execução deste workflow científico, o que também
ocorreria com pipelines baseados em scripts.
5. Em alguns casos, a limitação computacional e a falta de capacidade de
processamento impossibilitaram a pesquisa com alguns softwares como, por
exemplo, o MrBayes, por não dispor de infraestrutura para execução e testes
do mesmo.
6. A dificuldade na criação dos módulos do workflow para ser executado usando
o Sistema Gerenciador de Workflow Científico, neste caso o Vistrails 1.3. Pelo
fato de o mesmo não ser uma ferramenta de uso trivial, o que é um fator
complicador para pessoas com pouca formação computacional.
5.9 - Análises proteicas das aquaporinas.
Para a geração das árvores filogenéticas foi feita a variação somente dos
métodos de construção das árvores, sendo mantidos os mesmos programas de
alinhamento e limpeza de sequências alinhadas para todos os experimentos. Em
função das sequências processadas, podemos inferir que independente dos
métodos utilizados, de um modo geral, as topologias das árvores foram
semelhantes, embora pequenas variações tenham sido observadas em determinado
método. Essas variações podem ter ocorrido devido aos diferentes algoritmos que
implementam cada um dos métodos, mas de um modo geral os grupos foram
semelhantes, mostrando que mesmo após a extração de blocos conservados das
sequências alinhadas, não houve perda significativa da informação filogenética
essencial à reconstrução de parte da história evolutiva das sequências.
Na árvore gerada (Figura 4.12) formou-se um grupo de tritryps, que parecem
possuir o mesmo ancestral comum para as aquaporinas 1 e 3. Também podemos
inferir que existe uma grande proximidade entre as aquaporinas do tipo 1 e 3.
Corroboram estas informações os autores [20] e [92].
As sequências de aquaporina de tipo 9 para Trypanossoma cruzi
(AQP9TRYCR) apresentou grande proximidade das aquaporinas de tipo 9 de
Leishmania (AQP9LEIBR2), (ver Figura 4.12).
57
Na aquaporina de tipo 9 de Trypanosoma brucei (AQP9TRYBRU), que ficou
mais próxima das aquaporinas de tipo 3 de Leishmania braziliensis (AQP3TRYBR2),
indica que possivelmente ocorreu uma mudança a nível de sequência que pode ter
ocasionado a troca na aquaporina de tipo 3 para o tipo 9 ou pode ter sido feita uma
anotação errada da aquaporina em questão.
6 - CONCLUSÕES
O workflow de reconstrução filogenética PHYLO mostrou ser uma boa
ferramenta para concepção e execução de experimentos científicos, assim como o
Phylemon, o ARPA [8] e o SCaFoS [111] em suas versões WEB. Porém, o PHYLO,
mostrou-se melhor que as implementações do ARPA [8] e SCaFoS [111] em suas
versões de linha de comando.
O workflow PHYLO constitui uma ferramenta de fácil utilização e execução,
assim como o Phylemon [7], o ARPA [8] e o SCaFoS [111]. O PHYLO pode ser
utilizado em qualquer área biológica que implemente experimentos baseados em
construção de árvores filogenéticas. Ele possibilita a combinação de vários
programas de alinhamento múltiplo de sequências, limpeza de sequências alinhadas
e programas que implementem métodos filogenéticos, num total de 21 programas
de bioinformática. Entre as vantagens do PHYLO está a diversidade de formato de
arquivos de sequências para entrada de dados que pode ser no formato Fasta,
nexus ou Phylip, enquanto que no Phylemon [7] só são aceitos arquivos no formato
Fasta e Phylip.
O PHYLO tem como vantagem sobre o Phylemon o quantitativo de programas
de bioinformática disponibilizado em sua estrutura. Enquanto o Phylemon
disponibiliza somente dois programas para alinhamento múltiplo (ClustalW V1.83
[42] e o Muscle V3.52 [44]), o PHYLO disponibiliza seis (o Align-m [41], ClustalW
[42], Mafft [43], Muscle [44], T-coffee [46] e o Probcons [45]). Além disso, o PHYLO
tem implementado em sua estrutura dois programas para extração de blocos
conservados (o G-blocks [47] e Trimal [48]), programas estes não disponibilizados
no Phylemon [7]. Apesar da vantagem de disponibilização de programas para
reconstrução filogenética, num total de 21 programas ao todo, o PHYLO tem a
desvantagem de não disponibilizar em sua estrutura programas para realização de
testes evolucionários, além daquele que já encontra-se em sua composição o
Modelgenerator [49]. Este programa é usado para determinar o melhor modelo
evolutivo para a confecção de uma árvore filogenética.
58
6.1 - Contribuições
O workflow científico PHYLO para reconstrução filogenética desenvolvido em
um Sistema de Gerenciamento de Workflows Científicos é a principal contribuição
deste trabalho, disponível para download em http://kineto2.biowebdb.org/PHYLO.
Outra contribuição deste trabalho é a flexibilidade da composição de novos
workflows científicos a partir dos módulos existentes no PHYLO. Esta flexibilidade
permite ao usuário criar novos workflows, simplesmente arrastando e soltando os
módulos na tela de edição do SGWfC . Após a interligação dos módulos na interface
gráfica, o mesmo está pronto para o uso, sendo dispensável ao usuário o
conhecimento da lógica de programação e linguagem de script que compõem a
função interna dos módulos. Os módulos do workflow PHYLO possuem interface
intuitiva voltada para usuário final, o que facilita o seu uso e a execução de
experimentos. Os detalhes de implementação dos módulos não são expostos ao
usuário, permitindo a ele concentrar-se apenas no nível conceitual do workflow. No
entanto, para realização das tarefas de especificação do workflow, o usuário deve
dispor do conhecimento de operação básica do SGWfC.
Outra contribuição que o módulo PHYLO oferece é a possibilidade de
intervenção do usuário no experimento durante a sua execução. Esta possibilidade
permite a reconfiguração dos parâmetros em tempo de execução, além do registro
das entradas e proveniência de dados.
O workflow PHYLO foi desenvolvido e baseado em tecnologia open source
podendo o mesmo ser utilizado por toda a comunidade científica.
6.2 - Melhorias e trabalhos futuros
O workflow PHYLO desenvolvido possui em sua construção a possibilidade de
visualização de árvores, sendo uma por vez. O ideal seria a implementação da
visualização gráfica de suas árvores no software de visualização de imagens do
Vistrails chamado spreadsheet, possibilitando, assim, a visualização de várias
árvores em uma única tela, tendo como diferencial a variação dos parâmetros de
cada execução do mesmo experimento.
Como sugestão de uma nova implementação, os resultados provenientes da
execução do workflow PHYLO podem ser armazenados em uma base de dados
filogenética, sendo proposta a interligação com o GUSdb[119].
59
O workflow científico PHYLO aborda somente métodos e programas para
reconstrução filogenética, além do uso do Modelgenerator para geração de melhor
modelo evolutivo de árvores, devendo ser implementados em versões futuras,
métodos e programas evolutivos.
Como proposta final para implementação de trabalhos futuros, sugerimos a
possibilidade de execução dos módulos do workflow científico PHYLO via WEB.
60
7 - REFERÊNCIAS BIBLIOGRÁFICAS
1.
Hernandez, T. and S. Kambhampati, Integration of Biological Sources: Current
Systems and Challenges Ahead. ACM SIGMOD Record, 2004. 33(3): p. 5160.
2.
Cruz, S.M.S., Silva, E., Oliveira, F.T., Vilela, C., Cuadrat, R.R.C., Dávila,
A.M.R., Campos, M.L.M., Mattoso, M.L.Q. and OrthoSearch: A Scientific
Workflow Approach to Detect DistantHomologies on Protozoans., in In: ACM
SAC, . 2008: Fortaleza, Br. p. 1281-1285.
3.
Cruz, S.M.S., Campos L. M., Campos M. L. M., Pires P. F., Monitoring
Bioinformatics Web services Requests and Responses through a Log Based
Architectur. In XXXII SEMISH-SBC, 2005: p. 1787--1801.
4.
Taylor, I.J., Deelman, E., Gannon, D. B., Shields, M., (Eds), Workflows for eScience: Scientific Workflows for Grids. 1 ed. Springer ed. 2007. p. 530.
5.
YU, J. and R. BUYYA, A Taxonomy of Scientific Workflow Systems for Grid
Computing. SIGMOD Record, 2005. 34(3).
6.
Cruz, S.M.S., Chirigati, F.S., Dahis, R., Campos, M.L.M. e Mattoso, M. , Using
explicit controlprocesses in distributed workflows to gather provenance, in In:
IPAW´08. 2008: Utah, USA, LNCS, to appear.
7.
Tarraga, J.M., I. Arbiza, L. Huerta-Cepas, J. Gabaldon, T. Dopazo, J. Dopazo,
H., Phylemon: a suite of web tools for molecular evolution, phylogenetics and
phylogenomics. Nucleic Acids Res, 2007. 35(Web Server issue): p. W38-42.
8.
Ocaña, K.A.C.S., Silva, F.B., Jardim, R., Dávila, A. M. R., ARPA: Automatic
Reconstruction of Phylogenomic Analysis in X-meeting 2009. 2009: Angra dos
Reis - Brasil.
9.
Watson, J.D. and F.H. Crick, The structure of DNA. Cold Spring Harb Symp
Quant Biol, 1953. 18: p. 123-131.
10.
Sanger, F. and A.R. Coulson, J Mol. Blol, 1975. 94: p. 441-448.
11.
Baldi, P. and S. Brunak, Bioinformatics: the Machine Learning approach, ed.
s. edition. 2001: MIT Press.
12.
Setúbal, J.C. and J. Meidanis, Introduction to Computational Molecular
Biology. PWS Publishing Company, 1997.
13.
Charles, D., On the origin of species 1859.
61
14.
Scheineider, H., Métodos de análise filogenética. Um guia prático. 2003,
Ribeirão Preto, São Paulo: Holos editora. p. 200.
15.
JUDD, W.S., C.S. CAMPBELL, and P.F. STEVENS, Plant Systematics: A
Phylogenetic Approach. Sinauer Associates . , Inc. Publishers. Sunderland,
MA,USA, 1999.
16.
Doyle, J.J. and B.S. GAUT, Evolution of genes and taxa: a primer. Plant
Molecular Biology, 2000. 42: p. 1-23.
17.
Ciccarelli, F.D., Doerks, T., von Mering, C., Creevey, C. J.,Snel, B., Bork, P.,
Toward automatic reconstruction of a highly resolved tree of life. Science,
2006. 311(5765): p. 1283-1287.
18.
Losos, J.B., Phylogenetic perpectives on community ecology. Ecology 1996.
77: p. 1344-1354.
19.
Maherali, H. and J.N. Klironomos, Influence of phylogeny on fungal community
assembly and ecosystem functioning. Science, 2007. 316(5832): p. 17461748.
20.
Beitz, E., Aquaporins from pathogenic protozoan parasites: structure, function
and potential for chemotherapy. Biol Cell, 2005. 97(6): p. 373-383.
21.
Marquis, N., Gourbal, B., Rosen, B. P., Mukhopadhyay, R., Ouellette, M.,
Modulation in aquaglyceroporin AQP1 gene transcript levels in drug-resistant
Leishmania. Mol Microbiol, 2005. 57(6): p. 1690-1699.
22.
HERENDEEN, P.S., BRUNEAU, A., LEWIS, G.P.,, Phylogenetic relationships
in caesalpinioid legumes: a preliminary analysis based on morphological and
molecular data. In: B.B. Klitgaard and A. Bruneau (eds.). Advances in Legume
Systematics. part 10, Higher Level Systematics Royal Botanic Gardens, Kew.,
2003: p. 37-62.
23.
Nahum, L.A. and S.L. Pereira Phylogenomics, Protein Family Evolution and
the Tree of Life: An Integrated Approach between Molecular Evolution and
Computational Intelligence, in In: Smolinski TG, Milanova MG, Hassanien A-E
(eds), Studies in Computational Intelligence (SCI). 2008, Springer Berlin /
Heidelberg. p. 259–279.
24.
Decuypere, S., Rijal, S., Yardley, V., De Doncker, S., Laurent, T., Khanal, B.
,Chappuis, F., Dujardin, J. C., Gene expression analysis of the mechanism of
natural Sb(V) resistance in Leishmania donovani isolates from Nepal.
Antimicrob Agents Chemother, 2005. 49(11): p. 4616-4621.
62
25.
Lee, W., Park, J.,Choi, J.,Jung, K., Park, B., Kim, D., Lee, J., Ahn,K., Song,
W., Kang, S., Lee, Y.H., Lee, S., IMGD: an integrated platform supporting
comparative genomics and phylogenetics of insect mitochondrial genomes., in
BMC Genomics. 2009. p. 148.
26.
Benson, D.A., Karsch-Mizrachi, I., Lipman, D. J., Ostell, J., Wheeler, D. L.,
GenBank. Nucleic Acids Res, 2008. 36(Database issue): p. D25-30.
27.
Borenstein, E., Kupiec, M., Feldman, M. W., Ruppin, E., Large-scale
reconstruction and phylogenetic analysis of metabolic environments. Proc Natl
Acad Sci U S A, 2008. 105(38): p. 14482-14487.
28.
Tatusova, T., B. Smith-White, and J. Ostell, A collection of plant-specific
genomic data and resources at NCBI. Methods Mol Biol, 2007. 406: p. 61-87.
29.
Camon, E., Barrell, D., Lee, V., Dimmer, E., Apweiler, R., The Gene Ontology
Annotation (GOA) Database--an integrated resource of GO annotations to the
UniProt Knowledgebase. In Silico Biol, 2004. 4(1): p. 5-6.
30.
PAGE, R.D.M. and E.C. HOLMES, Molecular Evolution: A Phylogenetic
Approach. Blackwell Science, United Kingdom., 2001: p. 346 .
31.
MIYAKI, C.Y., C.A.M. RUSSO, and S.L. PEREIRA, Reconstrução filogenética.
Introdução e o método da parcimônia. In: MATIOLI, S. R. (ed.) in Biologia
Molecular e Evolução. 2001, Holos Editora: Ribeirão Preto p. 97-107.
32.
Sokal, J.E. and H.P. Treffers, The synthesis of protein-azobenzyl-nucleic acid
compounds. Yale J Biol Med, 1953. 25(5): p. 320-325.
33.
SOKAL, R.R. and C.D. MICHENER, Statistical method for evaluating
systematic relationships. University of Kansas Science Bulletin, 1958. vol. 38,:
p. p.1409-1438.
34.
GRAUR, D. and W. LI, Fundamentals of Molecular Evolution. Sinauer
Associates, Inc. Second Edition. Sunderland, U. S. A, 199: p. 481.
35.
NEi, M. and S. KUMAR, Molecular Evolution and Phylogenetics. Oxford
University Press, Inc. New York, United States of America, 2001: p. 333 .
36.
Saitou, N. and M. Nei, The neighbor-joining method: a new method for
reconstructing phylogenetic trees. Mol Biol Evol, 1987. 4(4): p. 406-425.
37.
Cavalli-Sforza, L.L. and A.W. Edwards, Phylogenetic analysis. Models and
estimation procedures. Am J Hum Genet, 1967. 19(3 Pt 1): p. 233-257.
38.
MEYER, D., Árvores evolutivas humanas - Uma discussão sobre inferência
filogenética. In: DUARTE, F. A. M. (editor). Série monografias nº 3. Sociedade
Brasileira de Genética, Ribeirão Preto – SP, 1996: p.1-162.
63
39.
Felsenstein, J., Evolutionary trees from DNA sequences: a maximum
likelihood approach. J Mol Evol, 1981. 17(6): p. 368-376.
40.
MOUNT, D.W., Bioinformatics: Sequence and Genome Analysis. 2nd edition.
Cold Spring Harbor Laboratory Press, Cold Spring Harbor, New Cork, USA.,
2004: p. 692 .
41.
Van Walle, I., I. Lasters, and L. Wyns, Align-m—A new algorithm for multiple
alignment of highly divergent sequences. Bioinformatics. 2004. 20: p. 14281435.
42.
Thompson, J.D., D.G. Higgins, and T.J. Gibson, CLUSTAL W: improving the
sensitivity of progressive multiple sequence alignment through sequence
weighting, position-specific gap penalties and weight matrix choice. Nucleic
Acids Res, 1994. 22(22): p. 4673-4680.
43.
Katoh, K., Misawa, K., Kuma, K.,Miyata, T., MAFFT: a novel method for rapid
multiple sequence alignment based on fast Fourier transform. Nucleic Acids
Res, 2002. 30(14): p. 3059-3066.
44.
Edgar, R.C., MUSCLE: multiple sequence alignment with high accuracy and
high throughput. Nucleic Acids Res., 2004. 32: p. 1792–1797.
45.
Do, C.B., Mahabhashyam, M.S., Brudno, M., Batzoglou, S. , ProbCons:
Probabilistic consistency-based multiple sequence alignment. Genome Res.,
2005. 15: p. 330–340.
46.
Notredame, C., D.G. Higgins, and J. Heringa, T-Coffee: A novel method for
fast and accurate multiple sequence alignment. J Mol Biol, 2000. 302(1): p.
205-217.
47.
Castresana, J., Selection of conserved blocks from multiple alignments for
their use in phylogenetic analysis. Mol Biol Evol, 2000. 17(4): p. 540-552.
48.
Capella-Gutierrez, S., J.M. Silla-Martinez, and T. Gabaldon, trimAl: a tool for
automated
alignment
trimming
in
large-scale
phylogenetic
analyses.
Bioinformatics, 2009. 25(15): p. 1972-1973.
49.
Keane, T.M., Creevey, C. J., Pentony, M. M.,Naughton, T. J.,McLnerney, J.
O., Assessment of methods for amino acid matrix selection and their use on
empirical data shows that ad hoc assumptions for choice of matrix are not
justified. BMC Evol Biol, 2006. 6: p. 29.
50.
Readseq:Read and reformat biosequences. 2002; Available from: Disponível:
http://iubio.bio.indiana.edu/soft/molbio/readseq/java/
64
51.
Felsenstein, J., PHYLIP (Phylogeny Inference Package) Version 3.6.
Distributed by the Author. Department of Genome Sciences, University of
Washington, Seattle. 2005.
52.
Swofford, D.L., PAUP*: phylogenetic analysis using parsimony (*and other
methods), version 4, Sinauer Associates, Sunderland, Massachusetts, USA,.
2002.
53.
Huelsenbeck, J.P. and P. Ronquist MRBAYES: Bayesian inference of
phylogeny, Bioinformatics. 2001. 17: p. 754-755. .
54.
Bruno, W.J., N.D. Socci, and A.L. Halpern, Weighted Neighbor Joining: A Fast
Approximation to Maximum-Likelihood.Phylogeny Reconstruction. Mol Biol
Evol 17, 2006. 1: p. 189-197.
55.
Zwickl,
D.J.
GARLI
-
by
2008;
Available
from:
http://www.bio.utexas.edu/faculty/antisense/garli/Garli.html.
56.
Stamatakis, A., T. Ludwig, and H. Meier, RAxML-III: a fast program for
maximum
likelihood-based
inference
of
large
phylogenetic
trees.
Bioinformatics, 2005. 21(4): p. 456-463.
57.
Ferro, M., Batista, C.C., Fedel, F., Kamimura, E., Nascimento-Junior, O.S.,
Scafi, R., Rodovalho, C.M., Bacci, M., Guilherme, I.R., , Desenvolvimento de
pipeline para análise de sequências ESTs de Formigas Attini- 55. 2009.
58.
Raman, K., Construction and analysis of protein-protein interaction networks.
BMC Biol.20010, 2010. 2(2).
59.
Schwarzenbacher, R., A. Godzik, and L. Jaroszewski, The JCSG MR pipeline:
optimized alignments, multiple models and parallel searches. Acta Crystallogr
D Biol Crystallogr, 2008. 64(Pt 1): p. 133-140.
60.
Puigbo, P., S. Garcia-Vallve, and J.O. McInerney, TOPD/FMTS: a new
software to compare phylogenetic trees. Bioinformatics, 2007. 23(12): p. 15561558.
61.
Gouret, P., Thompson ,J. D., Pontarotti,P., PhyloPattern: regular expressions
to identify complex patterns in phylogenetic trees. BMC Bioinformatics, 2009.
10:298.
62.
Guindon, S. and O. Gascuel, A simple, fast, and accurate algorithm to
estimate large phylogenies by maximum likelihood. Syst Biol, 2003. 52(5): p.
696-704.
65
63.
Schmidt, H.A., Strimmer, K.,Vingron, M., von Haeseler, A., TREE-PUZZLE:
maximum likelihood phylogenetic analysis using quartets and parallel
computing. Bioinformatics, 2002. 18(3): p. 502-504.
64.
Felsenstein, J. Seqboot -- Bootstrap, Jackknife, or Permutation Resampling of
Molecular Sequence, Restriction Site, Gene Frequency or Character Data.
1991-2008; Available from: http://cmgm.stanford.edu/phylip/seqboot.html.
65.
Posada, D. and K.A. Crandall, MODELTEST: testing the model of DNA
substitution. Bioinformatics, 1998. 14(9): p. 817-818.
66.
Robinson-Rechavi, M. and D. Huchon, RRTree: relative-rate tests between
groups of sequences on a phylogenetic tree. Bioinformatics, 2000. 16(3): p.
296-297.
67.
Adachi, J. and M. Hasegawa, Model of amino acid substitution in proteins
encoded by mitochondrial DNA. J Mol Evol, 1996. 42(4): p. 459-468.
68.
Massingham, T. and N. Goldman, Detecting amino acid sites under positive
selection and purifying selection. Genetics, 2005. 169(3): p. 1753-1762.
69.
Yang, Z., PAML: a program package for phylogenetic analysis by maximum
likelihood. Comput Appl Biosci, 1997. 13(5): p. 555-556.
70.
ARAÚJO, R.M. and M.R.d.S. BORGES, Sistemas de Workflow, in In: XX
Jornada de Atualização de Informática – Congresso da SBC,. 2001:
Fortaleza, Brasil.
71.
HOLLINGSWORTH, D. Workflow Management Coalition. The Workflow
Reference Model: WfMc. In.
[Consultado em 27/02/2010]; Available from:
http://www.wfmc.org/standards/docs/tc003v11.pdf. .
72.
Seffino L.A., M.C.B., Rocha J.V., and Yi B. Woodss, a spatial decision support
system based on workflows. . Decision Support Systems, 1999. 27(1-2):: p.
105-123.
73.
TARGINO, R.S., M.C. CAVALCANTI, and M. MATTOSO, An Environment to
Define and Execute In-Silico Workflows Using Web Services., in International
Workshop on Data Integration in the Life Sciences - DILS 2005. p. 288-291.
74.
Lemos, M., Workflow para Bioinformática. Tese de D.Sc., pontifícia
Univercidade Católica - PUC- Rio, Rio de Janeiro,RJ, Brasil., 2004.
75.
SUMPTER, R., “Whitepaper on Data Management”. Lawrence Livermore
National Laboratory. The IEEE Metadata Workshop, 1994.
76.
AALST, W.e.H., K., Workflow Management: Models, Methods, and Systems.1
ed., January . MIT Press, 2002.
66
77.
SINGH, M.P., VOUK, M. A., , Scientific Workflows: Scientific Computing Meets
Transactional
Workflows.
In
http://www.csc.ncsu.edu/faculty/mpsingh/papers/databases/workflows/
[Consultado em 20/02/2010].
78.
Guia do usuário do Vistrails 2009 [Consultado em 04/12/2009]; Available from:
http://www.vistrails.org/index.php/userguide.
79.
Callahan S.P., F.J., Santos E., Scheidegger C.E., Silva C.T., and Vo H.T., et
al., Vistrails: visualization meets data management. . In SIGMOD '06:
Proceedings of the 2006 ACM SIGMOD international conference on
Management of data, pages 745{747, New York, NY, USA, 2006. ACM..
80.
Kepler - Your Science. Enabled. 2010; Available from: https://keplerproject.org/.
81.
Taverna Project Website, Taverna. . 2008 Dezembro 2010]; Available from:
http://www.taverna.org.uk/.
82.
Fox G.C., G.D., Special issue: Workflow in grid systems Concurrency and
Computation: Practice and Experience 18(10): 2006, p.1009-1019.
83.
ALTINTAS, I., BERKLEY, C., JAEGER, E., JONES, M., LUDASCHER, B., e
MOCK, and S., Kepler: An extensible system for design and execution of
scientic work-ows. SSDBM '04: Proceedings of the 16th International
Conference on Scientic and Statistical Database Management, 2004.
84.
Java. 2010; Available from: http://www.java.com.
85.
ZHAO, J., GOBLE, C., STEVENS, R.,, “Semantic web applications to escience in silico experiments”, in The 13th international World Wide Web
conference onAlternate track papers & posters. 2004: New York, NY, USA,. p.
pp. 284-285,.
86.
Cheidde,
L.,
Shor,N.,,
Review
:
Water
Trasnport.
Rev
Ass
Med
Brasil;45(1):1999, p.71-78.
87.
Agre, P., Preston G. M., Smith , B.L., Aquaporin CHIP:The archetypal
molecular watter channel. Anmj Physiol 1997. 265: p. F463-476.
88.
Preston, G.M., Agree, P., Isolation of the cDna for erythocyte integral
membrane protein of 28 Kd: Member of an ancient channel family. proc Natl
Acad Sci U S A, 1991, p.110-114.
89.
Knepper, M.A., Soren, N., Agre, P.,, 2003 Nobel Prize Winner in Chemistry. J
AM SOC Nephrol.15, 2004 p.1093-1095.
67
90.
Borgnia, M., Nielsen, S., Engel, A., Agre, P., Cellular and molecular biology of
the aquaporin water channels. Annu Rev Biochem, 1999. 68: p. 425-58.
91.
Agre, P., Kozono, D., Aquaporin water channels: molecular mechanisms for
human diseases. . FEBS Lett 2003, 555(1):2003, p.72-78.
92.
Fadiel, A., Isokpehi, R. D., Stambouli, N., Hamza, A., Benammar-Elgaaied, A.,
Scalise, T. J., Protozoan parasite aquaporins. Expert Rev Proteomics, 2009.
6(2): p. 199-211.
93.
Gardner, S.N., Cell cycle phase-specific chemotherapy: computational
methods for guiding treatment. Cell Cycle, 2002. 1(6): p. 369-374.
94.
Ersfeld, K., Genomes and genome projects of protozoan parasites. Curr
Issues Mol Biol, 2003. 5(3): p. 61-74.
95.
Beitz, E., Aquaporin water and solute channels from malaria parasites and
other pathogenic protozoa. ChemMedChem, 2006. 1(6): p. 587-592.
96.
Kirk, K., Channels and transporters as drug targets in the Plasmodiuminfected erythrocyte. Acta Trop, 2004. 89(3): p. 285-298.
97.
Sturm , A., Heussler, V. , Live and let die: manipulation of host hepatocytes by
exoerythrocytic Plasmodium parasites. Med. Microbiol. Immunol. 196(3),2007
p.127-133 .
98.
Portincasa, P., Palasciano, G., Svelto, M, .Calamita, G. , Aquaporins in the
hepatobiliary tract. Which, where and what they do in health and disease. Eur.
J. Clin. Invest. 38(1),2008, p.1-10.
99.
Kalinina, O.V., Mironov, A. A., Gelfand, M. S., Rahmaninova, A. B., Automated
selection of positions determining functional specificity of proteins by
comparative analysis of orthologous groups in protein families. Protein Sci,
2004. 13(2): p. 443-456.
100.
Krane, C.M. and D.L. Goldstein, Comparative functional analysis of
aquaporins/glyceroporins in mammals and anurans. Mamm Genome, 2007.
18(6-7): p. 452-462.
101.
Hamdi, M., Sanchez, M. A., Beene, L. C., Liu, Q., Landfear, S. M., Rosen, B.
P., Liu, Z., Arsenic transport by zebrafish aquaglyceroporins. BMC Mol Biol,
2009. 10: p. 104.
102.
Leprohon, P., Legare, D., Girard, I., Papadopoulou, B., Ouellette, M.,
Modulation of Leishmania ABC protein gene expression through life stages
and among drug-resistant parasites. Eukaryot Cell, 2006. 5(10): p. 1713-1725.
68
103.
Zardoya, R., Ding, X., Kitagawa, Y., Chrispeels, M. J., Origin of plant glycerol
transporters by horizontal gene transfer and functional recruitment. Proc Natl
Acad Sci U S A, 2002. 99(23): p. 14893-14896.
104.
SwissProt.
.
2010;
Available
from:
http://www.expasy.ch/people/swissprot.html.
105.
Nozaki, K., D. Ishii, and K. Ishibashi, Intracellular aquaporins: clues for
intracellular water transport? Pflugers Arch, 2008. 456(4): p. 701-707.
106.
Ubuntu. 2009; Available from: http://www.ubuntu.com/.
107.
The
Apache
Software
Foundation.
2009;
Available
from:
01/07/2009];
Available
from:
http://www.apache.org/.
108.
Python
TM.
2009
[Acessado
http://www.python.org/.
109.
Wilgenbusch J.C., W.D.L., Swofford D.L. AWTY: A system for graphical
exploration of MCMC convergence in Bayesian phylogenetic inference. 2004;
Available from: http://ceb.csit.fsu.edu/awty.
110.
Rice, P., Longden, I., Bleasby, A., EMBOSS: the Europan Molecular Biology
Open Software Suite. Trends Genet., 2000. 16: p. 276-277.
111.
Roure, B., Rodriguez-Ezpeleta, N., Philippe, H,. SCaFoS: a tool for Selection,
Concatenation
and
Fusion
of
Sequences
for
phylogenomics.
BMC
Evolutionary Biology 2007, 7(Suppl 1):S2 doi:10.1186/1471-2148-7-S1-S2
<supplement>, 2007.
112.
Campbell O., D.D.A., and Steven W. K., Phylocom: software for the analysis
of phylogenetic community structure and trait evolution. BIOINFORMATICS,
2008. 24: p. 2098–2100.
113.
TARGINO, R.S., O Ambiente 10+C para definição e execução de workflows
in silico através de serviços Web. Tese de Mestrado. COPPE/UFRJ. Novembro,
2004.
114.
Freire, J., Koop, D., Santos, E., Silva, C. T.,, Provenance for Computational
Tasks: A Survey. Computing in Science and Engineering 2008. 10, n. 3: p. 11-21.
115.
ALTSCHULA, S., GISHA, W., MILLERB, W., MEYERSC, E., LIPMANA, D. ,
Basic local alignment search tool. . Journal of Molecular Biology, 215(3), 1990.
116.
RÖSSLE, S., CARVALHO, P., DARDENNE, L. e BISCH, P., , Development of
a Computational Environment for Protein Structure Prediction and Functional
Analysis. In Proccedings of 2nd Brazilian Workshop on Bioinformatics (WOB),
Riode Janeiro,. 2003.
69
117.
SALI, A., Seek Project. MODELLER: A Program for Protein Structure
Modeling Release 6. Rockefeller University.
118.
LASKOWSKI, R.A., MACARTHUR, M. W., MOSS, D. S. e THORNTON, J. M.,
PROCHECK: a Program to Check the Stereochemical Quality of Protein
Structures. Journal of Appl. Cryst., Vol. 26, 1993, p. 283-291.
119. DAVIDSON S., CRABTREE,J., BRUNK,B, SHUG,J., TANNEN,V, OVERTON,
C(2000) K2 and GUS:Experiments in integrated acess to genomics data sources.
IBM Systems J., 40, in press, 2000.
70
8 - APÊNDICES E ANEXOS
Apêndice A - Código do módulo Connection.
import core.modules.module_registry
import base64
import getpass
import os
import socket
import time
import sys
import traceback
import select
import paramiko
import webbrowser
from core.modules.vistrails_module import Module
#from Bio import SeqIO
import thread
from time import gmtime, strftime
#import psycopg2
import re
version="0.1"
name="PHYLO_1_Connection"
identifier="biowebdb.PHYLO.connection.vistrails"
###############################################################################################
#
# Global Functions
def receive_data(channel):
### Read when data is available
data = ''
while select.select([channel,], [], []):
x = channel.recv(1024)
if not x: break
data += x
return data
def exec_command(connection, command):
### Executes a SSH command
print command
chan = connection.open_session()
chan.exec_command(command)
data = receive_data(chan)
chan.close()
return data
###############################################################################################
class SSHCommand (Module):
"Executa um comando qualquer no servidor passado como entrada"
def compute(self):
conn = self.getInputFromPort("Connection")
cmd = self.getInputFromPort("Command")
std_out = ''
try:
std_out = exec_command(conn, cmd)
self.setResult("StdOut", std_out)
except Exception, e:
print '*** Caught exception in "SSHCommand" module: %s: %s' % (e.__class__, e)
conn.close()
###############################################################################################
class SSHConnection (Module):
"Retorna uma conexao SSH do tipo Transport da API paramiko"
def compute(self):
# setup logging
71
paramiko.util.log_to_file('demo_simple.log')
# get hostname
out = ''
username = self.getInputFromPort("username")
hostname = self.getInputFromPort("hostname")
password = self.getInputFromPort("password")
port = self.getInputFromPort("port")
# now, connect and use paramiko Transport to negotiate SSH2 across the connection
try:
t = paramiko.Transport((hostname, port))
t.connect( username=username, password=password )
self.setResult("connection", t)
except Exception, e:
print '*** Caught exception in "SSHConnection" module: %s: %s' % (e.__class__, e)
###############################################################################################
class SCPCommand (Module):
" copia arquivos do cliente par o diretorio no servidor"
def compute(self):
# Args:
# 1: hostname
# 2: username
# 3: local filename
# 4: remote filename
# 5: password
# get hostname
out = ''
hostname = self.getInputFromPort("hostname")
username = self.getInputFromPort("username")
local_filename = self.getInputFromPort("local_filename")
remote_filename = self.getInputFromPort("remote_filename") + "/in.PHYLO"
password = self.getInputFromPort("password")
print "Transfer file - SCP"
print "Host:"+hostname
print "User:"+username
print "Local:"+local_filename
print "Remote:"+remote_filename
# Socket connection to remote host
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# sock.connect((sys.argv[1], 22))
sock.connect((hostname, 22))
# Build a SSH transport
t = paramiko.Transport(sock)
t.start_client()
# t.auth_password(sys.argv[2], getpass.getpass('Password: '))
t.auth_password(username, password)
# Start a scp channel
scp_channel = t.open_session()
print "Session opened"
#f = file(sys.argv[3], 'rb')]
f = file(local_filename, 'rb')
scp_channel.exec_command('scp -v -t %s\n'
% '/'.join(remote_filename.split('/')[:-1]))
print "Exec command 1 - Done"
scp_channel.send('C%s %d %s\n'
%(oct(os.stat(local_filename).st_mode)[-4:],
os.stat(local_filename)[6],
remote_filename.split('/')[-1]))
print "Exec command 2 - Done"
scp_channel.sendall(f.read())
# Cleanup
f.close()
scp_channel.close()
t.close()
sock.close()
print "Close all"
self.setResult("remote_filename_out", remote_filename)
72
###############################################################################################
def initialize(*args, **keywords):
reg = core.modules.module_registry.registry
reg.add_module(SSHConnection)
reg.add_input_port(SSHConnection,"username",(core.modules.basic_modules.String,"User Name"))
reg.add_input_port(SSHConnection,"hostname",(core.modules.basic_modules.String,"Host Name"))
reg.add_input_port(SSHConnection,"password",(core.modules.basic_modules.String,"Password"))
reg.add_input_port(SSHConnection,"port",(core.modules.basic_modules.Integer,"Port Number"))
reg.add_output_port(SSHConnection,"connection",(core.modules.vistrails_module.Module,"SSH Connection"))
reg.add_module(SSHCommand)
reg.add_input_port(SSHCommand,"Connection",(core.modules.basic_modules.Module,"Connection"))
reg.add_input_port(SSHCommand,"Command",(core.modules.basic_modules.String,"Command to be executed"))
reg.add_output_port(SSHCommand,"StdOut",(core.modules.basic_modules.String,"Standard Output of the
SSHCommand command"))
reg.add_module(SCPCommand)
reg.add_input_port(SCPCommand,"username",(core.modules.basic_modules.String,"User Name"))
reg.add_input_port(SCPCommand,"password",(core.modules.basic_modules.String,"password"))
reg.add_input_port(SCPCommand,"hostname",(core.modules.basic_modules.String,"Host Name"))
reg.add_input_port(SCPCommand,"local_filename",(core.modules.basic_modules.String,"local_filename"))
reg.add_input_port(SCPCommand,"remote_filename",(core.modules.basic_modules.String,"remote_filename"))
reg.add_output_port(SCPCommand,"remote_filename_out",(core.modules.basic_modules.String,"remote_filename_out
"))
73
Apêndice B - Código do módulo Alignment.
import core.modules.module_registry
import base64
import getpass
import os
import socket
import time
import sys
import traceback
import select
import paramiko
import webbrowser
from core.modules.vistrails_module import Module
#from Bio import SeqIO
import thread
from time import gmtime, strftime
#import psycopg2
import re
version="0.1"
name="PHYLO_2_Alignment"
identifier="biowebdb.PHYLO.align.vistrails"
###############################################################################################
# Global Functions
def receive_data(channel):
### Read when data is available
data = ''
while select.select([channel,], [], []):
x = channel.recv(1024)
if not x: break
data += x
return data
def exec_command(connection, command):
### Executes a SSH command
print command
chan = connection.open_session()
chan.exec_command(command)
data = receive_data(chan)
chan.close()
return data
###############################################################################################
class Mafft (Module):
"Teste"
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
out = 'Fui'
"Tipo de alinhamento"
tipo = self.getInputFromPort("tipo")
fileIn = self.getInputFromPort("fileIn")
dirin = self.getInputFromPort("dirin")
import makeMafft_aa
makeMafft_aa.paramModuleExecution(dirin)
for m in os.listdir(dirin):
if m.endswith('.mafft'):
path_alignment = os.path.join(dirin, m)
os.chmod(path_alignment, 0755)
##Faz um monte de coisas e retorna
self.setResult("path_alignment", path_alignment)
self.setResult("dirin_out", dirin)
###############################################################################################
74
class Align_m (Module):
"Teste"
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
out = 'Fui'
"Tipo de alinhamento"
tipo = self.getInputFromPort("tipo")
fileIn = self.getInputFromPort("fileIn")
dirin = self.getInputFromPort("dirin")
import makeMafft_aa
makeMafft_aa.paramModuleExecution(dirin)
for m in os.listdir(dirin):
if m.endswith('.mafft'):
path_alignment = os.path.join(dirin, m)
os.chmod(path_alignment, 0755)
##Faz um monte de coisas e retorna
self.setResult("path_alignment", path_alignment)
self.setResult("dirin_out", dirin)
###############################################################################################
class Clustal_w (Module):
"Teste"
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
out = 'Fui'
"Tipo de alinhamento"
tipo = self.getInputFromPort("tipo")
fileIn = self.getInputFromPort("fileIn")
dirin = self.getInputFromPort("dirin")
import makeMafft_aa
makeMafft_aa.paramModuleExecution(dirin)
for m in os.listdir(dirin):
if m.endswith('.mafft'):
path_alignment = os.path.join(dirin, m)
os.chmod(path_alignment, 0755)
##Faz um monte de coisas e retorna
self.setResult("path_alignment", path_alignment)
self.setResult("dirin_out", dirin)
###############################################################################################
class Muscle (Module):
"Teste"
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
out = 'Fui'
"Tipo de alinhamento"
tipo = self.getInputFromPort("tipo")
fileIn = self.getInputFromPort("fileIn")
dirin = self.getInputFromPort("dirin")
import makeMafft_aa
makeMafft_aa.paramModuleExecution(dirin)
for m in os.listdir(dirin):
if m.endswith('.mafft'):
path_alignment = os.path.join(dirin, m)
os.chmod(path_alignment, 0755)
##Faz um monte de coisas e retorna
self.setResult("path_alignment", path_alignment)
self.setResult("dirin_out", dirin)
75
###############################################################################################
class Probcons (Module):
"Teste"
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
out = 'Fui'
"Tipo de alinhamento"
tipo = self.getInputFromPort("tipo")
fileIn = self.getInputFromPort("fileIn")
dirin = self.getInputFromPort("dirin")
import makeMafft_aa
makeMafft_aa.paramModuleExecution(dirin)
for m in os.listdir(dirin):
if m.endswith('.mafft'):
path_alignment = os.path.join(dirin, m)
os.chmod(path_alignment, 0755)
##Faz um monte de coisas e retorna
self.setResult("path_alignment", path_alignment)
self.setResult("dirin_out", dirin)
###############################################################################################
class Tcoffee (Module):
"Teste"
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
out = 'Fui'
"Tipo de alinhamento"
tipo = self.getInputFromPort("tipo")
fileIn = self.getInputFromPort("fileIn")
dirin = self.getInputFromPort("dirin")
import makeMafft_aa
makeMafft_aa.paramModuleExecution(dirin)
for m in os.listdir(dirin):
if m.endswith('.mafft'):
path_alignment = os.path.join(dirin, m)
os.chmod(path_alignment, 0755)
##Faz um monte de coisas e retorna
self.setResult("path_alignment", path_alignment)
self.setResult("dirin_out", dirin)
###############################################################################################
def initialize(*args, **keywords):
reg = core.modules.module_registry.registry
reg.add_module(Mafft)
reg.add_input_port(Mafft,"tipo",(core.modules.basic_modules.String,"tipo de alinhamento"))
reg.add_input_port(Mafft,"fileIn",(core.modules.basic_modules.File,"Arquivo de Entrada"))
reg.add_input_port(Mafft,"dirin",(core.modules.basic_modules.String,"Diretorio de entrada"))
reg.add_output_port(Mafft,"path_alignment",(core.modules.basic_modules.String,"Caminho do alinhamento"))
reg.add_output_port(Mafft,"dirin_out",(core.modules.basic_modules.String,"Saida do alinhamento"))
reg.add_module(Align_m)
reg.add_input_port(Align_m,"tipo",(core.modules.basic_modules.String,"tipo de alinhamento"))
reg.add_input_port(Align_m,"fileIn",(core.modules.basic_modules.File,"Arquivo de Entrada"))
reg.add_input_port(Align_m,"dirin",(core.modules.basic_modules.String,"Diretorio de entrada"))
reg.add_output_port(Align_m,"path_alignment",(core.modules.basic_modules.String,"Caminho do alinhamento"))
reg.add_output_port(Align_m,"dirin_out",(core.modules.basic_modules.String,"Saida do alinhamento"))
reg.add_module(Clustal_w)
reg.add_input_port(Clustal_w,"tipo",(core.modules.basic_modules.String,"tipo de alinhamento"))
reg.add_input_port(Clustal_w,"fileIn",(core.modules.basic_modules.File,"Arquivo de Entrada"))
reg.add_input_port(Clustal_w,"dirin",(core.modules.basic_modules.String,"Diretorio de entrada"))
reg.add_output_port(Clustal_w,"path_alignment",(core.modules.basic_modules.String,"Caminho do alinhamento"))
reg.add_output_port(Clustal_w,"dirin_out",(core.modules.basic_modules.String,"Saida do alinhamento"))
76
reg.add_module(Muscle)
reg.add_input_port(Muscle,"tipo",(core.modules.basic_modules.String,"tipo de alinhamento"))
reg.add_input_port(Muscle,"fileIn",(core.modules.basic_modules.File,"Arquivo de Entrada"))
reg.add_input_port(Muscle,"dirin",(core.modules.basic_modules.String,"Diretorio de entrada"))
reg.add_output_port(Muscle,"path_alignment",(core.modules.basic_modules.String,"Caminho do alinhamento"))
reg.add_output_port(Muscle,"dirin_out",(core.modules.basic_modules.String,"Saida do alinhamento"))
reg.add_module(Probcons)
reg.add_input_port(Probcons,"tipo",(core.modules.basic_modules.String,"tipo de alinhamento"))
reg.add_input_port(Probcons,"fileIn",(core.modules.basic_modules.File,"Arquivo de Entrada"))
reg.add_input_port(Probcons,"dirin",(core.modules.basic_modules.String,"Diretorio de entrada"))
reg.add_output_port(Probcons,"path_alignment",(core.modules.basic_modules.String,"Caminho do alinhamento"))
reg.add_output_port(Probcons,"dirin_out",(core.modules.basic_modules.String,"Saida do alinhamento"))
reg.add_module(Tcoffee)
reg.add_input_port(Tcoffee,"tipo",(core.modules.basic_modules.String,"tipo de alinhamento"))
reg.add_input_port(Tcoffee,"fileIn",(core.modules.basic_modules.File,"Arquivo de Entrada"))
reg.add_input_port(Tcoffee,"dirin",(core.modules.basic_modules.String,"Diretorio de entrada"))
reg.add_output_port(Tcoffee,"path_alignment",(core.modules.basic_modules.String,"Caminho do alinhamento"))
reg.add_output_port(Tcoffee,"dirin_out",(core.modules.basic_modules.String,"Saida do alinhamento"))
77
Apêndice C - Código do módulo Trimming.
import core.modules.module_registry
import base64
import getpass
import os
import socket
import time
import sys
import traceback
import select
import paramiko
import webbrowser
from core.modules.vistrails_module import Module
#from Bio import SeqIO
import thread
from time import gmtime, strftime
#import psycopg2
import re
version="0.1"
name="PHYLO_3_Trimming"
identifier="biowebdb.PHYLO.Trimming.vistrails"
###############################################################################################
# Global Functions
def receive_data(channel):
### Read when data is available
data = ''
while select.select([channel,], [], []):
x = channel.recv(1024)
if not x: break
data += x
return data
def exec_command(connection, command):
### Executes a SSH command
print command
chan = connection.open_session()
chan.exec_command(command)
data = receive_data(chan)
chan.close()
return data
###############################################################################################
class Gblocks (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
dirin = self.getInputFromPort("dirin")
path_alignment = self.getInputFromPort("path_alignment")
##Faz um monte de coisas e retorna
self.setResult("path_alignment_out", path_alignment)
self.setResult("dirin_out", dirin)
###############################################################################################
class TrimAl (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
dirin = self.getInputFromPort("dirin")
path_alignment = self.getInputFromPort("path_alignment")
##Faz um monte de coisas e retorna
self.setResult("path_alignment_out", path_alignment)
self.setResult("dirin_out", dirin)
78
###############################################################################################
def initialize(*args, **keywords):
reg = core.modules.module_registry.registry
reg.add_module(Gblocks)
reg.add_input_port(Gblocks,"dirin",(core.modules.basic_modules.String,"dirin"))
reg.add_input_port(Gblocks,"path_alignment",(core.modules.basic_modules.String,"path_alignment"))
reg.add_output_port(Gblocks,"path_alignment_out",(core.modules.basic_modules.String,"Caminho do alinhamento"))
reg.add_output_port(Gblocks,"dirin_out",(core.modules.basic_modules.String,"Saida do alinhamento"))
reg.add_module(TrimAl)
reg.add_input_port(TrimAl,"dirin",(core.modules.basic_modules.String,"dirin"))
reg.add_input_port(TrimAl,"path_alignment",(core.modules.basic_modules.String,"path_alignment"))
reg.add_output_port(TrimAl,"path_alignment_out",(core.modules.basic_modules.String,"Caminho do alinhamento"))
reg.add_output_port(TrimAl,"dirin_out",(core.modules.basic_modules.String,"Saida do alinhamento"))
Apêndice D - Código do módulo Basic.
import core.modules.module_registry
import base64
import getpass
import os
import socket
import time
import sys
import traceback
import select
import paramiko
import webbrowser
from core.modules.vistrails_module import Module
#from Bio import SeqIO
import thread
from time import gmtime, strftime
#import psycopg2
import re
version="0.1"
name="PHYLO_4_Basic"
identifier="biowebdb.PHYLO.Basic.vistrails"
###############################################################################################
# Global Functions
def receive_data(channel):
### Read when data is available
data = ''
while select.select([channel,], [], []):
x = channel.recv(1024)
if not x: break
data += x
return data
def exec_command(connection, command):
### Executes a SSH command
print command
chan = connection.open_session()
chan.exec_command(command)
data = receive_data(chan)
chan.close()
return data
def init_file(connection,dirin):
## Cria diretorio e copia arquivo
# ostimes = data/hora em milisegundos
# mkdir (ostimes)
# copy
# dirout = ostimes
ostimes = str(os.times()[4])
dirout = "/tmp/" + ostimes
exec_command(connection,"rm -rf " + dirout)
exec_command(connection,"mkdir " + dirout)
return dirout
79
###############################################################################################
class remove_pipe_dna (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
dirin = self.getInputFromPort("dirin")
import makeRemovePipe_aa
corrected_file = makeRemovePipe_aa.paramModule(dirin)
##Faz um monte de coisas e retorna
self.setResult("corrected_file", corrected_file)
self.setResult("dirin_out", dirin)
###############################################################################################
class ReadSeq_dna (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
dirin = self.getInputFromPort("dirin")
path_trimmer = self.getInputFromPort("path_trimmer")
import makeReadseq_aa
makeReadseq_aa.paramModuleReadseq(path_trimmer)
##Faz um monte de coisas e retorna
self.setResult("dirin_out", dirin)
self.setResult("path_trimmer_out", path_trimmer)
##############################################################################################
class remove_pipe_aa (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
dirin = self.getInputFromPort("dirin")
import makeRemovePipe_aa
corrected_file = makeRemovePipe_aa.paramModule(dirin)
##Faz um monte de coisas e retorna
self.setResult("corrected_file", corrected_file)
self.setResult("dirin_out", dirin)
###############################################################################################
class ReadSeq_aa (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
dirin = self.getInputFromPort("dirin")
path_trimmer = self.getInputFromPort("path_trimmer")
import makeReadseq_aa
makeReadseq_aa.paramModuleReadseq(path_trimmer)
##Faz um monte de coisas e retorna
self.setResult("dirin_out", dirin)
self.setResult("path_trimmer_out", path_trimmer)
##############################################################################################
class Modelgenerator_aa (Module):
def compute(self):
80
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
dirin = self.getInputFromPort("dirin")
dirin_current = self.getInputFromPort("dirin_current")
import makeReadseq_aa
makeReadseq_aa.paramModuleReadseq(path_trimmer)
##Faz um monte de coisas e retorna
self.setResult("dirin_out", dirin)
self.setResult("dirin_current_out", dirin_current)
##############################################################################################
class File_Fasta (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
dirin = self.getInputFromPort("dirin")
path_trimmer = self.getInputFromPort("path_trimmer")
import makeReadseq_aa
makeReadseq_aa.paramModuleReadseq(path_trimmer)
##Faz um monte de coisas e retorna
self.setResult("dirin_out", dirin)
self.setResult("path_trimmer_out", path_trimmer)
##############################################################################################
class File_Phylip (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
dirin = self.getInputFromPort("dirin")
path_trimmer = self.getInputFromPort("path_trimmer")
import makeReadseq_aa
makeReadseq_aa.paramModuleReadseq(path_trimmer)
##Faz um monte de coisas e retorna
self.setResult("dirin_out", dirin)
self.setResult("path_trimmer_out", path_trimmer)
###############################################################################################
class File_Nexus (Module):
def compute(self):
# get hostname
dirin = self.getInputFromPort("dirin")
connection = self.getInputFromPort("connection")
dirout = init_file(connection,dirin)
##Faz um monte de coisas e retorna
self.setResult("dirin_out", dirout)
self.setResult("path__out", dirin)
###############################################################################################
def initialize(*args, **keywords):
reg = core.modules.module_registry.registry
reg.add_module(remove_pipe_dna)
reg.add_input_port(remove_pipe_dna,"dirin",(core.modules.basic_modules.String,"dirin"))
reg.add_output_port(remove_pipe_dna,"corrected_file",(core.modules.basic_modules.File,"Saida"))
reg.add_output_port(remove_pipe_dna,"dirin_out",(core.modules.basic_modules.String,"Diretorio de entrada"))
reg.add_module(ReadSeq_dna)
reg.add_input_port(ReadSeq_dna,"dirin",(core.modules.basic_modules.String,"dirin"))
reg.add_input_port(ReadSeq_dna,"path_trimmer",(core.modules.basic_modules.String,"path_trimmer"))
81
reg.add_output_port(ReadSeq_dna,"path_trimmer_out",(core.modules.basic_modules.String,"Saida"))
reg.add_output_port(ReadSeq_dna,"dirin_out",(core.modules.basic_modules.String,"Saida"))
reg.add_module(remove_pipe_aa)
reg.add_input_port(remove_pipe_aa,"dirin",(core.modules.basic_modules.String,"dirin"))
reg.add_output_port(remove_pipe_aa,"corrected_file",(core.modules.basic_modules.File,"Saida"))
reg.add_output_port(remove_pipe_aa,"dirin_out",(core.modules.basic_modules.String,"Diretorio de entrada"))
reg.add_module(ReadSeq_aa)
reg.add_input_port(ReadSeq_aa,"dirin",(core.modules.basic_modules.String,"dirin"))
reg.add_input_port(ReadSeq_aa,"path_trimmer",(core.modules.basic_modules.String,"path_trimmer"))
reg.add_output_port(ReadSeq_aa,"path_trimmer_out",(core.modules.basic_modules.String,"Saida"))
reg.add_output_port(ReadSeq_aa,"dirin_out",(core.modules.basic_modules.String,"Saida"))
reg.add_module(Modelgenerator_aa)
reg.add_input_port(Modelgenerator_aa,"dirin",(core.modules.basic_modules.String,"dirin"))
reg.add_input_port(Modelgenerator_aa,"dirin_current",(core.modules.basic_modules.String,"dirin_current"))
reg.add_output_port(Modelgenerator_aa,"dirin_current_out",(core.modules.basic_modules.String,"dirin_current_out"))
reg.add_output_port(Modelgenerator_aa,"dirin_out",(core.modules.basic_modules.String,"dirin_out"))
reg.add_module(File_Fasta)
reg.add_input_port(File_Fasta,"dirin",(core.modules.basic_modules.String,"dirin"))
reg.add_input_port(File_Fasta,"path_trimmer",(core.modules.basic_modules.String,"path_trimmer"))
reg.add_output_port(File_Fasta,"path_trimmer_out",(core.modules.basic_modules.String,"Saida"))
reg.add_output_port(File_Fasta,"dirin_out",(core.modules.basic_modules.String,"Saida"))
reg.add_module(File_Phylip)
reg.add_input_port(File_Phylip,"dirin",(core.modules.basic_modules.String,"dirin"))
reg.add_input_port(File_Phylip,"path_trimmer",(core.modules.basic_modules.String,"path_trimmer"))
reg.add_output_port(File_Phylip,"path_trimmer_out",(core.modules.basic_modules.String,"Saida"))
reg.add_output_port(File_Phylip,"dirin_out",(core.modules.basic_modules.String,"Saida"))
reg.add_module(File_Nexus)
reg.add_input_port(File_Nexus,"dirin",(core.modules.basic_modules.String,"dirin"))
reg.add_input_port(File_Nexus,"connection",(core.modules.vistrails_module.Module,"connection"))
reg.add_output_port(File_Nexus,"dirin_out",(core.modules.basic_modules.String,"Saida"))
reg.add_output_port(File_Nexus,"path__out",(core.modules.basic_modules.String,"path__out"))
82
Apêndice E - Código do módulo Amino.
import core.modules.module_registry
import base64
import getpass
import os
import socket
import time
import sys
import traceback
import select
import paramiko
import webbrowser
from core.modules.vistrails_module import Module
#from Bio import SeqIO
import thread
from time import gmtime, strftime
#import psycopg2
import re
version="0.1"
name="PHYLO_5_Amino"
identifier="biowebdb.PHYLO.Amino.vistrails"
###############################################################################################
# Global Functions
def receive_data(channel):
### Read when data is available
data = ''
while select.select([channel,], [], []):
x = channel.recv(1024)
if not x: break
data += x
return data
def exec_command(connection, command):
### Executes a SSH command
print command
chan = connection.open_session()
chan.exec_command(command)
data = receive_data(chan)
chan.close()
return data
###############################################################################################
class Trimming (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
dirin = self.getInputFromPort("dirin")
path_alignment = self.getInputFromPort("path_alignment")
##Faz um monte de coisas e retorna
self.setResult("path_alignment_out", path_alignment)
self.setResult("dirin_out", dirin)
###############################################################################################
class ReadSeq (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
dirin = self.getInputFromPort("dirin")
path_trimmer = self.getInputFromPort("path_trimmer")
import makeReadseq_aa
makeReadseq_aa.paramModuleReadseq(path_trimmer)
83
##Faz um monte de coisas e retorna
self.setResult("dirin_out", dirin)
self.setResult("path_trimmer_out", path_trimmer)
###############################################################################################
class Raxml (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
out = 'Fui'
dirin = self.getInputFromPort("dirin")
model = self.getInputFromPort("model")
bootstrap = self.getInputFromPort("bootstrap")
nb_categ = self.getInputFromPort("nb_categ")
rates_raxml_aa = self.getInputFromPort("rates_raxml_aa")
freq_raxml_aa = self.getInputFromPort("freq_raxml_aa")
import makeRaxml_aa
makeRaxml_aa.ModuleRaxml(dirin, model, bootstrap, nb_categ, rates_raxml_aa, freq_raxml_aa)
##Faz um monte de coisas e retorna
self.setResult("Out", out)
###############################################################################################
class Garli (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
out = 'Fui'
dirin = self.getInputFromPort("dirin")
model = self.getInputFromPort("model")
bootstrap = self.getInputFromPort("bootstrap")
nb_categ = self.getInputFromPort("nb_categ")
import makeGarli_aa
makeGarli_aa.ModuleGarli(dirin,model,bootstrap,nb_categ)
##Faz um monte de coisas e retorna
self.setResult("Out", out)
##############################################################################################
class PhyML (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
out = 'Fui'
Evolutionary_model = self.getInputFromPort("Evolutionary_model")
bootstrap = self.getInputFromPort("bootstrap")
Substitution_Rate_Categories = self.getInputFromPort("Substitution_Rate_Categories")
Gama_distribution = self.getInputFromPort("Gama_distribution")
Proportion_of_invariable_sites = self.getInputFromPort("Proportion_of_invariable_sites")
#import makeGarli_aa
#makeGarli_aa.ModuleGarli(dirin, model, bootstrap, nb_categ)
##Faz um monte de coisas e retorna
self.setResult("Out", out)
###############################################################################################
class Phylip_ML (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
out = 'Fui'
bootstrap = self.getInputFromPort("bootstrap")
#import makeGarli_aa
#makeGarli_aa.ModuleGarli(dirin, model, bootstrap, nb_categ)
84
##Faz um monte de coisas e retorna
self.setResult("Out", out)
###############################################################################################
class Paup_ML (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
out = 'Fui'
bootstrap = self.getInputFromPort("bootstrap")
#import makeGarli_aa
#makeGarli_aa.ModuleGarli(dirin, model, bootstrap, nb_categ)
##Faz um monte de coisas e retorna
self.setResult("Out", out)
###############################################################################################
class Weighbor (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
out = 'Fui'
Evolutionary_model = self.getInputFromPort("Evolutionary_model")
Substitution_rates_categories = self.getInputFromPort("Substitution_rates_categories")
#import makeGarli_aa
#makeGarli_aa.ModuleGarli(dirin, model, bootstrap, nb_categ)
##Faz um monte de coisas e retorna
self.setResult("Out", out)
###############################################################################################
class Phylip_NJ (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
out = 'Fui'
bootstrap = self.getInputFromPort("bootstrap")
#import makeGarli_aa
#makeGarli_aa.ModuleGarli(dirin, model, bootstrap, nb_categ)
##Faz um monte de coisas e retorna
self.setResult("Out", out)
###############################################################################################
class Paup_NJ (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
out = 'Fui'
bootstrap = self.getInputFromPort("bootstrap")
#import makeGarli_aa
#makeGarli_aa.ModuleGarli(dirin, model, bootstrap, nb_categ)
##Faz um monte de coisas e retorna
self.setResult("Out", out)
###############################################################################################
class Phylip_MP (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
out = 'Fui'
bootstrap = self.getInputFromPort("bootstrap")
85
#import makeGarli_aa
#makeGarli_aa.ModuleGarli(dirin, model, bootstrap, nb_categ)
##Faz um monte de coisas e retorna
self.setResult("Out", out)
###############################################################################################
class Paup_MP (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
out = 'Fui'
bootstrap = self.getInputFromPort("bootstrap")
#import makeGarli_aa
#makeGarli_aa.ModuleGarli(dirin, model, bootstrap, nb_categ)
##Faz um monte de coisas e retorna
self.setResult("Out", out)
###############################################################################################
class MrBayes (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
out = 'Fui'
Evolutionary_model = self.getInputFromPort("Evolutionary_model")
Generation_number = self.getInputFromPort("Generation_number")
Substitution_rates_categories = self.getInputFromPort("Substitution_rates_categories")
Chain_Printed = self.getInputFromPort("Chain_Printed")
Markov_chain_Sampled = self.getInputFromPort("Markov_chain_Sampled")
Chains_run = self.getInputFromPort("Chains_run")
Number_of_samples_discarded = self.getInputFromPort("Number_of_samples_discarded")
Number_of_independent_analyses = self.getInputFromPort("Number_of_independent_analyses")
Rates_variation_model = self.getInputFromPort("Rates_variation_model")
#import makeGarli_aa
#makeGarli_aa.ModuleGarli(dirin, model, bootstrap, nb_categ)
##Faz um monte de coisas e retorna
self.setResult("Out", out)
###############################################################################################
def initialize(*args, **keywords):
reg = core.modules.module_registry.registry
reg.add_module(Raxml)
reg.add_input_port(Raxml,"dirin",(core.modules.basic_modules.String,"dirin"))
reg.add_input_port(Raxml,"model",(core.modules.basic_modules.String,"model"))
reg.add_input_port(Raxml,"bootstrap",(core.modules.basic_modules.String,"Bootstrap"))
reg.add_input_port(Raxml,"nb_categ",(core.modules.basic_modules.String,"nb_categ"))
reg.add_input_port(Raxml,"rates_raxml_aa",(core.modules.basic_modules.String,"rates_raxml_aa"))
reg.add_input_port(Raxml,"freq_raxml_aa",(core.modules.basic_modules.String,"freq_raxml_aa"))
reg.add_output_port(Raxml,"Out",(core.modules.basic_modules.String,"Saida"))
reg.add_module(Garli)
reg.add_input_port(Garli,"dirin",(core.modules.basic_modules.String,"dirin"))
reg.add_input_port(Garli,"model",(core.modules.basic_modules.String,"model"))
reg.add_input_port(Garli,"bootstrap",(core.modules.basic_modules.String,"Bootstrap"))
reg.add_input_port(Garli,"nb_categ",(core.modules.basic_modules.String,"nb_categ"))
reg.add_output_port(Garli,"Out",(core.modules.basic_modules.String,"Saida"))
reg.add_module(PhyML)
reg.add_input_port(PhyML,"Evolutionary_model",(core.modules.basic_modules.String,"Evolutionary_model"))
reg.add_input_port(PhyML,"bootstrap",(core.modules.basic_modules.String,"bootstrap"))
reg.add_input_port(PhyML,"Substitution_Rate_Categories",(core.modules.basic_modules.String,"Substitution_Rate_Ca
tegories"))
reg.add_input_port(PhyML,"Gama_distribution",(core.modules.basic_modules.String,"Gama_distribution"))
reg.add_input_port(PhyML,"Proportion_of_invariable_sites",(core.modules.basic_modules.String,"Proportion_of_invaria
ble_sites"))
reg.add_output_port(PhyML,"Out",(core.modules.basic_modules.String,"Saida"))
86
reg.add_module(Phylip_ML)
reg.add_input_port(Phylip_ML,"bootstrap",(core.modules.basic_modules.String,"bootstrap"))
reg.add_output_port(Phylip_ML,"Out",(core.modules.basic_modules.String,"Saida"))
reg.add_module(Paup_ML)
reg.add_input_port(Paup_ML,"bootstrap",(core.modules.basic_modules.String,"bootstrap"))
reg.add_output_port(Paup_ML,"Out",(core.modules.basic_modules.String,"Saida"))
reg.add_module(Weighbor)
reg.add_input_port(Weighbor,"Evolutionary_model",(core.modules.basic_modules.String,"Evolutionary_model"))
reg.add_input_port(Weighbor,"Substitution_rates_categories",(core.modules.basic_modules.String,"Substitution_rates_
categories"))
reg.add_output_port(Weighbor,"Out",(core.modules.basic_modules.String,"Saida"))
reg.add_module(Phylip_NJ)
reg.add_input_port(Phylip_NJ,"bootstrap",(core.modules.basic_modules.String,"bootstrap"))
reg.add_output_port(Phylip_NJ,"Out",(core.modules.basic_modules.String,"Saida"))
reg.add_module(Paup_NJ)
reg.add_input_port(Paup_NJ,"bootstrap",(core.modules.basic_modules.String,"bootstrap"))
reg.add_output_port(Paup_NJ,"Out",(core.modules.basic_modules.String,"Saida"))
reg.add_module(Phylip_MP)
reg.add_input_port(Phylip_MP,"bootstrap",(core.modules.basic_modules.String,"bootstrap"))
reg.add_output_port(Phylip_MP,"Out",(core.modules.basic_modules.String,"Saida"))
reg.add_module(Paup_MP)
reg.add_input_port(Paup_MP,"bootstrap",(core.modules.basic_modules.String,"bootstrap"))
reg.add_output_port(Paup_MP,"Out",(core.modules.basic_modules.String,"Saida"))
reg.add_module(MrBayes)
reg.add_input_port(MrBayes,"Evolutionary_model",(core.modules.basic_modules.String,"Evolutionary_model"))
reg.add_input_port(MrBayes,"Generation_number",(core.modules.basic_modules.String,"Generation_number"))
reg.add_input_port(MrBayes,"Substitution_rates_categories",(core.modules.basic_modules.String,"Substitution_rates
_categories"))
reg.add_input_port(MrBayes,"Chain_Printed",(core.modules.basic_modules.String,"Chain_Printed"))
reg.add_input_port(MrBayes,"Markov_chain_Sampled",(core.modules.basic_modules.String,"Markov_chain_Sampled
"))
reg.add_input_port(MrBayes,"Chains_run ",(core.modules.basic_modules.String,"Chains_run "))
reg.add_input_port(MrBayes,"Number_of_samples_discarded",(core.modules.basic_modules.String,"Number_of_sam
ples_discarded"))
reg.add_input_port(MrBayes,"Number_of_independent_analyses",(core.modules.basic_modules.String,"Number_of_i
ndependent_analyses"))
reg.add_input_port(MrBayes,"Rates_variation_model",(core.modules.basic_modules.String,"Rates_variation_model"))
reg.add_output_port(MrBayes,"Out",(core.modules.basic_modules.String,"Saida"))
Apêndice F - Código do módulo DNA.
import core.modules.module_registry
import base64
import getpass
import os
import socket
import time
import sys
import traceback
import select
import paramiko
import webbrowser
from core.modules.vistrails_module import Module
#from Bio import SeqIO
import thread
from time import gmtime, strftime
#import psycopg2
import re
version="0.1"
name="PHYLO_6_Dna"
identifier="biowebdb.PHYLO.dna.vistrails"
87
###############################################################################################
# Global Functions
def receive_data(channel):
### Read when data is available
data = ''
while select.select([channel,], [], []):
x = channel.recv(1024)
if not x: break
data += x
return data
def exec_command(connection, command):
### Executes a SSH command
print command
chan = connection.open_session()
chan.exec_command(command)
data = receive_data(chan)
chan.close()
return data
###############################################################################################
class Raxml (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
out = 'Fui'
dirin = self.getInputFromPort("dirin")
Evolutionary_model = self.getInputFromPort("Evolutionary_model")
Bootstrap = self.getInputFromPort("Bootstrap")
Substitution_rate_categories = self.getInputFromPort("Substitution_rate_categories")
Substitution_rates = self.getInputFromPort("Substitution_rates")
rates_raxml_aa = self.getInputFromPort("rates_raxml_aa")
freq_raxml_aa = self.getInputFromPort("freq_raxml_aa")
import makeRaxml_aa
makeRaxml_aa.ModuleRaxml(dirin, model, bootstrap, nb_categ, rates_raxml_aa, freq_raxml_aa)
##Faz um monte de coisas e retorna
self.setResult("Out", out)
###############################################################################################
class Garli (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
out = 'Fui'
dirin = self.getInputFromPort("dirin")
Evolutionary_model = self.getInputFromPort("Evolutionary_model")
Bootstrap = self.getInputFromPort("Bootstrap")
Substitution_rates_categories = self.getInputFromPort("Substitution_Rates_Categories")
import makeGarli_aa
makeGarli_aa.ModuleGarli(dirin, model, bootstrap, nb_categ)
##Faz um monte de coisas e retorna
self.setResult("Out", out)
##############################################################################################
class PhyML (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
out = 'Fui'
Evolutionary_model = self.getInputFromPort("Evolutionary_model")
bootstrap = self.getInputFromPort("bootstrap")
Substitution_Rate_Categories = self.getInputFromPort("Substitution_Rate_Categories")
Gama_distribution = self.getInputFromPort("Gama_distribution")
Proportion_of_invariable_sites = self.getInputFromPort("Proportion_of_invariable_sites")
88
#import makeGarli_aa
#makeGarli_aa.ModuleGarli(dirin, model, bootstrap, nb_categ)
##Faz um monte de coisas e retorna
self.setResult("Out", out)
##############################################################################################
class Phylip_ML (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
out = 'Fui'
bootstrap = self.getInputFromPort("bootstrap")
#import makeGarli_aa
#makeGarli_aa.ModuleGarli(dirin, model, bootstrap, nb_categ)
##Faz um monte de coisas e retorna
self.setResult("Out", out)
###############################################################################################
class Paup_ML (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
out = 'Fui'
bootstrap = self.getInputFromPort("bootstrap")
#import makeGarli_aa
#makeGarli_aa.ModuleGarli(dirin, model, bootstrap, nb_categ)
##Faz um monte de coisas e retorna
self.setResult("Out", out)
###############################################################################################
class Weighbor (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
out = 'Fui'
Evolutionary_model = self.getInputFromPort("Evolutionary_model")
Substitution_rates_categories = self.getInputFromPort("Substitution_rates_categories")
#import makeGarli_aa
#makeGarli_aa.ModuleGarli(dirin, model, bootstrap, nb_categ)
##Faz um monte de coisas e retorna
self.setResult("Out", out)
###############################################################################################
class Phylip_NJ (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
out = 'Fui'
bootstrap = self.getInputFromPort("bootstrap")
#import makeGarli_aa
#makeGarli_aa.ModuleGarli(dirin, model, bootstrap, nb_categ)
##Faz um monte de coisas e retorna
self.setResult("Out", out)
###############################################################################################
#
class Paup_NJ (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
89
# get hostname
out = 'Fui'
bootstrap = self.getInputFromPort("bootstrap")
#import makeGarli_aa
#makeGarli_aa.ModuleGarli(dirin, model, bootstrap, nb_categ)
##Faz um monte de coisas e retorna
self.setResult("Out", out)
###############################################################################################
class Phylip_MP (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
out = 'Fui'
bootstrap = self.getInputFromPort("bootstrap")
#import makeGarli_aa
#makeGarli_aa.ModuleGarli(dirin, model, bootstrap, nb_categ)
##Faz um monte de coisas e retorna
self.setResult("Out", out)
###############################################################################################
class Paup_MP (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
out = 'Fui'
bootstrap = self.getInputFromPort("bootstrap")
#import makeGarli_aa
#makeGarli_aa.ModuleGarli(dirin, model, bootstrap, nb_categ)
##Faz um monte de coisas e retorna
self.setResult("Out", out)
###############################################################################################
class MrBayes (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
out = 'Fui'
Evolutionary_model = self.getInputFromPort("Evolutionary_model")
Generation_number = self.getInputFromPort("Generation_number")
Substitution_rates_categories = self.getInputFromPort("Substitution_rates_categories")
Chain_Printed = self.getInputFromPort("Chain_Printed")
Markov_chain_Sampled = self.getInputFromPort("Markov_chain_Sampled")
Chains_run = self.getInputFromPort("Chains_run")
Number_of_samples_discarded = self.getInputFromPort("Number_of_samples_discarded")
Number_of_independent_analyses = self.getInputFromPort("Number_of_independent_analyses")
Rates_variation_model = self.getInputFromPort("Rates_variation_model")
#import makeGarli_aa
#makeGarli_aa.ModuleGarli(dirin, model, bootstrap, nb_categ)
##Faz um monte de coisas e retorna
self.setResult("Out", out)
###############################################################################################
def initialize(*args, **keywords):
reg = core.modules.module_registry.registry
reg.add_module(Raxml)
reg.add_input_port(Raxml,"dirin",(core.modules.basic_modules.String,"dirin"))
reg.add_input_port(Raxml,"evolutmodel",(core.modules.basic_modules.String,"model"))
reg.add_input_port(Raxml,"bootstrap",(core.modules.basic_modules.String,"Bootstrap"))
reg.add_input_port(Raxml,"nb_categ",(core.modules.basic_modules.String,"nb_categ"))
reg.add_input_port(Raxml,"rates_raxml_aa",(core.modules.basic_modules.String,"rates_raxml_aa"))
reg.add_input_port(Raxml,"freq_raxml_aa",(core.modules.basic_modules.String,"freq_raxml_aa"))
reg.add_output_port(Raxml,"Out",(core.modules.basic_modules.String,"Saida"))
90
reg.add_module(Garli)
reg.add_input_port(Garli,"dirin",(core.modules.basic_modules.String,"dirin"))
reg.add_input_port(Garli,"Evolutionary_model",(core.modules.basic_modules.String,"Evolutionary_model"))
reg.add_input_port(Garli,"Bootstrap",(core.modules.basic_modules.String,"Bootstrap"))
reg.add_input_port(Garli,"Substitution_rates_categories",(core.modules.basic_modules.String,"Substitution_rates_cate
gories"))
reg.add_output_port(Garli,"Out",(core.modules.basic_modules.String,"Saida"))
reg.add_module(PhyML)
reg.add_input_port(PhyML,"Evolutionary_model",(core.modules.basic_modules.String,"Evolutionary_model"))
reg.add_input_port(PhyML,"bootstrap",(core.modules.basic_modules.String,"bootstrap"))
reg.add_input_port(PhyML,"Substitution_Rate_Categories",(core.modules.basic_modules.String,"Substitution_Rate_Ca
tegories"))
reg.add_input_port(PhyML,"Gama_distribution",(core.modules.basic_modules.String,"Gama_distribution"))
reg.add_input_port(PhyML,"Proportion_of_invariable_sites",(core.modules.basic_modules.String,"Proportion_of_invaria
ble_sites"))
reg.add_output_port(PhyML,"Out",(core.modules.basic_modules.String,"Saida"))
reg.add_module(Phylip_ML)
reg.add_input_port(Phylip_ML,"bootstrap",(core.modules.basic_modules.String,"bootstrap"))
reg.add_output_port(Phylip_ML,"Out",(core.modules.basic_modules.String,"Saida"))
reg.add_module(Paup_ML)
reg.add_input_port(Paup_ML,"bootstrap",(core.modules.basic_modules.String,"bootstrap"))
reg.add_output_port(Paup_ML,"Out",(core.modules.basic_modules.String,"Saida"))
reg.add_module(Weighbor)
reg.add_input_port(Weighbor,"Evolutionary_model",(core.modules.basic_modules.String,"Evolutionary_model"))
reg.add_input_port(Weighbor,"Substitution_rates_categories",(core.modules.basic_modules.String,"Substitution_rates_
categories"))
reg.add_output_port(Weighbor,"Out",(core.modules.basic_modules.String,"Saida"))
reg.add_module(Phylip_NJ)
reg.add_input_port(Phylip_NJ,"bootstrap",(core.modules.basic_modules.String,"bootstrap"))
reg.add_output_port(Phylip_NJ,"Out",(core.modules.basic_modules.String,"Saida"))
reg.add_module(Paup_NJ)
reg.add_input_port(Paup_NJ,"bootstrap",(core.modules.basic_modules.String,"bootstrap"))
reg.add_output_port(Paup_NJ,"Out",(core.modules.basic_modules.String,"Saida"))
reg.add_module(Phylip_MP)
reg.add_input_port(Phylip_MP,"bootstrap",(core.modules.basic_modules.String,"bootstrap"))
reg.add_output_port(Phylip_MP,"Out",(core.modules.basic_modules.String,"Saida"))
reg.add_module(Paup_MP)
reg.add_input_port(Paup_MP,"bootstrap",(core.modules.basic_modules.String,"bootstrap"))
reg.add_output_port(Paup_MP,"Out",(core.modules.basic_modules.String,"Saida"))
reg.add_module(MrBayes)
reg.add_input_port(MrBayes,"Evolutionary_model",(core.modules.basic_modules.String,"Evolutionary_model"))
reg.add_input_port(MrBayes,"Generation_number",(core.modules.basic_modules.String,"Generation_number"))
reg.add_input_port(MrBayes,"Substitution_rates_categories",(core.modules.basic_modules.String,"Substitution_rates_c
ategories"))
reg.add_input_port(MrBayes,"Chain_Printed",(core.modules.basic_modules.String,"Chain_Printed"))
reg.add_input_port(MrBayes,"Markov_chain_Sampled",(core.modules.basic_modules.String,"Markov_chain_Sampled")
)
reg.add_input_port(MrBayes,"Chains_run ",(core.modules.basic_modules.String,"Chains_run "))
reg.add_input_port(MrBayes,"Number_of_samples_discarded",(core.modules.basic_modules.String,"Number_of_sampl
es_discarded"))
reg.add_input_port(MrBayes,"Number_of_independent_analyses",(core.modules.basic_modules.String,"Number_of_in
dependent_analyses"))
reg.add_input_port(MrBayes,"Rates_variation_model",(core.modules.basic_modules.String,"Rates_variation_model"))
reg.add_output_port(MrBayes,"Out",(core.modules.basic_modules.String,"Saida"))
91
Apêndice G- Código do módulo view
import core.modules.module_registry
import base64import getpass
import osimport socketimport timeimport sysimport tracebackimport selectimport paramikoimport webbrowserfrom
core.modules.vistrails_module import Module#from Bio import SeqIO
import thread
from time import gmtime, strftime
#import psycopg2
import re
version="0.1"
name="PHYLO_7_View"
identifier="biowebdb.PHYLO.view.vistrails"
###############################################################################################
#
# Global Functions
def receive_data(channel):
### Read when data is available
data = ''
while select.select([channel,], [], []):
x = channel.recv(1024)
if not x: break
data += x
return data
def exec_command(connection, command):
### Executes a SSH command
print command
chan = connection.open_session()
chan.exec_command(command)
data = receive_data(chan)
chan.close()
return data
###############################################################################################
##
class view (Module):
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
# get hostname
treeURL = self.getInputFromPort("treeURL")
# path_alignment = self.getInputFromPort("path_alignment")
os.popen("firefox " +
"http://kineto2.biowebdb.org:8080/archaeopteryx/index1.jsp?PHYLO="+treeURL.replace("/var/www/",
"http://kineto2.biowebdb.org/"))
###############################################################################################
##
def initialize(*args, **keywords):
reg = core.modules.module_registry.registry
reg.add_module(view)
reg.add_input_port(view,"treeURL",(core.modules.basic_modules.String,"treeURL"))
# reg.add_input_port(view,"path_alignment",(core.modules.basic_modules.String,"path_alignment"))
92
Apêndice H - Desenvolvimento de módulo workflow Científico no Vistrails 1.3
Para o desenvolvimento de módulos no Vistrails, devemos seguir os
seguintes passos:
a.
Desenvolvimento de módulos no Vistrails - Para a criação de Módulos
no Vistrails é necessário criar classes da linguagem de programação em Python, nas
quais serão criados packages, cada um correspondendo a um arquivo Python,
devendo ser armazenados em pastas específicas (/vistrails/packages/), onde cada
package é um conjunto de módulos que correspondem a cada classe do arquivo.
Características do package : Inicialmente, têm-se as importações necessárias
para criação da instância dos módulos do Vistrails.
Imports core.modules.module.module_registry
From core.modules.vistrails_module
Import Module, ModuleError
Em seguida, a importação de bibliotecas Python necessárias para execução
dos módulos de acordo com a implementação a ser dada :
Imports os
Imports Time
Imports Paramico
Dados do módulo, versão, identificação e nome:
version = “2.0”
name = “PHYLO_1_Connection”
identifier = “biowebdb.PHYLO.align.vistrails.”
Nome da classe que é igual o nome do módulo:
Mafft (Module):
A funcionalidade do módulo é definida por uma função dentro da classe:
def compute(self):
tipo = self.getInputFromPort("tipo")
fileIn = self.getInputFromPort("fileIn")
dirin = self.getInputFromPort("dirin")
.
Função necessária para o registro do módulo
def initialize(*args, **keywords):
reg = core.modules.module_registry.registry
93
Adição dos módulos e das portas de entrada e saída, bem como as
características dos dados a serem processados
reg.add_module(Mafft)
reg.add_input_port(Mafft,"tipo",(core.modules.basic_modules.String,"
tipo"))
reg.add_input_port(Mafft,"fileIn",(core.modules.basic_modules.String,"
fileIn"))
reg.add_input_port(Mafft,"dirin",(core.modules.basic_modules.String,"dirin
"))
reg.add_input_port(Mafft,"path_alignment",(core.modules.basic_modules.I
nteger," path_alignment"))
reg.add_output_port(Mafft,"dirin_out",(core.modules.vistrails_module.Mod
ule,"dirin_out"))
b. Exemplo de código completo para ser adicionado ao módulo.
Código completo:
import core.modules.module_registry
import base64
import getpass
import os
import socket
import time
import sys
import traceback
import select
import paramiko
import webbrowser
from core.modules.vistrails_module import Module
import thread
from time import gmtime, strftime
import re
94
version="0.1"
name="PHYLO_2_Alignment"
identifier="biowebdb.PHYLO.align.vistrails"
##################################################
# Global Functions
def receive_data(channel):
### Read when data is available
data = ''
while select.select([channel,], [], []):
x = channel.recv(1024)
if not x: break
data += x
return data
def exec_command(connection, command):
### Executes a SSH command
print command
chan = connection.open_session()
chan.exec_command(command)
data = receive_data(chan)
chan.close()
return data
##################################################
class Mafft (Module):
"Teste"
def compute(self):
# setup logging
paramiko.util.log_to_file('demo_simple.log')
"Tipo de alinhamento"
tipo = self.getInputFromPort("tipo")
fileIn = self.getInputFromPort("fileIn")
95
dirin = self.getInputFromPort("dirin")
import makeMafft_aa
makeMafft_aa.paramModuleExecution(dirin)
for m in os.listdir(dirin):
if m.endswith('.mafft'):
path_alignment = os.path.join(dirin, m)
os.chmod(path_alignment, 0755)
self.setResult("path_alignment", path_alignment)
self.setResult("dirin_out", dirin)
##########################################
########
def initialize(*args, **keywords):
reg = core.modules.module_registry.registry
reg.add_module(Mafft)
reg.add_input_port(Mafft,"tipo",(core.modules.basic_modules.String,"tipo
de alinhamento"))
reg.add_input_port(Mafft,"fileIn",(core.modules.basic_modules.File,"Arqui
vo de Entrada"))
reg.add_input_port(Mafft,"dirin",(core.modules.basic_modules.String,"Dir
etorio de entrada"))
reg.add_output_port(Mafft,"path_alignment",(core.modules.basic_modules
.String,"Caminho do alinhamento"))
reg.add_output_port(Mafft,"dirin_out",(core.modules.basic_modules.String
,"Saida do alinhamento"))
96
c. Adicionando o módulo desenvolvido na paleta de ferramentas do Vistrails :
Após a cópia do código do módulo no diretório /vistrails /packages/, o
usuário deverá seguir os seguintes passos:
1. Executar o Vistrails 1.3, podendo ser pela interface gráfica
ou pelo terminal, conforme Figura 8.1.
-
Figura 8.1– Tela inicial do vistrails para adicionar módulos.
2. Em seguida, no menu principal, selecionar “edit”,
“preferences”, e na tela de preferences (Figura 8.2) vá
até a aba “Module Packages” e, em seguida,
selecione no item “Disabled packages”, o módulo
desenvolvido e pressionar “Enable”, colocando o
mesmo na área de “Enable packages”.
97
Figura 8.2 – Tela do Vistrails, opção “preferences” selecionada.
Figura 8.3 – Inserção de módulo no Vistrails 1.3.
3. Após a execução destes processos (Figura 8.3), o módulo
será automaticamente inserido na área de módulos do
vistrails (Figura 8.4).
98
Figura 8.4 – Tela de execução do Vistrails com módulo adicionado.
Após a execução de todas estas fases, o workflow científico estará disponível
para uso.
99
Anexo A - Sequências proteicas de aquaporinas 1.
>AQP1SACE1
MSSNDSNDTDKQHTRLDPTGVDDAYIPPEQPETKHHRFKISRDTLRDHFIAAVGEFCGTF
MFLWCAYVICNVANHDVALVAAPDGSHPGQLIMIAIGFGFSVMFSIWCFAGVSGGALNPA
MSLSLCLARAVSPTRCVVMWVSQIVAGMAAGGAASAMTPGEVLFANSLGLGCSRTRGLFL
EMFGTAILCLTVLMTAVEKRETNFMAALPIGISLFIAHVALTAYTGTGVNPARSLGAAVA
ARYFPHYHWIYWIGTLLGSILAWSVWQLLQILDYTTYVTAEKAASTKEKAQKKGETSSSS
AVAEV
>AQP1SACE2
MSSNDSNDTDKQHTRLDPTGVDDAYIPPEQPETKHHRFKISRDTLRNHFIAAVGEFCGTF
MFLWCAYVICNVANHDVALVAAPDGSHPGQLIMIAIGFGFSVMFSIWCFAGVSGGALNPA
VSLSLCLARAVSPTRCVVMWVSQIVAGMAAGGAASAMTPGEVLFANSLGLGCSRTRGLFL
EMFGTAILCLTVLMTAVEKRETNFMAALPIGISLFIAHVALTAYTGTGVNPARSLGAAVA
ARYFPHYHWIYWIGPLLGSILAWSVWQLLQILDYTTYVTAEKAASTKEKAQKKVKPAVPL
LWLKSNFPLLFFISRSLALNVIIFGKN
>AQP1SACE3
MSSNDSNDTDKQHTRLDPTGVDDAYIPPEQPETKHHRFKISKDTLRNHFIAAAGEFCGTF
MFLWCAYVICNVANHDVALVAAPDGSHPGQLIMIAIGFGFSVMFSIWCFAGVSGGALNPA
MSLSLCLARAVSPTRCVVMWVSQIVAGMAAGGAASAMTPGEVLFANSLGLGCSRTRGLFL
EMFGTAILCLTVLMTAVEKRETNFMAALPIGISLFIAHVALTAYTGTGVNPARSLGAAVA
ARYFPHYHWIYWIGTLLGSILAWSVWQLLQILDYTTYVTAEKAASTKEKAQKKGETSSSS
AVAEV
>AQP1SACE4
MSSNDSNDTDKQHTRLDPTGVDDAYIPPEQPETKHHRFKISKDTLRNHFIAAAGEFCGTF
MFLWCAYVICNVANHDVALVAAPDGSHPGQLIMIAIGFGFSVMFSIWCFAGVSGGALNPA
VSLSLCLARAVSPTRCVVMWVSQIVAGMAAGGAASAMTPGEVLFANSLGLGCSRTRGLFL
EMFGTAILCLTVLMTAVEKRETNFMAALPIGISLFIAHVALTAYTGTGVNPARSLGAAVA
ARYFPHYHWIYWIGPLLGSILAWSVWQLLQILDYTTYVTAEKAASTKEKAQKKVKPAVPL
LWLKSNFSLLFFISRSLALNVIIFG
>AQP1ARATH1
MEGKEEDVRVGANKFPERQPIGTSAQSDKDYKEPPPAPFFEPGELSSWSFWRAGIAEFIA
TFLFLYITVLTVMGVKRSPNMCASVGIQGIAWAFGGMIFALVYCTAGISGGHINPAVTFG
LFLARKLSLTRALYYIVMQCLGAICGAGVVKGFQPKQYQALGGGANTVAHGYTKGSGLGA
EIIGTFVLVYTVFSATDAKRNARDSHVPILAPLPIGFAVFLVHLATIPITGTGINPARSL
GAAIIYNKDHSWDDHWVFWVGPFIGAALAALYHVVVIRAIPFKSRS
>AQP1ARATH3
MATSARRAYGFGRADEATHPDSIRATLAEFLSTFVFVFAAEGSILSLDKLYWEHAAHAGTNTPGGLILVA
LAHAFALFAAVSAAINVSGGHVNPAVTFGALVGGRVTAIRAIYYWIAQLLGAILACLLLRLTTNGMRPVG
FRLASGVGAVNGLVLEIILTFGLVYVVYSTLIDPKRGSLGIIAPLAIGLIVGANILVGGPFSGASMNPAR
AFGPALVGWRWHDHWIYWVGPFIGSALAALIYEYMVIPTEPPTHHAHGVHQPLAPEDY
>AQP1ARATH4
MKKIELGHHSEAAKPDCIKALIVEFITTFLFVFAGVGSAMATDSLVGNTLVGLFAVAVAHAFVVAVMISA
GHISGGHLNPAVTLGLLLGGHISVFRAFLYWIDQLLASSAACFLLSYLTGGMGTPVHTLASGVSYTQGII
WEIILTFSLLFTVYATIVDPKKGSLDGFGPLLTGFVVGANILAGGAFSGASMNPARSFGPALVSGNWTDH
WVYWVGPLIGGGLAGFIYENVLIDRPHVPVADDEQPLLN
>AQP1LEIMA1
MNSPTSMPVPCCEADAQMCMDKEDPDGVAVEHEMHQEAHRGSERKRSFTWQGKWPFYKYRWLVREYVAEF
FGTFFLVTFGTGVIATTVFHAGNAAVYQSNTSYMEITLGWGFGLTIGLFLSMAVSGGHLNPAVTLANCVF
GVLPWIKLPGYFLAQFLGALAGAANTYLLFKSHFDVGQKNLLPNETMASKYSGIFATYPNVANTYAAWSE
VFNTMALMMGILAITDPRMTPAVNFKPVAIGLLLFVIGITSGINSAYGLNPARDFAPRVFAAMLWGSEPF
TMHGFYFWIPLIAPFIGALLGMFFYVFFIIPPNF
100
>AQP1LEIDO1
MNSPTSTPPACYDAEVQLYMDKEDPEGVPIQNQMHEEEQGQLEGKRNFTSQNRWPLYKYRWWLREYVAEF
FGTFFLVTFGTGVIATTVFHAGNAASYQSNSSYMAITFGWGFGLTIGLFLSMAVSGGHLNPAVTLANCVF
GAFPWIKLPGYFLAQFLGGLVGAANTYGLFKSHFDDAQKALLPNETMASKYSGIFATYPNVANTYAVWSE
VFNTMALMMGILAITDPRMTPAVNYKPVAIGLLLFVIGITSGINSSYGLNPARDLSPRILSAMLWGSEPF
TLYSYYFWIPLVAPFVGALLGMFLYVFFIIPPNF
>>AQP1LEIMA2
MHEEEEDQHESKRNFMSQNRWPLYRYRWRLREYVAEFFGTFFLVTFGTGVVATTVFHGGTTAMYQSNSSY
LAITFGWAFGLAISLFLSMAVSGGHLNPAVTLANCVFGTFPWVKLPGYFLAQFLGGFVGAANTYVLFKSH
FDEAEKRLLLNETMASKYGGIFATYPNVANTYAVWSEVFNTMALMMGILAITDARMTPAVDYKPVAIGLL
LFVIGIASGINSSYGLNPARDLSPRILSAMLWGSEPFTLHSYYFWIPLVVPFVGALFGMFLYVFFIIPPS
C
>AQP1LEIDO2
MNSPTSTPPACYDAEVQLYMDKEDPEGVPIQNQMHEEEQGQLEGKRNFTSQNRWPLYKYRWWLREYVAEF
FGTFFLVTFGTGVIATTVFHAGNAASYQSNSSYMAITFGWGFGLTIGLFLSMAVSGGHLNPAVTLANCVF
GAFPWIKLPGYFLAQFLGGLVGAANTYGLFKSHFDDAQKALLPNETMASKYSGIFATYPNVANTYAVWSE
VFNTMALMMGILAITDPRMTPAVNYKPVAIGLLLFVIGITSGINSSYGLNPARDLSPRILSAMLWGSEPF
TLYSYYFWIPLVAPFVGALLGMFLYVFFIIPPNF
101
Anexo B - Sequências proteicas de aquaporinas 3.
>AQP3Sace
MSNPQKALNDFLSSESVHTHDSSRKQSNKQSSDEGRSSSQPSHHHSGGTNNNNNNNNNNNNSNNNNNGND
GGNDDDYDYEMQDYRPSPQSARPTPTYVPQYSVESGTAFPIQEVIPSAYINTQDINHKDNGPPSASSNRA
FRPRGQTTVSANVLNIEDFYKNADDAHTIPESHLSRRRSRSRATSNAGHSANTGATNGRTTGAQTNMESN
ESPRNVPIMVKPKTLYQNPQTPTVLPSTYHPINKWSSVKNTYLKEFLAEFMGTMVMIIFGSAVVCQVNVA
GKIQQDNFNVALDNLNVTGSSAETIDAMKSLTSLVSSVAGGTFDDVALGWAAAVVMGYFCAGGSAISGAH
LNPSITLANLVYRGFPLKKVPYYFAGQLIGAFTGALILFIWYKRVLQEAYSDWWMNESVAGMFCVFPKPY
LSSGRQFFSEFLCGAMLQAGTFALTDPYTCLSSDVFPLMMFILIFIINASMAYQTGTAMNLARDLGPRLA
LYAVGFDHKMLWVHHHHFFWVPMVGPFVGALMGGLVYDVCIYQGHESPVNWSLPVYKEMIMRAWFRRPGW
KKRNRARRTSDLSDFSYNNDDDEEFGERMALQKTKTKSSISDNENEAGEKKVQFKSVQRGKRTFGGIPTI
LEEEDSIETASLGATTTDSIGLSDTSSEDSHYGNAKKVT
>AQP3LEIBR2
MAIENHMDEDQQQRQKRDLTAQDTWPLYRYRWWIREYVAEFFGSFFLLSFGIGVTATTTF
HAGNTASFQTNVSYLAITLGWGFGLAIALFITMGVSGGHLNPAVTLANCAFGAFPWRKAP
GFMLAQLLGAILGAANVYGLFKQHFDDAGVMLLPNETMASKFSGVFVTYPNVSNVFAVWS
EIFNTMVLMMGILAINDNRMTPADGYKPVAVGLLLFVIGITTGINSGYALNPTRDLGPRI
FTAMLWGKEPFTLHGYYFWIPIVGPIAGALLGMFLYVFCIIPSGA
>AQP3LEIIN
MNSPTSTPPACYDAEVQLYMDKEDPEGVPIQNQMHEEEQGQLEGKRNFTSQNRWPLYKYR
WWLREYVAEFFGTFFLVTFGTGVIATTVFHAGNAASYQSNSSYMAITFGWGFGLTIGLFL
SMAVSGGHLNPAVTLANCVFGAFPWIKLPGYFLAQFLGGLVGAANTYGLFKSHFDDAQKA
LLPNETMASKYSGIFATYPNVANTYAVWSEVFNTMALMMGILAITDPRMTPAVNYKPVAI
GLLLFVIGITTGINSSYGLNPARDLSPRILSAMLWGSEPFTLYSYYFWIPLVAPFVGALL
GMFLYVFFIIPPNF
>AQP3TRYBRU
MSDEKINVHQYPSETDVRGLKARNGGACEVPFEENNEPIPNRSANPQEKNENELVGDNAD
NEAHDAVDVNYWAPRQLRLDYRNYMGEFLGTFVLLFMGNGVVATTILDKDLGFLSITLGW
GIAVTMGLYISLGISCGHLNPAVTLANAVFGCFPWRRVPGYIAAQMLGAFVGAACAYGVY
ADLLKQHSGGLVGFGDKGFAGMFSTYPREGNRLFYCIFSEFICTAILLFCVGGIFDPNNS
PAKGHEPLAVGALVFAIGNNIGYASGYAINPARDFGPRVFSAILFGSEVFTTGNYYFWVP
LFIPFLGGIFGLFLYKYFVPY
>AQP3TRYBR1
MQSQPDNVAYPMELQAVNKDGTVEVRVQGNDDSSNRKHEVAEAQEKPVGGINFWAPRELR
LNYRDYMGELLGTFVLLFMGNGVVATVIIDGKLGFLSITLGWGIAVTMALYVSLGISSGH
LNPAVTVGNAVFGDFPWRKVPGYIAAQMLGAFLGAACAYGVFADLLKAHGGGELIAFGEK
GTAGVFSTYPRDSNGLFSCIFGEFICTAMLLFCVCGIFDPNNSPAKGHEPLAVGALVFAI
GNNIGYSTGYAINPARDFGPRVFSSFLYGGEVFSHANYYFWVPLVIPLFGGIFGLFLYKY
FVPH
>AQP3TRYBR2
MQSQPDNVAYPMELQAVNKDGTVEVRVQGNVDNSSNERWDADVQKHEVAEAQEKPVGGIN
FWAPRELRLNYRDYVAEFLGNFVLIYIAKGAVITSLLVPDFGLLGLTIGIGVAVTMALYV
SLGISGGHLNSAVTVGNAVFGDFPWRKVPGYIAAQMLGTFLGAACAYGVFADLLKAHGGG
ELIAFGEKGIAWVFAMYPAEGNGIFYPIFAELISTAVLLLCVCGIFDPNNSPAKGYETVA
IGALVFVMVNNFGLASPLAMNPSLDFGPRVFGAILLGGEVFSHANYYFWVPLVVPFFGAI
LGLFLYKYFLPH
102
Anexo C - Sequências proteicas de aquaporinas 9.
>AQP9Sace
MSNESNDLEKNISHLDPTGVDNAYIPPEQPETKHSRFNIDRDTLRNHFIAAVGEFCGTFMFLWCAYVICN
VANHDVALTTEPEGSHPGQLIMIALGFGFSVMFSIWCFAGVSGGALNPAVSLSLCLARAISPARCVVMWF
SQIIAGMAAGGAASAMTPGKVLFTNALGLGCSRSRGLFLEMFGTAVLCLTVLMTAVEKRETNFMAALPIG
ISLFMAHMALTGYTGTGVNPARSLGAAVAARYFPHYHWIYWIGPLLGAFLAWSVWQLLQILDYPTYVNAE
KAAGQKKED
>AQP9LEIMA
MLSEFLSQLVAEFVGTFLLVLTIALASVGVGALAPIPIGFMLAAMCFTFGYISGAHFNPA
ISFAVFINRKMTLRRTVMYIVVQLAGSFCASLYASAIIGLQIPAPVAKGDLANTWQVLLC
ELVYTFALTSVVLHVCFSRQRSNDFYGFAIGMTLMAAGFSVGGFTSGAFNPAVATGTQLV
LCVYKNCDPLFYFWVYWIAPICGAFIASVIYQLLDTHESVPVVLGKEAVY
>AQP9LEIBR2
MLSEFLSQLVAEFVGTFLFVLTIILASVGVGSLAPIPIGFMLAAMCFTFGYISGAHFNPA
ISFAIFINRKMTLRQTVLYVMMQLGGSFCASLYASAIIGLKIPVPVPNENLAGTWQALLC
ELVYTFALTSVVLHVYFSRQHSNDFYGFAIGMMLMAAGFSVGGFTGGAFNPAVATGTQLV
LCLYNNCDPLFYVWVYWIAPIGGAVIASIVYQLLDAHERVPVVLSKEAVY
>AQP9LEIDO
MLSEFLSQLVAEFVGTFLLVLTITLASVGVGVLAPIPIGFMLAAMCFTFGYISGAHFNPA
ISFAVFINRKMTLRQTVMYVVVQLAGSFCASLYASAIIGLQIPAPLANGDLASTWQVLLC
ELVYTFALTSVVLHVCFSRQRSNDFYGFAIGMTLMAAGFSVGGFTGGAFNPAVATGTQLV
LCVYKNCDPLFYFWVYWIAPICGAFIASVIYQLLDTHESVPVVLGKEAVY
>AQP9LEIIN
MLSEFLSQLVAEFVGTFLLVLTITLASVGVGTLAPIPIGFMLAAMCFTFGYISGAHFNPA
ISFAVFINRKMTLRRTVMYIVVQLAGSFCASLYASAIIGLQIPAPVANGDLANTWQVLLC
ELVYTFALTSVVLHVCFSRQRSNDFYGFAIGMTLMAAGFSVGGFTGGAFNPAVATGTQLV
LCVYKNCDPLFYFWVYWIAPICGAFVASVIFQLLDTHESVPVVLGKEAVY
>AQP9TRYBRU
MQSQPDNVAYPMELQAVNKDGTVEVRVQGNVDNSSNERWDADVQKHEVAEAQEKPVGGIN
FWAPRELRLNYRDYVAEFLGNFVLIYIAKGAVITSLLVPDFGLLGLTIGIGVAVTMALYV
SLGISGGHLNSAVTVGNAVFGDFPWRKVPGYIAAQMLGTFLGAACAYGVFADLLKAHGGG
ELIAFGEKGIAWVFAMYPAEGNGIFYPIFAELISTAVLLLCVCGIFDPNNSPAKGYETVA
IGALVFVMVNNFGLASPLAMNPSLDFGPRVFGAILLGGEVFSHANYYFWVPLVVPFFGAI
LGLFLYKYFLPH
>AQP9TRYCR
MTFSPGMSEIVAEFVGTFLFVLTIPLASLGVGSLAPLPIGFMLAAMTFSFGYISGAHFNP
AITFATFINGKIPFRKMFFYMISQILAAFLASLYGSAIVGLRIPVPSTDVALVSVWQAIL
CEMVYTFALASVVLHVNYSRQRSNEFYGFAIGMTVLSASFAVGGFTGGAFNPAVATGTQL
VGCIGGNCKPLIFFWIYWVAPLGGSFLASIAYQILDTHDRVAPIELSGQVF
103
Anexo D - Sequências proteicas de aquaporinas 1, 3 e 9.
>AQP1SACE1
MSSNDSNDTDKQHTRLDPTGVDDAYIPPEQPETKHHRFKISRDTLRDHFIAAVGEFCGTF
MFLWCAYVICNVANHDVALVAAPDGSHPGQLIMIAIGFGFSVMFSIWCFAGVSGGALNPA
MSLSLCLARAVSPTRCVVMWVSQIVAGMAAGGAASAMTPGEVLFANSLGLGCSRTRGLFL
EMFGTAILCLTVLMTAVEKRETNFMAALPIGISLFIAHVALTAYTGTGVNPARSLGAAVA
ARYFPHYHWIYWIGTLLGSILAWSVWQLLQILDYTTYVTAEKAASTKEKAQKKGETSSSS
AVAEV
>AQP1SACE2
MSSNDSNDTDKQHTRLDPTGVDDAYIPPEQPETKHHRFKISRDTLRNHFIAAVGEFCGTF
MFLWCAYVICNVANHDVALVAAPDGSHPGQLIMIAIGFGFSVMFSIWCFAGVSGGALNPA
VSLSLCLARAVSPTRCVVMWVSQIVAGMAAGGAASAMTPGEVLFANSLGLGCSRTRGLFL
EMFGTAILCLTVLMTAVEKRETNFMAALPIGISLFIAHVALTAYTGTGVNPARSLGAAVA
ARYFPHYHWIYWIGPLLGSILAWSVWQLLQILDYTTYVTAEKAASTKEKAQKKVKPAVPL
LWLKSNFPLLFFISRSLALNVIIFGKN
>AQP1SACE3
MSSNDSNDTDKQHTRLDPTGVDDAYIPPEQPETKHHRFKISKDTLRNHFIAAAGEFCGTF
MFLWCAYVICNVANHDVALVAAPDGSHPGQLIMIAIGFGFSVMFSIWCFAGVSGGALNPA
MSLSLCLARAVSPTRCVVMWVSQIVAGMAAGGAASAMTPGEVLFANSLGLGCSRTRGLFL
EMFGTAILCLTVLMTAVEKRETNFMAALPIGISLFIAHVALTAYTGTGVNPARSLGAAVA
ARYFPHYHWIYWIGTLLGSILAWSVWQLLQILDYTTYVTAEKAASTKEKAQKKGETSSSS
AVAEV
>AQP1SACE4
MSSNDSNDTDKQHTRLDPTGVDDAYIPPEQPETKHHRFKISKDTLRNHFIAAAGEFCGTF
MFLWCAYVICNVANHDVALVAAPDGSHPGQLIMIAIGFGFSVMFSIWCFAGVSGGALNPA
VSLSLCLARAVSPTRCVVMWVSQIVAGMAAGGAASAMTPGEVLFANSLGLGCSRTRGLFL
EMFGTAILCLTVLMTAVEKRETNFMAALPIGISLFIAHVALTAYTGTGVNPARSLGAAVA
ARYFPHYHWIYWIGPLLGSILAWSVWQLLQILDYTTYVTAEKAASTKEKAQKKVKPAVPL
LWLKSNFSLLFFISRSLALNVIIFG
>AQP1ARATH1
MEGKEEDVRVGANKFPERQPIGTSAQSDKDYKEPPPAPFFEPGELSSWSFWRAGIAEFIA
TFLFLYITVLTVMGVKRSPNMCASVGIQGIAWAFGGMIFALVYCTAGISGGHINPAVTFG
LFLARKLSLTRALYYIVMQCLGAICGAGVVKGFQPKQYQALGGGANTVAHGYTKGSGLGA
EIIGTFVLVYTVFSATDAKRNARDSHVPILAPLPIGFAVFLVHLATIPITGTGINPARSL
GAAIIYNKDHSWDDHWVFWVGPFIGAALAALYHVVVIRAIPFKSRS
>AQP1ARATH3
MATSARRAYGFGRADEATHPDSIRATLAEFLSTFVFVFAAEGSILSLDKLYWEHAAHAGTNTPGGLILVA
LAHAFALFAAVSAAINVSGGHVNPAVTFGALVGGRVTAIRAIYYWIAQLLGAILACLLLRLTTNGMRPVG
FRLASGVGAVNGLVLEIILTFGLVYVVYSTLIDPKRGSLGIIAPLAIGLIVGANILVGGPFSGASMNPAR
AFGPALVGWRWHDHWIYWVGPFIGSALAALIYEYMVIPTEPPTHHAHGVHQPLAPEDY
>AQP1ARATH4
MKKIELGHHSEAAKPDCIKALIVEFITTFLFVFAGVGSAMATDSLVGNTLVGLFAVAVAHAFVVAVMISA
GHISGGHLNPAVTLGLLLGGHISVFRAFLYWIDQLLASSAACFLLSYLTGGMGTPVHTLASGVSYTQGII
WEIILTFSLLFTVYATIVDPKKGSLDGFGPLLTGFVVGANILAGGAFSGASMNPARSFGPALVSGNWTDH
WVYWVGPLIGGGLAGFIYENVLIDRPHVPVADDEQPLLN
>AQP1LEIMA1
MNSPTSMPVPCCEADAQMCMDKEDPDGVAVEHEMHQEAHRGSERKRSFTWQGKWPFYKYRWLVREYVAEF
FGTFFLVTFGTGVIATTVFHAGNAAVYQSNTSYMEITLGWGFGLTIGLFLSMAVSGGHLNPAVTLANCVF
GVLPWIKLPGYFLAQFLGALAGAANTYLLFKSHFDVGQKNLLPNETMASKYSGIFATYPNVANTYAAWSE
VFNTMALMMGILAITDPRMTPAVNFKPVAIGLLLFVIGITSGINSAYGLNPARDFAPRVFAAMLWGSEPF
TMHGFYFWIPLIAPFIGALLGMFFYVFFIIPPNF
>AQP1LEIDO1
MNSPTSTPPACYDAEVQLYMDKEDPEGVPIQNQMHEEEQGQLEGKRNFTSQNRWPLYKYRWWLREYVAEF
FGTFFLVTFGTGVIATTVFHAGNAASYQSNSSYMAITFGWGFGLTIGLFLSMAVSGGHLNPAVTLANCVF
104
GAFPWIKLPGYFLAQFLGGLVGAANTYGLFKSHFDDAQKALLPNETMASKYSGIFATYPNVANTYAVWSE
VFNTMALMMGILAITDPRMTPAVNYKPVAIGLLLFVIGITSGINSSYGLNPARDLSPRILSAMLWGSEPF
TLYSYYFWIPLVAPFVGALLGMFLYVFFIIPPNF
>AQP1LEIMA2
MHEEEEDQHESKRNFMSQNRWPLYRYRWRLREYVAEFFGTFFLVTFGTGVVATTVFHGGTTAMYQSNSSY
LAITFGWAFGLAISLFLSMAVSGGHLNPAVTLANCVFGTFPWVKLPGYFLAQFLGGFVGAANTYVLFKSH
FDEAEKRLLLNETMASKYGGIFATYPNVANTYAVWSEVFNTMALMMGILAITDARMTPAVDYKPVAIGLL
LFVIGIASGINSSYGLNPARDLSPRILSAMLWGSEPFTLHSYYFWIPLVVPFVGALFGMFLYVFFIIPPS
C
>AQP1LEIDO2
MNSPTSTPPACYDAEVQLYMDKEDPEGVPIQNQMHEEEQGQLEGKRNFTSQNRWPLYKYRWWLREYVAEF
FGTFFLVTFGTGVIATTVFHAGNAASYQSNSSYMAITFGWGFGLTIGLFLSMAVSGGHLNPAVTLANCVF
GAFPWIKLPGYFLAQFLGGLVGAANTYGLFKSHFDDAQKALLPNETMASKYSGIFATYPNVANTYAVWSE
VFNTMALMMGILAITDPRMTPAVNYKPVAIGLLLFVIGITSGINSSYGLNPARDLSPRILSAMLWGSEPF
TLYSYYFWIPLVAPFVGALLGMFLYVFFIIPPNF
>AQP3Sace
MSNPQKALNDFLSSESVHTHDSSRKQSNKQSSDEGRSSSQPSHHHSGGTNNNNNNNNNNNNSNNNNNGND
GGNDDDYDYEMQDYRPSPQSARPTPTYVPQYSVESGTAFPIQEVIPSAYINTQDINHKDNGPPSASSNRA
FRPRGQTTVSANVLNIEDFYKNADDAHTIPESHLSRRRSRSRATSNAGHSANTGATNGRTTGAQTNMESN
ESPRNVPIMVKPKTLYQNPQTPTVLPSTYHPINKWSSVKNTYLKEFLAEFMGTMVMIIFGSAVVCQVNVA
GKIQQDNFNVALDNLNVTGSSAETIDAMKSLTSLVSSVAGGTFDDVALGWAAAVVMGYFCAGGSAISGAH
LNPSITLANLVYRGFPLKKVPYYFAGQLIGAFTGALILFIWYKRVLQEAYSDWWMNESVAGMFCVFPKPY
LSSGRQFFSEFLCGAMLQAGTFALTDPYTCLSSDVFPLMMFILIFIINASMAYQTGTAMNLARDLGPRLA
LYAVGFDHKMLWVHHHHFFWVPMVGPFVGALMGGLVYDVCIYQGHESPVNWSLPVYKEMIMRAWFRRPGW
KKRNRARRTSDLSDFSYNNDDDEEFGERMALQKTKTKSSISDNENEAGEKKVQFKSVQRGKRTFGGIPTI
LEEEDSIETASLGATTTDSIGLSDTSSEDSHYGNAKKVT
>AQP3LEIBR2
MAIENHMDEDQQQRQKRDLTAQDTWPLYRYRWWIREYVAEFFGSFFLLSFGIGVTATTTF
HAGNTASFQTNVSYLAITLGWGFGLAIALFITMGVSGGHLNPAVTLANCAFGAFPWRKAP
GFMLAQLLGAILGAANVYGLFKQHFDDAGVMLLPNETMASKFSGVFVTYPNVSNVFAVWS
EIFNTMVLMMGILAINDNRMTPADGYKPVAVGLLLFVIGITTGINSGYALNPTRDLGPRI
FTAMLWGKEPFTLHGYYFWIPIVGPIAGALLGMFLYVFCIIPSGA
>AQP3LEIIN
MNSPTSTPPACYDAEVQLYMDKEDPEGVPIQNQMHEEEQGQLEGKRNFTSQNRWPLYKYR
WWLREYVAEFFGTFFLVTFGTGVIATTVFHAGNAASYQSNSSYMAITFGWGFGLTIGLFL
SMAVSGGHLNPAVTLANCVFGAFPWIKLPGYFLAQFLGGLVGAANTYGLFKSHFDDAQKA
LLPNETMASKYSGIFATYPNVANTYAVWSEVFNTMALMMGILAITDPRMTPAVNYKPVAI
GLLLFVIGITTGINSSYGLNPARDLSPRILSAMLWGSEPFTLYSYYFWIPLVAPFVGALL
GMFLYVFFIIPPNF
>AQP3TRYBRU
MSDEKINVHQYPSETDVRGLKARNGGACEVPFEENNEPIPNRSANPQEKNENELVGDNAD
NEAHDAVDVNYWAPRQLRLDYRNYMGEFLGTFVLLFMGNGVVATTILDKDLGFLSITLGW
GIAVTMGLYISLGISCGHLNPAVTLANAVFGCFPWRRVPGYIAAQMLGAFVGAACAYGVY
ADLLKQHSGGLVGFGDKGFAGMFSTYPREGNRLFYCIFSEFICTAILLFCVGGIFDPNNS
PAKGHEPLAVGALVFAIGNNIGYASGYAINPARDFGPRVFSAILFGSEVFTTGNYYFWVP
LFIPFLGGIFGLFLYKYFVPY
>AQP3TRYBR1
MQSQPDNVAYPMELQAVNKDGTVEVRVQGNDDSSNRKHEVAEAQEKPVGGINFWAPRELR
LNYRDYMGELLGTFVLLFMGNGVVATVIIDGKLGFLSITLGWGIAVTMALYVSLGISSGH
LNPAVTVGNAVFGDFPWRKVPGYIAAQMLGAFLGAACAYGVFADLLKAHGGGELIAFGEK
GTAGVFSTYPRDSNGLFSCIFGEFICTAMLLFCVCGIFDPNNSPAKGHEPLAVGALVFAI
GNNIGYSTGYAINPARDFGPRVFSSFLYGGEVFSHANYYFWVPLVIPLFGGIFGLFLYKY
FVPH
>AQP3TRYBR2
MQSQPDNVAYPMELQAVNKDGTVEVRVQGNVDNSSNERWDADVQKHEVAEAQEKPVGGIN
FWAPRELRLNYRDYVAEFLGNFVLIYIAKGAVITSLLVPDFGLLGLTIGIGVAVTMALYV
105
SLGISGGHLNSAVTVGNAVFGDFPWRKVPGYIAAQMLGTFLGAACAYGVFADLLKAHGGG
ELIAFGEKGIAWVFAMYPAEGNGIFYPIFAELISTAVLLLCVCGIFDPNNSPAKGYETVA
IGALVFVMVNNFGLASPLAMNPSLDFGPRVFGAILLGGEVFSHANYYFWVPLVVPFFGAI
LGLFLYKYFLPH
>AQP9Sace
MSNESNDLEKNISHLDPTGVDNAYIPPEQPETKHSRFNIDRDTLRNHFIAAVGEFCGTFMFLWCAYVICN
VANHDVALTTEPEGSHPGQLIMIALGFGFSVMFSIWCFAGVSGGALNPAVSLSLCLARAISPARCVVMWF
SQIIAGMAAGGAASAMTPGKVLFTNALGLGCSRSRGLFLEMFGTAVLCLTVLMTAVEKRETNFMAALPIG
ISLFMAHMALTGYTGTGVNPARSLGAAVAARYFPHYHWIYWIGPLLGAFLAWSVWQLLQILDYPTYVNAE
KAAGQKKED
>AQP9LEIMA
MLSEFLSQLVAEFVGTFLLVLTIALASVGVGALAPIPIGFMLAAMCFTFGYISGAHFNPA
ISFAVFINRKMTLRRTVMYIVVQLAGSFCASLYASAIIGLQIPAPVAKGDLANTWQVLLC
ELVYTFALTSVVLHVCFSRQRSNDFYGFAIGMTLMAAGFSVGGFTSGAFNPAVATGTQLV
LCVYKNCDPLFYFWVYWIAPICGAFIASVIYQLLDTHESVPVVLGKEAVY
>AQP9LEIBR2
MLSEFLSQLVAEFVGTFLFVLTIILASVGVGSLAPIPIGFMLAAMCFTFGYISGAHFNPA
ISFAIFINRKMTLRQTVLYVMMQLGGSFCASLYASAIIGLKIPVPVPNENLAGTWQALLC
ELVYTFALTSVVLHVYFSRQHSNDFYGFAIGMMLMAAGFSVGGFTGGAFNPAVATGTQLV
LCLYNNCDPLFYVWVYWIAPIGGAVIASIVYQLLDAHERVPVVLSKEAVY
>AQP9LEIDO
MLSEFLSQLVAEFVGTFLLVLTITLASVGVGVLAPIPIGFMLAAMCFTFGYISGAHFNPA
ISFAVFINRKMTLRQTVMYVVVQLAGSFCASLYASAIIGLQIPAPLANGDLASTWQVLLC
ELVYTFALTSVVLHVCFSRQRSNDFYGFAIGMTLMAAGFSVGGFTGGAFNPAVATGTQLV
LCVYKNCDPLFYFWVYWIAPICGAFIASVIYQLLDTHESVPVVLGKEAVY
>AQP9LEIIN
MLSEFLSQLVAEFVGTFLLVLTITLASVGVGTLAPIPIGFMLAAMCFTFGYISGAHFNPA
ISFAVFINRKMTLRRTVMYIVVQLAGSFCASLYASAIIGLQIPAPVANGDLANTWQVLLC
ELVYTFALTSVVLHVCFSRQRSNDFYGFAIGMTLMAAGFSVGGFTGGAFNPAVATGTQLV
LCVYKNCDPLFYFWVYWIAPICGAFVASVIFQLLDTHESVPVVLGKEAVY
>AQP9TRYBRU
MQSQPDNVAYPMELQAVNKDGTVEVRVQGNVDNSSNERWDADVQKHEVAEAQEKPVGGIN
FWAPRELRLNYRDYVAEFLGNFVLIYIAKGAVITSLLVPDFGLLGLTIGIGVAVTMALYV
SLGISGGHLNSAVTVGNAVFGDFPWRKVPGYIAAQMLGTFLGAACAYGVFADLLKAHGGG
ELIAFGEKGIAWVFAMYPAEGNGIFYPIFAELISTAVLLLCVCGIFDPNNSPAKGYETVA
IGALVFVMVNNFGLASPLAMNPSLDFGPRVFGAILLGGEVFSHANYYFWVPLVVPFFGAI
LGLFLYKYFLPH
>AQP9TRYCR
MTFSPGMSEIVAEFVGTFLFVLTIPLASLGVGSLAPLPIGFMLAAMTFSFGYISGAHFNP
AITFATFINGKIPFRKMFFYMISQILAAFLASLYGSAIVGLRIPVPSTDVALVSVWQAIL
CEMVYTFALASVVLHVNYSRQRSNEFYGFAIGMTVLSASFAVGGFTGGAFNPAVATGTQL
VGCIGGNCKPLIFFWIYWVAPLGGSFLASIAYQILDTHDRVAPIELSGQVF
106