Ejemplo n.º 1
0
 @Override
 public String toString() {
   final StringBuilder sb = new StringBuilder();
   final int[] assignment = new int[mStrains];
   int currentIndex = 0;
   int last = -1;
   while (currentIndex > 0 || last <= max(assignment, currentIndex)) {
     assignment[currentIndex++] = last + 1;
     while (currentIndex < assignment.length) {
       assignment[currentIndex++] = 0;
     }
     int countIndex = 0;
     for (int i = 0; i < mStride.length; i++) {
       countIndex += assignment[i] * mStride[i];
     }
     sb.append(Arrays.toString(assignment));
     sb.append(" = ");
     sb.append(mCounts[countIndex]);
     sb.append("\t");
     sb.append(Utils.realFormat((double) mCounts[countIndex] / mTotal, 6));
     sb.append(StringUtils.LS);
     last = assignment[--currentIndex];
     while (last == max(assignment, currentIndex) + 1 && currentIndex > 0) {
       last = assignment[--currentIndex];
     }
   }
   return sb.toString();
 }
Ejemplo n.º 2
0
 public void test() throws IOException {
   final ImplementHashFunction hf = getHashFunction();
   hf.integrity(0, 0, 0);
   hf.hashStep((byte) 0);
   hf.integrity(0, 0, 1);
   hf.hashStep((byte) 1);
   hf.integrity(0, 1, 2);
   hf.hashStep((byte) 2);
   hf.integrity(1, 2, 3);
   hf.hashStep((byte) 3);
   hf.integrity(3, 5, 4);
   assertEquals("ImplementHashFunction read length=36 window size=18", hf.toString());
   assertEquals(
       "00000000:00000000:00000000:00000000:00000000:00000000:00000000:00000011",
       Utils.toBitsSep(hf.mValuesF0));
   assertEquals(
       "00000000:00000000:00000000:00000000:00000000:00000000:00000000:00000101",
       Utils.toBitsSep(hf.mValuesF1));
   hf.reset();
   hf.integrity(0, 0, 0);
 }
Ejemplo n.º 3
0
 String countsString() {
   return mReadGroup
       + "\t"
       + mTotalReference
       + "\t"
       + mLengthDist.count()
       + "\t"
       + Utils.realFormat(mLengthDist.sum())
       + "\t"
       + Utils.realFormat(mLengthDist.sumSq())
       + "\t"
       + mFragmentSizeDist.count()
       + "\t"
       + Utils.realFormat(mFragmentSizeDist.sum())
       + "\t"
       + Utils.realFormat(mFragmentSizeDist.sumSq())
       + "\t"
       + mGapSizeDist.count()
       + "\t"
       + Utils.realFormat(mGapSizeDist.sum())
       + "\t"
       + Utils.realFormat(mGapSizeDist.sumSq())
       + "\t"
       + mMaxAlignment
       + "\t"
       + mProper
       + "\t"
       + mDiscordant
       + "\t"
       + mUnmated;
 }
Ejemplo n.º 4
0
 @Override
 public String toString() {
   return id()
       + "\t"
       + Utils.realFormat(meanLength(), 5)
       + "\t"
       + Utils.realFormat(fragmentMean(), 5)
       + "\t"
       + Utils.realFormat(fragmentStdDev(), 5)
       + "\t"
       + Utils.realFormat(gapMean(), 5)
       + "\t"
       + Utils.realFormat(gapStdDev(), 5)
       + "\t"
       + Utils.realFormat(maxAlignment(), 5)
       + "\t"
       + Utils.realFormat(properRate(), 6)
       + "\t"
       + Utils.realFormat(properRandomRate(), 6)
       + "\t"
       + Utils.realFormat(discordantRate(), 6)
       + "\t"
       + Utils.realFormat(unmatedRate(), 6);
 }
 /**
  * @param calibrator the mapping calibration stats to use when computing coverage
  * @param defaultSequenceLengths map of sequence names to sequence length, used if not already set
  *     in the calibrator
  * @param readGroupToSampleId read group to sample id
  * @param restriction a region restriction, may be null
  */
 public CalibratedPerSequenceExpectedCoverage(
     Calibrator calibrator,
     Map<String, Integer> defaultSequenceLengths,
     Map<String, String> readGroupToSampleId,
     RegionRestriction restriction) {
   mSequenceSampleCoverages = new HashMap<>();
   mSumCoverages = new HashMap<>();
   mSamples = Collections.unmodifiableSet(new HashSet<>(readGroupToSampleId.values()));
   final Map<String, Integer> sequenceLengths =
       calibrator.hasLengths() ? calibrator.getSequenceLengths() : defaultSequenceLengths;
   if (calibrator.getCovariateIndex(CovariateEnum.SEQUENCE)
       == -1) { // No per sequence separation in calibration data, calculate per-genome coverage
                // level
     long length = 0;
     for (final Map.Entry<String, Integer> entry : sequenceLengths.entrySet()) {
       length += entry.getValue();
     }
     final Map<String, HashMap<String, CalibrationStats>> local = new HashMap<>();
     findIndividualGlobalCoverage(calibrator, readGroupToSampleId, local);
     double currentMax = 0;
     double currentSum = 0;
     for (Map.Entry<String, HashMap<String, CalibrationStats>> e : local.entrySet()) {
       final HashMap<String, CalibrationStats> map = e.getValue();
       if (map.containsKey(DUMMY_SEQ)) {
         final double currentCov =
             (length == 0) ? 0 : (double) map.get(DUMMY_SEQ).getTotalLength() / length;
         final String sampleName = e.getKey();
         Diagnostic.userLog(
             "Average coverage for sample "
                 + sampleName
                 + " is "
                 + Utils.realFormat(currentCov, 2));
         for (final Map.Entry<String, Integer> entry : sequenceLengths.entrySet()) {
           final String seqName = entry.getKey();
           Map<String, Double> samples = mSequenceSampleCoverages.get(seqName);
           if (samples == null) {
             samples = new HashMap<>();
             mSequenceSampleCoverages.put(seqName, samples);
           }
           samples.put(sampleName, currentCov);
         }
         currentSum += currentCov;
         if (currentCov > currentMax) {
           currentMax = currentCov;
         }
       }
     }
     Diagnostic.userLog("Average combined coverage is " + Utils.realFormat(currentSum, 2));
     for (final Map.Entry<String, Integer> entry : sequenceLengths.entrySet()) {
       final String seqName = entry.getKey();
       mSumCoverages.put(seqName, currentSum);
     }
   } else { // Per-sequence separation is in calibration data, calculate per-sequence coverage
            // level
     final Map<String, HashMap<String, CalibrationStats>> local = new HashMap<>();
     findIndividualPerSequenceCoverage(
         calibrator, sequenceLengths, readGroupToSampleId, local, restriction);
     for (final Map.Entry<String, Integer> entry : sequenceLengths.entrySet()) {
       final String seqName = entry.getKey();
       if (restriction != null && !seqName.equals(restriction.getSequenceName())) {
         continue;
       }
       final int seqLength = entry.getValue();
       double currentMax = 0;
       double currentSum = 0;
       for (Map.Entry<String, HashMap<String, CalibrationStats>> e : local.entrySet()) {
         final HashMap<String, CalibrationStats> map = e.getValue();
         if (map.containsKey(seqName)) {
           final double currentCov =
               (seqLength == 0) ? 0 : (double) map.get(seqName).getTotalLength() / seqLength;
           final String sampleName = e.getKey();
           Diagnostic.userLog(
               "Average coverage across sequence "
                   + seqName
                   + " for sample "
                   + sampleName
                   + " is "
                   + Utils.realFormat(currentCov, 2));
           Map<String, Double> samples = mSequenceSampleCoverages.get(seqName);
           if (samples == null) {
             samples = new HashMap<>();
             mSequenceSampleCoverages.put(seqName, samples);
           }
           samples.put(sampleName, currentCov);
           currentSum += currentCov;
           if (currentCov > currentMax) {
             currentMax = currentCov;
           }
         }
       }
       Diagnostic.userLog(
           "Average combined coverage for sequence "
               + seqName
               + " is "
               + Utils.realFormat(currentSum, 2));
       mSumCoverages.put(seqName, currentSum);
     }
   }
 }