/* Function: p7_alidisplay_Create()
* Synopsis: Create an alignment display, from trace and oprofile.
* Incept: SRE, Sun Dec 30 09:13:31 2007 [Janelia]
*
* Purpose: Creates and returns an alignment display for domain number
* <which> in traceback <tr>, where the traceback
* corresponds to an alignment of optimized profile <om> to digital sequence
* <dsq>, and the unique name of that target
* sequence <dsq> is <sqname>. The <which> index starts at 0.
*
* It will be a little faster if the trace is indexed with
* <p7_trace_Index()> first. The number of domains is then
* in <tr->ndom>. If the caller wants to create alidisplays
* for all of these, it would loop <which> from
* <0..tr->ndom-1>.
*
* However, even without an index, the routine will work fine.
*
* Args: tr - traceback
* which - domain number, 0..tr->ndom-1
* om - optimized profile (query)
* sq - digital sequence (target)
*
* Returns: <eslOK> on success.
*
* Throws: <NULL> on allocation failure, or if something's internally corrupt
* in the data.
*/
P7_ALIDISPLAY *
p7_alidisplay_Create(const P7_TRACE *tr, int which, const P7_OPROFILE *om, const ESL_SQ *sq)
{
P7_ALIDISPLAY *ad = NULL;
char *Alphabet = om->abc->sym;
int n, pos, z;
int z1,z2;
int k,x,i,s;
int hmm_namelen, hmm_acclen, hmm_desclen;
int sq_namelen, sq_acclen, sq_desclen;
int status;
/* First figure out which piece of the trace (from first match to last match)
* we're going to represent, and how big it is.
*/
if (tr->ndom > 0) { /* if we have an index, this is a little faster: */
for (z1 = tr->tfrom[which]; z1 < tr->N; z1++) if (tr->st[z1] == p7T_M) break; /* find next M state */
if (z1 == tr->N) return NULL; /* no M? corrupt trace */
for (z2 = tr->tto[which]; z2 >= 0 ; z2--) if (tr->st[z2] == p7T_M) break; /* find prev M state */
if (z2 == -1) return NULL; /* no M? corrupt trace */
} else { /* without an index, we can still do it fine: */
for (z1 = 0; which >= 0 && z1 < tr->N; z1++) if (tr->st[z1] == p7T_B) which--; /* find the right B state */
if (z1 == tr->N) return NULL; /* no such domain <which> */
for (; z1 < tr->N; z1++) if (tr->st[z1] == p7T_M) break; /* find next M state */
if (z1 == tr->N) return NULL; /* no M? corrupt trace */
for (z2 = z1; z2 < tr->N; z2++) if (tr->st[z2] == p7T_E) break; /* find the next E state */
for (; z2 >= 0; z2--) if (tr->st[z2] == p7T_M) break; /* find prev M state */
if (z2 == -1) return NULL; /* no M? corrupt trace */
}
/* Now we know that z1..z2 in the trace will be represented in the
* alidisplay; that's z2-z1+1 positions. We need a \0 trailer on all
* our display lines, so allocate z2-z1+2. We know each position is
* M, D, or I, so there's a 1:1 correspondence of trace positions
* with alignment display positions. We also know the display
* starts and ends with M states.
*
* So now let's allocate. The alidisplay is packed into a single
* memory space, so this appears to be intricate, but it's just
* bookkeeping.
*/
n = (z2-z1+2) * 3; /* model, mline, aseq mandatory */
if (om->rf[0] != 0) n += z2-z1+2; /* optional reference line */
if (om->cs[0] != 0) n += z2-z1+2; /* optional structure line */
if (tr->pp != NULL) n += z2-z1+2; /* optional posterior prob line */
hmm_namelen = strlen(om->name); n += hmm_namelen + 1;
hmm_acclen = (om->acc != NULL ? strlen(om->acc) : 0); n += hmm_acclen + 1;
hmm_desclen = (om->desc != NULL ? strlen(om->desc) : 0); n += hmm_desclen + 1;
sq_namelen = strlen(sq->name); n += sq_namelen + 1;
sq_acclen = strlen(sq->acc); n += sq_acclen + 1; /* sq->acc is "\0" when unset */
sq_desclen = strlen(sq->desc); n += sq_desclen + 1; /* same for desc */
ESL_ALLOC(ad, sizeof(P7_ALIDISPLAY));
ad->mem = NULL;
pos = 0;
ad->memsize = sizeof(char) * n;
ESL_ALLOC(ad->mem, ad->memsize);
if (om->rf[0] != 0) { ad->rfline = ad->mem + pos; pos += z2-z1+2; } else { ad->rfline = NULL; }
if (om->cs[0] != 0) { ad->csline = ad->mem + pos; pos += z2-z1+2; } else { ad->csline = NULL; }
ad->model = ad->mem + pos; pos += z2-z1+2;
ad->mline = ad->mem + pos; pos += z2-z1+2;
ad->aseq = ad->mem + pos; pos += z2-z1+2;
if (tr->pp != NULL) { ad->ppline = ad->mem + pos; pos += z2-z1+2;} else { ad->ppline = NULL; }
ad->hmmname = ad->mem + pos; pos += hmm_namelen +1;
ad->hmmacc = ad->mem + pos; pos += hmm_acclen +1;
ad->hmmdesc = ad->mem + pos; pos += hmm_desclen +1;
ad->sqname = ad->mem + pos; pos += sq_namelen +1;
ad->sqacc = ad->mem + pos; pos += sq_acclen +1;
ad->sqdesc = ad->mem + pos; pos += sq_desclen +1;
strcpy(ad->hmmname, om->name);
if (om->acc != NULL) strcpy(ad->hmmacc, om->acc); else ad->hmmacc[0] = 0;
if (om->desc != NULL) strcpy(ad->hmmdesc, om->desc); else ad->hmmdesc[0] = 0;
strcpy(ad->sqname, sq->name);
strcpy(ad->sqacc, sq->acc);
strcpy(ad->sqdesc, sq->desc);
/* Determine hit coords */
ad->hmmfrom = tr->k[z1];
ad->hmmto = tr->k[z2];
ad->M = om->M;
ad->sqfrom = tr->i[z1];
ad->sqto = tr->i[z2];
ad->L = sq->n;
/* optional rf line */
if (ad->rfline != NULL) {
for (z = z1; z <= z2; z++) ad->rfline[z-z1] = ((tr->st[z] == p7T_I) ? '.' : om->rf[tr->k[z]]);
ad->rfline[z-z1] = '\0';
}
/* optional cs line */
if (ad->csline != NULL) {
for (z = z1; z <= z2; z++) ad->csline[z-z1] = ((tr->st[z] == p7T_I) ? '.' : om->cs[tr->k[z]]);
ad->csline[z-z1] = '\0';
}
/* optional pp line */
if (ad->ppline != NULL) {
for (z = z1; z <= z2; z++) ad->ppline[z-z1] = ( (tr->st[z] == p7T_D) ? '.' : p7_alidisplay_EncodePostProb(tr->pp[z]));
ad->ppline[z-z1] = '\0';
}
/* mandatory three alignment display lines: model, mline, aseq */
for (z = z1; z <= z2; z++)
{
k = tr->k[z];
i = tr->i[z];
x = sq->dsq[i];
s = tr->st[z];
switch (s) {
case p7T_M:
ad->model[z-z1] = om->consensus[k];
if (x == esl_abc_DigitizeSymbol(om->abc, om->consensus[k])) ad->mline[z-z1] = ad->model[z-z1];
else if (p7_oprofile_FGetEmission(om, k, x) > 1.0) ad->mline[z-z1] = '+'; /* >1 not >0; om has odds ratios, not scores */
else ad->mline[z-z1] = ' ';
ad->aseq [z-z1] = toupper(Alphabet[x]);
break;
case p7T_I:
ad->model [z-z1] = '.';
ad->mline [z-z1] = ' ';
ad->aseq [z-z1] = tolower(Alphabet[x]);
break;
case p7T_D:
ad->model [z-z1] = om->consensus[k];
ad->mline [z-z1] = ' ';
ad->aseq [z-z1] = '-';
break;
default: ESL_XEXCEPTION(eslEINVAL, "invalid state in trace: not M,D,I");
}
}
ad->model [z2-z1+1] = '\0';
ad->mline [z2-z1+1] = '\0';
ad->aseq [z2-z1+1] = '\0';
ad->N = z2-z1+1;
return ad;
ERROR:
p7_alidisplay_Destroy(ad);
return NULL;
}
/* annotate_posterior_probability()
* Synopsis: Add posterior probability annotation lines to new MSA.
*/
static int
annotate_posterior_probability(ESL_MSA *msa, P7_TRACE **tr, const int *matmap, int M, int optflags)
{
double *totp = NULL; /* total posterior probability in column <apos>: [0..alen-1] */
int *matuse = NULL; /* #seqs with pp annotation in column <apos>: [0..alen-1] */
int idx; /* counter over sequences [0..nseq-1] */
int apos; /* counter for alignment columns: pp's are [0..alen-1] (unlike ax) */
int z; /* counter over trace positions [0..tr->N-1] */
int status;
/* Determine if any of the traces have posterior probability annotation. */
for (idx = 0; idx < msa->nseq; idx++)
if (tr[idx]->pp != NULL) break;
if (idx == msa->nseq) return eslOK;
ESL_ALLOC(matuse, sizeof(double) * (msa->alen)); esl_vec_ISet(matuse, msa->alen, 0);
ESL_ALLOC(totp, sizeof(double) * (msa->alen)); esl_vec_DSet(totp, msa->alen, 0.0);
ESL_ALLOC(msa->pp, sizeof(char *) * msa->sqalloc);
for (idx = 0; idx < msa->nseq; idx++)
{
if (tr[idx]->pp == NULL) { msa->pp[idx] = NULL; continue; }
ESL_ALLOC(msa->pp[idx], sizeof(char) * (msa->alen+1));
for (apos = 0; apos < msa->alen; apos++) msa->pp[idx][apos] = '.';
msa->pp[idx][msa->alen] = '\0';
apos = 0;
for (z = 0; z < tr[idx]->N; z++)
{
switch (tr[idx]->st[z]) {
case p7T_M:
msa->pp[idx][matmap[tr[idx]->k[z]]-1] = p7_alidisplay_EncodePostProb(tr[idx]->pp[z]);
totp [matmap[tr[idx]->k[z]]-1]+= tr[idx]->pp[z];
matuse[matmap[tr[idx]->k[z]]-1]++;
case p7T_D:
apos = matmap[tr[idx]->k[z]];
break;
case p7T_I:
if ( !(optflags & p7_TRIM) || (tr[idx]->k[z] != 0 && tr[idx]->k[z] != M)) {
msa->pp[idx][apos] = p7_alidisplay_EncodePostProb(tr[idx]->pp[z]);
apos++;
}
break;
case p7T_N:
case p7T_C:
if (! (optflags & p7_TRIM) && tr[idx]->i[z] > 0) {
msa->pp[idx][apos] = p7_alidisplay_EncodePostProb(tr[idx]->pp[z]);
apos++;
}
break;
case p7T_E:
apos = matmap[M]; /* set position for C-terminal tail */
break;
default:
break;
}
}
}
for (; idx < msa->sqalloc; idx++) msa->pp[idx] = NULL; /* for completeness, following easel MSA conventions, but should be a no-op: nseq==sqalloc */
/* Consensus posterior probability annotation: only on match columns */
ESL_ALLOC(msa->pp_cons, sizeof(char) * (msa->alen+1));
for (apos = 0; apos < msa->alen; apos++) msa->pp_cons[apos] = '.';
msa->pp_cons[msa->alen] = '\0';
for (apos = 0; apos < msa->alen; apos++)
if (matuse[apos]) msa->pp_cons[apos] = p7_alidisplay_EncodePostProb( totp[apos] / (double) matuse[apos]);
free(matuse);
free(totp);
return eslOK;
ERROR:
if (matuse != NULL) free(matuse);
if (totp != NULL) free(totp);
if (msa->pp != NULL) esl_Free2D((void **) msa->pp, msa->sqalloc);
return status;
}