@@ -9,7 +9,7 @@ Description: GSNAP and GMAP are a pair of tools to align short-read

         methods to work with GMAP and GSNAP from within R. In addition,

         it provides methods to tally alignment results on a

         per-nucleotide basis using the bam_tally tool.

-Version: 1.13.1

+Version: 1.13.2

 Depends: R (>= 2.15.0), methods, GenomeInfoDb (>= 1.1.3),

         GenomicRanges (>= 1.17.12)

 Imports: S4Vectors, IRanges, Rsamtools (>= 1.17.8), rtracklayer (>= 1.25.5),

@@ -24,7 +24,8 @@ setClass("BamTallyParam",

                         xs = "logical",

                         read_pos = "logical",

                         min_base_quality = "integer",

-                        noncovered = "logical"))

+                        noncovered = "logical",

+                        nm = "logical"))

 ### - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

 ### Constructor

@@ -107,7 +108,8 @@ BamTallyParam <- function(genome, which = GRanges(),

                           indels = FALSE, include_soft_clips = 0L,

                           exon_iit = NULL, IIT_BPPARAM = NULL,

                           xs = FALSE, read_pos = FALSE,

-                          min_base_quality = 0L, noncovered = FALSE)

+                          min_base_quality = 0L, noncovered = FALSE,

+                          nm = FALSE)

 {

   if (!is.null(desired_read_group) && !isSingleString(desired_read_group))

     stop("'desired_read_group' must be NULL or a single, non-NA string")

@@ -139,6 +141,8 @@ BamTallyParam <- function(genome, which = GRanges(),

     stop("min_base_quality must be a single, non-negative, non-NA number")

   if (!isTRUEorFALSE(noncovered))

     stop("noncovered must be TRUE or FALSE")

+  if (!isTRUEorFALSE(nm))

+    stop("nm must be TRUE or FALSE")

   args <- names(formals(sys.function()))

   params <- mget(args, environment())

   params$genome <- as(genome, "GmapGenome")

@@ -11,11 +11,12 @@ setClass("TallyIIT", representation(ptr = "externalptr",

                                     genome = "GmapGenome",

                                     bam = "BamFile",

                                     xs = "logical",

-                                    read_pos = "logical"))

+                                    read_pos = "logical",

+                                    nm = "logical"))

-TallyIIT <- function(ptr, genome, bam, xs, read_pos) {

+TallyIIT <- function(ptr, genome, bam, xs, read_pos, nm) {

   new("TallyIIT", ptr = ptr, genome = genome, bam = bam, xs = xs,

-      read_pos = read_pos)

+      read_pos = read_pos, nm = nm)

 }

 setMethod("genome", "TallyIIT", function(x) x@genome)

@@ -72,16 +73,22 @@ setMethod("bam_tally", "GmapBamReader",

             TallyIIT(do.call(.bam_tally_C, c(list(x), param_list)), genome,

                      as(x, "BamFile"), xs=param_list$xs,

-                     read_pos=param_list$read_pos)

+                     read_pos=param_list$read_pos, nm=param_list$nm)

           })

-variantSummary <- function(x, read_pos_breaks = NULL, high_base_quality = 0L,

-                           keep_ref_rows = FALSE, read_length = NA_integer_)

+variantSummary <- function(x, read_pos_breaks = NULL,

+                           keep_ref_rows = FALSE, read_length = NA_integer_,

+                           high_nm_score = NA_integer_)

 {

   read_length <- as.integer(read_length)

   if (length(read_length) != 1L) {

     stop("'read_length' must be a single integer")

   }

+  high_nm_score <- as.integer(high_nm_score)

+  stopifnot(length(high_nm_score) == 1L)

+  if (!is.na(high_nm_score) && !x@nm) {

+      stop("'high_nm_score is not NA but NM scores were not tallied")

+  }

   if (length(read_pos_breaks) > 0L) {

     if (!x@read_pos) {

       stop("'read_pos_breaks' non-empty, but read positions were not tallied")

@@ -97,25 +104,23 @@ variantSummary <- function(x, read_pos_breaks = NULL, high_base_quality = 0L,

   tally <- .Call(R_tally_iit_parse, x@ptr,

                  read_pos_breaks,

-                 normArgSingleInteger(high_base_quality),

-                 NULL, read_length, x@xs)

+                 NULL, read_length, x@xs, high_nm_score)

   tally_names <- c("seqnames", "pos", "ref", "alt",

                    "n.read.pos", "n.read.pos.ref",

-                   "raw.count", "raw.count.ref",

-                   "raw.count.total",

-                   "high.quality", "high.quality.ref",

-                   "high.quality.total", "mean.quality",

-                   "mean.quality.ref",

+                   "count", "count.ref", "count.total",

                    "count.plus", "count.plus.ref",

                    "count.minus", "count.minus.ref",

                    "del.count.plus", "del.count.minus",

                    "read.pos.mean", "read.pos.mean.ref",

                    "read.pos.var", "read.pos.var.ref",

-                   "mdfne", "mdfne.ref", "codon.dir",

+                   "mdfne", "mdfne.ref", "codon.strand",

                    "count.xs.plus", "count.xs.plus.ref",

-                   "count.xs.minus", "count.xs.minus.ref")

-  

+                   "count.xs.minus", "count.xs.minus.ref",

+                   "count.high.nm", "count.high.nm.ref")

+

+  tally$codon.strand <- structure(tally$codon.strand, class="factor",

+                                  levels=strand())

   break_names <- character()

   if (length(read_pos_breaks) > 0L) {

     read_pos_breaks <- as.integer(read_pos_breaks)

@@ -124,6 +129,7 @@ variantSummary <- function(x, read_pos_breaks = NULL, high_base_quality = 0L,

     tally_names <- c(tally_names, break_names)

   }

   names(tally) <- tally_names

+  tally <- Filter(Negate(is.null), tally)  

   if (!keep_ref_rows) {

     variant_rows <- !is.na(tally$alt)

@@ -131,23 +137,20 @@ variantSummary <- function(x, read_pos_breaks = NULL, high_base_quality = 0L,

       tally <- lapply(tally, `[`, variant_rows)

   }

-  meta_names <- setdiff(tally_names,

-                        c("seqnames", "pos", "ref", "alt", "high.quality",

-                          "high.quality.ref", "high.quality.total"))

+  meta_names <- setdiff(names(tally),

+                        c("seqnames", "pos", "ref", "alt", "count",

+                          "count.ref", "count.total"))

   genome <- genome(x)

   indel <- nchar(tally$ref) == 0L | nchar(tally$alt) == 0L

   metacols <- DataFrame(tally[meta_names])

   mcols(metacols) <- variantSummaryColumnDescriptions(read_pos_breaks)

-  samecols = tally[["ref"]] != tally[["alt"]]

   gr <- with(tally,

              VRanges(seqnames,

                      IRanges(pos,

                              width = ifelse(nchar(alt) == 0, nchar(ref), 1L)),

                      ref, alt,

-                     ifelse(indel, raw.count.total, high.quality.total),

-                     ifelse(indel, raw.count.ref, high.quality.ref),

-                     ifelse(indel, raw.count, high.quality),

+                     count.total, count.ref, count,

                      seqlengths = seqlengths(genome)))

   mcols(gr) <- metacols

   checkTallyConsistency(gr)

@@ -160,11 +163,8 @@ variantSummary <- function(x, read_pos_breaks = NULL, high_base_quality = 0L,

 checkTallyConsistency <- function(x) {

   with(mcols(x), {

-    stopifnot(all(raw.count + raw.count.ref <= raw.count.total, na.rm=TRUE))

-    stopifnot(all(altDepth(x) <= raw.count, na.rm=TRUE))

-    stopifnot(all(refDepth(x) <= raw.count.ref, na.rm=TRUE))

-    stopifnot(all(count.plus + count.minus == raw.count, na.rm=TRUE))

-    stopifnot(all(count.plus.ref + count.minus.ref == raw.count.ref))

+    stopifnot(all(count.plus + count.minus == altDepth(x), na.rm=TRUE))

+    stopifnot(all(count.plus.ref + count.minus.ref == refDepth(x)))

   })

 }

@@ -228,7 +228,7 @@ normArgSingleCharacterOrNULL <- function(x) {

                          blocksize = 1000L, verbosep = FALSE,

                          include_soft_clips = 0L,

                          exon_iit = NULL, xs = FALSE, read_pos = FALSE,

-                         min_base_quality = 0L, noncovered = FALSE)

+                         min_base_quality = 0L, noncovered = FALSE, nm = FALSE)

 {

   if (!is(bamreader, "GmapBamReader"))

     stop("'bamreader' must be a GmapBamReader")

@@ -262,7 +262,8 @@ normArgSingleCharacterOrNULL <- function(x) {

         normArgTRUEorFALSE(xs),

         normArgTRUEorFALSE(read_pos),

         normArgSingleInteger(min_base_quality),

-        normArgTRUEorFALSE(noncovered))

+        normArgTRUEorFALSE(noncovered),

+        normArgTRUEorFALSE(nm))

 }

 ### - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

@@ -7,7 +7,7 @@

 static const R_CallMethodDef callMethods[] = {

   /* bamtally.c */

-  CALLMETHOD_DEF(R_Bamtally_iit, 25),

+  CALLMETHOD_DEF(R_Bamtally_iit, 26),

   CALLMETHOD_DEF(R_tally_iit_parse, 6),

   /* bamreader.c */

@@ -26,7 +26,8 @@ R_Bamtally_iit (SEXP bamreader_R, SEXP genome_dir_R, SEXP db_R,

                 SEXP verbosep_R, SEXP max_softclip_R,

                 SEXP genome_iit_file_R,

                 SEXP print_xs_scores_p_R, SEXP print_cycles_p_R,

-                SEXP minimum_quality_score_R, SEXP noncovered_R)

+                SEXP minimum_quality_score_R, SEXP noncovered_R,

+                SEXP print_nm_scores_p_R)

 {

   Bamreader_T bamreader = (Bamreader_T) R_ExternalPtrAddr(bamreader_R);

   const char *genome_dir =

@@ -54,6 +55,7 @@ R_Bamtally_iit (SEXP bamreader_R, SEXP genome_dir_R, SEXP db_R,

   bool print_cycles_p = asLogical(print_cycles_p_R);

   int minimum_quality_score = asInteger(minimum_quality_score_R);

   bool noncovered_p = asLogical(noncovered_R);

+  bool print_nm_scores_p = asLogical(print_nm_scores_p_R);

   Genome_T genome = createGenome(genome_dir, db);

   IIT_T chromosome_iit = readChromosomeIIT(genome_dir, db);

@@ -88,7 +90,7 @@ R_Bamtally_iit (SEXP bamreader_R, SEXP genome_dir_R, SEXP db_R,

                                  print_indels_p, blocksize, verbosep,

                                  /*readlevel_p*/false, max_softclip,

                                  print_cycles_p,

-                                 /*print_nm_scores_p*/ false,

+                                 print_nm_scores_p,

                                  print_xs_scores_p, noncovered_p);

   IIT_free(&chromosome_iit);

   Genome_free(&genome);

@@ -23,7 +23,8 @@ R_Bamtally_iit (SEXP bamreader_R, SEXP genome_dir_R, SEXP db_R,

                 SEXP verbosep_R, SEXP max_softclip_R,

                 SEXP genome_iit_file_R,

                 SEXP print_xs_scores_p_R, SEXP print_cycles_p_R,

-                SEXP minimum_quality_score_R, SEXP nonconvered_R);

+                SEXP minimum_quality_score_R, SEXP nonconvered_R,

+                SEXP print_nm_scores_p_R);

 SEXP

 R_tally_iit_parse(SEXP tally_iit_R, SEXP cycle_breaks_R,

@@ -1,4 +1,4 @@

-static char rcsid[] = "$Id: bamtally.c 172388 2015-08-21 20:10:50Z twu $";

+static char rcsid[] = "$Id: bamtally.c 178481 2015-11-09 20:55:28Z twu $";

 #ifdef HAVE_CONFIG_H

 #include <config.h>

 #endif

@@ -859,13 +859,18 @@ pass_variant_filter_p (long int nmatches, long int delcounts_plus, long int delc

   if (variant_strands == 0) {

     return true;

   } else if (variant_strands == 1) {

-    if (mismatches_by_shift == NULL) {

+    /* Not sure if we should look at insertions_byshift also */

+    if (mismatches_by_shift == NULL && delcounts_plus == 0 && delcounts_minus == 0) {

       return false;

     } else {

       return true;

     }

   } else {

+    if (delcounts_plus > 0 && delcounts_minus > 0) {

+      return true;

+    }

+

     plus_strand_p[0] = plus_strand_p[1] = plus_strand_p[2] = plus_strand_p[3] = false;

     minus_strand_p[0] = minus_strand_p[1] = minus_strand_p[2] = minus_strand_p[3] = false;

@@ -873,64 +878,71 @@ pass_variant_filter_p (long int nmatches, long int delcounts_plus, long int delc

     for (ptr = mismatches_by_shift; ptr != NULL; ptr = List_next(ptr)) {

       mismatch = (Mismatch_T) List_head(ptr);

       if (mismatch->shift > 0) {

+	if (delcounts_minus > 0) {

+	  return true;

+	}

 	switch (mismatch->nt) {

 	case 'A':

-	  if (minus_strand_p[0] == true) {

+	  if (minus_strand_p[/*A*/0] == true) {

 	    return true;

 	  } else {

-	    plus_strand_p[0] = true;

+	    plus_strand_p[/*A*/0] = true;

 	  }

 	  break;

 	case 'C':

-	  if (minus_strand_p[1] == true) {

+	  if (minus_strand_p[/*C*/1] == true) {

 	    return true;

 	  } else {

-	    plus_strand_p[1] = true;

+	    plus_strand_p[/*C*/1] = true;

 	  }

 	  break;

 	case 'G': 

-	  if (minus_strand_p[2] == true) {

+	  if (minus_strand_p[/*G*/2] == true) {

 	    return true;

 	  } else {

-	    plus_strand_p[2] = true;

+	    plus_strand_p[/*G*/2] = true;

 	  }

 	  break;

 	case 'T':

-	  if (minus_strand_p[3] == true) {

+	  if (minus_strand_p[/*T*/3] == true) {

 	    return true;

 	  } else {

-	    plus_strand_p[3] = true;

+	    plus_strand_p[/*T*/3] = true;

 	  }

 	  break;

 	}

+

       } else if (mismatch->shift < 0) {

+	if (delcounts_plus > 0) {

+	  return true;

+	}

 	switch (mismatch->nt) {

 	case 'A':

-	  if (plus_strand_p[0] == true) {

+	  if (plus_strand_p[/*A*/0] == true) {

 	    return true;

 	  } else {

-	    minus_strand_p[0] = true;

+	    minus_strand_p[/*A*/0] = true;

 	  }

 	  break;

 	case 'C':

-	  if (plus_strand_p[1] == true) {

+	  if (plus_strand_p[/*C*/1] == true) {

 	    return true;

 	  } else {

-	    minus_strand_p[1] = true;

+	    minus_strand_p[/*C*/1] = true;

 	  }

 	  break;

 	case 'G':

-	  if (plus_strand_p[2] == true) {

+	  if (plus_strand_p[/*G*/2] == true) {

 	    return true;

 	  } else {

-	    minus_strand_p[2] = true;

+	    minus_strand_p[/*G*/2] = true;

 	  }

 	  break;

 	case 'T':

-	  if (plus_strand_p[3] == true) {

+	  if (plus_strand_p[/*T*/3] == true) {

 	    return true;

 	  } else {

-	    minus_strand_p[3] = true;

+	    minus_strand_p[/*T*/3] = true;

 	  }

 	  break;

 	}

@@ -5930,6 +5942,11 @@ Bamtally_run (long int **tally_matches, long int **tally_mismatches,

   ignore_duplicates_p = true;

 #endif

+  /*

+  fprintf(stderr,"Called with alloclength %d, minimum_mapq %d, good_unique_mapq %d, minimum_quality_score %d, maximum_nhits %d, need_concordant_p %d, need_unique_p %d, need_primary_p %d, ignore_duplicates_p %d, min_depth %d, variant_strands %d, ignore_query_Ns_p %d, blocksize %d, verbosep %d, readlevel_p %d, max_softclip %d\n",

+	  alloclength,minimum_mapq,good_unique_mapq,minimum_quality_score,maximum_nhits,need_concordant_p,need_unique_p,need_primary_p,ignore_duplicates_p,min_depth,variant_strands,ignore_query_Ns_p,blocksize,verbosep,readlevel_p,max_softclip);

+  */

+

   /* Create tally at position N to store n_fromleft */

   alloc_tallies_alloc = (Tally_T *) CALLOC(alloclength + 2*max_softclip + 1,sizeof(Tally_T));

@@ -1,4 +1,4 @@

-#define DEBUG2 1

+#define DEBUG2 0

 #include <stdlib.h> /* for abs */

 #include <string.h> /* for strlen */

@@ -7,21 +7,18 @@

 #include "bytestream.h"

 /*I changed the order of these, because the XS spots are optional...*/

-enum { SEQNAMES, POS, REF, READ, N_CYCLES, N_CYCLES_REF, COUNT, COUNT_REF, //8

-       COUNT_TOTAL, HIGH_QUALITY, HIGH_QUALITY_REF, HIGH_QUALITY_TOTAL, //12

-       MEAN_QUALITY, MEAN_QUALITY_REF, //14

-       COUNT_PLUS, COUNT_PLUS_REF, COUNT_MINUS, //17

-       COUNT_MINUS_REF, DELCOUNT_PLUS, DELCOUNT_MINUS, //21

-       READ_POS_MEAN, READ_POS_MEAN_REF, READ_POS_VAR, //24

-       READ_POS_VAR_REF, MDFNE, MDFNE_REF,  CODON_STRAND, //28

-       COUNT_XS_PLUS, COUNT_XS_PLUS_REF, //30

-       COUNT_XS_MINUS, COUNT_XS_MINUS_REF, N_BASE_COLS }; //33

-

-

-enum{ CODON_MINUS = -1,

-      NON_CODON,

-      CODON_PLUS};

-

+enum { SEQNAMES, POS, REF, READ, N_CYCLES, N_CYCLES_REF, COUNT, COUNT_REF,

+       COUNT_TOTAL, COUNT_PLUS, COUNT_PLUS_REF, COUNT_MINUS,

+       COUNT_MINUS_REF, DELCOUNT_PLUS, DELCOUNT_MINUS,

+       READ_POS_MEAN, READ_POS_MEAN_REF, READ_POS_VAR,

+       READ_POS_VAR_REF, MDFNE, MDFNE_REF,  CODON_STRAND,

+       COUNT_XS_PLUS, COUNT_XS_PLUS_REF,

+       COUNT_XS_MINUS, COUNT_XS_MINUS_REF,

+       COUNT_HIGH_NM, COUNT_HIGH_NM_REF, N_BASE_COLS };

+

+enum { CODON_PLUS = 1,

+       CODON_MINUS,

+       NON_CODON };

 static char *codon_table[64] = 

   {"AAA", "AAC", "AAG", "AAT", "ACA", "ACC", "ACG", "ACT",

@@ -33,10 +30,6 @@ static char *codon_table[64] =

    "TAA", "TAC", "TAG", "TAT", "TCA", "TCC", "TCG", "TCT",

    "TGA", "TGC", "TGG", "TGT", "TTA", "TTC", "TTG", "TTT"};

-

-

-

-

 static int NUM_PTRS = 5;

 typedef struct TallyTable {

@@ -49,11 +42,6 @@ typedef struct TallyTable {

   int *count;

   int *count_ref;

   int *count_total;

-  int *high_quality;

-  int *high_quality_ref;

-  int *high_quality_total;

-  double *mean_quality;

-  double *mean_quality_ref;

   int *count_plus;

   int *count_plus_ref;

   int *count_minus;

@@ -70,6 +58,8 @@ typedef struct TallyTable {

   int *count_xs_plus_ref;

   int *count_xs_minus;

   int *count_xs_minus_ref;

+  int *count_high_nm;

+  int *count_high_nm_ref;

   int *strand;

   int **cycle_bins;

 } TallyTable;

@@ -77,16 +67,15 @@ typedef struct TallyTable {

 typedef struct TallyParam {

   int *cycle_breaks;

   int n_cycle_bins;

-  int high_base_quality;

   int read_length;

   double *mdfne_buf;

   bool xs;

+  int high_nm_score;

 } TallyParam;

 static SEXP R_TallyTable_new(int n_rows, int n_cycle_bins, bool xs) {

   SEXP tally_R; /* the result list */

   PROTECT(tally_R = allocVector(VECSXP, N_BASE_COLS + n_cycle_bins));

-  

   SET_VECTOR_ELT(tally_R, SEQNAMES, allocVector(STRSXP, n_rows));

   SET_VECTOR_ELT(tally_R, POS, allocVector(INTSXP, n_rows));

   SET_VECTOR_ELT(tally_R, REF, allocVector(STRSXP, n_rows));

@@ -96,11 +85,6 @@ static SEXP R_TallyTable_new(int n_rows, int n_cycle_bins, bool xs) {

   SET_VECTOR_ELT(tally_R, COUNT, allocVector(INTSXP, n_rows));

   SET_VECTOR_ELT(tally_R, COUNT_REF, allocVector(INTSXP, n_rows));

   SET_VECTOR_ELT(tally_R, COUNT_TOTAL, allocVector(INTSXP, n_rows));

-  SET_VECTOR_ELT(tally_R, HIGH_QUALITY, allocVector(INTSXP, n_rows));

-  SET_VECTOR_ELT(tally_R, HIGH_QUALITY_REF, allocVector(INTSXP, n_rows));

-  SET_VECTOR_ELT(tally_R, HIGH_QUALITY_TOTAL, allocVector(INTSXP, n_rows));

-  SET_VECTOR_ELT(tally_R, MEAN_QUALITY, allocVector(REALSXP, n_rows));

-  SET_VECTOR_ELT(tally_R, MEAN_QUALITY_REF, allocVector(REALSXP, n_rows));

   SET_VECTOR_ELT(tally_R, COUNT_PLUS, allocVector(INTSXP, n_rows));

   SET_VECTOR_ELT(tally_R, COUNT_PLUS_REF, allocVector(INTSXP, n_rows));

   SET_VECTOR_ELT(tally_R, COUNT_MINUS, allocVector(INTSXP, n_rows));

@@ -114,12 +98,15 @@ static SEXP R_TallyTable_new(int n_rows, int n_cycle_bins, bool xs) {

   SET_VECTOR_ELT(tally_R, CODON_STRAND, allocVector(INTSXP, n_rows));

   SET_VECTOR_ELT(tally_R, DELCOUNT_PLUS, allocVector(INTSXP, n_rows));

   SET_VECTOR_ELT(tally_R, DELCOUNT_MINUS, allocVector(INTSXP, n_rows));

-  SET_VECTOR_ELT(tally_R, COUNT_XS_PLUS, allocVector(INTSXP, n_rows));

-  SET_VECTOR_ELT(tally_R, COUNT_XS_PLUS_REF, allocVector(INTSXP, n_rows));

-  SET_VECTOR_ELT(tally_R, COUNT_XS_MINUS, allocVector(INTSXP, n_rows));

-  SET_VECTOR_ELT(tally_R, COUNT_XS_MINUS_REF, allocVector(INTSXP, n_rows));

- 

-

+  if (xs) {

+      SET_VECTOR_ELT(tally_R, COUNT_XS_PLUS, allocVector(INTSXP, n_rows));

+      SET_VECTOR_ELT(tally_R, COUNT_XS_PLUS_REF, allocVector(INTSXP, n_rows));

+      SET_VECTOR_ELT(tally_R, COUNT_XS_MINUS, allocVector(INTSXP, n_rows));

+      SET_VECTOR_ELT(tally_R, COUNT_XS_MINUS_REF, allocVector(INTSXP, n_rows));

+  }

+  SET_VECTOR_ELT(tally_R, COUNT_HIGH_NM, allocVector(INTSXP, n_rows));

+  SET_VECTOR_ELT(tally_R, COUNT_HIGH_NM_REF, allocVector(INTSXP, n_rows));

+  

   for (int bin = 0; bin < n_cycle_bins; bin++) {

     SEXP cycle_bin_R = allocVector(INTSXP, n_rows);

     SET_VECTOR_ELT(tally_R, bin + N_BASE_COLS, cycle_bin_R);

@@ -130,7 +117,7 @@ static SEXP R_TallyTable_new(int n_rows, int n_cycle_bins, bool xs) {

 }

 static TallyTable *TallyTable_new(SEXP tally_R, bool xs) {

-  TallyTable *tally = (TallyTable *) R_alloc(sizeof(TallyTable), 1);

+  TallyTable *tally = (TallyTable *) S_alloc(sizeof(TallyTable), 1);

   int n_cycle_bins = length(tally_R) - N_BASE_COLS;

   tally->seqnames_R = VECTOR_ELT(tally_R, SEQNAMES);

@@ -142,11 +129,6 @@ static TallyTable *TallyTable_new(SEXP tally_R, bool xs) {

   tally->count = INTEGER(VECTOR_ELT(tally_R, COUNT));

   tally->count_ref = INTEGER(VECTOR_ELT(tally_R, COUNT_REF));

   tally->count_total = INTEGER(VECTOR_ELT(tally_R, COUNT_TOTAL));

-  tally->high_quality = INTEGER(VECTOR_ELT(tally_R, HIGH_QUALITY));

-  tally->high_quality_ref = INTEGER(VECTOR_ELT(tally_R, HIGH_QUALITY_REF));

-  tally->high_quality_total = INTEGER(VECTOR_ELT(tally_R, HIGH_QUALITY_TOTAL));

-  tally->mean_quality = REAL(VECTOR_ELT(tally_R, MEAN_QUALITY));

-  tally->mean_quality_ref = REAL(VECTOR_ELT(tally_R, MEAN_QUALITY_REF));

   tally->count_plus = INTEGER(VECTOR_ELT(tally_R, COUNT_PLUS));

   tally->count_plus_ref = INTEGER(VECTOR_ELT(tally_R, COUNT_PLUS_REF));

   tally->count_minus = INTEGER(VECTOR_ELT(tally_R, COUNT_MINUS));

@@ -161,12 +143,18 @@ static TallyTable *TallyTable_new(SEXP tally_R, bool xs) {

   tally->delcount_plus = INTEGER(VECTOR_ELT(tally_R, DELCOUNT_PLUS));

   tally->delcount_minus = INTEGER(VECTOR_ELT(tally_R, DELCOUNT_MINUS));

   tally->cycle_bins = (int **) R_alloc(sizeof(int*), n_cycle_bins);

-  tally->count_xs_plus = INTEGER(VECTOR_ELT(tally_R, COUNT_XS_PLUS));

-  tally->count_xs_plus_ref = INTEGER(VECTOR_ELT(tally_R, COUNT_XS_PLUS_REF));

-  tally->count_xs_minus = INTEGER(VECTOR_ELT(tally_R, COUNT_XS_MINUS));

-  tally->count_xs_minus_ref = INTEGER(VECTOR_ELT(tally_R, COUNT_XS_MINUS_REF));

+  if (xs) {

+      tally->count_xs_plus = INTEGER(VECTOR_ELT(tally_R, COUNT_XS_PLUS));

+      tally->count_xs_plus_ref = INTEGER(VECTOR_ELT(tally_R,

+                                                    COUNT_XS_PLUS_REF));

+      tally->count_xs_minus = INTEGER(VECTOR_ELT(tally_R, COUNT_XS_MINUS));

+      tally->count_xs_minus_ref = INTEGER(VECTOR_ELT(tally_R,

+                                                     COUNT_XS_MINUS_REF));

+  }

+  tally->count_high_nm = INTEGER(VECTOR_ELT(tally_R, COUNT_HIGH_NM));

+  tally->count_high_nm_ref = INTEGER(VECTOR_ELT(tally_R,

+                                                COUNT_HIGH_NM_REF));

-

   for (int bin = 0; bin < n_cycle_bins; bin++) {

     tally->cycle_bins[bin] = INTEGER(VECTOR_ELT(tally_R, bin + N_BASE_COLS));

   }

@@ -181,11 +169,30 @@ read_total_counts(unsigned char **bytes, int row, int *count_total) {

   count_total[row] = count_total_plus + count_total_minus;

 }

+static void

+read_nm_counts(unsigned char **bytes, int row, int *count_high_nm,

+               int high_nm_score)

+{

+    int n_nm = read_int(bytes);

+    count_high_nm[row] = 0;

+    /* FIXME: currently bam_tally gives us counts whether we want them or not */

+    for (int index = 0; index < n_nm; index++) {

+        int nm = read_int(bytes);

+	int count = read_int(bytes);

+        if (nm >= high_nm_score) {

+            count_high_nm[row] += count;

+        }

+    }

+}

+

 static void

 read_xs_counts(unsigned char **bytes, int row, int *count_xs_plus,

                int *count_xs_minus)

 {

     int n_xs = read_int(bytes);

+    if (count_xs_plus == NULL) {

+        return;

+    }

     count_xs_plus[row] = 0;

     count_xs_minus[row] = 0;

     for (int index = 0; index < n_xs; index++) {

@@ -197,14 +204,8 @@ read_xs_counts(unsigned char **bytes, int row, int *count_xs_plus,

 	    count_xs_minus[row] = count;

 	} 

     }

-#ifdef DEBUG2

-    printf("row %d xs counts: %d plus %d minus", row, count_xs_plus[row], count_xs_minus[row]);

-#endif

 }

-

-

-

 static void

 read_cycle_counts(unsigned char **bytes, int row, TallyParam param,

                   int *n_cycles, double *read_pos_mean, double *read_pos_var,

@@ -274,9 +275,6 @@ parse_indels(unsigned char *bytes, int row,

              TallyParam param, TallyTable *tally, bool insertion)

 {

   int indel_count = read_int(&bytes);

-#ifdef DEBUG2

-  printf("row %d indel count: %d", row, indel_count);

-#endif

   for (int indel = 0; indel < indel_count; indel++, row++) {

     for (int b = 0; b < param.n_cycle_bins; b++) {

       tally->cycle_bins[b][row] = 0;

@@ -302,72 +300,48 @@ parse_indels(unsigned char *bytes, int row,

     read_cycle_counts(&bytes, row, param, tally->n_cycles,

                       tally->read_pos_mean, tally->read_pos_var,

                       tally->mdfne, tally->cycle_bins);

-    /* quality is per-base and so not relevant for indels */

-    tally->mean_quality[row] = NA_REAL;

-    tally->mean_quality_ref[row] = NA_REAL;

-    tally->high_quality[row] = NA_INTEGER;

-    tally->high_quality_ref[row] = NA_INTEGER;

-    tally->high_quality_total[row] = NA_INTEGER;

+    read_nm_counts(&bytes, row, tally->count_high_nm, param.high_nm_score);

+    read_xs_counts(&bytes, row, tally->count_xs_plus, tally->count_xs_minus);

     /* no position from which to tabulate the cycles */

     tally->n_cycles_ref[row] = NA_INTEGER;

     tally->read_pos_mean_ref[row] = NA_REAL;

     tally->read_pos_var_ref[row] = NA_REAL;

     tally->mdfne_ref[row] = NA_REAL;

-  }

-  return indel_count;

-}

-

-static void

-read_quality_counts(unsigned char **bytes, int row, int *high_quality,

-                    double *mean_quality, int high_base_quality)

-{

-  int n_qualities = read_int(bytes);

-  int total_quality = 0;

-  int total_quality_weight = 0;

-  high_quality[row] = 0;

-  for (int index = 0; index < n_qualities; index++) {

-    int quality = read_int(bytes);

-    int count = read_int(bytes);

-    if (quality >= high_base_quality) {

-	total_quality += quality * count;

-	total_quality_weight += count;

-	high_quality[row] += count;

+    /* overlapping deletion count only relevant for SNVs */

+    tally->delcount_plus[row] = NA_INTEGER;

+    tally->delcount_minus[row] = NA_INTEGER;

+    /* information not available for "ref" allele */

+    tally->count_high_nm_ref[row] = NA_INTEGER;

+    if (param.xs) {

+        tally->count_xs_plus_ref[row] = NA_INTEGER;

+        tally->count_xs_minus_ref[row] = NA_INTEGER;

     }

   }

-  mean_quality[row] = total_quality_weight > 0 ?

-    (double)total_quality / total_quality_weight : R_NaN;

+  return indel_count;

 }

 static int

 read_allele_counts(unsigned char **bytes, int row, SEXP read_R,

-                   int *count_plus, int *count_minus, int *count, int strand)

+                   int *count_plus, int *count_minus, int *count,

+                   int *delcount_plus, int *delcount_minus,

+                   int strand)

 {

   int n_alleles = 0;

   char allele;

   char stop = strand == 0 ? '\0' : (char) 255;

-#ifdef DEBUG2

-  printf("Starting read_allele_counts (codon strand %d) at row %d. Total length of read_R is %d\n", strand, row, LENGTH(read_R));

-#endif

+  

   while((allele = (char)read_char(bytes)) != stop) {

-#ifdef DEBUG2

-      printf("Parsing counts for allele: %d (%s) row %d \n", allele, &allele, row );

-#endif

+    if (allele == '_') {

+        *delcount_plus = read_int(bytes);

+        *delcount_minus = read_int(bytes);

+        continue;

+    }

     if(strand == 0)

        SET_STRING_ELT(read_R, row, mkCharLen(&allele, 1));

     else

        SET_STRING_ELT(read_R, row, mkCharLen(codon_table[(int)allele], 3));

-#ifdef DEBUG2

-    printf("Reading allele plus count: ");

-#endif

     count_plus[row] = read_int(bytes);

-#ifdef DEBUG2

-    printf("%d\n", count_plus[row]);

-    printf("Reading allele minus count: ");

-#endif

     count_minus[row] = read_int(bytes);

-#ifdef DEBUG2

-    printf("%d\n", count_minus[row]);

-#endif

     count[row] = count_plus[row] + count_minus[row];

     row++;

     n_alleles++;

@@ -376,69 +350,35 @@ read_allele_counts(unsigned char **bytes, int row, SEXP read_R,

   return n_alleles;

 }

-

-//format _(int)(int) 

-static void

-read_del_counts(unsigned char **bytes, int row, int *delcount_plus,

-                int *delcount_minus)

-{

-

-//This consumes a byte!!!

-    unsigned char mychar = read_char(bytes);

-#ifdef DEBUG2

-    printf("in read_del_counts, mchar is (as int) %d", mychar);

-#endif 

-

-    if(mychar == '_') {

-

-

-	*delcount_plus = read_int(bytes);

-	*delcount_minus = read_int(bytes);

-#ifdef DEBUG2 

-	printf("read_del_counts: '_' character detected. count plus %d count minus %d\n", *delcount_plus, *delcount_minus);

-#endif

-    } else {

-	//backtrack char consumption if it wasn't a "_"

-	*bytes = *bytes-1;

-	*delcount_plus = 0;

-	*delcount_minus = 0;

-    }

-    return;

-}

-

 static int

 parse_alleles(unsigned char *bytes, int row, int ref_row,

               TallyParam param, TallyTable *tally, int strand)

 {

-  bool have_ref_row = false;

   read_total_counts(&bytes, row, tally->count_total);

+  int delcount_plus = 0, delcount_minus = 0;

   int n_alleles = read_allele_counts(&bytes, row, tally->read_R,

                                      tally->count_plus, tally->count_minus,

 	                             tally->count,

+                                     &delcount_plus, &delcount_minus,

 	                             strand);

-  int delcount_plus, delcount_minus;

-/*  read_del_counts(&bytes, row, &delcount_plus, &delcount_minus);*/

   for (int allele = 0; allele < n_alleles; allele++, row++) {

     tally->n_cycles[row] = 0;

     for (int b = 0; b < param.n_cycle_bins; b++) {

       tally->cycle_bins[b][row] = 0;

     }

-    tally->high_quality[row] = 0;

-    tally->mean_quality[row] = R_NaN;

     tally->strand[row] = strand;

-    tally->delcount_plus[row] = R_NaN;//delcount_plus;

-    tally->delcount_minus[row] = R_NaN;//delcount_minus;

+    tally->delcount_plus[row] = delcount_plus;

+    tally->delcount_minus[row] = delcount_minus;

     if (tally->count[row] > 0) {

       read_cycle_counts(&bytes, row, param, tally->n_cycles,

                         tally->read_pos_mean, tally->read_pos_var,

                         tally->mdfne, tally->cycle_bins);

-      read_quality_counts(&bytes, row, tally->high_quality, tally->mean_quality,

-                          param.high_base_quality);

+      read_nm_counts(&bytes, row, tally->count_high_nm, param.high_nm_score);

       if (param.xs) {

-        read_xs_counts(&bytes, row, tally->count_xs_plus, tally->count_xs_minus);

+        read_xs_counts(&bytes, row, tally->count_xs_plus,

+                       tally->count_xs_minus);

       }

-

     } else {

       tally->read_pos_mean[row] = R_NaN;

       tally->read_pos_var[row] = NA_REAL;

@@ -446,27 +386,19 @@ parse_alleles(unsigned char *bytes, int row, int ref_row,

       if (param.xs) {

         tally->count_xs_plus[row] = 0;

         tally->count_xs_minus[row] = 0;

-      

       }

     }

-    have_ref_row = true;

-  }

-  int high_quality_total = 0;

-  for (int r = ref_row; r < row; r++) {

-    high_quality_total += tally->high_quality[r];

   }

   for (int r = ref_row; r < row; r++) {

     tally->n_cycles_ref[r] = tally->n_cycles[ref_row];

     tally->count_total[r] = tally->count_total[ref_row];

-    tally->mean_quality_ref[r] = tally->mean_quality[ref_row];

-    tally->high_quality_ref[r] = tally->high_quality[ref_row];

-    tally->high_quality_total[r] = high_quality_total;

     tally->count_plus_ref[r] = tally->count_plus[ref_row];

     tally->count_minus_ref[r] = tally->count_minus[ref_row];

     tally->count_ref[r] = tally->count_plus_ref[r] + tally->count_minus_ref[r];

     tally->read_pos_mean_ref[r] = tally->read_pos_mean[ref_row];

     tally->read_pos_var_ref[r] = tally->read_pos_var[ref_row];

     tally->mdfne_ref[r] = tally->mdfne[ref_row];

+    tally->count_high_nm_ref[r] = tally->count_high_nm[ref_row];

     if (param.xs) {

       tally->count_xs_plus_ref[r] = tally->count_xs_plus[ref_row];

       tally->count_xs_minus_ref[r] = tally->count_xs_minus[ref_row];

@@ -474,12 +406,9 @@ parse_alleles(unsigned char *bytes, int row, int ref_row,

     SET_STRING_ELT(tally->ref_R, r, STRING_ELT(tally->read_R, ref_row));  

   }

-//  if (have_ref_row) {

     /* clear the 'alt' columns for the 'ref' row with NAs */

     SET_STRING_ELT(tally->read_R, ref_row, NA_STRING);

     tally->n_cycles[ref_row] = NA_INTEGER;

-    tally->mean_quality[ref_row] = NA_REAL;

-    tally->high_quality[ref_row] = NA_REAL;

     tally->count_plus[ref_row] = NA_INTEGER;

     tally->count_minus[ref_row] = NA_INTEGER;

     tally->count[ref_row] = NA_INTEGER;

@@ -491,7 +420,6 @@ parse_alleles(unsigned char *bytes, int row, int ref_row,

       tally->count_xs_minus[ref_row] = NA_INTEGER;

     }

-// }

   return n_alleles;

 }

@@ -504,11 +432,9 @@ static int parse_allele_count(unsigned char *bytes) {

   int n_alleles = 1; /* always have a reference */

   bytes += sizeof(int) * 4 + 1; /* skip total and reference */

   while(bytes[0] != '\0') {

-#ifdef DEBUG2

-    printf("Found allele %s\n", &bytes[0]);

-#endif

-    bytes += sizeof(int) * 2 + 1;

-    n_alleles++;

+      if (bytes[0] != '_')

+          n_alleles++;

+      bytes += sizeof(int) * 2 + 1;

   }

   return n_alleles;

 }

@@ -518,9 +444,6 @@ static int parse_codon_count(unsigned char *bytes) {

   int n_alleles = 1; /* always have a reference */

   bytes += sizeof(int) * 4 + 1; /* skip reference */

   while((int) bytes[0] != 255 ){ // && bytes [0] != '\0') {

-#ifdef DEBUG2

-    printf("Found codon %d\n", bytes[0]);

-#endif

     bytes += sizeof(int) * 2 + 1;

     n_alleles++;

   }

@@ -571,38 +494,12 @@ static int parse_interval(IIT_T tally_iit, int index,

   SEXP divstring_R;

   PROTECT(divstring_R = mkChar(IIT_divstring_from_index(tally_iit, index)));

   for (int position = 0; position < width; position++) {

-#ifdef DEBUG2

-    printf("Reading insertion offset: ");

-#endif

     int insertion_offset = read_int(&bytes);

-#ifdef DEBUG2

-    printf("%d\n", insertion_offset);

-    printf("Reading deletion offset: ");

-#endif

     int deletion_offset = read_int(&bytes);

-#ifdef DEBUG2

-    printf("%d\n", deletion_offset);

-    printf("Reading allele offset: ");

-#endif

     int allele_offset = read_int(&bytes);

-#ifdef DEBUG2

-    printf("%d\n", allele_offset);

-    printf("Reading codon plus offset: ");

-#endif

     int codon_plus_offset = read_int(&bytes);

-#ifdef DEBUG2

-    printf("%d\n", codon_plus_offset);

-    printf("Reading codon_minus offset: ");

-#endif

     int codon_minus_offset = read_int(&bytes);

-#ifdef DEBUG2

-    printf("%d\n", codon_minus_offset);

-    printf("Reading 'next' offset: ");

-#endif

     int next_offset = read_int(&bytes);

-#ifdef DEBUG2

-    printf("%d\n", next_offset);

-#endif

     int ref_row = row;

     bytes -= 4; /* rewind from read-ahead */

     if (codon_plus_offset - allele_offset > 0)

@@ -616,12 +513,10 @@ static int parse_interval(IIT_T tally_iit, int index,

                           param, tally, false);

     if (codon_minus_offset - codon_plus_offset > 0) {

-//      ref_row = row;

       row += parse_alleles(base + codon_plus_offset, row, row,

                            param, tally, CODON_PLUS);

     }

     if (next_offset - codon_minus_offset > 0) { 

-//      ref_row = row;

       row += parse_alleles(base + codon_minus_offset, row, row,

                            param, tally, CODON_MINUS);

     }

@@ -640,17 +535,9 @@ static SEXP parse_all(IIT_T tally_iit, TallyParam param)

   int n_rows = 0;

   /* loop over the IIT, getting the total number of rows

      this is (num alts + 1) for every position. */

-#ifdef DEBUG2

-  printf("Total number of intervals: %d\n", IIT_total_nintervals(tally_iit));

-#endif

   for (int index = 1; index <= IIT_total_nintervals(tally_iit); index++) {

     n_rows += count_rows_for_interval(tally_iit, index);

   }

-

-#ifdef DEBUG2

-  printf("Total number of rows: %d\n", n_rows);