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