residue.h

Go to the documentation of this file.

/**********************************************************************
residue.h - Defines for residue properties, names, etc.

Copyright (C) 2001, 2002 OpenEye Scientific Software, Inc.
Some portions Copyright (C) 2001-2006 by Geoffrey R. Hutchison

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.
***********************************************************************/

/**********************************************************************
Global arrays Residue, ElemDesc and function GetResidueNumber were
obtained in part or whole from RasMol2 by Roger Sayle.
***********************************************************************/

#ifndef OB_RESIDUE_H
#define OB_RESIDUE_H

#include <openbabel/babelconfig.h>

#ifndef EXTERN
# define EXTERN extern
#endif

#include <vector>
#include <string>

#include <openbabel/base.h>

namespace OpenBabel {

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

 // Class OBResidue
 // class introduction in residue.cpp
 class OBAPI OBResidue : public OBBase
 {
 public:

 OBResidue(void);
 OBResidue(const OBResidue &);
 virtual ~OBResidue(void);

 OBResidue &operator=(const OBResidue &);

 void AddAtom(OBAtom *atom);
 void InsertAtom(OBAtom *atom);
 void RemoveAtom(OBAtom *atom);
 bool Clear();

 void SetName(const std::string &resname);
 void SetNum(const unsigned int resnum);
 void SetNum(const std::string resnum);
 void SetChain(const char chain);
 void SetChainNum(const unsigned int chainnum);
 void SetIdx(const unsigned int idx);
 void SetInsertionCode(const char insertioncode);

 void SetAtomID(OBAtom *atom, const std::string &id);
 void SetHetAtom(OBAtom *atom, bool hetatm);
 void SetSerialNum(OBAtom *atom, unsigned int sernum);

 std::string GetName(void) const;
 int GetNum(void);
 std::string GetNumString(void);
 unsigned int GetNumAtoms() const;
 char GetChain(void) const;
 unsigned int GetChainNum(void) const;
 unsigned int GetIdx(void) const;
 unsigned int GetResKey(void) const;

 std::vector<OBAtom*> GetAtoms(void) const;
 std::vector<OBBond*> GetBonds(bool exterior= true)const;

 std::string GetAtomID(OBAtom *atom) const;
 unsigned GetSerialNum(OBAtom *atom) const;
 char GetInsertionCode(void) const;

 bool GetAminoAcidProperty(int) const;
 bool GetAtomProperty(OBAtom *a, int) const;
 bool GetResidueProperty(int) const;

 bool IsHetAtom(OBAtom *atom) const;
 bool IsResidueType(int) const;


 OBAtomIterator BeginAtoms() { return _atoms.begin(); }
 OBAtomIterator EndAtoms() { return _atoms.end(); }
 OBAtom *BeginAtom(std::vector<OBAtom*>::iterator &i);
 OBAtom *NextAtom(std::vector<OBAtom*>::iterator &i);

 protected: // members

 unsigned int _idx; 
 char _chain; 
 unsigned int _aakey; 
 unsigned int _reskey;
 std::string _resnum;
 std::string _resname;
 char _insertioncode;

 std::vector<bool> _hetatm;
 std::vector<std::string> _atomid;
 std::vector<OBAtom*> _atoms; 
 std::vector<unsigned int> _sernum;
 // Now in OBBase
 // std::vector<OBGenericData*> _vdata; //!< Custom data
 }; // OBResidue


 // Global Definitions

#define MAXSETNO 40
#define MAXELEM 29
#define MAXRES 54

 // Amino Acid Definitions

#define AA_ALA (1<<1)
#define AA_GLY (1<<2)
#define AA_LEU (1<<3)
#define AA_SER (1<<4)
#define AA_VAL (1<<5)
#define AA_THR (1<<6)
#define AA_LYS (1<<7)
#define AA_ASP (1<<8)
#define AA_ILE (1<<9)
#define AA_ASN (1<<10)
#define AA_GLU (1<<11)
#define AA_PRO (1<<12)
#define AA_ARG (1<<13)
#define AA_PHE (1<<14)
#define AA_GLN (1<<15)
#define AA_TYR (1<<16)
#define AA_HIS (1<<17)
#define AA_CYS (1<<18)
#define AA_MET (1<<19)
#define AA_TRP (1<<20)

 // Amino Acid Property Definitions
#define IS_ACIDIC(x) ((x) & ((AA_ASP)|(AA_GLU)))
#define IS_ACYCLIC(x) ((x) & ((AA_ALA)|(AA_GLY)|(AA_LEU)|(AA_SER)| \
 (AA_VAL)|(AA_THR)|(AA_LYS)|(AA_ASP)| \
 (AA_ILE)|(AA_ASN)|(AA_GLU)|(AA_GLN)| \
 (AA_CYS)|(AA_MET)))
#define IS_ALIPHATIC(x) ((x) & ((AA_ALA)|(AA_GLY)|(AA_ILE)|(AA_LEU)| \
 (AA_VAL)))
#define IS_AROMATIC(x) ((x) & ((AA_HIS)|(AA_PHE)|(AA_TRP)|(AA_TYR)))
#define IS_BASIC(x) ((x) & ((AA_ARG)|(AA_HIS)|(AA_LYS)))
#define IS_BURIED(x) ((x) & ((AA_ALA)|(AA_CYS)|(AA_ILE)|(AA_LEU)| \
 (AA_MET)|(AA_PHE)|(AA_TRP)|(AA_VAL)))
#define IS_CHARGED(x) ((x) & ((AA_ASP)|(AA_GLU)|(AA_ARG)|(AA_HIS)| \
 (AA_LYS)))
#define IS_CYCLIC(x) ((x) & ((AA_HIS)|(AA_PHE)|(AA_PRO)|(AA_TRP)| \
 (AA_TYR)))
#define IS_HYDROPHOBIC(x) ((x) & ((AA_ALA)|(AA_LEU)|(AA_VAL)|(AA_ILE)| \
 (AA_PRO)|(AA_PHE)|(AA_MET)|(AA_TRP)))
#define IS_LARGE(x) ((x) & ((AA_ARG)|(AA_PHE)|(AA_GLN)|(AA_TYR)| \
 (AA_HIS)|(AA_LEU)|(AA_LYS)|(AA_ILE)| \
 (AA_GLU)|(AA_MET)|(AA_TRP)))
#define IS_MEDIUM(x) ((x) & ((AA_VAL)|(AA_THR)|(AA_ASP)|(AA_ASN)| \
 (AA_PRO)|(AA_CYS)))
#define IS_NEGATIVE(x) ((x) & ((AA_ASP)|(AA_GLU)))
#define IS_NEUTRAL(x) ((x) & ((AA_ALA)|(AA_GLY)|(AA_LEU)|(AA_SER)| \
 (AA_VAL)|(AA_THR)|(AA_PHE)|(AA_GLN)| \
 (AA_TYR)|(AA_HIS)|(AA_CYS)|(AA_MET)| \
 (AA_TRP)|(AA_ILE)|(AA_ASN)|(AA_PRO)))
#define IS_POLAR(x) ((x) & ((AA_ASP)|(AA_ILE)|(AA_ASN)|(AA_GLU)| \
 (AA_SER)|(AA_THR)|(AA_ARG)|(AA_GLN)| \
 (AA_CYS)|(AA_HIS)))
#define IS_POSITIVE(x) ((x) & ((AA_ARG)|(AA_HIS)|(AA_LYS)))
#define IS_SMALL(x) ((x) & ((AA_ALA)|(AA_GLY)|(AA_SER)))
#define IS_SURFACE(x) ((x) & ((AA_THR)|(AA_LYS)|(AA_ASP)|(AA_ILE)| \
 (AA_ASN)|(AA_GLU)|(AA_PRO)|(AA_ARG)| \
 (AA_GLY)|(AA_SER)|(AA_GLN)|(AA_TYR)| \
 (AA_HIS)))

 namespace OBAminoAcidProperty
 {
 enum
 {
 ACIDIC = 0,
 ACYCLIC = 1,
 ALIPHATIC = 2,
 AROMATIC = 3,
 BASIC = 4,
 BURIED = 5,
 CHARGED = 6,
 CYCLIC = 7,
 HYDROPHOBIC = 8,
 LARGE = 9,
 MEDIUM = 10,
 NEGATIVE = 11,
 NEUTRAL = 12,
 POLAR = 13,
 POSITIVE = 14,
 SMALL = 15,
 SURFACE = 16
 };
 }

 namespace OBResidueAtomProperty
 {
 enum
 {
 ALPHA_CARBON = 0,
 AMINO_BACKBONE = 1,
 BACKBONE = 2,
 CYSTEINE_SULPHUR = 3,
 LIGAND = 4,
 NUCLEIC_BACKBONE = 5,
 SHAPELY_BACKBONE = 6,
 SHAPELY_SPECIAL = 7,
 SIDECHAIN = 8,
 SUGAR_PHOSPHATE = 9
 };
 }

 // some of these are invalid or troublesome in scripting interfaces
 // so they are removed by the #ifndef SWIG parts
 // (otherwise ignore them for C++ use)
 namespace OBResidueIndex
 {
 enum
 {
 ALA = 0,
 GLY = 1,
 LEU = 2,
 SER = 3,
 VAL = 4,
#ifndef SWIGPERL
 THR = 5,
#endif
 LYS = 6,
 ASP = 7,
 ILE = 8,
 ASN = 9,
 GLU = 10,
 PRO = 11,
 ARG = 12,
 PHE = 13,
 GLN = 14,
 TYR = 15,
 HIS = 16,
 CYS = 17,
 MET = 18,
 TRP = 19,
 ASX = 20,
 GLX = 21,
 PCA = 22,
 HYP = 23,
 A = 24,
 C = 25,
 G = 26,
 T = 27,
 U = 28,
 UPLUS = 29,
 I = 30,
 _1MA = 32,
 _5MC = 32,
 OMC = 33,
 _1MG = 34,
 _2MG = 35,
 M2G = 36,
 _7MG = 37,
 OMG = 38,
 YG = 39,
 H2U = 40,
 _5MU = 41,
 PSU = 42,
 UNK = 43,
 ACE = 44,
 FOR = 45,
 HOH = 46,
 DOD = 47,
 SO4 = 48,
 PO4 = 49,
 NAD = 50,
 COA = 51,
 NAP = 52,
 NDP = 53
 };
 }

 namespace OBResidueProperty
 {
 enum
 {
 AMINO = 0,
 AMINO_NUCLEO = 1,
 COENZYME = 2,
 ION = 3,
 NUCLEO = 4,
 PROTEIN = 5,
 PURINE = 6,
 PYRIMIDINE = 7,
 SOLVENT = 8,
 WATER = 9
 };
 }

} // end namespace OpenBabel

#endif