static GtUchar bambase2gtbase(uint8_t base, GtAlphabet *alphabet)
{
switch (base)
{
case BAMBASEA:
return gt_alphabet_encode(alphabet, 'A');
case BAMBASEC:
return gt_alphabet_encode(alphabet, 'C');
case BAMBASEG:
return gt_alphabet_encode(alphabet, 'G');
case BAMBASET:
return gt_alphabet_encode(alphabet, 'T');
default:
return gt_alphabet_encode(alphabet,
(char) gt_alphabet_wildcard_show(alphabet));
}
}
static int gt_linspace_align_runner(GT_UNUSED int argc,
GT_UNUSED const char **argv,
GT_UNUSED int parsed_args,
void *tool_arguments,
GtError *err)
{
GtLinspaceArguments *arguments = tool_arguments;
int had_err = 0;
GtAlignment *align;
GtWord left_dist = 0, right_dist = 0;
GtSequenceTable *sequence_table1, *sequence_table2;
GtLinspaceManagement *spacemanager;
GtScoreHandler *scorehandler = NULL;
GtTimer *linspacetimer = NULL;
GtAlphabet *alphabet = NULL;
gt_error_check(err);
gt_assert(arguments);
sequence_table1 = gt_sequence_table_new();
sequence_table2 = gt_sequence_table_new();
align = gt_alignment_new();
spacemanager = gt_linspace_management_new();
gt_linspace_management_set_TSfactor(spacemanager,arguments->timesquarefactor);
/* get sequences */
if (gt_str_array_size(arguments->strings) > 0)
{
get_onesequence(sequence_table1, arguments->strings, 0);
sequence_table1->size++;
get_onesequence(sequence_table2, arguments->strings, 1);
sequence_table2->size++;
}
else if (gt_str_array_size(arguments->files) > 0)
{
had_err = get_fastasequences(sequence_table1,
gt_str_array_get_str(arguments->files,0),err);
if (!had_err)
{
had_err = get_fastasequences(sequence_table2,
gt_str_array_get_str(arguments->files,1),err);
}
}
if (arguments->dna)
{
alphabet = gt_alphabet_new_dna();
} else
{
gt_assert(arguments->protein);
alphabet = gt_alphabet_new_protein();
}
gt_encode_sequence_table(alphabet,sequence_table1);
gt_encode_sequence_table(alphabet,sequence_table2);
if (!had_err)
{
scorehandler = gt_arguments2scorehandler(arguments,err);
if (scorehandler == NULL)
{
had_err = -1;
} else
{
if (arguments->global && arguments->protein && !arguments->has_costmatrix)
{
GtScoreHandler *costhandler = gt_scorehandler2costhandler(scorehandler);
gt_scorehandler_delete(scorehandler);
scorehandler = costhandler;
}
}
}
/* get diagonal band */
if (!had_err && arguments->diagonal)
{
if (gt_str_array_size(arguments->diagonalbonds) > 0)
{
had_err = gt_parse_score_value(__LINE__,&left_dist,
gt_str_array_get(arguments->diagonalbonds,0),
false, err);
if (!had_err)
{
had_err = gt_parse_score_value(__LINE__,&right_dist,
gt_str_array_get(arguments->diagonalbonds,1),
false, err);
}
}
}
if (!had_err && arguments->spacetime)
{
linspacetimer = gt_timer_new();
}
/* alignment functions with linear gap costs */
if (!had_err)
{
bool affine;
if (gt_str_array_size(arguments->linearcosts) > 0)
{
affine = false;
} else
{
gt_assert(gt_str_array_size(arguments->affinecosts) > 0);
affine = true;
}
had_err = gt_all_against_all_alignment_check (
affine, align, arguments,
spacemanager,
scorehandler,
gt_alphabet_characters(alphabet),
gt_alphabet_wildcard_show(alphabet),
sequence_table1,
sequence_table2,
left_dist,
right_dist,
linspacetimer,err);
}
/*spacetime option*/
if (!had_err && arguments->spacetime)
{
printf("# combined space peak in kilobytes: %f\n",
GT_KILOBYTES(gt_linspace_management_get_spacepeak(spacemanager)));
gt_timer_show_formatted(linspacetimer,"# TIME overall " GT_WD ".%02ld\n",
stdout);
}
gt_timer_delete(linspacetimer);
gt_linspace_management_delete(spacemanager);
gt_sequence_table_delete(sequence_table1);
gt_sequence_table_delete(sequence_table2);
gt_alignment_delete(align);
gt_alphabet_delete(alphabet);
gt_scorehandler_delete(scorehandler);
return had_err;
}
int gt_runidxlocali(const IdxlocaliOptions *idxlocalioptions,GtError *err)
{
Genericindex *genericindex = NULL;
bool haserr = false;
GtLogger *logger;
const GtEncseq *encseq = NULL;
logger = gt_logger_new(idxlocalioptions->verbose,
GT_LOGGER_DEFLT_PREFIX, stdout);
if (idxlocalioptions->doonline)
{
GtEncseqLoader *el;
el = gt_encseq_loader_new();
gt_encseq_loader_require_multiseq_support(el);
gt_encseq_loader_drop_description_support(el);
gt_encseq_loader_set_logger(el, logger);
encseq = gt_encseq_loader_load(el, gt_str_get(idxlocalioptions->indexname),
err);
gt_encseq_loader_delete(el);
if (encseq == NULL)
{
haserr = true;
}
} else
{
genericindex = genericindex_new(gt_str_get(idxlocalioptions->indexname),
idxlocalioptions->withesa,
idxlocalioptions->withesa ||
idxlocalioptions->docompare,
false,
true,
0,
logger,
err);
if (genericindex == NULL)
{
haserr = true;
} else
{
encseq = genericindex_getencseq(genericindex);
}
}
if (!haserr)
{
GtSeqIterator *seqit;
const GtUchar *query;
unsigned long querylen;
char *desc = NULL;
int retval;
Limdfsresources *limdfsresources = NULL;
const AbstractDfstransformer *dfst;
SWdpresource *swdpresource = NULL;
Showmatchinfo showmatchinfo;
ProcessIdxMatch processmatch;
GtAlphabet *a;
void *processmatchinfoonline, *processmatchinfooffline;
Storematchinfo storeonline, storeoffline;
a = gt_encseq_alphabet(encseq);
if (idxlocalioptions->docompare)
{
processmatch = storematch;
gt_initstorematch(&storeonline,encseq);
gt_initstorematch(&storeoffline,encseq);
processmatchinfoonline = &storeonline;
processmatchinfooffline = &storeoffline;
} else
{
processmatch = showmatch;
showmatchinfo.encseq = encseq;
showmatchinfo.characters = gt_alphabet_characters(a);
showmatchinfo.wildcardshow = gt_alphabet_wildcard_show(a);
showmatchinfo.showalignment = idxlocalioptions->showalignment;
processmatchinfoonline = processmatchinfooffline = &showmatchinfo;
}
if (idxlocalioptions->doonline || idxlocalioptions->docompare)
{
swdpresource = gt_newSWdpresource(idxlocalioptions->matchscore,
idxlocalioptions->mismatchscore,
idxlocalioptions->gapextend,
idxlocalioptions->threshold,
idxlocalioptions->showalignment,
processmatch,
processmatchinfoonline);
}
dfst = gt_locali_AbstractDfstransformer();
if (!idxlocalioptions->doonline || idxlocalioptions->docompare)
{
gt_assert(genericindex != NULL);
limdfsresources = gt_newLimdfsresources(genericindex,
true,
0,
0, /* maxpathlength */
true, /* keepexpandedonstack */
processmatch,
processmatchinfooffline,
NULL, /* processresult */
NULL, /* processresult info */
dfst);
}
seqit = gt_seq_iterator_sequence_buffer_new(idxlocalioptions->queryfiles,
err);
if (!seqit)
haserr = true;
if (!haserr)
{
gt_seq_iterator_set_symbolmap(seqit, gt_alphabet_symbolmap(a));
for (showmatchinfo.queryunit = 0; /* Nothing */;
showmatchinfo.queryunit++)
{
retval = gt_seq_iterator_next(seqit,
&query,
&querylen,
&desc,
err);
if (retval < 0)
{
haserr = true;
break;
}
if (retval == 0)
{
break;
}
printf("process sequence " Formatuint64_t " of length %lu\n",
PRINTuint64_tcast(showmatchinfo.queryunit),querylen);
if (idxlocalioptions->doonline || idxlocalioptions->docompare)
{
gt_multiapplysmithwaterman(swdpresource,encseq,query,querylen);
}
if (!idxlocalioptions->doonline || idxlocalioptions->docompare)
{
gt_indexbasedlocali(limdfsresources,
idxlocalioptions->matchscore,
idxlocalioptions->mismatchscore,
idxlocalioptions->gapstart,
idxlocalioptions->gapextend,
idxlocalioptions->threshold,
query,
querylen,
dfst);
}
if (idxlocalioptions->docompare)
{
gt_checkandresetstorematch(showmatchinfo.queryunit,
&storeonline,&storeoffline);
}
}
if (limdfsresources != NULL)
{
gt_freeLimdfsresources(&limdfsresources,dfst);
}
if (swdpresource != NULL)
{
gt_freeSWdpresource(swdpresource);
swdpresource = NULL;
}
gt_seq_iterator_delete(seqit);
}
if (idxlocalioptions->docompare)
{
gt_freestorematch(&storeonline);
gt_freestorematch(&storeoffline);
}
}
if (genericindex == NULL)
{
gt_encseq_delete((GtEncseq *) encseq);
encseq = NULL;
} else
{
genericindex_delete(genericindex);
}
gt_logger_delete(logger);
logger = NULL;
return haserr ? -1 : 0;
}
