org.broadinstitute.hellbender.utils

Class GenomeLoc

java.lang.Object

org.broadinstitute.hellbender.utils.GenomeLoc

All Implemented Interfaces:

htsjdk.samtools.util.Locatable, java.io.Serializable, java.lang.Comparable<GenomeLoc>, HasGenomeLocation

public class GenomeLoc
extends java.lang.Object
implements java.lang.Comparable<GenomeLoc>, java.io.Serializable, HasGenomeLocation, htsjdk.samtools.util.Locatable

Genome location representation. It is *** 1 *** based closed. Note that GenomeLocs start and stop values can be any positive or negative number, by design. Bound validation is a feature of the GenomeLocParser, and not a fundamental constraint of the GenomeLoc This class is not intended to be extended outside of the core GATK engine and tests.

See Also:

Serialized Form

Field Summary

Fields

Modifier and Type	Field and Description
protected int	contigIndex the basic components of a genome loc, its contig index, start and stop position, and (optionally) the contig name
protected java.lang.String	contigName
protected int	start
protected int	stop
static GenomeLoc	UNMAPPED A static constant to use when referring to the unmapped section of a datafile file.
static GenomeLoc	WHOLE_GENOME

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	GenomeLoc(java.lang.String contig, int contigIndex, int start, int stop)

Method Summary

Modifier and Type	Method and Description
int	compareContigs(GenomeLoc that) conpare this genomeLoc's contig to another genome loc
int	compareTo(GenomeLoc that)
boolean	containsP(GenomeLoc that)
boolean	contiguousP(GenomeLoc that)
boolean	discontinuousP(GenomeLoc that)
boolean	disjointP(GenomeLoc that)
int	distance(GenomeLoc that)
long	distanceAcrossContigs(GenomeLoc other, htsjdk.samtools.SAMFileHeader samFileHeader) Calculates the distance between two genomeLocs across contigs (if necessary).
GenomeLoc	endpointSpan(GenomeLoc that) Returns a new GenomeLoc that represents the region between the endpoints of this and that.
boolean	equals(java.lang.Object other) Check to see whether two genomeLocs are equal.
java.lang.String	getContig()
int	getContigIndex()
int	getEnd()
GenomeLoc	getLocation()
int	getStart()
GenomeLoc	getStartLocation()
int	getStop()
GenomeLoc	getStopLocation()
int	hashCode()
GenomeLoc	intersect(GenomeLoc that)
boolean	isBefore(GenomeLoc that) Tests whether this contig is completely before contig 'that'.
boolean	isBetween(GenomeLoc left, GenomeLoc right)
boolean	isPast(GenomeLoc that) Tests whether this contig is completely after contig 'that'.
boolean	isUnmapped() Return true if this GenomeLoc represents the UNMAPPED location
static boolean	isUnmapped(GenomeLoc loc)
GenomeLoc	max(GenomeLoc other) Returns the maximum GenomeLoc of this and other
GenomeLoc	merge(GenomeLoc that) Returns a new GenomeLoc that represents the entire span of this and that.
static <T extends GenomeLoc> GenomeLoc	merge(java.util.SortedSet<T> sortedLocs) Merges a list of *sorted* *contiguous* locs into 1
static <T extends GenomeLoc> GenomeLoc	merge(T a, T b) Merges 2 *contiguous* locs into 1
int	minDistance(GenomeLoc that) Return the minimum distance between any pair of bases in this and that GenomeLocs:
boolean	onSameContig(GenomeLoc that)
boolean	overlapsP(GenomeLoc that)
double	reciprocialOverlapFraction(GenomeLoc o) reciprocialOverlap: what is the min.
static GenomeLoc	setStart(GenomeLoc loc, int start) create a new genome loc from an existing loc, with a new start position Note that this function will NOT explicitly check the ending offset, in case someone wants to set the start of a new GenomeLoc pertaining to a read that goes off the end of the contig.
static GenomeLoc	setStop(GenomeLoc loc, int stop) create a new genome loc from an existing loc, with a new stop position Note that this function will NOT explicitly check the ending offset, in case someone wants to set the stop of a new GenomeLoc pertaining to a read that goes off the end of the contig.
int	size() How many BPs are covered by this locus?
GenomeLoc[]	split(int splitPoint) Splits the contig into to regions: [start,split point) and [split point, end].
java.util.List<GenomeLoc>	subtract(GenomeLoc that)
java.lang.String	toString()
GenomeLoc	union(GenomeLoc that)

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface htsjdk.samtools.util.Locatable

contains, contigsMatch, getLengthOnReference, overlaps, withinDistanceOf

Field Detail

contigIndex

protected final int contigIndex

the basic components of a genome loc, its contig index, start and stop position, and (optionally) the contig name

start

protected final int start

stop

protected final int stop

contigName

protected final java.lang.String contigName

UNMAPPED

public static final GenomeLoc UNMAPPED

A static constant to use when referring to the unmapped section of a datafile file. The unmapped region cannot be subdivided. Only this instance of the object may be used to refer to the region, as '==' comparisons are used in comparators, etc.

WHOLE_GENOME

public static final GenomeLoc WHOLE_GENOME

Constructor Detail

GenomeLoc

protected GenomeLoc(java.lang.String contig,
                    int contigIndex,
                    int start,
                    int stop)

Method Detail

isUnmapped

public static final boolean isUnmapped(GenomeLoc loc)

getLocation

public final GenomeLoc getLocation()

Specified by:

getLocation in interface HasGenomeLocation

getStartLocation

public final GenomeLoc getStartLocation()

getStopLocation

public final GenomeLoc getStopLocation()

getContig

public final java.lang.String getContig()

Specified by:

getContig in interface htsjdk.samtools.util.Locatable

Returns:

the name of the contig of this GenomeLoc

getContigIndex

public final int getContigIndex()

getStart

public final int getStart()

Specified by:

getStart in interface htsjdk.samtools.util.Locatable

getEnd

public int getEnd()

Specified by:

getEnd in interface htsjdk.samtools.util.Locatable

getStop

public final int getStop()

toString

public final java.lang.String toString()

Overrides:

toString in class java.lang.Object

disjointP

public final boolean disjointP(GenomeLoc that)

discontinuousP

public final boolean discontinuousP(GenomeLoc that)

overlapsP

public final boolean overlapsP(GenomeLoc that)

contiguousP

public final boolean contiguousP(GenomeLoc that)

isUnmapped

public final boolean isUnmapped()

Return true if this GenomeLoc represents the UNMAPPED location

Returns:

merge

public GenomeLoc merge(GenomeLoc that)
                throws GATKException

Returns a new GenomeLoc that represents the entire span of this and that. Requires that this and that GenomeLoc are contiguous and both mapped

Throws:

GATKException

split

public GenomeLoc[] split(int splitPoint)

Splits the contig into to regions: [start,split point) and [split point, end].

Parameters:

splitPoint - The point at which to split the contig. Must be contained in the given interval.

Returns:

A two element array consisting of the genome loc before the split and the one after.

union

public GenomeLoc union(GenomeLoc that)

intersect

public GenomeLoc intersect(GenomeLoc that)
                    throws GATKException

Throws:

GATKException

subtract

public final java.util.List<GenomeLoc> subtract(GenomeLoc that)

containsP

public final boolean containsP(GenomeLoc that)

onSameContig

public final boolean onSameContig(GenomeLoc that)

distance

public final int distance(GenomeLoc that)

isBetween

public final boolean isBetween(GenomeLoc left,
                               GenomeLoc right)

isBefore

public final boolean isBefore(GenomeLoc that)

Tests whether this contig is completely before contig 'that'.

Parameters:

that - Contig to test against.

Returns:

true if this contig ends before 'that' starts; false if this is completely after or overlaps 'that'.

isPast

public final boolean isPast(GenomeLoc that)

Tests whether this contig is completely after contig 'that'.

Parameters:

that - Contig to test against.

Returns:

true if this contig starts after 'that' ends; false if this is completely before or overlaps 'that'.

minDistance

public final int minDistance(GenomeLoc that)

Return the minimum distance between any pair of bases in this and that GenomeLocs:

equals

public boolean equals(java.lang.Object other)

Check to see whether two genomeLocs are equal. Note that this implementation ignores the contigInfo object.

Overrides:

equals in class java.lang.Object

Parameters:

other - Other contig to compare.

hashCode

public int hashCode()

Overrides:

hashCode in class java.lang.Object

compareContigs

public final int compareContigs(GenomeLoc that)

conpare this genomeLoc's contig to another genome loc

Parameters:

that - the genome loc to compare contigs with

Returns:

0 if equal, -1 if that.contig is greater, 1 if this.contig is greater

compareTo

public int compareTo(GenomeLoc that)

Specified by:

compareTo in interface java.lang.Comparable<GenomeLoc>

size

public int size()

How many BPs are covered by this locus?

Returns:

Number of BPs covered by this locus. According to the semantics of GenomeLoc, this should never be < 1.

reciprocialOverlapFraction

public final double reciprocialOverlapFraction(GenomeLoc o)

reciprocialOverlap: what is the min. percent of gl1 and gl2 covered by both gl1.s ---------- gk1.e gl2.s ---------- gl2.e 100% gl1.s ---------- gk1.e gl2.s ---------- gl2.e 50% gl1.s ---------- gk1.e gl2.s -------------------- gl2.e 25% (50% for gl1 but only 25% for gl2)

max

public GenomeLoc max(GenomeLoc other)

Returns the maximum GenomeLoc of this and other

Parameters:

other - another non-null genome loc

Returns:

the max of this and other

merge

public static <T extends GenomeLoc> GenomeLoc merge(T a,
                                                    T b)

Merges 2 *contiguous* locs into 1

Parameters:

a - GenomeLoc #1

b - GenomeLoc #2

Returns:

one merged loc

merge

public static <T extends GenomeLoc> GenomeLoc merge(java.util.SortedSet<T> sortedLocs)

Merges a list of *sorted* *contiguous* locs into 1

Parameters:

sortedLocs - a sorted list of contiguous locs

Returns:

one merged loc

distanceAcrossContigs

public long distanceAcrossContigs(GenomeLoc other,
                                  htsjdk.samtools.SAMFileHeader samFileHeader)

Calculates the distance between two genomeLocs across contigs (if necessary). Returns minDistance(other) if in same contig. Works with intervals! Uses the SAMFileHeader to extract the size of the contigs and follows the order in the dictionary.

Parameters:

other - the genome loc to compare to

samFileHeader - the contig information

Returns:

the sum of all the bases in between the genomeLocs, including entire contigs

setStart

public static GenomeLoc setStart(GenomeLoc loc,
                                 int start)

create a new genome loc from an existing loc, with a new start position Note that this function will NOT explicitly check the ending offset, in case someone wants to set the start of a new GenomeLoc pertaining to a read that goes off the end of the contig.

Parameters:

loc - the old location

start - a new start position

Returns:

a newly allocated GenomeLoc as loc but with start == start

setStop

public static GenomeLoc setStop(GenomeLoc loc,
                                int stop)

create a new genome loc from an existing loc, with a new stop position Note that this function will NOT explicitly check the ending offset, in case someone wants to set the stop of a new GenomeLoc pertaining to a read that goes off the end of the contig.

Parameters:

loc - the old location

stop - a new stop position

Returns:

a newly allocated GenomeLoc as loc but with stop == stop

endpointSpan

public GenomeLoc endpointSpan(GenomeLoc that)

Returns a new GenomeLoc that represents the region between the endpoints of this and that. Requires that this and that GenomeLoc are both mapped.