src/common/open_prospect.h

Go to the documentation of this file.

/*
 *      This program is free software; you can redistribute it and/or modify
 *      it under the terms of the GNU General Public License as published by
 *      the Free Software Foundation; either version 2 of the License, or
 *      (at your option) any later version.
 *
 *      This program 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 General Public License for more details.
 *
 *      You should have received a copy of the GNU General Public License
 *      along with this program; if not, write to the Free Software
 *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

/***************************************************
 **
 **   open_prospect.h
 **        Feb 1st, 2004
 **    Kyle Ellrott
 **
 **
 **
 ***************************************************/

#ifndef __open_prospect_h__
#define __open_prospect_h__


#include <stdlib.h>
#include <math.h>
#include <assert.h>

#define TEMPLATELIST_DEFAULT        "default.list"  
#define TEMPLATELIST_FSSP           "fssp.list"
#define TEMPLATELIST_SCOP           "scop.list"
#define FUNCTIONLIST                "function.list"
#define SINGLETON_FILE              "singleton.param" 
#define PAIRWISE_FILE               "pair.param" 
#define ALIGNMENT_FILE              "alignment.dat"
#define CONTACT_FILE            "contact_count.param"

#define GONNETMATRIX_FILE           "gonnet.param"
#define RESIDUELIB_FILE         "residues.lib"
#define BBIND_FILE              "bbind02.May.lib"
#define ATOMDATA_FILE           "atoms.dat"

#define DEFIRE_CB_DATA              "dfire_cb.dat"
#define DEFIRE_BIN_DATA             "dfire_bin_info.dat"

#define WEIGHT_CONF_FILE        "weights.conf"


//#define PairDistCutoff 49.0
#define PairDistCutoff 58.0
#define PairDistCutoffSqrt   7.61577310586
#define MinDistTwoBody  4

#define MaxContactCount 25

#define StructTypeCount  3  
#define ResidueTypeCount 20

#define HELIX                  2
#define SHEET                  1
#define LOOP                   0



extern char pdb_atomname[288][4];


#define pValType float


//#define vGapOpen    10.8
//#define vGapExtend  0.6

#define e_mutation       0
#define e_mutationfull   1
#define e_mutationlog    2
#define e_mutscore       3
#define e_singleton      4
#define e_sec_struct     5
#define e_twobody_frozen 6
#define e_twobody        7
#define e_distconst      8
#define e_dfire          9
#define e_contact        10
#define e_gapopen        11
#define e_gapconst       12
#define e_coredel        13
#define e_tsingledel     14
#define e_tsingleins     15
#define e_qsingledel     16
#define e_qsingleins     17
#define e_contactdel     18
#define e_count          19

#define e_mask(x)         ((0x00000001) << (x))

#define et_gap            0
#define et_single         1
#define et_pair           2


#ifdef energy_global_define
char e_names[e_count][40] = {
        "mutation",
        "mutationfull",
        "mutationlog",
        "mutscore",
        "singleton",
        "sec_struct",
        "twobody_frozen",
        "twobody",
        "distconst",
        "dfire",
        "contact",
        "gapopen",
        "gapconst",
        "coredel",
        "tsingledel",
        "tsingleins",
        "qsingledel",
        "qsingleins",
        "contactdel"
};
char e_types[ e_count ] = {
        et_single,
        et_single,
        et_single,
        et_single,
        et_single,
        et_single,
        et_single,
        et_pair,
        et_pair,
        et_pair,
        et_single,
        et_gap,
        et_gap,
        et_gap,
        et_gap,
        et_gap,
        et_gap,
        et_gap
};
        
#else
extern char e_names[e_count][40];
extern char e_types[e_count];
#endif


#if 1
typedef pValType EnergyArray[e_count];
#else
class EnergyArray {
public:
        pValType& operator[](int x) {
                return value[x];
        }
//private:
        pValType value[e_count];
};
#endif

typedef pValType WeightArray[e_count];



#define f_count  13

class AlignFeatures {
public:
        AlignFeatures(void);
        enum {
                //actual numeric values
                fn_align,
                fn_ident,
                fn_contact,
                fn_halfcontact,
                fn_align_pair,
                fn_align_core, 
                fn_align_core_res,              
                fr_align,
                fr_ident,
                fr_contact,
                fr_halfcontact,
                fr_align_pair,
                fr_surface
        };      
        void CalcFeatures( class TemplateStruct *template_data, class TargetStruct *taget_data,  class AlignmentStruct *align );                
        pValType Get(unsigned int i) {
                return feature[i];
        }
        static char *GetName(unsigned int i);   
        char IsSet(unsigned int i) {
                return is_set[i];
        }
        void Set(unsigned int i, pValType val) {
                feature[ i ] = val;
                is_set[i] = 1;
        }
        static int Count(void) { return f_count; };
private:
        pValType feature[ f_count ];
        char is_set[ f_count ];
};





#ifndef VEC3_DEFINED
#define VEC3_DEFINED
typedef float vec3[3];
typedef float mat3[3][3];
#endif


#define anN    0
#define anCa   1
#define anC    2
#define anO    3
#define anBBcount 4
#define anCb   4

#define kMaxResAtoms   24

class ResidueAtoms {
public: 
        ResidueAtoms()  { atom_count = 0;  chain = ' '; res_num = 0; bb_num[0] = bb_num[1] = bb_num[2] = bb_num[3] = bb_num[4] = -1; }
        void GetBBLoc( int n, vec3 loc ) {
                if ( bb_num[n] != -1 ) {
                        for ( int i = 0; i < 3; i++ )
                                loc[i] = atom[ bb_num[ n ] ][i];
                }
        }
        int GetAtomIndex( int atom_name );
        void SetAtomLoc( int atom_name, vec3 loc);
        void SetTempFactor( int atom_index, float new_temp);
        void ReadAtomLine( char * line );
        char *WriteAtomLine(int i, char RS = 'X', int res_num = 0, char chain = ' ');
        vec3          atom[kMaxResAtoms];
        int           atom_name[kMaxResAtoms];
        int           atom_num[kMaxResAtoms];
        int           bb_num[anBBcount + 1];
        pValType      radius[kMaxResAtoms];
        pValType      temp_factor[kMaxResAtoms];
        vec3          Cm;
        int           atom_count;
        
        int           res_num;
        char          res_mod;
        char          chain;
};

int ResidueAtoms_CalcCb(ResidueAtoms *res);
pValType calc_LRET(vec3 a, vec3 b, pValType ra, pValType rb);

typedef struct TemplateResidue {
  long Score[21];
  int core_num;                                 
  int NUM;                                      
  int ACC;                                      //< Solvent Accesbity catagory
  
  //this info is replicated in the TargetResidue
  //  pValType PROFILE[21];                             ///< Amino Acid profile information
  //  char RS;                                  //< Amino acid letter
  //  char SS;                                  //< Secondary structure definition
  //  pValType phi,psi;                         //< Phi,Psi values
  //  ResidueAtoms structure;  
} TemplateResidue;

//#define rsUndefined  0
//#define rsBackBone   1
//#define rsSideChain  2

class TargetResidue {
public: 
        TargetResidue() {
                chain = ' ';
                RS = 'X';
                SS = 'L';
                //structure_state = rsUndefined;
                orig_num = 0;
                single_del = 1.0;
                single_ins = 1.0;
        };
        
        pValType FREQ[21];    //< The frequency profile of this residue
        pValType SS_PROB[3];  //< Probability of different secondary structures
        pValType single_del, single_ins;

        char RS;                
        char SS;                
        int  orig_num;   
//      ResidueAtoms structure;
//      char  structure_state;  ///< to what level has the  atomic positions been defined, see the rs... #define values
        pValType phi, psi;
        char     chain;
} ;




typedef struct {
  int member_count;
  int core_number[4];
  int residue_number[4];
  int core_flag;
} InteractionElement;

typedef struct {
  int head;
//  int tail;
  int len;
} TemplateCoreDefinition;





typedef struct DfireStruct {
        int bin_count, dist_hash_size;
        pValType *bin_min, *bin_max, dist_max;
        short *dist_hash;
        pValType ***bin;
} DfireStruct;



//the following data structures outline the standard interface for threading functions

typedef char *(*threading_function)(struct ProspectParam *, 
                                                                        WeightArray,
                                                                        struct TemplateStruct *, 
                                                                        struct TargetStruct *,
                                                                        struct AlignmentStruct *);

typedef char *(*scoring_function)(ProspectParam *, 
                                                                  WeightArray, 
                                                                  TemplateStruct *,
                                                                  TargetStruct *,
                                                                  AlignmentStruct *);

class ParamElement {
public:
        ParamElement( ProspectParam *in_parent) { parent = in_parent; };
        virtual ~ParamElement(void) { FreeMem(); };
        virtual void FreeMem(void) { } ;
protected:
        class ProspectParam *parent;
};




typedef struct ResidueInfoElement {
        char RS;          
        ResidueAtoms   structure;
        int torsion_count; 
        pValType *torsion_val;  
        char **torsion_mask; 
        char *torsion_a;
        char *torsion_b;
} ResidueInfoElement;



typedef struct AtomDataElement {
        char name[4];
        pValType radius;
} AtomDataElement;


class AtomData : public ParamElement {
public:
        AtomData( ProspectParam *in_parent);    
        pValType FindRadius( char *name );      
        pValType FindRadius( int num ); 
        AtomDataElement *atoms; 
        int atom_data_count;
};
        
typedef struct PopsParamsElement {
        int atom_num, rs_num;
        float radius, p_i;
};

class PopsParam : public ParamElement {
public: 
        PopsParam(ProspectParam *in_parent);            
        int LoadParam(char *path);      
        PopsParamsElement *params;
        int param_count;
        float b_ij, p_j, p_14, p_gt14;  
};



typedef struct {
        float prob;             
        pValType  chi[4];       
        int phi,psi;
} RotamerElement;

typedef struct RotamerArray {
        char RS;      
                                  //    int chi_count;  ///< number of chi angles stored in each rotamer element
        int rotamer_count;
        RotamerElement *rotamer;
        int phi_bin, psi_bin;
} RotamerArray;



class ProspectParam{
public: 
        ProspectParam(char *base_path = NULL);
        ~ProspectParam();
        
        int Init(void);
        
        //int InitAtomData(void);
        
        int InitRotamer(void);

        int InitPops(void);
        
        PopsParam* GetPopsParam(void);
        PopsParam* GetPopsRParam(void); 

        char ** Template_Paths(void);   
        
        char * TemplateFind(char *template_name);
        
        //Methods for dynamic function/datastructure search
        
        threading_function ThreaderFind(char *request_name);    
        
        int Weight_Find(char *request_name, WeightArray weights);
        
        int DoThreading(
                                        char *threader_name,
                                        WeightArray weight,              
                                        TemplateStruct *template_data,
                                        TargetStruct *target_data,
                                        AlignmentStruct *alignment,
                                        struct ScoreStruct *scores ) ;
        
        
        int DoThreading(
                                        threading_function threader,
                                        WeightArray weight,              
                                        TemplateStruct *template_data,
                                        TargetStruct *target_data,
                                        AlignmentStruct *alignment,
                                        struct ScoreStruct *scores ) ;
        
        
        
        void CopyGonnetMatrix( class TemplateStruct *template_data );
        
        
        //path information      
        char *ProspectPath;
        char **template_paths;
        
        //Parameter tables for  threading, loaded by Init()
        pValType **PAIR_POT;
        pValType SINGLETON[21][9];
        char ALIGN_MATRIX[21][21];
        pValType  GONNET_MATRIX[21][21];
        pValType  CONTACT_MATRIX[21][MaxContactCount];
        DfireStruct dfire;
        
        //Optional Parameter Elements 
        
        //Residue info
        ResidueInfoElement *residue_info;
        RotamerArray *rotamer_array;
        AtomData *atom_data;
        int atom_data_count;
        
        //The Pops based SASA calculation parameters, one for all atom, one for residue based calculations
        PopsParam *pops_param, *pops_r_param;
        
        //User Alterable variables
        char output_weights, output_timeinfo, output_template_loc, output_pdb, output_backbone, simple_twobody;
        unsigned char ncpus;
        long max_bytes;
        int z_cycles;
        char filter, no_loop, second_guess, full_twobody;
        char v_level; //how verbose?
};





class ScoreStruct {
public: 
        
        enum {
                SCORE_RAW           = 0,
                SCORE_Z             = 1,
                SCORE_ZFULL         = 2,
                SCORE_NN            = 3,
                SCORE_USER0         = 4,
                SCORE_USER1         = 5,
                SCORE_USER2         = 6,
                SCORE_USER3         = 7,
                SCORE_ZMUTATIONLOG  = 8,
                SCORE_ZSINGLETON    = 9,
                SCORE_ZSEC_STRUCT   = 10,
                SCORE_ZTWOBODY      = 11,
                SCORE_ZDFIRE        = 12,
                
                SCORE_COUNT         = 8,
                SCORE_COUNT_TOTAL   = 13,
                
                SCORE_ZENERGY_START = 8,
                SCORE_ZENERGY_END   = 13,
                
                DO_SCORE_RAW         = 0x01,
                DO_SCORE_Z           = 0x02,
                DO_SCORE_ZFULL       = 0x04,
                DO_SCORE_ZENERGY     = 0x10,
        };
        
        
        ScoreStruct(void);
        ~ScoreStruct(void);
        
        pValType ScoreRaw(
                                  ProspectParam *param,
                                  WeightArray weight,            
                                  TemplateStruct *template_data,
                                  TargetStruct *target_data, 
                                  AlignmentStruct *alignment);
        
        pValType ScoreZ(
                                ProspectParam *param,
                                WeightArray weight,              
                                TemplateStruct *template_data, 
                                TargetStruct *target_data,
                                AlignmentStruct *alignment_whole);
        
        pValType ScoreZFull(
                                        ProspectParam *param,
                                        WeightArray weight,              
                                        TemplateStruct *template_data, 
                                        TargetStruct *target_data,
                                        AlignmentStruct *alignment_whole);
        
        void SetScore( int i,  pValType val ) { mask |= (0x00000001 << i); values[i] = val; }

        pValType GetScore( int i ) { return  values[i]; }
        
        static char *GetScoreName(int num);
        
        int mask;
        pValType  values[ SCORE_COUNT_TOTAL ];          
        pValType  z_sd[ SCORE_COUNT_TOTAL ], z_mean[ SCORE_COUNT_TOTAL ];       
};


typedef struct TargetDistConstraint {
        int aa[2];
        pValType dist;
        pValType var;
} TargetDistConstraint;


class TargetStruct {
public:
        TargetStruct(void);     
        virtual ~TargetStruct();        
        
        virtual void SetLen(int new_len);
        void FreeMem(void);     
        
        TargetStruct(const TargetStruct &rhs);
        
        int Setup(ProspectParam *param);        
        int LoadConstraint(char *constraint_file);
        int LoadPsiPred(char *psipred_path);
        int LoadFasta(char *SeqPath);
        int LoadPHD(char *filename);
        int LoadChk(char *ChkPath);
        int LoadFreq(char *FreqPath);
        int LoadPDB(char *filename, char chain=0);
        int SetSequence(char *seq);
        int Copy(TargetStruct *template_data, int start = -1, int stop = -1);
        int Append(TargetStruct *rhs, int start = -1, int stop = -1);
        int LoadSSP( char *ssp_path);
        
        
        int LoadSSPStr(char *ssp_text);
                
        void ReadSingleDelStr( char *text );
        void ReadSingleInsStr( char *text );

        
        int LoadXML( char *xml_path);
        /*
         int StructureSet(ProspectParam *param, 
                                          TemplateStruct *template_data, 
                                          AlignmentStruct *align_data, 
                                          int *rotamer_selection );
         */
        int CopyBackBone( TemplateStruct *template_data,
                                          AlignmentStruct *align_data,
                                          int start = -1, int stop = -1);
        
        pValType Calc_LRET(ProspectParam *param);
        //pValType Prospect_calc_LRET(vec3 a, vec3 b, pValType ra, pValType rb);
        int Count_Atoms(void);
        
        void ReNumberAtoms(int start = 0);
        
        int Count_SetResidues(void);
        int Count_UnSetResidues(void);
        
        vec3 *GetCaLocArray(void);
        
        void SetChain(char new_chain = ' ');
        
        int DSSP(void);
        
        void Calc_hloc(int residue, vec3 h_loc);
        float Calc_hval(int i, int j);
        void Setup_Hbonds( void );
        
        void CleanUndefinedResidues(void);
        
        void ChouFasman(void);
        //char* Prospect_Target_TextPDB(TargetStruct *target_data);
        int WritePDB(char *outpath = NULL, int start=-1, int stop=-1);
        char * WritePDBText(int start=-1, int stop=-1);
        
        char *GetSeq(void);
        
        int FindResIndexFromResNum( int res_num, char res_mod = ' ' );
        
        int SideChain_Init(ProspectParam *param);       
        int SideChain_Pack(ProspectParam *param);
        
        
        void MoveMeanToOrigin(void);
        
        TargetResidue *GetResidue(int i) {
                if ( i < len )
                        return &residue[i];
                else
                        return NULL;
        }
        ResidueAtoms *GetResidueAtoms(int i) {
                if ( i < len )
                        return &structure[i];
                else
                        return NULL;
        }
        
        
        pValType GetTwobody(int i, int j) {
                if ( i < len && j < len ) 
                        return twobody[i][j];
                else
                        return 10000;
        }
        
        char GetBSheet(int i, int j) {
                if (bsheet != NULL &&
                        i >= 0 && i < len &&
                        j >= 0 && j < len ) 
                        return bsheet[i][j];
                return 0;
        }
        
        void Translate(vec3 trans);
        void Rotate (mat3 rotate);      
        int GetCaCount(void);
        vec3 *GetCaArray(void);
        
        int len, residue_offset;             
        pValType **twobody;  
        pValType **hbond;
        char **bsheet;
        TargetDistConstraint  *distconst;
        int distconst_count;
        TargetResidue *residue; 
        ResidueAtoms *structure;
};


class TemplateStruct : public TargetStruct {
public:
        
        TemplateStruct();
        ~TemplateStruct();
        
        void FreeMem(void);
        
        int LoadFile( char *template_path );                       
        
        void SetLen(int new_len);
        

        TemplateCoreDefinition *get_core( int i ) {
                if ( i < core_count ) 
                        return &cores[i];
                else 
                        return NULL;
        }
        
        int SetSequence(char *seq);
        
        void CopyScoreTable( pValType **score_matrix );
        void CopyScoreTable( pValType score_matrix[21][21] );

  TemplateResidue *t_residue_info;
  char *template_name;
  char pdbcode[5];
  char pdbchain;
  int start_res, stop_res;
  char start_icode, stop_icode;
  //  int interaction_count;
  //  InteractionElement *interactions;
  int twobody_count;
  InteractionElement *twobody_interactions;
  int threebody_count;
  InteractionElement *threebody_interactions;
  int fourbody_count;
  InteractionElement *fourbody_interactions;
  int core_count;
  TemplateCoreDefinition *cores;
  pValType  **cb_dist;
};






class AlignmentStruct {
public:
        AlignmentStruct();
        ~AlignmentStruct();
        
        AlignmentStruct & operator=(const AlignmentStruct &rhs);        
        AlignmentStruct(const AlignmentStruct &rhs);    
        
        void Free(void);
        void Copy(const AlignmentStruct &rhs);  
        
        void SetAlign( int in_target_len, int *in_target_align, int in_template_len, int *in_template_align) {
                target_len = in_target_len;
                target_align = in_target_align;
                template_len = in_template_len;
                template_align = in_template_align;     
        }
        
        int SetAlign( char *target_align, char *template_align );
        int SetAlign( AlignmentStruct &rhs, int target_start = -1, int target_end = -1);
        int SetAlign( ProspectParam *param,
                                  WeightArray weights,
                                  TemplateStruct *template_data, 
                                  TargetStruct *target_data, 
                                  int *core_pos, char *core_del = NULL );
        int SetAlignFromNumStr( char *target_align, char *template_align );

        char * Write_XML(ProspectParam *param,
                                         WeightArray weight,    
                                         TemplateStruct *template_data,
                                         TargetStruct *target_data, 
                                         ScoreStruct *score);
        
        void GetEnergies( ProspectParam *param, 
                                          TemplateStruct *template_data, TargetStruct *target_data,
                                          EnergyArray energy, long mask = 0xFFFFFFFF);

        int GetFragCount(void);
        int GetFragStart(int frag_num);
        int GetFragStop(int frag_num);
        void CalcFrag(void);
        
        int GetTargetAlign(int i) {
                if (i >= 0 && i < target_len)
                        return target_align[i];
                return -1;
        }
        int GetTemplateAlign(int i) {
                if (i >= 0 && i < template_len)
                        return template_align[i];
                return -1;
        }
        int GetTargetLen(void) { return target_len; }
        int GetTemplateLen(void) { return template_len; }
        char *GetTargetAlignStr(TemplateStruct *template_data, TargetStruct *target_data);
        char *GetTemplateAlignStr(TemplateStruct *template_data, TargetStruct *target_data);    
        void GetAlignmentStrings( ProspectParam *param, 
                                                 TemplateStruct *template_data,
                                                 TargetStruct *target_data,
                                                 char** template_str, char** template_ss_str,
                                                 char** target_str, char** target_ss_str,
                                                 char** align_str, char** core_str);
        
        
        char    method[ 20 ];   
        friend class ProspectOutput;
        friend class ProspectThreadingInfo;
protected:
        int    *target_align;
        int    *template_align;
        int     target_len;
        int     template_len;
        int *frag_start;
        int *frag_stop;         
        int frag_count;
        friend class TargetAlignmentStruct;
};




class TargetAlignmentStruct {
public:
        TargetAlignmentStruct();
        ~TargetAlignmentStruct();
        TargetAlignmentStruct(const TargetAlignmentStruct &rhs);
        
        TargetAlignmentStruct(const AlignmentStruct &rhs);

        void SetAlign(TargetStruct *target_1_in, int *target_1_align_in, TargetStruct *target_2_in, int *target_2_align_in);
        void SetAlign(TargetStruct *target_1_in, int target_1_offset, TargetStruct *target_2_in, int target_2_offset, int len);
        char SetAlign(const char *target1, const char *target2);
        
        void SetAlign(int *target_1, int *target_2, int len_both);
        void SetAlign(int *target_1, int len_1, int *target_2, int len_2);

        
        char LoadFast(char *fast_file);
        
        void ClearAlign(void);
        
        void ModAlign(int target_1_offset, int target_2_offset, int len);
        
        char MergeAlign( TargetAlignmentStruct *align_1, TargetAlignmentStruct *align_2);
        
        char CheckAlign(void);
        
        pValType GetCaRmsd(TargetStruct *target_1, TargetStruct *target_2);
        pValType Get1to2Trans(TargetStruct *target_1, TargetStruct *target_2, vec3 trans1, mat3 rot, vec3 trans2 );
        pValType Get2to1Trans(TargetStruct *target_1, TargetStruct *target_2, vec3 trans1, mat3 rot, vec3 trans2 );
        
        void Move1to2( TargetStruct *target_1, TargetStruct *target_2 );
        void Move2to1( TargetStruct *target_1, TargetStruct *target_2 );
        
        void Move1to2( vec3 *target_1, vec3 *target_2 );        
        
        pValType AlignTargetCa(TargetStruct *target_1, TargetStruct *target_2, 
                                                   int *target_1_align, int *target_2_align,
                                                   vec3 trans1, mat3 rot, vec3 trans2);
        pValType AlignVec3( vec3 *target_1, vec3 *target_2, vec3 trans1, mat3 rot, vec3 trans2);
        
        void ApplyAlignTrans( TargetStruct *target, vec3 trans1, mat3 rot, vec3 trans2);
        void ApplyAlignTrans( ResidueAtoms *target, int target_len, vec3 trans1, mat3 rot, vec3 trans2);
        void ApplyAlignTrans( vec3 *target, int target_len, vec3 trans1, mat3 rot, vec3 trans2);
        
        int GetTarget1Align(int i) {
                if (i >= 0 && i < target_1_len)
                        return target_1_align[i];
                return -1;
        }
        int GetTarget2Align(int i) {
                if (i >= 0 && i < target_2_len)
                        return target_2_align[i];
                return -1;
        }
private:
        int *target_1_align, *target_2_align, target_1_len, target_2_len;       
};





typedef struct ThreaderDesc {
  char name[255];
  char parallel;       
  char pair_optimize;  
  threading_function  function_call;
} ThreaderDesc;



int Prospect_Target_Rotamer(ProspectParam *param, ResidueAtoms *structure, char residue, int rotamer_number);


/*
class ProteinLinearAtoms {
public:
        ProteinLinearAtoms(void) { 
                atom_count = 0; atom_loc = NULL; residue_num = NULL; 
                atom_type = NULL; temp_factor = NULL;
        };
        ~ProteinLinearAtoms(){
                if (atom_loc != NULL) free(atom_loc);
                if (residue_num != NULL) free(residue_num);
                if (atom_type != NULL) free(atom_type);
                if (temp_factor != NULL) free(temp_factor);
        }
        ProteinLinearAtoms( ResidueAtoms *r_atoms, int count ) {
                extract_residueatom_array( r_atoms, count );
        }
        
        void extract_target( TargetStruct *target );
        void extract_residueatom_array( ResidueAtoms *r_atoms, int count);
        
        int atom_count;
        vec3 *atom_loc;
        int *residue_num;
        int *atom_type;
        float *temp_factor;
};
*/


typedef struct RotamerMask {
        long len;
        char **state;
        ResidueAtoms **structure;
        pValType **single_score;
        pValType ***pair_score;
        long **rot_num;
        long *count;
} RotamerMask;


pValType rot_mask_pairscore_get( RotamerMask *mask, long vertex_1, long vertex_2, long state_1, long state_2);
void rot_mask_pairscore_set( RotamerMask *mask, long vertex_1, long vertex_2, long state_1, long state_2, pValType score);

int Prospect_Target_RotamerMask_Init(ProspectParam *param, TargetStruct *target_data, RotamerMask *rotamer_mask);
void Prospect_Target_RotamerMask_Free(RotamerMask *mask);
int Prospect_RotamerMask_DEE(RotamerMask *mask);
int Prospect_RotamerMask_DEE_Split(RotamerMask *mask);
int Prospect_RotamerMask_TreeDecomp( RotamerMask *mask );


pValType calc_raw_score( WeightArray weights, EnergyArray energies );


pValType calc_single_energy(ProspectParam *param,
                                                        WeightArray weights,
                                                        TemplateStruct *template_data,
                                                        TargetStruct *target_data,
                                                        int template_res_num,
                                                        int target_res_num);


pValType calc_pair_energy(ProspectParam *param,
                                                  WeightArray weights,
                                                  TemplateStruct *template_data,
                                                  TargetStruct *target_data,
                                                  int template_res_num_1, int template_res_num_2,
                                                  int target_res_num_1, int target_res_num_2);


pValType calc_del_val(ProspectParam *param,
                                          WeightArray weights,
                                          TemplateStruct *template_data,
                                          TargetStruct *target_data,
                                          int template_res_num, int target_res_num );



pValType calc_ins_val( ProspectParam *param,
                                           WeightArray weights,
                                           TemplateStruct *template_data,
                                           TargetStruct *target_data,
                                           int template_res_num, int target_res_num );

pValType calc_coredel(ProspectParam *param,
                                          TemplateStruct *template_data,
                                          int template_res_num);


pValType calc_contactdel(ProspectParam *param,
                                                  TemplateStruct *template_data,
                                                  int template_res_num);

/*
void calc_core_single_energies(ProspectParam *param,
                               TemplateStruct *template_data,
                               TargetStruct *target_data,
                               long core, long core_pos, pValType *energies);
*/

pValType calc_mutation(ProspectParam *param,
                     TemplateStruct *template_data,
                     TargetStruct *target_data,
                     int template_res_num,
                     int target_res_num);


pValType calc_mutationlog(ProspectParam *param,
                     TemplateStruct *template_data,
                     TargetStruct *target_data,
                     int template_res_num,
                     int target_res_num);


pValType calc_mutationfull(ProspectParam *param,
                                                        TemplateStruct *template_data,
                                                        TargetStruct *target_data,
                                                        int template_res_num,
                                                        int target_res_num);

pValType calc_sec_struct(ProspectParam *param,
                       TemplateStruct *template_data,
                       TargetStruct *target_data,
                       int template_res_num,
                       int target_res_num);

pValType calc_singleton(ProspectParam *param,
                      TemplateStruct *template_data,
                      TargetStruct *target_data,
                      int template_res_num,
                      int target_res_num);

pValType calc_mutscore(ProspectParam *param,
                                           TemplateStruct *template_data,
                                           TargetStruct *target_data,
                                           int template_res_num,
                                           int target_res_num);
                     
                     
pValType calc_twobody_frozen(ProspectParam *param,
                                 TemplateStruct *template_data,
                                 TargetStruct *target_data,
                                 int template_res_num,
                                 int target_res_num);




pValType calc_contact_frozen(ProspectParam *param,
                                                         TemplateStruct *template_data,
                                                         TargetStruct *target_data,
                                                         int template_res_num,
                                                         int target_res_num);


pValType calc_twobody(ProspectParam *param,
                    TemplateStruct *template_data,
                    TargetStruct *target_data,
                    int template_res_num_1, int template_res_num_2,
                    int target_res_num_1, int target_res_num_2);


pValType calc_twobody_val(ProspectParam *param,
                    TargetStruct *target_data,
                    int template_res_num_1, int template_res_num_2);

pValType calc_dfire(ProspectParam *param,
                     TemplateStruct *template_data,
                     TargetStruct *target_data,
                     int template_res_num_1, int template_res_num_2,
                     int target_res_num_1, int target_res_num_2);


pValType calc_dfire( ProspectParam *param, char res_a, char res_b, float dist );

pValType calc_distconst(ProspectParam *param,
                                                TemplateStruct *template_data,
                                                TargetStruct *target_data,
                                                int template_res_num_1, int template_res_num_2,
                                                int target_res_num_1, int target_res_num_2);





pValType calc_singledel(ProspectParam *param,
                                                TemplateStruct *template_data,
                                                int template_res_num);

pValType calc_singleins(ProspectParam *param,
                                                TemplateStruct *template_data,
                                                int template_res_num);



int ss_filter(ProspectParam *param,
                TemplateStruct *template_data,
                TargetStruct *target_data,
                int core_num, int core_position);

        

#define vUp        1
#define vLeft      2
#define vMatch     3


class DynamicAlign {
public:
        DynamicAlign() {
                size_x = size_y = 0;
                gap_open = 0;
                gap_extend = 0;
                energy_matrix = NULL;
                score_matrix = NULL;
                source_matrix = NULL;
        };      
        DynamicAlign(int in_x, int in_y)  {
                energy_matrix = NULL;
                score_matrix = NULL;
                source_matrix = NULL;
                SetDim( in_x, in_y );           
        };      
        virtual ~DynamicAlign() {
                FreeMem();
        }
        void FreeMem(void) {            
                if ( energy_matrix ) {
                        free( energy_matrix[0] );
                        free( energy_matrix );
                }
                energy_matrix = NULL;
                if ( score_matrix ) {
                        free( score_matrix[0] );
                        free( score_matrix );
                }
                score_matrix = NULL;
                if ( source_matrix ) {
                        free( source_matrix[0] );
                        free( source_matrix );
                }
                source_matrix = NULL;
                size_x = size_y = 0;
                gap_open = 0;
                gap_extend = 0;
        }       
        //virtual void CalcEnergyTable();
        
        void SetDim( int x, int y );
        
        void Align(void) { Align( 0,0,size_x,size_y); };
        virtual void Align( int start_x, int start_y, int end_x, int end_y, char start_state = vMatch, pValType start_val = 0.0 );
        void TraceAlign( int *align_x, int *align_y) {
                TraceAlign( 0,0, size_x, size_y, align_x, align_y );
        };
        void TraceAlign( int start_x, int start_y, int end_x, int end_y,
                                         int *align_x, int *align_y);
        void TraceAlign( AlignmentStruct *out_align );
        pValType GetCellVal( int x, int y ) {
                return score_matrix[x+1][y+1];
        }
        char GetCellState( int x, int y ) {
                return source_matrix[x+1][y+1];
        }
        pValType GetCellEnergy( int x, int y ) {
                return energy_matrix[x][y];
        }

        //for creative usage of the alignment matrix
        void SetCellState( int x, int y, int state ) {
                source_matrix[x+1][y+1] = state;
        }
        void ContinueAlign( int start_x, int start_y );
        void ForceXDelete( int start_x, int len );
        void ForceYDelete( int start_y, int len );
        void ForceAlign( int start_x, int start_y, int len );

protected:              
        int size_x, size_y;
        pValType **energy_matrix, **score_matrix, gap_open, gap_extend;
        char **source_matrix;   
};


class ProspectDynamicAlign : public DynamicAlign {
public:
        virtual void CalcEnergyTable(ProspectParam *param,
                                                 WeightArray weights,   
                                                 TemplateStruct *template_data,
                                                 TargetStruct *target_data );
        
};


class ProspectDynamicCoreAlign : public ProspectDynamicAlign {
private:
        pValType **extra_del_score, **extra_ins_score;  
public:
        
        ProspectDynamicCoreAlign() : ProspectDynamicAlign() {
                extra_del_score = NULL;
                extra_ins_score = NULL;
        }
        ~ProspectDynamicCoreAlign()  {
                if ( extra_del_score ) {
                        free( extra_del_score[0] );
                        free( extra_del_score );
                }
                extra_del_score = NULL;
                if ( extra_ins_score ) {
                        free( extra_ins_score[0] );
                        free( extra_ins_score );
                }
                extra_ins_score = NULL;         
                FreeMem();
        }       
        void CalcEnergyTable(ProspectParam *param,
                                                 WeightArray weights,   
                                                 TemplateStruct *template_data,
                                                 TargetStruct *target_data );   
        void Align(void) { Align( 0,0,size_x,size_y); };
        void Align( int start_x, int start_y, int end_x, int end_y, char start_state = vMatch, pValType start_val = 0.0 );      
};

char AA3toAA1(char * res);
void AA1toAA3(char res, char *res_name);
int AA1toAANum(char a);
char AANumtoAA1(int a);

int SS1toSSNum(char a);

int PDBAtomtoNum( char *atom_name );

int solvent_acc(char a, int template_acc);


int solvent_sec_struct(TemplateStruct *template_data,
                       int template_res_num);



void shuffle_seq(TargetStruct *q, TargetStruct *s_q);





class ProspectThreadingInfo {
public: 
        ProspectThreadingInfo();
        ~ProspectThreadingInfo();
        

        ProspectThreadingInfo(const ProspectThreadingInfo &rhs);        
        ProspectThreadingInfo & operator=(const ProspectThreadingInfo &rhs);    

        void Copy( const ProspectThreadingInfo &rhs);
        void Free(void);
        
        pValType Score_Calc_NN( void );
        /*
        pValType GetAlignPercent(void) {
                return (pValType)nalign/(pValType)align.target_len;
        }
         */

        pValType GetEnergy( int energy_id ) {
                return energy[ energy_id ];
        }
        pValType GetAveRaw(void);
        void ExtractTarget( TargetStruct *target_in, int start = -1, int stop = -1);
        
        void  SetScoreExtra(int extra_num, float val );
        float GetScoreExtra(int extra_num  );

        
        class ProspectOutput *parent;
                
        char *template_name;
        ScoreStruct scores;
        pValType score_extra;
        char *align_target_ss, *align_target_seq, *align_match, *align_template_ss, *align_template_seq;
        char *template_rs, *target_rs, *template_ss, *target_ss;
        long rank;
//      double extra_score;
        char *pdb_text;
        
        //int nalign, npair_align, nalign_core_res, nalign_core, nident;
                
        AlignmentStruct align;
        AlignFeatures features;
        EnergyArray  energy;
        WeightArray  weight;
                
        int target_len, template_len, core_count, core_res_count;
        TemplateCoreDefinition *core;           
        ResidueAtoms *residue_atoms;    
        pValType lret;
        int atom_count;
        
        void *xml_node; 
};




class ProspectOutput {
public: 
        ProspectOutput(char *path = NULL);
        ~ProspectOutput();      
        
        void Free(void);
        
        int Load( char *path);
        int Save( char *path);
        
        int AddThreadingInfo( ProspectThreadingInfo *thread_info );
        int AddThreadingInfo( ProspectParam *param,
                                                  WeightArray weight,   
                                                  TemplateStruct *template_data,
                                                  TargetStruct *target_data, 
                                                  ScoreStruct *score,
                                                  AlignmentStruct *alignment);
        
        int GetThreadingCount( void);
        char * GetTemplateName( int N);
        int GetTemplateNum( char *);
        
        ProspectThreadingInfo GetThreadingInfo( int N );
        
        int GetThreadingInfo( int N, ProspectThreadingInfo *thread_info);
        int GetThreadingInfo( const char * name, ProspectThreadingInfo *thread_info);
        int Get_PDBText( int N, ProspectThreadingInfo *thread_info);    
        void Sort( int feature );
        void Sort( char *eqn, bool minimize = true);
        void Sort( class ThreadFeatureParse *sort_func, bool minimize = true );
        //void SortScoreUser(  bool minimize = true );
        void SetSortVal( int i, float val);
        float GetSortVal( int i );
        
        int GetRank(int i) { if (reorder) return reorder[i]; return i;} ;
        /*
        void SetScoreExtra( int i, int extra_num, float val );
        float GetScoreExtra( int i, int extra_num  );
        */
        void GetRawNormalize( float &mean, float &sd );
        
protected:
                friend class ThreadFeatureParse;
        //a pointer that actually points to a xmlDocPtr, but is kept char * to 
        //skip the compication of needing the libxml headers when compiling
        void * output_xml_handle;       
        int *reorder;
        float *sort_val;
};



#define FPOP_SET  1
#define FPOP_GET  2
#define FPOP_ADD  3
#define FPOP_SUB  4
#define FPOP_MUL  5
#define FPOP_DIV  6
#define FPOP_POW  7
#define FPOP_SRT  8
#define FPOP_LOG  9
#define FPOP_SIN  10
#define FPOP_COS  11
#define FPOP_NEG  12
#define FPOP_ABS  13
#define FPOP_RES  14

typedef struct feature_parse_op {
        int op_code;
        union {
                int reg[2];
                double val;
        } op_arg;
        int mem_store;
} feature_parse_op;


class ThreadFeatureParse {
public:
        ThreadFeatureParse ();
        ThreadFeatureParse( feature_parse_op *op_list, int op_count, int mem_size );
        ThreadFeatureParse( char *eqn_str );
        ThreadFeatureParse & operator =( const ThreadFeatureParse &rhs );
        void Copy(const ThreadFeatureParse &rhs);
        ~ThreadFeatureParse();
        
        
  float RunParse( ProspectThreadingInfo *thread );
  float *RunParse( ProspectOutput *threads );

  static ThreadFeatureParse *CompileParse(char *str);

        static float calc_averaw( ProspectThreadingInfo *thread, int foo = 0);
        static float get_score( ProspectThreadingInfo *thread, int feature ) {
                return thread->scores.values[ feature ];
        };
        /*
        static float get_user_score( ProspectThreadingInfo *thread, int feature ) {
                if ( thread == NULL || thread->parent == NULL )
                        return 0;
                return thread->parent->GetScoreExtra( thread->parent->GetTemplateNum( thread->template_name ), feature );
        };
        static float *get_user_score_array( ProspectOutput *threads, int feature );
        */
        static float get_score_mean( ProspectThreadingInfo *thread, int feature ) {
                return thread->scores.z_mean[ feature ];
        };
        
        static float get_score_sd( ProspectThreadingInfo *thread, int feature ) {
                return thread->scores.z_sd[ feature ];
        };
        
        static float get_struct_feature( ProspectThreadingInfo *thread, int feature );
        static float get_align_feature( ProspectThreadingInfo *thread, int feature ) {
                return thread->features.Get( feature );
        }
        static float get_raw_zscore( ProspectThreadingInfo *thread, int feature );

        static float get_target_frag_count( ProspectThreadingInfo *thread, int foo = 0) {
                return thread->align.GetFragCount();
        }       
        static float get_weight( ProspectThreadingInfo *thread, int feature ) {
                return thread->weight[ feature ];
        }
        static float get_energy( ProspectThreadingInfo *thread, int feature ) {
                return thread->energy[ feature ];
        }
        static float get_energy_weight( ProspectThreadingInfo *thread, int feature ) {
                return thread->energy[ feature ] * thread->weight[ feature ];
        }
                
        static float *get_raw_zscore_array( ProspectOutput *threads, int feature );
        static float* get_score_array( ProspectOutput *threads, int feature );  
        static float* get_score_array_mean( ProspectOutput *threads, int feature );     
        static float* get_score_array_sd( ProspectOutput *threads, int feature );       

        static float* get_weight_array( ProspectOutput *threads, int feature ); 
        static float* get_energy_array( ProspectOutput *threads, int feature ); 
        static float* get_energy_weight_array( ProspectOutput *threads, int feature );  
        static float* get_align_feature_array( ProspectOutput *threads, int feature );  
        static float* get_struct_len_array( ProspectOutput *thread, int feature );

        static float GetFeatureFloat(  ProspectThreadingInfo *thread_info, char *str);
        static float GetFeatureFloat(  ProspectThreadingInfo *thread_info, int id);
        static int   GetFeatureID( char *str);
        static char *GetFeatureStr( ProspectThreadingInfo *thread_info, char *str);     
        static char *ParseFeatureStr( ProspectThreadingInfo *thread_info, char *str );  
        static float ParseFeatureEqn( ProspectThreadingInfo *thread_info, char *eqn_str );

 private:
                float RunFeatureProgram( ProspectThreadingInfo *thread, float *feature_vals = NULL );

        feature_parse_op *ops;
        int op_count;
        double *mem;
        int mem_count;
};



class SasaCalc {
public:
        SasaCalc(void) { };
        virtual ~SasaCalc(void) { };
        virtual float CalcResidueSasa( TargetStruct *target_data, int res) = 0;
        float CalcSasa( TargetStruct *target_data );
};


class PopsSasa : public SasaCalc, public ParamElement {
public:
        PopsSasa(ProspectParam *in_parent, bool load = true);
        ~PopsSasa() {
                if (params != NULL) 
                        free( params );
        }
        float CalcResidueSasa( TargetStruct *target_data, int res);
        pValType FindRadius( int atom_num );    
        pValType FindP( int atom_num ); 

protected:
        PopsParam *params;
};


class PopsRSasa : public PopsSasa {
public:
        PopsRSasa( ProspectParam *in_parent );  
};

class SimpleSasa :  public SasaCalc, public ParamElement {
public:
        SimpleSasa(ProspectParam *in_parent) : SasaCalc(), ParamElement( in_parent ) { } ;
        float CalcResidueSasa( TargetStruct *target_data, int res);
};


class DsspSasa : public SasaCalc {
public:
        DsspSasa() { len = 0; acc_val = NULL; };
        ~DsspSasa() { if ( acc_val ) delete acc_val; };
        void LoadDssp(char *path);

        float CalcResidueSasa( TargetStruct *target_data, int res);

protected:
                int len;
        float *acc_val;
};

#endif

---