autotors.c

c++编写的并行拉马克遗传算法的程序。实现分析对接程序

		fprintf(outfile,"%6s%4d %-4s",chptr,node->new_id,atmptr+LINE_LEN*node->id+12);
	};/*traverse #4*/
	}else{/*not hflag*/
		if(traverse_num==4)print_out(node->id,node->new_id,node->next_num+node->prev_num);
	};
	for(i=0;i<node->prev_num;i++){
	     nnum=node->prev[i]->next_num+node->prev[i]->prev_num;
	if(!(*(atmptr+LINE_LEN*node->id+13)=='C')|| (!(*(atmptr+LINE_LEN*node->prev[i]->id+12)=='H')&&!(*(atmptr+LINE_LEN*node->prev[i]->id+13)=='H'))||!hflag){
       		if((nnum==1)&&!on_list(node->prev[i]->id,rootlist,rootnum)){
			if(traverse_num==3){
				if(hflag&&debug)printf("polar leaf = %d\n",node->prev[i]->id);
				node->prev[i]->new_id=outatom++;
			}else
			if(traverse_num==4)print_out(node->prev[i]->id,node->prev[i]->new_id,node->prev[i]->next_num+node->prev[i]->prev_num);
		};
	};/*not non-polar H*/
	};/*for all prevs*/
	for(i=0;i<node->next_num;i++){
	nnum=node->next[i]->next_num+node->next[i]->prev_num;
	if(!(*(atmptr+LINE_LEN*node->id+13)=='C')||(!(*(atmptr+LINE_LEN*node->next[i]->id+12)=='H')&&!(*(atmptr+LINE_LEN*node->next[i]->id+13)=='H'))||!hflag){
       		if((nnum==1)&&!on_list(node->next[i]->id,rootlist,rootnum)){
			if(traverse_num==3){
				if(hflag&&debug)printf("polar leaf = %d\n",node->next[i]->id);
				node->next[i]->new_id=outatom++;
			}else
			if(traverse_num==4)print_out(node->next[i]->id,node->next[i]->new_id,node->next[i]->prev_num+node->next[i]->next_num);
		};
	};/*not non-polar H*/
	};/*for all nexts*/
	return(1);
}
	


void next_prev(node,list,index,nlist,nindex)
ATOM_NODE * node;
int *list,*index;
int *nlist,*nindex;

{
	int i,j,k,tpindex,counter,pcounter;
	int switchs;
	ATOM_NODE * temp,*tnext;

	switchs=0;
	counter=node->next_num;


        if(on_list(node->id,nlist,*nindex)){
                printf("error in next_prev:%d is its own successor\n",node->id);
                exit(1);
        };
/*if not a cycle- error, add this node to the visited list*/
        *(nlist+*nindex)=node->id;
        *nindex=*nindex+1;

	if(node->next_num){
		for(i=0;i<counter;i++){
			if(!on_list(node->next[i]->id,list,*index)){
				switchs++;
				tnext=node->next[i];
                                if(!on_list(tnext->id,nlist,*nindex))
					{
				if(!num_cycle(tnext))
				      next_prev(tnext,list,index,nlist,nindex);
				} else    {
                                  printf("%d is its own successor\n",tnext->id);
                                  exit(1);
                                };
				tnext->next[tnext->next_num++]=node;
				node->prev[node->prev_num++]=tnext;
				/*have to find prev index of tnext entry=temp*/
				tpindex=-1;
				for(k=0;k<tnext->prev_num;k++){
					if(tnext->prev[k]==node){
						tpindex=k;
					};
				};
				node->next[i]=NULL;
				pcounter=tnext->prev_num;
				for(k=tpindex;k<pcounter-1;k++){
					tnext->prev[k]=tnext->prev[k+1];
				};
				tnext->prev[--(tnext->prev_num)]=NULL;
			};/*if !on_list*/
		};/*for i's*/
		/*now have to rearrange the nexts*/
		for(j=0;j<node->next_num;j++){
			if(!node->next[j]){
				for(k=j+1;k<node->next_num;k++){
					if(node->next[k]){
						node->next[j]=node->next[k];
						node->next[k]=NULL;
						break;
					};
				};
			};
		};
		node->next_num=node->next_num-switchs;
		/*for(k=0;k<switchs;k++){
			node->next_num--;
		};*/
	};
}

void prev_next(node,list,index,plist,pindex)
ATOM_NODE * node;
int *list,*index;
int *plist,*pindex;

{
	int i,j,k,tnindex,counter,pcounter;
	int switchs;
	ATOM_NODE * temp,*tprev;

	switchs=0;
	counter=node->prev_num;
        if(on_list(node->id,plist,*pindex)){
                printf("error in prev_next:%d is its own predessor\n",node->id);
                exit(1);
        };

        *(plist+*pindex)=node->id;
        *pindex=*pindex +1;
	if(node->prev_num) {
		for(i=0;i<counter;i++){
			if(!on_list(node->prev[i]->id,list,*index)){
				switchs++;
				tprev=node->prev[i];
				
                                if(!on_list(tprev->id,plist,*pindex))
					{
				if(!num_cycle(tprev))
				      prev_next(tprev,list,index,plist,pindex);}
                                else    {
                                printf("%d is its own successor\n",node->id);
                                exit(1);
                                };
				tprev->prev[tprev->prev_num++]=node;
				node->next[node->next_num++]=tprev;
				/*have to find next index of tnext entry=temp*/
				tnindex=-1;
				for(k=0;k<tprev->next_num;k++){
					if(tprev->next[k]==node){
						tnindex=k;
					};
				};
				node->prev[i]=NULL;
				pcounter=tprev->next_num;
				for(k=tnindex;k<pcounter-1;k++){
					tprev->next[k]=tprev->next[k+1];
				};
				tprev->next[--(tprev->next_num)]=NULL;
			};/*if*/
		};/*for j's*/
		/*now have to rearrange the prevs*/
		for(j=0;j<node->prev_num;j++){
			if(!node->prev[j]){
				for(k=j+1;k<node->prev_num;k++){
					if(node->prev[k]){
						node->prev[j]=node->prev[k];
						node->prev[k]=NULL;
						break;
					};/*if*/
				};/*for k*/
			};
		};
		node->prev_num=node->prev_num-switchs;
		/*for(k=0;k<switchs;k++){
			node->prev_num--;
		};*/
	};/*else*/
}

int is_amide(node)
ATOM_NODE * node;
{
	int i,j,k;
	int ans;
	int connects,nconnects,nnconnects;
	int singleOx,singleH,isN,isC;

	ans=0;
	singleOx=0;
	singleH=0;
	isN=0;
	isC=0;
	connects=node->prev_num+node->next_num;
	if((*(atmptr+LINE_LEN*node->id+13)=='C')&&connects==3){
		for(i=0;i<node->prev_num;i++){
		nconnects=node->prev[i]->prev_num+node->prev[i]->next_num;
		if((*(atmptr+LINE_LEN*node->prev[i]->id+13)=='O')&&nconnects==1)
			singleOx=1;
		if((*(atmptr+LINE_LEN*node->prev[i]->id+13)=='N')&&nconnects>=2){
			for(j=0;j<node->prev[i]->prev_num;j++){
				nnconnects=node->prev[i]->prev[j]->prev_num+node->prev[i]->prev[j]->next_num;
				if(((*(atmptr+LINE_LEN*node->prev[i]->prev[j]->id+13)=='H')||(*(atmptr+LINE_LEN*node->prev[i]->prev[j]->id+12)=='H'))&&nnconnects==1){
				isN=-1;
				};
			};
			for(j=0;j<node->prev[i]->next_num;j++){
				nnconnects=node->prev[i]->next[j]->prev_num+node->prev[i]->next[j]->next_num;
				if(((*(atmptr+LINE_LEN*node->prev[i]->next[j]->id+13)=='H')||(*(atmptr+LINE_LEN*node->prev[i]->next[j]->id+12)=='H'))&&nnconnects==1){
				isN=-1;
				};
			};
		};/*if prev is N */
		};/*for all the prevs of a C*/
		for(i=0;i<node->next_num;i++){
		nconnects=node->next[i]->prev_num+node->next[i]->next_num;
		if((*(atmptr+LINE_LEN*node->next[i]->id+13)=='O')&&nconnects==1)
			singleOx=1;
		if((*(atmptr+LINE_LEN*node->next[i]->id+13)=='N')&&nconnects>=2){
			for(j=0;j<node->next[i]->prev_num;j++){
				nnconnects=node->next[i]->prev[j]->prev_num+node->next[i]->prev[j]->next_num;
				if(((*(atmptr+LINE_LEN*node->next[i]->prev[j]->id+13)=='H')||(*(atmptr+LINE_LEN*node->next[i]->prev[j]->id+12)=='H'))&&nnconnects==1){
				isN=1;
				};
			};
			for(j=0;j<node->next[i]->next_num;j++){
				nnconnects=node->next[i]->next[j]->prev_num+node->next[i]->next[j]->next_num;
				if(((*(atmptr+LINE_LEN*node->next[i]->next[j]->id+13)=='H')||(*(atmptr+LINE_LEN*node->next[i]->next[j]->id+12)=='H'))&&nnconnects==1){
				isN=1;
				};
			};
		};/*if next is a N */
		};/*for all of a C's nexts*/
	if(singleOx)return(isN);
	};
	
	if((*(atmptr+LINE_LEN*node->id+13)=='N')&&connects>=2){
		for(i=0;i<node->prev_num;i++){
		nconnects=node->prev[i]->prev_num+node->prev[i]->next_num;
		if(((*(atmptr+LINE_LEN*node->prev[i]->id+13)=='H')||(*(atmptr+LINE_LEN*node->prev[i]->id+12)=='H'))&&nconnects==1)
			singleH=1;
		if((*(atmptr+LINE_LEN*node->prev[i]->id+13)=='C')&&nconnects==3){
			for(j=0;j<node->prev[i]->prev_num;j++){
				nnconnects=node->prev[i]->prev[j]->prev_num+node->prev[i]->prev[j]->next_num;
				if((*(atmptr+LINE_LEN*node->prev[i]->prev[j]->id+13)=='O')&&nnconnects==1){
				isC=-1;
				};
			};
			for(j=0;j<node->prev[i]->next_num;j++){
				nnconnects=node->prev[i]->next[j]->prev_num+node->prev[i]->next[j]->next_num;
				if((*(atmptr+LINE_LEN*node->prev[i]->next[j]->id+13)=='O')&&nnconnects==1){
				isC=-1;
				};
			};
		};/*if prev is C */
		};/*for all the prevs of a N*/
		for(i=0;i<node->next_num;i++){
		nconnects=node->next[i]->prev_num+node->next[i]->next_num;
		if(((*(atmptr+LINE_LEN*node->next[i]->id+13)=='H')||(*(atmptr+LINE_LEN*node->next[i]->id+12)=='H'))&&nconnects==1)
			singleH=1;
		if((*(atmptr+LINE_LEN*node->next[i]->id+13)=='C')&&nconnects==3){
			for(j=0;j<node->next[i]->prev_num;j++){
				nnconnects=node->next[i]->prev[j]->prev_num+node->next[i]->prev[j]->next_num;
				if((*(atmptr+LINE_LEN*node->next[i]->prev[j]->id+13)=='O')&&nnconnects==1){
				isC=1;
				};
			};
			for(j=0;j<node->next[i]->next_num;j++){
				nnconnects=node->next[i]->next[j]->prev_num+node->next[i]->next[j]->next_num;
				if((*(atmptr+LINE_LEN*node->next[i]->next[j]->id+13)=='O')&&nnconnects==1){
				isC=1;
				};
			};
		};/*if next is a C */
		};/*for all of a N nexts*/
	if(singleH)return(isC);
	};
	return(ans);
}
			
int check_back(node,index,direction)
ATOM_NODE * node;
int index;
char direction;
{
	int i,j,k;

/*logic: if ok to add torsion, return 0 else if part of backbone 
	which should be disallowed, return 1*/

	if(atmtype(atmptr,node->id)=='N'){
		if(direction == 'p'){
			if(!strncmp(atmptr+LINE_LEN*node->prev[index]->id+13,"C ",2)){
				 return(1);
			};
			if(!strncmp(atmptr+LINE_LEN*node->prev[index]->id+13,"CA",2)){
				return(1);
			};
		};
		if(direction == 'n'){
			if(!strncmp(atmptr+LINE_LEN*node->next[index]->id+13,"C ",2)){
				 return(1);
			};
			if(!strncmp(atmptr+LINE_LEN*node->next[index]->id+13,"CA",2)){
				return(1);
			};
		};
	};
	if(atmtype(atmptr,node->id)=='C'){
		if(direction == 'p'){
			if(!strncmp(atmptr+LINE_LEN*node->prev[index]->id+13,"CA",2)){
				return(1);
			};
			if(!strncmp(atmptr+LINE_LEN*node->prev[index]->id+13,"N ",2)){
				 return(1);
			};
		};
		if(direction == 'n'){
			if(!strncmp(atmptr+LINE_LEN*node->next[index]->id+13,"CA",2)){
				return(1);
			};
			if(!strncmp(atmptr+LINE_LEN*node->next[index]->id+13,"N ",2)){
				 return(1);
			};
		};
	};
	if(!strncmp(atmptr+LINE_LEN*node->id+13,"CA",2)){
		if(direction == 'p'){
			if(!strncmp(atmptr+LINE_LEN*node->prev[index]->id+13,"N ",2)){
				 return(1);
			};
			if(!strncmp(atmptr+LINE_LEN*node->prev[index]->id+13,"C ",2)){
				 return(1);
			};
		};
		if(direction == 'n'){
			if(!strncmp(atmptr+LINE_LEN*node->next[index]->id+13,"N ",2)){
				 return(1);
			};
			if(!strncmp(atmptr+LINE_LEN*node->next[index]->id+13,"C ",2)){
				 return(1);
			};
		};
	};
	return(0);
}


void     visit_prev(node,list,index,nlist,nindex)
ATOM_NODE * node;
int *list,*index;
int *nlist,*nindex;

{
	int i,j,k,s,r,*newlist;
        int connects;
	double mk;
	ATOM_NODE * tempr;

	if((node->next_num)+(node->prev_num)==1)return;
	if(on_list(node->id,list,*index)){
		return;
	};
	if(num_cycle(node)){
		newlist=is_cycle(node);
                traverse_cycle(newlist,num_cycle(node),0,list,index);
		return;
        };
	*(list + * index)=node->id;
	*index=*(index) + 1;
	check_h(node);
	if(traverse_num==1&&!((node->next_num==1)&&on_list(node->next[0]->id,list,*index))){
	     next_prev(node,list,index,nlist,nindex);
	     for(k=0;k<*nindex;k++){
		*(nlist+k)=0;
	     };
	     *nindex=0;
	};

switch(node->prev_num) {
case 0  : return;
case 1  :connects=node->prev[0]->prev_num+node->prev[0]->next_num;
	if(((connects>0)||num_cycle(node->prev[0]))&&!on_list(node->prev[0]->id,list,*index)){
		if(!on_list(node->prev[0]->id,rootlist,rootnum)&&connects>1&& traverse_num==1) {
			if(aflag && is_amide(node)<0)printf("found amide (prev) %d\n",node->id);			
		else
			if(!(bflag && check_back(node,0,'p')))
			head_tors=add_tors(node->id,node->prev[0]->id,head_tors);
		};
		if(traverse_num==2&&check_tors(node->id,node->prev[0]->id))
			 nbranch++;
		if(traverse_num==2&&!nbranch&&!check_tors(node->id,node->prev[0]->id)){
			if(!on_list(node->id,rootlist,rootnum)){
			node->root=1;
			rootlist[rootnum++]=node->id;
			};
			if(!on_list(node->prev[0]->id,rootlist,rootnum)){
			if(i=num_cycle(node->prev[0])){
				for(j=0;j<cycle_size[i];j++){
				if(!on_list(cycles[i][j],rootlist,rootnum)){
					rootlist[rootnum++]=cycles[i][j];
					tempr=find_key(cycles[i][j],natom,head);
					tempr->root=1;
				};
				};/*for all the cycle members*/
			}else{
			node->prev[0]->root=1;
			rootlist[rootnum++]=node->prev[0]->id;
			};
			};
		};
		if(traverse_num==2){
			if(atmtype(atmptr,node->id)=='O'||atmtype(atmptr,node->id)=='S'){
				if(connects==1&& atmtype(atmptr,node->prev[0]->id)=='H'){
					torsdof--;
	/*need to decrement torsdof*/
				};
			};
		};
		if(traverse_num==4&&check_tors(node->id,node->prev[0]->id))
		fprintf(outfile,"TORS %d %d\n",node->new_id,node->prev[0]->new_id);
		if(k=num_cycle(node->prev[0])){
			newlist=is_cycle(node->prev[0]);
			traverse_cycle(newlist,k,0,list,index);
			if(traverse_num==2&&check_tors(node->id,node->prev[0]->id))
			nbranch--;
			if(traverse_num==4&&check_tors(node->id,node->prev[0]->id))
			fprintf(outfile,"ENDTORS %d %d\n",node->new_id,(node->prev[0])->new_id);
		}else{  	/*if not a cycle*/
		visit_prev(node->prev[0],list,index,nlist,nindex);
		if(traverse_num==2&&check_tors(node->id,node->prev[0]->id))
			 nbranch--;
		if(traverse_num==4&&check_tors(node->id,node->prev[0]->id))
		fprintf(outfile,"ENDTORS %d %d\n",node->new_id,node->prev[0]->new_id);
		};
		};/*if of case1*/
	break;
default: 
   for(i=0;i<node->prev_num;i++){
               connects=node->prev[i]->prev_num+node->prev[i]->next_num;
	if(((connects>0)||num_cycle(node->prev[i]))&&!on_list(node->prev[i]->id,list,*index)){
	   if(!on_list(node->prev[i]->id,rootlist,rootnum)&&connects>1&&traverse_num==1) {
		if(aflag && is_amide(node)<0)printf("2:found amide prev %d\n",node->id);
		else
		if(!(bflag && check_back(node,i,'p')))
		head_tors=add_tors(node->id,(node->prev[i])->id,head_tors);
	   };
	if(traverse_num==2&&check_tors(node->id,node->prev[i]->id))
	nbranch++;
	if(traverse_num==2&&!nbranch&&!check_tors(node->id,node->prev[i]->id)){
		if(!on_list(node->id,rootlist,rootnum)){
		node->root=1;
		rootlist[rootnum++]=node->id;