Open Babel

You can use openbabel.OBAtomAtomIter to iterate over the OBAtoms
attached to an OBAtom. (I really should improve the documentation) You
should familiarise yourself with all of the "Iter" methods in the OB
API, as they are very useful for this type of problem:

import openbabel as ob
import pybel

mol = pybel.readstring("smi", "COCC")
mol.OBMol.AddHydrogens()

obatom = mol.atoms[0].OBAtom
for neighbour_atom in ob.OBAtomAtomIter(obatom):
   print neighbour_atom.GetAtomicNum()

Result is: 8 1 1 1

(If you don't add hydrogens, you just get 8)

Noel

On 18/09/2007, Matic Cankar <matic.cankar@...> wrote:
> Hello,
>
> I have a question about bonds of the atom in the molecule. I would like to
> get all atoms, that are connected to one specific atom.
>
> I solved my problem this way (code is just symbolic, not actual code):
> -> I make the bond iterator for the specific atom
>
> bonds = coreAtom.BeginBonds()
> bond = coreAtom.BeginBond(bonds)
>
> -> and for each bond I use method "GetEndAtom()"
>  bond.GetEndAtom()
>
> but I for the end atom from the first bond I get the specific atom that I
> choose first (I get the atom that I'm processing not the end atom). When I
> repaired the code so that I used "GetBeginAtom()" for the first bond and,
> the "GetEndAtom()" for all others, I get the correct answer.
>
> The molecule is kind of graph and bonds are kind of edges. Are bonds
> directed edges, and why so?
> Will my corrected code worked in all conditions? Is first bond always
> directed to the specified (processing atom in my code) atom and others away
> of the specified atom?
>
> thank you for your answer!
>
> Matic
>
>
>
>
> -------------------------------------------------------------------------
> This SF.net email is sponsored by: Microsoft
> Defy all challenges. Microsoft(R) Visual Studio 2005.
> http://clk.atdmt.com/MRT/go/vse0120000070mrt/direct/01/
> _______________________________________________
> OpenBabel-scripting mailing list
> OpenBabel-scripting@...
> https://lists.sourceforge.net/lists/listinfo/openbabel-scripting
>
>

Thank you Noel for the answer.
I'll need information about the atoms and the bonds with which are they
connected to the "processed" atom. That's the reason why I chose that way of
programming.

So if I understand you clear is better way that I use "
openbabel.OBAtomAtomIter" to get the atoms and then I get the bonds with
GetBond(OBAtom) like:

#######
import openbabel as ob
import pybel

mol = pybel.readstring("smi", "COCC")
mol.OBMol.AddHydrogens()

obatom = mol.atoms[0].OBAtom
for neighbour_atom in ob.OBAtomAtomIter(obatom):
   print neighbour_atom.GetAtomicNum()
   bond  =  obatom.GetBond(neighbour_atom)
   print bond.GetBondOrder()

######



Matic


On 9/18/07, Noel O'Boyle <baoilleach@...> wrote:
>
> You can use openbabel.OBAtomAtomIter to iterate over the OBAtoms
> attached to an OBAtom. (I really should improve the documentation) You
> should familiarise yourself with all of the "Iter" methods in the OB
> API, as they are very useful for this type of problem:
>
> import openbabel as ob
> import pybel
>
> mol = pybel.readstring("smi", "COCC")
> mol.OBMol.AddHydrogens()
>
> obatom = mol.atoms[0].OBAtom
> for neighbour_atom in ob.OBAtomAtomIter(obatom):
>    print neighbour_atom.GetAtomicNum()
>
> Result is: 8 1 1 1
>
> (If you don't add hydrogens, you just get 8)
>
> Noel
>
> On 18/09/2007, Matic Cankar <matic.cankar@...> wrote:
> > Hello,
> >
> > I have a question about bonds of the atom in the molecule. I would like
> to
> > get all atoms, that are connected to one specific atom.
> >
> > I solved my problem this way (code is just symbolic, not actual code):
> > -> I make the bond iterator for the specific atom
> >
> > bonds = coreAtom.BeginBonds()
> > bond = coreAtom.BeginBond(bonds)
> >
> > -> and for each bond I use method "GetEndAtom()"
> >  bond.GetEndAtom()
> >
> > but I for the end atom from the first bond I get the specific atom that
> I
> > choose first (I get the atom that I'm processing not the end atom). When
> I
> > repaired the code so that I used "GetBeginAtom()" for the first bond
> and,
> > the "GetEndAtom()" for all others, I get the correct answer.
> >
> > The molecule is kind of graph and bonds are kind of edges. Are bonds
> > directed edges, and why so?
> > Will my corrected code worked in all conditions? Is first bond always
> > directed to the specified (processing atom in my code) atom and others
> away
> > of the specified atom?
> >
> > thank you for your answer!
> >
> > Matic
> >
> >
> >
> >
> >
> -------------------------------------------------------------------------
> > This SF.net email is sponsored by: Microsoft
> > Defy all challenges. Microsoft(R) Visual Studio 2005.
> > http://clk.atdmt.com/MRT/go/vse0120000070mrt/direct/01/
> > _______________________________________________
> > OpenBabel-scripting mailing list
> > OpenBabel-scripting@...
> > https://lists.sourceforge.net/lists/listinfo/openbabel-scripting
> >
> >
>

On 18/09/2007, Matic Cankar <matic.cankar@...> wrote:
> Thank you Noel for the answer.
> I'll need information about the atoms and the bonds with which are they
> connected to the "processed" atom. That's the reason why I chose that way of
> programming.

Ah, OK. So you want information on the bonds.

> So if I understand you clear is better way that I use "
> openbabel.OBAtomAtomIter" to get the atoms and then I get the bonds with
> GetBond(OBAtom) like:

Yes, this seems like the best way if you're interested in both the
atoms and the bonds attached to a particular atom. However, if you're
just interested in the bond orders of the bonds attached, you would
just use openbabel.OBAtomBondIter(obatom) to iterate over the bonds
attached to a particular atom.

> #######
> import openbabel as ob
> import pybel
>
> mol = pybel.readstring("smi", "COCC")
> mol.OBMol.AddHydrogens()
>
> obatom = mol.atoms[0].OBAtom
> for neighbour_atom in ob.OBAtomAtomIter(obatom):
>    print neighbour_atom.GetAtomicNum()
>    bond  =  obatom.GetBond(neighbour_atom)
>    print bond.GetBondOrder ()
>
> ######

> Matic
>
>
>
> On 9/18/07, Noel O'Boyle <baoilleach@...> wrote:
> > You can use openbabel.OBAtomAtomIter to iterate over the OBAtoms
> > attached to an OBAtom. (I really should improve the documentation) You
> > should familiarise yourself with all of the "Iter" methods in the OB
> > API, as they are very useful for this type of problem:
> >
> > import openbabel as ob
> > import pybel
> >
> > mol = pybel.readstring("smi", "COCC")
> > mol.OBMol.AddHydrogens()
> >
> > obatom = mol.atoms[0].OBAtom
> > for neighbour_atom in ob.OBAtomAtomIter(obatom):
> >    print neighbour_atom.GetAtomicNum()
> >
> > Result is: 8 1 1 1
> >
> > (If you don't add hydrogens, you just get 8)
> >
> > Noel
> >
> > On 18/09/2007, Matic Cankar <matic.cankar@...> wrote:
> > > Hello,
> > >
> > > I have a question about bonds of the atom in the molecule. I would like
> to
> > > get all atoms, that are connected to one specific atom.
> > >
> > > I solved my problem this way (code is just symbolic, not actual code):
> > > -> I make the bond iterator for the specific atom
> > >
> > > bonds = coreAtom.BeginBonds()
> > > bond = coreAtom.BeginBond(bonds)
> > >
> > > -> and for each bond I use method "GetEndAtom()"
> > >  bond.GetEndAtom()
> > >
> > > but I for the end atom from the first bond I get the specific atom that
> I
> > > choose first (I get the atom that I'm processing not the end atom). When
> I
> > > repaired the code so that I used "GetBeginAtom()" for the first bond
> and,
> > > the "GetEndAtom()" for all others, I get the correct answer.
> > >
> > > The molecule is kind of graph and bonds are kind of edges. Are bonds
> > > directed edges, and why so?
> > > Will my corrected code worked in all conditions? Is first bond always
> > > directed to the specified (processing atom in my code) atom and others
> away
> > > of the specified atom?
> > >
> > > thank you for your answer!
> > >
> > > Matic
> > >
> > >
> > >
> > >
> > >
> -------------------------------------------------------------------------
> > > This SF.net email is sponsored by: Microsoft
> > > Defy all challenges. Microsoft(R) Visual Studio 2005.
> > > http://clk.atdmt.com/MRT/go/vse0120000070mrt/direct/01/
> > > _______________________________________________
> > > OpenBabel-scripting mailing list
> > > OpenBabel-scripting@...
> > >
> https://lists.sourceforge.net/lists/listinfo/openbabel-scripting
> > >
> > >
> >
>
>

Hi,

> but I for the end atom from the first bond I get the specific atom  
> that I choose first (I get the atom that I'm processing not the end  
> atom). When I repaired the code so that I used "GetBeginAtom()" for  
> the first bond and, the "GetEndAtom()" for all others, I get the  
> correct answer.

I see that Noel answered your question, but I wonder if this is a  
documentation issue. With Open Babel, a bond is a connection between  
two atoms -- the BeginAtom and the EndAtom.

Now these are in random order, so the "begin" and the "end" are  
relative terms. (We might have called them GetAtom1 and GetAtom2.)

Is this something that should be made clear in the documentation for  
OBBond?

As Noel mentioned, if you're interested in iterating, you should look  
at the various OB...Iter classes.

Cheers,
-Geoff

>
>
> Now these are in random order, so the "begin" and the "end" are
> relative terms. (We might have called them GetAtom1 and GetAtom2.)


That's strange to me. I thought that bond shouldn't have a direction. For me
is an endAtom always on the other side of the bond from the way I looked
(from the atom that I called the method). If I am at one atom, on the end of
the bond from this atom shouldn't be the same atom. Every bond has two
atoms, but who decide which is at the beginning and which is at the end?
Maybe I am wrong...

That was the question in my head...



> As Noel mentioned, if you're interested in iterating, you should look
> at the various OB...Iter classes.


Noel's answer was very helpful (is that what I need), but yours cleared my
picture of OBbond (that I'll maybe need in the future).

I hope that my questions don't spend a lot of your time.
Matic

Hello!

I'm writing a script that takes a few connected atoms from one molecule 
and finds connected atoms (submolecule) in another molecule. The script 
first creates one-atom-submolecule. If this atom is a part of another 
molecule, than the script adds another atom to the submolecule. The 
added atom is connected to the first atom from the submolecule. Then the 
script tests if this bigger submolecule is part of another molecule. 
This continues until the submolecule is still a part of another molecule.

I have a problem when I create a "submolecule". The structure of this 
part of script is:

-> First, I take the atoms and the bonds that connect the atoms.
-> Than I create the openBabel molecule from these atoms and bonds. If 
it nessesery, I set the atom's and the bond's aromatic flags.
-> finally I use the findall() function from pybel to find the 
submolecule in another molecule


If I take a submolecule from a molecule and I try to find it in this 
molecule afterwards, the script doesn’t find it. This problem occurs, 
when there are aromatic cycles. I made three different modifications to 
the code which makes the submolecule from the COP(=S)(OC)SCn1nnc2ccccc2c1=O:

FIRST:
Before the adding atoms to the molecule and after it I added 
beginModify() and endModify() functions.
-> the atoms are written correctly (capital instead of small case 
letters) only if the aromatic cycle is closed:

0. N
1. NC
2. NCC
3. NCCC
4. NCC(C)C
5. NCC(CC)C
6. NCC(CC)CC
7. NCc1ccccc1
8. [N](Cc1ccccc1)[NH]
9. n1cc2c(cccc2)nn1

The submolecules from 0. to 8. are not written correctly but the ninth 
is. Also the findall() function finds the ninth submolecule in 
COP(=S)(OC)SCn1nnc2ccccc2c1=O.
So when I close the aromatic cycle I get correctly written carbon and 
nitrous atoms.

SECOND:
Without the use of the beginModify() and endModify functions.
-> that's not good, because the atoms are newer written correctly

1. N
2. NC
3. NCC
4. NCCC
5. NCC(C)C
6. NCC(CC)C
7. NCC(CC)CC
8. NCC1=CC=CC=C1
9. [N](CC1=CC=CC=C1)[NH]
10. N1=CC2=C(C=CC=C2)N=N1
11. [N]1(=CC2=C(C=CC=C2)N=N1)C

THIRD:
Every time when I add the atom in the submolecule I print out the 
submolecule. That's done by adding the
pyMolecule = py.Molecule(mol)
print pyMolecule.write()
lines at the end of the loop which creates the submolecule. 
BeginModify() an EndModify() are not used

-> the atoms are written correctly before the cycle is closed

1. N
2. nc
3. ncc
4. nccc
5. ncc(c)c
6. ncc(cc)c
7. ncc(cc)cc
8. ncc1ccccc1
9. [nH](cc1ccccc1)[n]
10. [nH]1cc2c(cccc2)[n][n]1
11. n1(cc2c(cccc2)[n][n]1)C
12. n1(cc2c(cccc2)[n][n]1)C[S]
13. n1(cc2c(cccc2)[n][n]1)C[S]P


Problem is that submolecules 1., 8. and 9. are not written correctly. 
The findall() function does not find them in 
COP(=S)(OC)SCn1nnc2ccccc2c1=O. The others are OK.


I'll would to have all the submolecules written correctly.

Thank you for your help,
Matic