aligner_23mm.h

   1 /*
   2  * aligner_23mm.h
   3  */
   4
   5 #ifndef ALIGNER_23MM_H_
   6 #define ALIGNER_23MM_H_
   7
   8 #include <utility>
   9 #include <vector>
  10 #include "aligner.h"
  11 #include "hit.h"
  12 #include "range_source.h"
  13 #include "row_chaser.h"
  14 #include "range_chaser.h"
  15 #include "ref_aligner.h"
  16
  17 /**
  18  * Concrete factory for constructing unpaired 2- or 3-mismatch aligners.
  19  */
  20 class Unpaired23mmAlignerV1Factory : public AlignerFactory {
  21         typedef RangeSourceDriver<EbwtRangeSource> TRangeSrcDr;
  22         typedef CostAwareRangeSourceDriver<EbwtRangeSource> TCostAwareRangeSrcDr;
  23         typedef std::vector<TRangeSrcDr*> TRangeSrcDrPtrVec;
  24 public:
  25         Unpaired23mmAlignerV1Factory(
  26                         Ebwt<String<Dna> >& ebwtFw,
  27                         Ebwt<String<Dna> >* ebwtBw,
  28                         bool two,
  29                         bool doFw,
  30                         bool doRc,
  31                         HitSink& sink,
  32                         const HitSinkPerThreadFactory& sinkPtFactory,
  33                         RangeCache *cacheFw,
  34                         RangeCache *cacheBw,
  35                         uint32_t cacheLimit,
  36                         ChunkPool *pool,
  37                         BitPairReference* refs,
  38                         vector<String<Dna5> >& os,
  39                         bool maqPenalty,
  40                         bool qualOrder,
  41                         bool strandFix,
  42                         bool rangeMode,
  43                         bool verbose,
  44                         bool quiet,
  45                         uint32_t seed) :
  46                         ebwtFw_(ebwtFw),
  47                         ebwtBw_(ebwtBw),
  48                         two_(two),
  49                         doFw_(doFw), doRc_(doRc),
  50                         sink_(sink),
  51                         sinkPtFactory_(sinkPtFactory),
  52                         cacheFw_(cacheFw),
  53                         cacheBw_(cacheBw),
  54                         cacheLimit_(cacheLimit),
  55                         pool_(pool),
  56                         refs_(refs),
  57                         os_(os),
  58                         maqPenalty_(maqPenalty),
  59                         qualOrder_(qualOrder),
  60                         strandFix_(strandFix),
  61                         rangeMode_(rangeMode),
  62                         verbose_(verbose),
  63                         quiet_(quiet),
  64                         seed_(seed)
  65         {
  66                 assert(ebwtFw.isInMemory());
  67                 assert(ebwtBw != NULL);
  68                 assert(ebwtBw->isInMemory());
  69         }
  70
  71         /**
  72          * Create a new UnpairedExactAlignerV1s.
  73          */
  74         virtual Aligner* create() const {
  75
  76                 HitSinkPerThread* sinkPt = sinkPtFactory_.create();
  77                 EbwtSearchParams<String<Dna> >* params =
  78                         new EbwtSearchParams<String<Dna> >(*sinkPt, os_);
  79
  80                 const bool seeded = false;
  81
  82                 EbwtRangeSource *rFw_Bw = new EbwtRangeSource(
  83                          ebwtBw_, true, 0xffffffff, true, verbose_, quiet_, 0, seeded, maqPenalty_, qualOrder_);
  84                 EbwtRangeSource *rFw_Fw = new EbwtRangeSource(
  85                         &ebwtFw_, true, 0xffffffff, false, verbose_, quiet_, 0, seeded, maqPenalty_, qualOrder_);
  86                 EbwtRangeSource *rFw_BwHalf = new EbwtRangeSource(
  87                          ebwtBw_, true, 0xffffffff, false, verbose_, quiet_, 2,  seeded, maqPenalty_, qualOrder_);
  88                 EbwtRangeSource *rFw_FwHalf = NULL;
  89                 if(!two_) {
  90                         rFw_FwHalf = new EbwtRangeSource(
  91                                 &ebwtFw_, true, 0xffffffff, false, verbose_, quiet_, 3,  seeded, maqPenalty_, qualOrder_);
  92                 }
  93
  94                 // Driver wrapper for rFw_Bw
  95                 EbwtRangeSourceDriver * drFw_Bw = new EbwtRangeSourceDriver(
  96                         *params, rFw_Bw, true, false, maqPenalty_, qualOrder_, sink_, sinkPt,
  97                         0,          // seedLen (0 = whole read is seed)
  98                         true,       // nudgeLeft (true for Fw index, false for Bw)
  99                         PIN_TO_HI_HALF_EDGE, // right half is unrevisitable
 100                         PIN_TO_HI_HALF_EDGE, // trumped by 0-mm
 101                         two_ ? PIN_TO_LEN : PIN_TO_HI_HALF_EDGE,
 102                         PIN_TO_LEN,
 103                         os_, verbose_, quiet_, true, pool_, NULL);
 104                 // Driver wrapper for rFw_Fw
 105                 EbwtRangeSourceDriver * drFw_Fw = new EbwtRangeSourceDriver(
 106                         *params, rFw_Fw, true, false, maqPenalty_, qualOrder_, sink_, sinkPt,
 107                         0,          // seedLen (0 = whole read is seed)
 108                         false,      // nudgeLeft (true for Fw index, false for Bw)
 109                         PIN_TO_HI_HALF_EDGE, // right half is unrevisitable
 110                         PIN_TO_HI_HALF_EDGE, // trumped by 0-mm
 111                         two_ ? PIN_TO_LEN : PIN_TO_HI_HALF_EDGE,
 112                         PIN_TO_LEN,
 113                         os_, verbose_, quiet_, true, pool_, NULL);
 114                 // Driver wrapper for rFw_Fw
 115                 EbwtRangeSourceDriver * drFw_BwHalf = new EbwtRangeSourceDriver(
 116                         *params, rFw_BwHalf, true, false, maqPenalty_, qualOrder_, sink_, sinkPt,
 117                         0,          // seedLen (0 = whole read is seed)
 118                         true,       // nudgeLeft (true for Fw index, false for Bw)
 119                         PIN_TO_BEGINNING,    // nothing's unrevisitable
 120                         PIN_TO_HI_HALF_EDGE,
 121                         two_ ? PIN_TO_LEN : PIN_TO_HI_HALF_EDGE,
 122                         PIN_TO_LEN,
 123                         os_, verbose_, quiet_, true, pool_, NULL);
 124                 // Driver wrapper for rFw_Fw
 125                 EbwtRangeSourceDriver * drFw_FwHalf = NULL;
 126                 if(!two_) {
 127                         drFw_FwHalf = new EbwtRangeSourceDriver(
 128                                 *params, rFw_FwHalf, true, false, maqPenalty_, qualOrder_, sink_, sinkPt,
 129                                 0,          // seedLen (0 = whole read is seed)
 130                                 false,      // nudgeLeft (true for Fw index, false for Bw)
 131                                 PIN_TO_BEGINNING,    // nothing's unrevisitable
 132                                 PIN_TO_HI_HALF_EDGE,
 133                                 PIN_TO_HI_HALF_EDGE,
 134                                 PIN_TO_LEN,
 135                                 os_, verbose_, quiet_, true, pool_, NULL);
 136                 }
 137
 138                 TRangeSrcDrPtrVec *drVec = new TRangeSrcDrPtrVec();
 139                 if(doFw_) {
 140                         drVec->push_back(drFw_Bw);
 141                         drVec->push_back(drFw_Fw);
 142                         drVec->push_back(drFw_BwHalf);
 143                         if(!two_) {
 144                                 drVec->push_back(drFw_FwHalf);
 145                         }
 146                 }
 147
 148                 EbwtRangeSource *rRc_Fw = new EbwtRangeSource(
 149                         &ebwtFw_, false, 0xffffffff, true,  verbose_, quiet_, 0, seeded, maqPenalty_, qualOrder_);
 150                 EbwtRangeSource *rRc_Bw = new EbwtRangeSource(
 151                          ebwtBw_, false, 0xffffffff, false, verbose_, quiet_, 0, seeded, maqPenalty_, qualOrder_);
 152                 EbwtRangeSource *rRc_FwHalf = new EbwtRangeSource(
 153                         &ebwtFw_, false, 0xffffffff, false, verbose_, quiet_, 2,  seeded, maqPenalty_, qualOrder_);
 154                 EbwtRangeSource *rRc_BwHalf = NULL;
 155                 if(!two_) {
 156                         rRc_BwHalf = new EbwtRangeSource(
 157                                  ebwtBw_, false, 0xffffffff, false, verbose_, quiet_, 3,  seeded, maqPenalty_, qualOrder_);
 158                 }
 159
 160                 // Driver wrapper for rRc_Fw
 161                 EbwtRangeSourceDriver * drRc_Fw = new EbwtRangeSourceDriver(
 162                         *params, rRc_Fw, false, false, maqPenalty_, qualOrder_, sink_, sinkPt,
 163                         0,          // seedLen (0 = whole read is seed)
 164                         true,       // nudgeLeft (true for Fw index, false for Bw)
 165                         PIN_TO_HI_HALF_EDGE, // right half is unrevisitable
 166                         PIN_TO_HI_HALF_EDGE, // trumped by 0-mm
 167                         two_ ? PIN_TO_LEN : PIN_TO_HI_HALF_EDGE,
 168                         PIN_TO_LEN,
 169                         os_, verbose_, quiet_, true, pool_, NULL);
 170                 // Driver wrapper for rRc_Bw
 171                 EbwtRangeSourceDriver * drRc_Bw = new EbwtRangeSourceDriver(
 172                         *params, rRc_Bw, false, false, maqPenalty_, qualOrder_, sink_, sinkPt,
 173                         0,          // seedLen (0 = whole read is seed)
 174                         false,      // nudgeLeft (true for Fw index, false for Bw)
 175                         PIN_TO_HI_HALF_EDGE, // right half is unrevisitable
 176                         PIN_TO_HI_HALF_EDGE, // trumped by 0-mm
 177                         two_ ? PIN_TO_LEN : PIN_TO_HI_HALF_EDGE,
 178                         PIN_TO_LEN,
 179                         os_, verbose_, quiet_, true, pool_, NULL);
 180                 // Driver wrapper for rRc_Fw
 181                 EbwtRangeSourceDriver * drRc_FwHalf = new EbwtRangeSourceDriver(
 182                         *params, rRc_FwHalf, false, false, maqPenalty_, qualOrder_, sink_, sinkPt,
 183                         0,          // seedLen (0 = whole read is seed)
 184                         true,       // nudgeLeft (true for Fw index, false for Bw)
 185                         PIN_TO_BEGINNING,    // nothing's unrevisitable
 186                         PIN_TO_HI_HALF_EDGE,
 187                         two_ ? PIN_TO_LEN : PIN_TO_HI_HALF_EDGE,
 188                         PIN_TO_LEN,
 189                         os_, verbose_, quiet_, true, pool_, NULL);
 190                 EbwtRangeSourceDriver * drRc_BwHalf = NULL;
 191                 if(!two_) {
 192                         drRc_BwHalf = new EbwtRangeSourceDriver(
 193                                 *params, rRc_BwHalf, false, false, maqPenalty_, qualOrder_, sink_, sinkPt,
 194                                 0,          // seedLen (0 = whole read is seed)
 195                                 false,       // nudgeLeft (true for Fw index, false for Bw)
 196                                 PIN_TO_BEGINNING,    // nothing's unrevisitable
 197                                 PIN_TO_HI_HALF_EDGE,
 198                                 PIN_TO_HI_HALF_EDGE,
 199                                 PIN_TO_LEN,
 200                                 os_, verbose_, quiet_, true, pool_, NULL);
 201                 }
 202                 if(doRc_) {
 203                         drVec->push_back(drRc_Fw);
 204                         drVec->push_back(drRc_Bw);
 205                         drVec->push_back(drRc_FwHalf);
 206                         if(!two_) {
 207                                 drVec->push_back(drRc_BwHalf);
 208                         }
 209                 }
 210                 TCostAwareRangeSrcDr* dr = new TCostAwareRangeSrcDr(strandFix_, drVec, verbose_, quiet_, false);
 211                 delete drVec;
 212
 213                 // Set up a RangeChaser
 214                 RangeChaser<String<Dna> > *rchase =
 215                         new RangeChaser<String<Dna> >(cacheLimit_, cacheFw_, cacheBw_);
 216
 217                 return new UnpairedAlignerV2<EbwtRangeSource>(
 218                         params, dr, rchase,
 219                         sink_, sinkPtFactory_, sinkPt, os_, refs_,
 220                         rangeMode_, verbose_, quiet_, INT_MAX, pool_, NULL, NULL);
 221         }
 222
 223 private:
 224         Ebwt<String<Dna> >& ebwtFw_;
 225         Ebwt<String<Dna> >* ebwtBw_;
 226         bool two_;
 227         bool doFw_;
 228         bool doRc_;
 229         HitSink& sink_;
 230         const HitSinkPerThreadFactory& sinkPtFactory_;
 231         RangeCache *cacheFw_;
 232         RangeCache *cacheBw_;
 233         const uint32_t cacheLimit_;
 234         ChunkPool *pool_;
 235         BitPairReference* refs_;
 236         vector<String<Dna5> >& os_;
 237         const bool maqPenalty_;
 238         const bool qualOrder_;
 239         const bool strandFix_;
 240         const bool rangeMode_;
 241         const bool verbose_;
 242         const bool quiet_;
 243         uint32_t seed_;
 244 };
 245
 246 /**
 247  * Concrete factory for constructing paired 2- or 3-mismatch aligners.
 248  */
 249 class Paired23mmAlignerV1Factory : public AlignerFactory {
 250         typedef RangeSourceDriver<EbwtRangeSource> TRangeSrcDr;
 251         typedef ListRangeSourceDriver<EbwtRangeSource> TListRangeSrcDr;
 252         typedef CostAwareRangeSourceDriver<EbwtRangeSource> TCostAwareRangeSrcDr;
 253         typedef std::vector<TRangeSrcDr*> TRangeSrcDrPtrVec;
 254 public:
 255         Paired23mmAlignerV1Factory(
 256                         Ebwt<String<Dna> >& ebwtFw,
 257                         Ebwt<String<Dna> >* ebwtBw,
 258                         bool color,
 259                         bool doFw,
 260                         bool doRc,
 261                         bool v1,
 262                         bool two,
 263                         HitSink& sink,
 264                         const HitSinkPerThreadFactory& sinkPtFactory,
 265                         bool mate1fw,
 266                         bool mate2fw,
 267                         uint32_t peInner,
 268                         uint32_t peOuter,
 269                         bool dontReconcile,
 270                         uint32_t symCeil,
 271                         uint32_t mixedThresh,
 272                         uint32_t mixedAttemptLim,
 273                         RangeCache *cacheFw,
 274                         RangeCache *cacheBw,
 275                         uint32_t cacheLimit,
 276                         ChunkPool *pool,
 277                         BitPairReference* refs,
 278                         vector<String<Dna5> >& os,
 279                         bool reportSe,
 280                         bool maqPenalty,
 281                         bool qualOrder,
 282                         bool strandFix,
 283                         bool rangeMode,
 284                         bool verbose,
 285                         bool quiet,
 286                         uint32_t seed) :
 287                         ebwtFw_(ebwtFw),
 288                         ebwtBw_(ebwtBw),
 289                         color_(color),
 290                         doFw_(doFw),
 291                         doRc_(doRc),
 292                         v1_(v1),
 293                         two_(two),
 294                         sink_(sink),
 295                         sinkPtFactory_(sinkPtFactory),
 296                         mate1fw_(mate1fw),
 297                         mate2fw_(mate2fw),
 298                         peInner_(peInner),
 299                         peOuter_(peOuter),
 300                         dontReconcile_(dontReconcile),
 301                         symCeil_(symCeil),
 302                         mixedThresh_(mixedThresh),
 303                         mixedAttemptLim_(mixedAttemptLim),
 304                         cacheFw_(cacheFw),
 305                         cacheBw_(cacheBw),
 306                         cacheLimit_(cacheLimit),
 307                         pool_(pool),
 308                         refs_(refs), os_(os),
 309                         reportSe_(reportSe),
 310                         maqPenalty_(maqPenalty),
 311                         qualOrder_(qualOrder),
 312                         strandFix_(strandFix),
 313                         rangeMode_(rangeMode),
 314                         verbose_(verbose),
 315                         quiet_(quiet),
 316                         seed_(seed)
 317         {
 318                 assert(ebwtBw != NULL);
 319                 assert(ebwtFw.isInMemory());
 320                 assert(ebwtBw->isInMemory());
 321         }
 322
 323         /**
 324          * Create a new UnpairedExactAlignerV1s.
 325          */
 326         virtual Aligner* create() const {
 327                 HitSinkPerThread* sinkPt = sinkPtFactory_.createMult(2);
 328                 HitSinkPerThread* sinkPtSe1 = NULL, * sinkPtSe2 = NULL;
 329                 EbwtSearchParams<String<Dna> >* params =
 330                         new EbwtSearchParams<String<Dna> >(*sinkPt, os_);
 331                 EbwtSearchParams<String<Dna> >* paramsSe1 = NULL, * paramsSe2 = NULL;
 332                 if(reportSe_) {
 333                         sinkPtSe1 = sinkPtFactory_.create();
 334                         sinkPtSe2 = sinkPtFactory_.create();
 335                         paramsSe1 =
 336                                 new EbwtSearchParams<String<Dna> >(*sinkPtSe1, os_);
 337                         paramsSe2 =
 338                                 new EbwtSearchParams<String<Dna> >(*sinkPtSe2, os_);
 339                 }
 340
 341                 const bool seeded = false;
 342
 343                 bool do1Fw = true;
 344                 bool do1Rc = true;
 345                 bool do2Fw = true;
 346                 bool do2Rc = true;
 347                 if(!doFw_) {
 348                         if(mate1fw_) do1Fw = false;
 349                         else         do1Rc = false;
 350                         if(mate2fw_) do2Fw = false;
 351                         else         do2Rc = false;
 352                 }
 353                 if(!doRc_) {
 354                         if(mate1fw_) do1Rc = false;
 355                         else         do1Fw = false;
 356                         if(mate2fw_) do2Rc = false;
 357                         else         do2Fw = false;
 358                 }
 359
 360                 TRangeSrcDrPtrVec *dr1FwVec = new TRangeSrcDrPtrVec();
 361
 362                 if(do1Fw) {
 363                         EbwtRangeSource *r1Fw_Bw = new EbwtRangeSource(
 364                                  ebwtBw_, true, 0xffffffff, true,  verbose_, quiet_, 0, seeded, maqPenalty_, qualOrder_);
 365                         EbwtRangeSource *r1Fw_Fw = new EbwtRangeSource(
 366                                 &ebwtFw_, true, 0xffffffff, false, verbose_, quiet_, 0, seeded, maqPenalty_, qualOrder_);
 367                         EbwtRangeSource *r1Fw_BwHalf = new EbwtRangeSource(
 368                                  ebwtBw_, true, 0xffffffff, false, verbose_, quiet_, 2, seeded, maqPenalty_, qualOrder_);
 369                         EbwtRangeSource *r1Fw_FwHalf = two_ ? NULL : new EbwtRangeSource(
 370                                 &ebwtFw_, true, 0xffffffff, false, verbose_, quiet_, 3, seeded, maqPenalty_, qualOrder_);
 371
 372                         // Driver wrapper for rFw_Bw
 373                         EbwtRangeSourceDriver * dr1Fw_Bw = new EbwtRangeSourceDriver(
 374                                 *params, r1Fw_Bw, true, false, maqPenalty_, qualOrder_, sink_, sinkPt,
 375                                 0,          // seedLen (0 = whole read is seed)
 376                                 true,      // nudgeLeft (true for Fw index, false for Bw)
 377                                 PIN_TO_HI_HALF_EDGE, // right half is unrevisitable
 378                                 PIN_TO_HI_HALF_EDGE, // trumped by 0-mm
 379                                 two_ ? PIN_TO_LEN : PIN_TO_HI_HALF_EDGE,
 380                                 PIN_TO_LEN,
 381                                 os_, verbose_, quiet_, true, pool_, NULL);
 382                         // Driver wrapper for rFw_Fw
 383                         EbwtRangeSourceDriver * dr1Fw_Fw = new EbwtRangeSourceDriver(
 384                                 *params, r1Fw_Fw, true, false, maqPenalty_, qualOrder_, sink_, sinkPt,
 385                                 0,          // seedLen (0 = whole read is seed)
 386                                 false,       // nudgeLeft (true for Fw index, false for Bw)
 387                                 PIN_TO_HI_HALF_EDGE, // right half is unrevisitable
 388                                 PIN_TO_HI_HALF_EDGE, // trumped by 0-mm
 389                                 two_ ? PIN_TO_LEN : PIN_TO_HI_HALF_EDGE,
 390                                 PIN_TO_LEN,
 391                                 os_, verbose_, quiet_, true, pool_, NULL);
 392                         // Driver wrapper for rFw_Fw
 393                         EbwtRangeSourceDriver * dr1Fw_BwHalf = new EbwtRangeSourceDriver(
 394                                 *params, r1Fw_BwHalf, true, false, maqPenalty_, qualOrder_, sink_, sinkPt,
 395                                 0,          // seedLen (0 = whole read is seed)
 396                                 true,       // nudgeLeft (true for Fw index, false for Bw)
 397                                 PIN_TO_BEGINNING,    // nothing's unrevisitable
 398                                 PIN_TO_HI_HALF_EDGE,
 399                                 two_ ? PIN_TO_LEN : PIN_TO_HI_HALF_EDGE,
 400                                 PIN_TO_LEN,
 401                                 os_, verbose_, quiet_, true, pool_, NULL);
 402                         dr1FwVec->push_back(dr1Fw_Bw);
 403                         dr1FwVec->push_back(dr1Fw_Fw);
 404                         dr1FwVec->push_back(dr1Fw_BwHalf);
 405                         if(!two_) {
 406                                 // Driver wrapper for rFw_Fw
 407                                 EbwtRangeSourceDriver * dr1Fw_FwHalf = two_ ? NULL : new EbwtRangeSourceDriver(
 408                                         *params, r1Fw_FwHalf, true, false, maqPenalty_, qualOrder_, sink_, sinkPt,
 409                                         0,          // seedLen (0 = whole read is seed)
 410                                         false,       // nudgeLeft (true for Fw index, false for Bw)
 411                                         PIN_TO_BEGINNING,    // nothing's unrevisitable
 412                                         PIN_TO_BEGINNING,
 413                                         PIN_TO_HI_HALF_EDGE,
 414                                         PIN_TO_LEN,
 415                                         os_, verbose_, quiet_, true, pool_, NULL);
 416                                 dr1FwVec->push_back(dr1Fw_FwHalf);
 417                         }
 418                 }
 419
 420                 TRangeSrcDrPtrVec *dr1RcVec;
 421                 if(v1_) {
 422                         dr1RcVec = new TRangeSrcDrPtrVec();
 423                 } else {
 424                         dr1RcVec = dr1FwVec;
 425                 }
 426
 427                 if(do1Rc) {
 428                         EbwtRangeSource *r1Rc_Fw = new EbwtRangeSource(
 429                                 &ebwtFw_, false, 0xffffffff, true,  verbose_, quiet_, 0, seeded, maqPenalty_, qualOrder_);
 430                         EbwtRangeSource *r1Rc_Bw = new EbwtRangeSource(
 431                                  ebwtBw_, false, 0xffffffff, false, verbose_, quiet_, 0, seeded, maqPenalty_, qualOrder_);
 432                         EbwtRangeSource *r1Rc_FwHalf = new EbwtRangeSource(
 433                                 &ebwtFw_, false, 0xffffffff, false, verbose_, quiet_, 2, seeded, maqPenalty_, qualOrder_);
 434                         EbwtRangeSource *r1Rc_BwHalf = two_ ? NULL : new EbwtRangeSource(
 435                                  ebwtBw_, false, 0xffffffff, false, verbose_, quiet_, 3, seeded, maqPenalty_, qualOrder_);
 436
 437                         // Driver wrapper for rRc_Fw
 438                         EbwtRangeSourceDriver * dr1Rc_Fw = new EbwtRangeSourceDriver(
 439                                 *params, r1Rc_Fw, false, false, maqPenalty_, qualOrder_, sink_, sinkPt,
 440                                 0,          // seedLen (0 = whole read is seed)
 441                                 true,       // nudgeLeft (true for Fw index, false for Bw)
 442                                 PIN_TO_HI_HALF_EDGE, // right half is unrevisitable
 443                                 PIN_TO_HI_HALF_EDGE, // trumped by 0-mm
 444                                 two_ ? PIN_TO_LEN : PIN_TO_HI_HALF_EDGE,
 445                                 PIN_TO_LEN,
 446                                 os_, verbose_, quiet_, true, pool_, NULL);
 447                         // Driver wrapper for rRc_Bw
 448                         EbwtRangeSourceDriver * dr1Rc_Bw = new EbwtRangeSourceDriver(
 449                                 *params, r1Rc_Bw, false, false, maqPenalty_, qualOrder_, sink_, sinkPt,
 450                                 0,          // seedLen (0 = whole read is seed)
 451                                 false,      // nudgeLeft (true for Fw index, false for Bw)
 452                                 PIN_TO_HI_HALF_EDGE, // right half is unrevisitable
 453                                 PIN_TO_HI_HALF_EDGE, // trumped by 0-mm
 454                                 two_ ? PIN_TO_LEN : PIN_TO_HI_HALF_EDGE,
 455                                 PIN_TO_LEN,
 456                                 os_, verbose_, quiet_, true, pool_, NULL);
 457                         // Driver wrapper for rRc_Fw
 458                         EbwtRangeSourceDriver * dr1Rc_FwHalf = new EbwtRangeSourceDriver(
 459                                 *params, r1Rc_FwHalf, false, false, maqPenalty_, qualOrder_, sink_, sinkPt,
 460                                 0,          // seedLen (0 = whole read is seed)
 461                                 true,       // nudgeLeft (true for Fw index, false for Bw)
 462                                 PIN_TO_BEGINNING,
 463                                 PIN_TO_HI_HALF_EDGE,
 464                                 two_ ? PIN_TO_LEN : PIN_TO_HI_HALF_EDGE,
 465                                 PIN_TO_LEN,
 466                                 os_, verbose_, quiet_, true, pool_, NULL);
 467                         dr1RcVec->push_back(dr1Rc_Fw);
 468                         dr1RcVec->push_back(dr1Rc_Bw);
 469                         dr1RcVec->push_back(dr1Rc_FwHalf);
 470                         if(!two_) {
 471                                 // Driver wrapper for rRc_Bw
 472                                 EbwtRangeSourceDriver * dr1Rc_BwHalf = two_ ? NULL : new EbwtRangeSourceDriver(
 473                                         *params, r1Rc_BwHalf, false, false, maqPenalty_, qualOrder_, sink_, sinkPt,
 474                                         0,          // seedLen (0 = whole read is seed)
 475                                         false,       // nudgeLeft (true for Fw index, false for Bw)
 476                                         PIN_TO_BEGINNING,
 477                                         PIN_TO_HI_HALF_EDGE,
 478                                         PIN_TO_HI_HALF_EDGE,
 479                                         PIN_TO_LEN,
 480                                         os_, verbose_, quiet_, true, pool_, NULL);
 481                                 dr1RcVec->push_back(dr1Rc_BwHalf);
 482                         }
 483                 }
 484
 485                 TRangeSrcDrPtrVec *dr2FwVec;
 486                 if(v1_) {
 487                         dr2FwVec = new TRangeSrcDrPtrVec();
 488                 } else {
 489                         dr2FwVec = dr1FwVec;
 490                 }
 491
 492                 if(do2Fw) {
 493                         EbwtRangeSource *r2Fw_Bw = new EbwtRangeSource(
 494                                  ebwtBw_, true, 0xffffffff, true,  verbose_, quiet_, 0, seeded, maqPenalty_, qualOrder_);
 495                         EbwtRangeSource *r2Fw_Fw = new EbwtRangeSource(
 496                                 &ebwtFw_, true, 0xffffffff, false, verbose_, quiet_, 0, seeded, maqPenalty_, qualOrder_);
 497                         EbwtRangeSource *r2Fw_BwHalf = new EbwtRangeSource(
 498                                  ebwtBw_, true, 0xffffffff, false, verbose_, quiet_, 2, seeded, maqPenalty_, qualOrder_);
 499                         EbwtRangeSource *r2Fw_FwHalf = two_ ? NULL : new EbwtRangeSource(
 500                                 &ebwtFw_, true, 0xffffffff, false, verbose_, quiet_, 3, seeded, maqPenalty_, qualOrder_);
 501
 502                         // Driver wrapper for rFw_Bw
 503                         EbwtRangeSourceDriver * dr2Fw_Bw = new EbwtRangeSourceDriver(
 504                                 *params, r2Fw_Bw, true, false, maqPenalty_, qualOrder_, sink_, sinkPt,
 505                                 0,          // seedLen (0 = whole read is seed)
 506                                 true,       // nudgeLeft (true for Fw index, false for Bw)
 507                                 PIN_TO_HI_HALF_EDGE, // right half is unrevisitable
 508                                 PIN_TO_HI_HALF_EDGE, // trumped by 0-mm
 509                                 two_ ? PIN_TO_LEN : PIN_TO_HI_HALF_EDGE,
 510                                 PIN_TO_LEN,
 511                                 os_, verbose_, quiet_, false, pool_, NULL);
 512                         // Driver wrapper for rFw_Fw
 513                         EbwtRangeSourceDriver * dr2Fw_Fw = new EbwtRangeSourceDriver(
 514                                 *params, r2Fw_Fw, true, false, maqPenalty_, qualOrder_, sink_, sinkPt,
 515                                 0,          // seedLen (0 = whole read is seed)
 516                                 false,      // nudgeLeft (true for Fw index, false for Bw)
 517                                 PIN_TO_HI_HALF_EDGE, // right half is unrevisitable
 518                                 PIN_TO_HI_HALF_EDGE, // trumped by 0-mm
 519                                 two_ ? PIN_TO_LEN : PIN_TO_HI_HALF_EDGE,
 520                                 PIN_TO_LEN,
 521                                 os_, verbose_, quiet_, false, pool_, NULL);
 522                         // Driver wrapper for rFw_Fw
 523                         EbwtRangeSourceDriver * dr2Fw_BwHalf = new EbwtRangeSourceDriver(
 524                                 *params, r2Fw_BwHalf, true, false, maqPenalty_, qualOrder_, sink_, sinkPt,
 525                                 0,          // seedLen (0 = whole read is seed)
 526                                 true,       // nudgeLeft (true for Fw index, false for Bw)
 527                                 PIN_TO_BEGINNING,    // nothing's unrevisitable
 528                                 PIN_TO_HI_HALF_EDGE,
 529                                 two_ ? PIN_TO_LEN : PIN_TO_HI_HALF_EDGE,
 530                                 PIN_TO_LEN,
 531                                 os_, verbose_, quiet_, false, pool_, NULL);
 532                         dr2FwVec->push_back(dr2Fw_Bw);
 533                         dr2FwVec->push_back(dr2Fw_Fw);
 534                         dr2FwVec->push_back(dr2Fw_BwHalf);
 535                         if(!two_) {
 536                                 EbwtRangeSourceDriver * dr2Fw_FwHalf = two_ ? NULL : new EbwtRangeSourceDriver(
 537                                         *params, r2Fw_FwHalf, true, false, maqPenalty_, qualOrder_, sink_, sinkPt,
 538                                         0,          // seedLen (0 = whole read is seed)
 539                                         false,       // nudgeLeft (true for Fw index, false for Bw)
 540                                         PIN_TO_BEGINNING,    // nothing's unrevisitable
 541                                         PIN_TO_BEGINNING,
 542                                         PIN_TO_HI_HALF_EDGE,
 543                                         PIN_TO_LEN,
 544                                         os_, verbose_, quiet_, false, pool_, NULL);
 545                                 dr2FwVec->push_back(dr2Fw_FwHalf);
 546                         }
 547                 }
 548
 549                 TRangeSrcDrPtrVec *dr2RcVec;
 550                 if(v1_) {
 551                         dr2RcVec = new TRangeSrcDrPtrVec();
 552                 } else {
 553                         dr2RcVec = dr1FwVec;
 554                 }
 555
 556                 if(do2Rc) {
 557                         EbwtRangeSource *r2Rc_Fw = new EbwtRangeSource(
 558                                 &ebwtFw_, false, 0xffffffff, true,  verbose_, quiet_, 0, seeded, maqPenalty_, qualOrder_);
 559                         EbwtRangeSource *r2Rc_Bw = new EbwtRangeSource(
 560                                  ebwtBw_, false, 0xffffffff, false, verbose_, quiet_, 0, seeded, maqPenalty_, qualOrder_);
 561                         EbwtRangeSource *r2Rc_FwHalf = new EbwtRangeSource(
 562                                 &ebwtFw_, false, 0xffffffff, false, verbose_, quiet_, 2,  seeded, maqPenalty_, qualOrder_);
 563                         EbwtRangeSource *r2Rc_BwHalf = two_ ? NULL : new EbwtRangeSource(
 564                                  ebwtBw_, false, 0xffffffff, false, verbose_, quiet_, 3,  seeded, maqPenalty_, qualOrder_);
 565
 566                         // Driver wrapper for rRc_Fw
 567                         EbwtRangeSourceDriver * dr2Rc_Fw = new EbwtRangeSourceDriver(
 568                                 *params, r2Rc_Fw, false, false, maqPenalty_, qualOrder_, sink_, sinkPt,
 569                                 0,          // seedLen (0 = whole read is seed)
 570                                 true,       // nudgeLeft (true for Fw index, false for Bw)
 571                                 PIN_TO_HI_HALF_EDGE, // right half is unrevisitable
 572                                 PIN_TO_HI_HALF_EDGE, // trumped by 0-mm
 573                                 two_ ? PIN_TO_LEN : PIN_TO_HI_HALF_EDGE,
 574                                 PIN_TO_LEN,
 575                                 os_, verbose_, quiet_, false, pool_, NULL);
 576                         // Driver wrapper for rRc_Bw
 577                         EbwtRangeSourceDriver * dr2Rc_Bw = new EbwtRangeSourceDriver(
 578                                 *params, r2Rc_Bw, false, false, maqPenalty_, qualOrder_, sink_, sinkPt,
 579                                 0,          // seedLen (0 = whole read is seed)
 580                                 false,      // nudgeLeft (true for Fw index, false for Bw)
 581                                 PIN_TO_HI_HALF_EDGE, // right half is unrevisitable
 582                                 PIN_TO_HI_HALF_EDGE, // trumped by 0-mm
 583                                 two_ ? PIN_TO_LEN : PIN_TO_HI_HALF_EDGE,
 584                                 PIN_TO_LEN,
 585                                 os_, verbose_, quiet_, false, pool_, NULL);
 586                         // Driver wrapper for rRc_Fw
 587                         EbwtRangeSourceDriver * dr2Rc_FwHalf = new EbwtRangeSourceDriver(
 588                                 *params, r2Rc_FwHalf, false, false, maqPenalty_, qualOrder_, sink_, sinkPt,
 589                                 0,          // seedLen (0 = whole read is seed)
 590                                 true,       // nudgeLeft (true for Fw index, false for Bw)
 591                                 PIN_TO_BEGINNING,    // nothing's unrevisitable
 592                                 PIN_TO_HI_HALF_EDGE,
 593                                 two_ ? PIN_TO_LEN : PIN_TO_HI_HALF_EDGE,
 594                                 PIN_TO_LEN,
 595                                 os_, verbose_, quiet_, false, pool_, NULL);
 596                         dr2RcVec->push_back(dr2Rc_Fw);
 597                         dr2RcVec->push_back(dr2Rc_Bw);
 598                         dr2RcVec->push_back(dr2Rc_FwHalf);
 599                         if(!two_) {
 600                                 EbwtRangeSourceDriver * dr2Rc_BwHalf = two_ ? NULL : new EbwtRangeSourceDriver(
 601                                         *params, r2Rc_BwHalf, false, false, maqPenalty_, qualOrder_, sink_, sinkPt,
 602                                         0,          // seedLen (0 = whole read is seed)
 603                                         false,       // nudgeLeft (true for Fw index, false for Bw)
 604                                         PIN_TO_BEGINNING,    // nothing's unrevisitable
 605                                         PIN_TO_BEGINNING,
 606                                         PIN_TO_HI_HALF_EDGE,
 607                                         PIN_TO_LEN,
 608                                         os_, verbose_, quiet_, false, pool_, NULL);
 609                                 dr2RcVec->push_back(dr2Rc_BwHalf);
 610                         }
 611                 }
 612
 613                 RefAligner<String<Dna5> >* refAligner;
 614                 if(two_) {
 615                         refAligner = new TwoMMRefAligner<String<Dna5> >(color_, verbose_, quiet_);
 616                 } else {
 617                         refAligner = new ThreeMMRefAligner<String<Dna5> >(color_, verbose_, quiet_);
 618                 }
 619
 620                 // Set up a RangeChaser
 621                 RangeChaser<String<Dna> > *rchase =
 622                         new RangeChaser<String<Dna> >(cacheLimit_, cacheFw_, cacheBw_);
 623
 624                 if(v1_) {
 625                         PairedBWAlignerV1<EbwtRangeSource> *al = new PairedBWAlignerV1<EbwtRangeSource>(
 626                                 params,
 627                                 new TCostAwareRangeSrcDr(strandFix_, dr1FwVec, verbose_, quiet_, false),
 628                                 new TCostAwareRangeSrcDr(strandFix_, dr1RcVec, verbose_, quiet_, false),
 629                                 new TCostAwareRangeSrcDr(strandFix_, dr2FwVec, verbose_, quiet_, false),
 630                                 new TCostAwareRangeSrcDr(strandFix_, dr2RcVec, verbose_, quiet_, false),
 631                                 refAligner, rchase,
 632                                 sink_, sinkPtFactory_, sinkPt, mate1fw_, mate2fw_,
 633                                 peInner_, peOuter_, dontReconcile_, symCeil_, mixedThresh_,
 634                                 mixedAttemptLim_, refs_, rangeMode_, verbose_,
 635                                 quiet_, INT_MAX, pool_, NULL);
 636                         delete dr1FwVec;
 637                         delete dr1RcVec;
 638                         delete dr2FwVec;
 639                         delete dr2RcVec;
 640                         return al;
 641                 } else {
 642                         PairedBWAlignerV2<EbwtRangeSource>* al = new PairedBWAlignerV2<EbwtRangeSource>(
 643                                 params, paramsSe1, paramsSe2,
 644                                 new TCostAwareRangeSrcDr(strandFix_, dr1FwVec, verbose_, quiet_, true),
 645                                 refAligner, rchase,
 646                                 sink_, sinkPtFactory_,
 647                                 sinkPt, sinkPtSe1, sinkPtSe2,
 648                                 mate1fw_, mate2fw_,
 649                                 peInner_, peOuter_,
 650                                 mixedAttemptLim_, refs_, rangeMode_,
 651                                 verbose_, quiet_, INT_MAX, pool_, NULL);
 652                         delete dr1FwVec;
 653                         return al;
 654                 }
 655         }
 656
 657 private:
 658         Ebwt<String<Dna> >& ebwtFw_;
 659         Ebwt<String<Dna> >* ebwtBw_;
 660         bool color_;
 661         bool doFw_;
 662         bool doRc_;
 663         bool v1_;
 664         bool two_;
 665         HitSink& sink_;
 666         const HitSinkPerThreadFactory& sinkPtFactory_;
 667         const bool mate1fw_;
 668         const bool mate2fw_;
 669         const uint32_t peInner_;
 670         const uint32_t peOuter_;
 671         const bool dontReconcile_;
 672         const uint32_t symCeil_;
 673         const uint32_t mixedThresh_;
 674         const uint32_t mixedAttemptLim_;
 675         RangeCache *cacheFw_;
 676         RangeCache *cacheBw_;
 677         const uint32_t cacheLimit_;
 678         ChunkPool *pool_;
 679         BitPairReference* refs_;
 680         vector<String<Dna5> >& os_;
 681         const bool reportSe_;
 682         const bool maqPenalty_;
 683         const bool qualOrder_;
 684         const bool strandFix_;
 685         const bool rangeMode_;
 686         const bool verbose_;
 687         const bool quiet_;
 688         const uint32_t seed_;
 689 };
 690
 691 #endif /* ALIGNER_23MM_H_ */