int
main(int argc, char **argv)
{
ESL_GETOPTS *go = esl_getopts_CreateDefaultApp(options, 0, argc, argv, banner, usage);
ESL_RANDOMNESS *r = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s"));
ESL_ALPHABET *abc = NULL;
P7_HMM *hmm = NULL;
P7_PROFILE *gm = NULL;
P7_BG *bg = NULL;
int M = 100;
int L = 200;
int nseq = 20;
char errbuf[eslERRBUFSIZE];
if ((abc = esl_alphabet_Create(eslAMINO)) == NULL) esl_fatal("failed to create alphabet");
if (p7_hmm_Sample(r, M, abc, &hmm) != eslOK) esl_fatal("failed to sample an HMM");
if ((bg = p7_bg_Create(abc)) == NULL) esl_fatal("failed to create null model");
if ((gm = p7_profile_Create(hmm->M, abc)) == NULL) esl_fatal("failed to create profile");
if (p7_ProfileConfig(hmm, bg, gm, L, p7_LOCAL) != eslOK) esl_fatal("failed to config profile");
if (p7_hmm_Validate (hmm, errbuf, 0.0001) != eslOK) esl_fatal("whoops, HMM is bad!: %s", errbuf);
if (p7_profile_Validate(gm, errbuf, 0.0001) != eslOK) esl_fatal("whoops, profile is bad!: %s", errbuf);
utest_basic (go);
utest_viterbi(go, r, abc, bg, gm, nseq, L);
p7_profile_Destroy(gm);
p7_bg_Destroy(bg);
p7_hmm_Destroy(hmm);
esl_alphabet_Destroy(abc);
esl_randomness_Destroy(r);
esl_getopts_Destroy(go);
return 0;
}
/* Function: p7_oprofile_Sample()
* Synopsis: Sample a random profile.
* Incept: MSF Tue Nov 3, 2009 [Janelia]
*
* Purpose: Sample a random profile of <M> nodes for alphabet <abc>,
* using <r> as the source of random numbers. Parameterize
* it for generation of target sequences of mean length
* <L>. Calculate its log-odds scores using background
* model <bg>.
*
* Args: r - random number generator
* abc - emission alphabet
* bg - background frequency model
* M - size of sampled profile, in nodes
* L - configured target seq mean length
* opt_hmm - optRETURN: sampled HMM
* opt_gm - optRETURN: sampled normal profile
* opt_om - RETURN: optimized profile
*
* Returns: <eslOK> on success.
*
* Throws: (no abnormal error conditions)
*/
int
p7_oprofile_Sample(ESL_RANDOMNESS *r, const ESL_ALPHABET *abc, const P7_BG *bg, int M, int L,
P7_HMM **opt_hmm, P7_PROFILE **opt_gm, P7_OPROFILE **ret_om)
{
P7_HMM *hmm = NULL;
P7_PROFILE *gm = NULL;
P7_OPROFILE *om = NULL;
int status;
if ((gm = p7_profile_Create (M, abc)) == NULL) { status = eslEMEM; goto ERROR; }
if ((om = p7_oprofile_Create(M, abc)) == NULL) { status = eslEMEM; goto ERROR; }
if ((status = p7_hmm_Sample(r, M, abc, &hmm)) != eslOK) goto ERROR;
if ((status = p7_ProfileConfig(hmm, bg, gm, L, p7_LOCAL)) != eslOK) goto ERROR;
if ((status = p7_oprofile_Convert(gm, om)) != eslOK) goto ERROR;
if ((status = p7_oprofile_ReconfigLength(om, L)) != eslOK) goto ERROR;
if (opt_hmm != NULL) *opt_hmm = hmm; else p7_hmm_Destroy(hmm);
if (opt_gm != NULL) *opt_gm = gm; else p7_profile_Destroy(gm);
*ret_om = om;
return eslOK;
ERROR:
if (opt_hmm != NULL) *opt_hmm = NULL;
if (opt_gm != NULL) *opt_gm = NULL;
*ret_om = NULL;
return status;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = p7_CreateDefaultApp(options, 1, argc, argv, banner, usage);
char *hmmfile = esl_opt_GetArg(go, 1);
ESL_STOPWATCH *w = esl_stopwatch_Create();
ESL_RANDOMNESS *r = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s"));
ESL_ALPHABET *abc = NULL;
P7_HMMFILE *hfp = NULL;
P7_HMM *hmm = NULL;
P7_BG *bg = NULL;
P7_PROFILE *gm = NULL;
P7_GMX *gx1 = NULL;
P7_GMX *gx2 = NULL;
int L = esl_opt_GetInteger(go, "-L");
int N = esl_opt_GetInteger(go, "-N");
ESL_DSQ *dsq = malloc(sizeof(ESL_DSQ) * (L+2));
float null2[p7_MAXCODE];
int i;
float fsc, bsc;
double Mcs;
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");
bg = p7_bg_Create(abc);
p7_bg_SetLength(bg, L);
gm = p7_profile_Create(hmm->M, abc);
p7_ProfileConfig(hmm, bg, gm, L, p7_LOCAL);
gx1 = p7_gmx_Create(gm->M, L);
gx2 = p7_gmx_Create(gm->M, L);
esl_rsq_xfIID(r, bg->f, abc->K, L, dsq);
p7_GForward (dsq, L, gm, gx1, &fsc);
p7_GBackward(dsq, L, gm, gx2, &bsc);
p7_GDecoding(gm, gx1, gx2, gx2);
esl_stopwatch_Start(w);
for (i = 0; i < N; i++)
p7_GNull2_ByExpectation(gm, gx2, null2);
esl_stopwatch_Stop(w);
Mcs = (double) N * (double) L * (double) gm->M * 1e-6 / w->user;
esl_stopwatch_Display(stdout, w, "# CPU time: ");
printf("# M = %d\n", gm->M);
printf("# %.1f Mc/s\n", Mcs);
free(dsq);
p7_gmx_Destroy(gx1);
p7_gmx_Destroy(gx2);
p7_profile_Destroy(gm);
p7_bg_Destroy(bg);
p7_hmm_Destroy(hmm);
p7_hmmfile_Close(hfp);
esl_alphabet_Destroy(abc);
esl_stopwatch_Destroy(w);
esl_randomness_Destroy(r);
esl_getopts_Destroy(go);
return 0;
}
int
main(int argc, char **argv)
{
char *msg = "p7_gmx unit test driver failed";
ESL_GETOPTS *go = p7_CreateDefaultApp(options, 0, argc, argv, banner, usage);
ESL_RANDOMNESS *r = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s"));
ESL_ALPHABET *abc = esl_alphabet_Create(eslAMINO);
P7_BG *bg = p7_bg_Create(abc);
P7_HMM *hmm = NULL;
P7_PROFILE *gm = NULL;
int M = esl_opt_GetInteger(go, "-M");
int L = esl_opt_GetInteger(go, "-L");
float tol = esl_opt_GetReal (go, "-t");
p7_FLogsumInit();
if (p7_hmm_Sample(r, M, abc, &hmm) != eslOK) esl_fatal(msg);
if ((gm = p7_profile_Create(hmm->M, abc)) == NULL) esl_fatal(msg);
if (p7_bg_SetLength(bg, L) != eslOK) esl_fatal(msg);
if (p7_ProfileConfig(hmm, bg, gm, L, p7_UNILOCAL) != eslOK) esl_fatal(msg);
utest_GrowTo();
utest_Compare(r, gm, bg, L, tol);
esl_getopts_Destroy(go);
esl_randomness_Destroy(r);
esl_alphabet_Destroy(abc);
p7_bg_Destroy(bg);
p7_hmm_Destroy(hmm);
p7_profile_Destroy(gm);
return eslOK;
}
/* 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;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = p7_CreateDefaultApp(options, 1, argc, argv, banner, usage);
ESL_RANDOMNESS *rng = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s"));
char *hmmfile = esl_opt_GetArg(go, 1);
int L = esl_opt_GetInteger(go, "-L");
int N = esl_opt_GetInteger(go, "-N");
ESL_ALPHABET *abc = NULL;
P7_HMMFILE *hfp = NULL;
P7_HMM *hmm = NULL;
P7_BG *bg = NULL;
P7_PROFILE *gm = NULL;
P7_TRACE *tr = p7_trace_Create();
ESL_SQ *sq = NULL;
char errbuf[eslERRBUFSIZE];
int i;
int status;
status = p7_hmmfile_OpenE(hmmfile, NULL, &hfp, errbuf);
if (status == eslENOTFOUND) p7_Fail("File existence/permissions problem in trying to open HMM file %s.\n%s\n", hmmfile, errbuf);
else if (status == eslEFORMAT) p7_Fail("File format problem in trying to open HMM file %s.\n%s\n", hmmfile, errbuf);
else if (status != eslOK) p7_Fail("Unexpected error %d in opening HMM file %s.\n%s\n", status, hmmfile, errbuf);
status = p7_hmmfile_Read(hfp, &abc, &hmm);
if (status == eslEFORMAT) p7_Fail("Bad file format in HMM file %s:\n%s\n", hfp->fname, hfp->errbuf);
else if (status == eslEINCOMPAT) p7_Fail("HMM in %s is not in the expected %s alphabet\n", hfp->fname, esl_abc_DecodeType(abc->type));
else if (status == eslEOF) p7_Fail("Empty HMM file %s? No HMM data found.\n", hfp->fname);
else if (status != eslOK) p7_Fail("Unexpected error in reading HMMs from %s\n", hfp->fname);
p7_hmmfile_Close(hfp);
bg = p7_bg_Create(abc); p7_bg_SetLength(bg, L);
gm = p7_profile_Create(hmm->M, abc); p7_ProfileConfig(hmm, bg, gm, L, p7_LOCAL);
sq = esl_sq_CreateDigital(abc);
for (i = 0; i < N; i++)
{
p7_ProfileEmit(rng, hmm, gm, bg, sq, tr);
esl_sq_FormatName(sq, "%s-sample%d", hmm->name, i);
esl_sqio_Write(stdout, sq, eslSQFILE_FASTA, FALSE);
if (p7_trace_Validate(tr, abc, sq->dsq, errbuf) != eslOK) esl_fatal(errbuf);
esl_sq_Reuse(sq);
p7_trace_Reuse(tr);
}
esl_sq_Destroy(sq);
p7_trace_Destroy(tr);
p7_profile_Destroy(gm);
p7_bg_Destroy(bg);
p7_hmm_Destroy(hmm);
esl_alphabet_Destroy(abc);
esl_randomness_Destroy(rng);
esl_getopts_Destroy(go);
return 0;
}
static void
utest_oprofileSendRecv(int my_rank, int nproc)
{
ESL_RANDOMNESS *r = esl_randomness_CreateFast(42);
ESL_ALPHABET *abc = esl_alphabet_Create(eslAMINO);
P7_HMM *hmm = NULL;
P7_BG *bg = NULL;
P7_PROFILE *gm = NULL;
P7_OPROFILE *om = NULL;
P7_OPROFILE *om2 = NULL;
int M = 200;
int L = 400;
char *wbuf = NULL;
int wn = 0;
int i;
char errbuf[eslERRBUFSIZE];
p7_hmm_Sample(r, M, abc, &hmm); /* master and worker's sampled profiles are identical */
bg = p7_bg_Create(abc);
gm = p7_profile_Create(hmm->M, abc);
om = p7_oprofile_Create(hmm->M, abc);
p7_ProfileConfig(hmm, bg, gm, L, p7_LOCAL);
p7_oprofile_Convert(gm, om);
p7_bg_SetLength (bg, L);
if (my_rank == 0)
{
for (i = 1; i < nproc; i++)
{
ESL_DPRINTF1(("Master: receiving test profile\n"));
p7_oprofile_MPIRecv(MPI_ANY_SOURCE, 0, MPI_COMM_WORLD, &wbuf, &wn, &abc, &om2);
ESL_DPRINTF1(("Master: test profile received\n"));
if (p7_oprofile_Compare(om, om2, 0.001, errbuf) != eslOK)
p7_Die("Received profile not identical to what was sent\n%s", errbuf);
p7_oprofile_Destroy(om2);
}
}
else
{
ESL_DPRINTF1(("Worker %d: sending test profile\n", my_rank));
p7_oprofile_MPISend(om, 0, 0, MPI_COMM_WORLD, &wbuf, &wn);
ESL_DPRINTF1(("Worker %d: test profile sent\n", my_rank));
}
free(wbuf);
p7_profile_Destroy(gm);
p7_oprofile_Destroy(om);
p7_bg_Destroy(bg);
p7_hmm_Destroy(hmm);
esl_alphabet_Destroy(abc);
esl_randomness_Destroy(r);
return;
}
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;
}
/* The Config test simply makes sure a random profile passes
* a Validate() check.
*/
static void
utest_Config(P7_HMM *hmm, P7_BG *bg)
{
char *msg = "modelconfig.c::p7_ProfileConfig() unit test failed";
P7_PROFILE *gm = NULL;
if ((gm = p7_profile_Create(hmm->M, hmm->abc)) == NULL) esl_fatal(msg);
if (p7_ProfileConfig(hmm, bg, gm, 350, p7_LOCAL) != eslOK) esl_fatal(msg);
if (p7_profile_Validate(gm, NULL, 0.0001) != eslOK) esl_fatal(msg);
p7_profile_Destroy(gm);
return;
}
static void
emit_sequences(ESL_GETOPTS *go, FILE *ofp, int outfmt, ESL_RANDOMNESS *r, P7_HMM *hmm)
{
ESL_SQ *sq = NULL;
P7_TRACE *tr = NULL;
P7_BG *bg = NULL;
P7_PROFILE *gm = NULL;
int do_profile = esl_opt_GetBoolean(go, "-p");
int N = esl_opt_GetInteger(go, "-N");
int L = esl_opt_GetInteger(go, "-L");
int mode = p7_LOCAL;
int nseq;
int status;
if (esl_opt_GetBoolean(go, "--local")) mode = p7_LOCAL;
else if (esl_opt_GetBoolean(go, "--unilocal")) mode = p7_UNILOCAL;
else if (esl_opt_GetBoolean(go, "--glocal")) mode = p7_GLOCAL;
else if (esl_opt_GetBoolean(go, "--uniglocal")) mode = p7_UNIGLOCAL;
if ((sq = esl_sq_CreateDigital(hmm->abc)) == NULL) esl_fatal("failed to allocate sequence");
if ((tr = p7_trace_Create()) == NULL) esl_fatal("failed to allocate trace");
if ((bg = p7_bg_Create(hmm->abc)) == NULL) esl_fatal("failed to create null model");
if ((gm = p7_profile_Create(hmm->M, hmm->abc)) == NULL) esl_fatal("failed to create profile");
if (p7_ProfileConfig(hmm, bg, gm, L, mode) != eslOK) esl_fatal("failed to configure profile");
if (p7_bg_SetLength(bg, L) != eslOK) esl_fatal("failed to reconfig null model length");
if (p7_hmm_Validate (hmm, NULL, 0.0001) != eslOK) esl_fatal("whoops, HMM is bad!");
if (p7_profile_Validate(gm, NULL, 0.0001) != eslOK) esl_fatal("whoops, profile is bad!");
for (nseq = 1; nseq <= N; nseq++)
{
if (do_profile) status = p7_ProfileEmit(r, hmm, gm, bg, sq, tr);
else status = p7_CoreEmit (r, hmm, sq, tr);
if (status) esl_fatal("Failed to emit sequence\n");
status = esl_sq_FormatName(sq, "%s-sample%d", hmm->name, nseq);
if (status) esl_fatal("Failed to set sequence name\n");
status = esl_sqio_Write(ofp, sq, outfmt, FALSE);
if (status != eslOK) esl_fatal("Failed to write sequence\n");
p7_trace_Reuse(tr);
esl_sq_Reuse(sq);
}
esl_sq_Destroy(sq);
p7_trace_Destroy(tr);
p7_bg_Destroy(bg);
p7_profile_Destroy(gm);
return;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = esl_getopts_CreateDefaultApp(options, 0, argc, argv, banner, usage);
ESL_RANDOMNESS *r = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s"));
ESL_ALPHABET *abc = NULL;
P7_HMM *hmm = NULL;
P7_PROFILE *gm = NULL;
P7_OPROFILE *om = NULL;
P7_BG *bg = NULL;
ESL_DSQ *dsq = NULL;
ESL_SQ *sq = NULL;
int M = 6;
int L = 10;
int ntrace = 1000;
if ((abc = esl_alphabet_Create(eslAMINO)) == NULL) esl_fatal("failed to create alphabet");
if (p7_hmm_Sample(r, M, abc, &hmm) != eslOK) esl_fatal("failed to sample an HMM");
if ((bg = p7_bg_Create(abc)) == NULL) esl_fatal("failed to create null model");
if ((gm = p7_profile_Create(hmm->M, abc)) == NULL) esl_fatal("failed to create profile");
if (p7_ProfileConfig(hmm, bg, gm, L, p7_LOCAL) != eslOK) esl_fatal("failed to config profile");
if ((om = p7_oprofile_Create(gm->M, abc)) == NULL) esl_fatal("failed to create optimized profile");
if (p7_oprofile_Convert(gm, om) != eslOK) esl_fatal("failed to convert profile");
/* Test with randomly generated (iid) sequence */
if ((dsq = malloc(sizeof(ESL_DSQ) *(L+2))) == NULL) esl_fatal("malloc failed");
if (esl_rsq_xfIID(r, bg->f, abc->K, L, dsq) != eslOK) esl_fatal("seq generation failed");
utest_stotrace(go, r, abc, gm, om, dsq, L, ntrace);
/* Test with seq sampled from profile */
if ((sq = esl_sq_CreateDigital(abc)) == NULL) esl_fatal("sequence allocation failed");
if (p7_ProfileEmit(r, hmm, gm, bg, sq, NULL) != eslOK) esl_fatal("profile emission failed");
utest_stotrace(go, r, abc, gm, om, sq->dsq, sq->n, ntrace);
esl_sq_Destroy(sq);
free(dsq);
p7_oprofile_Destroy(om);
p7_profile_Destroy(gm);
p7_bg_Destroy(bg);
p7_hmm_Destroy(hmm);
esl_alphabet_Destroy(abc);
esl_randomness_Destroy(r);
esl_getopts_Destroy(go);
return 0;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = p7_CreateDefaultApp(options, 0, argc, argv, banner, usage);
ESL_RANDOMNESS *r = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s"));
ESL_ALPHABET *abc = esl_alphabet_Create(eslAMINO);
P7_HMM *hmm = NULL;
P7_BG *bg = NULL;
P7_PROFILE *gm = NULL;
P7_GMX *fwd = NULL;
P7_GMX *bck = NULL;
ESL_DSQ *dsq = NULL;
int M = esl_opt_GetInteger(go, "-M");
int L = esl_opt_GetInteger(go, "-L");
/* Sample a random HMM */
p7_hmm_Sample(r, M, abc, &hmm);
/* Configure a profile from the sampled HMM */
bg = p7_bg_Create(abc);
p7_bg_SetLength(bg, L);
gm = p7_profile_Create(hmm->M, abc);
p7_ProfileConfig(hmm, bg, gm, L, p7_LOCAL);
/* Other initial allocations */
dsq = malloc(sizeof(ESL_DSQ) * (L+2));
fwd = p7_gmx_Create(gm->M, L);
bck = p7_gmx_Create(gm->M, L);
p7_FLogsumInit();
utest_correct_normalization(r, gm, bg, dsq, L, fwd, bck);
free(dsq);
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_randomness_Destroy(r);
esl_getopts_Destroy(go);
return 0;
}
int
main(int argc, char **argv)
{
char *hmmfile = argv[1];
ESL_ALPHABET *abc = NULL;
P7_HMMFILE *hfp = NULL;
P7_HMM *hmm = NULL;
P7_BG *bg = NULL;
P7_PROFILE *gm = NULL;
P7_OPROFILE *om1 = NULL;
P7_OPROFILE *om2 = NULL;
int status;
char errmsg[512];
status = p7_hmmfile_Open(hmmfile, NULL, &hfp);
if (status == eslENOTFOUND) esl_fatal("Failed to open HMM file %s for reading.\n", hmmfile);
else if (status == eslEFORMAT) esl_fatal("File %s does not appear to be in a recognized HMM format.\n", hmmfile);
else if (status != eslOK) esl_fatal("Unexpected error %d in opening HMM file %s.\n", status, hmmfile);
status = p7_hmmfile_Read(hfp, &abc, &hmm);
if (status == eslEFORMAT) esl_fatal("Bad file format in HMM file %s:\n%s\n", hfp->fname, hfp->errbuf);
else if (status == eslEINCOMPAT) esl_fatal("HMM in %s is not in the expected %s alphabet\n", hfp->fname, esl_abc_DecodeType(abc->type));
else if (status == eslEOF) esl_fatal("Empty HMM file %s? No HMM data found.\n", hfp->fname);
else if (status != eslOK) esl_fatal("Unexpected error in reading HMMs from %s\n", hfp->fname);
bg = p7_bg_Create(abc);
gm = p7_profile_Create(hmm->M, abc);
om1 = p7_oprofile_Create(hmm->M, abc);
p7_ProfileConfig(hmm, bg, gm, 400, p7_LOCAL);
p7_oprofile_Convert(gm, om1);
om2 = p7_oprofile_Copy(om1);
if (p7_oprofile_Compare(om1, om2, 0.001f, errmsg) != eslOK) esl_fatal("Compare failed %s\n", errmsg);
p7_oprofile_Destroy(om1);
p7_profile_Destroy(gm);
p7_bg_Destroy(bg);
p7_hmm_Destroy(hmm);
p7_hmmfile_Close(hfp);
esl_alphabet_Destroy(abc);
return eslOK;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = esl_getopts_CreateDefaultApp(options, 1, argc, argv, banner, usage);
char *hmmfile = esl_opt_GetArg(go, 1);
ESL_STOPWATCH *w = esl_stopwatch_Create();
ESL_ALPHABET *abc = NULL;
P7_HMMFILE *hfp = NULL;
P7_HMM *hmm = NULL;
P7_BG *bg = NULL;
P7_PROFILE *gm = NULL;
P7_OPROFILE *om = NULL;
int L = esl_opt_GetInteger(go, "-L");
int N = esl_opt_GetInteger(go, "-N");
int i;
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);
gm = p7_profile_Create(hmm->M, abc);
p7_ProfileConfig(hmm, bg, gm, L, p7_LOCAL);
om = p7_oprofile_Create(gm->M, abc);
esl_stopwatch_Start(w);
for (i = 0; i < N; i++)
p7_oprofile_Convert(gm, om);
esl_stopwatch_Stop(w);
esl_stopwatch_Display(stdout, w, "# CPU time: ");
printf("# M = %d\n", gm->M);
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_stopwatch_Destroy(w);
esl_getopts_Destroy(go);
return 0;
}
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_GMX *fwd = NULL;
ESL_SQ *sq = NULL;
ESL_SQFILE *sqfp = NULL;
P7_TRACE *tr = NULL;
int format = eslSQFILE_UNKNOWN;
char errbuf[eslERRBUFSIZE];
float sc;
int d;
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);
/* 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);
if (esl_sqio_Read(sqfp, sq) != eslOK) p7_Fail("Failed to read sequence");
esl_sqfile_Close(sqfp);
/* Configure a profile from the HMM */
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);
/* Allocate matrix and a trace */
fwd = p7_gmx_Create(gm->M, sq->n);
tr = p7_trace_Create();
/* Run Viterbi; do traceback */
p7_GViterbi (sq->dsq, sq->n, gm, fwd, &sc);
p7_GTrace (sq->dsq, sq->n, gm, fwd, tr);
/* Dump and validate the trace. */
p7_trace_Dump(stdout, tr, gm, sq->dsq);
if (p7_trace_Validate(tr, abc, sq->dsq, errbuf) != eslOK) p7_Die("trace fails validation:\n%s\n", errbuf);
/* Domain info in the trace. */
p7_trace_Index(tr);
printf("# Viterbi: %d domains : ", tr->ndom);
for (d = 0; d < tr->ndom; d++) printf("%6d %6d %6d %6d ", tr->sqfrom[d], tr->sqto[d], tr->hmmfrom[d], tr->hmmto[d]);
printf("\n");
/* Cleanup */
p7_trace_Destroy(tr);
p7_gmx_Destroy(fwd);
p7_profile_Destroy(gm);
p7_bg_Destroy(bg);
p7_hmm_Destroy(hmm);
esl_sq_Destroy(sq);
esl_alphabet_Destroy(abc);
esl_getopts_Destroy(go);
return 0;
}
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;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = esl_getopts_CreateDefaultApp(options, 1, argc, argv, banner, usage);
char *hmmfile = esl_opt_GetArg(go, 1);
ESL_STOPWATCH *w = esl_stopwatch_Create();
ESL_RANDOMNESS *r = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s"));
ESL_ALPHABET *abc = NULL;
P7_HMMFILE *hfp = NULL;
P7_HMM *hmm = NULL;
P7_BG *bg = NULL;
P7_PROFILE *gm = NULL;
P7_GMX *gx = NULL;
int L = esl_opt_GetInteger(go, "-L");
int N = esl_opt_GetInteger(go, "-N");
ESL_DSQ *dsq = malloc(sizeof(ESL_DSQ) * (L+2));
int i;
float sc;
double base_time, bench_time, Mcs;
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);
gm = p7_profile_Create(hmm->M, abc);
p7_ProfileConfig(hmm, bg, gm, L, p7_UNILOCAL);
gx = p7_gmx_Create(gm->M, L);
/* Baseline time. */
esl_stopwatch_Start(w);
for (i = 0; i < N; i++) esl_rsq_xfIID(r, bg->f, abc->K, L, dsq);
esl_stopwatch_Stop(w);
base_time = w->user;
/* Benchmark time. */
esl_stopwatch_Start(w);
for (i = 0; i < N; i++)
{
esl_rsq_xfIID(r, bg->f, abc->K, L, dsq);
p7_GViterbi (dsq, L, gm, gx, &sc);
}
esl_stopwatch_Stop(w);
bench_time = w->user - base_time;
Mcs = (double) N * (double) L * (double) gm->M * 1e-6 / (double) bench_time;
esl_stopwatch_Display(stdout, w, "# CPU time: ");
printf("# M = %d\n", gm->M);
printf("# %.1f Mc/s\n", Mcs);
free(dsq);
p7_gmx_Destroy(gx);
p7_profile_Destroy(gm);
p7_bg_Destroy(bg);
p7_hmm_Destroy(hmm);
p7_hmmfile_Close(hfp);
esl_alphabet_Destroy(abc);
esl_stopwatch_Destroy(w);
esl_randomness_Destroy(r);
esl_getopts_Destroy(go);
return 0;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = p7_CreateDefaultApp(options, 1, argc, argv, banner, usage);
char *hmmfile = esl_opt_GetArg(go, 1);
ESL_STOPWATCH *w = esl_stopwatch_Create();
ESL_RANDOMNESS *r = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s"));
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 *ox1 = NULL;
P7_OMX *ox2 = NULL;
int L = esl_opt_GetInteger(go, "-L");
int N = esl_opt_GetInteger(go, "-N");
ESL_DSQ *dsq = malloc(sizeof(ESL_DSQ) * (L+2));
float null2[p7_MAXCODE];
int i,j,d,pos;
int nsamples = 200;
float fsc, bsc;
double Mcs;
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");
bg = p7_bg_Create(abc); p7_bg_SetLength(bg, L);
gm = p7_profile_Create(hmm->M, abc); p7_ProfileConfig(hmm, bg, gm, L, p7_LOCAL);
om = p7_oprofile_Create(gm->M, abc); p7_oprofile_Convert(gm, om);
p7_oprofile_ReconfigLength(om, L);
ox1 = p7_omx_Create(gm->M, L, L);
ox2 = p7_omx_Create(gm->M, L, L);
esl_rsq_xfIID(r, bg->f, abc->K, L, dsq);
p7_Forward (dsq, L, om, ox1, &fsc);
if (esl_opt_GetBoolean(go, "-t"))
{
P7_TRACE *tr = p7_trace_Create();
float *n2sc = malloc(sizeof(float) * (L+1));
esl_stopwatch_Start(w);
for (i = 0; i < N; i++)
{ /* This is approximately what p7_domaindef.c::region_trace_ensemble() is doing: */
for (j = 0; j < nsamples; j++)
{
p7_StochasticTrace(r, dsq, L, om, ox1, tr);
p7_trace_Index(tr);
pos = 1;
for (d = 0; d < tr->ndom; d++)
{
p7_Null2_ByTrace(om, tr, tr->tfrom[d], tr->tto[d], ox2, null2);
for (; pos <= tr->sqfrom[d]; pos++) n2sc[pos] += 1.0;
for (; pos < tr->sqto[d]; pos++) n2sc[pos] += null2[dsq[pos]];
}
for (; pos <= L; pos++) n2sc[pos] += 1.0;
p7_trace_Reuse(tr);
}
for (pos = 1; pos <= L; pos++)
n2sc[pos] = logf(n2sc[pos] / nsamples);
}
esl_stopwatch_Stop(w);
free(n2sc);
p7_trace_Destroy(tr);
}
else
{
p7_Backward(dsq, L, om, ox1, ox2, &bsc);
p7_Decoding(om, ox1, ox2, ox2);
esl_stopwatch_Start(w);
for (i = 0; i < N; i++)
p7_Null2_ByExpectation(om, ox2, null2);
esl_stopwatch_Stop(w);
}
Mcs = (double) N * (double) L * (double) gm->M * 1e-6 / (double) w->user;
esl_stopwatch_Display(stdout, w, "# CPU time: ");
printf("# M = %d\n", gm->M);
printf("# %.1f Mc/s\n", Mcs);
free(dsq);
p7_omx_Destroy(ox1);
p7_omx_Destroy(ox2);
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_stopwatch_Destroy(w);
esl_randomness_Destroy(r);
esl_getopts_Destroy(go);
return 0;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = esl_getopts_CreateDefaultApp(options, 1, argc, argv, banner, usage);
char *hmmfile = esl_opt_GetArg(go, 1);
ESL_STOPWATCH *w = esl_stopwatch_Create();
ESL_RANDOMNESS *r = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s"));
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;
int L = esl_opt_GetInteger(go, "-L");
int N = esl_opt_GetInteger(go, "-N");
ESL_DSQ *dsq = malloc(sizeof(ESL_DSQ) * (L+2));
int i;
float fsc, bsc;
float fsc2, bsc2;
double base_time, bench_time, Mcs;
p7_FLogsumInit();
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);
gm = p7_profile_Create(hmm->M, abc);
p7_ProfileConfig(hmm, bg, gm, L, p7_LOCAL);
om = p7_oprofile_Create(gm->M, abc);
p7_oprofile_Convert(gm, om);
p7_oprofile_ReconfigLength(om, L);
if (esl_opt_GetBoolean(go, "-x") && p7_FLogsumError(-0.4, -0.5) > 0.0001)
p7_Fail("-x here requires p7_Logsum() recompiled in slow exact mode");
if (esl_opt_GetBoolean(go, "-P")) {
fwd = p7_omx_Create(gm->M, 0, L);
bck = p7_omx_Create(gm->M, 0, L);
} else {
fwd = p7_omx_Create(gm->M, L, L);
bck = p7_omx_Create(gm->M, L, L);
}
gx = p7_gmx_Create(gm->M, L);
/* Get a baseline time: how long it takes just to generate the sequences */
esl_stopwatch_Start(w);
for (i = 0; i < N; i++) esl_rsq_xfIID(r, bg->f, abc->K, L, dsq);
esl_stopwatch_Stop(w);
base_time = w->user;
esl_stopwatch_Start(w);
for (i = 0; i < N; i++)
{
esl_rsq_xfIID(r, bg->f, abc->K, L, dsq);
if (esl_opt_GetBoolean(go, "-P")) {
if (! esl_opt_GetBoolean(go, "-B")) p7_ForwardParser (dsq, L, om, fwd, &fsc);
if (! esl_opt_GetBoolean(go, "-F")) p7_BackwardParser(dsq, L, om, fwd, bck, &bsc);
} else {
if (! esl_opt_GetBoolean(go, "-B")) p7_Forward (dsq, L, om, fwd, &fsc);
if (! esl_opt_GetBoolean(go, "-F")) p7_Backward(dsq, L, om, fwd, bck, &bsc);
}
if (esl_opt_GetBoolean(go, "-c") || esl_opt_GetBoolean(go, "-x"))
{
p7_GForward (dsq, L, gm, gx, &fsc2);
p7_GBackward(dsq, L, gm, gx, &bsc2);
printf("%.4f %.4f %.4f %.4f\n", fsc, bsc, fsc2, bsc2);
}
}
esl_stopwatch_Stop(w);
bench_time = w->user - base_time;
Mcs = (double) N * (double) L * (double) gm->M * 1e-6 / (double) bench_time;
esl_stopwatch_Display(stdout, w, "# CPU time: ");
printf("# M = %d\n", gm->M);
printf("# %.1f Mc/s\n", Mcs);
free(dsq);
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_stopwatch_Destroy(w);
esl_randomness_Destroy(r);
esl_getopts_Destroy(go);
return 0;
}
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;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = p7_CreateDefaultApp(options, 1, argc, argv, banner, usage);
char *hmmfile = esl_opt_GetArg(go, 1);
ESL_RANDOMNESS *r = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s"));
ESL_ALPHABET *abc = NULL;
P7_HMMFILE *hfp = NULL;
P7_HMM *hmm = NULL;
P7_BG *bg = NULL;
P7_PROFILE *gm = NULL;
P7_OPROFILE *om = NULL;
double lambda = 0.0;
double mmu = 0.0;
double vmu = 0.0;
double ftau = 0.0;
int Z = esl_opt_GetInteger(go, "-Z");
int EmL = esl_opt_GetInteger(go, "--EmL");
int EmN = esl_opt_GetInteger(go, "--EmN");
int EvL = esl_opt_GetInteger(go, "--EvL");
int EvN = esl_opt_GetInteger(go, "--EvN");
int EfL = esl_opt_GetInteger(go, "--EfL");
int EfN = esl_opt_GetInteger(go, "--EfN");
int Eft = esl_opt_GetReal (go, "--Eft");
int iteration;
int do_msv, do_vit, do_fwd;
int status;
if (esl_opt_GetBoolean(go, "--msvonly") == TRUE) { do_msv = TRUE; do_vit = FALSE; do_fwd = FALSE; }
else if (esl_opt_GetBoolean(go, "--vitonly") == TRUE) { do_msv = FALSE; do_vit = TRUE; do_fwd = FALSE; }
else if (esl_opt_GetBoolean(go, "--fwdonly") == TRUE) { do_msv = FALSE; do_vit = FALSE; do_fwd = TRUE; }
else { do_msv = TRUE; do_vit = TRUE; do_fwd = TRUE; }
if (p7_hmmfile_OpenE(hmmfile, NULL, &hfp, NULL) != eslOK) p7_Fail("Failed to open HMM file %s", hmmfile);
while ((status = p7_hmmfile_Read(hfp, &abc, &hmm)) != eslEOF)
{
if (bg == NULL) bg = p7_bg_Create(abc);
gm = p7_profile_Create(hmm->M, abc);
p7_ProfileConfig(hmm, bg, gm, EvL, p7_LOCAL); /* the EvL doesn't matter */
om = p7_oprofile_Create(hmm->M, abc);
p7_oprofile_Convert(gm, om);
if (esl_opt_IsOn(go, "--lambda")) lambda = esl_opt_GetReal(go, "--lambda");
else p7_Lambda(hmm, bg, &lambda);
for (iteration = 0; iteration < Z; iteration++)
{
if (do_msv) p7_MSVMu (r, om, bg, EmL, EmN, lambda, &mmu);
if (do_vit) p7_ViterbiMu (r, om, bg, EvL, EvN, lambda, &vmu);
if (do_fwd) p7_Tau (r, om, bg, EfL, EfN, lambda, Eft, &ftau);
printf("%s %.4f %.4f %.4f %.4f\n", hmm->name, lambda, mmu, vmu, ftau);
}
p7_hmm_Destroy(hmm);
p7_profile_Destroy(gm);
p7_oprofile_Destroy(om);
}
p7_hmmfile_Close(hfp);
p7_bg_Destroy(bg);
esl_alphabet_Destroy(abc);
esl_randomness_Destroy(r);
esl_getopts_Destroy(go);
return eslOK;
}
int
main(int argc, char **argv)
{
ESL_ALPHABET *abc = NULL; /* sequence alphabet */
ESL_GETOPTS *go = NULL; /* command line processing */
ESL_RANDOMNESS *r = NULL; /* source of randomness */
P7_HMM *hmm = NULL; /* sampled HMM to emit from */
P7_HMM *core = NULL; /* safe copy of the HMM, before config */
P7_BG *bg = NULL; /* null model */
ESL_SQ *sq = NULL; /* sampled sequence */
P7_TRACE *tr = NULL; /* sampled trace */
P7_PROFILE *gm = NULL; /* profile */
int i,j;
int i1,i2;
int k1,k2;
int iseq;
FILE *fp = NULL;
double expected;
int do_ilocal;
char *hmmfile = NULL;
int nseq;
int do_swlike;
int do_ungapped;
int L;
int M;
int do_h2;
char *ipsfile = NULL;
char *kpsfile = NULL;
ESL_DMATRIX *imx = NULL;
ESL_DMATRIX *kmx = NULL;
ESL_DMATRIX *iref = NULL; /* reference matrix: expected i distribution under ideality */
int Lbins;
int status;
char errbuf[eslERRBUFSIZE];
/*****************************************************************
* Parse the command line
*****************************************************************/
go = esl_getopts_Create(options);
if (esl_opt_ProcessCmdline(go, argc, argv) != eslOK) esl_fatal("Failed to parse command line: %s\n", go->errbuf);
if (esl_opt_VerifyConfig(go) != eslOK) esl_fatal("Failed to parse command line: %s\n", go->errbuf);
if (esl_opt_GetBoolean(go, "-h") == TRUE) {
puts(usage);
puts("\n where options are:\n");
esl_opt_DisplayHelp(stdout, go, 0, 2, 80); /* 0=all docgroups; 2 = indentation; 80=textwidth*/
return eslOK;
}
do_ilocal = esl_opt_GetBoolean(go, "-i");
hmmfile = esl_opt_GetString (go, "-m");
nseq = esl_opt_GetInteger(go, "-n");
do_swlike = esl_opt_GetBoolean(go, "-s");
do_ungapped = esl_opt_GetBoolean(go, "-u");
L = esl_opt_GetInteger(go, "-L");
M = esl_opt_GetInteger(go, "-M");
do_h2 = esl_opt_GetBoolean(go, "-2");
ipsfile = esl_opt_GetString (go, "--ips");
kpsfile = esl_opt_GetString (go, "--kps");
if (esl_opt_ArgNumber(go) != 0) {
puts("Incorrect number of command line arguments.");
printf("Usage: %s [options]\n", argv[0]);
return eslFAIL;
}
r = esl_randomness_CreateFast(0);
if (hmmfile != NULL)
{ /* Read the HMM (and get alphabet from it) */
P7_HMMFILE *hfp = NULL;
status = p7_hmmfile_OpenE(hmmfile, NULL, &hfp, errbuf);
if (status == eslENOTFOUND) p7_Fail("File existence/permissions problem in trying to open HMM file %s.\n%s\n", hmmfile, errbuf);
else if (status == eslEFORMAT) p7_Fail("File format problem in trying to open HMM file %s.\n%s\n", hmmfile, errbuf);
else if (status != eslOK) p7_Fail("Unexpected error %d in opening HMM file %s.\n%s\n", status, hmmfile, errbuf);
if ((status = p7_hmmfile_Read(hfp, &abc, &hmm)) != eslOK) {
if (status == eslEOD) esl_fatal("read failed, HMM file %s may be truncated?", hmmfile);
else if (status == eslEFORMAT) esl_fatal("bad file format in HMM file %s", hmmfile);
else if (status == eslEINCOMPAT) esl_fatal("HMM file %s contains different alphabets", hmmfile);
else esl_fatal("Unexpected error in reading HMMs");
}
M = hmm->M;
p7_hmmfile_Close(hfp);
}
else
{ /* Or sample the HMM (create alphabet first) */
abc = esl_alphabet_Create(eslAMINO);
if (do_ungapped) p7_hmm_SampleUngapped(r, M, abc, &hmm);
else if (do_swlike) p7_hmm_SampleUniform (r, M, abc, 0.05, 0.5, 0.05, 0.2, &hmm); /* tmi, tii, tmd, tdd */
else p7_hmm_Sample (r, M, abc, &hmm);
}
Lbins = M;
imx = esl_dmatrix_Create(Lbins, Lbins);
iref = esl_dmatrix_Create(Lbins, Lbins);
kmx = esl_dmatrix_Create(M, M);
esl_dmatrix_SetZero(imx);
esl_dmatrix_SetZero(iref);
esl_dmatrix_SetZero(kmx);
tr = p7_trace_Create();
sq = esl_sq_CreateDigital(abc);
bg = p7_bg_Create(abc);
core = p7_hmm_Clone(hmm);
if (do_h2) {
gm = p7_profile_Create(hmm->M, abc);
p7_H2_ProfileConfig(hmm, bg, gm, p7_UNILOCAL);
} else {
gm = p7_profile_Create(hmm->M, abc);
p7_ProfileConfig(hmm, bg, gm, L, p7_UNILOCAL);
if (p7_hmm_Validate (hmm, NULL, 0.0001) != eslOK) esl_fatal("whoops, HMM is bad!");
if (p7_profile_Validate(gm, NULL, 0.0001) != eslOK) esl_fatal("whoops, profile is bad!");
}
/* Sample endpoints.
* Also sample an ideal reference distribution for i endpoints. i
* endpoints are prone to discretization artifacts, when emitted
* sequences have varying lengths. Taking log odds w.r.t. an ideal
* reference that is subject to the same discretization artifacts
* cancels out the effect.
*/
for (iseq = 0; iseq < nseq; iseq++)
{
if (do_ilocal) ideal_local_endpoints (r, core, sq, tr, Lbins, &i1, &i2, &k1, &k2);
else profile_local_endpoints(r, core, gm, sq, tr, Lbins, &i1, &i2, &k1, &k2);
imx->mx[i1-1][i2-1] += 1.;
kmx->mx[k1-1][k2-1] += 1.;
/* reference distribution for i */
ideal_local_endpoints (r, core, sq, tr, Lbins, &i1, &i2, &k1, &k2);
iref->mx[i1-1][i2-1] += 1.;
}
/* Adjust both mx's to log_2(obs/exp) ratio */
printf("Before normalization/log-odds:\n");
printf(" i matrix values range from %f to %f\n", dmx_upper_min(imx), dmx_upper_max(imx));
printf(" k matrix values range from %f to %f\n", dmx_upper_min(kmx), dmx_upper_max(kmx));
printf("iref matrix values range from %f to %f\n", dmx_upper_min(iref), dmx_upper_max(iref));
expected = (double) nseq * 2. / (double) (M*(M+1));
for (i = 0; i < kmx->m; i++)
for (j = i; j < kmx->n; j++)
kmx->mx[i][j] = log(kmx->mx[i][j] / expected) / log(2.0);
for (i = 0; i < imx->m; i++)
for (j = i; j < imx->m; j++)
if (iref->mx[i][j] == 0. && imx->mx[i][j] == 0.)
imx->mx[i][j] = 0.;
else if (iref->mx[i][j] == 0.)
imx->mx[i][j] = eslINFINITY;
else if (imx->mx[i][j] == 0.)
imx->mx[i][j] = -eslINFINITY;
else
imx->mx[i][j] = log(imx->mx[i][j] / iref->mx[i][j]) / log(2.0);
/* Print ps files */
if (kpsfile != NULL) {
if ((fp = fopen(kpsfile, "w")) == NULL) esl_fatal("Failed to open output postscript file %s", kpsfile);
dmx_Visualize(fp, kmx, -4., 5.);
fclose(fp);
}
if (ipsfile != NULL) {
if ((fp = fopen(ipsfile, "w")) == NULL) esl_fatal("Failed to open output postscript file %s", ipsfile);
dmx_Visualize(fp, imx, -4., 5.);
/* dmx_Visualize(fp, imx, dmx_upper_min(imx), dmx_upper_max(imx)); */
fclose(fp);
}
printf("After normalization/log-odds:\n");
printf("i matrix values range from %f to %f\n", dmx_upper_min(imx), dmx_upper_max(imx));
printf("k matrix values range from %f to %f\n", dmx_upper_min(kmx), dmx_upper_max(kmx));
p7_profile_Destroy(gm);
p7_bg_Destroy(bg);
p7_hmm_Destroy(core);
p7_hmm_Destroy(hmm);
p7_trace_Destroy(tr);
esl_sq_Destroy(sq);
esl_dmatrix_Destroy(imx);
esl_dmatrix_Destroy(kmx);
esl_alphabet_Destroy(abc);
esl_randomness_Destroy(r);
esl_getopts_Destroy(go);
return eslOK;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = esl_getopts_CreateDefaultApp(options, 1, argc, argv, banner, usage);
char *hmmfile = esl_opt_GetArg(go, 1);
ESL_STOPWATCH *w = esl_stopwatch_Create();
ESL_RANDOMNESS *r = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s"));
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;
int L = esl_opt_GetInteger(go, "-L");
int N = esl_opt_GetInteger(go, "-N");
ESL_DSQ *dsq = malloc(sizeof(ESL_DSQ) * (L+2));
int i;
float sc1, sc2;
double base_time, bench_time, Mcs;
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);
gm = p7_profile_Create(hmm->M, abc);
p7_ProfileConfig(hmm, bg, gm, L, p7_LOCAL);
om = p7_oprofile_Create(gm->M, abc);
p7_oprofile_Convert(gm, om);
p7_oprofile_ReconfigLength(om, L);
if (esl_opt_GetBoolean(go, "-x")) p7_profile_SameAsVF(om, gm);
ox = p7_omx_Create(gm->M, 0, 0);
gx = p7_gmx_Create(gm->M, L);
/* Get a baseline time: how long it takes just to generate the sequences */
esl_stopwatch_Start(w);
for (i = 0; i < N; i++)
esl_rsq_xfIID(r, bg->f, abc->K, L, dsq);
esl_stopwatch_Stop(w);
base_time = w->user;
/* Run the benchmark */
esl_stopwatch_Start(w);
for (i = 0; i < N; i++)
{
esl_rsq_xfIID(r, bg->f, abc->K, L, dsq);
p7_ViterbiFilter(dsq, L, om, ox, &sc1);
if (esl_opt_GetBoolean(go, "-c"))
{
p7_GViterbi(dsq, L, gm, gx, &sc2);
printf("%.4f %.4f\n", sc1, sc2);
}
if (esl_opt_GetBoolean(go, "-x"))
{
p7_GViterbi(dsq, L, gm, gx, &sc2);
sc2 /= om->scale_w;
if (om->mode == p7_UNILOCAL) sc2 -= 2.0; /* that's ~ L \log \frac{L}{L+2}, for our NN,CC,JJ */
else if (om->mode == p7_LOCAL) sc2 -= 3.0; /* that's ~ L \log \frac{L}{L+3}, for our NN,CC,JJ */
printf("%.4f %.4f\n", sc1, sc2);
}
}
esl_stopwatch_Stop(w);
bench_time = w->user - base_time;
Mcs = (double) N * (double) L * (double) gm->M * 1e-6 / (double) bench_time;
esl_stopwatch_Display(stdout, w, "# CPU time: ");
printf("# M = %d\n", gm->M);
printf("# %.1f Mc/s\n", Mcs);
free(dsq);
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_stopwatch_Destroy(w);
esl_randomness_Destroy(r);
esl_getopts_Destroy(go);
return 0;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = p7_CreateDefaultApp(options, 1, argc, argv, banner, usage);
char *hmmfile = esl_opt_GetArg(go, 1);
ESL_STOPWATCH *w = esl_stopwatch_Create();
ESL_RANDOMNESS *r = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s"));
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 *gx1 = NULL;
P7_GMX *gx2 = NULL;
P7_OMX *ox1 = NULL;
P7_OMX *ox2 = NULL;
P7_TRACE *tr = NULL;
int L = esl_opt_GetInteger(go, "-L");
int N = esl_opt_GetInteger(go, "-N");
ESL_DSQ *dsq = malloc(sizeof(ESL_DSQ) * (L+2));
int i;
float fsc, bsc, accscore;
float fsc_g, bsc_g, accscore_g;
double Mcs;
p7_FLogsumInit();
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");
bg = p7_bg_Create(abc); p7_bg_SetLength(bg, L);
gm = p7_profile_Create(hmm->M, abc); p7_ProfileConfig(hmm, bg, gm, L, p7_LOCAL);
om = p7_oprofile_Create(gm->M, abc); p7_oprofile_Convert(gm, om);
p7_oprofile_ReconfigLength(om, L);
if (esl_opt_GetBoolean(go, "-x") && p7_FLogsumError(-0.4, -0.5) > 0.0001)
p7_Fail("-x here requires p7_Logsum() recompiled in slow exact mode");
ox1 = p7_omx_Create(gm->M, L, L);
ox2 = p7_omx_Create(gm->M, L, L);
tr = p7_trace_CreateWithPP();
esl_rsq_xfIID(r, bg->f, abc->K, L, dsq);
p7_Forward (dsq, L, om, ox1, &fsc);
p7_Backward(dsq, L, om, ox1, ox2, &bsc);
p7_Decoding(om, ox1, ox2, ox2);
esl_stopwatch_Start(w);
for (i = 0; i < N; i++)
{
p7_OptimalAccuracy(om, ox2, ox1, &accscore);
if (! esl_opt_GetBoolean(go, "--notrace"))
{
p7_OATrace(om, ox2, ox1, tr);
p7_trace_Reuse(tr);
}
}
esl_stopwatch_Stop(w);
Mcs = (double) N * (double) L * (double) gm->M * 1e-6 / (double) w->user;
esl_stopwatch_Display(stdout, w, "# CPU time: ");
printf("# M = %d\n", gm->M);
printf("# %.1f Mc/s\n", Mcs);
if (esl_opt_GetBoolean(go, "-c") || esl_opt_GetBoolean(go, "-x") )
{
gx1 = p7_gmx_Create(gm->M, L);
gx2 = p7_gmx_Create(gm->M, L);
p7_GForward (dsq, L, gm, gx1, &fsc_g);
p7_GBackward(dsq, L, gm, gx2, &bsc_g);
p7_GDecoding(gm, gx1, gx2, gx2);
p7_GOptimalAccuracy(gm, gx2, gx1, &accscore_g);
printf("generic: fwd=%8.4f bck=%8.4f acc=%8.4f\n", fsc_g, bsc_g, accscore_g);
printf("VMX: fwd=%8.4f bck=%8.4f acc=%8.4f\n", fsc, bsc, accscore);
p7_gmx_Destroy(gx1);
p7_gmx_Destroy(gx2);
}
free(dsq);
p7_omx_Destroy(ox1);
p7_omx_Destroy(ox2);
p7_trace_Destroy(tr);
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_stopwatch_Destroy(w);
esl_randomness_Destroy(r);
esl_getopts_Destroy(go);
return 0;
}
static void
search_thread(void *arg)
{
int i;
int count;
int seed;
int status;
int workeridx;
WORKER_INFO *info;
ESL_THREADS *obj;
ESL_SQ dbsq;
ESL_STOPWATCH *w = NULL; /* timing stopwatch */
P7_BUILDER *bld = NULL; /* HMM construction configuration */
P7_BG *bg = NULL; /* null model */
P7_PIPELINE *pli = NULL; /* work pipeline */
P7_TOPHITS *th = NULL; /* top hit results */
P7_PROFILE *gm = NULL; /* generic model */
P7_OPROFILE *om = NULL; /* optimized query profile */
obj = (ESL_THREADS *) arg;
esl_threads_Started(obj, &workeridx);
info = (WORKER_INFO *) esl_threads_GetData(obj, workeridx);
w = esl_stopwatch_Create();
bg = p7_bg_Create(info->abc);
esl_stopwatch_Start(w);
/* set up the dummy description and accession fields */
dbsq.desc = "";
dbsq.acc = "";
/* process a query sequence or hmm */
if (info->seq != NULL) {
bld = p7_builder_Create(NULL, info->abc);
if ((seed = esl_opt_GetInteger(info->opts, "--seed")) > 0) {
esl_randomness_Init(bld->r, seed);
bld->do_reseeding = TRUE;
}
bld->EmL = esl_opt_GetInteger(info->opts, "--EmL");
bld->EmN = esl_opt_GetInteger(info->opts, "--EmN");
bld->EvL = esl_opt_GetInteger(info->opts, "--EvL");
bld->EvN = esl_opt_GetInteger(info->opts, "--EvN");
bld->EfL = esl_opt_GetInteger(info->opts, "--EfL");
bld->EfN = esl_opt_GetInteger(info->opts, "--EfN");
bld->Eft = esl_opt_GetReal (info->opts, "--Eft");
if (esl_opt_IsOn(info->opts, "--mxfile")) status = p7_builder_SetScoreSystem (bld, esl_opt_GetString(info->opts, "--mxfile"), NULL, esl_opt_GetReal(info->opts, "--popen"), esl_opt_GetReal(info->opts, "--pextend"), bg);
else status = p7_builder_LoadScoreSystem(bld, esl_opt_GetString(info->opts, "--mx"), esl_opt_GetReal(info->opts, "--popen"), esl_opt_GetReal(info->opts, "--pextend"), bg);
if (status != eslOK) {
//client_error(info->sock, status, "hmmgpmd: failed to set single query sequence score system: %s", bld->errbuf);
fprintf(stderr, "hmmpgmd: failed to set single query sequence score system: %s", bld->errbuf);
pthread_exit(NULL);
return;
}
p7_SingleBuilder(bld, info->seq, bg, NULL, NULL, NULL, &om); /* bypass HMM - only need model */
p7_builder_Destroy(bld);
} else {
gm = p7_profile_Create (info->hmm->M, info->abc);
om = p7_oprofile_Create(info->hmm->M, info->abc);
p7_ProfileConfig(info->hmm, bg, gm, 100, p7_LOCAL);
p7_oprofile_Convert(gm, om);
}
/* Create processing pipeline and hit list */
th = p7_tophits_Create();
pli = p7_pipeline_Create(info->opts, om->M, 100, FALSE, p7_SEARCH_SEQS);
p7_pli_NewModel(pli, om, bg);
if (pli->Z_setby == p7_ZSETBY_NTARGETS) pli->Z = info->db_Z;
/* loop until all sequences have been processed */
count = 1;
while (count > 0) {
int inx;
int blksz;
HMMER_SEQ **sq;
/* grab the next block of sequences */
if (pthread_mutex_lock(info->inx_mutex) != 0) p7_Fail("mutex lock failed");
inx = *info->inx;
blksz = *info->blk_size;
if (inx > *info->limit) {
blksz /= 5;
if (blksz < 1000) {
*info->limit = info->sq_cnt * 2;
} else {
*info->limit = inx + (info->sq_cnt - inx) * 2 / 3;
}
}
*info->blk_size = blksz;
*info->inx += blksz;
if (pthread_mutex_unlock(info->inx_mutex) != 0) p7_Fail("mutex unlock failed");
sq = info->sq_list + inx;
count = info->sq_cnt - inx;
if (count > blksz) count = blksz;
/* Main loop: */
for (i = 0; i < count; ++i, ++sq) {
if ( !(info->range_list) || hmmpgmd_IsWithinRanges ((*sq)->idx, info->range_list)) {
dbsq.name = (*sq)->name;
dbsq.dsq = (*sq)->dsq;
dbsq.n = (*sq)->n;
dbsq.idx = (*sq)->idx;
if((*sq)->desc != NULL) dbsq.desc = (*sq)->desc;
p7_bg_SetLength(bg, dbsq.n);
p7_oprofile_ReconfigLength(om, dbsq.n);
p7_Pipeline(pli, om, bg, &dbsq, th);
p7_pipeline_Reuse(pli);
}
}
}
/* make available the pipeline objects to the main thread */
info->th = th;
info->pli = pli;
/* clean up */
p7_bg_Destroy(bg);
p7_oprofile_Destroy(om);
if (gm != NULL) p7_profile_Destroy(gm);
esl_stopwatch_Stop(w);
info->elapsed = w->elapsed;
esl_stopwatch_Destroy(w);
esl_threads_Finished(obj, workeridx);
pthread_exit(NULL);
return;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = p7_CreateDefaultApp(options, 1, argc, argv, banner, usage);
char *hmmfile = esl_opt_GetArg(go, 1);
ESL_STOPWATCH *w = esl_stopwatch_Create();
ESL_RANDOMNESS *r = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s"));
ESL_ALPHABET *abc = NULL;
P7_HMMFILE *hfp = NULL;
P7_HMM *hmm = NULL;
P7_BG *bg = NULL;
P7_PROFILE *gm = NULL;
P7_GMX *gx1 = NULL;
P7_GMX *gx2 = NULL;
P7_TRACE *tr = NULL;
int L = esl_opt_GetInteger(go, "-L");
int N = esl_opt_GetInteger(go, "-N");
ESL_DSQ *dsq = malloc(sizeof(ESL_DSQ) * (L+2));
int i;
float fsc, bsc, accscore;
double Mcs;
p7_FLogsumInit();
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");
bg = p7_bg_Create(abc);
p7_bg_SetLength(bg, L);
gm = p7_profile_Create(hmm->M, abc);
p7_ProfileConfig(hmm, bg, gm, L, p7_UNILOCAL);
gx1 = p7_gmx_Create(gm->M, L);
gx2 = p7_gmx_Create(gm->M, L);
tr = p7_trace_CreateWithPP();
esl_rsq_xfIID(r, bg->f, abc->K, L, dsq);
p7_GForward (dsq, L, gm, gx1, &fsc);
p7_GBackward(dsq, L, gm, gx2, &bsc);
p7_GDecoding(gm, gx1, gx2, gx2); /* <gx2> is now the posterior decoding matrix */
esl_stopwatch_Start(w);
for (i = 0; i < N; i++)
{
p7_GOptimalAccuracy(gm, gx2, gx1, &accscore); /* <gx1> is now the OA matrix */
if (! esl_opt_GetBoolean(go, "--notrace"))
{
p7_GOATrace(gm, gx2, gx1, tr);
p7_trace_Reuse(tr);
}
}
esl_stopwatch_Stop(w);
Mcs = (double) N * (double) L * (double) gm->M * 1e-6 / w->user;
esl_stopwatch_Display(stdout, w, "# CPU time: ");
printf("# M = %d\n", gm->M);
printf("# %.1f Mc/s\n", Mcs);
free(dsq);
p7_trace_Destroy(tr);
p7_gmx_Destroy(gx1);
p7_gmx_Destroy(gx2);
p7_profile_Destroy(gm);
p7_bg_Destroy(bg);
p7_hmm_Destroy(hmm);
p7_hmmfile_Close(hfp);
esl_alphabet_Destroy(abc);
esl_stopwatch_Destroy(w);
esl_randomness_Destroy(r);
esl_getopts_Destroy(go);
return 0;
}
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 = esl_opt_GetInteger(go, "-L");
int N = esl_opt_GetInteger(go, "-N") / SSE16_NVALS;
int MaxPart = esl_opt_GetInteger(go, "-M");
int NROUNDS = esl_opt_GetInteger(go, "-R");
int check = esl_opt_GetBoolean(go, "-c");
__m128 resdata[10];
int i, j;
float *sc1 = (float*) resdata;
ESL_SQFILE *sqfp = NULL;
DATA_COPS16 *dcops;
struct timeb tbstart, tbend;
int sumlengths = 0;
float* results = NULL;
srand(time(NULL));
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);
dcops = p7_ViterbiCOPSw_Create(gm1);
p7_ViterbiCOPSW_Setup(dcops, L+100, MaxPart); // use max L
dcops->L = L;
int dbsize = SSE16_NVALS*N;
SEQ **seqsdb= calloc(dbsize+1, sizeof(SEQ*));
int equallength = 1;
if (esl_sqfile_OpenDigital(abc, seqfile, eslSQFILE_FASTA, NULL, &sqfp) == eslOK)
{ // Use Sequence file
ESL_SQ* sq = esl_sq_CreateDigital(abc);
int maxseqs, len=0;
if (esl_opt_IsDefault(go, "-N")) // N not specified in cmdline
maxseqs = INT_MAX; // no limit
else
maxseqs = SSE16_NVALS*N; // use cmdline limit
for (j = 0; j < maxseqs && esl_sqio_Read(sqfp, sq) == eslOK; j++)
{
if (equallength && sq->n != len && j > 0)
equallength = 0;
len = sq->n;
if (j > dbsize)
{ seqsdb = realloc(seqsdb, 2*(dbsize+1)*sizeof(SEQ*));
dbsize *= 2;
}
ESL_DSQ* dsq = sq->dsq;
seqsdb[j] = malloc(sizeof(SEQ));
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);
}
N = j/SSE16_NVALS;
}
else // Not found database. Generate random sequences
for (i = 0; i < N; i++)
for (j = 0; j < SSE16_NVALS; j++)
{
int len = L; // - rand()%1000;
seqsdb[i*SSE16_NVALS+j] = malloc(sizeof(SEQ));
seqsdb[i*SSE16_NVALS+j]->seq = malloc(len+4);
seqsdb[i*SSE16_NVALS+j]->length = len;
esl_rsq_xfIID(r, bg->f, abc->K, len, seqsdb[i*SSE16_NVALS+j]->seq);
sumlengths += len;
}
printf("Viterbi COPS Word with %d threads, model %s. ModelLen: %d, #Segms: %d, SeqL.: %d, #seqs: %d, Partition: %d, #parts: %d\n",
NTHREADS, hmmfile, gm1->M, (int) ceil(gm1->M/SSE16_NVALS), L, SSE16_NVALS*N*NROUNDS, dcops->partition, dcops->Npartitions);
/* // No. of partitions computed without full parallelism ( == no. of threads active while some are idle)
int Niters_part = dcops->Npartitions % NTHREADS;
// No. of Model lines that could be computed but are wasted by idle threads waiting on the end
int Nwasted_threads = dcops->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= (dcops->partition - gm1->M % dcops->partition) % dcops->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, dcops->partition * NTHREADS);
printf("Total Comp Lines: %d | Wasted Comp Lines: %d\n", totalcomp, wastedcomp);
*/
if (check) results = (float*) alloc_m128_aligned64((N+1)*2);
ftime(&tbstart);
if (!equallength)
{ // Sort sequences by length
qsort(seqsdb, N*SSE16_NVALS, sizeof(SEQ*), compare_seqs);
}
for (j = 0; j < NROUNDS; j++)
for (i = 0; i < N; i++)
{
// if (i % 1000 == 0) printf("Seq %d\n", i);
p7_ViterbiCOPSw_run(dcops, seqsdb+i*SSE16_NVALS, sc1);
if (check) memcpy(results+i*SSE16_NVALS, sc1, 32); // 32 bytes indeed! SSE16_NVALS floats
}
ftime(&tbend);
double secs = TIMEDIFF(tbstart,tbend);
w->elapsed = w->user = secs;
esl_stopwatch_Display(stdout, w, "# Opt CPU time: ");
double compmillioncells = NROUNDS * (double) sumlengths * (double) hmm->M * 1e-6;
printf("# %.0fM cells in %.1f Mc/s\n", compmillioncells, compmillioncells / secs);
if (check)
{ 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);
printf("Compare results against base version\n");
for (i = 0; i < N; i++)
{
int maxll = 0; float sc2;
for (j = 0; j < SSE16_NVALS; j++)
if (maxll < seqsdb[i*SSE16_NVALS+j]->length)
maxll = seqsdb[i*SSE16_NVALS+j]->length;
p7_oprofile_ReconfigRestLength(om, maxll);
// p7_ReconfigLength(gm2, maxll); // emulate the lock-step inter-sequence reconfigs
for (j = 0; j < SSE16_NVALS; j++)
{
// p7_ReconfigLength(gm2, seqsdb[i*SSE16_NVALS+j]->length);
// p7_Viterbi_unilocal(seqsdb[i*SSE16_NVALS+j]->seq, seqsdb[i*SSE16_NVALS+j]->length, gm2, &sc3);
// p7_Viterbi_unilocal_word(seqsdb[i*SSE16_NVALS+j]->seq, seqsdb[i*SSE16_NVALS+j]->length, gm2, &sc2);
// p7_oprofile_ReconfigLength(om, seqsdb[i*SSE16_NVALS+j]->length);
p7_ViterbiFilter(seqsdb[i*SSE16_NVALS+j]->seq, seqsdb[i*SSE16_NVALS+j]->length, om, ox, &sc2);
sc2 += 1.0; // -2.0nat optimization, Local to Unilocal mode
if (fabs(results[i*SSE16_NVALS+j] - sc2) > 0.0001)
{ printf("Seq %d Len %4d: %f - %f\tdiff: %f\n", i*SSE16_NVALS+j, seqsdb[i*SSE16_NVALS+j]->length,
results[i*SSE16_NVALS+j], sc2, fabs(results[i*SSE16_NVALS+j] - sc2));
}
}
}
}
return 0;
}
/* Function: p7_Calibrate()
* Synopsis: Calibrate the E-value parameters of a model.
* Incept: SRE, Thu Dec 25 09:29:31 2008 [Magallon]
*
* Purpose: Calibrate the E-value parameters of a model with
* one calculation ($\lambda$) and two brief simulations
* (Viterbi $\mu$, Forward $\tau$).
*
* Args: hmm - HMM to be calibrated
* cfg_b - OPTCFG: ptr to optional build configuration;
* if <NULL>, use default parameters.
* byp_rng - BYPASS optimization: pass ptr to <ESL_RANDOMNESS> generator
* if already known;
* <*byp_rng> == NULL> if <rng> return is desired;
* pass <NULL> to use and discard internal default.
* byp_bg - BYPASS optimization: pass ptr to <P7_BG> if already known;
* <*byp_bg == NULL> if <bg> return is desired;
* pass <NULL> to use and discard internal default.
* byp_gm - BYPASS optimization: pass ptr to <gm> profile if already known;
* pass <*byp_gm == NULL> if <gm> return desired;
* pass <NULL> to use and discard internal default.
* byp_om - BYPASS optimization: pass ptr to <om> profile if already known;
* pass <*byp_om == NULL> if <om> return desired;
* pass <NULL> to use and discard internal default.
*
* Returns: <eslOK> on success.
*
* Throws: <eslEMEM> on allocation failure.
* <eslEINVAL> if <hmm>, <gm>, <om> aren't compatible somehow.
*
* Xref: J4/41
*/
int
p7_Calibrate(P7_HMM *hmm, P7_BUILDER *cfg_b, ESL_RANDOMNESS **byp_rng, P7_BG **byp_bg, P7_PROFILE **byp_gm, P7_OPROFILE **byp_om)
{
P7_BG *bg = (esl_byp_IsProvided(byp_bg) ? *byp_bg : NULL);
P7_PROFILE *gm = (esl_byp_IsProvided(byp_gm) ? *byp_gm : NULL);
P7_OPROFILE *om = (esl_byp_IsProvided(byp_om) ? *byp_om : NULL);
ESL_RANDOMNESS *r = (esl_byp_IsProvided(byp_rng) ? *byp_rng : NULL);
char *errbuf = ((cfg_b != NULL) ? cfg_b->errbuf : NULL);
int EmL = ((cfg_b != NULL) ? cfg_b->EmL : 200);
int EmN = ((cfg_b != NULL) ? cfg_b->EmN : 200);
int EvL = ((cfg_b != NULL) ? cfg_b->EvL : 200);
int EvN = ((cfg_b != NULL) ? cfg_b->EvN : 200);
int EfL = ((cfg_b != NULL) ? cfg_b->EfL : 100);
int EfN = ((cfg_b != NULL) ? cfg_b->EfN : 200);
double Eft = ((cfg_b != NULL) ? cfg_b->Eft : 0.04);
double lambda, mmu, vmu, tau;
int status;
/* Configure any objects we need
* that weren't already passed to us as a bypass optimization
*/
if (r == NULL) {
if ((r = esl_randomness_CreateFast(42)) == NULL) ESL_XFAIL(eslEMEM, errbuf, "failed to create RNG");
} else if (cfg_b != NULL && cfg_b->do_reseeding) {
esl_randomness_Init(r, esl_randomness_GetSeed(r));
}
if (bg == NULL) {
if ((bg = p7_bg_Create(hmm->abc)) == NULL) ESL_XFAIL(eslEMEM, errbuf, "failed to allocate background");
}
/* there's an odd case where the <om> is provided and a <gm> isn't going to be returned
* where we don't need a <gm> at all, and <gm> stays <NULL> after the next block.
* Note that the <EvL> length in the ProfileConfig doesn't matter; the individual
* calibration routines MSVMu(), etc. contain their own length reconfig calls.
*/
if ((esl_byp_IsInternal(byp_gm) && ! esl_byp_IsProvided(byp_om)) || esl_byp_IsReturned(byp_gm)) {
if ( (gm = p7_profile_Create(hmm->M, hmm->abc)) == NULL) ESL_XFAIL(eslEMEM, errbuf, "failed to allocate profile");
if ( (status = p7_ProfileConfig(hmm, bg, gm, EvL, p7_LOCAL)) != eslOK) ESL_XFAIL(status, errbuf, "failed to configure profile");
}
if (om == NULL) {
if ((om = p7_oprofile_Create(hmm->M, hmm->abc)) == NULL) ESL_XFAIL(eslEMEM, errbuf, "failed to create optimized profile");
if ((status = p7_oprofile_Convert(gm, om)) != eslOK) ESL_XFAIL(status, errbuf, "failed to convert to optimized profile");
}
/* The calibration steps themselves */
if ((status = p7_Lambda(hmm, bg, &lambda)) != eslOK) ESL_XFAIL(status, errbuf, "failed to determine lambda");
if ((status = p7_MSVMu (r, om, bg, EmL, EmN, lambda, &mmu)) != eslOK) ESL_XFAIL(status, errbuf, "failed to determine msv mu");
if ((status = p7_ViterbiMu(r, om, bg, EvL, EvN, lambda, &vmu)) != eslOK) ESL_XFAIL(status, errbuf, "failed to determine vit mu");
if ((status = p7_Tau (r, om, bg, EfL, EfN, lambda, Eft, &tau)) != eslOK) ESL_XFAIL(status, errbuf, "failed to determine fwd tau");
/* Store results */
hmm->evparam[p7_MLAMBDA] = om->evparam[p7_MLAMBDA] = lambda;
hmm->evparam[p7_VLAMBDA] = om->evparam[p7_VLAMBDA] = lambda;
hmm->evparam[p7_FLAMBDA] = om->evparam[p7_FLAMBDA] = lambda;
hmm->evparam[p7_MMU] = om->evparam[p7_MMU] = mmu;
hmm->evparam[p7_VMU] = om->evparam[p7_VMU] = vmu;
hmm->evparam[p7_FTAU] = om->evparam[p7_FTAU] = tau;
hmm->flags |= p7H_STATS;
if (gm != NULL) {
gm->evparam[p7_MLAMBDA] = lambda;
gm->evparam[p7_VLAMBDA] = lambda;
gm->evparam[p7_FLAMBDA] = lambda;
gm->evparam[p7_MMU] = mmu;
gm->evparam[p7_VMU] = vmu;
gm->evparam[p7_FTAU] = tau;
}
if (byp_rng != NULL) *byp_rng = r; else esl_randomness_Destroy(r); /* bypass convention: no-op if rng was provided.*/
if (byp_bg != NULL) *byp_bg = bg; else p7_bg_Destroy(bg); /* bypass convention: no-op if bg was provided. */
if (byp_gm != NULL) *byp_gm = gm; else p7_profile_Destroy(gm); /* bypass convention: no-op if gm was provided. */
if (byp_om != NULL) *byp_om = om; else p7_oprofile_Destroy(om); /* bypass convention: no-op if om was provided. */
return eslOK;
ERROR:
if (! esl_byp_IsProvided(byp_rng)) esl_randomness_Destroy(r);
if (! esl_byp_IsProvided(byp_bg)) p7_bg_Destroy(bg);
if (! esl_byp_IsProvided(byp_gm)) p7_profile_Destroy(gm);
if (! esl_byp_IsProvided(byp_om)) p7_oprofile_Destroy(om);
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_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;
}
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 *gx1 = NULL;
P7_GMX *gx2 = NULL;
ESL_SQ *sq = NULL;
ESL_SQFILE *sqfp = NULL;
P7_TRACE *tr = NULL;
int format = eslSQFILE_UNKNOWN;
char errbuf[eslERRBUFSIZE];
float fsc, bsc, vsc;
float accscore;
int status;
/* 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_OpenDigital(abc, 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);
if (esl_sqio_Read(sqfp, sq) != eslOK) p7_Fail("Failed to read sequence");
esl_sqfile_Close(sqfp);
/* Configure a profile from the HMM */
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); /* multihit local: H3 default */
/* Allocations */
gx1 = p7_gmx_Create(gm->M, sq->n);
gx2 = p7_gmx_Create(gm->M, sq->n);
tr = p7_trace_CreateWithPP();
p7_FLogsumInit();
/* Run Forward, Backward; do OA fill and trace */
p7_GForward (sq->dsq, sq->n, gm, gx1, &fsc);
p7_GBackward(sq->dsq, sq->n, gm, gx2, &bsc);
p7_GDecoding(gm, gx1, gx2, gx2); /* <gx2> is now the posterior decoding matrix */
p7_GOptimalAccuracy(gm, gx2, gx1, &accscore); /* <gx1> is now the OA matrix */
p7_GOATrace(gm, gx2, gx1, tr);
if (esl_opt_GetBoolean(go, "-d")) p7_gmx_Dump(stdout, gx2, p7_DEFAULT);
if (esl_opt_GetBoolean(go, "-m")) p7_gmx_Dump(stdout, gx1, p7_DEFAULT);
p7_trace_Dump(stdout, tr, gm, sq->dsq);
if (p7_trace_Validate(tr, abc, sq->dsq, errbuf) != eslOK) p7_Die("trace fails validation:\n%s\n", errbuf);
printf("fwd = %.4f nats\n", fsc);
printf("bck = %.4f nats\n", bsc);
printf("acc = %.4f (%.2f%%)\n", accscore, accscore * 100. / (float) sq->n);
p7_trace_Reuse(tr);
p7_GViterbi(sq->dsq, sq->n, gm, gx1, &vsc);
p7_GTrace (sq->dsq, sq->n, gm, gx1, tr);
p7_trace_SetPP(tr, gx2);
p7_trace_Dump(stdout, tr, gm, sq->dsq);
printf("vit = %.4f nats\n", vsc);
printf("acc = %.4f\n", p7_trace_GetExpectedAccuracy(tr));
/* Cleanup */
esl_sq_Destroy(sq);
p7_trace_Destroy(tr);
p7_gmx_Destroy(gx1);
p7_gmx_Destroy(gx2);
p7_profile_Destroy(gm);
p7_bg_Destroy(bg);
p7_hmm_Destroy(hmm);
esl_alphabet_Destroy(abc);
esl_getopts_Destroy(go);
return 0;
}
