nuclacidmod.h

Go to the documentation of this file.

#if !defined(NUCLACIDMOD_H) 
#define NUCLACIDMOD_H

#include "hastl.h"
#include "haconst.h"
#include "halinalg.h"
#include "hastring.h"
#include "hacompmod.h"
#include "vec3d.h"

const int FLEX_FF    = 0;
const int AMBER91_FF = 1;
const int AMBER94_FF = 2;


class HaMolecule;

class NuclAcidMod : public HaCompMod
{
public:
         NuclAcidMod(HaMolSet* new_pmset=NULL);
        ~NuclAcidMod();

        int SetStdParams();     

        int BuildNuclAcid();       
        int UpdateXYZ();           
        int MinEne();              
        int CalcEne();             
        int CreateMolFromJumna();  

        HaMolecule* FindDNAMol();  

        int SaveAXEfile(const char* axe_file); 
        int ReadAXEfile(const char* axe_file); 

        HaString out_prefix; 
    HaString pdb_prefix; 

        HaVec_int nsym_unit; 

        int nbreak_1;  
        int nbreak_2;  

    HaVec_int homon_symm_flags; 
        HaVec_int homon_symm_offs;  
        int ene_per_unit_flag;      

        HaVec_int dir_strand;       

        HaString seq[4];                 
        int SetSeq(const char* seq_str); 
    int GenComplStrand();            

    int max_iter;                    

        int init_flag;      

        double sup_helix_rad;        
        double sup_helix_pit;        
        double fst_twist;            

        int SetFFtype(const char* new_ff_type); 
        int SetFFtypeIdx(const int i_ff_type);  
    int force_field;             

        int SetDielSlope( double slope_new);    
        double diel_slope;                      
        int SetPhosChrg( double phos_chrg_new); 
        double phos_chrg;                       

        HaVec_double hel_crd;       
        HaVec_int    lock_hel;      

        HaVec_double bb_crd;        
    HaVec_int    lock_bb;       
    HaVec_int    bb_sidx;       

        Vec3D_arr     u,h,o;        
        Vec3D_arr     uho,hho,ul;   
    HaVec_double  dif;          
        
        HaMat_double hel;
        HaMat_double hold;
        HaMat_double vold;
        HaMat_double bend;
        HaMat_double vkin;

        HaMat_double tor;
        HaMat_double sug;
        HaMat_double bs_bs_pars;

        HaVec_int  ncrd_res;        
        HaVec_int  ncrd_ind_res;    
        
        int SetHelCoord(int i_strand, int i_res, int i_crd, double crd_val); 
        int LockHelCoord(int i_strand, int i_res, int i_crd, int do_lock);   
    int IsHelCoordLocked(int ir, int i_crd);   

        int SetBBCoord(int i_strand, int i_res, int i_crd, double crd_val);  
        int LockBBCoord(int i_strand, int i_res, int i_crd, int do_lock);    

        int update_var_flag;        

    int UpdateVarCoord();            
        int SetCoordsFromJumna();  
        int SetIntCoordsToJumna(); 
        int SaveConfig();          
        int RestoreConfig();       

        int BBOffset(int ir);        
        int IsRibRes(int ir);        
    int IsThymineRes(int ir);    
        int NumIndBBVarRes(int ir);  
    int NumAllBBVarRes(int ir);  
    int Is3endRes(int ir);       
    int IsFstResInChain(int ir); 
        int IdxResInChain(int ir);   
        int ChainIdxOfRes(int ir);   
        int IsSupHlxConstr();        
        int NumBBCoord();            
        int NumFreeBBCoord();        
        int IdxLastHelCoord();       
        int IdxLastFreeHelCoord();   
        int SetShlxTwist(double shlx_tw);             
        double GetAtomCrd(int at_num, int coord_num); 
        double GetVarNum(int crd_num);                

// Analysis function:

        int CalcPdistToShlxCnt();              
        int CalcLocCrdSys();                   
        int CalcLocHlxCrd(int for_bp = TRUE);  
    int CalcAxis();                        
        int CalcBend();                        
        int CalcGlobHlxCrd();                  
        int CalcBBCrd();                       


        int CalcAxisPar1(HaMat_double& ax_hlxc, double& sum, HaVec_double& gra, HaVec_double& scp); 
        
        int GetNRes() const;     
        
        double cur_energy;       

        HaMolecule* p_dna_mol;   

};

#if defined(INT_JUMNA)

extern "C"{
    extern void jumcall_(); 
    extern void closejm_(int_4* ipl,int_4* iabas);
    extern void ecomp_(); 
    extern void ecomp91_();
        extern void ecomp94_();
    extern void minim_();
        extern void disth_();
    extern void microb_();  

    extern void penalty_(); 
        extern void helix_();   
        extern void backbo_();  
    extern void setvar_();  
    extern void equim_(int_4* newq,int_4* nspc,int_4* nhlc,int_4* nbcc,
                                   int_4* nklc,int_4* nlgc,int_4* istop); 
    extern void equivjm_(int_4* nspc,int_4* nbcc,int_4* nhlc,int_4* nklc, int_4* nlgc); 
    extern void putbac_(int_4* key); 
        extern void reset_(char* axe_file, int len); 
        extern void axeout_(char* axe_file, int len); 
    extern void setbac_();                       

     const int N0_J = 5;     
     const int N1_J = 2000;  
     const int N2_J = 74;    
     const int N3_J = 300;   
     const int N4_J = 230;   
     const int N5_J = 20;    
         const int N6_J = 12000;  
         const int N6A_J = 12000; 
         const int N7_J = 1100;  
         const int N8_J = 200;   
     const int N9_J = 20;    
           
//      typedef struct{
//         char finp[80];
//        } jfinp_type;

//        extern jfinp_type jfinp_;
 
         typedef struct{
                  int iret; 
         } hacon_type;

         extern hacon_type hacon_;

          typedef struct{
                 char libn[80];
          } jmdirs_type;

      extern jmdirs_type jmdirs_;


          typedef struct{
                 char mac[32],lmo[32],lib[32],libm[32],out[32];
                 char axe[32],axl[32],noe[32],nol[32], test[32];
                 char pdb[32],ins[32],bar[32],parm[32];
//         char vc[32*N_CHA];
          } cha_type;
 
          extern cha_type cha_;
 
          typedef struct{
                double acc,phos,epsi,epsr,plat,slope,rhbl,vfac,tfac,rfac,xfac,
               scale,rpiv,tpiv,fad,fan,damp,fnoew,fnoes,fnoea,df1,scnb,scee,
               catd,catr,catc,rad,pit,enit;
            int_4  nshel,maxn,opt,mhomo,mhomo2,mhomo3,
               nick,limit,
                           nop,  
                           nrib, 
                           ncat, 
                           lig,
                           naxo;
            int_2  sup,rcom,homo,homo2,homo3,diep,sum,link,ecen,
                       cyl,lcat,cent,autos,amber;
//              int_2  amber;
          } datjm_type;

          extern datjm_type datjm_;
      
          typedef struct{
                  double xsum,ysum;
                  int_4  itwl[N2_J],
                             nvs[N7_J],
                                 ihm[N2_J],
                                 ksym[3],
                                 nbrk[2],
                             isym;
                  int_4 isur; 
                  int_4 isup; 
                  int_2 ihl[N2_J];  
          } symjm_type;

          extern symjm_type symjm_;

      typedef struct{
          double corm[N1_J*3]; 
                  double dmon[N1_J];   
                  char mnam[N1_J*4];   
                  char munit[N1_J*4];  
          int_4 imch[N1_J];    
                  int_4 imty[N1_J];    
                  int_4 icm[N1_J];
                  int_4 matm[3*N1_J];  
                  int_4 matd[N1_J*7];  
                  int_4 nunit[N1_J];   
          int_4 nuc[N2_J+1];   
                  int_4 ncen[N0_J*N2_J+1];
                  int_4 kam;           
                  int_4 khm,lkm,kcen;  
          } mrc_type; 

          extern mrc_type mrc_;

      typedef struct{
          char seq[120]; 
                  double hel[N2_J*6]; 
                  double vkink[N2_J*4];  
                  double set[N2_J*N8_J]; 





              char code[N2_J*8]; 
                  char kode[N2_J*8];
              int_4 irec[N2_J];  
                  int_4 itr[N2_J];   
                  int_4 ito[N2_J];   
                  int_4 nst;         
                  int_4 nto;         
                  int_4 kseq;        
                  int_4 ieq[50*4];   
                  int_4 ilq[N2_J*2]; 
                  int_4 idr[4];      
          int_2 kink[N2_J];  
                  int_2 lthy[N2_J];  
          } strjm_type;

          extern strjm_type strjm_;

//        typedef struct{
//        common/strjm/seq,hel(n2,6),vkink(n2,4),set(n2,n8),code(n2),kode(n2),
//   1 irec(n2),itr(n2),ito(n2),nst,nto,kseq,ieq(50,4),ilq(n2,2),idr(4),
//     1 kink(n2),lthy(n2)
//        } strjm_type;
//        extern strjm_type strjm_;

          typedef struct{
                double thy[N2_J];
                double rsr[N0_J*N2_J]; 
                int_4 iofs[N2_J];  
                int_4 iofe[N2_J];  
                int_4 ithy[6];
                int_4 nith;
        int_4 neq[N7_J];   



                int_4 isr[N0_J*2*N2_J]; 
                int_4 nsr[N2_J];        
                int_2 ribose[N2_J];     
                int_2 cation[N2_J];     
          } extjm_type;             

          extern extjm_type extjm_;

          typedef struct{
                   double rlig[N9_J*6]; 
                   double slig[N9_J*2];
                   int_4 ilig[N9_J*6],lopt[N9_J],lpiv[N9_J];
           int_4 ntlg; 
                   int_4 nlgi; 
                   int_4 nlig; 
                   int_4 ntl;  
                   char  lnam[N9_J*4];
                   int_2 locr[N2_J*N0_J];  
         } lgd_type; 

         extern lgd_type lgd_;

     typedef struct{
                int_2 hst[N2_J*6];    
                int_2 bst[N2_J*N8_J]; 
                int_2 vst[N2_J*4],
                lgi[N1_J],            
                lgj[N1_J],            
                lgu[N2_J];
         } slg_type;

         extern slg_type slg_;

     typedef struct{
             int_4 iend[5]; 
                 int_4 ise[N2_J]; 
                 int_4 ienb[N2_J*2];
                 int_4 kapt[N2_J+1]; 
                 int_4 nsph; 
                 } ind_type;

         extern ind_type ind_;

         typedef struct{
            double sor[N4_J*N5_J*3]; 

                double smon[N4_J*N5_J];  
            char snam[N4_J*N5_J*4];  
            char suni[N4_J*N5_J*4];  
            int_4 nuni[N4_J*N5_J];   
            char sub[N5_J*4];        
            int_4 isch[N4_J*N5_J];   
                int_4 isty[N4_J*N5_J];   
                int_4 ics[N4_J*N5_J];    
        int_4 mats[3*N4_J*N5_J]; 




                                         
                int_4 kas[N5_J]; 
                int_4 khs[N5_J]; 
                int_4 ksub;      
         } moljm_type;

         extern moljm_type moljm_;

         typedef struct{
            double sap[N6_J]; 

                double refg,refb,refh,refv;
                int_4 iap[N8_J*N4_J*N5_J];  

                int_4 nap[N8_J*7   *N5_J];  





                int_4 kap[3*N5_J]; 



         } flx_type;

         extern flx_type flx_;

         typedef struct{
            double force[N1_J*3]; 
                double tor[N1_J*3];   
                double fot[N6_J];
                double ener; 
                double elec; 
        double repl; 
                double disp; 
                double eang; 
                double etog; 
                double epen; 
            int_2  i23[8*N1_J]; 
                int_2  i34[8*N1_J];
                int_2  elim[N1_J];  
         } enf_type;

         extern enf_type enf_;

         typedef struct{ 
            double var[N7_J]; 





                double gra[N7_J];  
                double con[N0_J*N2_J + N3_J];
                double scl[N7_J];   
                int_4 ncon;
                int_4 nvrc;
                int_4 ntba; 
                int_4 nbac; 
                int_4 nthe; 
                int_4 nhel; 
                int_4 ntki; 
                int_4 nkin; 
                int_4 ntri;
                int_4 ntot;
                int_4 nvar; 
                int_4 nrin;
            int_2 lar[N7_J];  
            int_2 lock[N6A_J]; 
         } mnn_type;

         extern mnn_type mnn_;
};

         typedef struct{ 
        double rnoe[N3_J]; 
                double bnoe[N3_J]; 
                double fnoe[N3_J];
                double snoe;
                char   knam[200*4*2];
                int_4 ktyp[200];
                int_4 icon[N2_J*2];
        int_4 inoe[N3_J*9]; 



                int_4 ih68[N2_J];   
                int_4 jnoe[N3_J];   





                int_4 nnoe;         
                int_4 ndcs;
                int_4 ndiv[100];
                int_4 nlin;
         }nmrjm_type;

         extern nmrjm_type nmrjm_;

//     Amber force field parameters:
//     common/para/
//     ro(57) - VdW radii for computing vdw foreced
//     reps(57) - energy minimum for identical atom VdW interactions
//     angc(191),fangc(191),btor(88),
//     $ gtor(88),ftor(88),bdtor(30),gdtor(30),fdtor(30),
//     amb(57,57), - A and B coef in (A/r12 + B/r6) : amb(i,j) = sqrt(reps(i)*reps(j))*(ro(i)+(ro(j))**12
//     bmb(57,57)                                     bmb(i,j) = 2*sqrt(reps(i)*reps(j))*(ro(i)+(ro(j))**6
//     amh(9,11),bmh(9,11),mtor(88),itor(88,4),iadt(30,4),
//     $ iangc(191,3),mof,nof,nang,ntor,ntors,nad,
//     atclas(57) - character*2 - of atom class
//


#endif

#endif // end !defined(NUCLACIDMOD_H) 

---