atom.h

Go to the documentation of this file.

/**********************************************************************
atom.h - Handle OBAtom class.

Copyright (C) 1998-2001 by OpenEye Scientific Software, Inc.
Some portions Copyright (C) 2001-2006 by Geoffrey R. Hutchison
Some portions Copyright (C) 2003 by Michael Banck

This file is part of the Open Babel project.
For more information, see <http://openbabel.org/>

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation version 2 of the License.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
***********************************************************************/

#ifndef OB_ATOM_H
#define OB_ATOM_H

#include <openbabel/babelconfig.h>

#ifndef EXTERN
#  define EXTERN extern
#endif

#include <vector>
#include <string>

#include <openbabel/base.h>
#include <openbabel/residue.h>
#include <openbabel/math/vector3.h>

namespace OpenBabel
{

  class OBBond;
  class OBMol;

  typedef OBAtom OBNodeBase;
  typedef std::vector<OBBond*>::iterator OBBondIterator;
  typedef std::vector<OBAtom*>::iterator OBAtomIterator;

  //ATOM Property Macros (flags)
#define OB_4RING_ATOM     (1<<1)
#define OB_3RING_ATOM     (1<<2)
#define OB_AROMATIC_ATOM  (1<<3)
#define OB_RING_ATOM      (1<<4)
#define OB_DONOR_ATOM     (1<<7)
#define OB_ACCEPTOR_ATOM  (1<<8)

#define SET_OR_UNSET_FLAG(X) \
  if (value) SetFlag(X); \
  else     UnsetFlag(X);

  // Class OBAtom
  // class introduction in atom.cpp
 #define OBATOM_TYPE_LEN 6
 class OBAPI OBAtom: public OBBase
    {
    protected:
      unsigned char                 _ele;       
      unsigned char                 _imph;      
      char                          _type[OBATOM_TYPE_LEN];   
      short                         _fcharge;   
      unsigned short                _isotope;   
      short                         _spinmultiplicity;

      unsigned int                  _idx;       
      OBMol                        *_parent;    
      std::vector<OBBond*>          _vbond;     

      unsigned int                  _cidx;      
      unsigned short                _hyb;       
      unsigned short                _flags;     
      double                        _pcharge;   
      double                      **_c;         
      mutable vector3               _v;         
      OBResidue                    *_residue;   

      unsigned long                 _id;        

      int  GetFlag() const    {  return(_flags);  }
      void SetFlag(int flag)  { _flags |= flag;   }
      void UnsetFlag(int flag) { _flags &= (~(flag)); }
      bool HasFlag(int flag)  {  return((_flags & flag) ? true : false); }

    public:
      enum StereoFlag {

      };


      bool Visit;

      OBAtom();
      virtual ~OBAtom();
      OBAtom &operator = (OBAtom &);
      bool operator==(const OBAtom * other) const {  return (GetIdx() == other->GetIdx()); }
      void Duplicate(OBAtom *);
      bool Clear();


      void SetIdx(int idx)    { _idx = idx; _cidx = (idx-1)*3; }
      void SetId(unsigned long id) { _id = id; }
      void SetHyb(int hyb)    { _hyb = hyb; }
      void SetAtomicNum(int atomicnum)    { _ele = (char)atomicnum; }
      void SetIsotope(unsigned int iso);
      void SetImplicitHCount(unsigned int val)    { _imph = (unsigned char)val; }
      void SetFormalCharge(int fcharge)   { _fcharge = fcharge; }
      void SetSpinMultiplicity(short spin){ _spinmultiplicity = spin; }
      void SetType(const char *type);
      void SetType(const std::string &type);
      void SetPartialCharge(double pcharge){ _pcharge = pcharge; }
      void SetVector(const vector3 &v);
      void SetVector(const double x,const double y,const double z);
      void SetCoordPtr(double **c)        { _c = c; _cidx = (GetIdx()-1)*3; }
      void SetVector();
      void SetResidue(OBResidue *res)     { _residue=res; }
      void SetParent(OBMol *ptr)          { _parent=ptr; }
      void SetAromatic(bool value=true)                  { SET_OR_UNSET_FLAG(OB_AROMATIC_ATOM); }
      void SetInRing(bool value=true)         { SET_OR_UNSET_FLAG(OB_RING_ATOM); }
      void ClearCoordPtr()     { _c = NULL; _cidx=0; }


      int          GetFormalCharge()  const { return(_fcharge);    }
      unsigned int GetAtomicNum()     const { return((unsigned int)_ele); }
      unsigned short int GetIsotope() const { return(_isotope);    }
      int          GetSpinMultiplicity() const { return(_spinmultiplicity); }
      double     GetAtomicMass()    const;
      double     GetExactMass()     const;
      unsigned int GetIdx()           const { return((int)_idx);  }
      unsigned int GetIndex() const { return _idx - 1; }
      unsigned long GetId() const { return _id; }
      unsigned int GetCoordinateIdx() const { return((int)_cidx); }
      unsigned int GetExplicitDegree() const { return (unsigned int)_vbond.size(); }
      unsigned int GetTotalDegree() const { return (unsigned int)(_vbond.size() + _imph); }
      unsigned int GetExplicitValence() const;
      unsigned int GetTotalValence() const;
      unsigned int GetHyb()             const;
      unsigned char GetImplicitHCount() const { return _imph; };
      unsigned int GetHvyDegree()      const;
      unsigned int GetHeteroDegree()   const;
      char        *GetType();

      double      GetX() const   {        return(x());    }
      double      GetY() const  {        return(y());    }
      double      GetZ() const  {        return(z());    }

      // These methods check to see if there is a coordinate pointer
      // or an internal vector (e.g., SetCoordPtr())
      double      x() const {
        if (_c)            return((*_c)[_cidx]);
        else               return _v.x();
      }
      double      y() const {
        if (_c)            return((*_c)[_cidx+1]);
        else               return _v.y();
      }
      double      z() const {
        if (_c)            return((*_c)[_cidx+2]);
        else               return _v.z();
      }
      double     *GetCoordinate(){
        if (_c)          return(&(*_c)[_cidx]);
        else             return NULL;
      }
      vector3   &GetVector();
      const vector3   &GetVector() const;
      double     GetPartialCharge();
      OBResidue *GetResidue();
      OBMol     *GetParent()        {return((OBMol*)_parent);}
      bool       GetNewBondVector(vector3 &v,double length);
      OBBond    *GetBond(OBAtom *);


      OBBondIterator BeginBonds()
        { return(_vbond.begin()); }
      OBBondIterator EndBonds()
        { return(_vbond.end());   }
      OBBond *BeginBond(OBBondIterator &i);
      OBBond *NextBond(OBBondIterator &i);
      OBAtom *BeginNbrAtom(OBBondIterator &i);
      OBAtom *NextNbrAtom(OBBondIterator &i);

      double GetDistance(int index);
      double GetDistance(OBAtom*);
      double GetDistance(vector3* v);
      double GetAngle(int b, int c);
      double GetAngle(OBAtom *b, OBAtom *c);



      void NewResidue()
        {
          if (!_residue)
            _residue = new OBResidue;
        }
      void AddResidue(OBResidue *res) { SetResidue(res); }
      void DeleteResidue(){
        if (_residue) {
          delete _residue;
          _residue = NULL; // Make sure to clear that a residue existed
        }
      }
      void AddBond(OBBond *bond) { _vbond.push_back(bond); }
      void InsertBond(OBBondIterator &i, OBBond *bond)
        {
          _vbond.insert(i, bond);
        }
      bool DeleteBond(OBBond* bond);
      void ClearBond() {_vbond.clear();}



      bool HtoMethyl();
      bool SetHybAndGeom(int);


      unsigned int  CountFreeOxygens()      const;
      unsigned int  CountFreeSulfurs()      const;
      unsigned int  ExplicitHydrogenCount(bool ExcludeIsotopes=false) const;
      unsigned int  MemberOfRingCount()     const;
      unsigned int  MemberOfRingSize()    const;
      unsigned int  CountRingBonds() const;
      double      SmallestBondAngle();
      double      AverageBondAngle();
      std::pair<int, int> LewisAcidBaseCounts() const;
      bool HasResidue()    { return(_residue != NULL);    }
      bool IsHetAtom() {
        if (_residue == NULL)
          return false;
        else
          return _residue->IsHetAtom(this);
      }
      bool IsAromatic()      const;
      bool IsInRing()        const;
      bool IsInRingSize(int) const;
      bool IsHeteroatom();
      bool IsConnected(OBAtom*);
      bool IsOneThree(OBAtom*);
      bool IsOneFour(OBAtom*);
      bool IsCarboxylOxygen();
      bool IsPhosphateOxygen();
      bool IsSulfateOxygen();
      bool IsNitroOxygen();
      bool IsAmideNitrogen();
      bool IsPolarHydrogen();
      bool IsNonPolarHydrogen();
      bool IsAromaticNOxide();
      bool IsChiral();
      bool IsAxial();
      bool IsHbondAcceptor();
      bool IsHbondAcceptorSimple();
      bool IsHbondDonor();
      bool IsHbondDonorH();
      bool IsMetal();
      bool HasAlphaBetaUnsat(bool includePandS=true);
      bool HasBondOfOrder(unsigned int bo);
      int  CountBondsOfOrder(unsigned int bo);
      int  HighestBondOrder();
      bool HasNonSingleBond();
      bool HasSingleBond()    {        return(HasBondOfOrder(1));    }
      bool HasDoubleBond()    {        return(HasBondOfOrder(2));    }
      bool HasAromaticBond()  {        return(HasBondOfOrder(5));    }
      bool MatchesSMARTS(const char *);

    }; // class OBAtom

}// namespace OpenBabel

#endif   // OB_ATOM_H