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