new_perm.cpp

在任务级并行平台P2HP上开发的demo应用

#include "Unit1.h"
#include "New_Perm.h"

char *FileNam = "F:\论文\P2P\MyArtical\基于免疫算法的蛋白质结构预测\code\SC lattice\data\48.1.txt";
char *FileNam_Out = "F:\论文\P2P\MyArtical\基于免疫算法的蛋白质结构预测\code\SC lattice\output\1111111.txt";

/*******************************************************
***                                                  ***
***                  二、全局变量定义                ***
***                                                  ***
*******************************************************/


#define Edge 0
#define Ehh 1
#define Ehp 0
#define Epp 0
#define Ratio 70
#define Vectors 6




double C = 1 ;                                 // 系数
double Z0 = 1 ;                                // 系数
double Exp1T = 50 ;

typedef struct{                     //构型的绝对坐标位置
                int x;
                int y;
                int z;
                       }Coordinate_XYZ[ Num ];


                       
int Data[ Num ];                    // HP数据 0:P,1:H
int Best_Energy;                   // 找到的最优势能
int New_Best_Energy;               // 重新定义后的能量
int Cur_Energy;                     // 当前点的势能值
int New_Cur_Energy;                     // 当前点的势能值
int Optimized_Energy;               // 客观最优势能值

int Num_Processed;                  // 当前已放入的球数目
//*************设为两倍是为另外充分的容纳结构到里面去
int Judgement[ 2 * Num - Edge ][ 2 * Num - Edge ][ 2 * Num - Edge ]; // 判断矩阵
Coordinate_XYZ Coordinate;           // 当前点的绝对坐标
Coordinate_XYZ Best_Coordinate;      // 最好点的绝对坐标
double Converted_Coordinate[ Num ][ 2 ];      // 画图时转换后的坐标

double Weight[ Num ];          // 当前长度为i的链的好度  //******这个是否指的是weight????
double Average_Weight[ Num ];  // 所有Weight[i]平均值    //*******这个是否就是指Zn?????
long int Number_Len[ Num ];    // 长度为 i 的链的数量     //*******难道每个round都被清为1

double Uper_Threshold;         // 当前的好度上限阈值
double Down_Threshold;         // 当前的好度下限阈值
double Weight_Predict;         // 当前的权重的预测值
double Quality[Vectors];                  // 当前所有动作的好度   //****一共是6个方向
//     int    K_Free_Next[Vectors];              // 当前动作后K_Free值
//************************这两个Increasement有什么区别？？？？？？？？？？？
int    E_Increasement[Vectors];           // 当前动作新增势能值
int    New_E_Increasement[Vectors];       // 新定义当前动作新增势能值
double Total_Quality ;              // 当前各个动作值之和
double Average_Quality ;            // 当前各个动作平均值
int    K_Free;                      // 当前可能的动作总数
int    K_Copy;                      // 当前复制的路径数目
int    Time_Start,Time_End ;
//long int    Number_Of_Energy[ 100 ];

double Three_To_Two[ Num ][ 2 ];

int Base[ Vectors ][ 3 ] = { {0,0,1}, {0,0,-1}, {0,1,0}, {0,-1,0},  {1,0,0},  {-1,0,0} };

int Time_Consuming ;
/*******************************************************
***                                                  ***
***                三、初始化部分子函数              ***
***                                                  ***
*******************************************************/

/*******************************************************
***                                                  ***
***                 Func 3.1: 读入数据               ***
***                                                  ***
*******************************************************/
void Reading_Data( )
{
  int i;
  FILE *fp;
  fp = fopen( FileNam, "r");

  if( fp == NULL )
    {
      printf("\n无法打开数据文件,请重试!\n");
      return;
     }

  for( i = 0; i < Num; i++ )
    fscanf( fp, "%d", &Data[ i ]);
  fscanf( fp, "%d", &Optimized_Energy );
  fclose( fp );
  free( fp );
  return;
 }

//**********转换数据从另外一边开始进行折叠


/*******************************************************
***                                                  ***
***                 Func 3.2: 返转数据               ***
***                                                  ***
*******************************************************/
void Reverting_Data( )
{
 int i ;
 int temp ;
 for ( i = 0 ; i < Num / 2 ; i ++ )
  {
    temp = Data[ i ] ;
    Data[ i ] = Data[ Num - 1 - i ] ;
    Data[ Num - 1 - i ] = temp ;
  }
  return ;
 }


//****************************************************************

//**********输出了部分解
/*******************************************************
***                                                  ***
***             Func 3.3: 文本输出最优解             ***
***                                                  ***
*******************************************************/
 void Outputing_Data( )
{
  int i;
  FILE *fp ;
  fp = fopen( FileNam_Out, "ab");

  if( fp == NULL )
    {
      printf("\n无法打开数据文件,请重试!\n");
      return;
     }

  for ( i = 0; i < Num ; i ++ )
   {
    fprintf( fp, "%d  %d  %d    ", Coordinate[ i ].x,
                        Coordinate[ i ].y, Coordinate[ i ].z );
   }
  fprintf( fp, "E = %d           Time= %d           \n  ",New_Cur_Energy,  Time_Consuming/1000 );
  fclose( fp );
  free( fp );

  return;
 }



/*******************************************************
***                                                  ***
***           Func 3.2: 计算各动作的好度：           ***
***                 Quality及其各参数                ***
***                                                  ***
*******************************************************/
void Computing_Quality( )
{
  register int i, k ;
  register int x,y,z;
  int ex, ey, ez;

  x = Coordinate[ Num_Processed - 1 ].x;
  y = Coordinate[ Num_Processed - 1 ].y;
  z = Coordinate[ Num_Processed - 1 ].z;

  K_Free = 0;
  double total_e;
  for( i = 0 ; i < Vectors ; i ++ )
   {
//    K_Free_Next[ i ] = 0 ;
    E_Increasement[ i ] = 0 ;
    New_E_Increasement[ i ] = 0 ;
    Quality[ i ] = 0 ;
   }
  // 先对基向量赋初值
  // 依次计算Vectors个动作各参数:


  for( k = 0 ; k < Vectors ; k ++ )
  {
    //方向为k：
    if( Judgement[ x + Base[ k ][ 0 ] ][ y + Base[ k ][ 1 ] ][ z + Base[ k ][ 2 ] ] != 0 )
      Quality[ k ] = 0;   // 此动作非法，已被占用。
    else                  // 此动作合法，可被利用。
      {
        K_Free ++ ;       // K_Free加一
        ex = x + Base[ k ][ 0 ] ;
        ey = y + Base[ k ][ 1 ] ;
        ez = z + Base[ k ][ 2 ] ;
        //******************计算这个的时候是否有问题？？？没有把前继情况去除 ？？？
        if( Data[ Num_Processed ] == 1 )
          {
                  // 为H,算黑切点 : 第k个方向与和它相邻的球构成的黑切点
                  for( i = 0 ; i < Vectors ; i ++ )
                   {
                    if( ( Judgement[ ex + Base[ i ][ 0 ] ][ ey + Base[ i ][ 1 ] ][ ez + Base[ i ][ 2 ] ] != 0 )&&
                      ( Data[ Judgement[ ex + Base[ i ][ 0 ] ][ ey + Base[ i ][ 1 ] ][ ez + Base[ i ][ 2 ] ] - 1 ] == 1 ) )
                              E_Increasement[ k ] += Ehh ;
                    }

                  New_E_Increasement[ k ] = E_Increasement[ k ] ;

                  // 为H,算HP排斥能量
                  for( i = 0 ; i < Vectors ; i ++ )
                   {
                    if( ( Judgement[ ex + Base[ i ][ 0 ] ][ ey + Base[ i ][ 1 ] ][ ez + Base[ i ][ 2 ] ] != 0 )&&
                      ( Data[ Judgement[ ex + Base[ i ][ 0 ] ][ ey + Base[ i ][ 1 ] ][ ez + Base[ i ][ 2 ] ] - 1 ] == 0 ) )
                              New_E_Increasement[ k ] += Ehp ;
                    }
          }  // if

        if( Data[ Num_Processed ] == 0 )
          {
                  // 为P,算白切点
                  for( i = 0 ; i < Vectors ; i ++ )
                   {
                    if( ( Judgement[ ex + Base[ i ][ 0 ] ][ ey + Base[ i ][ 1 ] ][ ez + Base[ i ][ 2 ] ] != 0 )&&
                      ( Data[ Judgement[ ex + Base[ i ][ 0 ] ][ ey + Base[ i ][ 1 ] ][ ez + Base[ i ][ 2 ] ] - 1 ] == 0 ) )
                              New_E_Increasement[ k ] += Epp ;
                    }

                  // 为P,算PH排斥能量
                  for( i = 0 ; i < Vectors ; i ++ )
                   {
                    if( ( Judgement[ ex + Base[ i ][ 0 ] ][ ey + Base[ i ][ 1 ] ][ ez + Base[ i ][ 2 ] ] != 0 )&&
                      ( Data[ Judgement[ ex + Base[ i ][ 0 ] ][ ey + Base[ i ][ 1 ] ][ ez + Base[ i ][ 2 ] ] - 1 ] == 1 ) )
                              New_E_Increasement[ k ] += Ehp ;
                    }
          }  // if

         Quality[ k ] = pow( Exp1T , New_E_Increasement[ k ] );
       }    // else
     } // for k
     total_e = 0 ;
     for( i = 0 ; i < Vectors ; i ++ )
       total_e += New_E_Increasement[ i ] ;

     //为什么要计算平均好度呢？？？？？？
     if( K_Free > 0 )
       total_e /= K_Free ;
     Average_Quality = pow(Exp1T , total_e );

     Total_Quality = 0 ;
     for( i = 0 ; i < Vectors ; i ++ )
      Total_Quality += Quality[ i ] ;
 }


/*******************************************************
***                                                  ***
***               Func 3.3: 选择一个位置             ***
***                                                  ***
*******************************************************/
int Selecting_Operation( )
{
  int i;
  double operation;
  double Q_Sum[Vectors + 1 ];
  int x , y , z ;           // 标记上一个点位置
  x =  Coordinate[ Num_Processed - 1 ].x ;
  y =  Coordinate[ Num_Processed - 1 ].y ;
  z =  Coordinate[ Num_Processed - 1 ].z ;


  //***************建造出一个区间来进行选择   这些是在情况a,b的时候进行的操作

  // 求出前i个方向的质量和
  Q_Sum[ 0 ] = 0 ;
  for( i = 1 ; i < Vectors + 1  ; i ++ )
     Q_Sum[ i ] = Q_Sum[ i - 1 ] + Quality[ i - 1 ] / Total_Quality ;

  operation =(double)( rand( )%1000) / 1000 ;
                        // 产生一[0，1）随机数
  for( i = 1 ; i <= Vectors ; i ++ )
   {
    if ( operation <= Q_Sum[ i ] && operation > Q_Sum[ i - 1 ] ) // 选定第i个方向,作此动作
       {
         return (i-1) ;
         break;
       }
   } // for
}


/*******************************************************
***                                                  ***
***        Func 3.4: 初始化数据并产生初始解          ***
***                                                  ***
*******************************************************/

void Initializing( )
{
  int i,j,k;
  int ex,ey,ez;
  int flag = 0 ;
  int select ;
  Best_Coordinate[ 0 ].x = Num - 1 ;
  Best_Coordinate[ 0 ].y = Num - 1 ;
  Best_Coordinate[ 0 ].z = Num - 1 ;
  Best_Coordinate[ 1 ].x = Best_Coordinate[ 0 ].x + Base[ 0 ][ 0 ] ;
  Best_Coordinate[ 1 ].y = Best_Coordinate[ 0 ].y + Base[ 0 ][ 1 ] ;
  Best_Coordinate[ 1 ].z = Best_Coordinate[ 0 ].z + Base[ 0 ][ 2 ] ;
  Coordinate[ 0 ].x = Num - 1 ;
  Coordinate[ 0 ].y = Num - 1 ;
  Coordinate[ 0 ].z = Num - 1 ;
  Coordinate[ 1 ].x = Best_Coordinate[ 0 ].x + Base[ 0 ][ 0 ] ;
  Coordinate[ 1 ].y = Best_Coordinate[ 0 ].y + Base[ 0 ][ 1 ] ;
  Coordinate[ 1 ].z = Best_Coordinate[ 0 ].z + Base[ 0 ][ 2 ] ;

  Weight[ 0 ] = 1 ;
  Weight[ 1 ] = 1 ;

  while( flag == 0 )         // 直到产生合法初始点为止
    {
                             // 每一次都要初始判断矩阵　
      for( i = 0 ; i < 2 * Num - Edge ; i ++ )
       for( j = 0 ; j < 2 * Num - Edge ; j ++ )
        for( k = 0 ; k < 2 * Num - Edge ; k ++ )
        Judgement[ i ][ j ][ k ] = 0 ;


      //*******************将第几位放到里面去
      Judgement[ Num - 1 ][ Num - 1 ][ Num - 1 ] = 1 ;
      Judgement[ Num - 1 ][ Num - 1 ][ Num ] = 2 ;

      Num_Processed = 2 ;
      Cur_Energy = 0 ;       // 重新开始，势能为0
      New_Cur_Energy = 0 ;       // 重新开始，势能为0

      // 按Quality依次随机产生各个方向
      while( Num_Processed < Num )
       {
         Computing_Quality( );

         if ( K_Free == 0 )  // 如果无动作可作从头开始
          {
            flag = 0 ;
            break;
           }                 // if

         else                // 此时一定有合法动作可作
          {
                             // 记录上一木块的坐标位置
            select = Selecting_Operation( ) ;
                             // 选择一动作并作此动作
            //***********************为什么这里不除以温度T?????                 
            Weight[ Num_Processed ] = Weight[ Num_Processed - 1 ]
                                      * pow( Exp1T , New_E_Increasement[ select ] ) ;

            ex = Coordinate[ Num_Processed - 1 ].x + Base[ select ][ 0 ] ;
            ey = Coordinate[ Num_Processed - 1 ].y + Base[ select ][ 1 ] ;
            ez = Coordinate[ Num_Processed - 1 ].z + Base[ select ][ 2 ] ;
            Judgement[ ex ][ ey ][ ez ] = Num_Processed + 1 ;

            Coordinate[ Num_Processed ].x = ex ;
            Coordinate[ Num_Processed ].y = ey ;
            Coordinate[ Num_Processed ].z = ez ;

            Cur_Energy += E_Increasement[ select ];
            New_Cur_Energy += New_E_Increasement[ select ];

            Num_Processed ++ ;
                             // 因为其为全局变量需改变
           } // else

        } // while

       if( Num_Processed == Num )
                             // 已产生合法的初始解
        {
           flag = 1 ;        // 退了while循环
           Best_Energy = Cur_Energy ;
           New_Best_Energy = New_Cur_Energy ;

           //****************记录下了第一次计算的信息
           for( i = 0 ; i < Num ; i ++ )
           {