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;
}
/* determining start and end of local alignment and call global function */
GtWord gt_linearalign_compute_local_generic(GtLinspaceManagement *spacemanager,
const GtScoreHandler *scorehandler,
GtAlignment *align,
const GtUchar *useq,
GtUword ustart,
GtUword ulen,
const GtUchar *vseq,
GtUword vstart,
GtUword vlen)
{
GtWord *Ltabcolumn,
score = GT_WORD_MAX;
GtUwordPair *Starttabcolumn;
GtUword ulen_part, ustart_part, vlen_part, vstart_part;
GtMaxcoordvalue *max;
gt_assert(spacemanager && scorehandler && align);
gt_linspace_management_set_ulen(spacemanager,ulen);
if (ulen == 0UL || vlen == 0UL)
{
/* empty alignment */
return 0;
}
else if (vlen == 1UL)
{
gt_linspace_management_check_local(spacemanager,
(ulen+1)*(vlen+1)-1, ulen,
sizeof (GtWord),
sizeof (GtWord *));
return gt_squarealign_calculate_local_generic(spacemanager, align,
useq, ustart, ulen,
vseq, vstart, vlen,
scorehandler);
}
else if (gt_linspace_management_checksquare_local(spacemanager, ulen, vlen,
sizeof (*Ltabcolumn),
sizeof (*Starttabcolumn)))
{
/* call 2dim */
return gt_squarealign_calculate_local_generic(spacemanager, align,
useq, ustart, ulen,
vseq, vstart, vlen,
scorehandler);
}
gt_linspace_management_check_local(spacemanager,
ulen, vlen,
sizeof (*Ltabcolumn),
sizeof (*Starttabcolumn));
max = evaluateallLScolumns(spacemanager, scorehandler,
useq, ustart, ulen,
vseq, vstart, vlen);
if (gt_maxcoordvalue_get_length_safe(max))
{
GtScoreHandler *costhandler;
ustart_part = ustart+(gt_maxcoordvalue_get_start(max)).a;
vstart_part = vstart+(gt_maxcoordvalue_get_start(max)).b;
ulen_part = gt_maxcoordvalue_get_row_length(max);
vlen_part = gt_maxcoordvalue_get_col_length(max);
score = gt_maxcoordvalue_get_value(max);
gt_alignment_set_seqs(align, useq + ustart_part, ulen_part,
vseq + vstart_part, vlen_part);
costhandler = gt_scorehandler2costhandler(scorehandler);
/* call global function */
gt_calc_linearalign(spacemanager,
costhandler, align,
useq, ustart_part, ulen_part,
vseq, vstart_part, vlen_part);
gt_scorehandler_delete(costhandler);
} else
{
/*empty alignment */
return 0;
}
return score;
}
