/* Fetch in a random sequence of length <L> from the the pre-digitized
* concatenated sequence database, select a random subseq, shuffle it
* by the chosen algorithm; set dsq[1..L] to the resulting randomized
* segment.
*
* If <logfp> is non-NULL, append one or more "<sqname> <from> <to>"
* fields to current line, to record where the random segment was
* selected from. This is useful in cases where we want to track back
* the origin of a high-scoring segment, in case the randomization
* wasn't good enough to obscure the identity of a segment.
*
*/
static int
set_random_segment(ESL_GETOPTS *go, struct cfg_s *cfg, FILE *logfp, ESL_DSQ *dsq, int L)
{
ESL_SQ *sq = esl_sq_CreateDigital(cfg->abc);
int minDPL = esl_opt_GetInteger(go, "--minDPL");
int db_dependent = (esl_opt_GetBoolean(go, "--iid") == TRUE ? FALSE : TRUE);
char *pkey = NULL;
int start, end;
int64_t Lseq;
int status;
if (L==0) return eslOK;
if (L > cfg->db_maxL) esl_fatal("can't fetch a segment of length %d; database max is %d\n", L, cfg->db_maxL);
/* fetch a random subseq from the source database */
esl_sq_GrowTo(sq, L);
if (db_dependent)
{
do {
if (pkey != NULL) free(pkey);
if (esl_ssi_FindNumber(cfg->dbfp->data.ascii.ssi, esl_rnd_Roll(cfg->r, cfg->db_nseq), NULL, NULL, NULL, &Lseq, &pkey) != eslOK)
esl_fatal("failed to look up a random seq");
} while (Lseq < L);
start = 1 + esl_rnd_Roll(cfg->r, Lseq-L);
end = start + L - 1;
if (esl_sqio_FetchSubseq(cfg->dbfp, pkey, start, end, sq) != eslOK) esl_fatal("failed to fetch subseq");
esl_sq_ConvertDegen2X(sq);
}
/* log sequence source info: <name> <start> <end> */
if (logfp != NULL && db_dependent)
fprintf(logfp, " %-15s %5d %5d", pkey, start, end);
/* Now apply the appropriate randomization algorithm */
if (esl_opt_GetBoolean(go, "--mono")) status = esl_rsq_XShuffle (cfg->r, sq->dsq, L, sq->dsq);
else if (esl_opt_GetBoolean(go, "--di")) {
if (L < minDPL) status = esl_rsq_XShuffle (cfg->r, sq->dsq, L, sq->dsq);
else status = esl_rsq_XShuffleDP(cfg->r, sq->dsq, L, cfg->abc->Kp, sq->dsq);
}
else if (esl_opt_GetBoolean(go, "--markov0")) status = esl_rsq_XMarkov0 (cfg->r, sq->dsq, L, cfg->abc->Kp, sq->dsq);
else if (esl_opt_GetBoolean(go, "--markov1")) status = esl_rsq_XMarkov1 (cfg->r, sq->dsq, L, cfg->abc->Kp, sq->dsq);
else if (esl_opt_GetBoolean(go, "--reverse")) status = esl_rsq_XReverse (sq->dsq, L, sq->dsq);
else if (esl_opt_GetBoolean(go, "--iid")) status = esl_rsq_xIID (cfg->r, cfg->fq, cfg->abc->K, L, sq->dsq);
else status = eslEINCONCEIVABLE;
if (status != eslOK) esl_fatal("esl's shuffling failed");
memcpy(dsq, sq->dsq+1, sizeof(ESL_DSQ) * L);
esl_sq_Destroy(sq);
free(pkey);
return eslOK;
}
/* Each test sequence will contain one or two domains, depending on whether --single is set.
*/
static int
synthesize_positives(ESL_GETOPTS *go, struct cfg_s *cfg, char *testname, ESL_STACK *teststack, int *ret_ntest)
{
ESL_SQ *domain1, *domain2;
ESL_SQ *sq;
void *p;
int64_t L; /* total length of synthetic test seq */
int d1n, d2n; /* lengths of two domains */
int L1,L2,L3; /* lengths of three random regions */
int i,j;
int ntest = 0;
int ndomains = ( (esl_opt_GetBoolean(go, "--single") == TRUE) ? 1 : 2);
int status;
while (esl_stack_ObjectCount(teststack) >= ndomains)
{
ESL_RALLOC(cfg->test_lens, p, (cfg->ntest+1) * sizeof(struct testseq_s));
/* Pop our one or two test domains off the stack */
esl_stack_PPop(teststack, &p);
domain1 = p;
d1n = domain1->n;
if (ndomains == 2)
{
esl_stack_PPop(teststack, &p);
domain2 = p;
d2n = domain2->n;
}
else
{
domain2 = NULL;
d2n = 0;
}
/* Select a random total sequence length */
if (d1n+d2n > cfg->db_maxL) esl_fatal("can't construct test seq; no db seq >= %d residues\n", d1n+d2n);
do {
if (esl_ssi_FindNumber(cfg->dbfp->data.ascii.ssi, esl_rnd_Roll(cfg->r, cfg->db_nseq), NULL, NULL, NULL, &L, NULL) != eslOK)
esl_fatal("failed to look up a random seq");
} while (L < d1n+d2n);
/* Now figure out the embedding */
if (ndomains == 2)
{
/* Select random lengths of three flanking domains;
* Imagine picking two "insert after" points i,j in sequence 1..L', for
* L' = L-d1n-d2n (the total length of nonhomologous test seq)
*/
do {
i = esl_rnd_Roll(cfg->r, L - d1n - d2n + 1 ); /* i = 0..L' */
j = esl_rnd_Roll(cfg->r, L - d1n - d2n + 1 ); /* j = 0..L' */
} while (i > j);
/* now 1 .. i = random region 1 (if i==0, there's none);
* i+1 .. i+d1n = domain 1
* i+d1n+1 .. j+d1n = random region 2 (if i==j, there's none);
* j+d1n+1 .. j+d1n+d2n = domain 2
* j+d1n+d2n+1 .. L = random region 3 (if j == L-d1n-d2n, there's none);
*/
L1 = i;
L2 = j-i;
L3 = L - d1n - d2n - j;
}
else
{ /* embedding one domain */
i = esl_rnd_Roll(cfg->r, L - d1n + 1 ); /* i = 0..L' */
/* now 1 .. i = random region 1 (if i==0, there's none);
* i+1 .. i+d1n = domain 1
* i+d1n+1 .. L = random region 2 (if i==j, there's none);
*/
L1 = i;
L2 = L - d1n - L1;
L3 = 0;
}
sq = esl_sq_CreateDigital(cfg->abc);
esl_sq_GrowTo(sq, L);
sq->n = L;
if (ndomains == 2)
{
esl_sq_FormatName(sq, "%s/%d/%d-%d/%d-%d", testname, cfg->ntest, i+1, i+d1n, j+d1n+1, j+d1n+d2n);
esl_sq_FormatDesc(sq, "domains: %s %s", domain1->name, domain2->name);
}
else
{
esl_sq_FormatName(sq, "%s/%d/%d-%d", testname, cfg->ntest, i+1, i+d1n);
esl_sq_FormatDesc(sq, "domain: %s", domain1->name);
}
fprintf(cfg->possummfp, "%-35s %5d %5d %5d %5d %5d %5d", sq->name, (int) sq->n, L1, d1n, L2, d2n, L3);
sq->dsq[0] = sq->dsq[L+1] = eslDSQ_SENTINEL;
set_random_segment(go, cfg, cfg->possummfp, sq->dsq+1, L1);
memcpy(sq->dsq+i+1, domain1->dsq+1, sizeof(ESL_DSQ) * d1n);
fprintf(cfg->possummfp, " %-24s %5d %5d", domain1->name, 1, d1n);
set_random_segment(go, cfg, cfg->possummfp, sq->dsq+i+d1n+1, L2);
if (ndomains == 2)
{
memcpy(sq->dsq+j+d1n+1, domain2->dsq+1, sizeof(ESL_DSQ) * d2n);
fprintf(cfg->possummfp, " %-24s %5d %5d", domain2->name, 1, d2n);
set_random_segment(go, cfg, cfg->possummfp, sq->dsq+j+d1n+d2n+1, L3);
}
fprintf(cfg->possummfp, "\n");
cfg->test_lens[cfg->ntest].L = L;
cfg->test_lens[cfg->ntest].L1 = L1;
cfg->test_lens[cfg->ntest].d1n = d1n;
cfg->test_lens[cfg->ntest].L2 = L2;
cfg->test_lens[cfg->ntest].d2n = d2n;
cfg->test_lens[cfg->ntest].L3 = L3;
cfg->ntest++;
ntest++;
esl_sqio_Write(cfg->out_seqfp, sq, eslSQFILE_FASTA, FALSE);
esl_sq_Destroy(domain1);
if (ndomains == 2) esl_sq_Destroy(domain2);
esl_sq_Destroy(sq);
}
*ret_ntest = ntest;
return eslOK;
ERROR:
esl_fatal("Failure in synthesize_positives");
return status;
}
