/** * Determines if a cigar has any element that both consumes read bases and consumes reference bases * (e.g. is not all soft-clipped) */ public static boolean cigarMapsNoBasesToRef(final Cigar cigar) { for (final CigarElement el : cigar.getCigarElements()) { if (el.getOperator().consumesReadBases() && el.getOperator().consumesReferenceBases()) { return false; } } return true; }
public static List<CigarElement> toCigarOperatorList(List<CigEl> list) { List<CigarElement> result = new ArrayList<CigarElement>(list.size()); for (CigEl e : list) result.add(new CigarElement(e.len, CigarOperator.characterToEnum(e.op))); return result; } }
public CigarSizeDistribution(List<CigarDetailMetrics> list) { this.phred = new double[CigarOperator.values().length][]; for (CigarOperator op : CigarOperator.values()) { char charop = (char)CigarOperator.enumToCharacter(op); this.phred[CigarOperator.enumToBinary(op)] = calcPhred(Lists.newArrayList(Iterables.filter(list, cdm -> cdm.OPERATOR == charop))); } } private static double[] calcPhred(List<CigarDetailMetrics> sc) {
private static List<CigarDetailMetrics> getCigarMetrics(File cigarMetricsFile) { if (cigarMetricsFile == null) return null; List<CigarDetailMetrics> list = new ArrayList<CigarDetailMetrics>(); for (CigarDetailMetrics metric : Iterables.filter(MetricsFile.readBeans(cigarMetricsFile), CigarDetailMetrics.class)) { list.add(metric); } Collections.sort(list, CigarDetailMetricsByLength); for (CigarOperator op : CigarOperator.values()) { List<CigarDetailMetrics> opList = list.stream().filter(cdm -> cdm.OPERATOR == CigarOperator.enumToCharacter(op)).collect(Collectors.toList()); for (int i = 0; i < opList.size(); i++) { if (opList.get(i).LENGTH != i) { String msg = String.format("%s missing cigar metric: expected metric for length %d, found %d", cigarMetricsFile, i, opList.get(0).LENGTH); log.error(msg); throw new RuntimeException(msg); } } } return list; } public InsertSizeDistribution getInsertSizeDistribution() {
final CigarElement e = cigar.get(elementIndex); final CigarOperator operator = e.getOperator(); if (operator.equals(CigarOperator.I)) { } else if (operator.equals(CigarOperator.D)) { if (operator.consumesReadBases()) readBase += e.getLength(); if (operator.consumesReferenceBases()) refBase += e.getLength();
/** * @return The number of read bases that the read covers. */ public static int getReadLength(final List<CigarElement> cigarElements) { int length = 0; for (final CigarElement element : cigarElements) { if (element.getOperator().consumesReadBases()){ length += element.getLength(); } } return length; }
if (ce.getOperator().consumesReadBases()) { for (int i = 0; i < ce.getLength(); i++) { if (r1.getBaseQualities()[i + posInRead - 1] != r2.getBaseQualities()[i + posInRead - 1]) { d.refBase = ref[i + posInRef - 1]; ce.getOperator(); d.cigarOp = CigarOperator.enumToCharacter(ce.getOperator()); d.oScore = r1.getBaseQualities()[i + posInRead - 1]; d.score = r2.getBaseQualities()[i + posInRead - 1]; posInRead += ce.getOperator().consumesReadBases() ? ce.getLength() : 0; posInRef += ce.getOperator().consumesReferenceBases() ? ce.getLength() : 0;
/** * Returns the number of reference bases 'consumed' by the given cigar * @param list * @return base count */ public static int referenceLength(List<CigarElement> list) { int length = 0; for (CigarElement e : list) { if (e.getOperator().consumesReferenceBases()) { length += e.getLength(); } } return length; } /**
private void parseAlignments() { Utils.parseCigarInto(evidenceRecord.ReferenceAlignment, firstHalf.cgCigElList); int len = 0; for (CigEl e : firstHalf.cgCigElList) { switch (e.op) { case 'B': break; default: len += CigarOperator.characterToEnum(e.op).consumesReadBases() ? e.len : 0; break; } } if ((evidenceRecord.side == 1 && !evidenceRecord.negativeStrand) || (evidenceRecord.side == 0 && evidenceRecord.negativeStrand)) { secondHalf.baseBuf = Utils.slice(baseBuf, 0, len); secondHalf.scoreBuf = Utils.slice(scoreBuf, 0, len); firstHalf.baseBuf = Utils.slice(baseBuf, len, baseBuf.limit()); firstHalf.scoreBuf = Utils.slice(scoreBuf, len, scoreBuf.limit()); } else { firstHalf.baseBuf = Utils.slice(baseBuf, 0, len); firstHalf.scoreBuf = Utils.slice(scoreBuf, 0, len); secondHalf.baseBuf = Utils.slice(baseBuf, len, baseBuf.limit()); secondHalf.scoreBuf = Utils.slice(scoreBuf, len, scoreBuf.limit()); } Utils.parseCigarInto(evidenceRecord.MateReferenceAlignment, secondHalf.cgCigElList); }
final CigarOperator currentOp = cigarOperators.get(i); int j = i + 1; while (j < cigarOperators.size() && cigarOperators.get(j).equals(currentOp)) { j++;
int[] deletedBlock= new int[2]; // Length 2 because it contains start and end of deleted block for(CigarElement op : cigarOps){ if(op.getOperator().equals(CigarOperator.DELETION)){ deletedBlock[0]= samRecord.getReferencePositionAtReadPosition(readTracker) + 1; deletedBlock[1]= samRecord.getReferencePositionAtReadPosition(readTracker + 1) - 1; if(op.getOperator().consumesReadBases()){ readTracker += op.getLength();
private static boolean testBaseCategory(BaseCategory c, ScoreDiff diff) { switch (c.type) { case FLANKING_DELETION: return diff.nextBaseCoP == CigarOperator.enumToCharacter(CigarOperator.DELETION) || diff.prevBaseCoP == CigarOperator.enumToCharacter(CigarOperator.DELETION); case INSERTION: return diff.cigarOp == CigarOperator.enumToCharacter(CigarOperator.INSERTION); case LOWER_COVERAGE: return diff.coverage < c.param; case MATCH: return diff.base == diff.refBase; case MISMATCH: return diff.base != diff.refBase; case PILEUP: return diff.pileup <= c.param; default: throw new RuntimeException("Unknown read category: " + c.type.name()); } }
/**List of positions on screen where the skipped bases (cigar op: N) start * @throws IOException * @throws InvalidGenomicCoordsException * */ private void setTextPositionsOfSkippedBases() throws InvalidGenomicCoordsException, IOException{ int genomicPosition= this.getSamRecord().getAlignmentStart(); List<CigarElement> cigar = this.getSamRecord().getCigar().getCigarElements(); for(CigarElement el : cigar){ if(el.getOperator().equals(CigarOperator.SKIPPED_REGION)){ int[] textPositions= new int[2]; // +1 because textPosition is 1-based textPositions[0]= Utils.getIndexOfclosestValue(genomicPosition, this.gc.getMapping()) + 1; textPositions[1]= Utils.getIndexOfclosestValue(genomicPosition + el.getLength(), this.gc.getMapping()) + 1; this.textPositionsOfSkippedBases.add(textPositions); }; if(el.getOperator().consumesReferenceBases()){ genomicPosition += el.getLength(); } } }
@Test(dataProvider = "opStatus") public void testIsSetOfOperations(final CigarOperator op, final boolean isClipping, final boolean isIndel,final boolean isSkip, final boolean isAlignment, final boolean isPadding) throws Exception { Assert.assertEquals(op.isClipping(), isClipping); Assert.assertEquals(op.isIndel(), isIndel); Assert.assertEquals(op.isIndelOrSkippedRegion(), isIndel || isSkip); Assert.assertEquals(op.isAlignment(), isAlignment); Assert.assertEquals(op.isPadding(), isPadding); } }
/** * Returns the phred scaled probability of a cigar operator of at least this length * @param length * @return phred score */ public double getPhred(CigarOperator operator, int length) { if (length < 0) return 0; double[] opPhred = phred[CigarOperator.enumToBinary(operator)]; assert(opPhred != null); if (length >= opPhred.length) return opPhred[opPhred.length - 1]; return opPhred[length]; } }
public CigarElement(final int length, final CigarOperator operator) { if (length < 0) throw new IllegalArgumentException(String.format("Cigar element being constructed with negative length: %d and operation: %s" , length, operator.name())); this.length = length; this.operator = operator; }
private static boolean isClippingOperator(final CigarOperator op) { return op !=null && op.isClipping(); }
/** * @param cigarette CIGAR element (operator + length) encoded as an unsigned int. * @return Object representation of the CIGAR element. */ private static CigarElement binaryCigarToCigarElement(final int cigarette) { final int binaryOp = cigarette & 0xf; final int length = cigarette >>> 4; return new CigarElement(length, CigarOperator.binaryToEnum(binaryOp)); } }
final CigarElement e = cigar.get(elementIndex); final CigarOperator operator = e.getOperator(); if (operator.equals(CigarOperator.I)) { } else if (operator.equals(CigarOperator.D)) { if (operator.consumesReadBases()) readBase += e.getLength(); if (operator.consumesReferenceBases()) refBase += e.getLength();
/** * @return The number of read bases that the read covers. */ public static int getReadLength(final List<CigarElement> cigarElements) { int length = 0; for (final CigarElement element : cigarElements) { if (element.getOperator().consumesReadBases()){ length += element.getLength(); } } return length; }