Inheritance diagram for lsst.geom.geometry.SphericalBoxPartitionMap:

Public Member Functions
def	__init__ (self, numStripes, numSubStripesPerStripe)

def	getSubStripe (self, phi)

def	getStripe (self, phi)

def	getSubChunk (self, subStripe, theta)

def	getChunk (self, stripe, theta)

def	getChunkBoundingBox (self, chunkId)

def	getSubChunkBoundingBox (self, chunkId, subChunkId)

def	getChunkId (self, stripe, chunk)

def	getSubChunkId (self, subStripe, subChunk)

def	intersect (self, args)

def	__iter__ (self)

def	__eq__ (self, other)

def	__repr__ (self)

Public Attributes
	numStripes

	numSSPerStripe

	numSubStripes

	stripeHeight

	subStripeHeight

	numChunks

	numSCPerChunk

	subChunkWidth

	maxSCPerChunk

Detailed Description

A simple partitioning scheme that breaks the unit sphere into fixed
height latitude angle stripes. These are in turn broken up into fixed
width longitude angle chunks (each stripe has a variable number of chunks
to account for distortion at the poles). Chunks are in turn broken up
into fixed height sub-stripes, and each sub-stripe is then divided into
fixed width sub-chunks. Again, the number of sub-chunks per sub-stripe is
variable to account for polar distortion.

Definition at line 2040 of file geometry.py.

Constructor & Destructor Documentation

◆ init()

def lsst.geom.geometry.SphericalBoxPartitionMap.__init__	(	self,
		numStripes,
		numSubStripesPerStripe
	)

Definition at line 2050 of file geometry.py.

     def __init__(self, numStripes, numSubStripesPerStripe):
         if (not isinstance(numStripes, numbers.Integral) or
                 not isinstance(numSubStripesPerStripe, numbers.Integral)):
             raise TypeError('Number of stripes and sub-stripes per stripe ' +
                             'must be integers')
         if numStripes < 1 or numSubStripesPerStripe < 1:
             raise RuntimeError('Number of stripes and sub-stripes per ' +
                                'stripe must be positive')
         self.numStripes = numStripes
         self.numSSPerStripe = numSubStripesPerStripe
         self.numSubStripes = numStripes * numSubStripesPerStripe
         h = 180.0 / numStripes
         hs = 180.0 / self.numSubStripes
         self.stripeHeight = h
         self.subStripeHeight = hs
         self.numChunks = [segments(i * h - 90.0, (i + 1) * h - 90.0, h)
                           for i in range(numStripes)]
         self.numSCPerChunk = []
         self.subChunkWidth = []
         for i in range(self.numSubStripes):
             nc = self.numChunks[i//numSubStripesPerStripe]
             n = segments(i * hs - 90.0, (i + 1) * hs - 90.0, hs)//nc
             self.numSCPerChunk.append(n)
             w = 360.0 / (n * nc)
             self.subChunkWidth.append(w)
         self.maxSCPerChunk = max(self.numSCPerChunk)
 

Member Function Documentation

◆ eq()

def lsst.geom.geometry.SphericalBoxPartitionMap.__eq__	(	self,
		other
	)

Definition at line 2429 of file geometry.py.

     def __eq__(self, other):
         if isinstance(other, SphericalBoxPartitionMap):
             return (self.numStripes == other.numStripes and
                     self.numSSPerStripe == other.numSSPerStripe)
         return False
 

◆ iter()

def lsst.geom.geometry.SphericalBoxPartitionMap.__iter__ ( self )

Returns an iterator over (chunkId, SubIterator) tuples - one for
each chunk in the partition map. Each SubIterator is an iterator over
subChunkIds for the corresponding chunk.

Definition at line 2420 of file geometry.py.

     def __iter__(self):
         """Returns an iterator over (chunkId, SubIterator) tuples - one for
         each chunk in the partition map. Each SubIterator is an iterator over
         subChunkIds for the corresponding chunk.
         """
         for s in range(self.numStripes):
             for c in range(self.numChunks[s]):
                 yield (self.getChunkId(s, c), self._allSubChunks(s, False))
 

◆ repr()

def lsst.geom.geometry.SphericalBoxPartitionMap.__repr__ ( self )

Definition at line 2435 of file geometry.py.

     def __repr__(self):
         return ''.join([self.__class__.__name__, '(', repr(self.numStripes),
                         ', ', repr(self.numSSPerStripe), ')'])
 

◆ getChunk()

def lsst.geom.geometry.SphericalBoxPartitionMap.getChunk	(	self,
		stripe,
		theta
	)

Returns the chunk number of the chunk containing all points
in the given stripe with the given longitude angle.

Definition at line 2106 of file geometry.py.

     def getChunk(self, stripe, theta):
         """Returns the chunk number of the chunk containing all points
         in the given stripe with the given longitude angle.
         """
         assert stripe >= 0 and theta >= 0.0 and theta <= 360.0
         ss = stripe * self.numSSPerStripe
         sc = self.getSubChunk(ss, theta)
         return sc//self.numSCPerChunk[ss]
 

◆ getChunkBoundingBox()

def lsst.geom.geometry.SphericalBoxPartitionMap.getChunkBoundingBox	(	self,
		chunkId
	)

Returns a SphericalBox bounding the given chunk. Note that
this is a bounding box only - not an exact representation! In
particular, for a point p and a chunk C with bounding box B,
B.contains(p) == True does not imply that p is assigned to C.
However, for all points p assigned to C, B.contains(p) is True.

Definition at line 2144 of file geometry.py.

     def getChunkBoundingBox(self, chunkId):
         """Returns a SphericalBox bounding the given chunk. Note that
         this is a bounding box only - not an exact representation! In
         particular, for a point p and a chunk C with bounding box B,
         B.contains(p) == True does not imply that p is assigned to C.
         However, for all points p assigned to C, B.contains(p) is True.
         """
         s = chunkId / (self.numStripes * 2)
         c = chunkId - s * self.numStripes * 2
         return self._getChunkBoundingBox(s, c)
 

◆ getChunkId()

def lsst.geom.geometry.SphericalBoxPartitionMap.getChunkId	(	self,
		stripe,
		chunk
	)

Returns the chunk ID of the chunk with the given
stripe/chunk numbers.

Definition at line 2195 of file geometry.py.

     def getChunkId(self, stripe, chunk):
         """Returns the chunk ID of the chunk with the given
         stripe/chunk numbers.
         """
         return stripe * self.numStripes * 2 + chunk
 

◆ getStripe()

def lsst.geom.geometry.SphericalBoxPartitionMap.getStripe	(	self,
		phi
	)

Returns the stripe number of the stripe containing all points
with the given latitude angle.

Definition at line 2087 of file geometry.py.

     def getStripe(self, phi):
         """Returns the stripe number of the stripe containing all points
         with the given latitude angle.
         """
         ss = self.getSubStripe(phi)
         return ss//self.numSSPerStripe
 

◆ getSubChunk()

def lsst.geom.geometry.SphericalBoxPartitionMap.getSubChunk	(	self,
		subStripe,
		theta
	)

Returns the sub-chunk number of the sub-chunk containing all points
in the given sub-stripe with the given longitude angle.

Definition at line 2094 of file geometry.py.

     def getSubChunk(self, subStripe, theta):
         """Returns the sub-chunk number of the sub-chunk containing all points
         in the given sub-stripe with the given longitude angle.
         """
         assert subStripe >= 0 and theta >= 0.0 and theta <= 360.0
         sc = int(math.floor(theta / self.subChunkWidth[subStripe]))
         nsc = (self.numSCPerChunk[subStripe] *
                self.numChunks[subStripe//self.numSSPerStripe])
         if sc >= nsc:
             sc = nsc - 1
         return sc
 

◆ getSubChunkBoundingBox()

def lsst.geom.geometry.SphericalBoxPartitionMap.getSubChunkBoundingBox	(	self,
		chunkId,
		subChunkId
	)

Returns a SphericalBox bounding the given sub-chunk. Note that
this is a bounding box only - not an exact representation! In
particular, for a point p and a sub-chunk SC with bounding box B,
B.contains(p) == True does not imply that p is assigned to SC.
However, for all points p assigned to SC, B.contains(p) is True.

Definition at line 2180 of file geometry.py.

     def getSubChunkBoundingBox(self, chunkId, subChunkId):
         """Returns a SphericalBox bounding the given sub-chunk. Note that
         this is a bounding box only - not an exact representation! In
         particular, for a point p and a sub-chunk SC with bounding box B,
         B.contains(p) == True does not imply that p is assigned to SC.
         However, for all points p assigned to SC, B.contains(p) is True.
         """
         s = chunkId//(self.numStripes * 2)
         c = chunkId - s * self.numStripes * 2
         ssc = subChunkId//self.maxSCPerChunk
         scc = subChunkId - ssc * self.maxSCPerChunk
         ss = s * self.numSSPerStripe + ssc
         sc = c * self.numSCPerChunk[ss] + scc
         return self._getSubChunkBoundingBox(ss, sc)
 

◆ getSubChunkId()

def lsst.geom.geometry.SphericalBoxPartitionMap.getSubChunkId	(	self,
		subStripe,
		subChunk
	)

Returns the sub-chunk ID of the sub-chunk with the given
sub-stripe/sub-chunk numbers.

Definition at line 2201 of file geometry.py.

     def getSubChunkId(self, subStripe, subChunk):
         """Returns the sub-chunk ID of the sub-chunk with the given
         sub-stripe/sub-chunk numbers.
         """
         ss = (subStripe % self.numSSPerStripe) * self.maxSCPerChunk
         sc = (subChunk % self.numSCPerChunk[subStripe])
         return ss + sc
 

◆ getSubStripe()

def lsst.geom.geometry.SphericalBoxPartitionMap.getSubStripe	(	self,
		phi
	)

Returns the sub-stripe number of the sub-stripe containing points
with the given latitude angle.

Definition at line 2077 of file geometry.py.

     def getSubStripe(self, phi):
         """Returns the sub-stripe number of the sub-stripe containing points
         with the given latitude angle.
         """
         assert phi >= -90.0 and phi <= 90.0
         ss = int(math.floor((phi + 90.0) / self.subStripeHeight))
         if ss >= self.numSubStripes:
             ss = self.numSubStripes - 1
         return ss
 

◆ intersect()

def lsst.geom.geometry.SphericalBoxPartitionMap.intersect	(	self,
		args
	)

Computes the intersection of a spherical box partitioning of the
unit sphere and one or more SphericalRegions. Results are
returned as an iterator over (chunkId, SubIterator) tuples. These
correspond to all chunks overlapping at least one input region,
and contain sub-iterators over all sub-chunks intersecting at least
one input region. The sub-iterators return (subChunkId, Regions)
tuples, where Regions is a set of the regions that intersect with
(but do not completely contain) a particular sub-chunk. Note that
Regions can be an empty set - this means that the sub-chunk
is completely contained in at least one of the input regions.

Definition at line 2277 of file geometry.py.

     def intersect(self, *args):
         """Computes the intersection of a spherical box partitioning of the
         unit sphere and one or more SphericalRegions. Results are
         returned as an iterator over (chunkId, SubIterator) tuples. These
         correspond to all chunks overlapping at least one input region,
         and contain sub-iterators over all sub-chunks intersecting at least
         one input region. The sub-iterators return (subChunkId, Regions)
         tuples, where Regions is a set of the regions that intersect with
         (but do not completely contain) a particular sub-chunk. Note that
         Regions can be an empty set - this means that the sub-chunk
         is completely contained in at least one of the input regions.
         """
         if len(args) == 0:
             return
         elif len(args) == 1 and not isinstance(args[0], SphericalRegion):
             # accept arbitrary sequences of SphericalRegion objects
             args = args[0]
         if not all(isinstance(r, SphericalRegion) for r in args):
             raise TypeError(
                 'Input must consist of one or more SphericalRegion objects')
         # Construct list of (bounding box, region) tuples
         regions = []
         for r in args:
             b = r.getBoundingBox()
             if b.wraps():
                 # Split boxes that wrap
                 bMin = (0.0, b.getMin()[1])
                 bMax = (360.0, b.getMax()[1])
                 regions.append((SphericalBox(bMin, b.getMax()), r))
                 # Cannot use SphericalBox constructor: 360.0 would get
                 # range reduced to 0!
                 b2 = SphericalBox()
                 b2.min = b.getMin()
                 b2.max = bMax
                 regions.append((b2, r))
             else:
                 regions.append((b, r))
         # Sort regions by minimum bounding box latitude angle
         regions.sort(key=lambda x: x[0].getMin()[1])
         minS = self.getStripe(
             max(-90.0, regions[0][0].getMin()[1] - ANGLE_EPSILON))
         sOverlap = _SubList(regions)
         sOverlap.append(0)
         # Loop over regions
         for i in range(1, len(regions)):
             s = self.getStripe(
                 max(-90.0, regions[i][0].getMin()[1] - ANGLE_EPSILON))
             if s == minS:
                 sOverlap.append(i)
                 continue
             # All regions overlapping minS have been accumulated
             for x in self._processStripe(minS, s, sOverlap):
                 yield x
             minS = s
             sOverlap.append(i)
         for x in self._processStripe(minS, self.numStripes, sOverlap):
             yield x
 

Member Data Documentation

◆ maxSCPerChunk

lsst.geom.geometry.SphericalBoxPartitionMap.maxSCPerChunk

Definition at line 2075 of file geometry.py.

◆ numChunks

lsst.geom.geometry.SphericalBoxPartitionMap.numChunks

Definition at line 2065 of file geometry.py.

◆ numSCPerChunk

lsst.geom.geometry.SphericalBoxPartitionMap.numSCPerChunk

Definition at line 2067 of file geometry.py.

◆ numSSPerStripe

lsst.geom.geometry.SphericalBoxPartitionMap.numSSPerStripe

Definition at line 2059 of file geometry.py.

◆ numStripes

lsst.geom.geometry.SphericalBoxPartitionMap.numStripes

Definition at line 2058 of file geometry.py.

◆ numSubStripes

lsst.geom.geometry.SphericalBoxPartitionMap.numSubStripes

Definition at line 2060 of file geometry.py.

◆ stripeHeight

lsst.geom.geometry.SphericalBoxPartitionMap.stripeHeight

Definition at line 2063 of file geometry.py.

◆ subChunkWidth

lsst.geom.geometry.SphericalBoxPartitionMap.subChunkWidth

Definition at line 2068 of file geometry.py.

◆ subStripeHeight

lsst.geom.geometry.SphericalBoxPartitionMap.subStripeHeight

Definition at line 2064 of file geometry.py.

The documentation for this class was generated from the following file:

/home/jenkins-slave/snowflake/release/lsstsw/stack/Linux64/geom/15.0+10/python/lsst/geom/geometry.py

Public Member Functions

Public Attributes