hamolecule.h

Go to the documentation of this file.

#ifndef HAMOLECULE_H
#define HAMOLECULE_H

#include "hastring.h"
#include "hastl.h"
#include "halinalg.h"
#include "gaufile.h"
#include "haatom.h"
#include "habond.h"
#include "haatgroup.h"
#include "object3d.h"
#include "command.h"

class HaAtom;
class HaBond;
class HaQCMod;
class HaMolView;

typedef list<HaAtom>                       AtomsType;
typedef set<HaBond, less<HaBond> >         BondsType;

#define SourceNone   0
#define SourcePDB    1
#define SourceCalc   2

enum ADD_ATOM_TYPE 
{                    
    ADD_ALL_ATOMS = 0x0,
    ADD_HYDROGENS = 0x1,
    ADD_POLAR_HYDROGENS = 0x2,
        ADD_HEAVY_ATOMS = 0x4 
};
                                  
#define FeatHelix    1
#define FeatSheet    2
#define FeatTurn     3


class FeatEntry
{
public:
        FeatEntry();
        virtual ~FeatEntry();

        int init, term;
        char chain;
        char type;

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

protected:
};

class AtomNode 
{
public:
        AtomNode() {}
        AtomNode(const AtomNode& ref_node); 
        virtual ~AtomNode() {}


        HaAtom* at; 
        HaAtom* ar; 
                    // if ar == NULL - the atom is missing
        
        int ntype;
        int nresolv_neib;
        vector<int> bonded_nodes; 

};

class AtomIteratorMolecule;
class BondIteratorMolecule;
class ResidueIteratorMolecule;

class HaMolecule: public Object3D, public AtomCollection
{
public:
    HaMolecule(HaMolSet* new_phost_mset, HaString new_name="HARLEMMOL");
        HaMolecule(const HaMolecule& Mol_ref);
    virtual ~HaMolecule();

//      typedef AtomIteratorMolecule AtomIterator; //!<  Atom iterator type for the molecule
        typedef BondIteratorMolecule BondIterator; 
        typedef ResidueIteratorMolecule ResidueIterator; 

        HaMolSet* GetHostMolSet() { return phost_mset; }
        const HaMolSet* GetHostMolSet() const { return phost_mset; }

        bool AddMolCopy(const HaMolecule& Mol_ref, bool create_new_chain = true, 
                             map<HaAtom*, HaAtom*, less<HaAtom*> > *ptr_atom_map = NULL);

        static int AttachFragment( HaAtom* catom_host, HaAtom* catom_frag );
        int CombineMolecules(HaMolecule* frag_mol, HaAtom* catom_host, HaAtom* catom_frag );
        

protected:
        HaMolSet* phost_mset;

public:

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


        virtual bool SetObjName(const char* new_name);
        
        virtual int RotateObj( const HaMat_double& rot_mat, const Vec3D& cnt ); 

        virtual int Translate( const Vec3D& tr_vec ); 

        int GetStdPosition(HaMat_double& rot_std, Vec3D& trans_std); 
    int SetPosition(const HaMat_double& rot_new, const Vec3D& trans_new);    
    int SetPosEulerTrans(double phi, double cos_theta, double psi, const Vec3D& trans);  
    void GetPosEulerTrans( double& phi, double& cos_theta, double& psi, Vec3D& trans); 

        int SetIntCoordFromStr(const char* int_crd_str); 



        int SetAtomScreenCoord(HaMolView* pview);
        
        bool SetUniqueAtomNames();


    bool InitAtomsGRWF();                
        bool InitAtoms(GauFile& gfile);      
        
        static bool SetCoordSubstH(const HaAtom* aptr1, const HaAtom* aptr2, HaAtom* haptr);
                                              

        HaAtom* AddAtomFromTempl( HaAtom* aptr2, HaAtom* aptr3, HaAtom* aptr4, 
                                     const HaAtom* aptr_templ, const HaAtom* aptr_templ_2, const HaAtom* aptr_templ_3, 
                                                         const HaAtom* aptr_templ_4); 

        int GetSeqNumOfAtom(const HaAtom* aptr) const;        
    HaAtom* GetAtomBySeqNum(const int index);             
    const HaAtom* GetAtomBySeqNum(const int index) const; 

        HaAtom* GetAtomByRef(const char* at_ref);             

// virtual of AtomCollection

    virtual int GetNAtoms() const;                   
    virtual int IsMember(const HaAtom* aptr) const;  
        virtual AtomIterator* GetAtomIterator();         

// Bonds Related functions:

public:
        int GetNBonds()  const;   
        int GetNHBonds() const;   
        int GetNSSBonds() const;  

        int AreHBonded(HaAtom* src, HaAtom* dst) const; 

    void CalcHydrogenBonds();  

        bool AreHBondsFound() const  { return HBonds_found; }  
        bool AreSSBondsFound() const { return SSBonds_found; } 

        void CreateMoleculeBonds();

        HaBond*  AddBond(HaAtom* src, HaAtom* dst,int flag ); 
        HaHBond* AddHBond(HaAtom* src, HaAtom* dst);  
        HaHBond* AddSSBond(HaAtom* src, HaAtom* dst); 
    bool DeleteBond(HaAtom* src, HaAtom* dst);

        int AddAllMissingAtoms(ADD_ATOM_TYPE atom_type);   
        int AddMissingAtoms(HaResidue* pres,ADD_ATOM_TYPE atom_type); 
        int AddWaterHydrogens(HaResidue* pres); 

protected:
        int AddMissingAtoms_2(HaResidue* pres, HaResidue* prtempl, ADD_ATOM_TYPE atom_type);


        vector<AtomNode> nodes;
public:
    void BondIfClose(HaAtom* sptr, HaAtom* dptr); 

    void CreateHydrogenBond(HaAtom* src, HaAtom* dst,
                                                        int energy, int offset );

        void CalcNucleicHBonds(HaChain* chn1 );
        void CalcProteinHBonds(HaChain* chn1 );
        int  CalculateBondEnergy(HaResidue* group );
    void TestDisulphideBridge(HaResidue*  group1,HaResidue* group2, HaAtom* cys1 );

        int SetTermResNames(); 
    int SetCysBridgeNames(); 

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

// Residues Related Functions:

        HaResidue* CreateMolResidue(); 
        int GetNRes() const;     

        HaResidue* GetResByRef(const HaString& res_str); 

// Chain Related functions      
        int GetNChains() { return Chains.size(); } 
        HaChain* AddChain(char ident); 

        HaChain* GetFirstChain(); 
        HaChain* GetNextChain();  

        HaChain* GetChain(const char chain_id ); 

// overridables of PointCollection:

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

        bool FixChainsIdent(); 

// Secondary Structure manipulation functions:
public:
        void DescribeMolecule();
        void DetermineStructure(int flag); 
        void FindDisulphideBridges();      

        void Renumber(int start );
        void DescribeSequence();

        static int SeqFormat; 
        
        FeatEntry* AddFeature();
        int GetNumFeatures(const int itype) const;
        void UpdateFeature(FeatEntry* ptr, int mask);
        void ProcessFeatures();
        
        bool IsSecStructFound() { return sec_struct_found; }
        bool sec_struct_found;  

        int structsource;  
        
        list<FeatEntry> Features;
        
protected:
        void FindAlphaHelix( int pitch, int flag );
        void FindTurnStructure();
        void FindBetaTurns();
    void FindBetaSheets();
        void TestLadder(list<HaChain>::iterator chain_ref,HaResidue* prevri,HaResidue* curri, HaResidue* nexti);

public:

        bool GetMinMaxCrd(double& MinX_v, double& MinY_v, double& MinZ_v,
                                      double& MaxX_v, double& MaxY_v, double& MaxZ_v);

        bool GetAverageCoord(double& avx, double& avy, double& avz); 

        bool GetStdRotMat(HaMat_double& rot_mat);


// Molecule data:

public:
        list<HaChain> Chains;      
        set<HaHBond, less<HaHBond> > HBonds;      
        set<HaHBond, less<HaHBond> > SSBonds;     
        set<HaBond, less<HaBond> >   Bonds;  
        
        list<HaAtom> Atoms;        

        bool SSBonds_found;



public:
        bool HBonds_found; 

// Electronic wave function classes
public:
        
        HaString classification;
        HaString identcode;


protected:

// Auxiliary static pointers for common loops over molecular structural elements

public:
        HaResidue* CurResidue;       
        HaChain*   CurChain;         
protected:
        
        list<HaChain>::iterator CurChainItr;

// Internal Coordinate Manipulation Related Functions:
protected:

};


class AtomIteratorMolecule: public AtomIterator
{
public:

        AtomIteratorMolecule(HaMolecule* new_pMol);
        virtual ~AtomIteratorMolecule();
        
        virtual HaAtom* GetFirstAtom(); 
        virtual HaAtom* GetNextAtom();  
        
// Overrides of PointIterator: 

        virtual Vec3D* GetFirstPt() { return GetFirstAtom(); }
        virtual Vec3D* GetNextPt()  { return GetNextAtom(); }

protected:
        list<HaAtom>::iterator aitrm;
        
        HaMolecule* pMol;
};

class BondIteratorMolecule
{
public:
        BondIteratorMolecule(HaMolecule* new_pMol);
        virtual ~BondIteratorMolecule();
        
        HaBond* GetFirstBond(); 
        HaBond* GetNextBond();  
        
protected:
        set<HaBond>::iterator bitrm;
        
        HaMolecule* pMol;
};

class ResidueIteratorMolecule
{
public:
        ResidueIteratorMolecule(HaMolecule* new_pmol);
        virtual ~ResidueIteratorMolecule();
        
        HaResidue* GetFirstRes(); 
        HaResidue* GetNextRes();  
        
protected:
        Residues_type::iterator res_itr;
        list<HaChain>::iterator ch_itr;
        
        HaMolecule* pmol;
};


const int START_TERM_ATOM_ID=50000;


/*=================*/
/*  Database Flags */
/*=================*/

const int SelectFlag   =  0x01;
const int DrawBondFlag =  0x0e;
const int AllAtomFlag  =  0x1c;
const int HelixFlag    =  0x03;
const int DrawKnotFlag =  0x7e;
const int WideKnotFlag =  0x0e;


/* Bond Flags */
const int WireFlag     =   0x02;     
const int DashFlag     =   0x04;     
const int CylinderFlag =   0x08;     

const int HydrBondFlag  =  0x00;     
const int NormBondFlag  =  0x10;
const int DoubBondFlag  =  0x20;
const int TripBondFlag  =  0x40;
const int AromBondFlag  =  0x80;


/* Group Flags */
const int CystineFlag    = 0x01;     
const int StrandFlag     = 0x02;     
const int DashStrandFlag = 0x04;     
const int RibbonFlag     = 0x08;     
const int TraceFlag      = 0x10;     
const int CartoonFlag    = 0x20;     
const int DotsFlag       = 0x40;     

/* Structure Flags */
const int Helix3Flag  =    0x01;     
const int Helix4Flag  =    0x02;     
const int Helix5Flag  =    0x03;     
const int SheetFlag   =    0x04;     
const int TurnFlag    =    0x08;     

/*========================*/
/* Other Consts & Structs */
/*========================*/

#define SerNoFlag 0x01
#define ResNoFlag 0x02


// Macros for common loops

#define ForEachChain_HAMOL  for(chain=GetFirstChain();chain;chain=GetNextChain())
#define ForEachResidue_HAMOL  for(chain=GetFirstChain();chain;chain=GetNextChain()) \
                                  for( group=chain->GetFirstRes(); group; group=chain->GetNextRes() )
#define ForEachBack_HAMOL  for(chain=GetFirstChain();chain;chain=GetNextChain()) \
                                   for(bptr=chain->GetFirstBackB();bptr;bptr=chain->GetNextBackB())


#endif /* !HAMOLECULE_H */

---