static int
save_bitfile(char *bitfile, ESL_RANDOMNESS *r, int n)
{
FILE *fp = NULL;
int b,i;
long x;
/* Open the file.
*/
if ((fp = fopen(bitfile, "w")) == NULL)
esl_fatal("failed to open %s for writing", bitfile);
/* Sample <n> random numbers, output 31n random bits to the file.
*/
for (i = 0; i < n; i++)
{
esl_random(r);
x = r->rnd; /* peek inside, get the 31 bit random long */
for (b = 0; b < 31; b++) /* don't print the sign bit. */
{
if (x & 01) fprintf(fp, "1");
else fprintf(fp, "0");
x >>= 1;
}
fprintf(fp, "\n");
}
fclose(fp);
return eslOK;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = NULL;
ESL_RANDOMNESS *r = NULL;
int be_verbose;
go = esl_getopts_Create(options);
if (esl_opt_ProcessCmdline(go, argc, argv) != eslOK ||
esl_opt_VerifyConfig(go) != eslOK) esl_fatal("%s", go->errbuf);
if (esl_opt_GetBoolean(go, "-h") == TRUE) {
esl_usage(stdout, argv[0], usage);
puts("\n where options are:");
esl_opt_DisplayHelp(stdout, go, 0, 2, 80); /* 0=all docgroups; 2=indentation; 80=width */
exit(0);
}
if (esl_opt_ArgNumber(go) != 0) {
printf("Incorrect number of command line arguments.\n");
esl_usage(stdout, argv[0], usage);
exit(1);
}
be_verbose = esl_opt_GetBoolean(go, "-v");
if (esl_opt_GetBoolean(go, "-r")) {
r = esl_randomness_CreateTimeseeded();
if (be_verbose) printf("seed = %ld\n", esl_randomness_GetSeed(r));
} else r = esl_randomness_Create(esl_opt_GetInteger(go, "-s"));
utest_LinearRegression(r, TRUE, be_verbose);
utest_LinearRegression(r, FALSE, be_verbose);
esl_getopts_Destroy(go);
esl_randomness_Destroy(r);
exit(0);
}
static void
emit_fancycons(ESL_GETOPTS *go, FILE *ofp, int outfmt, P7_HMM *hmm)
{
ESL_SQ *sq = NULL;
float minl = esl_opt_GetReal(go, "--minl");
float minu = esl_opt_GetReal(go, "--minu");
if ((sq = esl_sq_Create()) == NULL) esl_fatal("failed to allocate sequence");
if (p7_emit_FancyConsensus(hmm, minl, minu, sq) != eslOK) esl_fatal("failed to create consensus seq");
if (esl_sq_FormatName(sq, "%s-consensus", hmm->name) != eslOK) esl_fatal("failed to set sequence name");
if (esl_sqio_Write(ofp, sq, outfmt, FALSE) != eslOK) esl_fatal("failed to write sequence");
esl_sq_Destroy(sq);
return;
}
/* utest_basic()
* An MSA to ex{e,o}rcise past demons.
* 1. seq2 gives an I->end transition.
* 2. seq1 contains degenerate Z,X, exercising symbol counting
* of degenerate residues.
*/
static void
utest_basic(void)
{
char *failmsg = "failure in build.c::utest_basic() unit test";
char msafile[16] = "p7tmpXXXXXX"; /* tmpfile name template */
FILE *ofp = NULL;
ESL_ALPHABET *abc = esl_alphabet_Create(eslAMINO);
ESL_MSAFILE *afp = NULL;
ESL_MSA *msa = NULL;
P7_HMM *hmm = NULL;
float symfrac = 0.5;
if (esl_tmpfile_named(msafile, &ofp) != eslOK) esl_fatal(failmsg);
fprintf(ofp, "# STOCKHOLM 1.0\n");
fprintf(ofp, "#=GC RF --xxxxxxxxxxxxxxxx-xxx-x--\n");
fprintf(ofp, "seq1 --ACDEFGHIKLMNPZXS-TVW-Yyy\n");
fprintf(ofp, "seq2 aaACDEFGHIKLMNPQRS-TVWw---\n");
fprintf(ofp, "seq3 aaAC-EFGHIKLMNPQRS-TVW-Y--\n");
fprintf(ofp, "seq4 aaAC-EFGHIKLMNPQRS-TVW-Y--\n");
fprintf(ofp, "//\n");
fclose(ofp);
if (esl_msafile_Open(&abc, msafile, NULL, eslMSAFILE_UNKNOWN, NULL, &afp) != eslOK) esl_fatal(failmsg);
if (esl_msafile_Read(afp, &msa) != eslOK) esl_fatal(failmsg);
if (p7_Fastmodelmaker(msa, symfrac, NULL, &hmm, NULL) != eslOK) esl_fatal(failmsg);
p7_hmm_Destroy(hmm);
esl_msa_Destroy(msa);
esl_msafile_Close(afp);
esl_alphabet_Destroy(abc);
remove(msafile);
return;
}
static void
utest_normalization(ESL_GETOPTS *go)
{
char *msg = "seqmodel normalization utest failed";
ESL_ALPHABET *abc = esl_alphabet_Create(eslAMINO);
char *seq = "ACDEFGHIKLMNPQRSTVWYBJZOUX";
int L = strlen(seq);
ESL_DSQ *dsq = NULL;
float popen = 0.1;
float pextend = 0.4;
P7_BUILDER *bld = NULL;
P7_BG *bg = p7_bg_Create(abc);
P7_HMM *hmm = NULL;
char errbuf[eslERRBUFSIZE];
if ( esl_abc_CreateDsq(abc, seq, &dsq) != eslOK) esl_fatal(msg);
if ( (bld = p7_builder_Create(NULL, abc)) == NULL) esl_fatal(msg);
if ( p7_builder_LoadScoreSystem(bld, "BLOSUM62", popen, pextend, bg) != eslOK) esl_fatal(msg);
if ( p7_Seqmodel(abc, dsq, L, "aatest", bld->Q, bg->f, bld->popen, bld->pextend, &hmm) != eslOK) esl_fatal(msg);
if (p7_hmm_Validate(hmm, errbuf, 0.0001) != eslOK) esl_fatal("normalization utest failed\n%s\n", errbuf);
free(dsq);
p7_bg_Destroy(bg);
p7_hmm_Destroy(hmm);
p7_builder_Destroy(bld);
esl_alphabet_Destroy(abc);
}
/* regurgitate_one_stockholm_entry()
* Read and output an alignment line-by-line without parsing it, stopping when
* we reach the end-of-alignment marker.
*/
static void
regurgitate_one_stockholm_entry(FILE *ofp, ESLX_MSAFILE *afp)
{
char *p;
esl_pos_t n;
int status;
while ( (status = eslx_msafile_GetLine(afp, &p, &n)) == eslOK)
{
fwrite(p, sizeof(char), n, ofp);
fputs("\n", ofp);
if (esl_memstrpfx(p, n, "//")) break;
}
if (status == eslEOF) esl_fatal("Reached end of file before finding // termination line for alignment");
else if (status != eslOK) esl_fatal("Failure in reading alignment line by line");
}
/* ViterbiScore() unit test
*
* We can compare these scores to GViterbi() almost exactly; the only
* differences should be negligible roundoff errors. Must convert
* the optimized profile to lspace, though, rather than pspace.
*/
static void
utest_viterbi_score(ESL_RANDOMNESS *r, ESL_ALPHABET *abc, P7_BG *bg, int M, int L, int N)
{
P7_HMM *hmm = NULL;
P7_PROFILE *gm = NULL;
P7_OPROFILE *om = NULL;
ESL_DSQ *dsq = malloc(sizeof(ESL_DSQ) * (L+2));
P7_OMX *ox = p7_omx_Create(M, 0, 0);
P7_GMX *gx = p7_gmx_Create(M, L);
float sc1, sc2;
p7_oprofile_Sample(r, abc, bg, M, L, &hmm, &gm, &om);
p7_oprofile_Logify(om);
while (N--)
{
esl_rsq_xfIID(r, bg->f, abc->K, L, dsq);
p7_ViterbiScore(dsq, L, om, ox, &sc1);
p7_GViterbi (dsq, L, gm, gx, &sc2);
if (fabs(sc1-sc2) > 0.001) esl_fatal("viterbi score unit test failed: scores differ");
}
free(dsq);
p7_hmm_Destroy(hmm);
p7_omx_Destroy(ox);
p7_gmx_Destroy(gx);
p7_profile_Destroy(gm);
p7_oprofile_Destroy(om);
}
int
main(void)
{
ESL_STOPWATCH *w = NULL;
ESL_DMATRIX *Q = NULL;
ESL_DMATRIX *P = NULL;
double t = 5.0;
int esl_iterations = 100;
int i;
#ifdef HAVE_LIBGSL
gsl_matrix *Qg = NULL;
gsl_matrix *Pg = NULL;
int gsl_iterations = 100;
#endif
w = esl_stopwatch_Create();
Q = esl_dmatrix_Create(20, 20);
P = esl_dmatrix_Create(20, 20);
esl_rmx_SetWAG(Q, NULL);
esl_stopwatch_Start(w);
for (i = 0; i < esl_iterations; i++)
esl_dmx_Exp(Q, t, P);
esl_stopwatch_Stop(w);
printf("Easel takes: %g sec\n", w->user / (double) esl_iterations);
#ifdef HAVE_LIBGSL
if (esl_dmx_MorphGSL(Q, &Qg) != eslOK) esl_fatal("morph to gsl_matrix failed");
if ((Pg = gsl_matrix_alloc(20, 20)) == NULL) esl_fatal("gsl alloc failed");
gsl_matrix_scale(Qg, t);
esl_stopwatch_Start(w);
for (i = 0; i < gsl_iterations; i++)
gsl_linalg_exponential_ss(Qg, Pg, GSL_PREC_DOUBLE);
esl_stopwatch_Stop(w);
printf(" GSL takes: %g sec\n", w->user / (double) gsl_iterations);
gsl_matrix_free(Qg);
gsl_matrix_free(Pg);
#endif /*HAVE_LIBGSL*/
esl_dmatrix_Destroy(Q);
esl_dmatrix_Destroy(P);
esl_stopwatch_Destroy(w);
return 0;
}
static void
utest_goodfile(char *filename, int testnumber, int expected_alphatype, int expected_nseq, int expected_alen)
{
ESL_ALPHABET *abc = NULL;
ESL_MSAFILE *afp = NULL;
ESL_MSA *msa1 = NULL;
ESL_MSA *msa2 = NULL;
char tmpfile1[32] = "esltmpXXXXXX";
char tmpfile2[32] = "esltmpXXXXXX";
FILE *ofp = NULL;
int status;
/* A2M must be specified (no format guessing, unless we use .a2m suffix) but guessing the alphabet should work: this is a digital open */
if ( (status = esl_msafile_Open(&abc, filename, NULL, eslMSAFILE_A2M, NULL, &afp)) != eslOK) esl_fatal("a2m good file test %d failed: digital open", testnumber);
if (afp->format != eslMSAFILE_A2M) esl_fatal("a2m good file test %d failed: bad format", testnumber);
if (abc->type != expected_alphatype) esl_fatal("a2m good file test %d failed: alphabet autodetection", testnumber);
/* This is a digital read, using <abc>. */
if ( (status = esl_msafile_a2m_Read(afp, &msa1)) != eslOK) esl_fatal("a2m good file test %d failed: msa read, digital", testnumber);
if (msa1->nseq != expected_nseq || msa1->alen != expected_alen) esl_fatal("a2m good file test %d failed: nseq/alen", testnumber);
if (esl_msa_Validate(msa1, NULL) != eslOK) esl_fatal("a2m good file test %d failed: msa invalid", testnumber);
esl_msafile_Close(afp);
/* write it back out to a new tmpfile (digital write) */
if ( (status = esl_tmpfile_named(tmpfile1, &ofp)) != eslOK) esl_fatal("a2m good file test %d failed: tmpfile creation", testnumber);
if ( (status = esl_msafile_a2m_Write(ofp, msa1)) != eslOK) esl_fatal("a2m good file test %d failed: msa write, digital", testnumber);
fclose(ofp);
/* now open and read it as text mode, in known format. */
if ( (status = esl_msafile_Open(NULL, tmpfile1, NULL, eslMSAFILE_A2M, NULL, &afp)) != eslOK) esl_fatal("a2m good file test %d failed: text mode open", testnumber);
if ( (status = esl_msafile_a2m_Read(afp, &msa2)) != eslOK) esl_fatal("a2m good file test %d failed: msa read, text", testnumber);
if (msa2->nseq != expected_nseq || msa2->alen != expected_alen) esl_fatal("a2m good file test %d failed: nseq/alen", testnumber);
if (esl_msa_Validate(msa2, NULL) != eslOK) esl_fatal("a2m good file test %d failed: msa invalid", testnumber);
esl_msafile_Close(afp);
/* write it back out to a new tmpfile (text write) */
if ( (status = esl_tmpfile_named(tmpfile2, &ofp)) != eslOK) esl_fatal("a2m good file test %d failed: tmpfile creation", testnumber);
if ( (status = esl_msafile_a2m_Write(ofp, msa2)) != eslOK) esl_fatal("a2m good file test %d failed: msa write, text", testnumber);
fclose(ofp);
esl_msa_Destroy(msa2);
/* open and read it in digital mode */
if ( (status = esl_msafile_Open(&abc, tmpfile1, NULL, eslMSAFILE_A2M, NULL, &afp)) != eslOK) esl_fatal("a2m good file test %d failed: 2nd digital mode open", testnumber);
if ( (status = esl_msafile_a2m_Read(afp, &msa2)) != eslOK) esl_fatal("a2m good file test %d failed: 2nd digital msa read", testnumber);
if (esl_msa_Validate(msa2, NULL) != eslOK) esl_fatal("a2m good file test %d failed: msa invalid", testnumber);
esl_msafile_Close(afp);
/* this msa <msa2> should be identical to <msa1> */
if (esl_msa_Compare(msa1, msa2) != eslOK) esl_fatal("a2m good file test %d failed: msa compare", testnumber);
remove(tmpfile1);
remove(tmpfile2);
esl_msa_Destroy(msa1);
esl_msa_Destroy(msa2);
esl_alphabet_Destroy(abc);
}
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;
}
/* The MSV score can be validated against Viterbi (provided we trust
* Viterbi), by creating a multihit local profile in which:
* 1. All t_MM scores = 0
* 2. All other core transitions = -inf
* 3. All t_BMk entries uniformly log 2/(M(M+1))
*/
static void
utest_msv(ESL_GETOPTS *go, ESL_RANDOMNESS *r, ESL_ALPHABET *abc, P7_BG *bg, P7_PROFILE *gm, int nseq, int L)
{
P7_PROFILE *g2 = NULL;
ESL_DSQ *dsq = NULL;
P7_GMX *gx = NULL;
float sc1, sc2;
int k, idx;
if ((dsq = malloc(sizeof(ESL_DSQ) *(L+2))) == NULL) esl_fatal("malloc failed");
if ((gx = p7_gmx_Create(gm->M, L)) == NULL) esl_fatal("matrix creation failed");
if ((g2 = p7_profile_Clone(gm)) == NULL) esl_fatal("profile clone failed");
/* Make g2's scores appropriate for simulating the MSV algorithm in Viterbi */
esl_vec_FSet(g2->tsc, p7P_NTRANS * g2->M, -eslINFINITY);
for (k = 1; k < g2->M; k++) p7P_TSC(g2, k, p7P_MM) = 0.0f;
for (k = 0; k < g2->M; k++) p7P_TSC(g2, k, p7P_BM) = log(2.0f / ((float) g2->M * (float) (g2->M+1)));
for (idx = 0; idx < nseq; idx++)
{
if (esl_rsq_xfIID(r, bg->f, abc->K, L, dsq) != eslOK) esl_fatal("seq generation failed");
if (p7_GMSV (dsq, L, gm, gx, 2.0, &sc1) != eslOK) esl_fatal("MSV failed");
if (p7_GViterbi(dsq, L, g2, gx, &sc2) != eslOK) esl_fatal("viterbi failed");
if (fabs(sc1-sc2) > 0.0001) esl_fatal("MSV score not equal to Viterbi score");
}
p7_gmx_Destroy(gx);
p7_profile_Destroy(g2);
free(dsq);
return;
}
/* Open the source sequence database for negative subseqs;
* upon return, cfg->dbfp is open (digital, SSI indexed);
* cfg->db_maxL and cfg->db_nseq are set.
*/
static int
process_dbfile(struct cfg_s *cfg, char *dbfile, int dbfmt)
{
ESL_SQ *sq = esl_sq_CreateDigital(cfg->abc);
int status;
/* Open the sequence file in digital mode */
status = esl_sqfile_OpenDigital(cfg->abc, dbfile, dbfmt, NULL, &(cfg->dbfp));
if (status == eslENOTFOUND) esl_fatal("No such file %s", dbfile);
else if (status == eslEFORMAT) esl_fatal("Format of seqfile %s unrecognized.", dbfile);
else if (status == eslEINVAL) esl_fatal("Can't autodetect stdin or .gz.");
else if (status != eslOK) esl_fatal("Open failed, code %d.", status);
/* Read info on each sequence */
cfg->db_nseq = 0;
cfg->db_maxL = 0;
while ((status = esl_sqio_ReadInfo(cfg->dbfp, sq)) == eslOK) {
cfg->db_maxL = ESL_MAX(sq->L, cfg->db_maxL);
cfg->db_nseq++;
esl_sq_Reuse(sq);
}
if (status != eslEOF) esl_fatal("Something went wrong with reading the seq db");
/* Open SSI index */
if (esl_sqfile_OpenSSI(cfg->dbfp, NULL) != eslOK) esl_fatal("Failed to open SSI index file");
if (cfg->dbfp->data.ascii.ssi->nprimary != cfg->db_nseq) esl_fatal("oops, nprimary != nseq");
esl_sq_Destroy(sq);
return eslOK;
}
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;
}
int
main(int argc, char **argv)
{
char *bgfile = argv[1];
char *alphabet = argv[2];
ESL_ALPHABET *abc = esl_alphabet_Create(esl_abc_EncodeType(alphabet));
P7_BG *bg = p7_bg_Create(abc);
char errbuf[eslERRBUFSIZE];
int status;
status = p7_bg_Read(bgfile, bg, errbuf);
if (status == eslENOTFOUND) esl_fatal("open failed: %s", errbuf);
else if (status == eslEFORMAT) esl_fatal("parse failed: %s", errbuf);
else if (status != eslOK) esl_fatal("failed to read bg file %s (error %d)\n", bgfile, status);
p7_bg_Write(stdout, bg);
return 0;
}
static void
read_test_msas_text(char *a2mfile, char *stkfile)
{
char msg[] = "A2M msa text-mode read unit test failed";
ESL_MSAFILE *afp1 = NULL;
ESL_MSAFILE *afp2 = NULL;
ESL_MSA *msa1, *msa2, *msa3, *msa4;
FILE *a2mfp, *stkfp;
char a2mfile2[32] = "esltmpa2m2XXXXXX";
char stkfile2[32] = "esltmpstk2XXXXXX";
/* vvvv-- everything's the same as the digital utest except these NULLs */
if ( esl_msafile_Open(NULL, a2mfile, NULL, eslMSAFILE_A2M, NULL, &afp1) != eslOK) esl_fatal(msg);
if ( esl_msafile_Open(NULL, stkfile, NULL, eslMSAFILE_STOCKHOLM, NULL, &afp2) != eslOK) esl_fatal(msg);
if ( esl_msafile_a2m_Read (afp1, &msa1) != eslOK) esl_fatal(msg);
if ( esl_msafile_stockholm_Read(afp2, &msa2) != eslOK) esl_fatal(msg);
if ( esl_msa_Compare(msa1, msa2) != eslOK) esl_fatal(msg);
if ( esl_msafile_a2m_Read (afp1, &msa3) != eslEOF) esl_fatal(msg);
if ( esl_msafile_stockholm_Read(afp2, &msa3) != eslEOF) esl_fatal(msg);
esl_msafile_Close(afp2);
esl_msafile_Close(afp1);
if ( esl_tmpfile_named(a2mfile2, &a2mfp) != eslOK) esl_fatal(msg);
if ( esl_tmpfile_named(stkfile2, &stkfp) != eslOK) esl_fatal(msg);
if ( esl_msafile_a2m_Write (a2mfp, msa2) != eslOK) esl_fatal(msg);
if ( esl_msafile_stockholm_Write(stkfp, msa1, eslMSAFILE_PFAM) != eslOK) esl_fatal(msg);
fclose(a2mfp);
fclose(stkfp);
if ( esl_msafile_Open(NULL, a2mfile2, NULL, eslMSAFILE_A2M, NULL, &afp1) != eslOK) esl_fatal(msg);
if ( esl_msafile_Open(NULL, stkfile2, NULL, eslMSAFILE_STOCKHOLM, NULL, &afp2) != eslOK) esl_fatal(msg);
if ( esl_msafile_a2m_Read (afp1, &msa3) != eslOK) esl_fatal(msg);
if ( esl_msafile_stockholm_Read(afp2, &msa4) != eslOK) esl_fatal(msg);
if ( esl_msa_Compare(msa3, msa4) != eslOK) esl_fatal(msg);
remove(a2mfile2);
remove(stkfile2);
esl_msafile_Close(afp2);
esl_msafile_Close(afp1);
esl_msa_Destroy(msa1);
esl_msa_Destroy(msa2);
esl_msa_Destroy(msa3);
esl_msa_Destroy(msa4);
}
int
main(int argc, char **argv)
{
char msg[] = "a2m MSA i/o module test driver failed";
ESL_GETOPTS *go = esl_getopts_CreateDefaultApp(options, 0, argc, argv, banner, usage);
char a2mfile[32] = "esltmpa2mXXXXXX";
char stkfile[32] = "esltmpstkXXXXXX";
FILE *a2mfp, *stkfp;
int testnumber;
int ngoodtests = 2;
char tmpfile[32];
FILE *ofp;
int expected_alphatype;
int expected_nseq;
int expected_alen;
if ( esl_tmpfile_named(a2mfile, &a2mfp) != eslOK) esl_fatal(msg);
if ( esl_tmpfile_named(stkfile, &stkfp) != eslOK) esl_fatal(msg);
write_test_msas(a2mfp, stkfp);
fclose(a2mfp);
fclose(stkfp);
read_test_msas_digital(a2mfile, stkfile);
read_test_msas_text (a2mfile, stkfile);
/* Various "good" files that should be parsed correctly */
for (testnumber = 1; testnumber <= ngoodtests; testnumber++)
{
strcpy(tmpfile, "esltmpXXXXXX");
if (esl_tmpfile_named(tmpfile, &ofp) != eslOK) esl_fatal(msg);
switch (testnumber) {
case 1: utest_write_good1 (ofp, &expected_alphatype, &expected_nseq, &expected_alen); break;
case 2: utest_write_good2 (ofp, &expected_alphatype, &expected_nseq, &expected_alen); break;
}
fclose(ofp);
utest_goodfile(tmpfile, testnumber, expected_alphatype, expected_nseq, expected_alen);
remove(tmpfile);
}
remove(a2mfile);
remove(stkfile);
esl_getopts_Destroy(go);
return 0;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = NULL; /* application configuration */
ESL_RANDOMNESS *r = NULL; /* random number generator */
FILE *ofp = NULL; /* data output stream */
int outfmt = eslSQFILE_FASTA;
/* Parse command line */
go = esl_getopts_Create(options);
if (esl_opt_ProcessCmdline(go, argc, argv) != eslOK)
cmdline_failure(argv[0], "Failed to parse command line: %s\n", go->errbuf);
if (esl_opt_VerifyConfig(go) != eslOK)
cmdline_failure(argv[0], "Error in app configuration: %s\n", go->errbuf);
if (esl_opt_GetBoolean(go, "-h") )
cmdline_help(argv[0], go);
/* Open the output data file, if any */
if (esl_opt_GetString(go, "-o") != NULL)
{
if ((ofp = fopen(esl_opt_GetString(go, "-o"), "w")) == NULL)
esl_fatal("Failed to open output file %s\n", esl_opt_GetString(go, "-o"));
}
else ofp = stdout;
/* Initialize */
r = esl_randomness_Create(esl_opt_GetInteger(go, "--seed"));
/* Hand off execution to one of the three modes */
if (esl_opt_GetBoolean(go, "-A")) /* Alignment shuffling */
{
if (esl_opt_ArgNumber(go) != 1)
cmdline_failure(argv[0], "Incorrect number of command line arguments.\n");
msa_shuffling(go, r, ofp, outfmt);
}
else if (esl_opt_GetBoolean(go, "-G")) /* Sequence generation */
{
if (esl_opt_ArgNumber(go) != 0)
cmdline_failure(argv[0], "Incorrect number of command line arguments.\n");
seq_generation(go, r, ofp, outfmt);
}
else if (esl_opt_GetBoolean(go, "-S")) /* Sequence shuffling */
{
if (esl_opt_ArgNumber(go) != 1)
cmdline_failure(argv[0], "Incorrect number of command line arguments.\n");
seq_shuffling(go, r, ofp, outfmt);
}
if (esl_opt_GetString(go, "-o") != NULL) fclose(ofp);
esl_randomness_Destroy(r);
esl_getopts_Destroy(go);
return 0;
}
static int
do_by_windows(ESL_GENCODE *gcode, ESL_GENCODE_WORKSTATE *wrk, ESL_SQFILE *sqfp)
{
ESL_SQ *sq = esl_sq_CreateDigital(gcode->nt_abc);
int windowsize = 4092; // can be any value, but a multiple of 3 makes most sense. windowsize can be +/-; + means reading top strand; - means bottom strand.
int contextsize = 2; // contextsize (adjacent window overlap) must be 2, or translation won't work properly.
int wstatus;
ESL_DASSERT1(( windowsize % 3 == 0 ));
while (( wstatus = esl_sqio_ReadWindow(sqfp, contextsize, windowsize, sq)) != eslEOF)
{
if (wstatus == eslEOD)
{
if ( (windowsize > 0 && wrk->do_watson) || (windowsize < 0 && wrk->do_crick))
esl_gencode_ProcessEnd(wrk, sq);
if (windowsize > 0 && ! wrk->do_crick) { esl_sq_Reuse(sq); continue; } // Don't switch to revcomp if we don't need do. Allows -W --watson to work on nonrewindable streams
if (windowsize < 0) esl_sq_Reuse(sq); // Do not Reuse the sq on the switch from watson to crick; ReadWindow needs sq->L
windowsize = -windowsize; // switch to other strand.
continue;
}
else if (wstatus == eslEFORMAT) esl_fatal("Parsing failed in sequence file %s:\n%s", sqfp->filename, esl_sqfile_GetErrorBuf(sqfp));
else if (wstatus == eslEINVAL) esl_fatal("Invalid residue(s) found in sequence file %s\n%s", sqfp->filename, esl_sqfile_GetErrorBuf(sqfp));
else if (wstatus != eslOK) esl_fatal("Unexpected error %d reading sequence file %s", wstatus, sqfp->filename);
/* If we're the first window in this input DNA sequence
* (or the first window in its revcomp), then initialize.
* sq->C is the actual context overlap; 0=1st window; 2 (i.e. C)= subsequent.
*/
if (sq->C == 0)
{
if (sq->n < 3) continue; // DNA sequence too short; skip it, don't even bother to revcomp, go to next sequence.
if ( (windowsize > 0 && wrk->do_watson) || (windowsize < 0 && wrk->do_crick))
esl_gencode_ProcessStart(gcode, wrk, sq);
}
if ( (windowsize > 0 && wrk->do_watson) || (windowsize < 0 && wrk->do_crick))
esl_gencode_ProcessPiece(gcode, wrk, sq);
}
esl_sq_Destroy(sq);
return eslOK;
}
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"));
int N = esl_opt_GetInteger(go, "-N");
P7_TOPHITS *h1 = NULL;
P7_TOPHITS *h2 = NULL;
P7_TOPHITS *h3 = NULL;
char name[] = "not_unique_name";
char acc[] = "not_unique_acc";
char desc[] = "Test description for the purposes of making the test driver allocate space";
double key;
int i;
fprintf(stderr, "## %s\n", argv[0]);
fprintf(stderr, "# rng seed = %" PRIu32 "\n", esl_randomness_GetSeed(r));
h1 = p7_tophits_Create(p7_TOPHITS_DEFAULT_INIT_ALLOC);
h2 = p7_tophits_Create(p7_TOPHITS_DEFAULT_INIT_ALLOC);
h3 = p7_tophits_Create(p7_TOPHITS_DEFAULT_INIT_ALLOC);
for (i = 0; i < N; i++)
{
key = esl_random(r);
tophits_Add(h1, name, acc, desc, key);
key = 10.0 * esl_random(r);
tophits_Add(h2, name, acc, desc, key);
key = 0.1 * esl_random(r);
tophits_Add(h3, name, acc, desc, key);
}
tophits_Add(h1, "last", NULL, NULL, -1.0);
tophits_Add(h1, "first", NULL, NULL, 20.0);
p7_tophits_SortBySortkey(h1);
if (strcmp(h1->hit[0]->name, "first") != 0) esl_fatal("sort failed (top is %s = %f)", h1->hit[0]->name, h1->hit[0]->sortkey);
if (strcmp(h1->hit[N+1]->name, "last") != 0) esl_fatal("sort failed (last is %s = %f)", h1->hit[N+1]->name, h1->hit[N+1]->sortkey);
p7_tophits_Merge(h1, h2);
if (strcmp(h1->hit[0]->name, "first") != 0) esl_fatal("after merge 1, sort failed (top is %s = %f)", h1->hit[0]->name, h1->hit[0]->sortkey);
if (strcmp(h1->hit[2*N+1]->name, "last") != 0) esl_fatal("after merge 1, sort failed (last is %s = %f)", h1->hit[2*N+1]->name, h1->hit[2*N+1]->sortkey);
p7_tophits_Merge(h3, h1);
if (strcmp(h3->hit[0]->name, "first") != 0) esl_fatal("after merge 2, sort failed (top is %s = %f)", h3->hit[0]->name, h3->hit[0]->sortkey);
if (strcmp(h3->hit[3*N+1]->name, "last") != 0) esl_fatal("after merge 2, sort failed (last is %s = %f)", h3->hit[3*N+1]->name, h3->hit[3*N+1]->sortkey);
if (p7_tophits_GetMaxNameLength(h3) != strlen(name)) esl_fatal("GetMaxNameLength() failed");
p7_tophits_Destroy(h1);
p7_tophits_Destroy(h2);
p7_tophits_Destroy(h3);
esl_randomness_Destroy(r);
esl_getopts_Destroy(go);
fprintf(stderr, "# status = ok\n");
return eslOK;
}
static void
pipeline_thread(void *arg)
{
int workeridx;
int status;
WORK_ITEM *item;
void *newItem;
WORKER_INFO *info;
ESL_THREADS *obj;
obj = (ESL_THREADS *) arg;
esl_threads_Started(obj, &workeridx);
info = (WORKER_INFO *) esl_threads_GetData(obj, workeridx);
status = esl_workqueue_WorkerUpdate(info->queue, NULL, &newItem);
if (status != eslOK) esl_fatal("Work queue worker failed");
/* loop until all blocks have been processed */
item = (WORK_ITEM *) newItem;
while (item->msa != NULL)
{
status = p7_Builder(info->bld, item->msa, info->bg, &item->hmm, NULL, NULL, NULL, &item->postmsa);
if (status != eslOK) p7_Fail("build failed: %s", info->bld->errbuf);
item->entropy = p7_MeanMatchRelativeEntropy(item->hmm, info->bg);
item->processed = TRUE;
status = esl_workqueue_WorkerUpdate(info->queue, item, &newItem);
if (status != eslOK) esl_fatal("Work queue worker failed");
item = (WORK_ITEM *) newItem;
}
status = esl_workqueue_WorkerUpdate(info->queue, item, NULL);
if (status != eslOK) esl_fatal("Work queue worker failed");
esl_threads_Finished(obj, workeridx);
return;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = esl_getopts_CreateDefaultApp(options, 1, argc, argv, banner, usage);
char *msafile = esl_opt_GetArg(go, 1);
ESL_ALPHABET *abc = NULL;
int infmt = eslMSAFILE_UNKNOWN;
ESLX_MSAFILE *afp = NULL;
ESL_MSA *msa = NULL;
FILE *ofp = stdout;
int nali = 0;
int namewidth;
double pid;
int nid, n;
int i,j;
int status;
/* allow user to assert the input MSA alphabet */
if (esl_opt_GetBoolean(go, "--rna")) abc = esl_alphabet_Create(eslRNA);
else if (esl_opt_GetBoolean(go, "--dna")) abc = esl_alphabet_Create(eslDNA);
else if (esl_opt_GetBoolean(go, "--amino")) abc = esl_alphabet_Create(eslAMINO);
/* allow user to assert the input MSA format */
if (esl_opt_IsOn(go, "--informat") &&
(infmt = eslx_msafile_EncodeFormat(esl_opt_GetString(go, "--informat"))) == eslMSAFILE_UNKNOWN)
esl_fatal("%s is not a valid MSA file format for --informat", esl_opt_GetString(go, "--informat"));
/* digital open */
if ( ( status = eslx_msafile_Open(&abc, msafile, NULL, infmt, NULL, &afp)) != eslOK)
eslx_msafile_OpenFailure(afp, status);
while ((status = eslx_msafile_Read(afp, &msa)) == eslOK)
{
nali++;
namewidth = esl_str_GetMaxWidth(msa->sqname, msa->nseq);
for (i = 0; i < msa->nseq; i++)
for (j = i+1; j < msa->nseq; j++)
{
esl_dst_XPairId(abc, msa->ax[i], msa->ax[j], &pid, &nid, &n);
fprintf(ofp, "%-*s %-*s %6.2f %6d %6d\n", namewidth, msa->sqname[i], namewidth, msa->sqname[j], pid*100.0, nid, n);
}
esl_msa_Destroy(msa);
}
if (nali == 0 || status != eslEOF) eslx_msafile_ReadFailure(afp, status);
eslx_msafile_Close(afp);
esl_alphabet_Destroy(abc);
esl_getopts_Destroy(go);
return 0;
}
static void
emit_alignment(ESL_GETOPTS *go, FILE *ofp, int outfmt, ESL_RANDOMNESS *r, P7_HMM *hmm)
{
ESL_MSA *msa = NULL;
ESL_SQ **sq = NULL;
P7_TRACE **tr = NULL;
int N = esl_opt_GetInteger(go, "-N");
int optflags = p7_ALL_CONSENSUS_COLS;
int i;
if ((tr = malloc(sizeof(P7_TRACE *) * N)) == NULL) esl_fatal("failed to allocate trace array");
if ((sq = malloc(sizeof(ESL_SQ *) * N)) == NULL) esl_fatal("failed to allocate seq array");
for (i = 0; i < N; i++)
{
if ((sq[i] = esl_sq_CreateDigital(hmm->abc)) == NULL) esl_fatal("failed to allocate seq");
if ((tr[i] = p7_trace_Create()) == NULL) esl_fatal("failed to allocate trace");
}
for (i = 0; i < N; i++)
{
if (p7_CoreEmit(r, hmm, sq[i], tr[i]) != eslOK) esl_fatal("Failed to emit sequence");
if (esl_sq_FormatName(sq[i], "%s-sample%d", hmm->name, i+1) != eslOK) esl_fatal("Failed to set sequence name\n");
}
p7_tracealign_Seqs(sq, tr, N, hmm->M, optflags, hmm, &msa);
eslx_msafile_Write(ofp, msa, outfmt);
for (i = 0; i < N; i++) p7_trace_Destroy(tr[i]); free(tr);
for (i = 0; i < N; i++) esl_sq_Destroy(sq[i]); free(sq);
esl_msa_Destroy(msa);
return;
}
/* utest_logf(): Test range/domain of logf */
static void
utest_logf(ESL_GETOPTS *go)
{
__m128 x; /* test input */
union { __m128 v; float x[4]; } r; /* test output */
/* Test IEEE754 specials:
* log(-inf) = NaN log(x<0) = NaN log(-0) = NaN
* log(0) = -inf log(inf) = inf log(NaN) = NaN
*/
x = _mm_set_ps(0.0, -0.0, -1.0, -eslINFINITY); /* set_ps() is in order 3 2 1 0 */
r.v = esl_sse_logf(x);
if (esl_opt_GetBoolean(go, "-v")) {
printf("logf");
esl_sse_dump_ps(stdout, x); printf(" ==> ");
esl_sse_dump_ps(stdout, r.v); printf("\n");
}
if (! isnan(r.x[0])) esl_fatal("logf(-inf) should be NaN");
if (! isnan(r.x[1])) esl_fatal("logf(-1) should be NaN");
if (! isnan(r.x[2])) esl_fatal("logf(-0) should be NaN");
if (! (r.x[3] < 0 && isinf(r.x[3]))) esl_fatal("logf(0) should be -inf");
x = _mm_set_ps(FLT_MAX, FLT_MIN, eslNaN, eslINFINITY);
r.v = esl_sse_logf(x);
if (esl_opt_GetBoolean(go, "-v")) {
printf("logf");
esl_sse_dump_ps(stdout, x); printf(" ==> ");
esl_sse_dump_ps(stdout, r.v); printf("\n");
}
if (! isinf(r.x[0])) esl_fatal("logf(inf) should be inf");
if (! isnan(r.x[1])) esl_fatal("logf(NaN) should be NaN");
}
/* The DChoose() and FChoose() unit tests.
*/
static void
utest_choose(ESL_RANDOMNESS *r, int n, int nbins, int be_verbose)
{
double *pd = NULL;
float *pf = NULL;
int *ct = NULL;
int i;
double X2, diff, exp, X2p;
if ((pd = malloc(sizeof(double) * nbins)) == NULL) esl_fatal("malloc failed");
if ((pf = malloc(sizeof(float) * nbins)) == NULL) esl_fatal("malloc failed");
if ((ct = malloc(sizeof(int) * nbins)) == NULL) esl_fatal("malloc failed");
/* Sample a random multinomial probability vector. */
if (esl_dirichlet_DSampleUniform(r, nbins, pd) != eslOK) esl_fatal("dirichlet sample failed");
esl_vec_D2F(pd, nbins, pf);
/* Sample observed counts using DChoose(). */
esl_vec_ISet(ct, nbins, 0);
for (i = 0; i < n; i++)
ct[esl_rnd_DChoose(r, pd, nbins)]++;
/* X^2 test on those observed counts. */
for (X2 = 0., i=0; i < nbins; i++) {
exp = (double) n * pd[i];
diff = (double) ct[i] - exp;
X2 += diff*diff/exp;
}
if (esl_stats_ChiSquaredTest(nbins, X2, &X2p) != eslOK) esl_fatal("chi square eval failed");
if (be_verbose) printf("DChoose(): \t%g\n", X2p);
if (X2p < 0.01) esl_fatal("chi squared test failed");
/* Repeat above for FChoose(). */
esl_vec_ISet(ct, nbins, 0);
for (i = 0; i < n; i++)
ct[esl_rnd_FChoose(r, pf, nbins)]++;
for (X2 = 0., i=0; i < nbins; i++) {
exp = (double) n * pd[i];
diff = (double) ct[i] - exp;
X2 += diff*diff/exp;
}
if (esl_stats_ChiSquaredTest(nbins, X2, &X2p) != eslOK) esl_fatal("chi square eval failed");
if (be_verbose) printf("FChoose(): \t%g\n", X2p);
if (X2p < 0.01) esl_fatal("chi squared test failed");
free(pd);
free(pf);
free(ct);
return;
}
/* Function: allocateSeqdata()
* Synopsis: ensure that space is allocated for the seqdata object
* in the FM-index metadata.
*/
int
allocateSeqdata (FM_METADATA *meta, ESL_SQ *sq, int numseqs, int *allocedseqs) {
int length;
int status = eslOK;
if (numseqs == *allocedseqs) { // either first allocation, or increase in size
*allocedseqs *= 4; // we've bumped up against allocation limit, double allocation.
ESL_REALLOC (meta->seq_data, *allocedseqs * sizeof(FM_SEQDATA));
if (meta->seq_data == NULL )
esl_fatal("unable to allocate memory to store FM meta data\n");
}
//allocate space for the name, source, acc, and desc of the sequence source for the block
length = strlen(sq->name);
meta->seq_data[numseqs].name_length = length;
ESL_ALLOC (meta->seq_data[numseqs].name, (1+length) * sizeof(char));
length = strlen(sq->acc);
meta->seq_data[numseqs].acc_length = length;
ESL_ALLOC (meta->seq_data[numseqs].acc, (1+length) * sizeof(char));
length = strlen(sq->source);
meta->seq_data[numseqs].source_length = length;
ESL_ALLOC (meta->seq_data[numseqs].source, (1+length) * sizeof(char));
length = strlen(sq->desc);
meta->seq_data[numseqs].desc_length = length;
ESL_ALLOC (meta->seq_data[numseqs].desc, (1+length) * sizeof(char));
if (meta->seq_data[numseqs].name == NULL || meta->seq_data[numseqs].acc == NULL || meta->seq_data[numseqs].source == NULL || meta->seq_data[numseqs].desc == NULL)
esl_fatal("unable to allocate memory to store FM meta data\n");
return eslOK;
ERROR:
return status;
}
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_BG *bg = NULL;
int M = esl_opt_GetInteger(go, "-M");
int L = esl_opt_GetInteger(go, "-L");
int N = esl_opt_GetInteger(go, "-N");
/* First round of tests for DNA alphabets. */
if ((abc = esl_alphabet_Create(eslDNA)) == NULL) esl_fatal("failed to create alphabet");
if ((bg = p7_bg_Create(abc)) == NULL) esl_fatal("failed to create null model");
if (esl_opt_GetBoolean(go, "-v")) printf("ViterbiFilter() tests, DNA\n");
utest_viterbi_filter(r, abc, bg, M, L, N);
utest_viterbi_filter(r, abc, bg, 1, L, 10);
utest_viterbi_filter(r, abc, bg, M, 1, 10);
esl_alphabet_Destroy(abc);
p7_bg_Destroy(bg);
/* Second round of tests for amino alphabets. */
if ((abc = esl_alphabet_Create(eslAMINO)) == NULL) esl_fatal("failed to create alphabet");
if ((bg = p7_bg_Create(abc)) == NULL) esl_fatal("failed to create null model");
if (esl_opt_GetBoolean(go, "-v")) printf("ViterbiFilter() tests, protein\n");
utest_viterbi_filter(r, abc, bg, M, L, N);
utest_viterbi_filter(r, abc, bg, 1, L, 10);
utest_viterbi_filter(r, abc, bg, M, 1, 10);
esl_alphabet_Destroy(abc);
p7_bg_Destroy(bg);
esl_getopts_Destroy(go);
esl_randomness_Destroy(r);
return eslOK;
}
/* The "generation" test scores sequences generated by the same profile.
* Each Viterbi and Forward score should be >= the trace score of the emitted seq.
* The expectation of Forward scores should be positive.
*/
static void
utest_generation(ESL_GETOPTS *go, ESL_RANDOMNESS *r, ESL_ALPHABET *abc,
P7_PROFILE *gm, P7_HMM *hmm, P7_BG *bg, int nseq)
{
ESL_SQ *sq = esl_sq_CreateDigital(abc);
P7_GMX *gx = p7_gmx_Create(gm->M, 100);
P7_TRACE *tr = p7_trace_Create();
float vsc, fsc, nullsc, tracesc;
float avg_fsc;
int idx;
avg_fsc = 0.0;
for (idx = 0; idx < nseq; idx++)
{
if (p7_ProfileEmit(r, hmm, gm, bg, sq, tr) != eslOK) esl_fatal("profile emission failed");
if (p7_gmx_GrowTo(gx, gm->M, sq->n) != eslOK) esl_fatal("failed to reallocate gmx");
if (p7_GViterbi(sq->dsq, sq->n, gm, gx, &vsc) != eslOK) esl_fatal("viterbi failed");
if (p7_GForward(sq->dsq, sq->n, gm, gx, &fsc) != eslOK) esl_fatal("forward failed");
if (p7_trace_Score(tr, sq->dsq, gm, &tracesc) != eslOK) esl_fatal("trace score failed");
if (p7_bg_NullOne(bg, sq->dsq, sq->n, &nullsc) != eslOK) esl_fatal("null score failed");
if (vsc < tracesc) esl_fatal("viterbi score is less than trace");
if (fsc < tracesc) esl_fatal("forward score is less than trace");
if (vsc > fsc) esl_fatal("viterbi score is greater than forward");
if (esl_opt_GetBoolean(go, "--vv"))
printf("generated: len=%d v=%8.4f f=%8.4f t=%8.4f\n", (int) sq->n, vsc, fsc, tracesc);
avg_fsc += (fsc - nullsc);
}
avg_fsc /= (float) nseq;
if (avg_fsc < 0.) esl_fatal("generation: Forward scores have negative expectation (%f nats)", avg_fsc);
p7_gmx_Destroy(gx);
p7_trace_Destroy(tr);
esl_sq_Destroy(sq);
}
/* compare results to GDecoding(). */
static void
utest_decoding(ESL_RANDOMNESS *r, ESL_ALPHABET *abc, P7_BG *bg, int M, int L, int N, float tolerance)
{
char *msg = "decoding unit test failed";
P7_HMM *hmm = NULL;
P7_PROFILE *gm = NULL;
P7_OPROFILE *om = NULL;
ESL_DSQ *dsq = malloc(sizeof(ESL_DSQ) * (L+2));
P7_OMX *fwd = p7_omx_Create(M, L, L);
P7_OMX *bck = p7_omx_Create(M, L, L);
P7_OMX *pp = p7_omx_Create(M, L, L);
P7_GMX *gxf = p7_gmx_Create(M, L);
P7_GMX *gxb = p7_gmx_Create(M, L);
P7_GMX *gxp2 = p7_gmx_Create(M, L);
float fsc1, fsc2;
float bsc1, bsc2;
if (p7_oprofile_Sample(r, abc, bg, M, L, &hmm, &gm, &om) != eslOK) esl_fatal(msg);
while (N--)
{
if (esl_rsq_xfIID(r, bg->f, abc->K, L, dsq) != eslOK) esl_fatal(msg);
if (p7_Forward (dsq, L, om, fwd, &fsc1) != eslOK) esl_fatal(msg);
if (p7_Backward (dsq, L, om, fwd, bck, &bsc1) != eslOK) esl_fatal(msg);
if (p7_Decoding(om, fwd, bck, pp) != eslOK) esl_fatal(msg);
if (p7_GForward (dsq, L, gm, gxf, &fsc2) != eslOK) esl_fatal(msg);
if (p7_GBackward(dsq, L, gm, gxb, &bsc2) != eslOK) esl_fatal(msg);
if (p7_GDecoding(gm, gxf, gxb, gxp2) != eslOK) esl_fatal(msg);
if (p7_gmx_Compare(pp, gxp2, tolerance) != eslOK) esl_fatal(msg);
}
p7_gmx_Destroy(gxp2);
p7_gmx_Destroy(gxf);
p7_gmx_Destroy(gxb);
p7_omx_Destroy(fwd);
p7_omx_Destroy(bck);
p7_omx_Destroy(pp);
free(dsq);
p7_oprofile_Destroy(om);
p7_profile_Destroy(gm);
p7_hmm_Destroy(hmm);
}
static void
utest_SendRecv(ESL_RANDOMNESS *rng, int my_rank, int nproc)
{
char msg[] = "utest_SendRecv() failed";
ESL_ALPHABET *abc = esl_alphabet_Create(eslAMINO);
P7_HMM *hmm = NULL;
P7_HMM *xhmm = NULL;
int M = 200;
char *wbuf = NULL;
int wn = 0;
int i;
uint32_t rngseed;
MPI_Status mpistatus;
char errmsg[eslERRBUFSIZE];
if (my_rank == 0)
{
/* First we send our RNG seed to all workers */
rngseed = esl_randomness_GetSeed(rng);
for (i = 1; i < nproc; i++)
if (MPI_Send( &rngseed, 1, MPI_UNSIGNED, i, 0, MPI_COMM_WORLD) != MPI_SUCCESS) esl_fatal(msg);
/* We sample an HMM that's going to be identical to the workers' */
if (p7_modelsample(rng, M, abc, &hmm) != eslOK) esl_fatal(msg);
for (i = 1; i < nproc; i++)
{
if (p7_hmm_mpi_Recv(MPI_ANY_SOURCE, 0, MPI_COMM_WORLD, &wbuf, &wn, &abc, &xhmm) != eslOK) esl_fatal(msg);
if (p7_hmm_Validate(xhmm, errmsg, 0.001) != eslOK) esl_fatal("%s:\n %s", msg, errmsg);
if (p7_hmm_Compare(hmm, xhmm, 0.001) != eslOK) esl_fatal(msg);
p7_hmm_Destroy(xhmm);
}
}
else
{
/* Worker(s) must first receive the exact same RNG seed that the master is using. */
if (MPI_Recv(&rngseed, 1, MPI_UNSIGNED, 0, 0, MPI_COMM_WORLD, &mpistatus) != MPI_SUCCESS) esl_fatal(msg);
/* and then the worker(s) can create the exact same RNG (and random number sequence) that the master has */
rng = esl_randomness_CreateFast(rngseed);
/* so when the worker samples this HMM, the master has independently sampled an exact duplicate of it... */
if (p7_modelsample(rng, M, abc, &hmm) != eslOK) esl_fatal(msg);
/* each worker sends the HMM to the master (it's the same HMM for each worker. The test is intended for one master, one worker.) */
if (p7_hmm_mpi_Send(hmm, 0, 0, MPI_COMM_WORLD, &wbuf, &wn) != eslOK) esl_fatal(msg);
/* worker's RNG is a private copy; destroy it. Master keeps its RNG, which the caller is responsible for. */
esl_randomness_Destroy(rng);
}
p7_hmm_Destroy(hmm);
esl_alphabet_Destroy(abc);
free(wbuf);
return;
}
/* utest_odds(): test accuracy of logf, expf on odds ratios,
* our main intended use.
*/
static void
utest_odds(ESL_GETOPTS *go, ESL_RANDOMNESS *r)
{
int N = esl_opt_GetInteger(go, "-N");
int verbose = esl_opt_GetBoolean(go, "-v");
int very_verbose = esl_opt_GetBoolean(go, "--vv");
int i;
float p1, p2, odds;
union {
__m128 v;
float x[4];
} r1;
union {
__m128 v;
float x[4];
} r2;
float scalar_r1, scalar_r2;
double err1, maxerr1 = 0.0, avgerr1 = 0.0; /* errors on logf() */
double err2, maxerr2 = 0.0, avgerr2 = 0.0; /* errors on expf() */
for (i = 0; i < N; i++)
{
p1 = esl_rnd_UniformPositive(r);
p2 = esl_rnd_UniformPositive(r);
odds = p1 / p2;
if (odds == 0.0) esl_fatal("whoa, odds ratio can't be 0!\n");
r1.v = esl_sse_logf(_mm_set1_ps(odds)); /* r1.x[z] = log(p1/p2) */
scalar_r1 = log(odds);
err1 = (r1.x[0] == 0. && scalar_r1 == 0.) ? 0.0 : 2 * fabs(r1.x[0] - scalar_r1) / fabs(r1.x[0] + scalar_r1);
if (err1 > maxerr1) maxerr1 = err1;
avgerr1 += err1 / (float) N;
if (isnan(avgerr1)) esl_fatal("whoa, what?\n");
r2.v = esl_sse_expf(r1.v); /* and back to odds */
scalar_r2 = exp(r1.x[0]);
err2 = (r2.x[0] == 0. && scalar_r2 == 0.) ? 0.0 : 2 * fabs(r2.x[0] - scalar_r2) / fabs(r2.x[0] + scalar_r2);
if (err2 > maxerr2) maxerr2 = err2;
avgerr2 += err2 / (float) N;
if (very_verbose)
printf("%13.7g %13.7g %13.7g %13.7g %13.7g %13.7g %13.7g\n", odds, scalar_r1, r1.x[0], scalar_r2, r2.x[0], err1, err2);
}
if (verbose) {
printf("Average [max] logf() relative error in %d odds trials: %13.8g [%13.8g]\n", N, avgerr1, maxerr1);
printf("Average [max] expf() relative error in %d odds trials: %13.8g [%13.8g]\n", N, avgerr2, maxerr2);
printf("(random seed : %" PRIu32 ")\n", esl_randomness_GetSeed(r));
}
if (avgerr1 > 1e-8) esl_fatal("average error on logf() is intolerable\n");
if (maxerr1 > 1e-6) esl_fatal("maximum error on logf() is intolerable\n");
if (avgerr2 > 1e-8) esl_fatal("average error on expf() is intolerable\n");
if (maxerr2 > 1e-6) esl_fatal("maximum error on expf() is intolerable\n");
}
