Creazione di un editor / visualizzatore molecolare: programmazione orientata agli oggetti, strutture di dati e molecole

Sono nuovo nella programmazione e sto cercando di risolvere il mio primo grosso problema e scrivere il mio primo grande programma. Ho cercato esempi open source di codice da cui imparare, ma finora ho trovato solo codice in lingue che non capisco completamente o che fa cose correlate ma ancora troppo lontane da cui posso davvero imparare. Ho problemi a fare alcuni passi concettuali qui.

Voglio creare un semplice software per costruire, modificare e in seguito rappresentare piccole molecole organiche. Questo è principalmente un esercizio di apprendimento. Un utente darebbe una stringa SMILES o sceglierebbe da un set base di molecole di partenza, e quindi potrebbe basarsi su quella molecola graficamente o tramite una sintassi di input di testo. Tuttavia, non sono ancora a quel punto di complessità. Non riesco nemmeno a comprendere appieno come creare classi / oggetti per immagazzinare le molecole. Quindi, la mia domanda in modo succinto: come posso usare classi / oggetti per costruire molecole mantenendo tutti i livelli di informazioni e quali strutture di dati dovrei usare come attributi per quali oggetti? E gli oggetti possono essere attributi di altri oggetti?

Ecco il mio pensiero fino ad ora: stavo pensando di avere una classe "Molecule", quindi una classe / sottoclasse "Atom" e una sottoclasse "Bond", e forse anche una sottoclasse "FunctionalGroup". Sembra un buon punto di partenza, ma forse sto fraintendendo OOP e questo è male. Ma poi il mio problema diventa davvero confuso (per me). Anche se ho tutti questi concetti / idee / classi, non capisco completamente quali strutture dati sono necessarie per rappresentare la molecola. Un elenco di atomi sarebbe una buona cosa da avere. Quell'elenco potrebbe essere un elenco di oggetti Atom? Avrei anche bisogno di un modo per archiviare la connettività. Una matrice 2D sembra una buona idea, con l'ordine dei legami come numeri interi nelle posizioni della matrice.

A questo punto sto iniziando a essere sopraffatto dal compito. Tutto ciò che sto facendo finora ha senso? Allegare un aspetto di visualizzazione / disegno sopra questo può significare che ho bisogno di riscrivere / rielaborare molte di queste cose, ma sto solo cercando di arrivare a un punto in cui posso almeno memorizzare le molecole con i dati rilevanti e quindi accedere quei dati da controllare / modificare. Stavo pensando di farlo in Python, quindi il codice / le classi potrebbero forse assomigliare a questo: http://pastebin.com/uUi1BMzr

Forse questa è davvero una domanda di programmazione per StackOverflow, ma ho pensato che fosse abbastanza specifico per andare qui. Qualsiasi tipo di assistenza sarebbe molto apprezzato, anche se mi fai notare dove ho commesso degli errori concettuali. Grazie in anticipo.

scrivere software è un processo iterativo - scrivi codice -> vedi quanto lontano puoi arrivare quindi pianifica i passi successivi -> scrivi codice -> ripeti. A questo punto nell'apprendimento dell'arte ti suggerirei di saltare presto solo per testare le acque. Non è necessario pianificare l'intero sistema in anticipo. Sì, Python sarebbe una buona prima lingua. Per la visualizzazione prova MatPlotLib, anche NumPy e SciPy sono utili. Il software su scala industriale fa sempre affidamento su librerie pre-compilate, invece di scrivere tutto da soli, ma soluzioni semplici possono e dovrebbero essere scritte da te, specialmente quando si impara a programmare. Il layout OO per ora sembra OK. Quando / se le relazioni con gli oggetti devono cambiare in seguito, l'atto di ricodificare il codice stesso è un'esperienza degna da padroneggiare. Benvenuto a bordo !

Il tuo obiettivo ha molte sfide. Li suddividerò in parti.

SMILES non è un linguaggio banale da analizzare e le regole per la percezione dell'aromaticità non sono ben definite. La definizione grammaticale dettagliata del progetto OpenSMILES dovrebbe aiutare alcuni.

SMILES definisce la topologia, ma non fornisce informazioni 2D o 3D. Fare una delle due è difficile. (Cioè, se vuoi che sia bello.)

Davvero, dovresti guardare al toolkit di cheminformatica RDKit (o OpenBabel, ma preferisco RDKit). Ha un parser SMILES integrato, così come un layout 2D, e credo che sia la generazione della conformazione 3D. Anche OpenBabel lo fa.

Quindi per la visualizzazione dovrai capire il sistema di interfaccia grafica. In realtà, qui il toolkit cheminformatica CDK, in Java, è il più avanzato.

Ma sei nelle basi di come rappresentare una molecola. Esistono differenze tra i modelli di dati a molecole piccole e molecole grandi (proteine, DNA), ma poiché sei interessato a SMILES significa che sei orientato verso piccole molecole.

Puoi guardare i documenti API per RDKit, OpenBabel, CDK, OEChem e Indigo, tra molti altri. Questo ti darà un'idea dei diversi modi in cui le persone sviluppano la loro API di classe. Di questi, preferisco di più OEChem, seguito da RDKit. Anche se OEChem è open source, l'API è online e liberamente leggibile, insieme ad esempi di utilizzo.

In breve, avere una classe Molecule, con un elenco di istanze Atom e Bond. "mol.AddAtom (numero elemento)" crea un nuovo atomo, senza legami, "mol.AddBond (atom1, atom2, bond_type)" crea una connessione di legame. Ogni legame deve conoscere gli atomi a cui è collegato e ogni atomo ha bisogno di un elenco di legami. Ciò porta a molti cicli nella struttura dei dati, ma è necessario affinché vari algoritmi, come la ricerca della connettività, possano essere eseguiti in tempo lineare.

Non utilizzare una matrice 2D. Sebbene fattibile per una piccola molecola, non si adatta bene e non è necessario. Pochi algoritmi richiedono la matrice di connettività ed è facilmente generato se / quando necessario.

Non avere un "Gruppo funzionale". È troppo specializzato. Usa qualcosa come un "Sottoinsieme" o "Frammento", che contiene l'elenco di atomi e legami che ti interessano. In questo modo puoi anche gestire cose come "atomi selezionati" e "sottostruttura ad anello" e "impalcatura" facendo riferimento a il sottoinsieme specifico.

Ho guardato il tuo pastebin. Il parser non dovrebbe funzionare in questo modo. Dovresti separare l'analisi dalla tua attuale struttura molecolare. Prova qualcosa del genere:

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 quindi il parser per una semplice catena lineare come "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

Naturalmente, un parser SMILES completo è molto più complicato di così, e il modello di dati completo deve gestire cose come la conta dell'idrogeno, che sono spesso implicite.

Le mailing list OpenBabel, RDKit e CDK sono anche buoni posti dove andare, se decidessi di usare uno di quei toolkit. C'è anche il sito di domande e risposte "Blue Obelisk", ospitato da Shapado.

Un altro approccio per iniziare potrebbe essere quello di dare un'occhiata ad un codice che fa già qualcosa relativo al tuo problema. In quel caso il tuo esercizio potrebbe anche finire in qualche altro programma, e sarebbe bello, no?

I programmi che potrebbero interessarti

• Il pacchetto di simulazione MD e modellistica molecolare MMTK (come già suggerito da Nate sopra)

• Il pacchetto di visualizzazione PyMol

Imparare i dettagli di un sistema a oggetti molecolari è un modo meraviglioso per i chimici di imparare la programmazione orientata agli oggetti. Scoprirai che l'implementazione di un tale sistema perfezionerà le tue intuizioni molecolari. Dovresti pensare attentamente agli atomi, alle molecole e forse alle raccolte di molecole in termini di attributi e metodi.

Ecco alcune belle diapositive di Python (un po 'più vecchie) che potrebbero aiutare: http://www.wag.caltech.edu/home/rpm/python_course/Lecture_4.pdf

Per controllare il tuo lavoro: oltre a openbabel (che ha i collegamenti in pitone!) E MMTK, c'è ELBOW in phenix.

Per il poliglotta in te, c'è anche PerlMol (Perlmol.org). PerlMol è scritto in perl orientato agli oggetti e può essere scaricato da CPAN.