int
p7_hit_Compare(const P7_HIT *h1, const P7_HIT *h2, float tol)
{
int d;
int status;
if ( strcmp(h1->name, h2->name) != 0) return eslFAIL;
if (esl_strcmp(h1->acc, h2->acc) != 0) return eslFAIL;
if (esl_strcmp(h1->desc, h2->desc) != 0) return eslFAIL;
if ( h1->window_length != h2->window_length) return eslFAIL;
if ( h1->ndom != h2->ndom) return eslFAIL;
if ( h1->noverlaps != h2->noverlaps) return eslFAIL;
if ( h1->flags != h2->flags) return eslFAIL;
if ( h1->nreported != h2->nreported) return eslFAIL;
if ( h1->nincluded != h2->nincluded) return eslFAIL;
if ( h1->best_domain != h2->best_domain) return eslFAIL;
if ( h1->seqidx != h2->seqidx) return eslFAIL;
if ( h1->subseq_start != h2->subseq_start) return eslFAIL;
if ( h1->offset != h2->offset) return eslFAIL;
if ( esl_DCompare( h1->sortkey, h2->sortkey, tol ) != eslOK) return eslFAIL;
if ( esl_FCompare( h1->score, h2->score, tol ) != eslOK) return eslFAIL;
if ( esl_FCompare( h1->pre_score, h2->pre_score, tol ) != eslOK) return eslFAIL;
if ( esl_FCompare( h1->sum_score, h2->sum_score, tol ) != eslOK) return eslFAIL;
if ( esl_DCompare( h1->lnP, h2->lnP, tol ) != eslOK) return eslFAIL;
if ( esl_DCompare( h1->pre_lnP, h2->pre_lnP, tol ) != eslOK) return eslFAIL;
if ( esl_DCompare( h1->sum_lnP, h2->sum_lnP, tol ) != eslOK) return eslFAIL;
if ( esl_DCompare( h1->nexpected, h2->nexpected, tol ) != eslOK) return eslFAIL;
for (d = 0; d < h1->ndom; d++)
if (( status = p7_domain_Compare(&(h1->dcl[d]), &(h2->dcl[d]), tol)) != eslOK) return status;
return eslOK;
}
/* tests:
* 1. each sampled trace must validate.
* 2. each trace must be <= viterbi trace score
* 3. in a large # of traces, one is "equal" to the viterbi trace score.
* (this of course is stochastic; but it's true for the particular
* choice of RNG seed used in tests here.)
*/
static void
utest_stotrace(ESL_GETOPTS *go, ESL_RANDOMNESS *rng, ESL_ALPHABET *abc, P7_PROFILE *gm, P7_OPROFILE *om, ESL_DSQ *dsq, int L, int ntrace)
{
P7_GMX *gx = NULL;
P7_OMX *ox = NULL;
P7_TRACE *tr = NULL;
char errbuf[eslERRBUFSIZE];
int idx;
float maxsc = -eslINFINITY;
float vsc, sc;
if ((gx = p7_gmx_Create(gm->M, L)) == NULL) esl_fatal("generic DP matrix creation failed");
if ((ox = p7_omx_Create(gm->M, L, L)) == NULL) esl_fatal("optimized DP matrix create failed");
if ((tr = p7_trace_Create()) == NULL) esl_fatal("trace creation failed");
if (p7_GViterbi(dsq, L, gm, gx, &vsc) != eslOK) esl_fatal("viterbi failed");
if (p7_Forward (dsq, L, om, ox, NULL) != eslOK) esl_fatal("forward failed");
for (idx = 0; idx < ntrace; idx++)
{
if (p7_StochasticTrace(rng, dsq, L, om, ox, tr) != eslOK) esl_fatal("stochastic trace failed");
if (p7_trace_Validate(tr, abc, dsq, errbuf) != eslOK) esl_fatal("trace invalid:\n%s", errbuf);
if (p7_trace_Score(tr, dsq, gm, &sc) != eslOK) esl_fatal("trace scoring failed");
maxsc = ESL_MAX(sc, maxsc);
if (sc > vsc) esl_fatal("sampled trace has score > optimal Viterbi path; not possible");
p7_trace_Reuse(tr);
}
if (esl_FCompare(maxsc, vsc, 0.1) != eslOK) esl_fatal("stochastic trace failed to sample the Viterbi path");
p7_trace_Destroy(tr);
p7_omx_Destroy(ox);
p7_gmx_Destroy(gx);
}
/* The "basic" utest is a minimal driver for making a small DNA profile and a small DNA sequence,
* then running Viterbi and Forward. It's useful for dumping DP matrices and profiles for debugging.
*/
static void
utest_basic(ESL_GETOPTS *go)
{
char *query= "# STOCKHOLM 1.0\n\nseq1 GAATTC\nseq2 GAATTC\n//\n";
int fmt = eslMSAFILE_STOCKHOLM;
char *targ = "GAATTC";
ESL_ALPHABET *abc = NULL;
ESL_MSA *msa = NULL;
P7_HMM *hmm = NULL;
P7_PROFILE *gm = NULL;
P7_BG *bg = NULL;
P7_PRIOR *pri = NULL;
ESL_DSQ *dsq = NULL;
P7_GMX *gx = NULL;
P7_TRACE *tr = NULL;
int L = strlen(targ);
float vsc, vsc2, fsc;
if ((abc = esl_alphabet_Create(eslDNA)) == NULL) esl_fatal("failed to create alphabet");
if ((pri = p7_prior_CreateNucleic()) == NULL) esl_fatal("failed to create prior");
if ((msa = esl_msa_CreateFromString(query, fmt)) == NULL) esl_fatal("failed to create MSA");
if (esl_msa_Digitize(abc, msa, NULL) != eslOK) esl_fatal("failed to digitize MSA");
if (p7_Fastmodelmaker(msa, 0.5, NULL, &hmm, NULL) != eslOK) esl_fatal("failed to create GAATTC model");
if (p7_ParameterEstimation(hmm, pri) != eslOK) esl_fatal("failed to parameterize GAATTC model");
if (p7_hmm_SetConsensus(hmm, NULL) != eslOK) esl_fatal("failed to make consensus");
if ((bg = p7_bg_Create(abc)) == NULL) esl_fatal("failed to create DNA null model");
if ((gm = p7_profile_Create(hmm->M, abc)) == NULL) esl_fatal("failed to create GAATTC profile");
if (p7_ProfileConfig(hmm, bg, gm, L, p7_UNILOCAL)!= eslOK) esl_fatal("failed to config profile");
if (p7_profile_Validate(gm, NULL, 0.0001) != eslOK) esl_fatal("whoops, profile is bad!");
if (esl_abc_CreateDsq(abc, targ, &dsq) != eslOK) esl_fatal("failed to create GAATTC digital sequence");
if ((gx = p7_gmx_Create(gm->M, L)) == NULL) esl_fatal("failed to create DP matrix");
if ((tr = p7_trace_Create()) == NULL) esl_fatal("trace creation failed");
p7_GViterbi (dsq, L, gm, gx, &vsc);
if (esl_opt_GetBoolean(go, "-v")) printf("Viterbi score: %.4f\n", vsc);
if (esl_opt_GetBoolean(go, "-v")) p7_gmx_Dump(stdout, gx, p7_DEFAULT);
p7_GTrace (dsq, L, gm, gx, tr);
p7_trace_Score(tr, dsq, gm, &vsc2);
if (esl_opt_GetBoolean(go, "-v")) p7_trace_Dump(stdout, tr, gm, dsq);
if (esl_FCompare(vsc, vsc2, 1e-5) != eslOK) esl_fatal("trace score and Viterbi score don't agree.");
p7_GForward (dsq, L, gm, gx, &fsc);
if (esl_opt_GetBoolean(go, "-v")) printf("Forward score: %.4f\n", fsc);
if (esl_opt_GetBoolean(go, "-v")) p7_gmx_Dump(stdout, gx, p7_DEFAULT);
p7_trace_Destroy(tr);
p7_gmx_Destroy(gx);
free(dsq);
p7_profile_Destroy(gm);
p7_bg_Destroy(bg);
p7_hmm_Destroy(hmm);
esl_msa_Destroy(msa);
p7_prior_Destroy(pri);
esl_alphabet_Destroy(abc);
return;
}
/* check_msa_weights
*
* Given an MSA, check if it has any weight that is
* different from 1.0. If yes return TRUE, if not
* return FALSE. If it does not have weights return
* FALSE.
*/
static int check_msa_weights(ESL_MSA *msa)
{
int i;
if(msa->wgt == NULL) return FALSE;
for(i = 0; i < msa->nseq; i++) {
if (esl_FCompare(msa->wgt[i], 1.0, eslSMALLX1) != eslOK) return TRUE;
}
return FALSE;
}
/* Function: p7_gmx_Compare()
* Synopsis: Compare two DP matrices for equality within given tolerance.
*
* Purpose: Compare all the values in DP matrices <gx1> and <gx2> using
* <esl_FCompare()> and relative epsilon <tolerance>. If any
* value pairs differ by more than the acceptable <tolerance>
* return <eslFAIL>. If all value pairs are identical within
* tolerance, return <eslOK>.
*/
int
p7_gmx_Compare(P7_GMX *gx1, P7_GMX *gx2, float tolerance)
{
int i,k,x;
if (gx1->M != gx2->M) return eslFAIL;
if (gx1->L != gx2->L) return eslFAIL;
for (i = 0; i <= gx1->L; i++)
{
for (k = 1; k <= gx1->M; k++) /* k=0 is a boundary; doesn't need to be checked */
{
if (esl_FCompare(gx1->dp[i][k * p7G_NSCELLS + p7G_M], gx2->dp[i][k * p7G_NSCELLS + p7G_M], tolerance) != eslOK) return eslFAIL;
if (esl_FCompare(gx1->dp[i][k * p7G_NSCELLS + p7G_I], gx2->dp[i][k * p7G_NSCELLS + p7G_I], tolerance) != eslOK) return eslFAIL;
if (esl_FCompare(gx1->dp[i][k * p7G_NSCELLS + p7G_D], gx2->dp[i][k * p7G_NSCELLS + p7G_D], tolerance) != eslOK) return eslFAIL;
}
for (x = 0; x < p7G_NXCELLS; x++)
if (esl_FCompare(gx1->xmx[i * p7G_NXCELLS + x], gx2->xmx[i * p7G_NXCELLS + x], tolerance) != eslOK) return eslFAIL;
}
return eslOK;
}
/* Note that calculate_occupancy has moved to p7_hmm.c, but
* unit tests over there aren't hooked up yet; so leave a copy of the unit test
* here for now.
*/
static void
utest_occupancy(P7_HMM *hmm)
{
char *msg = "modelconfig.c::calculate_occupancy() unit test failed";
float *occ;
float x;
occ = malloc(sizeof(float) * (hmm->M+1));
p7_hmm_CalculateOccupancy(hmm, occ, NULL);
x = esl_vec_FSum(occ+1, hmm->M) / (float) hmm->M;
if (esl_FCompare(x, 0.6, 0.1) != eslOK) esl_fatal(msg);
free(occ);
return;
}
/* Viterbi validation is done by comparing the returned score
* to the score of the optimal trace. Not foolproof, but catches
* many kinds of errors.
*
* Another check is that the average score should be <= 0,
* since the random sequences are drawn from the null model.
*/
static void
utest_viterbi(ESL_GETOPTS *go, ESL_RANDOMNESS *r, ESL_ALPHABET *abc, P7_BG *bg, P7_PROFILE *gm, int nseq, int L)
{
float avg_sc = 0.;
char errbuf[eslERRBUFSIZE];
ESL_DSQ *dsq = NULL;
P7_GMX *gx = NULL;
P7_TRACE *tr = NULL;
int idx;
float sc1, sc2;
if ((dsq = malloc(sizeof(ESL_DSQ) *(L+2))) == NULL) esl_fatal("malloc failed");
if ((tr = p7_trace_Create()) == NULL) esl_fatal("trace creation failed");
if ((gx = p7_gmx_Create(gm->M, L)) == NULL) esl_fatal("matrix creation failed");
for (idx = 0; idx < nseq; idx++)
{
if (esl_rsq_xfIID(r, bg->f, abc->K, L, dsq) != eslOK) esl_fatal("seq generation failed");
if (p7_GViterbi(dsq, L, gm, gx, &sc1) != eslOK) esl_fatal("viterbi failed");
if (p7_GTrace (dsq, L, gm, gx, tr) != eslOK) esl_fatal("trace failed");
if (p7_trace_Validate(tr, abc, dsq, errbuf) != eslOK) esl_fatal("trace invalid:\n%s", errbuf);
if (p7_trace_Score(tr, dsq, gm, &sc2) != eslOK) esl_fatal("trace score failed");
if (esl_FCompare(sc1, sc2, 1e-6) != eslOK) esl_fatal("Trace score != Viterbi score");
if (p7_bg_NullOne(bg, dsq, L, &sc2) != eslOK) esl_fatal("null score failed");
avg_sc += (sc1 - sc2);
if (esl_opt_GetBoolean(go, "--vv"))
printf("utest_viterbi: Viterbi score: %.4f (null %.4f) (total so far: %.4f)\n", sc1, sc2, avg_sc);
p7_trace_Reuse(tr);
}
avg_sc /= (float) nseq;
if (avg_sc > 0.) esl_fatal("Viterbi scores have positive expectation (%f nats)", avg_sc);
p7_gmx_Destroy(gx);
p7_trace_Destroy(tr);
free(dsq);
return;
}
/*
* 1. Compare accscore to GOptimalAccuracy().
* 2. Compare trace to GOATrace().
*
* Note: This test is subject to some expected noise and can fail
* for entirely innocent reasons. Generic Forward/Backward calculations with
* p7_GForward(), p7_GBackward() use coarse-grain table lookups to sum
* log probabilities, and sufficient roundoff error can accumulate to
* change the optimal accuracy traceback, causing this test to fail.
* So, if optacc_utest fails, before you go looking for bugs, first
* go to ../logsum.c, change the #ifdef to activate the slow/accurate
* version, recompile and rerun optacc_utest. If the failure goes away,
* you can ignore it. - SRE, Wed Dec 17 09:45:31 2008
*/
static void
utest_optacc(ESL_GETOPTS *go, ESL_RANDOMNESS *r, ESL_ALPHABET *abc, P7_BG *bg, int M, int L, int N)
{
char *msg = "optimal accuracy unit test failed";
P7_HMM *hmm = NULL;
P7_PROFILE *gm = NULL;
P7_OPROFILE *om = NULL;
ESL_SQ *sq = esl_sq_CreateDigital(abc);
P7_OMX *ox1 = p7_omx_Create(M, L, L);
P7_OMX *ox2 = p7_omx_Create(M, L, L);
P7_GMX *gx1 = p7_gmx_Create(M, L);
P7_GMX *gx2 = p7_gmx_Create(M, L);
P7_TRACE *tr = p7_trace_CreateWithPP();
P7_TRACE *trg = p7_trace_CreateWithPP();
P7_TRACE *tro = p7_trace_CreateWithPP();
float accscore_o;
float fsc, bsc, accscore;
float fsc_g, bsc_g, accscore_g, accscore_g2;
float pptol = 0.01;
float sctol = 0.001;
float gtol;
p7_FLogsumInit();
gtol = ( (p7_FLogsumError(-0.4, -0.5) > 0.0001) ? 0.1 : 0.001);
if (p7_oprofile_Sample(r, abc, bg, M, L, &hmm, &gm, &om)!= eslOK) esl_fatal(msg);
while (N--)
{
if (p7_ProfileEmit(r, hmm, gm, bg, sq, tro) != eslOK) esl_fatal(msg);
if (p7_omx_GrowTo(ox1, M, sq->n, sq->n) != eslOK) esl_fatal(msg);
if (p7_omx_GrowTo(ox2, M, sq->n, sq->n) != eslOK) esl_fatal(msg);
if (p7_gmx_GrowTo(gx1, M, sq->n) != eslOK) esl_fatal(msg);
if (p7_gmx_GrowTo(gx2, M, sq->n) != eslOK) esl_fatal(msg);
if (p7_Forward (sq->dsq, sq->n, om, ox1, &fsc) != eslOK) esl_fatal(msg);
if (p7_Backward(sq->dsq, sq->n, om, ox1, ox2, &bsc) != eslOK) esl_fatal(msg);
if (p7_Decoding(om, ox1, ox2, ox2) != eslOK) esl_fatal(msg);
if (p7_OptimalAccuracy(om, ox2, ox1, &accscore) != eslOK) esl_fatal(msg);
#if 0
p7_omx_FDeconvert(ox1, gx1);
p7_gmx_Dump(stdout, gx1, p7_DEFAULT);
p7_omx_FDeconvert(ox2, gx1);
p7_gmx_Dump(stdout, gx1, p7_DEFAULT);
#endif
if (p7_OATrace(om, ox2, ox1, tr) != eslOK) esl_fatal(msg);
if (p7_GForward (sq->dsq, sq->n, gm, gx1, &fsc_g) != eslOK) esl_fatal(msg);
if (p7_GBackward(sq->dsq, sq->n, gm, gx2, &bsc_g) != eslOK) esl_fatal(msg);
#if 0
p7_gmx_Dump(stdout, gx1, p7_DEFAULT); /* fwd */
p7_gmx_Dump(stdout, gx2, p7_DEFAULT); /* bck */
#endif
if (p7_GDecoding(gm, gx1, gx2, gx2) != eslOK) esl_fatal(msg);
if (p7_GOptimalAccuracy(gm, gx2, gx1, &accscore_g) != eslOK) esl_fatal(msg);
#if 0
p7_gmx_Dump(stdout, gx1, p7_DEFAULT); /* oa */
p7_gmx_Dump(stdout, gx2, p7_DEFAULT); /* pp */
#endif
if (p7_GOATrace(gm, gx2, gx1, trg) != eslOK) esl_fatal(msg);
if (p7_trace_SetPP(tro, gx2) != eslOK) esl_fatal(msg);
if (esl_opt_GetBoolean(go, "--traces"))
{
p7_trace_Dump(stdout, tro, gm, sq->dsq);
p7_trace_Dump(stdout, tr, gm, sq->dsq);
p7_trace_Dump(stdout, trg, gm, sq->dsq);
}
if (p7_trace_Validate(tr, abc, sq->dsq, NULL) != eslOK) esl_fatal(msg);
if (p7_trace_Validate(trg, abc, sq->dsq, NULL) != eslOK) esl_fatal(msg);
if (p7_trace_Compare(tr, trg, pptol) != eslOK) esl_fatal(msg);
accscore_o = p7_trace_GetExpectedAccuracy(tro); /* according to gx2; see p7_trace_SetPP() call above */
accscore_g2 = p7_trace_GetExpectedAccuracy(trg);
#if 0
printf("%f %f %f %f\n", accscore, accscore_g, accscore_g2, accscore_o);
#endif
if (esl_FCompare(fsc, bsc, sctol) != eslOK) esl_fatal(msg);
if (esl_FCompare(fsc_g, bsc_g, gtol) != eslOK) esl_fatal(msg);
if (esl_FCompare(fsc, fsc_g, gtol) != eslOK) esl_fatal(msg);
if (esl_FCompare(accscore, accscore_g, gtol) != eslOK) esl_fatal(msg);
if (esl_FCompare(accscore_g, accscore_g2, gtol) != eslOK) esl_fatal(msg);
if (accscore_g2 < accscore_o) esl_fatal(msg);
/* the above deserves explanation:
* - accscore_o is the accuracy of the originally emitted trace, according
* to the generic posterior decoding matrix <gx2>. This is a lower bound
* on the expected # of accurately aligned residues found by a DP
* optimization.
* - accscore is the accuracy found by the fast (vector) code DP implementation.
* - accscore_g is the accuracy found by the generic DP implementation.
* accscore and accscore_g should be nearly identical,
* within tolerance of roundoff error accumulation and
* the imprecision of Logsum() tables.
* - accscore_g2 is the accuracy of the traceback identified by the generic
* DP implementation. It should be identical (within order-of-evaluation
* roundoff error) to accscore_g.
*
* the "accscore_g2 < accscore_o" test is carefully contrived.
* accscore_o is a theoretical lower bound but because of fp error,
* accscore and (much more rarely) even accscore_g can exceed accscore_o.
* accscore_g2, however, is calculated with identical order of evaluation
* as accscore_o if the optimal trace does turn out to be identical to
* the originally emitted trace. It should be extremely unlikely (though
* not impossible) for accscore_o to exceed accscore_g2. (The DP algorithm
* would have to identify a trace that was different than the original trace,
* which the DP algorithm, by order-of-evaluation, assigned higher accuracy,
* but order-of-evaluation in traceback dependent code assigned lower accuracy.
* [xref J5/29]
*/
esl_sq_Reuse(sq);
p7_trace_Reuse(tr);
p7_trace_Reuse(trg);
p7_trace_Reuse(tro);
}
p7_trace_Destroy(tro);
p7_trace_Destroy(trg);
p7_trace_Destroy(tr);
p7_gmx_Destroy(gx2);
p7_gmx_Destroy(gx1);
p7_omx_Destroy(ox2);
p7_omx_Destroy(ox1);
esl_sq_Destroy(sq);
p7_oprofile_Destroy(om);
p7_profile_Destroy(gm);
p7_hmm_Destroy(hmm);
}
/* Function: p7_bg_Read()
* Synopsis: Read background frequencies from a file.
*
* Purpose: Read new background frequencies from file <bgfile>,
* overwriting the frequencies previously in the
* <P7_BG> object <bg>.
*
* Note that <bg> is already created by the caller, not
* created here. Also note that <p7_bg_Read()> only reads
* residue background frequencies used for the "null
* model", whereas a <P7_BG> object contains additional
* information for the bias filter and for the biased
* composition correction.
*
* Args: bgfile - file to read.
* bg - existing <P7_BG> object provided by the caller.
* errbuf - OPTIONAL: space for an error message, upon parse errors; or NULL.
*
* Returns: <eslOK> on success, and background frequencies in <bg>
* are overwritten.
*
* <eslENOTFOUND> if <bgfile> can't be opened for reading.
* <eslEFORMAT> if parsing of <bgfile> fails for some
* reason. In both cases, <errbuf> contains a
* user-directed error message upon return, including (if
* relevant) the file name <bgfile> and the line number on
* which an error was detected. <bg> is unmodified.
*
* Throws: <eslEMEM> on allocation failure; <bg> is unmodified,
* and <errbuf> is empty.
*/
int
p7_bg_Read(char *bgfile, P7_BG *bg, char *errbuf)
{
ESL_FILEPARSER *efp = NULL;
float *fq = NULL;
int n = 0;
char *tok;
int toklen;
int alphatype;
ESL_DSQ x;
int status;
if (errbuf) errbuf[0] = '\0';
status = esl_fileparser_Open(bgfile, NULL, &efp);
if (status == eslENOTFOUND) ESL_XFAIL(eslENOTFOUND, errbuf, "couldn't open bg file %s for reading", bgfile);
else if (status != eslOK) goto ERROR;
esl_fileparser_SetCommentChar(efp, '#');
/* First token is alphabet type: amino | DNA | RNA */
status = esl_fileparser_GetToken(efp, &tok, &toklen);
if (status == eslEOF) ESL_XFAIL(eslEFORMAT, errbuf, "premature end of file [line %d of bgfile %s]", efp->linenumber, bgfile);
else if (status != eslOK) goto ERROR;
alphatype = esl_abc_EncodeType(tok);
if (alphatype == eslUNKNOWN) ESL_XFAIL(eslEFORMAT, errbuf, "expected alphabet type but saw \"%s\" [line %d of bgfile %s]", tok, efp->linenumber, bgfile);
else if (alphatype != bg->abc->type) ESL_XFAIL(eslEFORMAT, errbuf, "bg file's alphabet is %s; expected %s [line %d, %s]", tok, esl_abc_DecodeType(bg->abc->type), efp->linenumber, bgfile);
ESL_ALLOC(fq, sizeof(float) * bg->abc->K);
esl_vec_FSet(fq, bg->abc->K, -1.0);
while ((status = esl_fileparser_NextLine(efp)) == eslOK)
{
status = esl_fileparser_GetTokenOnLine(efp, &tok, &toklen);
if (status == eslEOL) ESL_XFAIL(eslEFORMAT, errbuf, "premature end of file [line %d of bgfile %s", efp->linenumber, bgfile);
else if (status != eslOK) goto ERROR;
if (toklen != 1 || ! esl_abc_CIsCanonical(bg->abc, *tok))
ESL_XFAIL(eslEFORMAT, errbuf, "expected to parse a residue letter; saw %s [line %d of bgfile %s]", tok, efp->linenumber, bgfile);
x = esl_abc_DigitizeSymbol(bg->abc, *tok);
if (fq[x] != -1.0) ESL_XFAIL(eslEFORMAT, errbuf, "already parsed probability of %c [line %d of bgfile %s]", bg->abc->sym[x], efp->linenumber, bgfile);
n++;
status = esl_fileparser_GetTokenOnLine(efp, &tok, &toklen);
if (status == eslEOL) ESL_XFAIL(eslEFORMAT, errbuf, "premature end of file, expected a probability [line %d of bgfile %s]", efp->linenumber, bgfile);
else if (status != eslOK) goto ERROR;
if (! esl_str_IsReal(tok)) ESL_XFAIL(eslEFORMAT, errbuf, "expected a probability, saw %s [line %d of bgfile %s]", tok, efp->linenumber, bgfile);
fq[x] = atof(tok);
status = esl_fileparser_GetTokenOnLine(efp, &tok, &toklen);
if (status == eslOK) ESL_XFAIL(eslEFORMAT, errbuf, "extra unexpected data found [line %d of bgfile %s]", efp->linenumber, bgfile);
else if (status != eslEOL) goto ERROR;
}
if (status != eslEOF) goto ERROR;
if ( n != bg->abc->K)
ESL_XFAIL(eslEFORMAT, errbuf, "expected %d residue frequencies, but found %d in bgfile %s", bg->abc->K, n, bgfile);
if ( esl_FCompare(esl_vec_FSum(fq, bg->abc->K), 1.0, 0.001) != eslOK)
ESL_XFAIL(eslEFORMAT, errbuf, "residue frequencies do not sum to 1.0 in bgfile %s", bgfile);
/* all checking complete. no more error cases. overwrite bg with the new frequencies */
esl_vec_FNorm(fq, bg->abc->K);
esl_vec_FCopy(fq, bg->abc->K, bg->f);
free(fq);
esl_fileparser_Close(efp);
return eslOK;
ERROR:
if (fq) free(fq);
if (efp) esl_fileparser_Close(efp);
return status;
}
/* "singlemulti" test.
*
* Use p7_modelsample_SinglePathedASC() to create a
* profile/sequence/anchorset comparison that has only a single
* possible path when anchor set constrained. Now the expected true
* envelope(s) are known, from that single path, and we can compare.
*
* In order to guarantee only one possible path, while allowing
* multiple domains, the profile is limited to glocal-only.
*
* We test:
* 1. Trace and envelopes agree on number of domains.
* 2. For each domain, oa==ia, ob==ib, and these coords
* agree with the trace.
* 3. In the case of a single domain (D=1), the envelope
* score == the trace score.
*/
static void
utest_singlemulti(ESL_RANDOMNESS *rng, int M, const ESL_ALPHABET *abc, int N)
{
char msg[] = "reference_envelopes singlemulti unit test failed";
P7_BG *bg = p7_bg_Create(abc);
P7_HMM *hmm = NULL;
P7_PROFILE *gm = NULL;
ESL_DSQ *dsq = NULL;
int L;
P7_TRACE *gtr = NULL;
P7_ANCHOR *anch = NULL;
int D;
P7_REFMX *afu = p7_refmx_Create(M, 20);
P7_REFMX *afd = p7_refmx_Create(M, 20);
P7_REFMX *apu = p7_refmx_Create(M, 20);
P7_REFMX *apd = p7_refmx_Create(M, 20);
P7_ENVELOPES *env = p7_envelopes_Create();
float gsc;
float tol = 0.001;
int idx;
int d;
for (idx = 0; idx < N; idx++)
{
if ( p7_modelsample_SinglePathedASC(rng, M, bg, &hmm, &gm, &dsq, &L, >r, &anch, &D, &gsc) != eslOK) esl_fatal(msg);
if ( p7_ReferenceASCForward (dsq, L, gm, anch, D, afu, afd, NULL) != eslOK) esl_fatal(msg);
if ( p7_ReferenceASCBackward(dsq, L, gm, anch, D, apu, apd, NULL) != eslOK) esl_fatal(msg);
if ( p7_ReferenceASCDecoding(dsq, L, gm, anch, D, afu, afd, apu, apd, apu, apd) != eslOK) esl_fatal(msg);
if ( p7_reference_Envelopes (dsq, L, gm, anch, D, apu, apd, afu, afd, env) != eslOK) esl_fatal(msg);
/* Test 1. Domain #'s agree */
if (! (gtr->ndom == D && env->D == D)) esl_fatal(msg);
/* Test 2. Envelope coords (and outer env coords) match trace.
* (Beware, trace domains are numbered 0..D-1, env domains are 1..D )
*/
for (d = 1; d <= D; d++)
{
if (! (env->arr[d].ia == gtr->sqfrom[d-1] &&
env->arr[d].ia == env->arr[d].oa)) esl_fatal(msg);
if (! (env->arr[d].ib == gtr->sqto[d-1] &&
env->arr[d].ib == env->arr[d].ob)) esl_fatal(msg);
}
/* Test 3. If D == 1, envelope score == trace score. */
if (D == 1 && esl_FCompare(env->arr[1].env_sc, gsc, tol) != eslOK) esl_fatal(msg);
p7_envelopes_Reuse(env);
p7_refmx_Reuse(afu); p7_refmx_Reuse(afd);
p7_refmx_Reuse(apu); p7_refmx_Reuse(apd);
free(dsq);
free(anch);
p7_trace_Destroy(gtr);
p7_hmm_Destroy(hmm);
p7_profile_Destroy(gm);
}
p7_envelopes_Destroy(env);
p7_refmx_Destroy(afu); p7_refmx_Destroy(afd);
p7_refmx_Destroy(apu); p7_refmx_Destroy(apd);
p7_bg_Destroy(bg);
}
/* Function: p7_GTrace()
* Incept: SRE, Thu Feb 1 10:25:56 2007 [UA 8018 St. Louis to Dulles]
*
* Purpose: Traceback of a Viterbi matrix: retrieval
* of optimum alignment.
*
* This function is currently implemented as a
* reconstruction traceback, rather than using a shadow
* matrix. Because H3 uses floating point scores, and we
* can't compare floats for equality, we have to compare
* floats for near-equality and therefore, formally, we can
* only guarantee a near-optimal traceback. However, even in
* the unlikely event that a suboptimal is returned, the
* score difference from true optimal will be negligible.
*
* Args: dsq - digital sequence aligned to, 1..L
* L - length of <dsq>
* gm - profile
* mx - Viterbi matrix to trace, L x M
* tr - storage for the recovered traceback.
*
* Return: <eslOK> on success.
* <eslFAIL> if even the optimal path has zero probability;
* in this case, the trace is set blank (<tr->N = 0>).
*
* Note: Care is taken to evaluate the prev+tsc+emission
* calculations in exactly the same order that Viterbi did
* them, lest you get numerical problems with
* a+b+c = d; d-c != a+b because d,c are nearly equal.
* (This bug appeared in dev: xref J1/121.)
*/
int
p7_GTrace(const ESL_DSQ *dsq, int L, const P7_PROFILE *gm, const P7_GMX *gx, P7_TRACE *tr)
{
int i = L; /* position in seq (1..L) */
int k = 0; /* position in model (1..M) */
int M = gm->M;
float **dp = gx->dp; /* so {MDI}MX() macros work */
float *xmx = gx->xmx; /* so XMX() macro works */
float tol = 1e-5; /* floating point "equality" test */
float const *tsc = gm->tsc;
int sprv, scur; /* previous, current state in trace */
int status;
#ifdef p7_DEBUGGING
if (tr->N != 0) ESL_EXCEPTION(eslEINVAL, "trace isn't empty: forgot to Reuse()?");
#endif
if ((status = p7_trace_Append(tr, p7T_T, k, i)) != eslOK) return status;
if ((status = p7_trace_Append(tr, p7T_C, k, i)) != eslOK) return status;
sprv = p7T_C;
while (sprv != p7T_S) {
float const *rsc = (i>0 ? gm->rsc[dsq[i]] : NULL);
switch (sprv) {
case p7T_C: /* C(i) comes from C(i-1) or E(i) */
if (XMX(i,p7G_C) == -eslINFINITY) ESL_EXCEPTION(eslFAIL, "impossible C reached at i=%d", i);
if (esl_FCompare(XMX(i, p7G_C), XMX(i-1, p7G_C) + gm->xsc[p7P_C][p7P_LOOP], tol) == eslOK) scur = p7T_C;
else if (esl_FCompare(XMX(i, p7G_C), XMX(i, p7G_E) + gm->xsc[p7P_E][p7P_MOVE], tol) == eslOK) scur = p7T_E;
else ESL_EXCEPTION(eslFAIL, "C at i=%d couldn't be traced", i);
break;
case p7T_E: /* E connects from any M state. k set here */
if (XMX(i, p7G_E) == -eslINFINITY) ESL_EXCEPTION(eslFAIL, "impossible E reached at i=%d", i);
if (p7_profile_IsLocal(gm))
{
scur = p7T_M; /* can't come from D, in a *local* Viterbi trace. */
for (k = M; k >= 1; k--) if (esl_FCompare(XMX(i, p7G_E), MMX(i,k), tol) == eslOK) break;
if (k == 0) ESL_EXCEPTION(eslFAIL, "E at i=%d couldn't be traced", i);
}
else /* glocal mode: we either come from D_M or M_M */
{
if (esl_FCompare(XMX(i, p7G_E), MMX(i,M), tol) == eslOK) { scur = p7T_M; k = M; }
else if (esl_FCompare(XMX(i, p7G_E), DMX(i,M), tol) == eslOK) { scur = p7T_D; k = M; }
else ESL_EXCEPTION(eslFAIL, "E at i=%d couldn't be traced", i);
}
break;
case p7T_M: /* M connects from i-1,k-1, or B */
if (MMX(i,k) == -eslINFINITY) ESL_EXCEPTION(eslFAIL, "impossible M reached at k=%d,i=%d", k,i);
if (esl_FCompare(MMX(i,k), XMX(i-1,p7G_B) + TSC(p7P_BM, k-1) + MSC(k), tol) == eslOK) scur = p7T_B;
else if (esl_FCompare(MMX(i,k), MMX(i-1,k-1) + TSC(p7P_MM, k-1) + MSC(k), tol) == eslOK) scur = p7T_M;
else if (esl_FCompare(MMX(i,k), IMX(i-1,k-1) + TSC(p7P_IM, k-1) + MSC(k), tol) == eslOK) scur = p7T_I;
else if (esl_FCompare(MMX(i,k), DMX(i-1,k-1) + TSC(p7P_DM, k-1) + MSC(k), tol) == eslOK) scur = p7T_D;
else ESL_EXCEPTION(eslFAIL, "M at k=%d,i=%d couldn't be traced", k,i);
k--; i--;
break;
case p7T_D: /* D connects from M,D at i,k-1 */
if (DMX(i, k) == -eslINFINITY) ESL_EXCEPTION(eslFAIL, "impossible D reached at k=%d,i=%d", k,i);
if (esl_FCompare(DMX(i,k), MMX(i, k-1) + TSC(p7P_MD, k-1), tol) == eslOK) scur = p7T_M;
else if (esl_FCompare(DMX(i,k), DMX(i, k-1) + TSC(p7P_DD, k-1), tol) == eslOK) scur = p7T_D;
else ESL_EXCEPTION(eslFAIL, "D at k=%d,i=%d couldn't be traced", k,i);
k--;
break;
case p7T_I: /* I connects from M,I at i-1,k*/
if (IMX(i,k) == -eslINFINITY) ESL_EXCEPTION(eslFAIL, "impossible I reached at k=%d,i=%d", k,i);
if (esl_FCompare(IMX(i,k), MMX(i-1,k) + TSC(p7P_MI, k) + ISC(k), tol) == eslOK) scur = p7T_M;
else if (esl_FCompare(IMX(i,k), IMX(i-1,k) + TSC(p7P_II, k) + ISC(k), tol) == eslOK) scur = p7T_I;
else ESL_EXCEPTION(eslFAIL, "I at k=%d,i=%d couldn't be traced", k,i);
i--;
break;
case p7T_N: /* N connects from S, N */
if (XMX(i, p7G_N) == -eslINFINITY) ESL_EXCEPTION(eslFAIL, "impossible N reached at i=%d", i);
scur = ( (i == 0) ? p7T_S : p7T_N);
break;
case p7T_B: /* B connects from N, J */
if (XMX(i,p7G_B) == -eslINFINITY) ESL_EXCEPTION(eslFAIL, "impossible B reached at i=%d", i);
if (esl_FCompare(XMX(i,p7G_B), XMX(i, p7G_N) + gm->xsc[p7P_N][p7P_MOVE], tol) == eslOK) scur = p7T_N;
else if (esl_FCompare(XMX(i,p7G_B), XMX(i, p7G_J) + gm->xsc[p7P_J][p7P_MOVE], tol) == eslOK) scur = p7T_J;
else ESL_EXCEPTION(eslFAIL, "B at i=%d couldn't be traced", i);
break;
case p7T_J: /* J connects from E(i) or J(i-1) */
if (XMX(i,p7G_J) == -eslINFINITY) ESL_EXCEPTION(eslFAIL, "impossible J reached at i=%d", i);
if (esl_FCompare(XMX(i,p7G_J), XMX(i-1,p7G_J) + gm->xsc[p7P_J][p7P_LOOP], tol) == eslOK) scur = p7T_J;
else if (esl_FCompare(XMX(i,p7G_J), XMX(i, p7G_E) + gm->xsc[p7P_E][p7P_LOOP], tol) == eslOK) scur = p7T_E;
else ESL_EXCEPTION(eslFAIL, "J at i=%d couldn't be traced", i);
break;
default: ESL_EXCEPTION(eslFAIL, "bogus state in traceback");
} /* end switch over statetype[tpos-1] */
/* Append this state and the current i,k to be explained to the growing trace */
if ((status = p7_trace_Append(tr, scur, k, i)) != eslOK) return status;
/* For NCJ, we had to defer i decrement. */
if ( (scur == p7T_N || scur == p7T_J || scur == p7T_C) && scur == sprv) i--;
sprv = scur;
} /* end traceback, at S state */
tr->M = gm->M;
tr->L = L;
return p7_trace_Reverse(tr);
}
