etcoupl.h

Go to the documentation of this file.

#ifndef ETCOUPL_H
#define ETCOUPL_H

#include "hastl.h"
#include "abstree.h" 
#include "halocorb.h"
#include "command.h"
#include "hacompmod.h"
#include "hamatdb.h"

class HaQCMod;
class HaMolecule;
class HaMolSet;
class HaAtom;
class HaMat_double;


class ETNode;

class ETEdge
{
public:
        ETEdge();
        ETEdge(int new_inode1, int new_inode2);
        ~ETEdge() { }

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

        double coupling; // value of the log coupling for the connection
        double dist; // distance in ang

        int inode1;  // indexes of nodes in the vector of node ETCoupl
        int inode2;

protected:
        void SetDefaultParam();
};


class ETNode
{
public:
        ETNode();
        ETNode(HaAtom* new_pAtHost);
        virtual ~ETNode() { }

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



        list<ETEdge> edges;

        int set_edges_flag;
        HaAtom* GetHost() { return pAtHost; }

        friend class ETEdge; 
        friend class ETCoupl;

        double GetX() const; 
        double GetY() const;
        double GetZ() const;

protected:
        HaAtom* pAtHost;
        void SetDefaultParam();

};

class ETPath
{
public:
        ETPath();
        virtual ~ETPath() { }

        bool clear();
        bool empty() { return trace.empty(); }

        double coupling; // coupiling value
        list<int> trace; // list of node indexes of the best path

};

class PathStep
{
public: 
        PathStep();
        PathStep(double new_coupling, int new_destination, int new_source);
        virtual ~PathStep();
        
        bool operator == (const PathStep & rhs) const;
        bool operator < (const PathStep & rhs) const;

        double coupling;     
        int destination;     
        int source;          

};

const int BEST_PATH = 0, COUPL_MAP = 1; 
const int HAM_S_DIP_TR = 0, HAM_TR = 1; 

class ETCoupl: public HaCompMod
{
        friend class ETEffHamDlg;
public:

        ETCoupl(HaMolSet* new_phost_mset = NULL);
        ~ETCoupl();

        HaQCMod* GetQCMod() { return ptr_qc_mod; }  

// Virtuals of HaCompMod:

        virtual void SetDebugLevel(int new_debug_level);
        virtual int OnDelAtoms(AtomCollection& del_atoms);  

        bool clear(); 

        bool path_coupl_calc(); 
        bool select_important(double thresh); 


        bool calc_intermol_path_coupl(); 
        
        bool InitiateNodes();                   
        bool SetEdges(int inode);               
        bool set_dir_path_coupl(ETEdge& edge);  
        
        int GetCalcType() { return calc_type; }
        void SetCalcType(const int new_calc_type) { calc_type = new_calc_type; }

        bool DuttonModelCalc(); 

        bool CalcGFLocOrb();     
        bool CalcGFLocOrbHeff(); 
    int  PrintOvlpElem();    
        int  PrintHeffElem();    

    bool SetDAdipoleMat();                   
        double GetDAfield() { return DA_field; } 
        bool SetDAfield(double field);           
        bool FindMinSplit(double& min_field, double& min_split); 

        bool CreateEigVecContour(int idx, double flvl, int grid_size); 
        bool PrintEigVecCoef(int idx);       
        bool ScanEigEneField(int first_eig_val, int last_eig_val, double ifield_val, double ffield_val, 
                                                 double step_val); 

        double calc_edge_dist(); 

        vector<ETNode> nodes; 

        bool nodes_init_flag; 

        static int m_hbond_paths_flag;

        vector<PathStep> best_path; 
        vector<PathStep> coupl_map; 
                
    double GetTunEne() const;                   
    void SetTunEne(const double new_tun_ene);   

        bool PutSubMatToDB();           
        bool GetSubMatFromDB();         

        bool CalcHDAfromGF();             
        bool SetDAOrbFromEig();           
        bool CalcHDAPert(double& hda_coupl);  

        double GetDAsplit() const; 

        bool SetDACoef1();
        bool PrintProtectMat() const; 

        bool RecalcHeff(); 
        bool DiagHeff();   
        int ZeroLongInter(double cutoff); 
        
        int ham_trunc_type; 

    HaMat_double heff_mat; 
        HaMat_double ssl;      
        HaMat_double cmol;     
        HaVec_double enel;     

        HaMat_double don_acc_vec;  
        HaMat_double extern_field; 
        HaMat_double protect_mat;  



        HaMat_double DA_dipole; 


        double DA_field;  

        HaString db_file_name;  
        int ida_eig_1;          
        int ida_eig_2;          
        Operator_Type oper_type;

        bool donor_orb_set;       
    bool acceptor_orb_set;    

        int  set_da_orb_from_eig;  
        int  set_dab_huck_inter;  

// PATHWAYS model parameters:
    double pw_nb_decay;     
        double pw_nb_min_dist;  
        double pw_hb_decay;     
        double pw_hb_min_dist;  
        double pw_ln_cov_decay; 

        double best_path_coupl; 
        int log_calc_result;    
    
    double pw_nb_decay_intermol; 
        double nb_dist_limit;    
        double tun_ene;          

        int calc_type;  

        vector<const HaLocOrb*> src_orbitals;
        vector<const HaLocOrb*> tgt_orbitals;

    int rebuild_mol_coupl_map;

        PtrDoubleMap mol1_coupl_map;
        PtrDoubleMap mol2_coupl_map;


protected:

    HaQCMod*  ptr_qc_mod;

};


#endif /* !ETCOUPL_H */

---