/* create a global alignment in square space with constant cost values,
 * to use it in linear context you have to generate an spacemanager before,
 * in any other case it can be NULL */
GtUword alignment_in_square_space(GtLinspaceManagement *spacemanager,
                                  GtAlignment *align,
                                  const GtUchar *useq,
                                  GtUword ustart,
                                  GtUword ulen,
                                  const GtUchar *vseq,
                                  GtUword vstart,
                                  GtUword vlen,
                                  GtUword matchcost,
                                  GtUword mismatchcost,
                                  GtUword gapcost)
{
  GtUword distance;
  GtScoreHandler *scorehandler;

  gt_assert(align);
  scorehandler = gt_scorehandler_new(matchcost, mismatchcost, 0, gapcost);
  distance = alignment_in_square_space_generic (spacemanager, align,
                                                useq, ustart,  ulen,
                                                vseq,  vstart, vlen,
                                                scorehandler);
  gt_scorehandler_delete(scorehandler);
  return distance;
}
Beispiel #2
0
/* calculating alignment in linear space */
GtUword gt_calc_linearalign(LinspaceManagement *spacemanager,
                            GtScoreHandler *scorehandler,
                            GtAlignment *align,
                            const GtUchar *useq,
                            GtUword ustart,
                            GtUword ulen,
                            const GtUchar *vseq,
                            GtUword vstart,
                            GtUword vlen)
{
  GtUword distance, gapcost, *Ctab, *EDtabcolumn, *Rtabcolumn, threadcount = 1;

  gt_assert(scorehandler);
  gt_linspaceManagement_set_ulen(spacemanager,ulen);
  gapcost = gt_scorehandler_get_gapscore(scorehandler);

  if (ulen == 0UL)
  {
    return construct_trivial_insertion_alignment(align,vlen,gapcost);
  }
  else if (vlen == 0UL)
  {
    return construct_trivial_deletion_alignment(align,ulen,gapcost);
  }
  else if (vlen == 1UL)
  {
    gt_linspaceManagement_check(spacemanager,(ulen+1)*(vlen+1)-1,ulen,
                                sizeof (*EDtabcolumn), sizeof (EDtabcolumn), 0);
    return alignment_in_square_space_generic(spacemanager, align,
                                             useq, ustart, ulen,
                                             vseq, vstart, vlen, scorehandler);
  }
  else if (gt_linspaceManagement_checksquare(spacemanager, ulen, vlen,
                                             sizeof (*EDtabcolumn),
                                             sizeof (*Rtabcolumn)))
  { /* call 2dim */
    return alignment_in_square_space_generic(spacemanager, align,
                                             useq, ustart, ulen,
                                             vseq, vstart, vlen, scorehandler);
  }

#ifdef GT_THREADS_ENABLED
  gt_linspaceManagement_check(spacemanager, ulen + GT_DIV2(vlen), vlen,
                              sizeof (*EDtabcolumn), sizeof (*Rtabcolumn),
                              sizeof (*Ctab));
#else
  gt_linspaceManagement_check(spacemanager, ulen, vlen, sizeof (*EDtabcolumn),
                              sizeof (*Rtabcolumn), sizeof (*Ctab));
#endif
  Ctab = gt_linspaceManagement_get_crosspointTabspace(spacemanager);

  Ctab[vlen] = ulen;
  distance = evaluatelinearcrosspoints(spacemanager, scorehandler,
                                       useq, ustart, ulen,
                                       vseq, vstart, vlen,
                                       Ctab, 0, 0, &threadcount);

  determineCtab0(Ctab, scorehandler, vseq[vstart], useq, ustart);
  reconstructalignment_from_Ctab(align, Ctab, useq, ustart, vseq, vstart,
                                 vlen, scorehandler);

  return distance;
}