int p7_ViterbiCOPSw_run(DATA_COPS16* dcops, SEQ **seqsdb, float* results)
{
int j, maxL = 0;
for (j = 0; j < SSE16_NVALS; j++)
if (seqsdb[j]->length > maxL)
maxL = seqsdb[j]->length;
if (maxL > dcops->allocL-10)
{ // realloc
dcops->allocL = ESL_MAX(dcops->allocL*2, roundtop(maxL,1024));
free_cops_buffers(dcops);
alloc_cops_buffers(dcops, dcops->allocL);
}
if (dcops->L != maxL)
{ dcops->L = maxL;
p7_ReconfigLength(dcops->gm, maxL);
}
for (j = 0; j < SSE16_NVALS; j++)
// must be copied since we run N seqs in parallel up to the max length of the longest
memcpy(dcops->seqs[j], seqsdb[j]->seq, (seqsdb[j]->length+1)*sizeof(ESL_DSQ));
// pad sequences with k = Alphasize
byte alphSize = dcops->gm->abc->Kp;
for (j = 0; j < SSE16_NVALS; j++)
memset(dcops->seqs[j]+seqsdb[j]->length+1, alphSize, maxL-seqsdb[j]->length);
for (j = 1; j <= dcops->gm->M/dcops->partition; j++)
memset((void*) dcops->synchflags[j], 0, dcops->nflags);
dcops->synccontrol++;
p7_ViterbiCOPSw_partitioned_threaded(dcops, results, NTHREADS-1 );
return maxL;
}
/* Function: p7_ReconfigUnihit()
* Synopsis: Quickly reconfig model into unihit mode for target length <L>.
*
* Purpose: Given a profile <gm> that's already been configured once,
* quickly reconfigure it into a unihit mode for target
* length <L>.
*
* This gets called in domain definition, when we need to
* flip the model in and out of unihit <L=0> mode to
* process individual domains.
*/
int
p7_ReconfigUnihit(P7_PROFILE *gm, int L)
{
gm->xsc[p7P_E][p7P_MOVE] = 0.0f;
gm->xsc[p7P_E][p7P_LOOP] = -eslINFINITY;
gm->nj = 0.0f;
return p7_ReconfigLength(gm, L);
}
/* Function: p7_ReconfigMultihit()
* Synopsis: Quickly reconfig model into multihit mode for target length <L>.
*
* Purpose: Given a profile <gm> that's already been configured once,
* quickly reconfigure it into a multihit mode for target
* length <L>.
*
* This gets called in domain definition, when we need to
* flip the model in and out of unihit <L=0> mode to
* process individual domains.
*
* Note: You can't just flip uni/multi mode alone, because that
* parameterization also affects target length
* modeling. You need to make sure uni vs. multi choice is
* made before the length model is set, and you need to
* make sure the length model is recalculated if you change
* the uni/multi mode. Hence, these functions call
* <p7_ReconfigLength()>.
*/
int
p7_ReconfigMultihit(P7_PROFILE *gm, int L)
{
gm->xsc[p7P_E][p7P_MOVE] = -eslCONST_LOG2;
gm->xsc[p7P_E][p7P_LOOP] = -eslCONST_LOG2;
gm->nj = 1.0f;
return p7_ReconfigLength(gm, L);
}
int
main(int argc, char **argv)
{
char *hmmfile = argv[1]; /* name of HMM file to read one HMM from */
ESL_ALPHABET *abc = NULL; /* sequence alphabet */
ESL_RANDOMNESS *r = NULL; /* source of randomness */
P7_HMMFILE *hfp = NULL; /* open hmmfile */
P7_HMM *hmm = NULL; /* HMM to emit from */
P7_PROFILE *gm = NULL; /* profile HMM (scores) */
P7_BG *bg = NULL; /* null model */
P7_TRACE *tr = NULL; /* sampled trace */
ESL_SQ *sq = NULL; /* sampled digital sequence */
int n = 1000;
int counts[p7T_NSTATETYPES];
int i;
float sc;
float nullsc;
double bitscore;
r = esl_randomness_CreateFast(0);
tr = p7_trace_Create();
if (p7_hmmfile_OpenE(hmmfile, NULL, &hfp, NULL) != eslOK) p7_Fail("failed to open %s", hmmfile);
if (p7_hmmfile_Read(hfp, &abc, &hmm) != eslOK) p7_Fail("failed to read HMM");
sq = esl_sq_CreateDigital(abc);
bg = p7_bg_Create(abc);
gm = p7_profile_Create(hmm->M, abc);
p7_ProfileConfig(hmm, bg, gm, sq->n, p7_LOCAL);
for (i = 0; i < n; i++)
{
p7_ProfileEmit(r, hmm, gm, bg, sq, tr);
p7_trace_GetStateUseCounts(tr, counts);
p7_ReconfigLength(gm, sq->n);
p7_bg_SetLength(bg, sq->n);
p7_trace_Score(tr, sq->dsq, gm, &sc);
p7_bg_NullOne (bg, sq->dsq, sq->n, &nullsc);
bitscore = (sc - nullsc)/ eslCONST_LOG2;
printf("%d %8.4f\n",
counts[p7T_M] + (counts[p7T_I] + counts[p7T_D])/2,
bitscore);
}
p7_profile_Destroy(gm);
esl_sq_Destroy(sq);
p7_trace_Destroy(tr);
esl_randomness_Destroy(r);
esl_alphabet_Destroy(abc);
p7_hmmfile_Close(hfp);
p7_hmm_Destroy(hmm);
return eslOK;
}
int p7_ViterbiStream(DATA_STREAM* dstream, dsq_cmp_t **seqsdb, float* results)
{
int j, maxL = 0;
#if 0
for (j = 0; j < 8; j++)
if (seqsdb[j]->length > maxL)
maxL = seqsdb[j]->length;
// maxL = 2000;
// for (j = 0; j < 8; j++) printf("%d ", seqsdb[j]->length); printf("\n");
if (maxL > dstream->allocL-10)
{ // realloc
dstream->allocL = ESL_MAX(dstream->allocL*2, roundtop(maxL,1024));
free_stream_buffers(dstream);
alloc_stream_buffers(dstream, dstream->allocL);
}
if (dstream->L != maxL)
{ dstream->L = maxL;
p7_ReconfigLength(dstream->gm, maxL);
}
for (j = 0; j < 8; j++)
memcpy(dstream->seqs[j], seqsdb[j]->seq, (seqsdb[j]->length+1)*sizeof(ESL_DSQ));
// pad sequences with k = Alphasize
for (j = 0; j < 8; j++)
memset(dstream->seqs[j]+seqsdb[j]->length+1, dstream->gm->abc->Kp, maxL-seqsdb[j]->length);
for (j = 1; j <= dstream->gm->M/dstream->partition; j++)
memset((void*) dstream->synchflags[j], 0, dstream->nflags);
for (j = 1; j <= dstream->gm->M/dstream->partition; j++)
memset((void*) dstream->synchflags[j], 0, dstream->nflags);
#endif
if(1)
for (j = 0; j < NTHREADS-1; j++)
{ sem_post(&semsynch[j]);
syncflags[j] = 1;
}
dstream->synccontrol++;
viterbi_stream_word_partitioned(dstream, results, NTHREADS-1 );
return maxL;
}
int main(int argc, char **argv)
{
ESL_GETOPTS *go = esl_getopts_CreateDefaultApp(options, 2, argc, argv, banner, usage);
char *hmmfile = esl_opt_GetArg(go, 1);
char *seqfile = esl_opt_GetArg(go, 2);
ESL_STOPWATCH *w = esl_stopwatch_Create();
ESL_RANDOMNESS*r = esl_randomness_Create(esl_opt_GetInteger(go, "-s"));
ESL_ALPHABET*abc = NULL;
P7_HMMFILE *hfp = NULL;
P7_HMM *hmm = NULL;
P7_BG *bg = NULL;
P7_PROFILE *gm1, *gm2;
int L = 2000; // esl_opt_GetInteger(go, "-L");
int N = esl_opt_GetInteger(go, "-N");
int MaxPart = esl_opt_GetInteger(go, "-M");
__m128 resdata[10];
float *sc1 = (float*) (resdata+0); // uses 1 __m128s
ESL_DSQ *dsq = NULL;
int i, j;
ESL_SQFILE *sqfp = NULL;
DATA_STREAM *dstream;
struct timeb tbstart, tbend;
int sumlengths = 0;
if (p7_hmmfile_Open(hmmfile, NULL, &hfp)!= eslOK) p7_Fail("Failed to open HMM file %s", hmmfile);
if (p7_hmmfile_Read(hfp, &abc, &hmm) != eslOK) p7_Fail("Failed to read HMM");
bg = p7_bg_Create(abc);
p7_bg_SetLength(bg, L);
gm1 = p7_profile_Create(hmm->M, abc);
gm2 = p7_profile_Create(hmm->M, abc);
p7_ProfileConfig(hmm, bg, gm1, L, p7_UNILOCAL);
p7_ProfileConfig(hmm, bg, gm2, L, p7_UNILOCAL);
dstream = p7_ViterbiStream_Create(gm1);
p7_ViterbiStream_Setup(dstream, L+100, MaxPart); // use max L
dstream->L = L;
// No. of partitions computed without full parallelism ( == no. of threads active while some are idle)
int Niters_part = dstream->Npartitions % NTHREADS;
// No. of Model lines that could be computed but are wasted by idle threads waiting on the end
int Nwasted_threads = dstream->partition * ((NTHREADS-Niters_part) % NTHREADS);
// No. of lines in the last partition that go beyond M. It's wasted comp time by a single thread
int Nwasted_leftover= (dstream->partition - gm1->M % dstream->partition) % dstream->partition;
// Total number of wasted lines
int wastedcomp = Nwasted_threads + Nwasted_leftover;
// Total number of lines computed and waited for
int totalcomp = wastedcomp + gm1->M; // same as: roundtop(gm1->M, dstream->partition * NTHREADS);
printf("Viterbi Stream Word with %d Threads, model %s: Modelsize %d, #Segms: %d, SeqL: %d, Nseqs %d, Part %d, #Parts %d\n",
NTHREADS, hmmfile, gm1->M, (int) ceil(gm1->M/8.0), L, 8*N, dstream->partition, dstream->Npartitions);
printf("Total Comp Lines: %d | Wasted Comp Lines: %d\n", totalcomp, wastedcomp);
// for ViterbiFilter
P7_OPROFILE *om = p7_oprofile_Create(hmm->M, gm1->abc);
p7_oprofile_Convert(gm1, om);
P7_OMX *ox = p7_omx_Create(hmm->M, 0, 0);
dsq_cmp_t **seqsdb= calloc(8*N+64, sizeof(dsq_cmp_t*));
if(0)
{ ESL_SQ* sq = esl_sq_CreateDigital(abc);
if (esl_sqfile_OpenDigital(abc, seqfile, eslSQFILE_FASTA, NULL, &sqfp) != eslOK)
{ p7_Fail("Failed to open sequence file\n"); return -1; }
for (j = 0; j < 8*N; j++)
{
int res = esl_sqio_Read(sqfp, sq);
if (res != eslOK) { printf("ATENCAO: faltam sequencias\n"); break; }
int len = sq->n;
dsq = sq->dsq;
seqsdb[j] = malloc(sizeof(dsq_cmp_t));
seqsdb[j]->length = len;
seqsdb[j]->seq = malloc((len+4)*sizeof(ESL_DSQ));
memcpy(seqsdb[j]->seq, dsq, len+2);
sumlengths += len;
esl_sq_Reuse(sq);
}
ftime(&tbstart);
N = j/8;
printf("N = %d\n", N);
// Sort sequences by length
qsort(seqsdb, N*8, sizeof(dsq_cmp_t*), compare_seqs);
}
else if(0)
for (i = 0; i < N; i++)
{
for (j = 0; j < 8; j++)
{
int len = L - rand()%1000;
seqsdb[i*8+j] = malloc(sizeof(dsq_cmp_t));
seqsdb[i*8+j]->seq = malloc(len+4);
seqsdb[i*8+j]->length = len;
esl_rsq_xfIID(r, bg->f, abc->K, len, seqsdb[i*8+j]->seq);
sumlengths += len;
}
}
// double sumerrors = 0;
float* results = (float*) alloc_m128_aligned64(N*2+2);
ftime(&tbstart);
for (j = 0; j < N; j++)
for (i = 0; i < N; i++)
{
// if (i % 10000 == 0) printf("START %d\n", i);
p7_ViterbiStream(dstream, seqsdb+i*8, sc1);
// memcpy(results+i*8, sc1, 32);
}
ftime(&tbend);
double secs = TIMEDIFF(tbstart,tbend);
// printf("Qsort time: %6.3f | Viterbi time: %6.3f\n", TIMEDIFF(tbqsort,tbstart), secs);
w->elapsed = w->user = secs;
esl_stopwatch_Display(stdout, w, "# Opt CPU time: ");
printf("# %.0fM cells in %.1f Mc/s\n", (sumlengths * (double) gm1->M) / 1e6, (sumlengths * (double) gm1->M * 1e-6) / secs);
if(0) // compare results against base version
for (i = 0; i < 1000 && i < N; i++)
{
int maxll = 0; float sc2;
for (j = 0; j < 8; j++)
if (maxll < seqsdb[i*8+j]->length)
maxll = seqsdb[i*8+j]->length;
// for (j = 0; j < 8; j++) printf("%d ", seqsdb[i*8+j]->length); printf("\n");
// if (i % 10 == 0) printf("i %d\n", i);
p7_oprofile_ReconfigRestLength(om, maxll);
p7_ReconfigLength(gm2, maxll); // fazer Reconfig aqui para emular compl o VitStream
for (j = 0; j < 8; j++)
{
// p7_ReconfigLength(gm2, seqsdb[i*8+j]->length);
// p7_Viterbi_unilocal(seqsdb[i*8+j]->seq, seqsdb[i*8+j]->length, gm2, &sc3);
// p7_Viterbi_unilocal_word(seqsdb[i*8+j]->seq, seqsdb[i*8+j]->length, gm2, &sc2);
// p7_oprofile_ReconfigLength(om, seqsdb[i*8+j]->length);
p7_ViterbiFilter(seqsdb[i*8+j]->seq, seqsdb[i*8+j]->length, om, ox, &sc2);
//sumerrors += fabs(sc1[j]- sc2);
if (fabs(results[i*8+j] - sc2) > 0.00001)
{ printf("%3d-%d L %4d: VS %f d %f\t| Base SerI %f\n", i, j, seqsdb[i*8+j]->length,
results[i*8+j], fabs(results[i*8+j] - sc2), sc2);
getc(stdin);
}
}
}
return 0;
}
/* Function: p7_oprofile_ReconfigLength()
* Synopsis: Set the target sequence length of a model.
* Incept: MSF Tue Nov 3, 2009 [Janelia]
*
* Purpose: Given an already configured model <om>, quickly reset its
* expected length distribution for a new mean target sequence
* length of <L>.
*
* This doesn't affect the length distribution of the null
* model. That must also be reset, using <p7_bg_SetLength()>.
*
* We want this routine to run as fast as possible, because
* this call is in the critical path: it must be called at
* each new target sequence in a database search.
*
* Returns: <eslOK> on success. Costs/scores for N,C,J transitions are set
* here.
*/
int
p7_oprofile_ReconfigLength(P7_OPROFILE *om, int L)
{
return p7_ReconfigLength(om, L);
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = esl_getopts_CreateDefaultApp(options, 2, argc, argv, banner, usage);
char *hmmfile = esl_opt_GetArg(go, 1);
char *seqfile = esl_opt_GetArg(go, 2);
ESL_ALPHABET *abc = NULL;
P7_HMMFILE *hfp = NULL;
P7_HMM *hmm = NULL;
P7_BG *bg = NULL;
P7_PROFILE *gm = NULL;
P7_OPROFILE *om = NULL;
P7_OMX *ox = NULL;
P7_GMX *gx = NULL;
ESL_SQ *sq = NULL;
ESL_SQFILE *sqfp = NULL;
int format = eslSQFILE_UNKNOWN;
float vfraw, nullsc, vfscore;
float graw, gscore;
double P, gP;
int status;
/* Read in one HMM */
if (p7_hmmfile_Open(hmmfile, NULL, &hfp) != eslOK) p7_Fail("Failed to open HMM file %s", hmmfile);
if (p7_hmmfile_Read(hfp, &abc, &hmm) != eslOK) p7_Fail("Failed to read HMM");
/* Read in one sequence */
sq = esl_sq_CreateDigital(abc);
status = esl_sqfile_Open(seqfile, format, NULL, &sqfp);
if (status == eslENOTFOUND) p7_Fail("No such file.");
else if (status == eslEFORMAT) p7_Fail("Format unrecognized.");
else if (status == eslEINVAL) p7_Fail("Can't autodetect stdin or .gz.");
else if (status != eslOK) p7_Fail("Open failed, code %d.", status);
/* create default null model, then create and optimize profile */
bg = p7_bg_Create(abc);
p7_bg_SetLength(bg, sq->n);
gm = p7_profile_Create(hmm->M, abc);
p7_ProfileConfig(hmm, bg, gm, sq->n, p7_LOCAL);
om = p7_oprofile_Create(gm->M, abc);
p7_oprofile_Convert(gm, om);
/* allocate DP matrices, both a generic and an optimized one */
ox = p7_omx_Create(gm->M, 0, sq->n);
gx = p7_gmx_Create(gm->M, sq->n);
/* Useful to place and compile in for debugging:
p7_oprofile_Dump(stdout, om); dumps the optimized profile
p7_omx_SetDumpMode(ox, TRUE); makes the fast DP algorithms dump their matrices
p7_gmx_Dump(stdout, gx); dumps a generic DP matrix
*/
while ((status = esl_sqio_Read(sqfp, sq)) == eslOK)
{
p7_oprofile_ReconfigLength(om, sq->n);
p7_ReconfigLength(gm, sq->n);
p7_bg_SetLength(bg, sq->n);
p7_omx_GrowTo(ox, om->M, 0, sq->n);
p7_gmx_GrowTo(gx, gm->M, sq->n);
p7_ViterbiFilter (sq->dsq, sq->n, om, ox, &vfraw);
p7_bg_NullOne (bg, sq->dsq, sq->n, &nullsc);
vfscore = (vfraw - nullsc) / eslCONST_LOG2;
P = esl_gumbel_surv(vfscore, om->evparam[p7_VMU], om->evparam[p7_VLAMBDA]);
p7_GViterbi (sq->dsq, sq->n, gm, gx, &graw);
gscore = (graw - nullsc) / eslCONST_LOG2;
gP = esl_gumbel_surv(gscore, gm->evparam[p7_VMU], gm->evparam[p7_VLAMBDA]);
if (esl_opt_GetBoolean(go, "-1"))
{
printf("%-30s\t%-20s\t%9.2g\t%7.2f\t%9.2g\t%7.2f\n", sq->name, hmm->name, P, vfscore, gP, gscore);
}
else if (esl_opt_GetBoolean(go, "-P"))
{ /* output suitable for direct use in profmark benchmark postprocessors: */
printf("%g\t%.2f\t%s\t%s\n", P, vfscore, sq->name, hmm->name);
}
else
{
printf("target sequence: %s\n", sq->name);
printf("vit filter raw score: %.2f nats\n", vfraw);
printf("null score: %.2f nats\n", nullsc);
printf("per-seq score: %.2f bits\n", vfscore);
printf("P-value: %g\n", P);
printf("GViterbi raw score: %.2f nats\n", graw);
printf("GViterbi seq score: %.2f bits\n", gscore);
printf("GViterbi P-value: %g\n", gP);
}
esl_sq_Reuse(sq);
}
/* cleanup */
esl_sq_Destroy(sq);
esl_sqfile_Close(sqfp);
p7_omx_Destroy(ox);
p7_gmx_Destroy(gx);
p7_oprofile_Destroy(om);
p7_profile_Destroy(gm);
p7_bg_Destroy(bg);
p7_hmm_Destroy(hmm);
p7_hmmfile_Close(hfp);
esl_alphabet_Destroy(abc);
esl_getopts_Destroy(go);
return 0;
}
/* Function: p7_ProfileConfig()
* Synopsis: Configure a search profile.
*
* Purpose: Given a model <hmm> with core probabilities, the null1
* model <bg>, a desired search <mode> (one of <p7_LOCAL>,
* <p7_GLOCAL>, <p7_UNILOCAL>, or <p7_UNIGLOCAL>), and an
* expected target sequence length <L>; configure the
* search model in <gm> with lod scores relative to the
* background frequencies in <bg>.
*
* Returns: <eslOK> on success; the profile <gm> now contains
* scores and is ready for searching target sequences.
*
* Throws: <eslEMEM> on allocation error.
*/
int
p7_ProfileConfig(const P7_HMM *hmm, const P7_BG *bg, P7_PROFILE *gm, int L, int mode)
{
int k, x, z; /* counters over states, residues, annotation */
int status;
float *occ = NULL;
float *tp, *rp;
float sc[p7_MAXCODE];
float Z;
/* Contract checks */
if (gm->abc->type != hmm->abc->type) ESL_XEXCEPTION(eslEINVAL, "HMM and profile alphabet don't match");
if (hmm->M > gm->allocM) ESL_XEXCEPTION(eslEINVAL, "profile too small to hold HMM");
if (! (hmm->flags & p7H_CONS)) ESL_XEXCEPTION(eslEINVAL, "HMM must have a consensus to transfer to the profile");
/* Copy some pointer references and other info across from HMM */
gm->M = hmm->M;
gm->max_length = hmm->max_length;
gm->mode = mode;
gm->roff = -1;
gm->eoff = -1;
gm->offs[p7_MOFFSET] = -1;
gm->offs[p7_FOFFSET] = -1;
gm->offs[p7_POFFSET] = -1;
if (gm->name != NULL) free(gm->name);
if (gm->acc != NULL) free(gm->acc);
if (gm->desc != NULL) free(gm->desc);
if ((status = esl_strdup(hmm->name, -1, &(gm->name))) != eslOK) goto ERROR;
if ((status = esl_strdup(hmm->acc, -1, &(gm->acc))) != eslOK) goto ERROR;
if ((status = esl_strdup(hmm->desc, -1, &(gm->desc))) != eslOK) goto ERROR;
if (hmm->flags & p7H_RF) strcpy(gm->rf, hmm->rf);
if (hmm->flags & p7H_MMASK) strcpy(gm->mm, hmm->mm);
if (hmm->flags & p7H_CONS) strcpy(gm->consensus, hmm->consensus); /* must be present, actually, so the flag test is just for symmetry w/ other optional HMM fields */
if (hmm->flags & p7H_CS) strcpy(gm->cs, hmm->cs);
for (z = 0; z < p7_NEVPARAM; z++) gm->evparam[z] = hmm->evparam[z];
for (z = 0; z < p7_NCUTOFFS; z++) gm->cutoff[z] = hmm->cutoff[z];
for (z = 0; z < p7_MAXABET; z++) gm->compo[z] = hmm->compo[z];
/* Entry scores. */
if (p7_profile_IsLocal(gm))
{
/* Local mode entry: occ[k] /( \sum_i occ[i] * (M-i+1))
* (Reduces to uniform 2/(M(M+1)) for occupancies of 1.0) */
Z = 0.;
ESL_ALLOC(occ, sizeof(float) * (hmm->M+1));
if ((status = p7_hmm_CalculateOccupancy(hmm, occ, NULL)) != eslOK) goto ERROR;
for (k = 1; k <= hmm->M; k++)
Z += occ[k] * (float) (hmm->M-k+1);
for (k = 1; k <= hmm->M; k++)
p7P_TSC(gm, k-1, p7P_BM) = log(occ[k] / Z); /* note off-by-one: entry at Mk stored as [k-1][BM] */
free(occ);
}
else /* glocal modes: left wing retraction; must be in log space for precision */
{
Z = log(hmm->t[0][p7H_MD]);
p7P_TSC(gm, 0, p7P_BM) = log(1.0 - hmm->t[0][p7H_MD]);
for (k = 1; k < hmm->M; k++)
{
p7P_TSC(gm, k, p7P_BM) = Z + log(hmm->t[k][p7H_DM]);
Z += log(hmm->t[k][p7H_DD]);
}
}
/* E state loop/move probabilities: nonzero for MOVE allows loops/multihits
* N,C,J transitions are set later by length config
*/
if (p7_profile_IsMultihit(gm)) {
gm->xsc[p7P_E][p7P_MOVE] = -eslCONST_LOG2;
gm->xsc[p7P_E][p7P_LOOP] = -eslCONST_LOG2;
gm->nj = 1.0f;
} else {
gm->xsc[p7P_E][p7P_MOVE] = 0.0f;
gm->xsc[p7P_E][p7P_LOOP] = -eslINFINITY;
gm->nj = 0.0f;
}
/* Transition scores. */
for (k = 1; k < gm->M; k++) {
tp = gm->tsc + k * p7P_NTRANS;
tp[p7P_MM] = log(hmm->t[k][p7H_MM]);
tp[p7P_MI] = log(hmm->t[k][p7H_MI]);
tp[p7P_MD] = log(hmm->t[k][p7H_MD]);
tp[p7P_IM] = log(hmm->t[k][p7H_IM]);
tp[p7P_II] = log(hmm->t[k][p7H_II]);
tp[p7P_DM] = log(hmm->t[k][p7H_DM]);
tp[p7P_DD] = log(hmm->t[k][p7H_DD]);
}
/* Match emission scores. */
sc[hmm->abc->K] = -eslINFINITY; /* gap character */
sc[hmm->abc->Kp-2] = -eslINFINITY; /* nonresidue character */
sc[hmm->abc->Kp-1] = -eslINFINITY; /* missing data character */
for (k = 1; k <= hmm->M; k++) {
for (x = 0; x < hmm->abc->K; x++)
sc[x] = log((double)hmm->mat[k][x] / bg->f[x]);
esl_abc_FExpectScVec(hmm->abc, sc, bg->f);
for (x = 0; x < hmm->abc->Kp; x++) {
rp = gm->rsc[x] + k * p7P_NR;
rp[p7P_MSC] = sc[x];
}
}
/* Insert emission scores */
/* SRE, Fri Dec 5 08:41:08 2008: We currently hardwire insert scores
* to 0, i.e. corresponding to the insertion emission probabilities
* being equal to the background probabilities. Benchmarking shows
* that setting inserts to informative emission distributions causes
* more problems than it's worth: polar biased composition hits
* driven by stretches of "insertion" occur, and are difficult to
* correct for.
*/
for (x = 0; x < gm->abc->Kp; x++)
{
for (k = 1; k < hmm->M; k++) p7P_ISC(gm, k, x) = 0.0f;
p7P_ISC(gm, hmm->M, x) = -eslINFINITY; /* init I_M to impossible. */
}
for (k = 1; k <= hmm->M; k++) p7P_ISC(gm, k, gm->abc->K) = -eslINFINITY; /* gap symbol */
for (k = 1; k <= hmm->M; k++) p7P_ISC(gm, k, gm->abc->Kp-2) = -eslINFINITY; /* nonresidue symbol */
for (k = 1; k <= hmm->M; k++) p7P_ISC(gm, k, gm->abc->Kp-1) = -eslINFINITY; /* missing data symbol */
#if 0
/* original (informative) insert setting: relies on sc[K, Kp-1] initialization to -inf above */
for (k = 1; k < hmm->M; k++) {
for (x = 0; x < hmm->abc->K; x++)
sc[x] = log(hmm->ins[k][x] / bg->f[x]);
esl_abc_FExpectScVec(hmm->abc, sc, bg->f);
for (x = 0; x < hmm->abc->Kp; x++) {
rp = gm->rsc[x] + k*p7P_NR;
rp[p7P_ISC] = sc[x];
}
}
for (x = 0; x < hmm->abc->Kp; x++)
p7P_ISC(gm, hmm->M, x) = -eslINFINITY; /* init I_M to impossible. */
#endif
/* Remaining specials, [NCJ][MOVE | LOOP] are set by ReconfigLength()
*/
gm->L = 0; /* force ReconfigLength to reconfig */
if ((status = p7_ReconfigLength(gm, L)) != eslOK) goto ERROR;
return eslOK;
ERROR:
if (occ != NULL) free(occ);
return status;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = esl_getopts_CreateDefaultApp(options, 2, argc, argv, banner, usage);
char *hmmfile = esl_opt_GetArg(go, 1);
char *seqfile = esl_opt_GetArg(go, 2);
ESL_ALPHABET *abc = NULL;
P7_HMMFILE *hfp = NULL;
P7_HMM *hmm = NULL;
P7_BG *bg = NULL;
P7_PROFILE *gm = NULL;
P7_OPROFILE *om = NULL;
P7_GMX *gx = NULL;
P7_OMX *fwd = NULL;
P7_OMX *bck = NULL;
ESL_SQ *sq = NULL;
ESL_SQFILE *sqfp = NULL;
int format = eslSQFILE_UNKNOWN;
float fraw, braw, nullsc, fsc;
float gfraw, gbraw, gfsc;
double P, gP;
int status;
/* Read in one HMM */
if (p7_hmmfile_Open(hmmfile, NULL, &hfp) != eslOK) p7_Fail("Failed to open HMM file %s", hmmfile);
if (p7_hmmfile_Read(hfp, &abc, &hmm) != eslOK) p7_Fail("Failed to read HMM");
/* Open sequence file for reading */
sq = esl_sq_CreateDigital(abc);
status = esl_sqfile_Open(seqfile, format, NULL, &sqfp);
if (status == eslENOTFOUND) p7_Fail("No such file.");
else if (status == eslEFORMAT) p7_Fail("Format unrecognized.");
else if (status == eslEINVAL) p7_Fail("Can't autodetect stdin or .gz.");
else if (status != eslOK) p7_Fail("Open failed, code %d.", status);
/* create default null model, then create and optimize profile */
bg = p7_bg_Create(abc);
p7_bg_SetLength(bg, sq->n);
gm = p7_profile_Create(hmm->M, abc);
p7_ProfileConfig(hmm, bg, gm, sq->n, p7_UNILOCAL);
om = p7_oprofile_Create(gm->M, abc);
p7_oprofile_Convert(gm, om);
/* p7_oprofile_Dump(stdout, om); */
/* allocate DP matrices for O(M+L) parsers */
fwd = p7_omx_Create(gm->M, 0, sq->n);
bck = p7_omx_Create(gm->M, 0, sq->n);
gx = p7_gmx_Create(gm->M, sq->n);
/* allocate DP matrices for O(ML) fills */
/* fwd = p7_omx_Create(gm->M, sq->n, sq->n); */
/* bck = p7_omx_Create(gm->M, sq->n, sq->n); */
/* p7_omx_SetDumpMode(stdout, fwd, TRUE); */ /* makes the fast DP algorithms dump their matrices */
/* p7_omx_SetDumpMode(stdout, bck, TRUE); */
while ((status = esl_sqio_Read(sqfp, sq)) == eslOK)
{
p7_oprofile_ReconfigLength(om, sq->n);
p7_ReconfigLength(gm, sq->n);
p7_bg_SetLength(bg, sq->n);
p7_omx_GrowTo(fwd, om->M, 0, sq->n);
p7_omx_GrowTo(bck, om->M, 0, sq->n);
p7_gmx_GrowTo(gx, gm->M, sq->n);
p7_bg_NullOne (bg, sq->dsq, sq->n, &nullsc);
p7_ForwardParser (sq->dsq, sq->n, om, fwd, &fraw);
p7_BackwardParser(sq->dsq, sq->n, om, fwd, bck, &braw);
/* p7_Forward (sq->dsq, sq->n, om, fwd, &fsc); printf("forward: %.2f nats\n", fsc); */
/* p7_Backward(sq->dsq, sq->n, om, fwd, bck, &bsc); printf("backward: %.2f nats\n", bsc); */
/* Comparison to other F/B implementations */
p7_GForward (sq->dsq, sq->n, gm, gx, &gfraw);
p7_GBackward (sq->dsq, sq->n, gm, gx, &gbraw);
/* p7_gmx_Dump(stdout, gx); */
fsc = (fraw-nullsc) / eslCONST_LOG2;
gfsc = (gfraw-nullsc) / eslCONST_LOG2;
P = esl_exp_surv(fsc, om->evparam[p7_FTAU], om->evparam[p7_FLAMBDA]);
gP = esl_exp_surv(gfsc, gm->evparam[p7_FTAU], gm->evparam[p7_FLAMBDA]);
if (esl_opt_GetBoolean(go, "-1"))
{
printf("%-30s\t%-20s\t%9.2g\t%6.1f\t%9.2g\t%6.1f\n", sq->name, hmm->name, P, fsc, gP, gfsc);
}
else if (esl_opt_GetBoolean(go, "-P"))
{ /* output suitable for direct use in profmark benchmark postprocessors: */
printf("%g\t%.2f\t%s\t%s\n", P, fsc, sq->name, hmm->name);
}
else
{
printf("target sequence: %s\n", sq->name);
printf("fwd filter raw score: %.2f nats\n", fraw);
printf("bck filter raw score: %.2f nats\n", braw);
printf("null score: %.2f nats\n", nullsc);
printf("per-seq score: %.2f bits\n", fsc);
printf("P-value: %g\n", P);
printf("GForward raw score: %.2f nats\n", gfraw);
printf("GBackward raw score: %.2f nats\n", gbraw);
printf("GForward seq score: %.2f bits\n", gfsc);
printf("GForward P-value: %g\n", gP);
}
esl_sq_Reuse(sq);
}
/* cleanup */
esl_sq_Destroy(sq);
esl_sqfile_Close(sqfp);
p7_omx_Destroy(bck);
p7_omx_Destroy(fwd);
p7_gmx_Destroy(gx);
p7_oprofile_Destroy(om);
p7_profile_Destroy(gm);
p7_bg_Destroy(bg);
p7_hmm_Destroy(hmm);
p7_hmmfile_Close(hfp);
esl_alphabet_Destroy(abc);
esl_getopts_Destroy(go);
return 0;
}
void run_hmmer_pipeline(const char* seq) {
int index, i, status;
ESL_SQ* sq = esl_sq_CreateFrom(NULL, seq, NULL, NULL, NULL);
P7_OPROFILE *om = NULL;
P7_PROFILE *gm = NULL;
float usc, vfsc, fwdsc; /* filter scores */
float filtersc; /* HMM null filter score */
float nullsc; /* null model score */
float seqbias;
float seq_score; /* the corrected per-seq bit score */
double P;
WRAPPER_RESULT* result;
num_results = 0;
if(sq->n == 0) {
esl_sq_Destroy(sq);
return;
}
esl_sq_Digitize(abc, sq);
int n = 0;
float oasc;
for(index = 0;index < num_models;index++) {
om = models[index];
p7_omx_Reuse(oxf);
p7_omx_Reuse(oxb);
p7_omx_GrowTo(oxf, om->M, sq->n, sq->n);
p7_omx_GrowTo(oxb, om->M, sq->n, sq->n);
p7_oprofile_ReconfigLength(om, sq->n);
p7_bg_SetFilter(bg, om->M, om->compo);
p7_bg_SetLength(bg, sq->n);
//Calibrate null model
p7_bg_NullOne(bg, sq->dsq, sq->n, &nullsc);
//MSV Filter
p7_MSVFilter(sq->dsq, sq->n, om, oxf, &usc);
seq_score = (usc - nullsc) / eslCONST_LOG2;
P = esl_gumbel_surv(seq_score, om->evparam[p7_MMU], om->evparam[p7_MLAMBDA]);
if (P > f1) continue;
//Bias filter (model compo)
p7_bg_FilterScore(bg, sq->dsq, sq->n, &filtersc);
seq_score = (usc - filtersc) / eslCONST_LOG2;
P = esl_gumbel_surv(seq_score, om->evparam[p7_MMU], om->evparam[p7_MLAMBDA]);
if (P > f1) continue;
//Viterbi filter (Only do if P value from Bias is high)
if(P > f2) {
p7_ViterbiFilter(sq->dsq, sq->n, om, oxf, &vfsc);
seq_score = (vfsc - filtersc) / eslCONST_LOG2;
P = esl_gumbel_surv(seq_score, om->evparam[p7_VMU], om->evparam[p7_VLAMBDA]);
if (P > f2) continue;
}
//Get the real probability (forward)
p7_Forward(sq->dsq, sq->n, om, oxf, &fwdsc);
seq_score = (fwdsc - filtersc) / eslCONST_LOG2;
P = esl_exp_surv(seq_score, om->evparam[p7_FTAU], om->evparam[p7_FLAMBDA]);
if(hmmer_error) {
fprintf(stderr, "HMM: %s, seq: %s", om->name, seq);
hmmer_error = 0;
continue;
}
if (P > f3) continue;
//Real hit, go in to posterior decoding and alignment
p7_omx_Reuse(oxb);
p7_trace_Reuse(tr);
p7_Backward(sq->dsq, sq->n, om, oxf, oxb, NULL);
status = p7_Decoding(om, oxf, oxb, oxb);
if(status == eslOK) {
//And then trace the result
p7_OptimalAccuracy(om, oxb, oxf, &oasc);
p7_OATrace(om, oxb, oxf, tr);
} else if(status == eslERANGE) {
fprintf(stderr, "Decoding overflow on model %s\n", om->name);
gm = gmodels[index];
if(gxf == NULL) {
gxf = p7_gmx_Create(gm->M, sq->n);
gxb = p7_gmx_Create(gm->M, sq->n);
} else {
p7_gmx_GrowTo(gxf, gm->M, sq->n);
p7_gmx_GrowTo(gxb, gm->M, sq->n);
}
p7_ReconfigLength(gm, sq->n);
p7_GForward (sq->dsq, sq->n, gm, gxf, &fwdsc);
p7_GBackward(sq->dsq, sq->n, gm, gxb, NULL);
p7_GDecoding(gm, gxf, gxb, gxb);
p7_GOptimalAccuracy(gm, gxb, gxf, &oasc);
p7_GOATrace (gm, gxb, gxf, tr);
p7_gmx_Reuse(gxf);
p7_gmx_Reuse(gxb);
}
if(hmmer_error) {
fprintf(stderr, "HMM: %s, seq: %s", om->name, seq);
hmmer_error = 0;
continue;
}
result = wrapper_results[num_results];
reuse_result(result, tr->N + om->M, om->name); //We're way overallocating here, but it's hard to know at this point how much space we'll need for the alignment (plus leading and trailing gaps)
trace_into(tr, result, sq, abc, om->M);
result->bits = seq_score;
num_results++;
}
esl_sq_Destroy(sq);
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = esl_getopts_CreateDefaultApp(options, 2, argc, argv, banner, usage);
char *hmmfile = esl_opt_GetArg(go, 1);
char *seqfile = esl_opt_GetArg(go, 2);
float nu = esl_opt_GetReal(go, "--nu");
ESL_ALPHABET *abc = NULL;
P7_HMMFILE *hfp = NULL;
P7_HMM *hmm = NULL;
P7_BG *bg = NULL;
P7_PROFILE *gm = NULL;
P7_GMX *fwd = NULL;
ESL_SQ *sq = NULL;
ESL_SQFILE *sqfp = NULL;
P7_TRACE *tr = NULL;
int format = eslSQFILE_UNKNOWN;
float sc, nullsc, seqscore, P;
int status;
/* Read in one HMM */
if (p7_hmmfile_Open(hmmfile, NULL, &hfp) != eslOK) p7_Fail("Failed to open HMM file %s", hmmfile);
if (p7_hmmfile_Read(hfp, &abc, &hmm) != eslOK) p7_Fail("Failed to read HMM");
p7_hmmfile_Close(hfp);
/* Open sequence file */
sq = esl_sq_CreateDigital(abc);
status = esl_sqfile_Open(seqfile, format, NULL, &sqfp);
if (status == eslENOTFOUND) p7_Fail("No such file.");
else if (status == eslEFORMAT) p7_Fail("Format unrecognized.");
else if (status == eslEINVAL) p7_Fail("Can't autodetect stdin or .gz.");
else if (status != eslOK) p7_Fail("Open failed, code %d.", status);
/* Configure a profile from the HMM */
bg = p7_bg_Create(abc);
gm = p7_profile_Create(hmm->M, abc);
p7_ProfileConfig(hmm, bg, gm, sq->n, p7_LOCAL);
/* Allocate matrix */
fwd = p7_gmx_Create(gm->M, sq->n);
while ((status = esl_sqio_Read(sqfp, sq)) == eslOK)
{
p7_ReconfigLength(gm, sq->n);
p7_bg_SetLength(bg, sq->n);
p7_gmx_GrowTo(fwd, gm->M, sq->n);
/* Run MSV */
p7_GMSV(sq->dsq, sq->n, gm, fwd, nu, &sc);
/* Calculate bit score and P-value using standard null1 model*/
p7_bg_NullOne (bg, sq->dsq, sq->n, &nullsc);
seqscore = (sc - nullsc) / eslCONST_LOG2;
P = esl_gumbel_surv(seqscore, gm->evparam[p7_MMU], gm->evparam[p7_MLAMBDA]);
/* output suitable for direct use in profmark benchmark postprocessors:
* <Pvalue> <bitscore> <target name> <query name>
*/
printf("%g\t%.2f\t%s\t%s\n", P, seqscore, sq->name, hmm->name);
esl_sq_Reuse(sq);
}
if (status == eslEFORMAT) esl_fatal("Parse failed (sequence file %s):\n%s\n", sqfp->filename, esl_sqfile_GetErrorBuf(sqfp));
else if (status != eslEOF) esl_fatal("Unexpected error %d reading sequence file %s", status, sqfp->filename);
/* Cleanup */
esl_sqfile_Close(sqfp);
esl_sq_Destroy(sq);
p7_trace_Destroy(tr);
p7_gmx_Destroy(fwd);
p7_profile_Destroy(gm);
p7_bg_Destroy(bg);
p7_hmm_Destroy(hmm);
esl_alphabet_Destroy(abc);
esl_getopts_Destroy(go);
return 0;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = p7_CreateDefaultApp(options, 2, argc, argv, banner, usage);
char *hmmfile = esl_opt_GetArg(go, 1);
char *seqfile = esl_opt_GetArg(go, 2);
ESL_ALPHABET *abc = NULL;
P7_HMMFILE *hfp = NULL;
P7_HMM *hmm = NULL;
P7_BG *bg = NULL;
P7_PROFILE *gm = NULL;
P7_GMX *fwd = NULL;
P7_GMX *bck = NULL;
ESL_SQ *sq = NULL;
ESL_SQFILE *sqfp = NULL;
int format = eslSQFILE_UNKNOWN;
float fsc, bsc;
float nullsc;
int status;
/* Initialize log-sum calculator */
p7_FLogsumInit();
/* Read in one HMM */
if (p7_hmmfile_OpenE(hmmfile, NULL, &hfp, NULL) != eslOK) p7_Fail("Failed to open HMM file %s", hmmfile);
if (p7_hmmfile_Read(hfp, &abc, &hmm) != eslOK) p7_Fail("Failed to read HMM");
p7_hmmfile_Close(hfp);
/* Read in one sequence */
sq = esl_sq_CreateDigital(abc);
status = esl_sqfile_Open(seqfile, format, NULL, &sqfp);
if (status == eslENOTFOUND) p7_Fail("No such file.");
else if (status == eslEFORMAT) p7_Fail("Format unrecognized.");
else if (status == eslEINVAL) p7_Fail("Can't autodetect stdin or .gz.");
else if (status != eslOK) p7_Fail("Open failed, code %d.", status);
/* Configure a profile from the HMM */
bg = p7_bg_Create(abc);
gm = p7_profile_Create(hmm->M, abc);
/* Now reconfig the models however we were asked to */
if (esl_opt_GetBoolean(go, "--fs")) p7_ProfileConfig(hmm, bg, gm, sq->n, p7_LOCAL);
else if (esl_opt_GetBoolean(go, "--sw")) p7_ProfileConfig(hmm, bg, gm, sq->n, p7_UNILOCAL);
else if (esl_opt_GetBoolean(go, "--ls")) p7_ProfileConfig(hmm, bg, gm, sq->n, p7_GLOCAL);
else if (esl_opt_GetBoolean(go, "--s")) p7_ProfileConfig(hmm, bg, gm, sq->n, p7_UNIGLOCAL);
/* Allocate matrices */
fwd = p7_gmx_Create(gm->M, sq->n);
bck = p7_gmx_Create(gm->M, sq->n);
printf("%-30s %-10s %-10s %-10s %-10s\n", "# seq name", "fwd (raw)", "bck (raw) ", "fwd (bits)", "bck (bits)");
printf("%-30s %10s %10s %10s %10s\n", "#--------------", "----------", "----------", "----------", "----------");
while ( (status = esl_sqio_Read(sqfp, sq)) != eslEOF)
{
if (status == eslEFORMAT) p7_Fail("Parse failed (sequence file %s)\n%s\n", sqfp->filename, sqfp->get_error(sqfp));
else if (status != eslOK) p7_Fail("Unexpected error %d reading sequence file %s", status, sqfp->filename);
/* Resize the DP matrices if necessary */
p7_gmx_GrowTo(fwd, gm->M, sq->n);
p7_gmx_GrowTo(bck, gm->M, sq->n);
/* Set the profile and null model's target length models */
p7_bg_SetLength(bg, sq->n);
p7_ReconfigLength(gm, sq->n);
/* Run Forward, Backward */
p7_GForward (sq->dsq, sq->n, gm, fwd, &fsc);
p7_GBackward(sq->dsq, sq->n, gm, bck, &bsc);
p7_gmx_Dump(stdout, fwd, p7_DEFAULT);
/* Those scores are partial log-odds likelihoods in nats.
* Subtract off the rest of the null model, convert to bits.
*/
p7_bg_NullOne(bg, sq->dsq, sq->n, &nullsc);
printf("%-30s %10.4f %10.4f %10.4f %10.4f\n",
sq->name,
fsc, bsc,
(fsc - nullsc) / eslCONST_LOG2, (bsc - nullsc) / eslCONST_LOG2);
p7_gmx_Reuse(fwd);
p7_gmx_Reuse(bck);
esl_sq_Reuse(sq);
}
/* Cleanup */
esl_sqfile_Close(sqfp);
esl_sq_Destroy(sq);
p7_gmx_Destroy(fwd);
p7_gmx_Destroy(bck);
p7_profile_Destroy(gm);
p7_bg_Destroy(bg);
p7_hmm_Destroy(hmm);
esl_alphabet_Destroy(abc);
esl_getopts_Destroy(go);
return 0;
}
