From 9a68f43fcf3e08fd2319b8b859ed023a7eb3c51f Mon Sep 17 00:00:00 2001
From: tedsharpe <tsharpe@broadinstitute.org>
Date: Fri, 12 Apr 2019 14:14:13 -0400
Subject: [PATCH] improve readCounts report to make categories mutually
 exclusive and tallyable

---
 .../tools/AnalyzeSaturationMutagenesis.java   | 247 ++++++++++--------
 .../AnalyzeSaturationMutagenesisUnitTest.java | 167 ++++++------
 2 files changed, 213 insertions(+), 201 deletions(-)

diff --git a/src/main/java/org/broadinstitute/hellbender/tools/AnalyzeSaturationMutagenesis.java b/src/main/java/org/broadinstitute/hellbender/tools/AnalyzeSaturationMutagenesis.java
index 06a154bdd32..1ee8d7a0bd6 100644
--- a/src/main/java/org/broadinstitute/hellbender/tools/AnalyzeSaturationMutagenesis.java
+++ b/src/main/java/org/broadinstitute/hellbender/tools/AnalyzeSaturationMutagenesis.java
@@ -35,8 +35,8 @@
  *
  * <h3>Input</h3>
  * <ul>
- * <li>A BAM file. Any combination of paired or unpaired reads can be presented.  In paired mode, the default mode
- * of operation of the program where overlapping pairs are combined bedore variant calling, the BAM must be
+ * <li>A BAM file. Any combination of paired or unpaired reads can be presented.  In paired mode (the default mode
+ * of operation of the program where overlapping pairs are combined before variant calling), the BAM must be
  * in unsorted or query-name sorted order (so that read pairs are adjacent).  The BAM file should be
  * aligned to the amplicon under scrutiny.  You may also specify a text file listing several BAMs.</li>
  * <li>A fasta-formatted reference file with the wild-type sequence of the gene as a single contig.  It's best
@@ -118,15 +118,17 @@ public final class AnalyzeSaturationMutagenesis extends GATKTool {
     @Argument(doc = "paired mode evaluation of variants (combine mates, when possible)", fullName = "paired-mode")
     private static boolean pairedMode = true;
 
-    private static Reference reference;
-    private static CodonTracker codonTracker; // device for turning SNVs into CodonVariations
+    @VisibleForTesting static Reference reference;
+    @VisibleForTesting static CodonTracker codonTracker; // device for turning SNVs into CodonVariations
 
     // a map of SNV sets onto number of observations of that set of variations
-    private final HopscotchMap<SNVCollectionCount, Long, SNVCollectionCount> variationCounts =
+    private static final HopscotchMap<SNVCollectionCount, Long, SNVCollectionCount> variationCounts =
             new HopscotchMap<>(10000000);
 
-    private final ReadCounts readCounts = new ReadCounts();
-    private final MoleculeCounts moleculeCounts = new MoleculeCounts();
+    private static final ReadCounts readCounts = new ReadCounts();
+    private static final MoleculeCounts moleculeCountsUnpaired = new MoleculeCounts();
+    private static final MoleculeCounts moleculeCountsDisjointPair = new MoleculeCounts();
+    private static final MoleculeCounts moleculeCountsOverlappingPair = new MoleculeCounts();
 
     // a place to stash the first read of a pair during pairwise processing of the read stream
     private GATKRead read1 = null;
@@ -167,7 +169,6 @@ public void onTraversalStart() {
 
     @Override
     public void traverse() {
-        final byte[] refSeq = reference.getRefSeq();
 
         // ignore non-primary alignments
         final Stream<GATKRead> reads = getTransformedReadStream(ReadFilterLibrary.PRIMARY_LINE);
@@ -175,8 +176,8 @@ public void traverse() {
         if ( !pairedMode ) {
             reads.forEach(read -> {
                 try {
-                    final ReadReport report = getReadReport(read, refSeq, readCounts, reference);
-                    report.updateCounts(moleculeCounts, codonTracker, variationCounts, reference);
+                    final ReadReport report = getReadReport(read);
+                    report.updateCounts(moleculeCountsUnpaired, codonTracker, variationCounts, reference);
                 } catch ( final Exception e ) {
                     final String readName = read.getName();
                     throw new GATKException("Caught unexpected exception on read " +
@@ -188,20 +189,17 @@ public void traverse() {
             reads.forEach(read -> {
                 try {
                     if ( !read.isPaired() ) {
-                        final ReadReport report = getReadReport(read, refSeq, readCounts, reference);
-                        report.updateCounts(moleculeCounts, codonTracker, variationCounts, reference);
+                        final ReadReport report = getReadReport(read);
+                        report.updateCounts(moleculeCountsUnpaired, codonTracker, variationCounts, reference);
                     } else if ( read1 == null ) {
                         read1 = read;
                     } else if ( !read1.getName().equals(read.getName()) ) {
                         logger.warn("Read " + read1.getName() + " has no mate.");
-                        final ReadReport report = getReadReport(read1, refSeq, readCounts, reference);
-                        report.updateCounts(moleculeCounts, codonTracker, variationCounts, reference);
+                        final ReadReport report = getReadReport(read1);
+                        report.updateCounts(moleculeCountsUnpaired, codonTracker, variationCounts, reference);
                         read1 = read;
                     } else {
-                        final ReadReport report = combineReports(
-                                getReadReport(read1, refSeq, readCounts, reference),
-                                getReadReport(read, refSeq, readCounts, reference));
-                        report.updateCounts(moleculeCounts, codonTracker, variationCounts, reference);
+                        updateCountsForPair(getReadReport(read1), getReadReport(read));
                         read1 = null;
                     }
                 } catch ( final Exception e ) {
@@ -213,8 +211,8 @@ public void traverse() {
             if ( read1 != null ) {
                 logger.warn("Read " + read1.getName() + " has no mate.");
                 try {
-                    final ReadReport report = getReadReport(read1, refSeq, readCounts, reference);
-                    report.updateCounts(moleculeCounts, codonTracker, variationCounts, reference);
+                    final ReadReport report = getReadReport(read1);
+                    report.updateCounts(moleculeCountsUnpaired, codonTracker, variationCounts, reference);
                 } catch ( final Exception e ) {
                     final String readName = read1.getName();
                     throw new GATKException("Caught unexpected exception on read " +
@@ -237,7 +235,7 @@ public Object onTraversalSuccess() {
         return super.onTraversalSuccess();
     }
 
-    private List<SNVCollectionCount> getVariationEntries() {
+    private static List<SNVCollectionCount> getVariationEntries() {
         final long outputSize =
                 variationCounts.stream().filter(entry -> entry.getCount() >= minVariantObservations).count();
         final List<SNVCollectionCount> variationEntries = new ArrayList<>((int)outputSize);
@@ -253,7 +251,7 @@ private List<SNVCollectionCount> getVariationEntries() {
         return variationEntries;
     }
 
-    private void writeVariationCounts( final List<SNVCollectionCount> variationEntries ) {
+    private static void writeVariationCounts( final List<SNVCollectionCount> variationEntries ) {
         final int refSeqLength = reference.getRefSeqLength();
         final String variantsFile = outputFilePrefix + ".variantCounts";
         try ( final BufferedWriter writer =
@@ -284,7 +282,8 @@ private void writeVariationCounts( final List<SNVCollectionCount> variationEntri
         }
     }
 
-    private void describeVariantsAsCodons( final BufferedWriter writer, final List<SNV> snvs ) throws IOException {
+    private static void describeVariantsAsCodons( final BufferedWriter writer, final List<SNV> snvs )
+            throws IOException {
         final List<CodonVariation> codonVariations = codonTracker.encodeSNVsAsCodons(snvs);
         final int[] refCodonValues = codonTracker.getRefCodonValues();
 
@@ -334,7 +333,7 @@ private void describeVariantsAsCodons( final BufferedWriter writer, final List<S
         }
     }
 
-    private void writeRefCoverage() {
+    private static void writeRefCoverage() {
         final String refCoverageFile = outputFilePrefix + ".refCoverage";
         try ( final BufferedWriter writer =
                       new BufferedWriter(new OutputStreamWriter(BucketUtils.createFile(refCoverageFile))) ) {
@@ -352,7 +351,7 @@ private void writeRefCoverage() {
         }
     }
 
-    private void writeCodonCounts() {
+    private static void writeCodonCounts() {
         final String codonCountsFile = outputFilePrefix + ".codonCounts";
         try ( final BufferedWriter writer =
                       new BufferedWriter(new OutputStreamWriter(BucketUtils.createFile(codonCountsFile))) ) {
@@ -380,7 +379,7 @@ private void writeCodonCounts() {
         }
     }
 
-    private void writeCodonFractions() {
+    private static void writeCodonFractions() {
         final String codonFractFile = outputFilePrefix + ".codonFractions";
         try ( final BufferedWriter writer =
                       new BufferedWriter(new OutputStreamWriter(BucketUtils.createFile(codonFractFile))) ) {
@@ -408,7 +407,7 @@ private void writeCodonFractions() {
         }
     }
 
-    private void writeAACounts() {
+    private static void writeAACounts() {
         final String aaCountsFile = outputFilePrefix + ".aaCounts";
         try ( final BufferedWriter writer =
                       new BufferedWriter(new OutputStreamWriter(BucketUtils.createFile(aaCountsFile))) ) {
@@ -442,7 +441,7 @@ private void writeAACounts() {
         }
     }
 
-    private void writeAAFractions() {
+    private static void writeAAFractions() {
         final String aaFractFile = outputFilePrefix + ".aaFractions";
         try ( final BufferedWriter writer =
                       new BufferedWriter(new OutputStreamWriter(BucketUtils.createFile(aaFractFile))) ) {
@@ -476,53 +475,87 @@ private void writeAAFractions() {
         }
     }
 
-    private void writeReadCounts() {
+    private static void writeReadCounts() {
         final String readCountsFile = outputFilePrefix + ".readCounts";
         try ( final BufferedWriter writer =
                       new BufferedWriter(new OutputStreamWriter(BucketUtils.createFile(readCountsFile))) ) {
             final DecimalFormat df = new DecimalFormat("0.000");
+
             final long totalReads = readCounts.getNReads();
-            writer.write("Total Reads:\t" + totalReads);
+            writer.write("Total Reads:\t" + totalReads + "\t100.000%");
             writer.newLine();
+
             final long nUnmappedReads = readCounts.getNReadsUnmapped();
-            writer.write("Unmapped Reads:\t" + nUnmappedReads + "\t" +
+            writer.write(">Unmapped Reads:\t" + nUnmappedReads + "\t" +
                     df.format(100. * nUnmappedReads / totalReads) + "%");
             writer.newLine();
+
             final long nLowQualityReads = readCounts.getNReadsLowQuality();
-            writer.write("LowQ Reads:\t" + nLowQualityReads + "\t" +
+            writer.write(">LowQ Reads:\t" + nLowQualityReads + "\t" +
                     df.format(100. * nLowQualityReads / totalReads) + "%");
             writer.newLine();
-            final long nInconsistentPairs = moleculeCounts.getNInconsistentPairs();
-            final long nInsufficientFlankMolecules = moleculeCounts.getnInsufficientFlank();
-            final long nWildTypeMolecules = moleculeCounts.getNWildType();
-            final long nLowQualityVariantMolecules = moleculeCounts.getNLowQualityVariant();
-            final long nCalledVariantMolecules = moleculeCounts.getCalledVariant();
-            final long totalMolecules = nInconsistentPairs + nWildTypeMolecules + nInsufficientFlankMolecules +
-                    nLowQualityVariantMolecules + nCalledVariantMolecules;
-            writer.write("Number of inconsistent pair molecules:\t" + nInconsistentPairs + "\t" +
-                    df.format(100. * nInconsistentPairs / totalMolecules) + "%");
+
+            final long nEvaluableReads = readCounts.getNReadsEvaluable();
+            writer.write(">Evaluable Reads:\t" + nEvaluableReads + "\t" +
+                    df.format(100. * nEvaluableReads / totalReads) + "%");
             writer.newLine();
-            writer.write("Number of wild type molecules:\t" + nWildTypeMolecules + "\t" +
-                    df.format(100. * nWildTypeMolecules / totalMolecules) + "%");
+
+            final long nDisjointReads = moleculeCountsDisjointPair.getTotal();
+            writer.write(">>Reads in disjoint pairs evaluated separately:\t" +  nDisjointReads + "\t" +
+                    df.format(100. * nDisjointReads / nEvaluableReads) + "%");
             writer.newLine();
-            writer.write("Number of insufficient flank molecules:\t" + nInsufficientFlankMolecules + "\t" +
-                    df.format(100. * nInsufficientFlankMolecules / totalMolecules) + "%");
+            writeMoleculeCounts(moleculeCountsDisjointPair, df, writer);
+
+            final long nOverlappingReads = 2 * moleculeCountsOverlappingPair.getTotal();
+            writer.write(">>Reads in overlapping pairs evaluated together:\t" + nOverlappingReads + "\t" +
+                    df.format(100. * nOverlappingReads / nEvaluableReads) + "%");
             writer.newLine();
-            writer.write("Number of low quality variation molecules:\t" + nLowQualityVariantMolecules + "\t" +
-                    df.format(100. * nLowQualityVariantMolecules / totalMolecules) + "%");
+            writeMoleculeCounts(moleculeCountsOverlappingPair, df, writer);
+
+            final long totalBases = readCounts.getNTotalBaseCalls();
+            writer.write("Total base calls:\t" + totalBases + "\t100.000%");
             writer.newLine();
-            writer.write("Number of called variant molecules:\t" + nCalledVariantMolecules + "\t" +
-                    df.format(100. * nCalledVariantMolecules / totalMolecules) + "%");
+            final long totalCoverage = reference.getTotalCoverage();
+            writer.write(">Base calls evaluated for variants:\t" + totalCoverage + "\t" +
+                    df.format(100. * totalCoverage / totalBases) + "%");
             writer.newLine();
-            writer.write("Base calls evaluated for variants:\t" +
-                    df.format(100. * reference.getTotalCoverage() / readCounts.getNTotalBaseCalls()) + "%");
+            final long totalUnevaluatedBases = totalBases - totalCoverage;
+            writer.write(">Base calls unevaluated:\t" + totalUnevaluatedBases + "\t" +
+                    df.format(100. * totalUnevaluatedBases / totalBases) + "%");
             writer.newLine();
         } catch ( final IOException ioe ) {
             throw new UserException("Can't write " + readCountsFile, ioe);
         }
     }
 
-    private void writeCoverageSizeHistogram() {
+    private static void writeMoleculeCounts( final MoleculeCounts moleculeCounts,
+                                             final DecimalFormat df,
+                                             final BufferedWriter writer )
+            throws IOException {
+        final long nInconsistentPairs = moleculeCounts.getNInconsistentPairs();
+        final long nInsufficientFlankMolecules = moleculeCounts.getNInsufficientFlank();
+        final long nWildTypeMolecules = moleculeCounts.getNWildType();
+        final long nLowQualityVariantMolecules = moleculeCounts.getNLowQualityVariant();
+        final long nCalledVariantMolecules = moleculeCounts.getCalledVariant();
+        final long totalMolecules = moleculeCounts.getTotal();
+        writer.write(">>>Number of inconsistent pair molecules:\t" + nInconsistentPairs + "\t" +
+                df.format(100. * nInconsistentPairs / totalMolecules) + "%");
+        writer.newLine();
+        writer.write(">>>Number of wild type molecules:\t" + nWildTypeMolecules + "\t" +
+                df.format(100. * nWildTypeMolecules / totalMolecules) + "%");
+        writer.newLine();
+        writer.write(">>>Number of insufficient flank molecules:\t" + nInsufficientFlankMolecules + "\t" +
+                df.format(100. * nInsufficientFlankMolecules / totalMolecules) + "%");
+        writer.newLine();
+        writer.write(">>>Number of low quality variation molecules:\t" + nLowQualityVariantMolecules + "\t" +
+                df.format(100. * nLowQualityVariantMolecules / totalMolecules) + "%");
+        writer.newLine();
+        writer.write(">>>Number of called variant molecules:\t" + nCalledVariantMolecules + "\t" +
+                df.format(100. * nCalledVariantMolecules / totalMolecules) + "%");
+        writer.newLine();
+    }
+
+    private static void writeCoverageSizeHistogram() {
         final long[] refCoverageSizeHistogram = reference.getCoverageSizeHistogram();
 
         final String trimCountsFile = outputFilePrefix + ".coverageLengthCounts";
@@ -620,6 +653,7 @@ private int updateCoverage( final List<Interval> refCoverageList ) {
         private long nReadsTotal = 0; // total number of reads in input bam
         private long nReadsUnmapped = 0; // number of unmapped reads in bam
         private long nReadsLowQuality = 0; // number of reads where trimming made the read disappear
+        private long nReadsEvaluable = 0; // number of reads that can be evaluated for variants
         private long nTotalBaseCalls = 0; // number of base calls over all reads in bam (mapped or not, call trimmed or not)
 
         public void bumpNReads() { nReadsTotal += 1; }
@@ -631,6 +665,9 @@ private int updateCoverage( final List<Interval> refCoverageList ) {
         public void bumpNLowQualityReads() { nReadsLowQuality += 1; }
         public long getNReadsLowQuality() { return nReadsLowQuality; }
 
+        public void bumpNReadsEvaluable() { nReadsEvaluable += 1; }
+        public long getNReadsEvaluable() { return nReadsEvaluable; }
+
         public void addBaseCalls( final long nBases ) { nTotalBaseCalls += nBases; }
         public long getNTotalBaseCalls() { return nTotalBaseCalls; }
     }
@@ -648,11 +685,14 @@ private int updateCoverage( final List<Interval> refCoverageList ) {
         public void bumpInconsistentPairs() { nInconsistentPairs += 1; }
         public long getNInconsistentPairs() { return nInconsistentPairs; }
         public void bumpInsufficientFlank() { nInsufficientFlank += 1; }
-        public long getnInsufficientFlank() { return nInsufficientFlank; }
+        public long getNInsufficientFlank() { return nInsufficientFlank; }
         public void bumpNLowQualityVariant() { nLowQualityVariant += 1; }
         public long getNLowQualityVariant() { return nLowQualityVariant; }
         public void bumpCalledVariant() { nCalledVariant += 1; }
         public long getCalledVariant() { return nCalledVariant; }
+        public long getTotal() {
+            return nWildType + nInconsistentPairs + nInsufficientFlank + nLowQualityVariant + nCalledVariant;
+        }
     }
 
     // describes an interval on some sequence as a pair of offsets (0-based, half-open).
@@ -1241,7 +1281,7 @@ static boolean isStop( final int codonValue ) {
         }
     }
 
-    @VisibleForTesting static class ReadReport {
+    @VisibleForTesting static final class ReadReport {
         final List<Interval> refCoverage;
         final List<SNV> snvList;
 
@@ -1329,6 +1369,11 @@ public ReadReport( final GATKRead read, final Interval trim, final byte[] refSeq
             }
         }
 
+        public ReadReport( final ReadReport report1, final ReadReport report2 ) {
+            refCoverage = combineCoverage(report1, report2);
+            snvList = combineVariations(report1, report2);
+        }
+
         public List<Interval> getRefCoverage() {
             return refCoverage;
         }
@@ -1397,54 +1442,6 @@ public void updateCounts( final MoleculeCounts moleculeCounts,
             }
         }
 
-        protected ReadReport( final List<Interval> refCoverage, final List<SNV> snvList ) {
-            this.refCoverage = refCoverage;
-            this.snvList = snvList;
-        }
-
-        public static ReadReport NULL_REPORT = new ReadReport(new ArrayList<>(), new ArrayList<>());
-    }
-
-    @VisibleForTesting final static class PairedReadReport extends ReadReport {
-        final ReadReport report1;
-        final ReadReport report2;
-
-        public PairedReadReport( final ReadReport report1, final ReadReport report2 ) {
-            super(combineCoverage(report1, report2), combineVariations(report1, report2));
-            this.report1 = report1;
-            this.report2 = report2;
-        }
-
-        @Override
-        public boolean hasCleanFlanks( final int minFlankingLength, final int refLength ) {
-            // return true if the earlier-starting report is clean, and the later-ending report is clean
-            return (report1.getFirstRefIndex() < report2.getFirstRefIndex() ? report1 : report2)
-                    .hasCleanLeftFlank(minFlankingLength)
-                    &&
-                   (report1.getLastRefIndex() > report2.getLastRefIndex() ? report1 : report2)
-                    .hasCleanRightFlank(minFlankingLength, refLength);
-        }
-
-        @Override
-        public void updateCounts( final MoleculeCounts moleculeCounts,
-                                  final CodonTracker codonTracker,
-                                  final HopscotchMap<SNVCollectionCount, Long, SNVCollectionCount> variationCounts,
-                                  final Reference reference ) {
-            final int start1 = report1.getFirstRefIndex();
-            final int end1 = report1.getLastRefIndex();
-            final int start2 = report2.getFirstRefIndex();
-            final int end2 = report2.getLastRefIndex();
-
-            final int overlapStart = Math.max(start1, start2);
-            final int overlapEnd = Math.min(end1, end2);
-            if ( overlapStart > overlapEnd ) { // disjoint -- report each independently
-                report1.updateCounts(moleculeCounts, codonTracker, variationCounts, reference);
-                report2.updateCounts(moleculeCounts, codonTracker, variationCounts, reference);
-            } else { // overlapping -- report molecule as one
-                super.updateCounts(moleculeCounts, codonTracker, variationCounts, reference);
-            }
-        }
-
         private static List<Interval> combineCoverage( final ReadReport report1, final ReadReport report2 ) {
             final List<Interval> refCoverage1 = report1.getRefCoverage();
             final List<Interval> refCoverage2 = report2.getRefCoverage();
@@ -1551,12 +1548,16 @@ private static List<SNV> combineVariations( final ReadReport report1, final Read
             }
             return combinedSNVs;
         }
+
+        @VisibleForTesting ReadReport( final List<Interval> refCoverage, final List<SNV> snvList ) {
+            this.refCoverage = refCoverage;
+            this.snvList = snvList;
+        }
+
+        public static ReadReport NULL_REPORT = new ReadReport(new ArrayList<>(), new ArrayList<>());
     }
 
-    @VisibleForTesting static ReadReport getReadReport( final GATKRead read,
-                                                        final byte[] refSeq,
-                                                        final ReadCounts readCounts,
-                                                        final Reference reference ) {
+    @VisibleForTesting static ReadReport getReadReport( final GATKRead read ) {
         readCounts.bumpNReads();
         readCounts.addBaseCalls(read.getLength());
 
@@ -1565,15 +1566,22 @@ private static List<SNV> combineVariations( final ReadReport report1, final Read
             return ReadReport.NULL_REPORT;
         }
 
-        final Interval trim = calculateTrim(read.getBaseQualitiesNoCopy(), readCounts);
+        final Interval trim = calculateTrim(read.getBaseQualitiesNoCopy());
         if ( trim.size() == 0 ) {
+            readCounts.bumpNLowQualityReads();
             return ReadReport.NULL_REPORT;
         }
 
-        return new ReadReport(read, trim, reference.getRefSeq());
+        final ReadReport readReport = new ReadReport(read, trim, reference.getRefSeq());
+        if ( readReport.getRefCoverage().isEmpty() ) {
+            readCounts.bumpNLowQualityReads();
+        } else {
+            readCounts.bumpNReadsEvaluable();
+        }
+        return readReport;
     }
 
-    @VisibleForTesting static Interval calculateTrim( final byte[] quals, final ReadCounts readCounts ) {
+    @VisibleForTesting static Interval calculateTrim( final byte[] quals ) {
         // find initial end-trim
         int readStart = 0;
         int hiQCount = 0;
@@ -1586,7 +1594,6 @@ private static List<SNV> combineVariations( final ReadReport report1, final Read
             readStart += 1;
         }
         if ( readStart == quals.length ) {
-            readCounts.bumpNLowQualityReads();
             return Interval.NULL_INTERVAL;
         }
         readStart -= minLength - 1;
@@ -1607,9 +1614,21 @@ private static List<SNV> combineVariations( final ReadReport report1, final Read
         return new Interval(readStart, readEnd);
     }
 
-    private static ReadReport combineReports( final ReadReport report1, final ReadReport report2 ) {
-        if ( report1.getRefCoverage().isEmpty() ) return report2;
-        if ( report2.getRefCoverage().isEmpty() ) return report1;
-        return new PairedReadReport(report1, report2);
+    @VisibleForTesting static void updateCountsForPair( final ReadReport report1, final ReadReport report2 ) {
+        if ( report1.getRefCoverage().isEmpty() ) {
+            report2.updateCounts(moleculeCountsDisjointPair, codonTracker, variationCounts, reference);
+        } else if ( report2.getRefCoverage().isEmpty() ) {
+            report1.updateCounts(moleculeCountsDisjointPair, codonTracker, variationCounts, reference);
+        } else {
+            final int overlapStart = Math.max(report1.getFirstRefIndex(), report2.getFirstRefIndex());
+            final int overlapEnd = Math.min(report1.getLastRefIndex(), report2.getLastRefIndex());
+            if ( overlapStart <= overlapEnd ) { // if mates overlap, or are adjacent
+                final ReadReport combinedReport = new ReadReport(report1, report2);
+                combinedReport.updateCounts(moleculeCountsOverlappingPair, codonTracker, variationCounts, reference);
+            } else {
+                report1.updateCounts(moleculeCountsDisjointPair, codonTracker, variationCounts, reference);
+                report2.updateCounts(moleculeCountsDisjointPair, codonTracker, variationCounts, reference);
+            }
+        }
     }
 }
diff --git a/src/test/java/org/broadinstitute/hellbender/tools/AnalyzeSaturationMutagenesisUnitTest.java b/src/test/java/org/broadinstitute/hellbender/tools/AnalyzeSaturationMutagenesisUnitTest.java
index 7029e213b01..946bcedfd3c 100644
--- a/src/test/java/org/broadinstitute/hellbender/tools/AnalyzeSaturationMutagenesisUnitTest.java
+++ b/src/test/java/org/broadinstitute/hellbender/tools/AnalyzeSaturationMutagenesisUnitTest.java
@@ -3,7 +3,6 @@
 import htsjdk.samtools.SAMFileHeader;
 import org.broadinstitute.hellbender.GATKBaseTest;
 import org.broadinstitute.hellbender.tools.AnalyzeSaturationMutagenesis.*;
-import org.broadinstitute.hellbender.tools.spark.utils.HopscotchMap;
 import org.broadinstitute.hellbender.utils.read.ArtificialReadUtils;
 import org.broadinstitute.hellbender.utils.read.GATKRead;
 import org.testng.Assert;
@@ -28,7 +27,7 @@ public class AnalyzeSaturationMutagenesisUnitTest extends GATKBaseTest {
     final private static byte QUAL_30 = (byte)30;
     final private static byte[] refSeq = "ACATGCGTCTAGTACGT".getBytes();
     final private static String orfCoords = "3-6,8-12";
-    final private static CodonTracker codonTracker = new CodonTracker(orfCoords, refSeq, null);
+    final private static CodonTracker localCodonTracker = new CodonTracker(orfCoords, refSeq, logger);
 
     @Test
     public void testInterval() {
@@ -169,37 +168,37 @@ public void testCodonVariationBasics() {
     @Test
     public void testEncodingModifications() {
         // no SNVs implies no codon variations
-        Assert.assertTrue(codonTracker.encodeSNVsAsCodons(Collections.emptyList()).isEmpty());
+        Assert.assertTrue(localCodonTracker.encodeSNVsAsCodons(Collections.emptyList()).isEmpty());
 
         // changes outside the ORF shouldn't produce codon variations
-        Assert.assertTrue(codonTracker
+        Assert.assertTrue(localCodonTracker
                 .encodeSNVsAsCodons(Collections.singletonList(new SNV(1, CALL_C, CALL_G, QUAL_30)))
                 .isEmpty());
-        Assert.assertTrue(codonTracker
+        Assert.assertTrue(localCodonTracker
                 .encodeSNVsAsCodons(Collections.singletonList(new SNV(6, CALL_G, CALL_A, QUAL_30)))
                 .isEmpty());
-        Assert.assertTrue(codonTracker
+        Assert.assertTrue(localCodonTracker
                 .encodeSNVsAsCodons(Collections.singletonList(new SNV(12, CALL_T, CALL_C, QUAL_30)))
                 .isEmpty());
 
         // changes to a single codon should produce a single-codon variations
         Assert.assertEquals(
-                codonTracker.encodeSNVsAsCodons(Collections.singletonList(new SNV(2, CALL_A, CALL_C, QUAL_30))),
+                localCodonTracker.encodeSNVsAsCodons(Collections.singletonList(new SNV(2, CALL_A, CALL_C, QUAL_30))),
                 Collections.singletonList(CodonVariation.createModification(0, 30)));
         Assert.assertEquals(
-                codonTracker.encodeSNVsAsCodons(Collections.singletonList(new SNV(5, CALL_C, CALL_G, QUAL_30))),
+                localCodonTracker.encodeSNVsAsCodons(Collections.singletonList(new SNV(5, CALL_C, CALL_G, QUAL_30))),
                 Collections.singletonList(CodonVariation.createModification(1, 45)));
         Assert.assertEquals(
-                codonTracker.encodeSNVsAsCodons(Collections.singletonList(new SNV(7, CALL_T, CALL_G, QUAL_30))),
+                localCodonTracker.encodeSNVsAsCodons(Collections.singletonList(new SNV(7, CALL_T, CALL_G, QUAL_30))),
                 Collections.singletonList(CodonVariation.createModification(1, 25)));
         Assert.assertEquals(
-                codonTracker.encodeSNVsAsCodons(Collections.singletonList(new SNV(8, CALL_C, CALL_A, QUAL_30))),
+                localCodonTracker.encodeSNVsAsCodons(Collections.singletonList(new SNV(8, CALL_C, CALL_A, QUAL_30))),
                 Collections.singletonList(CodonVariation.createModification(1, 28)));
         Assert.assertEquals(
-                codonTracker.encodeSNVsAsCodons(Collections.singletonList(new SNV(11, CALL_G, CALL_A, QUAL_30))),
+                localCodonTracker.encodeSNVsAsCodons(Collections.singletonList(new SNV(11, CALL_G, CALL_A, QUAL_30))),
                 Collections.singletonList(CodonVariation.createModification(2, 48)));
         Assert.assertEquals(
-                codonTracker.encodeSNVsAsCodons(Arrays.asList(
+                localCodonTracker.encodeSNVsAsCodons(Arrays.asList(
                         new SNV(5, CALL_C, CALL_G, QUAL_30),
                         new SNV(7, CALL_T, CALL_G, QUAL_30),
                         new SNV(8, CALL_C, CALL_A, QUAL_30))),
@@ -207,7 +206,7 @@ public void testEncodingModifications() {
 
         // even if the change produces a nonsense codon
         Assert.assertEquals(
-                codonTracker.encodeSNVsAsCodons(Arrays.asList(
+                localCodonTracker.encodeSNVsAsCodons(Arrays.asList(
                         new SNV(5, CALL_C, CALL_T, QUAL_30),
                         new SNV(7, CALL_T, CALL_A, QUAL_30),
                         new SNV(8, CALL_C, CALL_A, QUAL_30))),
@@ -217,27 +216,27 @@ public void testEncodingModifications() {
     @Test
     public void testEncodingDeletions() {
         Assert.assertEquals(
-                codonTracker.encodeSNVsAsCodons(Collections.singletonList(new SNV(2, CALL_A, NO_CALL, QUAL_30))),
+                localCodonTracker.encodeSNVsAsCodons(Collections.singletonList(new SNV(2, CALL_A, NO_CALL, QUAL_30))),
                 Arrays.asList(
                         CodonVariation.createFrameshift(0),
                         CodonVariation.createModification(0, 57),
                         CodonVariation.createModification(1, 55),
                         CodonVariation.createModification(2, 11)));
         Assert.assertEquals(
-                codonTracker.encodeSNVsAsCodons(Arrays.asList(
+                localCodonTracker.encodeSNVsAsCodons(Arrays.asList(
                         new SNV(10, CALL_A, NO_CALL, QUAL_30),
                         new SNV(12, CALL_T, NO_CALL, QUAL_30))),
                 Arrays.asList(
                         CodonVariation.createFrameshift(2),
                         CodonVariation.createModification(2, 56)));
         Assert.assertEquals(
-                codonTracker.encodeSNVsAsCodons(Arrays.asList(
+                localCodonTracker.encodeSNVsAsCodons(Arrays.asList(
                         new SNV(5, CALL_C, NO_CALL, QUAL_30),
                         new SNV(7, CALL_T, NO_CALL, QUAL_30),
                         new SNV(8, CALL_C, NO_CALL, QUAL_30))),
                 Collections.singletonList(CodonVariation.createDeletion(1)));
         Assert.assertEquals(
-                codonTracker.encodeSNVsAsCodons(Arrays.asList(
+                localCodonTracker.encodeSNVsAsCodons(Arrays.asList(
                         new SNV(3, CALL_T, NO_CALL, QUAL_30),
                         new SNV(5, CALL_C, NO_CALL, QUAL_30),
                         new SNV(8, CALL_C, NO_CALL, QUAL_30))),
@@ -250,14 +249,14 @@ public void testEncodingDeletions() {
     @Test
     public void testEncodingInsertions() {
         Assert.assertEquals(
-                codonTracker.encodeSNVsAsCodons(Collections.singletonList(
+                localCodonTracker.encodeSNVsAsCodons(Collections.singletonList(
                         new SNV(5, NO_CALL, CALL_T, QUAL_30))),
                 Arrays.asList(
                         CodonVariation.createFrameshift(1),
                         CodonVariation.createModification(1, 55),
                         CodonVariation.createModification(2, 28)));
         Assert.assertEquals(
-                codonTracker.encodeSNVsAsCodons(Arrays.asList(
+                localCodonTracker.encodeSNVsAsCodons(Arrays.asList(
                         new SNV(2, NO_CALL, CALL_T, QUAL_30),
                         new SNV(2, NO_CALL, CALL_T, QUAL_30),
                         new SNV(2, NO_CALL, CALL_T, QUAL_30))),
@@ -268,14 +267,14 @@ public void testEncodingInsertions() {
     @Test
     public void testFrameRecoveringIndels() {
         Assert.assertEquals(
-                codonTracker.encodeSNVsAsCodons(Arrays.asList(
+                localCodonTracker.encodeSNVsAsCodons(Arrays.asList(
                         new SNV(3, CALL_T, NO_CALL, QUAL_30),
                         new SNV(7, NO_CALL, CALL_A, QUAL_30))),
                 Arrays.asList(
                         CodonVariation.createModification(0, 9),
                         CodonVariation.createModification(1, 13)));
         Assert.assertEquals(
-                codonTracker.encodeSNVsAsCodons(Arrays.asList(
+                localCodonTracker.encodeSNVsAsCodons(Arrays.asList(
                         new SNV(3, NO_CALL, CALL_T, QUAL_30),
                         new SNV(7, CALL_T, NO_CALL, QUAL_30))),
                 Arrays.asList(
@@ -285,7 +284,7 @@ public void testFrameRecoveringIndels() {
 
     @Test
     public void testWildTypeCodonCounts() {
-        final CodonTracker codonTracker = new CodonTracker(orfCoords, refSeq, null);
+        final CodonTracker codonTracker = new CodonTracker(orfCoords, refSeq, logger);
         codonTracker.reportWildCodonCounts(new Interval(0, 17));
         codonTracker.reportWildCodonCounts(new Interval(0, 17));
         final int[] wildTypeCodonValues = codonTracker.getRefCodonValues();
@@ -333,22 +332,22 @@ public void testWildTypeCodonValuesAndExons() {
     @Test
     public void testFindFrameShift() {
         Assert.assertEquals(
-                codonTracker.findFrameShift(Collections.singletonList(new SNV(1, CALL_A, NO_CALL, QUAL_30))),
+                localCodonTracker.findFrameShift(Collections.singletonList(new SNV(1, CALL_A, NO_CALL, QUAL_30))),
                 NO_FRAME_SHIFT_CODON);
         Assert.assertEquals(
-                codonTracker.findFrameShift(Collections.singletonList(new SNV(2, CALL_A, NO_CALL, QUAL_30))),
+                localCodonTracker.findFrameShift(Collections.singletonList(new SNV(2, CALL_A, NO_CALL, QUAL_30))),
                 0);
         Assert.assertEquals(
-                codonTracker.findFrameShift(Collections.singletonList(new SNV(4, NO_CALL, CALL_C, QUAL_30))),
+                localCodonTracker.findFrameShift(Collections.singletonList(new SNV(4, NO_CALL, CALL_C, QUAL_30))),
                 0);
         Assert.assertEquals(
-                codonTracker.findFrameShift(Collections.singletonList(new SNV(6, CALL_G, NO_CALL, QUAL_30))),
+                localCodonTracker.findFrameShift(Collections.singletonList(new SNV(6, CALL_G, NO_CALL, QUAL_30))),
                 NO_FRAME_SHIFT_CODON);
         Assert.assertEquals(
-                codonTracker.findFrameShift(Collections.singletonList(new SNV(12, NO_CALL, CALL_C, QUAL_30))),
+                localCodonTracker.findFrameShift(Collections.singletonList(new SNV(12, NO_CALL, CALL_C, QUAL_30))),
                 NO_FRAME_SHIFT_CODON);
         Assert.assertEquals(
-                codonTracker.findFrameShift(Arrays.asList(
+                localCodonTracker.findFrameShift(Arrays.asList(
                         new SNV(5, CALL_C, NO_CALL, QUAL_30),
                         new SNV(6, CALL_G, NO_CALL, QUAL_30),
                         new SNV(7, CALL_T, NO_CALL, QUAL_30),
@@ -370,41 +369,41 @@ public void testIsStop() {
 
     @Test
     public void testIsExonic() {
-        Assert.assertFalse(codonTracker.isExonic(-1));
-        Assert.assertFalse(codonTracker.isExonic(0));
-        Assert.assertFalse(codonTracker.isExonic(1));
-        Assert.assertTrue(codonTracker.isExonic(2));
-        Assert.assertTrue(codonTracker.isExonic(3));
-        Assert.assertTrue(codonTracker.isExonic(4));
-        Assert.assertTrue(codonTracker.isExonic(5));
-        Assert.assertFalse(codonTracker.isExonic(6));
-        Assert.assertTrue(codonTracker.isExonic(7));
-        Assert.assertTrue(codonTracker.isExonic(8));
-        Assert.assertTrue(codonTracker.isExonic(9));
-        Assert.assertTrue(codonTracker.isExonic(10));
-        Assert.assertTrue(codonTracker.isExonic(11));
-        Assert.assertFalse(codonTracker.isExonic(12));
-        Assert.assertFalse(codonTracker.isExonic(99));
+        Assert.assertFalse(localCodonTracker.isExonic(-1));
+        Assert.assertFalse(localCodonTracker.isExonic(0));
+        Assert.assertFalse(localCodonTracker.isExonic(1));
+        Assert.assertTrue(localCodonTracker.isExonic(2));
+        Assert.assertTrue(localCodonTracker.isExonic(3));
+        Assert.assertTrue(localCodonTracker.isExonic(4));
+        Assert.assertTrue(localCodonTracker.isExonic(5));
+        Assert.assertFalse(localCodonTracker.isExonic(6));
+        Assert.assertTrue(localCodonTracker.isExonic(7));
+        Assert.assertTrue(localCodonTracker.isExonic(8));
+        Assert.assertTrue(localCodonTracker.isExonic(9));
+        Assert.assertTrue(localCodonTracker.isExonic(10));
+        Assert.assertTrue(localCodonTracker.isExonic(11));
+        Assert.assertFalse(localCodonTracker.isExonic(12));
+        Assert.assertFalse(localCodonTracker.isExonic(99));
     }
 
     @Test
     public void testExonicBaseCount() {
-        Assert.assertEquals(codonTracker.exonicBaseIndex(-1), 0);
-        Assert.assertEquals(codonTracker.exonicBaseIndex(0), 0);
-        Assert.assertEquals(codonTracker.exonicBaseIndex(1), 0);
-        Assert.assertEquals(codonTracker.exonicBaseIndex(2), 0);
-        Assert.assertEquals(codonTracker.exonicBaseIndex(3), 1);
-        Assert.assertEquals(codonTracker.exonicBaseIndex(4), 2);
-        Assert.assertEquals(codonTracker.exonicBaseIndex(5), 3);
-        Assert.assertEquals(codonTracker.exonicBaseIndex(6), 4);
-        Assert.assertEquals(codonTracker.exonicBaseIndex(7), 4);
-        Assert.assertEquals(codonTracker.exonicBaseIndex(8), 5);
-        Assert.assertEquals(codonTracker.exonicBaseIndex(9), 6);
-        Assert.assertEquals(codonTracker.exonicBaseIndex(10), 7);
-        Assert.assertEquals(codonTracker.exonicBaseIndex(11), 8);
-        Assert.assertEquals(codonTracker.exonicBaseIndex(12), 9);
-        Assert.assertEquals(codonTracker.exonicBaseIndex(13), 9);
-        Assert.assertEquals(codonTracker.exonicBaseIndex(99), 9);
+        Assert.assertEquals(localCodonTracker.exonicBaseIndex(-1), 0);
+        Assert.assertEquals(localCodonTracker.exonicBaseIndex(0), 0);
+        Assert.assertEquals(localCodonTracker.exonicBaseIndex(1), 0);
+        Assert.assertEquals(localCodonTracker.exonicBaseIndex(2), 0);
+        Assert.assertEquals(localCodonTracker.exonicBaseIndex(3), 1);
+        Assert.assertEquals(localCodonTracker.exonicBaseIndex(4), 2);
+        Assert.assertEquals(localCodonTracker.exonicBaseIndex(5), 3);
+        Assert.assertEquals(localCodonTracker.exonicBaseIndex(6), 4);
+        Assert.assertEquals(localCodonTracker.exonicBaseIndex(7), 4);
+        Assert.assertEquals(localCodonTracker.exonicBaseIndex(8), 5);
+        Assert.assertEquals(localCodonTracker.exonicBaseIndex(9), 6);
+        Assert.assertEquals(localCodonTracker.exonicBaseIndex(10), 7);
+        Assert.assertEquals(localCodonTracker.exonicBaseIndex(11), 8);
+        Assert.assertEquals(localCodonTracker.exonicBaseIndex(12), 9);
+        Assert.assertEquals(localCodonTracker.exonicBaseIndex(13), 9);
+        Assert.assertEquals(localCodonTracker.exonicBaseIndex(99), 9);
     }
 
     @Test
@@ -432,7 +431,7 @@ public void testCombiningCoverage() {
         final ReadReport report2 = new ReadReport(Arrays.asList(
                 new Interval(17, 21), new Interval(22, 27), new Interval(38, 50), new Interval(58, 60), new Interval(70, 72)),
                 Collections.emptyList());
-        Assert.assertEquals(new PairedReadReport(report1, report2).getRefCoverage(),
+        Assert.assertEquals(new ReadReport(report1, report2).getRefCoverage(),
                 Arrays.asList(new Interval(0, 9), new Interval(17, 50), new Interval(58, 72), new Interval(100, 120)));
     }
 
@@ -450,33 +449,34 @@ public void testCombiningSNVLists() {
         final ReadReport report2 = new ReadReport(Collections.singletonList(new Interval(33, 60)), list2);
         final List<SNV> combinedList = new ArrayList<>(list1);
         combinedList.addAll(list2);
-        Assert.assertEquals(new PairedReadReport(report1, report2).getVariations(), combinedList);
+        Assert.assertEquals(new ReadReport(report1, report2).getVariations(), combinedList);
 
         // region of overlap has no conflicting SNVs
         final ReadReport report3 = new ReadReport(Collections.singletonList(new Interval(0, 35)), list1);
         final ReadReport report4 = new ReadReport(Collections.singletonList(new Interval(33, 60)), list2);
-        Assert.assertEquals(new PairedReadReport(report3, report4).getVariations(), combinedList);
+        Assert.assertEquals(new ReadReport(report3, report4).getVariations(), combinedList);
 
         // region of overlap has conflicting SNV: SNV at 35 is missing from report5
         final ReadReport report5 = new ReadReport(Collections.singletonList(new Interval(0, 36)), list1);
         final ReadReport report6 = new ReadReport(Collections.singletonList(new Interval(33, 60)), list2);
-        Assert.assertNull(new PairedReadReport(report5, report6).getVariations());
+        Assert.assertNull(new ReadReport(report5, report6).getVariations());
 
         // repair flaw above
         final List<SNV> list1Plus = new ArrayList<>(list1);
         list1Plus.add(new SNV(35, CALL_T, CALL_C, QUAL_10));
         final ReadReport report7 = new ReadReport(Collections.singletonList(new Interval(0, 36)), list1Plus);
-        Assert.assertEquals(new PairedReadReport(report7, report6).getVariations(), combinedList);
+        Assert.assertEquals(new ReadReport(report7, report6).getVariations(), combinedList);
 
         // now mess it up again by making the SNVs unequal
         list1Plus.set(3, new SNV(35, CALL_T, CALL_A, QUAL_30));
-        Assert.assertNull(new PairedReadReport(report7, report6).getVariations());
+        Assert.assertNull(new ReadReport(report7, report6).getVariations());
     }
 
     @Test
     public void testPairedApplication() {
-        final HopscotchMap<SNVCollectionCount, Long, SNVCollectionCount> variationCounts =
-                new HopscotchMap<>(10);
+        final byte[] longRefSeq = "TTTTTTTTTTAAAAAAAAAACCCCCCCCCCCCCCCTTTTTTTTTTGGGGGGGGGGCCCCCCCCCC".getBytes();
+        reference = new Reference(longRefSeq);
+        codonTracker = new CodonTracker("5-25", longRefSeq, logger);
 
         final List<SNV> list1 = Arrays.asList(
                 new SNV(10, CALL_A, CALL_C, QUAL_30),
@@ -489,20 +489,16 @@ public void testPairedApplication() {
 
         final ReadReport report1 = new ReadReport(Collections.singletonList(new Interval(0, 32)), list1);
         final ReadReport report2 = new ReadReport(Collections.singletonList(new Interval(33, 60)), list2);
-        final PairedReadReport pair1 = new PairedReadReport(report1, report2);
-        final byte[] longRefSeq = "TTTTTTTTTTAAAAAAAAAACCCCCCCCCCCCCCCTTTTTTTTTTGGGGGGGGGGCCCCCCCCCC".getBytes();
-        final Reference reference = new Reference(longRefSeq);
-        final MoleculeCounts moleculeCounts = new MoleculeCounts();
+        updateCountsForPair(report1, report2);
 
         // shouldn't be applied -- fails flanking bases test
-        pair1.updateCounts(moleculeCounts, codonTracker, variationCounts, reference);
         Assert.assertEquals(reference.countSpanners(0, 32), 0);
         Assert.assertEquals(reference.countSpanners(32, 33), 0);
         Assert.assertEquals(reference.countSpanners(33, 60), 0);
 
         // should be applied separately
         minFlankingLength = 1;
-        pair1.updateCounts(moleculeCounts, codonTracker, variationCounts, reference);
+        updateCountsForPair(report1, report2);
         Assert.assertEquals(reference.countSpanners(0, 32), 1);
         Assert.assertEquals(reference.countSpanners(32, 33), 0);
         Assert.assertEquals(reference.countSpanners(33, 60), 1);
@@ -510,8 +506,7 @@ public void testPairedApplication() {
         // should be applied as one
         final ReadReport report3 = new ReadReport(Collections.singletonList(new Interval(0, 35)), list1);
         final ReadReport report4 = new ReadReport(Collections.singletonList(new Interval(33, 60)), list2);
-        final PairedReadReport pair2 = new PairedReadReport(report3, report4);
-        pair2.updateCounts(moleculeCounts, codonTracker, variationCounts, reference);
+        updateCountsForPair(report3, report4);
         Assert.assertEquals(reference.countSpanners(0, 32), 2);
         Assert.assertEquals(reference.countSpanners(32, 33), 1);
         Assert.assertEquals(reference.countSpanners(33, 60), 2);
@@ -521,28 +516,26 @@ public void testPairedApplication() {
     public void testCalculateTrim() {
         final byte BAD_Q = (byte)(minQ - 1);
         final byte GOOD_Q = (byte)minQ;
-        final ReadCounts readCounts = new ReadCounts();
         final byte[] quals = new byte[100];
         Arrays.fill(quals, BAD_Q);
-        Assert.assertEquals(calculateTrim(quals, readCounts).size(), 0);
+        Assert.assertEquals(calculateTrim(quals).size(), 0);
         Arrays.fill(quals, GOOD_Q);
-        Assert.assertEquals(calculateTrim(quals, readCounts), new Interval(0, 100));
+        Assert.assertEquals(calculateTrim(quals), new Interval(0, 100));
         quals[minLength] = BAD_Q;
-        Assert.assertEquals(calculateTrim(quals, readCounts), new Interval(0, 100));
+        Assert.assertEquals(calculateTrim(quals), new Interval(0, 100));
         quals[minLength - 1] = BAD_Q;
-        Assert.assertEquals(calculateTrim(quals, readCounts), new Interval(minLength + 1, 100));
+        Assert.assertEquals(calculateTrim(quals), new Interval(minLength + 1, 100));
         quals[quals.length - minLength] = BAD_Q;
-        Assert.assertEquals(calculateTrim(quals, readCounts), new Interval(minLength + 1, quals.length - minLength));
+        Assert.assertEquals(calculateTrim(quals), new Interval(minLength + 1, quals.length - minLength));
         Arrays.fill(quals, GOOD_Q);
         for ( int idx = minLength - 1; idx < quals.length; idx += minLength ) {
             quals[idx] = BAD_Q;
         }
-        Assert.assertEquals(calculateTrim(quals, readCounts).size(), 0);
+        Assert.assertEquals(calculateTrim(quals).size(), 0);
     }
 
     @Test
     public void testGetReadReport() {
-        final ReadCounts readCounts = new ReadCounts();
         final SAMFileHeader header =
                 ArtificialReadUtils.createArtificialSamHeader(1, 0, 17);
         final byte[] bases = Arrays.copyOf(refSeq, refSeq.length);
@@ -550,13 +543,13 @@ public void testGetReadReport() {
         Arrays.fill(quals, QUAL_30);
         final GATKRead read = ArtificialReadUtils.createArtificialRead(header, "read1", 0, 1,
                                                                           bases, quals, "17M");
-        final Reference reference = new Reference(refSeq);
-        ReadReport readReport = getReadReport(read, refSeq, readCounts, reference);
+        reference = new Reference(refSeq);
+        final ReadReport readReport = getReadReport(read);
         Assert.assertEquals(readReport.getRefCoverage(), Collections.singletonList(new Interval(0, 17)));
         Assert.assertEquals(readReport.getVariations().size(), 0);
         read.getBasesNoCopy()[3] = CALL_A;
-        readReport = getReadReport(read, refSeq, readCounts, reference);
-        Assert.assertEquals(readReport.getVariations(),
+        final ReadReport readReport2 = getReadReport(read);
+        Assert.assertEquals(readReport2.getVariations(),
                 Collections.singletonList(new SNV(3, CALL_T, CALL_A, QUAL_30)));
     }
 }