@@ -77,19 +77,24 @@ variantSummary <- function(x, read_pos_breaks = NULL, high_base_quality = 0L,

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

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

   }

+  if (is.na(read_length)) {

+    read_length <- guessReadLengthFromBam(bamFile(x))

+  }

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

                  read_pos_breaks,

                  normArgSingleInteger(high_base_quality),

                  NULL, read_length)

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

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

+  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.pos", "count.pos.ref",

-                   "count.neg", "count.neg.ref",

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

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

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

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

                    "mdfne", "mdfne.ref")

   break_names <- character()

   if (length(read_pos_breaks) > 0L) {

@@ -155,6 +160,14 @@ normalizeIndelAlleles <- function(x, genome) {

   x

 }

+guessReadLengthFromBam <- function(x, n=100L) {

+  ga <- readGAlignments(BamSampler(x, yieldSize=n))

+  readlen <- unique(qwidth(ga))

+  if (length(readlen) != 1L)

+    NA

+  else readlen

+}

+

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

 ### Low-level wrappers

 ###

@@ -232,15 +245,21 @@ normArgTRUEorFALSE <- function(x) {

 variantSummaryColumnDescriptions <- function(read_pos_breaks) {

   desc <- c(

+    n.read.pos = "Number of unique read positions for the ALT",

+    n.read.pos.ref = "Number of unique read positions for the REF",

     raw.count = "Raw ALT count",

     raw.count.ref = "Raw REF count",

     raw.count.total = "Raw total count",

     mean.quality = "Average ALT base quality",

     mean.quality.ref = "Average REF base quality",

-    count.pos = "Raw positive strand ALT count",

-    count.pos.ref = "Raw positive strand REF count",

-    count.neg = "Raw negative strand ALT count",

-    count.neg.ref = "Raw negative strand REF count",

+    count.plus = "Raw positive strand ALT count",

+    count.plus.ref = "Raw positive strand REF count",

+    count.minus = "Raw negative strand ALT count",

+    count.minus.ref = "Raw negative strand REF count",

+    read.pos.mean = "Average read position for the ALT",

+    read.pos.mean.ref = "Average read position for the ALT",

+    read.pos.var = "Variance in read position for the ALT",

+    read.pos.var.ref = "Variance in read position for the REF",

     mdfne = "Median distance from nearest end of read for the ALT",

     mdfne.ref = "Median distance from nearest end of read for the REF")

   if (length(read_pos_breaks) > 0L) {

@@ -50,27 +50,28 @@ variantSummary(x, read_pos_breaks = NULL, high_base_quality = 0L,

   after quality filtering (except for indels, for which there is no

   quality filtering). The following \code{elementMetadata}

   columns are also present:

-  \item{n.read.pos}{The number of unique cycles at which the alternate allele was

-    observed, \code{NA} for the reference allele row.}

-  \item{n.read.pos.ref}{The number of unique cycles at which the reference

-    allele was observed.}

   \item{raw.count}{The number of reads with the alternate allele,

     \code{NA} for the reference allele row.}

   \item{raw.count.ref}{The number of reads with the reference allele.}

   \item{raw.count.total}{The total number of reads at that position,

     including reference and all alternates.}

+  \item{mean.quality}{The mean mapping quality for the alt allele.}

   \item{mean.quality.ref}{The mean mapping quality for the reference

     allele.}

-  \item{count.pos}{The number of positive strand reads for the alternate

+  \item{count.plus}{The number of positive strand reads for the alternate

     allele, \code{NA} for the reference allele row.}

-  \item{count.pos.ref}{The number of positive strand reads for the reference

+  \item{count.plus.ref}{The number of positive strand reads for the reference

     allele.}

-  \item{count.neg}{The number of negative strand reads for the alternate

+  \item{count.minus}{The number of negative strand reads for the alternate

     allele, \code{NA} for the reference allele row.}

-  \item{count.neg.ref}{The number of negative strand reads for the reference

+  \item{count.minus.ref}{The number of negative strand reads for the reference

     allele.}

+  \item{read.pos.mean}{Mean read position for the alt allele.}

+  \item{read.pos.mean.ref}{Mean read position for the ref allele.}

   \item{read.pos.var}{Variance in the read positions for the alt allele.}

   \item{read.pos.var.ref}{Variance in the read positions for the ref allele.}

+  \item{mdfne}{Median distance from nearest end for the alt allele.}

+  \item{mdfne.ref}{Median distance from nearest end for the ref allele.}

   An additional column is present for each bin formed by

   the \code{read_pos_breaks} parameter, with the read count for that bin.

@@ -4,16 +4,19 @@

 #include "iit.h"

 #include "bytestream.h"

-enum { SEQNAMES, POS, REF, READ, COUNT, COUNT_REF,

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

        COUNT_TOTAL, HIGH_QUALITY, HIGH_QUALITY_REF, HIGH_QUALITY_TOTAL,

        MEAN_QUALITY, MEAN_QUALITY_REF, COUNT_PLUS, COUNT_PLUS_REF, COUNT_MINUS,

-       COUNT_MINUS_REF, MDFNE, MDFNE_REF, N_BASE_COLS };

+       COUNT_MINUS_REF, READ_POS_MEAN, READ_POS_MEAN_REF, READ_POS_VAR,

+       READ_POS_VAR_REF, MDFNE, MDFNE_REF, N_BASE_COLS };

 typedef struct TallyTable {

   SEXP seqnames_R;

   int *pos;

   SEXP ref_R;

   SEXP read_R;

+  int *n_cycles;

+  int *n_cycles_ref;

   int *count;

   int *count_ref;

   int *count_total;

@@ -26,6 +29,10 @@ typedef struct TallyTable {

   int *count_plus_ref;

   int *count_minus;

   int *count_minus_ref;

+  double *read_pos_mean;

+  double *read_pos_mean_ref;

+  double *read_pos_var;

+  double *read_pos_var_ref;

   double *mdfne;

   double *mdfne_ref;

   int **cycle_bins;

@@ -47,6 +54,8 @@ static SEXP R_TallyTable_new(int n_rows, int n_cycle_bins) {

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

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

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

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

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

   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));

@@ -59,6 +68,10 @@ static SEXP R_TallyTable_new(int n_rows, int n_cycle_bins) {

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

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

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

+  SET_VECTOR_ELT(tally_R, READ_POS_MEAN, allocVector(REALSXP, n_rows));

+  SET_VECTOR_ELT(tally_R, READ_POS_MEAN_REF, allocVector(REALSXP, n_rows));

+  SET_VECTOR_ELT(tally_R, READ_POS_VAR, allocVector(REALSXP, n_rows));

+  SET_VECTOR_ELT(tally_R, READ_POS_VAR_REF, allocVector(REALSXP, n_rows));

   SET_VECTOR_ELT(tally_R, MDFNE, allocVector(REALSXP, n_rows));

   SET_VECTOR_ELT(tally_R, MDFNE_REF, allocVector(REALSXP, n_rows));

@@ -79,6 +92,8 @@ static TallyTable *TallyTable_new(SEXP tally_R) {

   tally->pos = INTEGER(VECTOR_ELT(tally_R, POS));

   tally->ref_R = VECTOR_ELT(tally_R, REF);

   tally->read_R = VECTOR_ELT(tally_R, READ);

+  tally->n_cycles = INTEGER(VECTOR_ELT(tally_R, N_CYCLES));

+  tally->n_cycles_ref = INTEGER(VECTOR_ELT(tally_R, N_CYCLES_REF));

   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));

@@ -91,6 +106,10 @@ static TallyTable *TallyTable_new(SEXP tally_R) {

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

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

   tally->count_minus_ref = INTEGER(VECTOR_ELT(tally_R, COUNT_MINUS_REF));

+  tally->read_pos_mean = REAL(VECTOR_ELT(tally_R, READ_POS_MEAN));

+  tally->read_pos_mean_ref = REAL(VECTOR_ELT(tally_R, READ_POS_MEAN_REF));

+  tally->read_pos_var = REAL(VECTOR_ELT(tally_R, READ_POS_VAR));

+  tally->read_pos_var_ref = REAL(VECTOR_ELT(tally_R, READ_POS_VAR_REF));

   tally->mdfne = REAL(VECTOR_ELT(tally_R, MDFNE));

   tally->mdfne_ref = REAL(VECTOR_ELT(tally_R, MDFNE_REF));

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

@@ -110,18 +129,19 @@ read_total_counts(unsigned char **bytes, int row, int *count_total) {

 static void

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

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

                   double *mdfne, int **cycle_bins)

 {

   int n_cycle_breaks = param.n_cycle_bins + 1;

-  int count_sum = 0;

+  int count_sum = 0, weighted_sum = 0, weighted_sum_sq = 0;

   int midpoint = param.read_length / 2.0 + 0.5;

   if (param.mdfne_buf != NULL) {

     memset(param.mdfne_buf, 0, sizeof(int) * midpoint);

   }

-  int n_cycles = read_int(bytes);

+  n_cycles[row] = read_int(bytes);

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

+  for (int index = 0; index < n_cycles[row]; index++) {

     int cycle = abs(read_int(bytes));

     int count = read_int(bytes);

     int bin = 0;

@@ -129,6 +149,8 @@ read_cycle_counts(unsigned char **bytes, int row, TallyParam param,

       param.mdfne_buf[midpoint-abs(cycle-midpoint)-1] = count;

     }

     count_sum += count;

+    weighted_sum += cycle * count;

+    weighted_sum_sq += cycle * cycle * count;

     if (param.cycle_breaks != NULL) {

       while(n_cycle_breaks > bin &&

             cycle > param.cycle_breaks[bin])

@@ -138,6 +160,14 @@ read_cycle_counts(unsigned char **bytes, int row, TallyParam param,

       }

     }

   }

+

+  read_pos_mean[row] = ((double)weighted_sum) / count_sum;

+  if (count_sum > 1) {

+    read_pos_var[row] = ((double)weighted_sum_sq) / (count_sum - 1) -

+      (count_sum / (count_sum - 1)) * read_pos_mean[row] * read_pos_mean[row];

+  } else {

+    read_pos_var[row] = NA_REAL;

+  }

   mdfne[row] = NA_REAL;

   if (param.mdfne_buf != NULL) {

@@ -187,7 +217,8 @@ parse_indels(unsigned char *bytes, int row,

       SET_STRING_ELT(tally->read_R, row, R_BlankString);

       SET_STRING_ELT(tally->ref_R, row, seq_R);

     }

-    read_cycle_counts(&bytes, row, param,

+    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;

@@ -196,6 +227,9 @@ parse_indels(unsigned char *bytes, int row,

     tally->high_quality_ref[row] = NA_INTEGER;

     tally->high_quality_total[row] = NA_INTEGER;

     /* 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;

@@ -248,17 +282,21 @@ parse_alleles(unsigned char *bytes, int row, int ref_row,

                                      tally->count_plus, tally->count_minus,

                                      tally->count);

   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;

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

-      read_cycle_counts(&bytes, row, param,

+      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);

     } else {

+      tally->read_pos_mean[row] = R_NaN;

+      tally->read_pos_var[row] = NA_REAL;

       tally->mdfne[row] = NA_REAL;

     }

   }

@@ -267,6 +305,7 @@ parse_alleles(unsigned char *bytes, int row, int ref_row,

     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];

@@ -274,6 +313,8 @@ parse_alleles(unsigned char *bytes, int row, int ref_row,

     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];

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

   }

@@ -281,11 +322,14 @@ parse_alleles(unsigned char *bytes, int row, int 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;

+    tally->read_pos_mean[ref_row] = NA_REAL;

+    tally->read_pos_var[ref_row] = NA_REAL;

     tally->mdfne[ref_row] = NA_REAL;

   }

   return n_alleles;