src/common/energy_functions.cc

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

#define energy_global_define 1
#include "open_prospect.h"
#include "sm_matrix.h"

extern "C" {
#include "filter_net.h"
}

#define ABS(a)         ( (a) < 0 ? (-(a)) : (a) )


pValType calc_raw_score( WeightArray weights, EnergyArray energies ) {
        pValType total = 0.0;
        for (int i = 0; i < e_count; i++ ) {
                total += weights[i] * energies[i];
        }
        return total;
}

pValType calc_single_energy(ProspectParam *param,
                                                        WeightArray weights,
                                                        TemplateStruct *template_data,
                                                        TargetStruct *target_data,
                                                        int template_res_num,
                                                        int target_res_num) {
        pValType score = 0;
        
        if ( target_res_num >= 0 && target_res_num < target_data->len) {
        
                if (weights[e_mutation] != 0) 
                        score += weights[e_mutation] * calc_mutation(param, template_data, target_data, template_res_num, target_res_num);
                
                //      if (weights[e_mutationfull] != 0) 
                //              score += weights[e_mutationfull] * calc_mutationfull(param, template_data, target_data, template_res_num, target_res_num);
                
                if (weights[e_mutationlog] != 0) 
                        score += weights[e_mutationlog] * calc_mutationlog(param, template_data, target_data, template_res_num, target_res_num);
                
                if (weights[e_singleton] != 0) 
                        score += weights[e_singleton] * calc_singleton(param, template_data, target_data, template_res_num, target_res_num);
                
                if (weights[e_mutscore] != 0) 
                        score += weights[e_mutscore] * calc_mutscore(param, template_data, target_data, template_res_num, target_res_num);
                
                if (weights[e_sec_struct] != 0) 
                        score += weights[e_sec_struct] * calc_sec_struct(param, template_data, target_data, template_res_num, target_res_num);
                
                if (weights[e_contact] != 0) 
                        score += weights[e_contact] * calc_contact_frozen(param, template_data, target_data, template_res_num, target_res_num);

                
                //      if (weights[e_twobody_frozen] != 0) 
                //              score += weights[e_twobody_frozen] * calc_twobody_frozen(param, template_data, target_data, template_res_num, target_res_num);
        }
                
        return score;
}



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 score = 0;
        
        if (weights[e_twobody] != 0.0)
                score += weights[e_twobody] * calc_twobody(param, template_data, target_data, 
                                                                                                   template_res_num_1, template_res_num_2, 
                                                                                                   target_res_num_1, target_res_num_2);

        if (weights[e_dfire] != 0.0)
                score += weights[e_dfire] * calc_dfire(param, template_data, target_data, 
                                                                                                   template_res_num_1, template_res_num_2, 
                                                                                                   target_res_num_1, target_res_num_2);

        
        if (weights[e_distconst] != 0.0)
                score += weights[e_distconst] * calc_distconst(param, template_data, target_data, 
                                                                                                   template_res_num_1, template_res_num_2, 
                                                                                                   target_res_num_1, target_res_num_2);
        
        return score;
}

/*
void calc_core_single_energies(ProspectParam *param,
                               TemplateStruct *template_data,
                               TargetStruct *target_data,                              
                               long core, long core_pos, pValType *energies) {
  long i;
  
  for (i = 0; i < e_count; i++) {
    energies[i] = 0;
  }
  for (i = 0; i < template_data->cores[ core ].len; i++) {
          if (core_pos+i >= 0 && core_pos+i < target_data->len) {
                  energies[e_mutation] += calc_mutation(param, template_data, target_data,
                                                                                                template_data->cores[ core ].head + i, core_pos + i);
//                energies[e_mutationfull] += calc_mutationfull(param, template_data, target_data,
//                                                                                                              template_data->cores[ core ].head + i, core_pos + i);
                  energies[e_mutationlog] += calc_mutationlog(param, template_data, target_data,
                                                                                                          template_data->cores[ core ].head + i, core_pos + i);
//                energies[e_gonnet] += calc_gonnet(param, template_data, target_data,
//                                                                                      template_data->cores[ core ].head + i, core_pos + i);
                  energies[e_singleton] += calc_singleton(param, template_data, target_data,
                                                                                                  template_data->cores[ core ].head + i, core_pos + i);
                  energies[e_sec_struct] += calc_sec_struct(param, template_data, target_data,
                                                                                                        template_data->cores[ core ].head + i, core_pos + i);
//                energies[e_twobody_frozen] += calc_twobody_frozen(param, template_data, target_data,
//                                                                                                                      template_data->cores[ core ].head + i, core_pos + i);
          }
  }
}
*/



//--------------------ENERGY FUNCTIONS-----------------
pValType calc_mutation(ProspectParam *param,
                     TemplateStruct *template_data,
                     TargetStruct *target_data,
                     int template_res_num,
                     int target_res_num) {
  int k;
  pValType mutation=0.0;

#ifdef ALTIVEC
  vector float partialProduct = (vector float) (0.0f, 0.0f, 0.0f, 0.0f), 
    temp, sum;
  vector unsigned int minusZero;
  float vDotProduct;                            /* X dot Y              */
  vector float  x,y;
  float *a,*b;
#if 0
  minusZero = vec_splat_u32 ( -1 );             /* create the -0.0 vector */
  minusZero = vec_sl ( minusZero, minusZero );  /* in vector integer      */
  partialProduct = ( vector float ) minusZero;   /* initialize to -0.0    */
#endif
  

  a = template_data->residue[template_res_num].PROFILE;
  b =  target_data->residue[target_res_num].FREQ;

  x = vec_ld(0, a);
  y = vec_ld(0, b);
  a+=4;
  b+=4;
  for (i = 1; i < 5; i++) {
    partialProduct = vec_madd ( x, y, partialProduct ); 
    x = vec_ld(0, a );
    y = vec_ld(0, b );
    a+=4;
    b+=4;
  }

  temp = vec_sld ( partialProduct, partialProduct, 4 );
  sum  = vec_add ( partialProduct, temp );
  temp = vec_sld ( sum, sum, 8 );
  sum  = vec_add ( sum, temp);
  
  vec_ste ( sum, 0, &vDotProduct );
  return -vDotProduct;  
#else
   if (template_res_num < template_data->len && template_res_num >= 0 &&
          target_res_num < target_data->len && target_res_num >= 0) {

 
     for (k=0;k<20;k++) {
                 mutation=mutation+template_data->residue[template_res_num].FREQ[k]*
         target_data->residue[target_res_num].FREQ[k];
     }
  }
  return (-mutation);
#endif
  
}


pValType calc_mutationfull(ProspectParam *param,
                                           TemplateStruct *template_data,
                                           TargetStruct *target_data,
                                           int template_res_num,
                                           int target_res_num) {
        int i,j;
        pValType mutation=0.0;


    if (template_res_num < template_data->len && template_res_num >= 0 &&
          target_res_num < target_data->len && target_res_num >= 0) {
        
        for (i = 0; i < 20; i++) {
                for (j = 0; j < 20; j++) {
                        mutation = mutation +
                        (template_data->residue[template_res_num].FREQ[i]*
                         target_data->residue[target_res_num].FREQ[j] * 
                         param->GONNET_MATRIX[ i ][ j ] );
                }
        }
      }

        return (-mutation);     
}


typedef struct AA_LetterProb {
  char a;
  pValType prob;
} AA_LetterProb;

static AA_LetterProb Robinson_prob[] = {
  { 'A', 0.07805 },
  { 'R', 0.05129 },
  { 'N', 0.04487 },
  { 'D', 0.05364 },
  { 'C', 0.01925 },
  { 'Q', 0.04264 },
  { 'E', 0.06295 },
  { 'G', 0.07377 },
  { 'H', 0.02199 },
  { 'I', 0.05142 },
  { 'L', 0.09019 },
  { 'K', 0.05744 },
  { 'M', 0.02243 },
  { 'F', 0.03856 },
  { 'P', 0.05203 },
  { 'S', 0.07120 },
  { 'T', 0.05841 },
  { 'W', 0.01330 },
  { 'Y', 0.03216 },
  { 'V', 0.06441 }
};



pValType calc_mutationlog(ProspectParam *param,
                     TemplateStruct *template_data,
                     TargetStruct *target_data,
                     int template_res_num,
                     int target_res_num) {
  long i;
  pValType sum = 0;
/*
  for (i = 0; i < 20; i++) {
    if ( template_data->residue[template_res_num].PROFILE[i] > 0.000001)
      sum += log( template_data->residue[template_res_num].PROFILE[i] / Robinson_prob[i].prob ) * 
        target_data->residue[target_res_num].FREQ[i] ;
    else 
      sum += -32768 * target_data->residue[target_res_num].FREQ[i];
  }
  if ( sum < -32768)
    sum = -32768;

  assert(!isnan(sum));
 */
  
  for (i = 0; i < 20; i++) {
          sum += target_data->residue[target_res_num].FREQ[i] * template_data->t_residue_info[template_res_num].Score[i];
  }
  assert( !isnan(sum) );
  return -sum;
}

pValType calc_mutscore(ProspectParam *param,
                     TemplateStruct *template_data,
                     TargetStruct *target_data,
                     int template_res_num,
                     int target_res_num) {
    return template_data->t_residue_info[ template_res_num ].Score[ AA1toAANum( target_data->residue[target_res_num].RS ) ];
}

pValType calc_sec_struct(ProspectParam *param,
                                                 TemplateStruct *template_data,
                                                 TargetStruct *target_data,
                                                 int template_res_num,
                                                 int target_res_num) {
        pValType ss_fit=0.0;    
        if (template_data->residue[template_res_num].SS=='H') {
                //ss_fit = 3.0 - rint(target_data->residue[target_res_num].SS_PROB[HELIX]*10.0);
                ss_fit = 0.3 - (target_data->residue[target_res_num].SS_PROB[HELIX]);
        } else if (template_data->residue[template_res_num].SS=='E') {
                //ss_fit = 3.0 - rint(target_data->residue[target_res_num].SS_PROB[SHEET]*10.0);
                ss_fit = 0.3 - (target_data->residue[target_res_num].SS_PROB[SHEET]);
        } else {
                //ss_fit = 3.0 - rint(target_data->residue[target_res_num].SS_PROB[LOOP]*10.0);
                ss_fit = 0.3 - (target_data->residue[target_res_num].SS_PROB[LOOP]);
        }
        return (ss_fit);
}


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

  int k,index;

  index = solvent_sec_struct(template_data,template_res_num);

  if (index==-1)
    return (0.0);
  
  pValType singleton=0.0;
  for (k=0;k<20;k++) {
    singleton = singleton + param->SINGLETON[k][index]*target_data->residue[target_res_num].FREQ[k];
  }

  return (singleton);

}


int solvent_sec_struct(TemplateStruct *template_data,
                       int template_res_num)
{

  int i,max;

  switch (template_data->residue[template_res_num].SS)
  {
    case 'H': i=0; break;
    case 'G': i=0; break;
    case 'I': i=0; break;
    case 'E': i=3; break;
    case 'B': i=3; break;
    default : i=6; break;
  }

  switch (template_data->residue[template_res_num].RS)
  {
    case 'A': max = 101; break;
    case 'C': max = 127; break;
    case 'D': max = 161; break;
    case 'E': max = 195; break;
    case 'F': max = 214; break;
    case 'G': max = 73;  break;
    case 'H': max = 193; break;
    case 'I': max = 174; break;
    case 'K': max = 200; break;
    case 'L': max = 182; break;
    case 'M': max = 192; break;
    case 'N': max = 171; break;
    case 'P': max = 127; break;
    case 'Q': max = 190; break;
    case 'R': max = 242; break;
    case 'S': max = 122; break;
    case 'T': max = 144; break;
    case 'V': max = 148; break;
    case 'W': max = 259; break;
    case 'Y': max = 235; break;
    default : max = -1;  break;
  }

  if (max==-1)
    return (-1);

  pValType check;
  check = (pValType)template_data->t_residue_info[template_res_num].ACC/(pValType)max;

  if (check <= 0.069) {
    return (i+0);
  } else if (check <= 0.368) {
    return (i+1);
  } else {
    return (i+2);
  }

}


pValType calc_contact_frozen(ProspectParam *param,
                                                         TemplateStruct *template_data,
                                                         TargetStruct *target_data,
                                                         int template_res_num,
                                                         int target_res_num) {
        int count = 0;
        if ( !template_data->structure )
                return 0;
        
        for (int i = 0; i < template_data->len; i++) {
                if ( i != template_res_num ) {
                        if ( smDistance( template_data->structure[i].atom[ template_data->structure[i].bb_num[ anCb ] ], 
                                                         template_data->structure[template_res_num].atom[ template_data->structure[template_res_num].bb_num[ anCb ] ] )
                                 < PairDistCutoffSqrt ) {
                                count++;
                        }
                }
        }
        if (count < MaxContactCount ) {
                pValType score = 0.0;
                for (int i = 0; i < 20; i++) 
                        score += target_data->residue[ target_res_num ].FREQ[i] * param->CONTACT_MATRIX[ i ][ count ];
                return score;
        }
        return 3200;
}


pValType calc_twobody_frozen(ProspectParam *param,
                                 TemplateStruct *template_data,
                                 TargetStruct *target_data,
                                 int template_res_num,
                                 int target_res_num) {
        pValType score = 0;
        long i,j,k;
        if ( !template_data->twobody_interactions) 
                return 0;
        
        for (i = 0; i < template_data->twobody_count; i++) {
        if (template_data->twobody_interactions[i].core_number[0] != -1 &&
                        template_data->twobody_interactions[i].core_number[1] != -1 &&
                        template_data->twobody_interactions[i].core_number[0] != template_data->twobody_interactions[i].core_number[1]) {
                        if (template_res_num == template_data->twobody_interactions[i].residue_number[0]) {
/*
                                for (j=0; j<20; j++) {
                                        for (k=0; k<20; k++) {
                                                        score += target_data->residue[target_res_num].FREQ[j] * 
                                                                 template_data->residue[template_data->twobody_interactions[i].residue_number[1]].PROFILE[k] *
                                                                 param->PAIR_POT[j][k];
      
                                                }
                                        } 
 */
                                        score += param->PAIR_POT[ AA1toAANum(target_data->residue[target_res_num].RS) ]
                                        [ AA1toAANum(template_data->residue[template_data->twobody_interactions[i].residue_number[1]].RS) ];
                                        
                        }
                        if (template_res_num == template_data->twobody_interactions[i].residue_number[1]) {
/*
                                for (j=0; j<20; j++) {
                                        for (k=0; k<20; k++) {
                                                        score += target_data->residue[target_res_num].FREQ[j] * 
                                                                 template_data->residue[template_data->twobody_interactions[i].residue_number[0]].PROFILE[k] *
                                                                 param->PAIR_POT[j][k];
      
                                                }
                                        } 
 */
                                        score += param->PAIR_POT[ AA1toAANum(target_data->residue[target_res_num].RS) ]
                                        [ AA1toAANum(template_data->residue[template_data->twobody_interactions[i].residue_number[0]].RS) ];
                                        
                        }
        }
    }   
        return score;      
}


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) {
        if ( ABS( (template_res_num_1 - template_res_num_2) ) > MinDistTwoBody &&
                 template_data->cb_dist[ template_res_num_1 ][template_res_num_2 ] <= PairDistCutoffSqrt ) {
                assert( target_res_num_1 >= 0 && target_res_num_1 < target_data->len && target_res_num_2 >= 0 && target_res_num_2 < target_data->len);
                assert( target_data->residue[ target_res_num_1 ].orig_num >= 0 && target_data->residue[ target_res_num_1 ].orig_num < target_data->len &&
                                target_data->residue[ target_res_num_2 ].orig_num >= 0 && target_data->residue[ target_res_num_2 ].orig_num < target_data->len );
                return target_data->twobody[ target_data->residue[ target_res_num_1 ].orig_num ][ target_data->residue[ target_res_num_2 ].orig_num ];
        } else 
                return 0;
}


pValType calc_twobody_val(ProspectParam *param,
                    TargetStruct *target_data,
                    int target_res_num_1, int target_res_num_2) {
        int i,j;
        pValType twobody = 0.0;
        twobody = 0;
        if ( param->simple_twobody ) {
                return param->PAIR_POT[ AA1toAANum( target_data->residue[target_res_num_1].RS ) ]
                [ AA1toAANum( target_data->residue[target_res_num_2].RS ) ];
        } else {
                for (i=0;i<20;i++) {
                        for (j=0;j<20;j++) {                    
                                twobody += target_data->residue[target_res_num_1].FREQ[i] * 
                                target_data->residue[target_res_num_2].FREQ[j] *
                                param->PAIR_POT[i][j];
                        }
                }       
        }
        return (twobody);
}


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) {
        long i;
        if (target_res_num_1 >= 0 && target_res_num_1 < target_data->len &&
                target_res_num_2 >= 0 && target_res_num_2 < target_data->len &&
                template_res_num_1 >= 0 && template_res_num_1 < template_data->len &&
                template_res_num_2 >= 0 && template_res_num_2 < template_data->len ) {
                pValType dist = template_data->cb_dist[ template_res_num_1 ][ template_res_num_2 ];
                
#if 0
                for (i = 0; i < param->dfire.bin_count; i++) {
                        if ( param->dfire.bin_min[i] <= dist && param->dfire.bin_max[i] > dist) {
                                return param->dfire.bin[i][ AA1toAANum(target_data->residue[target_res_num_1].RS) ]
                                [ AA1toAANum(target_data->residue[target_res_num_2].RS) ];
                        }
                }
#else
                i = (long)(dist * 10.0);
                if (i < param->dfire.dist_hash_size && param->dfire.dist_hash[i] != -1) {
                        return param->dfire.bin[ param->dfire.dist_hash[i] ][ AA1toAANum(target_data->residue[target_res_num_1].RS) ]
                        [ AA1toAANum(target_data->residue[target_res_num_2].RS) ];
                }
#endif
        }
        return 0;
}


pValType calc_dfire( ProspectParam *param, char res_a, char res_b, float dist ) {
        long i = (long)(dist * 10.0);
        if (i < param->dfire.dist_hash_size && param->dfire.dist_hash[i] != -1) {
                return param->dfire.bin[ param->dfire.dist_hash[i] ]
                [ AA1toAANum(res_a) ]
                [ AA1toAANum(res_b) ];
        }
        return 0;       
}
                                         

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 score = 0;
        long i;
        
        if (target_data->distconst) {
                for (i = 0; i < target_data->distconst_count; i++) {
                        if ( (target_data->distconst[i].aa[0] == target_res_num_1 &&
                                  target_data->distconst[i].aa[1] == target_res_num_2) ||
                                 (target_data->distconst[i].aa[1] == target_res_num_1 &&
                                  target_data->distconst[i].aa[0] == target_res_num_2) ) {
                                if ( fabs( template_data->cb_dist[ template_res_num_1 ][ template_res_num_2 ] - 
                                                  target_data->distconst[i].dist) < target_data->distconst[i].var ) {
                                        score--;
                                } else {
                                //      printf("distconst: %f %f\n", template_data->cb_dist[ template_res_num_1 ][ template_res_num_2 ],
                                //                 target_data->distconst[i].dist);
                                }
                        }
                }               
        }
        
        return score;
}



float residue_max_sasa[21] = {
        //measured by DSSP
        240.0 , // A max:
        295.0 , // R max: 
        221.0 , // N max: 
        247.0 , // D max: 
        174.0 , // C max: 
        245.0 , // Q max: 
        254.0 , // E max: 
        262.0 , // G max: 
        254.0 , // H max: 
        235.0 , // I max: 
        234.0 , // L max: 
        318.0 , // K max: 
        242.0 , // M max: 
        246.0 , // F max: 
        230.0 , // P max: 
        238.0 , // S max: 
        217.0 , // T max: 
        262.0 , // W max: 
        290.0 , // Y max: 
        227.0 , // V max: 
        1
};

float residue_ave_sasa[21] = {
/*
    //These averages are from the PopsR methods
        46.9261382097 , // A
        57.3720124498 , // R
        63.7989959076 , // N
        68.5261292949 , // D
        34.9587602287 , // C
        59.4041861357 , // Q
        65.0916408168 , // E
        63.612917346 , // G
        58.1849100782 , // H
        40.8545366915 , // I
        43.1632268618 , // L
        63.2779060589 , // K
        52.5770223822 , // M
        43.48384953 , // F
        66.5627212905 , // P
        61.2538013547 , // S
        54.7516852259 , // T
        44.1986291123 , // W
        44.6581405873 , // Y
        41.2469820032 , // V
*/
        //These averages are from DSSP
        35.7522151899 , // A max: 240.0
        102.584053794 , // R max: 295.0
        74.2146892655 , // N max: 221.0
        76.1526104418 , // D max: 247.0
        26.4561101549 , // C max: 174.0
        83.9657701711 , // Q max: 245.0
        88.9936708861 , // E max: 254.0
        38.6197583511 , // G max: 262.0
        69.592469546 , // H max: 254.0
        37.14604811 , // I max: 235.0
        41.0129971406 , // L max: 234.0
        99.2901748543 , // K max: 318.0
        55.1653439153 , // M max: 242.0
        48.2477650064 , // F max: 246.0
        61.3702882483 , // P max: 230.0
        52.223880597 , // S max: 238.0
        55.0547826087 , // T max: 217.0
        61.4861878453 , // W max: 262.0
        63.7211838006 , // Y max: 290.0
        35.5517128874 , // V max: 227.0
        
        1.0
};


pValType calc_del_val(ProspectParam *param,
                                          WeightArray weights,
                                          TemplateStruct *template_data,
                                          TargetStruct *target_data, 
                                          int template_res_num, int target_res_num ) {
        pValType total = 0.0;
        if ( weights[ e_tsingledel ] != 0.0 ) {
                total += weights[ e_tsingledel ]  * calc_singledel( param, template_data, template_res_num );
        }
        if ( weights[ e_coredel ] != 0.0 ) {
                total += weights[ e_coredel ] * calc_coredel( param, template_data, template_res_num );
        }
        if ( weights[ e_contactdel ] != 0.0 ) {
                total += weights[ e_contactdel ] * calc_contactdel( param, template_data, template_res_num );
        }
        if ( weights[ e_qsingleins ] != 0.0 ) {
                total += weights[ e_qsingleins ] * target_data->residue[ target_res_num ].single_ins;
        }
        
        return total;
}
        

pValType calc_ins_val( ProspectParam *param,
                                           WeightArray weights,
                                           TemplateStruct *template_data,
                                           TargetStruct *target_data, 
                                           int template_res_num, int target_res_num ) {
        pValType total = 0.0;
        if ( weights[ e_tsingleins ] != 0.0 ) {
                total += weights[ e_tsingleins ] * calc_singleins(param, template_data, template_res_num);
        }
        if ( weights[ e_qsingledel ] != 0.0 ) {
                total += weights[ e_qsingledel ] * target_data->residue[ target_res_num ].single_del;
        }
        return total;
}

        
pValType calc_singledel(ProspectParam *param,
                                         TemplateStruct *template_data,
                                         int template_res_num) {
        return (template_data->residue[template_res_num].single_del);
        //int res = AA1toAANum( template_data->residue[template_res_num].RS );
        //return (residue_max_sasa[ res ] - template_data->residue[template_res_num].ACC) / residue_ave_sasa[res]; 
        //return 1.0 - (template_data->residue[template_res_num].ACC / residue_ave_sasa[res]) ;
        //return residue_ave_sasa[res] - template_data->residue[template_res_num].ACC;
}


pValType calc_coredel(ProspectParam *param,
                                          TemplateStruct *template_data,
                                          int template_res_num) {
        if ( template_data->t_residue_info == NULL || 
                 template_data->cores == NULL || 
                 template_data->t_residue_info[ template_res_num ].core_num == -1 )
                return 0;
        
        return 1.0 / (float) ( template_data->cores[ template_data->t_residue_info[ template_res_num ].core_num ].len );
        
}

pValType calc_contactdel(ProspectParam *param,
                                                  TemplateStruct *template_data,
                                                  int template_res_num) {
        float total_contact = 0;
        ResidueAtoms *res_1 = &template_data->structure[ template_res_num ];
        for ( int i = 0; i < template_data->len; i++ ) {
                if ( i != template_res_num ) {
                        ResidueAtoms *res_2 = &template_data->structure[i];
                        float dist = smDistance( res_1->atom[ res_1->bb_num[ anCa ] ], 
                                                                         res_2->atom[ res_2->bb_num[ anCa ] ] );
                        if ( dist < 7.6 ) {
                                total_contact++;
                        }
                }
        }
        return total_contact;
}


pValType calc_singleins(ProspectParam *param,
                                                TemplateStruct *template_data,
                                                int template_res_num) {
        return (template_data->residue[template_res_num].single_ins);
}


#define kCoreMinSize   6
#define filter_cut     0.01

//FIXME:  This should be defined closer to the neural network
//mutation,singleton,sec_struct
char energy_mask[ e_count ] = {1,0,0,0,1,1,0,0,0,0,0};


int ss_filter(ProspectParam *param,
                TemplateStruct *template_data,
                TargetStruct *target_data,
                int core_num, int core_position) {
        //BUG:: This is all outdated code
        
        /*
  pValType score = 0;           
  long i, j;
  pValType energy_out[ e_count ];
  float energy_nn[ e_count ], filter_out;

 // calc_core_single_energies(param, template_data, target_data, core_num, core_position, energy_out );
  j = 0;
  for (i = 0; i < e_count; i++) {
    if (energy_mask[i]) {
      energy_nn[j] = energy_out[i];
      j++;
    }
  }
  filter_net( energy_nn, &filter_out, 1);
  if (filter_out > filter_cut) 
    return 1;
  */
        
  return 0;
}

---