p2_workcomp2.c

序列对齐 Compare a protein sequence to a protein sequence database or a DNA sequence to a DNA sequenc

/*****************************************************************/
/* Do do_opt() from list   s_func=DO_CALC_FLG                    */
/*****************************************************************/

    else if (qm_msg.s_func== DO_CALC_FLG) {  /* qm_msg.slist > 0 */

      bestcnt = 0;
      for (count=0; count < qm_msg.slist; count++) {
	rst.score[0] = rst.score[1] = rst.score[2] = -BIGNUM;
	itt = liblist[count].frame;
	seqnm = bestr2[bestcnt].seqnm  = liblist[count].seqnm;
	bestr2[bestcnt].m_seqnm = seqpt[seqnm].m_seqnm;

	do_opt (aa0[itt], qm_msg.n0, seqpt[seqnm].aa1,
		 seqpt[seqnm].n1, itt,
		 &pst, f_str[itt], &bestr[bestcnt].rst);

	bestr2[bestcnt].aln_code_n = 0;
	bestcnt++;

	if (bestcnt >= BFR2) {
	  send_bestr2(hosttid,bestr2,bestcnt);
	  bestcnt = 0;
	}
      }	/* END - for count loop */

      send_bestr2(hosttid,bestr2,(bestcnt|FINISHED));
    }

/*****************************************************************/
/* s_func=DO_OPT_FLG                                             */
/*                                                               */
/* from list:                                                    */
/* if (m_msg.stages > 1) do_opt()                                */
/* do_walign()                                                   */
/* calc_id or calc_code, no calcons                              */
/*****************************************************************/

    /* s_func == 1 means do_opt if necessary */
    else if (qm_msg.s_func== DO_OPT_FLG) {  /* qm_msg.slist > 0 */
#ifdef DEBUG
      fprintf(stderr," [%d] starting s_func:1 slist: %d\n",
	      worker,qm_msg.slist);
#endif
      /* get the buffer once - re-use it for the entire slist */
      if (m_msg.show_code == SHOW_CODE_ALIGN) {
	seqc_buff_len = (BFR2+5)*256;
	seqc = seqc_buff = (char *)calloc(seqc_buff_len,sizeof(char));
	seqc_buff_cnt = 0;
	if (seqc_buff == NULL) {
	  seqc_buff_cnt = seqc_buff_len = 0;
	}
      }

      bestcnt = 0;
      for (count=0; count < qm_msg.slist; count++) {
	rst.score[0] = rst.score[1] = rst.score[2] = -BIGNUM;
	itt = liblist[count].frame;
	seqnm = liblist[count].seqnm;

	bestr2[bestcnt].seqnm  = seqnm;
	bestr2[bestcnt].m_seqnm = seqpt[seqnm].m_seqnm;
	if (m_msg.stages > 1) {
	  do_opt (aa0[itt], qm_msg.n0, seqpt[seqnm].aa1,
		  seqpt[seqnm].n1, itt,
		  &pst, f_str[itt], &bestr[bestcnt].rst);
	}

	if (m_msg.markx & MX_M9SUMM) {
#ifdef DEBUG
	  fprintf(stderr," [%d] starting do_walign seqnm: %d n1: %d\n",
		  worker,seqnm,seqpt[seqnm].n1);
#endif
	  aln_dp = &bestr2[bestcnt].aln_d;
	  memcpy(aln_dp, &aln,sizeof(struct a_struct));

	  do_walign(aa0[itt], qm_msg.n0,
		    seqpt[seqnm].aa1, seqpt[seqnm].n1,
		    itt, &pst, f_str[itt],
		    &seqpt[seqnm].a_res[itt],
		    &have_walign);

	  sw_score = seqpt[seqnm].sw_score[itt] = seqpt[seqnm].a_res[itt].sw_score;

	  /* the a_res[itt] provided by do_walign is re-used - so it
	     must be copied to a valid location */

	  if (have_walign && !(have_walign & 0x2)) {
	    if ((tres = calloc(seqpt[seqnm].a_res[itt].nres+1,sizeof(int)))==NULL) {
	      w_abort(" cannot allocate tres","");
	    }
	    else {
	      memcpy(tres,seqpt[seqnm].a_res[itt].res,sizeof(int)*seqpt[seqnm].a_res[itt].nres);
	      seqpt[seqnm].a_res[itt].res = tres;
	      /*
		fprintf(stderr, " [%d] saving %d:%d[%d]:%o\n", worker, 
		walign_cnt[itt],seqnm,itt, seqpt[seqnm].a_res[itt].res);
	      */
	      if (walign_cnt[itt] < lcnt) walign_done[itt][walign_cnt[itt]++] = seqnm;
	      else w_abort(" walign_cnt overrun","");
	      seqpt[seqnm].walign_dflg[itt] = 1;
	    }
	  }
	  aln_func_vals(itt, aln_dp);

#ifdef DEBUG
	  fprintf(stderr," [%d] starting calc_id sw_score: %d\n",
		  worker,sw_score);
	  fprintf(stderr,"bi: %d seqc_buff_cnt: %d - seqc_buff_len: %d\n",
		  bestcnt, seqc_buff_cnt, seqc_buff_len);
#endif
	  aln_code_n = 0;	/* must be set in case no seqc_code */

	  if (m_msg.show_code == SHOW_CODE_ALIGN) {
	    if (seqc_buff_cnt < seqc_buff_len - 256) {
	      lc=calc_code(aa0[itt],qm_msg.n0,
			   seqpt[seqnm].aa1, seqpt[seqnm].n1,
			   aln_dp,&seqpt[seqnm].a_res[itt],&pst,
			   seqc,seqc_buff_len-seqc_buff_cnt-10,
			   NULL, NULL, NULL, 0,
			   f_str[itt]);
	      aln_code_n = strlen(seqc);
	      seqc_buff_cnt += aln_code_n + 1;
/*
	      fprintf(stderr,"%d:%d:%d: %d/%d - [%d] %s\n",
		      worker,seqnm,bestcnt,aln_code_n,seqc_buff_cnt, seqc-seqc_buff,seqc);
*/
	      seqc += aln_code_n;
	      *seqc++ = '\0';
	    }
	  }
	  else {
	    lc=calc_id(aa0[itt],qm_msg.n0,
		       seqpt[seqnm].aa1, seqpt[seqnm].n1,
		       aln_dp,&seqpt[seqnm].a_res[itt],&pst,f_str[itt]);
	  }

	  nident = aln_dp->nident;
	  aln_dp->a_len = lc;

	  if (lc > 0) percent = (100.0*(float)nident)/(float)lc;
	  else percent = 0.0;

	  ngap = aln_dp->ngap_q + aln_dp->ngap_l;
#ifndef SHOWSIM
	  if (lc-ngap > 0) gpercent = (100.0*(float)nident)/(float)(lc-ngap);
#else
	  if (lc > 0) gpercent =(100.0*(float)aln_dp->nsim)/(float)lc;
#endif
	  else gpercent = -1.0;

	  bestr2[bestcnt].sw_score = sw_score;
	  bestr2[bestcnt].percent = percent;
	  bestr2[bestcnt].gpercent = gpercent;
	  bestr2[bestcnt].aln_code_n = aln_code_n;
	}
	bestcnt++;

	if (bestcnt >= BFR2) {
	  send_bestr2(hosttid,bestr2,bestcnt);
	  if (m_msg.show_code == SHOW_CODE_ALIGN) {
	    send_code(hosttid,seqc_buff,seqc_buff_cnt);
	    memset(seqc_buff,0,seqc_buff_len);
	    seqc = seqc_buff;
	    seqc_buff_cnt = 0;
	  }
	  bestcnt = 0;
	}
      }	/* END - for count loop */

      send_bestr2(hosttid,bestr2,(bestcnt|FINISHED));
      if (m_msg.show_code == SHOW_CODE_ALIGN) {
	send_code(hosttid,seqc_buff,seqc_buff_cnt);
	if (seqc_buff) free(seqc_buff);
      }
    }
    /* get alignments */

/*****************************************************************/
/* s_list >                                                      */
/* s_func=DO_ALIGN_FLG                                           */
/*                                                               */
/* from list:                                                    */
/* do_walign() if not done already                               */ 
/* calcons()                                                     */
/*****************************************************************/

    else if (qm_msg.s_func==DO_ALIGN_FLG) {
      for (count=0; count < qm_msg.slist; count++) {
	itt = liblist[count].frame;
	seqnm = liblist[count].seqnm;
/*
	fprintf(stderr,"worker: %d; %s, frame: %d\n",worker,qm_msg.libstr,itt);
*/
	if (!seqpt[seqnm].walign_dflg[itt]) {
	  do_walign (aa0[itt], qm_msg.n0,seqpt[seqnm].aa1,
		     seqpt[seqnm].n1, itt,
		     &pst, f_str[itt],
		     &seqpt[seqnm].a_res[itt],
		     &have_walign);
	  seqpt[seqnm].sw_score[itt] = 
	    sw_score = seqpt[seqnm].a_res[itt].sw_score;
	}
	else {
	  sw_score = seqpt[seqnm].sw_score[itt];
	  pre_cons(seqpt[seqnm].aa1,seqpt[seqnm].n1,itt,f_str[itt]);
	}

	aln_func_vals(itt, &aln);

	if (aln.showall==1)
	  maxc = seqpt[seqnm].a_res[itt].nres + max(seqpt[seqnm].a_res[itt].min0,seqpt[seqnm].a_res[itt].min1)+
	    max((qm_msg.n0-seqpt[seqnm].a_res[itt].max0),
		(seqpt[seqnm].n1-seqpt[seqnm].a_res[itt].max1))+4;
	else  maxc = seqpt[seqnm].a_res[itt].nres + 4*aln.llen+4;

	initseq(&seqc0, &seqc0a, &seqc1, &seqca, maxc);

	nc=calcons_a(aa0[itt],qm_msg.n0,
		     seqpt[seqnm].aa1, seqpt[seqnm].n1,
		     &lc,&aln,&seqpt[seqnm].a_res[itt],&pst,
		     seqc0,seqc1,seqca,
		     m_msg.aa0a,seqc0a,m_msg.ann_arr,
		     f_str[itt]);

	/*
	fprintf(stderr,"[%d] nident: %d nsim: %d lc: %d\n",aln.nident, aln.nsim, lc);
	*/

	maxc = max(strlen(seqc0),strlen(seqc1))+1;
	nident = aln.nident;
	percent = (100.0*(float)nident)/(float)lc;
	ngap = aln.ngap_q+aln.ngap_l;
#ifndef SHOWSIM
	if (lc-ngap > 0) gpercent = (100.0*(float)nident)/(float)(lc-ngap);
#else
	if (lc > 0) gpercent = (100.0*(float)aln.nsim)/(float)lc;
#endif
	else gpercent = -1.0;

#ifdef PVM_SRC
	pvm_initsend(PvmDataRaw);
	pvm_pkint(&nc,1,1);
	pvm_pkint(&lc,1,1);
	pvm_pkint(&maxc,1,1);
	pvm_pkfloat(&percent,1,1);
	pvm_pkfloat(&gpercent,1,1);
	pvm_pkint(&sw_score,1,1);
	pvm_pkbyte((char *)&aln,sizeof(struct a_struct),1);
	pvm_send(hosttid,ALN1TYPE);
#ifdef DEBUG
	fprintf(stderr,"[%d] ALN1TYPE sent: %d\n",worker,qm_msg.n0);
#endif
	pvm_initsend(PvmDataRaw);
	pvm_pkbyte(seqc0,maxc,1);
	if (m_msg.q_ann_flg) pvm_pkbyte(seqc0a,maxc,1);
	pvm_pkbyte(seqc1,maxc,1);
	pvm_pkbyte(seqca,maxc,1);
	pvm_send(hosttid,ALN2TYPE);
#endif
#ifdef MPI_SRC
	last_msg_b[0]=nc;
	last_msg_b[1]=lc;
	last_msg_b[2]=maxc;
	last_msg_b[3]=sw_score;
	MPI_Send(last_msg_b,4,MPI_INT,hosttid,ALN1TYPE,MPI_COMM_WORLD);
	MPI_Send(&percent,1,MPI_FLOAT,hosttid,ALN2TYPE,MPI_COMM_WORLD);
	MPI_Send(&gpercent,1,MPI_FLOAT,hosttid,ALN2TYPE,MPI_COMM_WORLD);

/*	p4_dprintf("[%d] sending aln\n",worker); */
	MPI_Send(&aln,sizeof(struct a_struct),MPI_BYTE,hosttid,
		 ALN3TYPE,MPI_COMM_WORLD);

	MPI_Send(seqc0,maxc,MPI_BYTE,hosttid,ALN2TYPE,MPI_COMM_WORLD);
	if (m_msg.q_ann_flg) MPI_Send(seqc0a,maxc,MPI_BYTE,hosttid,ALN2TYPE,MPI_COMM_WORLD);
	MPI_Send(seqc1,maxc,MPI_BYTE,hosttid,ALN3TYPE,MPI_COMM_WORLD);
	MPI_Send(seqca,maxc,MPI_BYTE,hosttid,ALN3TYPE,MPI_COMM_WORLD);
#endif
	freeseq(&seqc0,&seqc0a,&seqc1,&seqca);
      }	
    }
    
/* send back parameter settings */
    if (worker==FIRSTWORK && qm_msg.slist==0) {
      get_param(&pst, info_gstring2p,info_gstring3);
#ifdef PVM_SRC
      pvm_initsend(PvmDataRaw);
      pvm_pkbyte(info_gstring2[0],MAX_STR,1);
      pvm_pkbyte(info_gstring2[1],MAX_STR,1);
      pvm_pkbyte(info_gstring3,sizeof(info_gstring3),1);
      pvm_pkbyte(lib_range,MAX_SSTR,1);
      pvm_send(hosttid,PARAMTYPE);
#endif
#ifdef MPI_SRC
      MPI_Send(info_gstring2[0],MAX_STR,MPI_BYTE,
	       hosttid,PARAMTYPE,MPI_COMM_WORLD);
      MPI_Send(info_gstring2[1],MAX_STR,MPI_BYTE,
	       hosttid,PARAMTYPE,MPI_COMM_WORLD);
      MPI_Send(info_gstring3,sizeof(info_gstring3),MPI_BYTE,
	       hosttid,PARAMTYPE,MPI_COMM_WORLD);
      MPI_Send(lib_range,MAX_SSTR,MPI_BYTE,
	       hosttid,PARAMTYPE,MPI_COMM_WORLD);
#endif
    }
    
    if (qm_msg.slist==0) {
      if (curtype == ONETYPE) curtype = TWOTYPE;
      else curtype = ONETYPE;
    }
  }	    /* END - while (1) loop */
#ifdef PVM_SRC
  pvm_exit();
#endif
#ifdef MPI_SRC
/*  MPI_Finalize(); */
#endif
}

void
send_bestr(int hosttid, int curtype, 
	   struct comstr *bestr, int buf_size, int lastcnt) {

  bestr[buf_size].seqnm = lastcnt;
#ifdef PVM_SRC
  pvm_initsend(PvmDataRaw);
  pvm_pkbyte((char *)&bestr[0],sizeof(struct comstr)*(buf_size+1),1);
  pvm_send(hosttid,curtype);
#endif
#ifdef MPI_SRC
  MPI_Send(bestr,sizeof(struct comstr)*(buf_size+1),MPI_BYTE,
	   hosttid,curtype,MPI_COMM_WORLD);
#endif
}

void
send_bestr2(int hosttid, struct comstr2 *bestr2,
	    int lastcnt)
{
  bestr2[BFR2].seqnm = lastcnt;
#ifdef PVM_SRC
  pvm_initsend(PvmDataRaw);
  pvm_pkbyte((char *)&bestr2[0],sizeof(struct comstr2)*(BFR2+1),1);
  pvm_send(hosttid,LISTRTYPE);
#endif
#ifdef MPI_SRC
  MPI_Send(&bestr2[0],sizeof(struct comstr2)*(BFR2+1),MPI_BYTE,
	   hosttid,LISTRTYPE,MPI_COMM_WORLD);
#endif
}

void
send_struct(int hosttid, int msg_type, void *void_p, size_t slen) {

#ifdef PVM_SRC
  pvm_initsend(PvmDataRaw);
  pvm_pkbyte((char *)void_p,slen,1);
  pvm_send(hosttid,msg_type);
#endif
#ifdef MPI_SRC
  MPI_Send(void_p,slen,MPI_BYTE, hosttid,msg_type,MPI_COMM_WORLD);
#endif
}

void
send_code(int hosttid, char *seqc_buff, int seqc_buff_len) {

#ifdef PVM_SRC
  pvm_initsend(PvmDataRaw);
  pvm_pkint(&seqc_buff_len,1,1);
  if (seqc_buff_len > 0) pvm_pkbyte(seqc_buff,seqc_buff_len,1);
  pvm_send(hosttid,CODERTYPE);
#endif
#ifdef MPI_SRC
  MPI_Send(&seqc_buff_len,1,MPI_INT,
	   hosttid,CODERTYPE,MPI_COMM_WORLD);
  if (seqc_buff_len>0) MPI_Send(seqc_buff,seqc_buff_len,MPI_BYTE,
			       hosttid,CODERTYPE,MPI_COMM_WORLD);
#endif
}

#ifdef PVM_SRC
int tidtonode(tid)
     int tid;
{
  int i;
  for (i=FIRSTNODE; i< nnodes; i++) if (tid==pinums[i]) return i;
  fprintf(stderr," cannot find tid %d\n",tid);
  return -1;
}
#endif

void
free_ares(struct sqs2 *seqpt, int itt, int *walign_done, int walign_cnt, int worker) {

  int i, seqnm;

  for (i=0; i< walign_cnt; i++) {
    seqnm = walign_done[i];
    walign_done[i]=0;
    if (seqpt[seqnm].walign_dflg[itt]) {
      if (seqpt[seqnm].a_res[itt].nres > 0 ) {
	/*
	fprintf(stderr, "[%d] freeing %d:%d[%d]:%o\n",
		worker,i,seqnm,itt,seqpt[seqnm].a_res[itt].res);
	*/
	seqpt[seqnm].a_res[itt].nres = 0;
	free(seqpt[seqnm].a_res[itt].res);
      }
    }
    else {
      w_abort(" have walign_done but no walign_dflag","");
    }
    seqpt[seqnm].walign_dflg[itt] = 0;
  }
}