haatgroup.h

Go to the documentation of this file.

#ifndef HAATGROUP_H
#define HAATGROUP_H

#include "haio.h"
#include "haatom.h"
#include "habond.h"
#include "halinalg.h"

class Expr;

class AtomIterator : public PointIterator
{
public:

        virtual HaAtom* GetFirstAtom() = 0; 
        virtual HaAtom* GetNextAtom() = 0;  
        
};

class AtomCollection: public PointCollection
{
public:
    virtual AtomIterator* GetAtomIterator() = 0; 
        virtual int GetNAtoms() const = 0;   

        virtual int IsMember(const HaAtom* aptr) const = 0;  
};

class AtomListIterator : public AtomIterator
{
public:
        AtomListIterator(AtomList* new_atlist);
        virtual ~AtomListIterator();
        
        HaAtom* GetFirstAtom(); 
        HaAtom* GetNextAtom();  
        
        Vec3D* GetFirstPt() { return GetFirstAtom(); }
        Vec3D* GetNextPt()  { return GetNextAtom(); }

protected:
        list<HaAtom*>::iterator aitrm; 
        
        AtomList* atlist;
};

class AtomList : public list<HaAtom*>, public AtomCollection
{       
public:
        AtomList() {}
        AtomList(const AtomList& ref_atset);
        AtomList(Expr* expr, HaMolSet* pmset);
        virtual ~AtomList();

        list<HaAtom*>::iterator CurAtomItr;

        virtual AtomIterator* GetAtomIterator() { return new AtomListIterator(this); }
        virtual int GetNAtoms() const { return size(); } 

//    typedef AtomListIterator AtomIterator;    

        bool InsertAtom(HaAtom* aptr); 
        bool DeleteAtom(HaAtom* aptr); 
        int DelSelAtoms(); 
 
        void BuildFrom(Expr* expr, HaMolSet* pmset );  
        virtual int IsMember(const HaAtom* aptr) const;       

        HaAtom* GetFirstAtom();
        HaAtom* GetNextAtom();

    const char* GetID() const;           
        void SetID(const HaString& new_id);  

        HaString id;

// Overidable of PointCollection:

    virtual PointIterator* GetPointIterator(); 
        virtual int GetPtNum() { return size(); }

protected:
        
};

class HaMolSet;

// Beware AddAtom is defined in winbase.h (WIN32)!!

class ChemGroup : public AtomList
{
public:
  ChemGroup();
  ChemGroup(HaMolSet* new_phost_mset, const char* new_id= "" );
  virtual ~ChemGroup();
          
  bool FillRef(char* buf) const; 

  double GetProtect() const;    
  bool SetProtect(const double new_protect);
  
  friend class HaMolSet;
 
  static HaString GetIDFromRef(const HaString& buf);

  bool Print_info(ostream &sout, const int level) const;

protected:

   HaMolSet* phost_mset;

   double protect; // screening factor of the group in the fragment
                  // from 0 to 1;  1.0 - non-perturbed group  
};

class HaChain;

// enum ResCodes {R_ALA=0, R_GLY, R_LEU, R_SER, R_VAL, R_THR, 
//                         R_LYS, R_ASP, R_ILE, R_ASN, R_GLU, 
//                                             R_PRO, R_ARG, R_PHE, R_GLN, R_TYR,
//                                  R_HIS, R_CYS, R_MET, R_TRP};

class HaResidue;

class AltChemState
{
public:
        AltChemState();
    AltChemState(AtomList* new_host_atom_set);
        AltChemState(const AltChemState& ref_state);
        virtual ~AltChemState();


        enum CHEM_STATE_TYPE { PROTONATED = 0, UNPROTONATED = 1, REDUCED = 2, OXIDIZED = 3 }; 

        AtomList* GetHostAtomList() { return host_atom_list; }
        void SetStdParam();       

        HaString   id;            
        StrDoubleMap chmap;       
        HaString mod_atom_name;   
        int      alt_state_type;  
    double   pk;              
        double   std_pk;          
        int      inactive_flag;   
        
        AtomList* host_atom_list;  
};


typedef AtomListIterator AtomIteratorResidue;

class HaResidue : public AtomList
{
public:
        HaResidue();
        HaResidue(const HaResidue& ref_res);
        HaResidue(HaChain* new_phost_ch);
        virtual ~HaResidue();
        
        bool SetParamFrom(const HaResidue& res_ref); 

        bool operator==(const HaResidue & rhs) const;
        bool operator< (const HaResidue & rhs) const;
        
        HaAtom* AddNewAtom(); 

        HaAtom* GetAtomByName(const char* atname);    
        const HaAtom* GetAtomByName(const char* atname) const;   
         
        HaChain* GetHostChain() { return phost_ch; } 
        bool SetHostChain(HaChain* new_phost) { phost_ch=new_phost; return true;} 
        HaMolecule* GetHostMol();  
        const HaMolecule* GetHostMol() const;  

        HaResidue* GetNextResInChain();   
        HaResidue* GetPrevResInChain();   

        bool IsBonded(HaResidue* res2) ; 
        int HasBackBHBond(HaResidue* res2); 

        const char* GetName() const;  
        int SetName(const char* ptr, int max_len=0); 
        void SetNameModifier( const char* new_name_mod) { NameModifier = new_name_mod; } 
    
        const char* GetNameModifier() { return NameModifier.c_str(); }  
        HaString GetFullName() const; 

        static HaString GetResNameFromFullName(const char* res_full_name); 

        HaString GetRef() const;  
        virtual bool FillRef(char* buf,int mode = 0) const; 

    int Selected(); 

        bool SetUniqueAtomNames();               
        HaString GetUniqueAtomName(int elem_no); 
        bool SplitResidue();

        int SetStdPK();    
        int SetStdPK_G1(); 
    
        bool SetStdPKforAtName(const char* at_name, double std_pk_new); 

    void PrintPK() const; 

        int GetNumAltStates() const;   
        AltChemState* GetAltChemState(int alt_state_idx); 
        AltChemState* GetAltChemStateByAtName(const char* at_name); 
    int SetStdCharges();     
        int SetAltCharges(AltChemState* alt_res_st, double weight=1.0); 
        int InterpolResParams(const char* res_name_1, const char* res_name_2, double weight_1); 

        HaResidue* GetTemplate(); 
        int CheckStruct(); 

    bool SetChargesForPH( double pH_val); 

        int GetSerNo() const { return serno; }  

        static const char* GetResNameInTable(const int j); 
// Structure definition functions:

        bool IsAmino()       const;  
        bool IsAminoNucleo() const;
        bool IsNucleo()      const;
        bool IsProtein()     const; 
        bool IsDNA()         const;
        bool IsSolvent()     const;
        bool IsWater()       const;
        bool IsIon()         const;
        bool IsPyrimidine()  const;
        bool IsPurine()      const;
        bool IsRNA()         const;
        bool IsProline()     const;
        bool IsHistidine()   const;
        bool IsCysteine()    const;
        bool IsAdenine()     const;
        bool IsCytosine()    const;
        bool IsGuanine()     const;
        bool IsThymine()     const;
        bool IsCoenzyme()    const;
        bool IsTerm()        const;

        int CalcStdCrdSys(int fit_std_geom = FALSE); 

// Geometry Calculations:

static double CalcPhiAngle(const HaResidue* prev, const HaResidue* curr);
static double CalcPsiAngle(const HaResidue* curr, const HaResidue* next );
        
        HaChain*  phost_ch;          
        short serno;                 
        double width;                
        short col1;                  
        short col2;                  
        char  insert;                
        int   refno;                 
        Byte  struc;                 
        Byte  flag;                  

        HaString NameModifier;       

    vector<AltChemState> alt_res_states; 
    Vec3D_arr std_crd_sys;       

        static StrVec ResNames; 

        static int init_res_names_flag; 
        static StrStrMap ResSynonym;  
        static int InitStdResNames(); 
        static int InitResSynonym();  

protected:
        void ResetData();
        
};

typedef list<HaBond>::iterator Bond_itr;
typedef set<HaResidue, less<HaResidue> > Residues_type;

class HaChain
{
public:
  HaChain();
  HaChain(HaMolecule* new_phost_mol, const char new_ident=' ');

  virtual ~HaChain();

  bool SetParamFrom(const HaChain& chain_ref); 
  
  HaResidue* AddResidue(const int res_ser_no);  
  int GetUniqResSerNo(const int term_res_flag=0) const; 

  bool SetUniqueResNo();  

  HaResidue* GetFirstRes();   
  HaResidue* GetNextRes();    

  HaResidue* GetResBySerNo(const int res_ser_no); 

  int GetNRes() const { return Residues.size(); }  

  HaBond*    AddBackB(HaAtom* src, HaAtom* dst,int flag); 

  HaBond*    GetFirstBackB(); 
  HaBond*    GetNextBackB();  

  bool operator==(const HaChain & rhs) const;
  bool operator< (const HaChain & rhs) const;

// RASMOL Chain structure parameters
   
  char ident;                      
 
  set<HaResidue, less<HaResidue> >  Residues;    
  list<HaBond>    BackBoneList;                  

  HaMolecule* GetHostMol() { return phost_mol; }  
  const HaMolecule* GetHostMol() const { return (const HaMolecule*) phost_mol; } 
  void SetMolHost(HaMolecule* new_phost_mol) { phost_mol=new_phost_mol; }

protected:
  
  void SetDefaultParam();

  HaMolecule* phost_mol; 

  set<HaResidue, less<HaResidue> >::iterator CurResItr;
  list<HaBond>::iterator CurBackBoneItr;

  
};

class Partition : public vector< AtomList >
{
public:
        Partition();
        
        int SetDimensions(double xmin_new, double ymin_new, double zmin_new, 
                              double xmax_new, double ymax_new, double zmax_new);

        int Reset() { clear(); resize(VOXSIZE); return True;}

        double xmin; 
        double ymin;
        double zmin;

        double dx;
        double dy;
        double dz;

        int VOXORDER;
        int VOXORDER2;
        int VOXSIZE;

        int GetIdx_x( double x_coord );
        int GetIdx_y( double y_coord );
        int GetIdx_z( double z_coord );

        int ixrad; 
        int iyrad;
        int izrad;

        int SetIncludeRad(double dist);
        int GetNeighbors(Vec3D& pt, AtomList& neighbors);

};

#endif /* !HAATGROUP_H */

---