public String getPairOrientation() {
    // LOG.info("getPairOrientation");
    String pairOrientation = "";
    if (EntryFlagHelper.isPaired(entry)
        && !EntryFlagHelper.isMateUnmapped(entry)
        && entry.getTargetIndex() == entry.getPairAlignmentLink().getTargetIndex()) {

      char s1 = EntryFlagHelper.isReadReverseStrand(entry) ? 'R' : 'F';
      char s2 = EntryFlagHelper.isMateReverseStrand(entry) ? 'R' : 'F';
      char o1 = ' ';
      char o2 = ' ';
      char[] tmp = new char[4];
      if (EntryFlagHelper.isFirstInPair(entry)) {
        o1 = '1';
        o2 = '2';
      } else if (EntryFlagHelper.isSecondInPair(entry)) {
        o1 = '2';
        o2 = '1';
      }
      if (getInferredInsertSize() > 0) {
        tmp[0] = s1;
        tmp[1] = o1;
        tmp[2] = s2;
        tmp[3] = o2;

      } else {
        tmp[2] = s1;
        tmp[3] = o1;
        tmp[0] = s2;
        tmp[1] = o2;
      }
      pairOrientation = new String(tmp);
    }
    return pairOrientation;
  }
Example #2
0
  /**
   * Determine if this iterator has more alignment entries in the given window.
   *
   * @return True if next() will return an alignment, False otherwise.
   */
  public boolean hasNext() {
    /*    LOG.debug(String.format("previousPosition: %d endReferencePosition %d previousReferenceIndex %d targetIndex %d",
            previousPosition, endReferencePosition, previousReferenceIndex, targetIndex)
    ); */
    // Fetch the next entry with skipTo
    if (nextEntry != null) return true;

    try {
      if (!useWindow) {
        // all results are returned
        if (!reader.hasNext()) return false;
        nextEntry = reader.next();
      } else {
        // we return only within a window
        nextEntry = reader.skipTo(targetIndex, startReferencePosition);

        if (nextEntry == null
            || (nextEntry.getTargetIndex() != targetIndex
                || nextEntry.getPosition() < startReferencePosition
                || nextEntry.getPosition() > endReferencePosition)) {
          // No next entry, on a different target sequence, or before the position of interest:
          nextEntry = null;
        }
      }
    } catch (IOException e) {
      nextEntry = null;
      LOG.error(e);
      //  throw new RuntimeException("IO error reading next Goby alignment entry", e);
      return false;
    } catch (GobyRuntimeException e) {
      nextEntry = null;
      LOG.error(e);
      //  throw new RuntimeException("IO error reading next Goby alignment entry", e);
      return false;
    }

    final boolean result = nextEntry != null;
    // LOG.debug("hasNext returning :" + result);
    return result;
  }
  /**
   * Verify that the list has an appropriate unbroken chain of back links.
   *
   * @param list the list of splices to validate
   * @return true if the list has an unbroken chain of back links
   */
  boolean spliceListIsValid(final ObjectArrayList<GobyAlignment> list) {

    if (list != null && list.size() > 1) {
      Alignments.AlignmentEntry prevEntry = list.get(0).entry;
      for (int i = 1; i < list.size(); i++) {
        Alignments.AlignmentEntry currentEntry = list.get(i).entry;
        if (!currentEntry.hasSplicedBackwardAlignmentLink()) return false;
        else {
          Alignments.RelatedAlignmentEntry currentBackwardLink =
              currentEntry.getSplicedBackwardAlignmentLink();

          if ((prevEntry.getQueryIndex() != currentEntry.getQueryIndex())
              || (prevEntry.getFragmentIndex() != currentBackwardLink.getFragmentIndex())
              || (prevEntry.getPosition() != currentBackwardLink.getPosition())
              || (prevEntry.getTargetIndex() != currentBackwardLink.getTargetIndex())) {
            return false;
          }
        }
        prevEntry = currentEntry;
      }
    }
    return true;
  }
  @Test
  public void testLastToCompact1() throws IOException {

    // test LastToCompact convert+filtering

    // read fake data and convert+filter
    final LastToCompactMode processor = new LastToCompactMode();
    final int LAST_TO_COMPACT_M_PARAM = 2;
    processor.setAmbiguityThreshold(LAST_TO_COMPACT_M_PARAM);
    processor.setInputFile("test-results/alignments/last-to-compact/last-101.maf");
    processor.setOutputFile("test-results/alignments/last-to-compact/last-101.compact");
    processor.setTargetReferenceIdsFilename(
        "test-results/alignments/last-to-compact/last-reference.compact-reads");
    processor.setOnlyMafFile(true);
    processor.setNumberOfReads(2857819);
    processor.setLargestQueryIndex(2857819);
    processor.setSmallestQueryIndex(0);
    processor.setPropagateQueryIds(false);
    processor.setPropagateTargetIds(true);
    processor.execute();

    // read compact alignment results
    final AlignmentReaderImpl reader = new AlignmentReaderImpl(processor.getOutputFile());
    reader.readHeader();
    assertEquals(2857819, reader.getNumberOfQueries());
    assertEquals(1, reader.getNumberOfTargets());
    assertTrue(reader.hasQueryIndexOccurrences());

    // lookup tables
    final Int2IntOpenHashMap queryIndex2NumberOfHits = new Int2IntOpenHashMap();

    final Int2FloatOpenHashMap queryIndex2Score = new Int2FloatOpenHashMap();
    final Int2IntOpenHashMap queryIndex2Multiplicity = new Int2IntOpenHashMap();
    final Int2IntOpenHashMap queryIndex2NumberOfIndels = new Int2IntOpenHashMap();
    final Int2IntOpenHashMap queryIndex2NumberOfMismatches = new Int2IntOpenHashMap();
    final Int2IntOpenHashMap queryIndex2Position = new Int2IntOpenHashMap();
    final Int2IntOpenHashMap queryIndex2QueryAlignedLength = new Int2IntOpenHashMap();
    final Int2IntOpenHashMap queryIndex2QueryPosition = new Int2IntOpenHashMap();
    final Int2IntOpenHashMap queryIndex2TargetIndex = new Int2IntOpenHashMap();
    final Int2BooleanOpenHashMap queryIndex2MatchingReverseStrand = new Int2BooleanOpenHashMap();
    final Int2IntOpenHashMap queryIndex2TargetAlignedLength = new Int2IntOpenHashMap();
    final Int2IntOpenHashMap queryIndex2QueryIndexOcc = new Int2IntOpenHashMap();
    final Int2IntOpenHashMap queryIndex2Ambiguity = new Int2IntOpenHashMap();

    // enter alignment data
    int qii;
    while (reader.hasNext()) {

      final Alignments.AlignmentEntry aln = reader.next();
      qii = aln.getQueryIndex();

      final int numHits = queryIndex2NumberOfHits.get(qii);

      queryIndex2NumberOfHits.put(qii, numHits + 1);

      queryIndex2Score.put(qii, aln.getScore());
      queryIndex2Multiplicity.put(qii, aln.getMultiplicity());
      queryIndex2NumberOfIndels.put(qii, aln.getNumberOfIndels());
      queryIndex2NumberOfMismatches.put(qii, aln.getNumberOfMismatches());
      queryIndex2Position.put(qii, aln.getPosition());
      queryIndex2QueryAlignedLength.put(qii, aln.getQueryAlignedLength());
      queryIndex2QueryPosition.put(qii, aln.getQueryPosition());
      queryIndex2TargetIndex.put(qii, aln.getTargetIndex());
      queryIndex2MatchingReverseStrand.put(qii, aln.getMatchingReverseStrand());
      queryIndex2TargetAlignedLength.put(qii, aln.getTargetAlignedLength());
      queryIndex2QueryIndexOcc.put(qii, aln.getQueryIndexOccurrences());
      queryIndex2Ambiguity.put(qii, aln.getAmbiguity());
    }

    //
    // validate alignment data using values from getMafInput() below
    //

    // there are a total of 5 entries with ID 2857818
    // 2 entries have score = 35 (the maximum score for this ID)
    // 3 entries are filtered b/c their scores are below 35
    qii = 2857818;
    assertEquals(queryIndex2NumberOfHits.get(qii), 2);
    assertEquals((int) queryIndex2Score.get(qii), 35);
    assertEquals(queryIndex2Multiplicity.get(qii), 1);
    assertEquals(queryIndex2NumberOfIndels.get(qii), 0);
    assertEquals(queryIndex2NumberOfMismatches.get(qii), 0);
    assertEquals(queryIndex2Position.get(qii), 1614); // last entry added
    assertEquals(queryIndex2QueryAlignedLength.get(qii), 35);
    assertEquals(queryIndex2QueryPosition.get(qii), 0);
    assertEquals(queryIndex2TargetIndex.get(qii), 0);
    assertEquals(queryIndex2MatchingReverseStrand.get(qii), false);
    assertEquals(queryIndex2TargetAlignedLength.get(qii), 35);
    assertEquals(2, queryIndex2QueryIndexOcc.get(qii));
    assertEquals(2, queryIndex2Ambiguity.get(qii));

    // there are 5 entries with the score = 35 (the maximum score for this ID)
    // filtered due to ambiguity
    qii = 577287;
    assertEquals(queryIndex2NumberOfHits.get(qii), 0);
    assertEquals((int) queryIndex2Score.get(qii), 0);
    assertEquals(queryIndex2Multiplicity.get(qii), 0);
    assertEquals(queryIndex2NumberOfIndels.get(qii), 0);
    assertEquals(queryIndex2NumberOfMismatches.get(qii), 0);
    assertEquals(queryIndex2Position.get(qii), 0);
    assertEquals(queryIndex2QueryAlignedLength.get(qii), 0);
    assertEquals(queryIndex2QueryPosition.get(qii), 0);
    assertEquals(queryIndex2TargetIndex.get(qii), 0);
    assertEquals(queryIndex2MatchingReverseStrand.get(qii), false);
    assertEquals(queryIndex2TargetAlignedLength.get(qii), 0);
    assertEquals(0, queryIndex2QueryIndexOcc.get(qii));
    assertEquals(0, queryIndex2Ambiguity.get(qii));

    //
    reader.close();
  }
  /** Get the reference id from the iterator, prepend "chr". */
  public String getChromosome() {

    return "chr" + iterator.indexToReferenceId.getId(entry.getTargetIndex()).toString();
  }