Criando um editor / visualizador molecular: Programação orientada a objetos, estruturas de dados e moléculas

Eu sou novo em programação e estou tentando resolver meu primeiro grande problema e escrever meu primeiro grande programa. Procurei exemplos de código-fonte aberto para aprender, mas até agora encontrei o código em idiomas que não entendo completamente ou que fazem coisas relacionadas, mas ainda muito distantes, para eu realmente aprender. Estou tendo problemas para executar algumas etapas conceituais aqui.

Quero criar um software simples para criar, modificar e mais tarde representar pequenas moléculas orgânicas. Este é principalmente um exercício de aprendizado. Um usuário forneceria uma string SMILES ou escolheria um conjunto básico de moléculas iniciadoras e, então, poderia desenvolver essa molécula graficamente ou por meio de uma sintaxe de entrada de texto. No entanto, ainda não estou nesse ponto de complexidade. Não consigo nem entender completamente como criar classes / objetos para armazenar as moléculas. Portanto, minha pergunta é sucinta: como uso classes / objetos para construir moléculas, mantendo todos os níveis de informação e quais estruturas de dados devo usar como atributos para quais objetos? E, os objetos podem ser atributos para outros objetos?

Aqui está minha linha de pensamento até agora: eu estava pensando em ter uma classe "Molecule", depois uma classe / subclasse "Atom" e uma subclasse "Bond", e talvez uma subclasse "FunctionalGroup" também. Parece um bom lugar para começar, mas talvez eu esteja entendendo mal o POO e isso seja ruim. Mas então meu problema realmente fica confuso (para mim). Embora eu tenha todos esses conceitos / idéias / classes, não entendo completamente quais estruturas de dados são necessárias para representar a molécula. Uma lista de átomos seria uma boa coisa para ter. Essa lista poderia ser uma lista de objetos Atom? Eu também precisaria ter uma maneira de armazenar conectividade. Uma matriz 2D parece uma boa idéia, com a ordem das ligações como números inteiros nas posições da matriz.

Neste ponto, estou começando a ficar sobrecarregado com a tarefa. Tudo o que estou fazendo até agora faz sentido? Anexar um aspecto de exibição / desenho em cima disso pode significar que eu preciso reescrever / retrabalhar muitas dessas coisas, mas estou apenas tentando chegar a um ponto em que eu possa pelo menos armazenar moléculas com os dados relevantes e acessar esses dados para verificar / modificar. Eu estava pensando em fazer isso em Python, para que o código / classes fosse algo parecido com isto: http://pastebin.com/uUi1BMzr

Talvez essa seja realmente uma questão de programação para o StackOverflow, mas achei que era específico o suficiente para ir aqui. Qualquer assistência seria muito apreciada, mesmo que você apenas indique onde cometi erros conceituais. Desde já, obrigado.

escrever software é um processo iterativo - escreva código -> veja até onde você pode chegar e planeje os próximos passos -> escreva código -> repita. Nesta fase do aprendizado da arte, sugiro que você entre logo para testar as águas. Não há necessidade de planejar todo o sistema antecipadamente. Sim, python seria uma boa primeira linguagem. Para visualização, experimente o MatPlotLib, também o NumPy e o SciPy são úteis. O software em escala industrial sempre se baseia em extrair bibliotecas pré-compiladas, em vez de escrever tudo sozinho, mas soluções simples podem e devem ser escritas por você, especialmente quando se aprende a programar. Seu layout OO parece bom por enquanto. Quando / se seus relacionamentos com objetos precisam mudar mais tarde, o ato de refazer seu próprio código é uma experiência digna de dominar. Bem vindo a bordo !

Seu objetivo tem muitos desafios. Vou dividi-los em partes.

SMILES não é uma linguagem trivial para analisar, e as regras para a percepção da aromaticidade não estão bem definidas. A definição gramatical detalhada do projeto OpenSMILES deve ajudar alguns.

SMILES define a topologia, mas não fornece informações 2D ou 3D. Fazer qualquer um é difícil. (Ou seja, se você quer que fique bonito.)

Realmente, você deve procurar o kit de ferramentas de RDMit cheminformatics (ou OpenBabel, mas eu prefiro o RDKit). Ele possui um analisador SMILES embutido, além de layout 2D, e acredito na geração de conformação 3D. O OpenBabel também.

Então, para exibição, você terá que descobrir o sistema da GUI. Na verdade, aqui o CDK Cheminformatics Toolkit, em Java, é o mais avançado.

Mas você está no básico de como representar uma molécula. Existem diferenças entre os modelos de dados de molécula pequena e molécula grande (proteína, DNA), mas como você está interessado no SMILES, isso significa que você é orientado para moléculas pequenas.

Você pode consultar os documentos da API para RDKit, OpenBabel, CDK, OEChem e Indigo, entre muitos outros. Isso lhe dará uma idéia das diversas maneiras pelas quais as pessoas desenvolvem sua API de classe. Destes, eu prefiro o OEChem mais, seguido pelo RDKit. Embora o OEChem seja de código aberto, a API é on-line e de fácil leitura, juntamente com exemplos de uso.

Em resumo, tenha uma classe Molecule, com uma lista de instâncias Atom e Bond. "mol.AddAtom (número do elemento)" cria um novo átomo, sem ligações, "mol.AddBond (atom1, atom2, bond_type)" faz uma conexão de ligação. Cada ligação precisa conhecer os átomos aos quais está conectada e cada átomo precisa de uma lista de ligações. Isso leva a muitos ciclos na estrutura de dados, mas é necessário para que vários algoritmos, como a pesquisa de conectividade, possam ser feitos em tempo linear.

Não use uma matriz 2D. Embora seja viável para uma molécula pequena, ela não escala tão bem, e não há necessidade dela. Poucos algoritmos precisam da matriz de conectividade e é gerada facilmente se / quando necessário.

Não tem um "FunctionalGroup". É muito especializado. Use algo como um "Subconjunto" ou "Fragmento", que contém a lista de átomos e ligações em que você está interessado. Dessa forma, você também pode lidar com coisas como "átomos selecionados", "subestrutura de anéis" e "andaime" consultando o subconjunto específico.

Eu olhei para a sua pasta. O analisador não deve funcionar dessa maneira. Você deve separar a análise da sua estrutura molecular real. Tente algo como isto:

class Molecule(object):
    def __init__(self):
        self.atoms = []
        self.bonds = []
        self._atom_id = 0
        self._bond_id = 0
    def _next_atom_id(self):
        atom_id = self._atom_id
        self.atom_id += 1
        return atom_id
    def AddAtom(self, eleno):
        self.atoms.append(Atom(self, self._next_atom_id(), eleno))
    def AddBond(self, atom1, atom2, bondtype):
        assert atom1.molecule is atom2.molecule
        self.bonds.append(Bond(self, self._next_bond_id(),
                               atom1, atom2, bondtype))

class Atom(object):
    def __init__(self, molecule, id, eleno):
        self.molecule = molecule
        self.id = id
        self.eleno = eleno
        self.charge = 0
        self.isotope = 0
   ..

e o analisador para uma cadeia linear simples como "CC O" é:

def parse_linear_chain(text):
   mol = Molecule()
   prev_atom = None
   for atom_symbol in text.split():
     eleno = lookup_symbol[atom_symbol]
     atom = mol.NewAtom(eleno)
     if pre_atom is not None:
       mol.AddBond(prev_atom, atom, 1)
     prev_atom = atom
   return mol

Obviamente, um analisador SMILES completo é muito mais complicado que isso, e o modelo de dados completo precisa lidar com coisas como a contagem de hidrogênio, que geralmente são implícitas.

As listas de discussão do OpenBabel, RDKit e CDK também são um bom lugar para ir, caso você decida usar um desses kits de ferramentas. Há também o site de perguntas e respostas "Blue Obelisk", hospedado por Shapado.

Outra abordagem para começar pode ser dar uma olhada em algum código que já faz algo relacionado ao seu problema. Nesse caso, seu exercício pode acabar em outro programa, e isso seria bom, não?

Os programas que podem ser do seu interesse são

• O pacote de simulação MD e modelagem molecular MMTK (como já sugerido por Nate acima)

• O pacote de visualização PyMol

Aprender os detalhes de um sistema de objetos moleculares é uma maneira maravilhosa para os químicos aprenderem a programação orientada a objetos. Você verá que a implementação de um sistema desse tipo refina suas intuições moleculares. Você deve pensar bastante sobre átomos, moléculas e talvez coleções de moléculas em termos de atributos e métodos.

Aqui estão alguns slides em python (um pouco mais antigos) que podem ajudar: http://www.wag.caltech.edu/home/rpm/python_course/Lecture_4.pdf

Para verificar seu trabalho: além do openbabel (que possui ligações python!) E do MMTK, existe o ELBOW no phenix.

Para o poliglota em você, também existe o PerlMol (Perlmol.org). O PerlMol é escrito em perl orientado a objetos e pode ser baixado do CPAN.