Residue.h

/* Copyright 2004
Stanford University

This file is part of the DSR PDB Library.

The DSR PDB Library is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or (at your
option) any later version.

The DSR PDB Library 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 Lesser General Public
License for more details.

You should have received a copy of the GNU Lesser General Public License
along with the DSR PDB Library; see the file COPYING.LIB.  If not, write to
the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
MA 02111-1307, USA. */

#ifndef DSR_PDB_RESIDUE_H
#define DSR_PDB_RESIDUE_H

#include <dsrpdb/Point.h>
//#include <dsr/pdb/Protein.h>
#include <dsrpdb/Atom.h>
#include <vector>
#include <map>
#include <dsrpdb/small_map.h>
//#include <dsrpdb/label.h>

namespace dsrpdb {

  class Protein;


  class Residue {
    friend class Protein;
    struct Residue_type_tag{};
    struct Atom_type_tag{};
  public:
    typedef PDB_index<Residue> Index;

    enum Type { GLY=0, ALA, VAL, LEU, ILE,
                SER, THR, CYS, MET, PRO,
                ASP, ASN, GLU, GLN, LYS,
                ARG, HIS, PHE, TYR, TRP,
                ACE, NH2, INV };



    enum Atom_label {AL_OTHER, AL_INVALID,
                     AL_N, AL_H, AL_1H, AL_2H, AL_3H,
                     
                     
                     AL_CA, AL_HA, AL_1HA, AL_2HA,
                     
                     AL_CB, AL_HB, AL_1HB, AL_2HB, AL_3HB,
                     
                     AL_C, AL_O, AL_OXT, AL_CH3,

                     AL_CG, AL_CG1, AL_CG2, AL_HG, AL_1HG, AL_2HG, //AL_HG1, 
                     AL_1HG1, AL_2HG1, AL_3HG1, AL_1HG2,
                     
                     AL_2HG2, AL_3HG2, AL_OG, AL_OG1, AL_SG,
                     
                     // AL_HD1, AL_HD2,
                     AL_CD, AL_CD1, AL_CD2,  AL_HD, AL_1HD, AL_2HD, AL_3HD, AL_1HD1,
                     AL_2HD1, AL_3HD1, AL_1HD2, AL_2HD2, AL_3HD2, AL_SD,
                     AL_OD1, AL_OD2, AL_ND1, AL_ND2,
                     
                     AL_CE, AL_CE1, AL_CE2, AL_CE3, AL_HE, AL_1HE, AL_2HE,
                     AL_3HE, //AL_HE1, AL_HE2, AL_HE3, 
                     AL_1HE2, AL_2HE2,
                     AL_OE1, AL_OE2, AL_NE, AL_NE1, AL_NE2,
                     
                     AL_CZ, AL_CZ2, AL_CZ3, AL_NZ, AL_HZ, AL_1HZ, AL_2HZ,
                     AL_3HZ, // AL_HZ2, AL_HZ3,
                     
                     AL_CH2, AL_NH1, AL_NH2, AL_OH, AL_HH, AL_1HH1,
                     AL_2HH1, AL_HH2, AL_1HH2, AL_2HH2, 
                     AL_1HH3, AL_2HH3, AL_3HH3};




    typedef std::pair<Atom::Index,Atom::Index> Bond;

    typedef small_map<Atom_label, Atom> Atoms;

    Residue(){}

    Residue(Type al);

    Type type() const;


    typedef std::vector<Bond>::const_iterator Bonds_iterator;
 

    Bonds_iterator bonds_begin() const {
      return bonds_.begin();
    }
    Bonds_iterator bonds_end() const {
      return bonds_.end();
    }
    unsigned int number_of_bonds() const;


    typedef Atoms::iterator Atoms_iterator;

    Atoms_iterator atoms_begin() {
      return atoms_.begin();
    }

    Atoms_iterator atoms_end() {
      return atoms_.end();
    }

    typedef Atoms::const_iterator Const_atoms_iterator;

    Const_atoms_iterator atoms_begin() const {
      return atoms_.begin();
    }

    Const_atoms_iterator atoms_end() const {
      return atoms_.end();
    }



    unsigned int number_of_atoms() const;


    bool has_atom(Atom_label al) const;

    bool can_have_atom(Atom_label al) const;

    
    const Atom& atom(Atom_label al) const;

    Atom_label atom_label(Atom::Index model_index) const;


    void set_atom(Atom_label al, const Atom &a);

    void set_atom_from_string(const char *str, const Atom &a) {
      set_atom(atom_label(str), a);
    }
    Atom::Index last_atom_index() const;
   

    Index index() const {
      return index_;
    }

    void set_index(Index i);
    

    void dump(std::ostream &out) const;
    void write(char chain, std::ostream &out) const;
   
    


    Point sidechain_point() const;

    

    void set_has_bonds(bool tf);
    
    bool has_bonds() const {
      return !bonds_.empty();
    }


    //----- Static functions

    static Type type(const std::string &st);
    static std::string type_string(Type rl);

    static Atom::Type element(Atom_label al);

    static std::string atom_label_string(Atom_label al);

    static Atom_label atom_label(const char *c);

   


  protected:
    /*Residue( Label al, 
             std::vector<Residue::Atom_label> * atoms,
             std::vector<std::pair<Residue::Atom_label,
             Residue::Atom_label> > *bonds);*/
    Atom::Index index(Residue::Atom_label al) const;

    Atom::Index min_atom_index() const {
      return min_atom_index_;
    }

    Atoms_iterator atoms_iterator_from_index(Atom::Index ind);
    Const_atoms_iterator atoms_iterator_from_index(Atom::Index ind) const;
  private:

    /*--------------- Data members-----------------------------------*/
    Atoms atoms_;
    std::vector<Bond> bonds_;
    Type label_;
    Index index_;
    Atom::Index min_atom_index_;
  };
}
#endif