static void align_seq_to_prf(ALNPTR mult_aln,double **tmat,sint *aligned,sint iseq,MULT_OPT mult_opt,sint output_order,Boolean use_maxid,Boolean verbose)
{
sint j,n;
sint *group;
lint score = 0;
group = (sint *)ckalloc( (mult_aln->nseqs+1) * sizeof (sint));
for (j=0,n=0;j<mult_aln->nseqs;j++)
if (aligned[j] != 0) {
group[j] = 1;
n++;
}
group[iseq] = 2;
aligned[iseq] = 1;
score = prfalign(2,mult_aln,group,tmat,use_maxid,mult_opt,NULL,TRUE);
if(verbose) info("Sequence:%d Score:%d",(pint)iseq+1,(pint)score);
if (output_order == INPUT) {
mult_aln->seqs[iseq].output_index = iseq;
}
else if (output_order == ALIGNED)
mult_aln->seqs[iseq].output_index = n;
group=ckfree((void *)group);
}
sint palign1(void) /* a profile alignment */
{
sint i,j,temp;
sint entries;
sint *aligned, *group;
float dscore;
lint score;
info("Start of Initial Alignment");
/* calculate sequence weights according to branch lengths of the tree -
weights in global variable seq_weight normalised to sum to INT_SCALE_FACTOR */
temp = INT_SCALE_FACTOR/nseqs;
for (i=0;i<nseqs;i++) seq_weight[i] = temp;
distance_tree = FALSE;
/* do the initial alignment......... */
group = (sint *)ckalloc( (nseqs+1) * sizeof (sint));
for(i=1; i<=profile1_nseqs; ++i)
group[i] = 1;
for(i=profile1_nseqs+1; i<=nseqs; ++i)
group[i] = 2;
entries = nseqs;
aligned = (sint *)ckalloc( (nseqs+1) * sizeof (sint) );
for (i=1;i<=nseqs;i++) aligned[i] = 1;
score = prfalign(group, aligned);
info("Sequences:%d Score:%d",(pint)entries,(pint)score);
group=ckfree((void *)group);
aligned=ckfree((void *)aligned);
for (i=1;i<=nseqs;i++) {
for (j=i+1;j<=nseqs;j++) {
dscore = countid(i,j);
tmat[i][j] = ((double)100.0 - (double)dscore)/(double)100.0;
tmat[j][i] = tmat[i][j];
}
}
return(nseqs);
}
static sint malign(ALNPTR mult_aln,MULT_OPT mult_opt,sint output_order,Boolean verbose,ALNCOUNT *alncount)
{
Boolean use_maxid;
sint i,j,n,tx,set;
sint ix,t1,t2;
sint status,entries;
sint nsets;
sint **sets;
sint naligned_groups;
sint *aligned_group;
sint *aligned;
lint score = 0;
sint *seq_weight;
IN_TREEPTR itree;
float min_dist,mean_dist;
float **group_dist;
double **tmat;
Boolean *delayed,ok;
char *dsc_ss;
char *jnet_ss;
if (verbose) info("Start of Multiple Alignment");
/* get the guide tree (tree should be in phylip format) */
if (mult_aln->nseqs >= 2) {
itree=(IN_TREEPTR)ckalloc(sizeof(IN_TREE));
status = read_tree(mult_aln->treename, mult_aln->seqs, (sint)0, mult_aln->nseqs,itree);
if (status < 0) return((sint)0);
}
if(status<0) use_maxid=TRUE;
else use_maxid=FALSE;
/* group the sequences according to their relative divergence */
sets = (sint **) ckalloc( (mult_aln->nseqs+1) * sizeof (sint *) );
for(i=0;i<mult_aln->nseqs;i++)
sets[i] = (sint *)ckalloc( (mult_aln->nseqs+1) * sizeof (sint) );
nsets=create_sets(mult_aln->nseqs,sets,itree);
if(verbose) info("There are %d groups",(pint)nsets);
if(debug>1)
for(set=0;set<nsets;set++) {
for (i=0;i<mult_aln->nseqs;i++) {
printf("%d ",sets[set][i]);
}
printf("\n");
}
/* calculate sequence weights according to branch lengths of the tree -
weights are normalised to sum to 100 */
seq_weight = calc_seq_weights((sint)0, mult_aln->nseqs, itree,mult_opt.no_weights);
for(i=0;i<mult_aln->nseqs;i++)
mult_aln->seqs[i].weight=seq_weight[i];
/* calculate tmat matrix containing percent distances for all pairs of sequences */
tmat = pw_distances_from_tree(mult_aln->seqs,mult_aln->nseqs,itree);
if (tmat == NULL) return((sint)0);
/* clear the memory used for the phylogenetic tree */
if (mult_aln->nseqs >= 2)
free_tree(itree);
/* start the multiple alignments......... */
if(verbose) info("Aligning...");
if (output_order==INPUT) {
for (i=0;i<mult_aln->nseqs;i++)
mult_aln->seqs[i].output_index = i;
}
else {
tx=0;
for (i=0;i<mult_aln->nseqs;i++)
mult_aln->seqs[i].output_index = -1;
for(set=0;set<nsets;set++) {
for (i=0;i<mult_aln->nseqs;i++) {
if (sets[set][i] != 0) {
if(mult_aln->seqs[i].output_index==(-1)) {
mult_aln->seqs[i].output_index = tx++;
}
}
}
}
}
/* align the closely related groups first */
aligned_group = (sint *) ckalloc( (mult_aln->nseqs+1) * sizeof (sint) );
delayed = (Boolean *) ckalloc( (mult_aln->nseqs+1) * sizeof (Boolean) );
for(set=0;set<nsets;set++) {
/* decide whether to do the alignment now - if the mean distance between sequences in the
two groups to be aligned is greater than the cutoff, then don't align now */
mean_dist=0.0;
entries=0;
ok=TRUE;
for (i=0,n=0;i<mult_aln->nseqs;i++) {
if (sets[set][i] != 0 && mult_aln->seqs[i].len>0) {
if(delayed[i]==TRUE) {
ok=FALSE;
break;
}
entries++;
for (j=i+1;j<mult_aln->nseqs;j++) {
if (sets[set][j] != 0 && mult_aln->seqs[j].len>0 && sets[set][i] != sets[set][j]) {
if(delayed[j]==TRUE) {
ok=FALSE;
break;
}
mean_dist+=tmat[i][j];
n++;
/* if(mean_dist>tmat[i][j]) mean_dist=tmat[i][j];*/
}
}
}
}
if(ok==TRUE && n>0) mean_dist=mean_dist/(float)(n);
if ((ok==TRUE) && mean_dist < 1.0-(float)mult_opt.divergence_cutoff/100.0) {
score = prfalign(0,mult_aln,sets[set],tmat,use_maxid,mult_opt,alncount,TRUE);
/*if (score < 0) return(-1);*/
if(verbose) info("Group %d: Sequences:%4d Score:%d",
(pint)set+1,(pint)entries,(pint)score);
for (i=0;i<mult_aln->nseqs;i++) {
if (sets[set][i] != 0) {
aligned_group[i]=set+1;
}
}
}
else {
if(verbose) info("Group %d: Sequences:%4d Delayed",(pint)set+1,(pint)entries);
for (i=0;i<mult_aln->nseqs;i++)
if (sets[set][i] != 0) {
delayed[i]=TRUE;
}
}
}
/* renumber the groups and assign a group number to any orphan sequences, that haven't
been aligned yet */
naligned_groups=renumber_groups(mult_aln->nseqs,aligned_group,0);
if (verbose) fprintf(stdout,"done groups %d\n",naligned_groups);
for(i=0;i<mult_aln->nseqs;i++)
mult_aln->seqs[i].simgroup=aligned_group[i];
for(i=0;i<mult_aln->nseqs;i++)
if(aligned_group[i]==0) {
aligned_group[i]=naligned_groups+1;
naligned_groups++;
}
if (verbose) fprintf(stdout,"done groups and added orphans %d\n",naligned_groups);
if(naligned_groups==1) return naligned_groups;
/* now align the two closest groups of sequences together */
/* the array aligned[] contains the group number of each sequence */
ix=0;
if(naligned_groups>1) {
for(i=0;i<mult_aln->nseqs;i++) mult_aln->seqs[i].output_index=(-1);
group_dist = (float **) ckalloc( (naligned_groups+1) * sizeof (float *) );
for(i=0;i<naligned_groups+1;i++)
group_dist[i] = (float *)ckalloc( (naligned_groups+1) * sizeof (float) );
aligned = (sint *) ckalloc( (mult_aln->nseqs+1) * sizeof (sint) );
/* calculate the distance between each pair of groups */
calc_group_dist(mult_aln->nseqs,naligned_groups,aligned_group,tmat,group_dist);
for(i=0;i<mult_aln->nseqs;i++)
sets[0][i] = 0;
/* align the two closest groups together */
min_dist=1000.0;
t1=t2=0;
for (i=0;i<naligned_groups;i++)
for (j=i+1;j<naligned_groups;j++)
if(min_dist>=group_dist[i][j]) {
min_dist=group_dist[i][j];
t1=i+1;
t2=j+1;
}
for(i=0;i<mult_aln->nseqs;i++)
if(aligned_group[i]==t1) {
sets[0][i]=1;
if (output_order==ALIGNED) mult_aln->seqs[i].output_index = ix++;
}
for(i=0;i<mult_aln->nseqs;i++)
if(aligned_group[i]==t2) {
sets[0][i]=2;
aligned_group[i]=t1;
if (output_order==ALIGNED) mult_aln->seqs[i].output_index = ix++;
}
for (i=0,tx=0;i<mult_aln->nseqs;i++)
if (sets[0][i] != 0) {
aligned[i]=1;
tx++;
}
score = prfalign(0,mult_aln,sets[0],tmat,use_maxid,mult_opt,alncount,TRUE);
/*if (score < 0) return(-1);*/
if(verbose) info("Group Align %d: Sequences:%4d Score:%d",
(pint)tx,(pint)entries,(pint)score);
}
/* now align the remaining groups to the first two */
naligned_groups=renumber_groups(mult_aln->nseqs,aligned_group,t1);
t1=1;
while(naligned_groups>1) {
/* calculate the distance of each remaining group to the first group */
calc_group_dist1(mult_aln->nseqs,naligned_groups,aligned_group,tmat,group_dist);
/* align the next closest group with the first group */
for(i=0;i<mult_aln->nseqs;i++)
sets[0][i] = 0;
min_dist=100.0;
t2=0;
for (j=1;j<naligned_groups;j++)
if(min_dist>=group_dist[0][j]) {
min_dist=group_dist[0][j];
t2=j+1;
}
if (verbose) fprintf(stdout,"Aligning Group %d %d\n",t1,t2);
for(i=0;i<mult_aln->nseqs;i++)
if(aligned_group[i]==1)
sets[0][i]=1;
else if(aligned_group[i]==t2) {
sets[0][i]=2;
aligned_group[i]=1;
if (output_order==ALIGNED) mult_aln->seqs[i].output_index = ix++;
}
if(debug>0)
for(i=0;i<mult_aln->nseqs;i++)
fprintf(stdout,"%s %d %d\n",mult_aln->seqs[i].name,mult_aln->seqs[i].output_index,aligned_group[i]);
for (i=0,tx=0;i<mult_aln->nseqs;i++)
if (sets[0][i] != 0) {
aligned[i]=1;
tx++;
}
score = prfalign(0,mult_aln,sets[0],tmat,use_maxid,mult_opt,alncount,TRUE);
/*if (score < 0) return(-1);*/
if(verbose) info("Group Align %d: Sequences:%4d Score:%d",
(pint)tx,(pint)entries,(pint)score);
naligned_groups=renumber_groups(mult_aln->nseqs,aligned_group,t1);
}
for(i=0;i<mult_aln->nseqs;i++)
tmat[i] = ckfree(tmat[i]);
tmat = ckfree(tmat);
for (i=0;i<naligned_groups;i++)
group_dist[i]=ckfree((void *)group_dist[i]);
group_dist=ckfree(group_dist);
aligned=ckfree(aligned);
for (i=0;i<naligned_groups;i++)
sets[i]=ckfree((void *)sets[i]);
sets=ckfree(sets);
return((sint)1);
}
sint palign2(char *p1_tree_name,char *p2_tree_name) /* a profile alignment */
{
sint i,j,sum,entries,status;
lint score;
sint *aligned, *group;
sint *maxid,*p1_weight,*p2_weight;
/* sint dscore; */
info("Start of Multiple Alignment");
/* get the phylogenetic trees from *.ph */
if (profile1_nseqs >= 2)
{
status = read_tree(p1_tree_name, (sint)0, profile1_nseqs);
if (status == 0) return(0);
}
/* calculate sequence weights according to branch lengths of the tree -
weights in global variable seq_weight normalised to sum to 100 */
p1_weight = (sint *) ckalloc( (profile1_nseqs) * sizeof(sint) );
calc_seq_weights((sint)0, profile1_nseqs, p1_weight);
/* clear the memory for the phylogenetic tree */
if (profile1_nseqs >= 2)
clear_tree(NULL);
if (nseqs-profile1_nseqs >= 2)
{
status = read_tree(p2_tree_name, profile1_nseqs, nseqs);
if (status == 0) return(0);
}
p2_weight = (sint *) ckalloc( (nseqs) * sizeof(sint) );
calc_seq_weights(profile1_nseqs,nseqs, p2_weight);
/* clear the memory for the phylogenetic tree */
if (nseqs-profile1_nseqs >= 2)
clear_tree(NULL);
/* convert tmat distances to similarities */
for (i=1;i<nseqs;i++)
for (j=i+1;j<=nseqs;j++) {
tmat[i][j]=100.0-tmat[i][j]*100.0;
tmat[j][i]=tmat[i][j];
}
/* weight sequences with max percent identity with other profile*/
maxid = (sint *)ckalloc( (nseqs+1) * sizeof (sint));
for (i=0;i<profile1_nseqs;i++) {
maxid[i] = 0;
for (j=profile1_nseqs+1;j<=nseqs;j++)
if(maxid[i]<tmat[i+1][j]) maxid[i] = tmat[i+1][j];
seq_weight[i] = maxid[i]*p1_weight[i];
}
for (i=profile1_nseqs;i<nseqs;i++) {
maxid[i] = -1;
for (j=1;j<=profile1_nseqs;j++)
if(maxid[i]<tmat[i+1][j]) maxid[i] = tmat[i+1][j];
seq_weight[i] = maxid[i]*p2_weight[i];
}
/*
Normalise the weights, such that the sum of the weights = INT_SCALE_FACTOR
*/
sum = 0;
for (j=0;j<nseqs;j++)
sum += seq_weight[j];
if (sum == 0)
{
for (j=0;j<nseqs;j++)
seq_weight[j] = 1;
sum = j;
}
for (j=0;j<nseqs;j++)
{
seq_weight[j] = (seq_weight[j] * INT_SCALE_FACTOR) / sum;
if (seq_weight[j] < 1) seq_weight[j] = 1;
}
if (debug > 1) {
fprintf(stdout,"new weights\n");
for (j=0;j<nseqs;j++) fprintf( stdout,"sequence %d: %d\n", j+1,seq_weight[j]);
}
/* do the alignment......... */
info("Aligning...");
group = (sint *)ckalloc( (nseqs+1) * sizeof (sint));
for(i=1; i<=profile1_nseqs; ++i)
group[i] = 1;
for(i=profile1_nseqs+1; i<=nseqs; ++i)
group[i] = 2;
entries = nseqs;
aligned = (sint *)ckalloc( (nseqs+1) * sizeof (sint) );
for (i=1;i<=nseqs;i++) aligned[i] = 1;
score = prfalign(group, aligned);
info("Sequences:%d Score:%d",(pint)entries,(pint)score);
group=ckfree((void *)group);
p1_weight=ckfree((void *)p1_weight);
p2_weight=ckfree((void *)p2_weight);
aligned=ckfree((void *)aligned);
maxid=ckfree((void *)maxid);
/* DES output_index = (int *)ckalloc( (nseqs+1) * sizeof (int)); */
for (i=1;i<=nseqs;i++) output_index[i] = i;
return(nseqs);
}
sint malign(sint istart,char *phylip_name) /* full progressive alignment*/
{
static sint *aligned;
static sint *group;
static sint ix;
sint *maxid, max, sum;
sint *tree_weight;
sint i,j,set,iseq=0;
sint status,entries;
lint score = 0;
info("Start of Multiple Alignment");
/* get the phylogenetic tree from *.ph */
if (nseqs >= 2)
{
status = read_tree(phylip_name, (sint)0, nseqs);
if (status == 0) return((sint)0);
}
/* calculate sequence weights according to branch lengths of the tree -
weights in global variable seq_weight normalised to sum to 100 */
calc_seq_weights((sint)0, nseqs, seq_weight);
/* recalculate tmat matrix as percent similarity matrix */
status = calc_similarities(nseqs);
if (status == 0) return((sint)0);
/* for each sequence, find the most closely related sequence */
maxid = (sint *)ckalloc( (nseqs+1) * sizeof (sint));
for (i=1;i<=nseqs;i++)
{
maxid[i] = -1;
for (j=1;j<=nseqs;j++)
if (j!=i && maxid[i] < tmat[i][j]) maxid[i] = tmat[i][j];
}
/* group the sequences according to their relative divergence */
if (istart == 0)
{
sets = (sint **) ckalloc( (nseqs+1) * sizeof (sint *) );
for(i=0;i<=nseqs;i++)
sets[i] = (sint *)ckalloc( (nseqs+1) * sizeof (sint) );
create_sets((sint)0,nseqs);
info("There are %d groups",(pint)nsets);
/* clear the memory used for the phylogenetic tree */
if (nseqs >= 2)
clear_tree(NULL);
/* start the multiple alignments......... */
info("Aligning...");
/* first pass, align closely related sequences first.... */
ix = 0;
aligned = (sint *)ckalloc( (nseqs+1) * sizeof (sint) );
for (i=0;i<=nseqs;i++) aligned[i] = 0;
for(set=1;set<=nsets;++set)
{
entries=0;
for (i=1;i<=nseqs;i++)
{
if ((sets[set][i] != 0) && (maxid[i] > divergence_cutoff))
{
entries++;
if (aligned[i] == 0)
{
if (output_order==INPUT)
{
++ix;
output_index[i] = i;
}
else output_index[++ix] = i;
aligned[i] = 1;
}
}
}
if(entries > 0) score = prfalign(sets[set], aligned);
else score=0.0;
/* negative score means fatal error... exit now! */
if (score < 0)
{
return(-1);
}
if ((entries > 0) && (score > 0))
info("Group %d: Sequences:%4d Score:%d",
(pint)set,(pint)entries,(pint)score);
else
info("Group %d: Delayed",
(pint)set);
}
for (i=0;i<=nseqs;i++)
sets[i]=ckfree((void *)sets[i]);
sets=ckfree(sets);
}
else
{
/* clear the memory used for the phylogenetic tree */
if (nseqs >= 2)
clear_tree(NULL);
aligned = (sint *)ckalloc( (nseqs+1) * sizeof (sint) );
ix = 0;
for (i=1;i<=istart+1;i++)
{
aligned[i] = 1;
++ix;
output_index[i] = i;
}
for (i=istart+2;i<=nseqs;i++) aligned[i] = 0;
}
/* second pass - align remaining, more divergent sequences..... */
/* if not all sequences were aligned, for each unaligned sequence,
find it's closest pair amongst the aligned sequences. */
group = (sint *)ckalloc( (nseqs+1) * sizeof (sint));
tree_weight = (sint *) ckalloc( (nseqs) * sizeof(sint) );
for (i=0;i<nseqs;i++)
tree_weight[i] = seq_weight[i];
/* if we haven't aligned any sequences, in the first pass - align the
two most closely related sequences now */
if(ix==0)
{
max = -1;
iseq = 0;
for (i=1;i<=nseqs;i++)
{
for (j=i+1;j<=nseqs;j++)
{
if (max < tmat[i][j])
{
max = tmat[i][j];
iseq = i;
}
}
}
aligned[iseq]=1;
if (output_order == INPUT)
{
++ix;
output_index[iseq] = iseq;
}
else
output_index[++ix] = iseq;
}
while (ix < nseqs)
{
for (i=1;i<=nseqs;i++) {
if (aligned[i] == 0)
{
maxid[i] = -1;
for (j=1;j<=nseqs;j++)
if ((maxid[i] < tmat[i][j]) && (aligned[j] != 0))
maxid[i] = tmat[i][j];
}
}
/* find the most closely related sequence to those already aligned */
max = -1;
iseq = 0;
for (i=1;i<=nseqs;i++)
{
if ((aligned[i] == 0) && (maxid[i] > max))
{
max = maxid[i];
iseq = i;
}
}
/* align this sequence to the existing alignment */
/* weight sequences with percent identity with profile*/
/* OR...., multiply sequence weights from tree by percent identity with new sequence */
if(no_weights==FALSE) {
for (j=0;j<nseqs;j++)
if (aligned[j+1] != 0)
seq_weight[j] = tree_weight[j] * tmat[j+1][iseq];
/*
Normalise the weights, such that the sum of the weights = INT_SCALE_FACTOR
*/
sum = 0;
for (j=0;j<nseqs;j++)
if (aligned[j+1] != 0)
sum += seq_weight[j];
if (sum == 0)
{
for (j=0;j<nseqs;j++)
seq_weight[j] = 1;
sum = j;
}
for (j=0;j<nseqs;j++)
if (aligned[j+1] != 0)
{
seq_weight[j] = (seq_weight[j] * INT_SCALE_FACTOR) / sum;
if (seq_weight[j] < 1) seq_weight[j] = 1;
}
}
entries = 0;
for (j=1;j<=nseqs;j++)
if (aligned[j] != 0)
{
group[j] = 1;
entries++;
}
else if (iseq==j)
{
group[j] = 2;
entries++;
}
aligned[iseq] = 1;
score = prfalign(group, aligned);
info("Sequence:%d Score:%d",(pint)iseq,(pint)score);
if (output_order == INPUT)
{
++ix;
output_index[iseq] = iseq;
}
else
output_index[++ix] = iseq;
}
group=ckfree((void *)group);
aligned=ckfree((void *)aligned);
maxid=ckfree((void *)maxid);
tree_weight=ckfree((void *)tree_weight);
aln_score();
/* make the rest (output stuff) into routine clustal_out in file amenu.c */
return(nseqs);
}
sint seqalign(sint istart,char *phylip_name) /* sequence alignment to existing profile */
{
static sint *aligned, *tree_weight;
static sint *group;
static sint ix;
sint *maxid, max;
sint i,j,status,iseq=0;
sint sum,entries;
lint score = 0;
info("Start of Multiple Alignment");
/* get the phylogenetic tree from *.ph */
if (nseqs >= 2)
{
status = read_tree(phylip_name, (sint)0, nseqs);
if (status == 0) return(0);
}
/* calculate sequence weights according to branch lengths of the tree -
weights in global variable seq_weight normalised to sum to 100 */
calc_seq_weights((sint)0, nseqs, seq_weight);
tree_weight = (sint *) ckalloc( (nseqs) * sizeof(sint) );
for (i=0;i<nseqs;i++)
tree_weight[i] = seq_weight[i];
/* recalculate tmat matrix as percent similarity matrix */
status = calc_similarities(nseqs);
if (status == 0) return((sint)0);
/* for each sequence, find the most closely related sequence */
maxid = (sint *)ckalloc( (nseqs+1) * sizeof (sint));
for (i=1;i<=nseqs;i++)
{
maxid[i] = -1;
for (j=1;j<=nseqs;j++)
if (maxid[i] < tmat[i][j]) maxid[i] = tmat[i][j];
}
/* clear the memory used for the phylogenetic tree */
if (nseqs >= 2)
clear_tree(NULL);
aligned = (sint *)ckalloc( (nseqs+1) * sizeof (sint) );
ix = 0;
for (i=1;i<=istart+1;i++)
{
aligned[i] = 1;
++ix;
output_index[i] = i;
}
for (i=istart+2;i<=nseqs;i++) aligned[i] = 0;
/* for each unaligned sequence, find it's closest pair amongst the
aligned sequences. */
group = (sint *)ckalloc( (nseqs+1) * sizeof (sint));
while (ix < nseqs)
{
if (ix > 0)
{
for (i=1;i<=nseqs;i++) {
if (aligned[i] == 0)
{
maxid[i] = -1;
for (j=1;j<=nseqs;j++)
if ((maxid[i] < tmat[i][j]) && (aligned[j] != 0))
maxid[i] = tmat[i][j];
}
}
}
/* find the most closely related sequence to those already aligned */
max = -1;
for (i=1;i<=nseqs;i++)
{
if ((aligned[i] == 0) && (maxid[i] > max))
{
max = maxid[i];
iseq = i;
}
}
/* align this sequence to the existing alignment */
entries = 0;
for (j=1;j<=nseqs;j++)
if (aligned[j] != 0)
{
group[j] = 1;
entries++;
}
else if (iseq==j)
{
group[j] = 2;
entries++;
}
aligned[iseq] = 1;
/* EITHER....., set sequence weights equal to percent identity with new sequence */
/*
for (j=0;j<nseqs;j++)
seq_weight[j] = tmat[j+1][iseq];
*/
/* OR...., multiply sequence weights from tree by percent identity with new sequence */
for (j=0;j<nseqs;j++)
seq_weight[j] = tree_weight[j] * tmat[j+1][iseq];
if (debug>1)
for (j=0;j<nseqs;j++) if (group[j+1] == 1)fprintf (stdout,"sequence %d: %d\n", j+1,tree_weight[j]);
/*
Normalise the weights, such that the sum of the weights = INT_SCALE_FACTOR
*/
sum = 0;
for (j=0;j<nseqs;j++)
if (group[j+1] == 1) sum += seq_weight[j];
if (sum == 0)
{
for (j=0;j<nseqs;j++)
seq_weight[j] = 1;
sum = j;
}
for (j=0;j<nseqs;j++)
{
seq_weight[j] = (seq_weight[j] * INT_SCALE_FACTOR) / sum;
if (seq_weight[j] < 1) seq_weight[j] = 1;
}
if (debug > 1) {
fprintf(stdout,"new weights\n");
for (j=0;j<nseqs;j++) if (group[j+1] == 1)fprintf( stdout,"sequence %d: %d\n", j+1,seq_weight[j]);
}
score = prfalign(group, aligned);
info("Sequence:%d Score:%d",(pint)iseq,(pint)score);
if (output_order == INPUT)
{
++ix;
output_index[iseq] = iseq;
}
else
output_index[++ix] = iseq;
}
group=ckfree((void *)group);
aligned=ckfree((void *)aligned);
maxid=ckfree((void *)maxid);
aln_score();
/* make the rest (output stuff) into routine clustal_out in file amenu.c */
return(nseqs);
}
