Open Babel: OBBuilder Class Reference

Public Member Functions | Static Public Member Functions

# OBBuilder Class Reference

Class to build 3D structures. More...

`#include <openbabel/builder.h>`

List of all members.

## Public Member Functions
| OBBuilder ()
void | LoadFragments ()
Call the build algorithm
bool | Build (OBMol &mol)
Setup build parameters
void | SetKeepRings ()
void | UnsetKeepRings ()
## Static Public Member Functions
static vector3 | GetNewBondVector (OBAtom *atom)
static vector3 | GetNewBondVector (OBAtom *atom, double length)
static bool | Connect (OBMol &mol, int a, int b, vector3 &newpos, int bondOrder=1)
static bool | Connect (OBMol &mol, int a, int b, int bondOrder=1)
static bool | Swap (OBMol &mol, int a, int b, int c, int d)
static void | CorrectStereoBonds (OBMol &mol)
static void | CorrectStereoAtoms (OBMol &mol)
static bool | IsSpiroAtom (unsigned long atomId, OBMol &mol)
static OBBitVec | GetFragment (OBAtom *atom)
static void | AddNbrs (OBBitVec &fragment, OBAtom *atom)

## Detailed Description

Class to build 3D structures.

Class for 3D structure generation.

Since:
  version 2.2

The OBBuilder class is used for generating 3D structures.

Below is and example which explain the basics.

          //
          // code to read molecule from smiles goes here...
          //
          OBBuilder builder;
          builder.Build(mol);
          //
          // code to write molecule to 3D file format goes here...
          //

## Constructor & Destructor Documentation

OBBuilder | ( | ) | `[inline]`

## Member Function Documentation

bool Build | ( | OBMol & | mol ) |

The mol object contains all connectivity information (atomic numbers, bonds, bond orders, ..) but no 3D coordinates. Build generates these coordinates and assigns them.

Parameters:

  mol | Molecule with the connectivity (from smiles for example). The coordinates are also changed in this mol.

void SetKeepRings | ( | ) | `[inline]`

If the molecule already contains 3D coordinates, if you set KeepRings to true it will use retain the 3D coordinates of the rings. By default KeepRings is false, and ring conformations are obtained by lookup in a library of ring conformers. However, since the ring conformer library is not exhaustive, if the ring system is not found in the library, the resulting 3D structure can be poor, and require geometry optimisation before it is reasonable. If your starting point is a 3D structure, you can set KeepRings to true, and the conformation will be taken from the input. The remaining (acyclic) bonds will still all be built by the builder.

void UnsetKeepRings | ( | ) | `[inline]`

void LoadFragments | ( | ) |

Load fragment info from file, if is it has not already been done.

vector3 GetNewBondVector | ( | OBAtom * | atom ) | `[static]`

Get the position for a new neighbour on atom.

Parameters:

  atom | Atom for which we want a new neighbour location.

Returns:
  The position for the new atom.

vector3 GetNewBondVector | ( | OBAtom * | atom,
|  | double | length
| ) |  | `[static]`

bool Connect | ( | OBMol & | mol,
|  | int | a,
|  | int | b,
|  | vector3 & | newpos,
|  | int | bondOrder = `1`
| ) |  | `[static]`

Atoms a and b are part of two fragments that are not connected in mol. Connect will translate and rotate the fragment that contains b so that a and b are seperated by a bond. This bond is also added.

Parameters:

  mol | The molecule to be modified
  a | Index for atom in fragment that should not be rotated.
  b | Index for atom in fragment that should be rotated.
  newpos | Direction for new bond between a and b
  bondOrder | Bond order of the new bond between a and b.

Returns:
  true if succesful or fails when failed (most likely cause for failing: a and b are in the same fragment, they are connected)

bool Connect | ( | OBMol & | mol,
|  | int | a,
|  | int | b,
|  | int | bondOrder = `1`
| ) |  | `[static]`

Atoms a and b are part of two fragments that are not connected in mol. Connect will translate and rotate the fragment that contains b so that a and b are seperated by a bond. This bond is also added.

Parameters:

  mol | The molecule to be modified
  a | Index for atom in fragment that should not be rotated.
  b | Index for atom in fragment that should be rotated.
  bondOrder | Bond order of the new bond bewtween a and b.

Returns:
  true if succesfull or fails when failed (most likely cause for failing: a and b are in the same fragment, they are connected)

bool Swap | ( | OBMol & | mol,
|  | int | a,
|  | int | b,
|  | int | c,
|  | int | d
| ) |  | `[static]`

Swap group b, bonded to a with group d, bonded to c. The bonds a-b and b-c cannot be part of a ring. Atoms a and b will not be moved. Atoms b, d and their connected atoms (after deleting bonds ab and cd) will be translated/rotated.

Example:

        \ /                            /
         b                            d
          \     /     Swap(a,b,c,d)    \     /
           a---x          ---->         a---x
          /     \     /                /     \     /
         x       c---d                x       c---b
                                                   \

This function can also be used to invert chiral centers if a and c are the same atom.

Example

         1                        3
         |      Swap(C,1,C,3)     |
      2>-C-<3      ----->      2>-C-<1
         |                        |
         4                        4

void CorrectStereoBonds | ( | OBMol & | mol ) | `[static]`

Atoms a and b must be bonded and this bond cannot be part of a ring. The bond will be broken and the smiles fragment will be inserted bewteen the two remaining fragments. The fragment that contains a will not be translated or rotated. Parameters c and d are the index in the smiles to which atoms a and b will be connected respectivly.

Correct double bond stereochemistry

void CorrectStereoAtoms | ( | OBMol & | mol ) | `[static]`

Correct stereochemistry at tetrahedral atoms with at least two non-ring bonds. It also works for spiro atoms.

bool IsSpiroAtom | ( | unsigned long | atomId,
|  | OBMol & | mol
| ) |  | `[static]`

Does this atom connect two rings which are not otherwise connected?

OBBitVec GetFragment | ( | OBAtom * | atom ) | `[static]`

Get the fragment to which this atom belongs.

Parameters:

  atom | Atom in the fragment.

Returns:
  The OBBitVec defining the fragment to which a belongs.

void AddNbrs | ( | OBBitVec & | fragment,
|  | OBAtom * | atom
| ) |  | `[static]`

The documentation for this class was generated from the following files:

- builder.h
- builder.cpp

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines