sentence1
stringlengths
52
3.87M
sentence2
stringlengths
1
47.2k
label
stringclasses
1 value
def sky_within(self, ra, dec, degin=False): """ Test whether a sky position is within this region Parameters ---------- ra, dec : float Sky position. degin : bool If True the ra/dec is interpreted as degrees, otherwise as radians. Default = False. Returns ------- within : bool True if the given position is within one of the region's pixels. """ sky = self.radec2sky(ra, dec) if degin: sky = np.radians(sky) theta_phi = self.sky2ang(sky) # Set values that are nan to be zero and record a mask mask = np.bitwise_not(np.logical_and.reduce(np.isfinite(theta_phi), axis=1)) theta_phi[mask, :] = 0 theta, phi = theta_phi.transpose() pix = hp.ang2pix(2**self.maxdepth, theta, phi, nest=True) pixelset = self.get_demoted() result = np.in1d(pix, list(pixelset)) # apply the mask and set the shonky values to False result[mask] = False return result
Test whether a sky position is within this region Parameters ---------- ra, dec : float Sky position. degin : bool If True the ra/dec is interpreted as degrees, otherwise as radians. Default = False. Returns ------- within : bool True if the given position is within one of the region's pixels.
entailment
def union(self, other, renorm=True): """ Add another Region by performing union on their pixlists. Parameters ---------- other : :class:`AegeanTools.regions.Region` The region to be combined. renorm : bool Perform renormalisation after the operation? Default = True. """ # merge the pixels that are common to both for d in range(1, min(self.maxdepth, other.maxdepth)+1): self.add_pixels(other.pixeldict[d], d) # if the other region is at higher resolution, then include a degraded version of the remaining pixels. if self.maxdepth < other.maxdepth: for d in range(self.maxdepth+1, other.maxdepth+1): for p in other.pixeldict[d]: # promote this pixel to self.maxdepth pp = p/4**(d-self.maxdepth) self.pixeldict[self.maxdepth].add(pp) if renorm: self._renorm() return
Add another Region by performing union on their pixlists. Parameters ---------- other : :class:`AegeanTools.regions.Region` The region to be combined. renorm : bool Perform renormalisation after the operation? Default = True.
entailment
def without(self, other): """ Subtract another Region by performing a difference operation on their pixlists. Requires both regions to have the same maxdepth. Parameters ---------- other : :class:`AegeanTools.regions.Region` The region to be combined. """ # work only on the lowest level # TODO: Allow this to be done for regions with different depths. if not (self.maxdepth == other.maxdepth): raise AssertionError("Regions must have the same maxdepth") self._demote_all() opd = set(other.get_demoted()) self.pixeldict[self.maxdepth].difference_update(opd) self._renorm() return
Subtract another Region by performing a difference operation on their pixlists. Requires both regions to have the same maxdepth. Parameters ---------- other : :class:`AegeanTools.regions.Region` The region to be combined.
entailment
def intersect(self, other): """ Combine with another Region by performing intersection on their pixlists. Requires both regions to have the same maxdepth. Parameters ---------- other : :class:`AegeanTools.regions.Region` The region to be combined. """ # work only on the lowest level # TODO: Allow this to be done for regions with different depths. if not (self.maxdepth == other.maxdepth): raise AssertionError("Regions must have the same maxdepth") self._demote_all() opd = set(other.get_demoted()) self.pixeldict[self.maxdepth].intersection_update(opd) self._renorm() return
Combine with another Region by performing intersection on their pixlists. Requires both regions to have the same maxdepth. Parameters ---------- other : :class:`AegeanTools.regions.Region` The region to be combined.
entailment
def symmetric_difference(self, other): """ Combine with another Region by performing the symmetric difference of their pixlists. Requires both regions to have the same maxdepth. Parameters ---------- other : :class:`AegeanTools.regions.Region` The region to be combined. """ # work only on the lowest level # TODO: Allow this to be done for regions with different depths. if not (self.maxdepth == other.maxdepth): raise AssertionError("Regions must have the same maxdepth") self._demote_all() opd = set(other.get_demoted()) self.pixeldict[self.maxdepth].symmetric_difference_update(opd) self._renorm() return
Combine with another Region by performing the symmetric difference of their pixlists. Requires both regions to have the same maxdepth. Parameters ---------- other : :class:`AegeanTools.regions.Region` The region to be combined.
entailment
def write_reg(self, filename): """ Write a ds9 region file that represents this region as a set of diamonds. Parameters ---------- filename : str File to write """ with open(filename, 'w') as out: for d in range(1, self.maxdepth+1): for p in self.pixeldict[d]: line = "fk5; polygon(" # the following int() gets around some problems with np.int64 that exist prior to numpy v 1.8.1 vectors = list(zip(*hp.boundaries(2**d, int(p), step=1, nest=True))) positions = [] for sky in self.vec2sky(np.array(vectors), degrees=True): ra, dec = sky pos = SkyCoord(ra/15, dec, unit=(u.degree, u.degree)) positions.append(pos.ra.to_string(sep=':', precision=2)) positions.append(pos.dec.to_string(sep=':', precision=2)) line += ','.join(positions) line += ")" print(line, file=out) return
Write a ds9 region file that represents this region as a set of diamonds. Parameters ---------- filename : str File to write
entailment
def write_fits(self, filename, moctool=''): """ Write a fits file representing the MOC of this region. Parameters ---------- filename : str File to write moctool : str String to be written to fits header with key "MOCTOOL". Default = '' """ datafile = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data', 'MOC.fits') hdulist = fits.open(datafile) cols = fits.Column(name='NPIX', array=self._uniq(), format='1K') tbhdu = fits.BinTableHDU.from_columns([cols]) hdulist[1] = tbhdu hdulist[1].header['PIXTYPE'] = ('HEALPIX ', 'HEALPix magic code') hdulist[1].header['ORDERING'] = ('NUNIQ ', 'NUNIQ coding method') hdulist[1].header['COORDSYS'] = ('C ', 'ICRS reference frame') hdulist[1].header['MOCORDER'] = (self.maxdepth, 'MOC resolution (best order)') hdulist[1].header['MOCTOOL'] = (moctool, 'Name of the MOC generator') hdulist[1].header['MOCTYPE'] = ('CATALOG', 'Source type (IMAGE or CATALOG)') hdulist[1].header['MOCID'] = (' ', 'Identifier of the collection') hdulist[1].header['ORIGIN'] = (' ', 'MOC origin') time = datetime.datetime.utcnow() hdulist[1].header['DATE'] = (datetime.datetime.strftime(time, format="%Y-%m-%dT%H:%m:%SZ"), 'MOC creation date') hdulist.writeto(filename, overwrite=True) return
Write a fits file representing the MOC of this region. Parameters ---------- filename : str File to write moctool : str String to be written to fits header with key "MOCTOOL". Default = ''
entailment
def _uniq(self): """ Create a list of all the pixels that cover this region. This list contains overlapping pixels of different orders. Returns ------- pix : list A list of HEALPix pixel numbers. """ pd = [] for d in range(1, self.maxdepth): pd.extend(map(lambda x: int(4**(d+1) + x), self.pixeldict[d])) return sorted(pd)
Create a list of all the pixels that cover this region. This list contains overlapping pixels of different orders. Returns ------- pix : list A list of HEALPix pixel numbers.
entailment
def radec2sky(ra, dec): """ Convert [ra], [dec] to [(ra[0], dec[0]),....] and also ra,dec to [(ra,dec)] if ra/dec are not iterable Parameters ---------- ra, dec : float or iterable Sky coordinates Returns ------- sky : numpy.array array of (ra,dec) coordinates. """ try: sky = np.array(list(zip(ra, dec))) except TypeError: sky = np.array([(ra, dec)]) return sky
Convert [ra], [dec] to [(ra[0], dec[0]),....] and also ra,dec to [(ra,dec)] if ra/dec are not iterable Parameters ---------- ra, dec : float or iterable Sky coordinates Returns ------- sky : numpy.array array of (ra,dec) coordinates.
entailment
def sky2ang(sky): """ Convert ra,dec coordinates to theta,phi coordinates ra -> phi dec -> theta Parameters ---------- sky : numpy.array Array of (ra,dec) coordinates. See :func:`AegeanTools.regions.Region.radec2sky` Returns ------- theta_phi : numpy.array Array of (theta,phi) coordinates. """ try: theta_phi = sky.copy() except AttributeError as _: theta_phi = np.array(sky) theta_phi[:, [1, 0]] = theta_phi[:, [0, 1]] theta_phi[:, 0] = np.pi/2 - theta_phi[:, 0] # # force 0<=theta<=2pi # theta_phi[:, 0] -= 2*np.pi*(theta_phi[:, 0]//(2*np.pi)) # # and now -pi<=theta<=pi # theta_phi[:, 0] -= (theta_phi[:, 0] > np.pi)*2*np.pi return theta_phi
Convert ra,dec coordinates to theta,phi coordinates ra -> phi dec -> theta Parameters ---------- sky : numpy.array Array of (ra,dec) coordinates. See :func:`AegeanTools.regions.Region.radec2sky` Returns ------- theta_phi : numpy.array Array of (theta,phi) coordinates.
entailment
def sky2vec(cls, sky): """ Convert sky positions in to 3d-vectors on the unit sphere. Parameters ---------- sky : numpy.array Sky coordinates as an array of (ra,dec) Returns ------- vec : numpy.array Unit vectors as an array of (x,y,z) See Also -------- :func:`AegeanTools.regions.Region.vec2sky` """ theta_phi = cls.sky2ang(sky) theta, phi = map(np.array, list(zip(*theta_phi))) vec = hp.ang2vec(theta, phi) return vec
Convert sky positions in to 3d-vectors on the unit sphere. Parameters ---------- sky : numpy.array Sky coordinates as an array of (ra,dec) Returns ------- vec : numpy.array Unit vectors as an array of (x,y,z) See Also -------- :func:`AegeanTools.regions.Region.vec2sky`
entailment
def vec2sky(cls, vec, degrees=False): """ Convert [x,y,z] vectors into sky coordinates ra,dec Parameters ---------- vec : numpy.array Unit vectors as an array of (x,y,z) degrees Returns ------- sky : numpy.array Sky coordinates as an array of (ra,dec) See Also -------- :func:`AegeanTools.regions.Region.sky2vec` """ theta, phi = hp.vec2ang(vec) ra = phi dec = np.pi/2-theta if degrees: ra = np.degrees(ra) dec = np.degrees(dec) return cls.radec2sky(ra, dec)
Convert [x,y,z] vectors into sky coordinates ra,dec Parameters ---------- vec : numpy.array Unit vectors as an array of (x,y,z) degrees Returns ------- sky : numpy.array Sky coordinates as an array of (ra,dec) See Also -------- :func:`AegeanTools.regions.Region.sky2vec`
entailment
def from_header(cls, header, beam=None, lat=None): """ Create a new WCSHelper class from the given header. Parameters ---------- header : `astropy.fits.HDUHeader` or string The header to be used to create the WCS helper beam : :class:`AegeanTools.fits_image.Beam` or None The synthesized beam. If the supplied beam is None then one is constructed form the header. lat : float The latitude of the telescope. Returns ------- obj : :class:`AegeanTools.wcs_helpers.WCSHelper` A helper object. """ try: wcs = pywcs.WCS(header, naxis=2) except: # TODO: figure out what error is being thrown wcs = pywcs.WCS(str(header), naxis=2) if beam is None: beam = get_beam(header) else: beam = beam if beam is None: logging.critical("Cannot determine beam information") _, pixscale = get_pixinfo(header) refpix = (header['CRPIX1'], header['CRPIX2']) return cls(wcs, beam, pixscale, refpix, lat)
Create a new WCSHelper class from the given header. Parameters ---------- header : `astropy.fits.HDUHeader` or string The header to be used to create the WCS helper beam : :class:`AegeanTools.fits_image.Beam` or None The synthesized beam. If the supplied beam is None then one is constructed form the header. lat : float The latitude of the telescope. Returns ------- obj : :class:`AegeanTools.wcs_helpers.WCSHelper` A helper object.
entailment
def from_file(cls, filename, beam=None): """ Create a new WCSHelper class from a given fits file. Parameters ---------- filename : string The file to be read beam : :class:`AegeanTools.fits_image.Beam` or None The synthesized beam. If the supplied beam is None then one is constructed form the header. Returns ------- obj : :class:`AegeanTools.wcs_helpers.WCSHelper` A helper object """ header = fits.getheader(filename) return cls.from_header(header, beam)
Create a new WCSHelper class from a given fits file. Parameters ---------- filename : string The file to be read beam : :class:`AegeanTools.fits_image.Beam` or None The synthesized beam. If the supplied beam is None then one is constructed form the header. Returns ------- obj : :class:`AegeanTools.wcs_helpers.WCSHelper` A helper object
entailment
def pix2sky(self, pixel): """ Convert pixel coordinates into sky coordinates. Parameters ---------- pixel : (float, float) The (x,y) pixel coordinates Returns ------- sky : (float, float) The (ra,dec) sky coordinates in degrees """ x, y = pixel # wcs and pyfits have oposite ideas of x/y return self.wcs.wcs_pix2world([[y, x]], 1)[0]
Convert pixel coordinates into sky coordinates. Parameters ---------- pixel : (float, float) The (x,y) pixel coordinates Returns ------- sky : (float, float) The (ra,dec) sky coordinates in degrees
entailment
def sky2pix(self, pos): """ Convert sky coordinates into pixel coordinates. Parameters ---------- pos : (float, float) The (ra, dec) sky coordinates (degrees) Returns ------- pixel : (float, float) The (x,y) pixel coordinates """ pixel = self.wcs.wcs_world2pix([pos], 1) # wcs and pyfits have oposite ideas of x/y return [pixel[0][1], pixel[0][0]]
Convert sky coordinates into pixel coordinates. Parameters ---------- pos : (float, float) The (ra, dec) sky coordinates (degrees) Returns ------- pixel : (float, float) The (x,y) pixel coordinates
entailment
def sky2pix_vec(self, pos, r, pa): """ Convert a vector from sky to pixel coords. The vector has a magnitude, angle, and an origin on the sky. Parameters ---------- pos : (float, float) The (ra, dec) of the origin of the vector (degrees). r : float The magnitude or length of the vector (degrees). pa : float The position angle of the vector (degrees). Returns ------- x, y : float The pixel coordinates of the origin. r, theta : float The magnitude (pixels) and angle (degrees) of the vector. """ ra, dec = pos x, y = self.sky2pix(pos) a = translate(ra, dec, r, pa) locations = self.sky2pix(a) x_off, y_off = locations a = np.sqrt((x - x_off) ** 2 + (y - y_off) ** 2) theta = np.degrees(np.arctan2((y_off - y), (x_off - x))) return x, y, a, theta
Convert a vector from sky to pixel coords. The vector has a magnitude, angle, and an origin on the sky. Parameters ---------- pos : (float, float) The (ra, dec) of the origin of the vector (degrees). r : float The magnitude or length of the vector (degrees). pa : float The position angle of the vector (degrees). Returns ------- x, y : float The pixel coordinates of the origin. r, theta : float The magnitude (pixels) and angle (degrees) of the vector.
entailment
def pix2sky_vec(self, pixel, r, theta): """ Given and input position and vector in pixel coordinates, calculate the equivalent position and vector in sky coordinates. Parameters ---------- pixel : (int,int) origin of vector in pixel coordinates r : float magnitude of vector in pixels theta : float angle of vector in degrees Returns ------- ra, dec : float The (ra, dec) of the origin point (degrees). r, pa : float The magnitude and position angle of the vector (degrees). """ ra1, dec1 = self.pix2sky(pixel) x, y = pixel a = [x + r * np.cos(np.radians(theta)), y + r * np.sin(np.radians(theta))] locations = self.pix2sky(a) ra2, dec2 = locations a = gcd(ra1, dec1, ra2, dec2) pa = bear(ra1, dec1, ra2, dec2) return ra1, dec1, a, pa
Given and input position and vector in pixel coordinates, calculate the equivalent position and vector in sky coordinates. Parameters ---------- pixel : (int,int) origin of vector in pixel coordinates r : float magnitude of vector in pixels theta : float angle of vector in degrees Returns ------- ra, dec : float The (ra, dec) of the origin point (degrees). r, pa : float The magnitude and position angle of the vector (degrees).
entailment
def sky2pix_ellipse(self, pos, a, b, pa): """ Convert an ellipse from sky to pixel coordinates. Parameters ---------- pos : (float, float) The (ra, dec) of the ellipse center (degrees). a, b, pa: float The semi-major axis, semi-minor axis and position angle of the ellipse (degrees). Returns ------- x,y : float The (x, y) pixel coordinates of the ellipse center. sx, sy : float The major and minor axes (FWHM) in pixels. theta : float The rotation angle of the ellipse (degrees). theta = 0 corresponds to the ellipse being aligned with the x-axis. """ ra, dec = pos x, y = self.sky2pix(pos) x_off, y_off = self.sky2pix(translate(ra, dec, a, pa)) sx = np.hypot((x - x_off), (y - y_off)) theta = np.arctan2((y_off - y), (x_off - x)) x_off, y_off = self.sky2pix(translate(ra, dec, b, pa - 90)) sy = np.hypot((x - x_off), (y - y_off)) theta2 = np.arctan2((y_off - y), (x_off - x)) - np.pi / 2 # The a/b vectors are perpendicular in sky space, but not always in pixel space # so we have to account for this by calculating the angle between the two vectors # and modifying the minor axis length defect = theta - theta2 sy *= abs(np.cos(defect)) return x, y, sx, sy, np.degrees(theta)
Convert an ellipse from sky to pixel coordinates. Parameters ---------- pos : (float, float) The (ra, dec) of the ellipse center (degrees). a, b, pa: float The semi-major axis, semi-minor axis and position angle of the ellipse (degrees). Returns ------- x,y : float The (x, y) pixel coordinates of the ellipse center. sx, sy : float The major and minor axes (FWHM) in pixels. theta : float The rotation angle of the ellipse (degrees). theta = 0 corresponds to the ellipse being aligned with the x-axis.
entailment
def pix2sky_ellipse(self, pixel, sx, sy, theta): """ Convert an ellipse from pixel to sky coordinates. Parameters ---------- pixel : (float, float) The (x, y) coordinates of the center of the ellipse. sx, sy : float The major and minor axes (FHWM) of the ellipse, in pixels. theta : float The rotation angle of the ellipse (degrees). theta = 0 corresponds to the ellipse being aligned with the x-axis. Returns ------- ra, dec : float The (ra, dec) coordinates of the center of the ellipse (degrees). a, b : float The semi-major and semi-minor axis of the ellipse (degrees). pa : float The position angle of the ellipse (degrees). """ ra, dec = self.pix2sky(pixel) x, y = pixel v_sx = [x + sx * np.cos(np.radians(theta)), y + sx * np.sin(np.radians(theta))] ra2, dec2 = self.pix2sky(v_sx) major = gcd(ra, dec, ra2, dec2) pa = bear(ra, dec, ra2, dec2) v_sy = [x + sy * np.cos(np.radians(theta - 90)), y + sy * np.sin(np.radians(theta - 90))] ra2, dec2 = self.pix2sky(v_sy) minor = gcd(ra, dec, ra2, dec2) pa2 = bear(ra, dec, ra2, dec2) - 90 # The a/b vectors are perpendicular in sky space, but not always in pixel space # so we have to account for this by calculating the angle between the two vectors # and modifying the minor axis length defect = pa - pa2 minor *= abs(np.cos(np.radians(defect))) return ra, dec, major, minor, pa
Convert an ellipse from pixel to sky coordinates. Parameters ---------- pixel : (float, float) The (x, y) coordinates of the center of the ellipse. sx, sy : float The major and minor axes (FHWM) of the ellipse, in pixels. theta : float The rotation angle of the ellipse (degrees). theta = 0 corresponds to the ellipse being aligned with the x-axis. Returns ------- ra, dec : float The (ra, dec) coordinates of the center of the ellipse (degrees). a, b : float The semi-major and semi-minor axis of the ellipse (degrees). pa : float The position angle of the ellipse (degrees).
entailment
def get_pixbeam_pixel(self, x, y): """ Determine the beam in pixels at the given location in pixel coordinates. Parameters ---------- x , y : float The pixel coordinates at which the beam is determined. Returns ------- beam : :class:`AegeanTools.fits_image.Beam` A beam object, with a/b/pa in pixel coordinates. """ ra, dec = self.pix2sky((x, y)) return self.get_pixbeam(ra, dec)
Determine the beam in pixels at the given location in pixel coordinates. Parameters ---------- x , y : float The pixel coordinates at which the beam is determined. Returns ------- beam : :class:`AegeanTools.fits_image.Beam` A beam object, with a/b/pa in pixel coordinates.
entailment
def get_beam(self, ra, dec): """ Determine the beam at the given sky location. Parameters ---------- ra, dec : float The sky coordinates at which the beam is determined. Returns ------- beam : :class:`AegeanTools.fits_image.Beam` A beam object, with a/b/pa in sky coordinates """ # check to see if we need to scale the major axis based on the declination if self.lat is None: factor = 1 else: # this works if the pa is zero. For non-zero pa it's a little more difficult factor = np.cos(np.radians(dec - self.lat)) return Beam(self.beam.a / factor, self.beam.b, self.beam.pa)
Determine the beam at the given sky location. Parameters ---------- ra, dec : float The sky coordinates at which the beam is determined. Returns ------- beam : :class:`AegeanTools.fits_image.Beam` A beam object, with a/b/pa in sky coordinates
entailment
def get_pixbeam(self, ra, dec): """ Determine the beam in pixels at the given location in sky coordinates. Parameters ---------- ra , dec : float The sly coordinates at which the beam is determined. Returns ------- beam : :class:`AegeanTools.fits_image.Beam` A beam object, with a/b/pa in pixel coordinates. """ if ra is None: ra, dec = self.pix2sky(self.refpix) pos = [ra, dec] beam = self.get_beam(ra, dec) _, _, major, minor, theta = self.sky2pix_ellipse(pos, beam.a, beam.b, beam.pa) if major < minor: major, minor = minor, major theta -= 90 if theta < -180: theta += 180 if not np.isfinite(theta): theta = 0 if not all(np.isfinite([major, minor, theta])): beam = None else: beam = Beam(major, minor, theta) return beam
Determine the beam in pixels at the given location in sky coordinates. Parameters ---------- ra , dec : float The sly coordinates at which the beam is determined. Returns ------- beam : :class:`AegeanTools.fits_image.Beam` A beam object, with a/b/pa in pixel coordinates.
entailment
def get_beamarea_deg2(self, ra, dec): """ Calculate the area of the synthesized beam in square degrees. Parameters ---------- ra, dec : float The sky coordinates at which the calculation is made. Returns ------- area : float The beam area in square degrees. """ barea = abs(self.beam.a * self.beam.b * np.pi) # in deg**2 at reference coords if self.lat is not None: barea /= np.cos(np.radians(dec - self.lat)) return barea
Calculate the area of the synthesized beam in square degrees. Parameters ---------- ra, dec : float The sky coordinates at which the calculation is made. Returns ------- area : float The beam area in square degrees.
entailment
def get_beamarea_pix(self, ra, dec): """ Calculate the beam area in square pixels. Parameters ---------- ra, dec : float The sky coordinates at which the calculation is made dec Returns ------- area : float The beam area in square pixels. """ parea = abs(self.pixscale[0] * self.pixscale[1]) # in deg**2 at reference coords barea = self.get_beamarea_deg2(ra, dec) return barea / parea
Calculate the beam area in square pixels. Parameters ---------- ra, dec : float The sky coordinates at which the calculation is made dec Returns ------- area : float The beam area in square pixels.
entailment
def sky_sep(self, pix1, pix2): """ calculate the GCD sky separation (degrees) between two pixels. Parameters ---------- pix1, pix2 : (float, float) The (x,y) pixel coordinates for the two positions. Returns ------- dist : float The distance between the two points (degrees). """ pos1 = self.pix2sky(pix1) pos2 = self.pix2sky(pix2) sep = gcd(pos1[0], pos1[1], pos2[0], pos2[1]) return sep
calculate the GCD sky separation (degrees) between two pixels. Parameters ---------- pix1, pix2 : (float, float) The (x,y) pixel coordinates for the two positions. Returns ------- dist : float The distance between the two points (degrees).
entailment
def get_psf_sky(self, ra, dec): """ Determine the local psf at a given sky location. The psf is returned in degrees. Parameters ---------- ra, dec : float The sky position (degrees). Returns ------- a, b, pa : float The psf semi-major axis, semi-minor axis, and position angle in (degrees). If a psf is defined then it is the psf that is returned, otherwise the image restoring beam is returned. """ # If we don't have a psf map then we just fall back to using the beam # from the fits header (including ZA scaling) if self.data is None: beam = self.wcshelper.get_beam(ra, dec) return beam.a, beam.b, beam.pa x, y = self.sky2pix([ra, dec]) # We leave the interpolation in the hands of whoever is making these images # clamping the x,y coords at the image boundaries just makes sense x = int(np.clip(x, 0, self.data.shape[1] - 1)) y = int(np.clip(y, 0, self.data.shape[2] - 1)) psf_sky = self.data[:, x, y] return psf_sky
Determine the local psf at a given sky location. The psf is returned in degrees. Parameters ---------- ra, dec : float The sky position (degrees). Returns ------- a, b, pa : float The psf semi-major axis, semi-minor axis, and position angle in (degrees). If a psf is defined then it is the psf that is returned, otherwise the image restoring beam is returned.
entailment
def get_psf_pix(self, ra, dec): """ Determine the local psf (a,b,pa) at a given sky location. The psf is in pixel coordinates. Parameters ---------- ra, dec : float The sky position (degrees). Returns ------- a, b, pa : float The psf semi-major axis (pixels), semi-minor axis (pixels), and rotation angle (degrees). If a psf is defined then it is the psf that is returned, otherwise the image restoring beam is returned. """ psf_sky = self.get_psf_sky(ra, dec) psf_pix = self.wcshelper.sky2pix_ellipse([ra, dec], psf_sky[0], psf_sky[1], psf_sky[2])[2:] return psf_pix
Determine the local psf (a,b,pa) at a given sky location. The psf is in pixel coordinates. Parameters ---------- ra, dec : float The sky position (degrees). Returns ------- a, b, pa : float The psf semi-major axis (pixels), semi-minor axis (pixels), and rotation angle (degrees). If a psf is defined then it is the psf that is returned, otherwise the image restoring beam is returned.
entailment
def get_pixbeam(self, ra, dec): """ Get the psf at the location specified in pixel coordinates. The psf is also in pixel coordinates. Parameters ---------- ra, dec : float The sky position (degrees). Returns ------- a, b, pa : float The psf semi-major axis (pixels), semi-minor axis (pixels), and rotation angle (degrees). If a psf is defined then it is the psf that is returned, otherwise the image restoring beam is returned. """ # If there is no psf image then just use the fits header (plus lat scaling) from the wcshelper if self.data is None: return self.wcshelper.get_pixbeam(ra, dec) # get the beam from the psf image data psf = self.get_psf_pix(ra, dec) if not np.all(np.isfinite(psf)): log.warn("PSF requested, returned Null") return None return Beam(psf[0], psf[1], psf[2])
Get the psf at the location specified in pixel coordinates. The psf is also in pixel coordinates. Parameters ---------- ra, dec : float The sky position (degrees). Returns ------- a, b, pa : float The psf semi-major axis (pixels), semi-minor axis (pixels), and rotation angle (degrees). If a psf is defined then it is the psf that is returned, otherwise the image restoring beam is returned.
entailment
def get_beam(self, ra, dec): """ Get the psf as a :class:`AegeanTools.fits_image.Beam` object. Parameters ---------- ra, dec : float The sky position (degrees). Returns ------- beam : :class:`AegeanTools.fits_image.Beam` The psf at the given location. """ if self.data is None: return self.wcshelper.beam else: psf = self.get_psf_sky(ra, dec) if not all(np.isfinite(psf)): return None return Beam(psf[0], psf[1], psf[2])
Get the psf as a :class:`AegeanTools.fits_image.Beam` object. Parameters ---------- ra, dec : float The sky position (degrees). Returns ------- beam : :class:`AegeanTools.fits_image.Beam` The psf at the given location.
entailment
def get_beamarea_pix(self, ra, dec): """ Calculate the area of the beam in square pixels. Parameters ---------- ra, dec : float The sky position (degrees). Returns ------- area : float The area of the beam in square pixels. """ beam = self.get_pixbeam(ra, dec) if beam is None: return 0 return beam.a * beam.b * np.pi
Calculate the area of the beam in square pixels. Parameters ---------- ra, dec : float The sky position (degrees). Returns ------- area : float The area of the beam in square pixels.
entailment
def get_beamarea_deg2(self, ra, dec): """ Calculate the area of the beam in square degrees. Parameters ---------- ra, dec : float The sky position (degrees). Returns ------- area : float The area of the beam in square degrees. """ beam = self.get_beam(ra, dec) if beam is None: return 0 return beam.a * beam.b * np.pi
Calculate the area of the beam in square degrees. Parameters ---------- ra, dec : float The sky position (degrees). Returns ------- area : float The area of the beam in square degrees.
entailment
def find_start_point(self): """ Find the first location in our array that is not empty """ for i, row in enumerate(self.data): for j, _ in enumerate(row): if self.data[i, j] != 0: # or not np.isfinite(self.data[i,j]): return i, j
Find the first location in our array that is not empty
entailment
def step(self, x, y): """ Move from the current location to the next Parameters ---------- x, y : int The current location """ up_left = self.solid(x - 1, y - 1) up_right = self.solid(x, y - 1) down_left = self.solid(x - 1, y) down_right = self.solid(x, y) state = 0 self.prev = self.next # which cells are filled? if up_left: state |= 1 if up_right: state |= 2 if down_left: state |= 4 if down_right: state |= 8 # what is the next step? if state in [1, 5, 13]: self.next = self.UP elif state in [2, 3, 7]: self.next = self.RIGHT elif state in [4, 12, 14]: self.next = self.LEFT elif state in [8, 10, 11]: self.next = self.DOWN elif state == 6: if self.prev == self.UP: self.next = self.LEFT else: self.next = self.RIGHT elif state == 9: if self.prev == self.RIGHT: self.next = self.UP else: self.next = self.DOWN else: self.next = self.NOWHERE return
Move from the current location to the next Parameters ---------- x, y : int The current location
entailment
def solid(self, x, y): """ Determine whether the pixel x,y is nonzero Parameters ---------- x, y : int The pixel of interest. Returns ------- solid : bool True if the pixel is not zero. """ if not(0 <= x < self.xsize) or not(0 <= y < self.ysize): return False if self.data[x, y] == 0: return False return True
Determine whether the pixel x,y is nonzero Parameters ---------- x, y : int The pixel of interest. Returns ------- solid : bool True if the pixel is not zero.
entailment
def walk_perimeter(self, startx, starty): """ Starting at a point on the perimeter of a region, 'walk' the perimeter to return to the starting point. Record the path taken. Parameters ---------- startx, starty : int The starting location. Assumed to be on the perimeter of a region. Returns ------- perimeter : list A list of pixel coordinates [ [x1,y1], ...] that constitute the perimeter of the region. """ # checks startx = max(startx, 0) startx = min(startx, self.xsize) starty = max(starty, 0) starty = min(starty, self.ysize) points = [] x, y = startx, starty while True: self.step(x, y) if 0 <= x <= self.xsize and 0 <= y <= self.ysize: points.append((x, y)) if self.next == self.UP: y -= 1 elif self.next == self.LEFT: x -= 1 elif self.next == self.DOWN: y += 1 elif self.next == self.RIGHT: x += 1 # stop if we meet some kind of error elif self.next == self.NOWHERE: break # stop when we return to the starting location if x == startx and y == starty: break return points
Starting at a point on the perimeter of a region, 'walk' the perimeter to return to the starting point. Record the path taken. Parameters ---------- startx, starty : int The starting location. Assumed to be on the perimeter of a region. Returns ------- perimeter : list A list of pixel coordinates [ [x1,y1], ...] that constitute the perimeter of the region.
entailment
def do_march(self): """ March about and trace the outline of our object Returns ------- perimeter : list The pixels on the perimeter of the region [[x1, y1], ...] """ x, y = self.find_start_point() perimeter = self.walk_perimeter(x, y) return perimeter
March about and trace the outline of our object Returns ------- perimeter : list The pixels on the perimeter of the region [[x1, y1], ...]
entailment
def _blank_within(self, perimeter): """ Blank all the pixels within the given perimeter. Parameters ---------- perimeter : list The perimeter of the region. """ # Method: # scan around the perimeter filling 'up' from each pixel # stopping when we reach the other boundary for p in perimeter: # if we are on the edge of the data then there is nothing to fill if p[0] >= self.data.shape[0] or p[1] >= self.data.shape[1]: continue # if this pixel is blank then don't fill if self.data[p] == 0: continue # blank this pixel self.data[p] = 0 # blank until we reach the other perimeter for i in range(p[1]+1, self.data.shape[1]): q = p[0], i # stop when we reach another part of the perimeter if q in perimeter: break # fill everything in between, even inclusions self.data[q] = 0 return
Blank all the pixels within the given perimeter. Parameters ---------- perimeter : list The perimeter of the region.
entailment
def do_march_all(self): """ Recursive march in the case that we have a fragmented shape. Returns ------- perimeters : [perimeter1, ...] The perimeters of all the regions in the image. See Also -------- :func:`AegeanTools.msq2.MarchingSquares.do_march` """ # copy the data since we are going to be modifying it data_copy = copy(self.data) # iterate through finding an island, creating a perimeter, # and then blanking the island perimeters = [] p = self.find_start_point() while p is not None: x, y = p perim = self.walk_perimeter(x, y) perimeters.append(perim) self._blank_within(perim) p = self.find_start_point() # restore the data self.data = data_copy return perimeters
Recursive march in the case that we have a fragmented shape. Returns ------- perimeters : [perimeter1, ...] The perimeters of all the regions in the image. See Also -------- :func:`AegeanTools.msq2.MarchingSquares.do_march`
entailment
def elliptical_gaussian(x, y, amp, xo, yo, sx, sy, theta): """ Generate a model 2d Gaussian with the given parameters. Evaluate this model at the given locations x,y. Parameters ---------- x, y : numeric or array-like locations at which to evaluate the gaussian amp : float Peak value. xo, yo : float Center of the gaussian. sx, sy : float major/minor axes in sigmas theta : float position angle (degrees) CCW from x-axis Returns ------- data : numeric or array-like Gaussian function evaluated at the x,y locations. """ try: sint, cost = math.sin(np.radians(theta)), math.cos(np.radians(theta)) except ValueError as e: if 'math domain error' in e.args: sint, cost = np.nan, np.nan xxo = x - xo yyo = y - yo exp = (xxo * cost + yyo * sint) ** 2 / sx ** 2 \ + (xxo * sint - yyo * cost) ** 2 / sy ** 2 exp *= -1. / 2 return amp * np.exp(exp)
Generate a model 2d Gaussian with the given parameters. Evaluate this model at the given locations x,y. Parameters ---------- x, y : numeric or array-like locations at which to evaluate the gaussian amp : float Peak value. xo, yo : float Center of the gaussian. sx, sy : float major/minor axes in sigmas theta : float position angle (degrees) CCW from x-axis Returns ------- data : numeric or array-like Gaussian function evaluated at the x,y locations.
entailment
def Cmatrix(x, y, sx, sy, theta): """ Construct a correlation matrix corresponding to the data. The matrix assumes a gaussian correlation function. Parameters ---------- x, y : array-like locations at which to evaluate the correlation matirx sx, sy : float major/minor axes of the gaussian correlation function (sigmas) theta : float position angle of the gaussian correlation function (degrees) Returns ------- data : array-like The C-matrix. """ C = np.vstack([elliptical_gaussian(x, y, 1, i, j, sx, sy, theta) for i, j in zip(x, y)]) return C
Construct a correlation matrix corresponding to the data. The matrix assumes a gaussian correlation function. Parameters ---------- x, y : array-like locations at which to evaluate the correlation matirx sx, sy : float major/minor axes of the gaussian correlation function (sigmas) theta : float position angle of the gaussian correlation function (degrees) Returns ------- data : array-like The C-matrix.
entailment
def Bmatrix(C): """ Calculate a matrix which is effectively the square root of the correlation matrix C Parameters ---------- C : 2d array A covariance matrix Returns ------- B : 2d array A matrix B such the B.dot(B') = inv(C) """ # this version of finding the square root of the inverse matrix # suggested by Cath Trott L, Q = eigh(C) # force very small eigenvalues to have some minimum non-zero value minL = 1e-9*L[-1] L[L < minL] = minL S = np.diag(1 / np.sqrt(L)) B = Q.dot(S) return B
Calculate a matrix which is effectively the square root of the correlation matrix C Parameters ---------- C : 2d array A covariance matrix Returns ------- B : 2d array A matrix B such the B.dot(B') = inv(C)
entailment
def jacobian(pars, x, y): """ Analytical calculation of the Jacobian for an elliptical gaussian Will work for a model that contains multiple Gaussians, and for which some components are not being fit (don't vary). Parameters ---------- pars : lmfit.Model The model parameters x, y : list Locations at which the jacobian is being evaluated Returns ------- j : 2d array The Jacobian. See Also -------- :func:`AegeanTools.fitting.emp_jacobian` """ matrix = [] for i in range(pars['components'].value): prefix = "c{0}_".format(i) amp = pars[prefix + 'amp'].value xo = pars[prefix + 'xo'].value yo = pars[prefix + 'yo'].value sx = pars[prefix + 'sx'].value sy = pars[prefix + 'sy'].value theta = pars[prefix + 'theta'].value # The derivative with respect to component i doesn't depend on any other components # thus the model should not contain the other components model = elliptical_gaussian(x, y, amp, xo, yo, sx, sy, theta) # precompute for speed sint = np.sin(np.radians(theta)) cost = np.cos(np.radians(theta)) xxo = x - xo yyo = y - yo xcos, ycos = xxo * cost, yyo * cost xsin, ysin = xxo * sint, yyo * sint if pars[prefix + 'amp'].vary: dmds = model / amp matrix.append(dmds) if pars[prefix + 'xo'].vary: dmdxo = cost * (xcos + ysin) / sx ** 2 + sint * (xsin - ycos) / sy ** 2 dmdxo *= model matrix.append(dmdxo) if pars[prefix + 'yo'].vary: dmdyo = sint * (xcos + ysin) / sx ** 2 - cost * (xsin - ycos) / sy ** 2 dmdyo *= model matrix.append(dmdyo) if pars[prefix + 'sx'].vary: dmdsx = model / sx ** 3 * (xcos + ysin) ** 2 matrix.append(dmdsx) if pars[prefix + 'sy'].vary: dmdsy = model / sy ** 3 * (xsin - ycos) ** 2 matrix.append(dmdsy) if pars[prefix + 'theta'].vary: dmdtheta = model * (sy ** 2 - sx ** 2) * (xsin - ycos) * (xcos + ysin) / sx ** 2 / sy ** 2 matrix.append(dmdtheta) return np.array(matrix)
Analytical calculation of the Jacobian for an elliptical gaussian Will work for a model that contains multiple Gaussians, and for which some components are not being fit (don't vary). Parameters ---------- pars : lmfit.Model The model parameters x, y : list Locations at which the jacobian is being evaluated Returns ------- j : 2d array The Jacobian. See Also -------- :func:`AegeanTools.fitting.emp_jacobian`
entailment
def lmfit_jacobian(pars, x, y, errs=None, B=None, emp=False): """ Wrapper around :func:`AegeanTools.fitting.jacobian` and :func:`AegeanTools.fitting.emp_jacobian` which gives the output in a format that is required for lmfit. Parameters ---------- pars : lmfit.Model The model parameters x, y : list Locations at which the jacobian is being evaluated errs : list a vector of 1\sigma errors (optional). Default = None B : 2d-array a B-matrix (optional) see :func:`AegeanTools.fitting.Bmatrix` emp : bool If true the use the empirical Jacobian, otherwise use the analytical one. Default = False. Returns ------- j : 2d-array A Jacobian. See Also -------- :func:`AegeanTools.fitting.Bmatrix` :func:`AegeanTools.fitting.jacobian` :func:`AegeanTools.fitting.emp_jacobian` """ if emp: matrix = emp_jacobian(pars, x, y) else: # calculate in the normal way matrix = jacobian(pars, x, y) # now munge this to be as expected for lmfit matrix = np.vstack(matrix) if errs is not None: matrix /= errs # matrix = matrix.dot(errs) if B is not None: matrix = matrix.dot(B) matrix = np.transpose(matrix) return matrix
Wrapper around :func:`AegeanTools.fitting.jacobian` and :func:`AegeanTools.fitting.emp_jacobian` which gives the output in a format that is required for lmfit. Parameters ---------- pars : lmfit.Model The model parameters x, y : list Locations at which the jacobian is being evaluated errs : list a vector of 1\sigma errors (optional). Default = None B : 2d-array a B-matrix (optional) see :func:`AegeanTools.fitting.Bmatrix` emp : bool If true the use the empirical Jacobian, otherwise use the analytical one. Default = False. Returns ------- j : 2d-array A Jacobian. See Also -------- :func:`AegeanTools.fitting.Bmatrix` :func:`AegeanTools.fitting.jacobian` :func:`AegeanTools.fitting.emp_jacobian`
entailment
def hessian(pars, x, y): """ Create a hessian matrix corresponding to the source model 'pars' Only parameters that vary will contribute to the hessian. Thus there will be a total of nvar x nvar entries, each of which is a len(x) x len(y) array. Parameters ---------- pars : lmfit.Parameters The model x, y : list locations at which to evaluate the Hessian Returns ------- h : np.array Hessian. Shape will be (nvar, nvar, len(x), len(y)) See Also -------- :func:`AegeanTools.fitting.emp_hessian` """ j = 0 # keeping track of the number of variable parameters # total number of variable parameters ntvar = np.sum([pars[k].vary for k in pars.keys() if k != 'components']) # construct an empty matrix of the correct size hmat = np.zeros((ntvar, ntvar, x.shape[0], x.shape[1])) npvar = 0 for i in range(pars['components'].value): prefix = "c{0}_".format(i) amp = pars[prefix + 'amp'].value xo = pars[prefix + 'xo'].value yo = pars[prefix + 'yo'].value sx = pars[prefix + 'sx'].value sy = pars[prefix + 'sy'].value theta = pars[prefix + 'theta'].value amp_var = pars[prefix + 'amp'].vary xo_var = pars[prefix + 'xo'].vary yo_var = pars[prefix + 'yo'].vary sx_var = pars[prefix + 'sx'].vary sy_var = pars[prefix + 'sy'].vary theta_var = pars[prefix + 'theta'].vary # precomputed for speed model = elliptical_gaussian(x, y, amp, xo, yo, sx, sy, theta) sint = np.sin(np.radians(theta)) sin2t = np.sin(np.radians(2*theta)) cost = np.cos(np.radians(theta)) cos2t = np.cos(np.radians(2*theta)) sx2 = sx**2 sy2 = sy**2 xxo = x-xo yyo = y-yo xcos, ycos = xxo*cost, yyo*cost xsin, ysin = xxo*sint, yyo*sint if amp_var: k = npvar # second round of keeping track of variable params # H(amp,amp)/G = 0 hmat[j][k] = 0 k += 1 if xo_var: # H(amp,xo)/G = 1.0*(sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*sin(t) + sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*cos(t))/(amp*sx**2*sy**2) hmat[j][k] = (xsin - ycos)*sint/sy2 + (xcos + ysin)*cost/sx2 hmat[j][k] *= model k += 1 if yo_var: # H(amp,yo)/G = 1.0*(-sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*cos(t) + sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*sin(t))/(amp*sx**2*sy**2) hmat[j][k] = -(xsin - ycos)*cost/sy2 + (xcos + ysin)*sint/sx2 hmat[j][k] *= model/amp k += 1 if sx_var: # H(amp,sx)/G = 1.0*((x - xo)*cos(t) + (y - yo)*sin(t))**2/(amp*sx**3) hmat[j][k] = (xcos + ysin)**2 hmat[j][k] *= model/(amp*sx**3) k += 1 if sy_var: # H(amp,sy) = 1.0*((x - xo)*sin(t) + (-y + yo)*cos(t))**2/(amp*sy**3) hmat[j][k] = (xsin - ycos)**2 hmat[j][k] *= model/(amp*sy**3) k += 1 if theta_var: # H(amp,t) = (-1.0*sx**2 + sy**2)*((x - xo)*sin(t) + (-y + yo)*cos(t))*((x - xo)*cos(t) + (y - yo)*sin(t))/(amp*sx**2*sy**2) hmat[j][k] = (xsin - ycos)*(xcos + ysin) hmat[j][k] *= sy2-sx2 hmat[j][k] *= model/(amp*sx2*sy2) # k += 1 j += 1 if xo_var: k = npvar if amp_var: # H(xo,amp)/G = H(amp,xo) hmat[j][k] = hmat[k][j] k += 1 # if xo_var: # H(xo,xo)/G = 1.0*(-sx**2*sy**2*(sx**2*sin(t)**2 + sy**2*cos(t)**2) + (sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*sin(t) + sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*cos(t))**2)/(sx**4*sy**4) hmat[j][k] = -sx2*sy2*(sx2*sint**2 + sy2*cost**2) hmat[j][k] += (sx2*(xsin - ycos)*sint + sy2*(xcos + ysin)*cost)**2 hmat[j][k] *= model/ (sx2**2*sy2**2) k += 1 if yo_var: # H(xo,yo)/G = 1.0*(sx**2*sy**2*(sx**2 - sy**2)*sin(2*t)/2 - (sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*sin(t) + sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*cos(t))*(sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*cos(t) - sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*sin(t)))/(sx**4*sy**4) hmat[j][k] = sx2*sy2*(sx2 - sy2)*sin2t/2 hmat[j][k] -= (sx2*(xsin - ycos)*sint + sy2*(xcos + ysin)*cost)*(sx2*(xsin -ycos)*cost - sy2*(xcos + ysin)*sint) hmat[j][k] *= model / (sx**4*sy**4) k += 1 if sx_var: # H(xo,sx) = ((x - xo)*cos(t) + (y - yo)*sin(t))*(-2.0*sx**2*sy**2*cos(t) + 1.0*((x - xo)*cos(t) + (y - yo)*sin(t))*(sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*sin(t) + sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*cos(t)))/(sx**5*sy**2) hmat[j][k] = (xcos + ysin) hmat[j][k] *= -2*sx2*sy2*cost + (xcos + ysin)*(sx2*(xsin - ycos)*sint + sy2*(xcos + ysin)*cost) hmat[j][k] *= model / (sx**5*sy2) k += 1 if sy_var: # H(xo,sy) = ((x - xo)*sin(t) + (-y + yo)*cos(t))*(-2.0*sx**2*sy**2*sin(t) + 1.0*((x - xo)*sin(t) + (-y + yo)*cos(t))*(sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*sin(t) + sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*cos(t)))/(sx2*sy**5) hmat[j][k] = (xsin - ycos) hmat[j][k] *= -2*sx2*sy2*sint + (xsin - ycos)*(sx2*(xsin - ycos)*sint + sy2*(xcos + ysin)*cost) hmat[j][k] *= model/(sx2*sy**5) k += 1 if theta_var: # H(xo,t) = 1.0*(sx**2*sy**2*(sx**2 - sy**2)*(x*sin(2*t) - xo*sin(2*t) - y*cos(2*t) + yo*cos(2*t)) + (-sx**2 + 1.0*sy**2)*((x - xo)*sin(t) + (-y + yo)*cos(t))*((x - xo)*cos(t) + (y - yo)*sin(t))*(sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*sin(t) + sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*cos(t)))/(sx**4*sy**4) # second part hmat[j][k] = (sy2-sx2)*(xsin - ycos)*(xcos + ysin) hmat[j][k] *= sx2*(xsin -ycos)*sint + sy2*(xcos + ysin)*cost # first part hmat[j][k] += sx2*sy2*(sx2 - sy2)*(xxo*sin2t -yyo*cos2t) hmat[j][k] *= model/(sx**4*sy**4) # k += 1 j += 1 if yo_var: k = npvar if amp_var: # H(yo,amp)/G = H(amp,yo) hmat[j][k] = hmat[0][2] k += 1 if xo_var: # H(yo,xo)/G = H(xo,yo)/G hmat[j][k] =hmat[1][2] k += 1 # if yo_var: # H(yo,yo)/G = 1.0*(-sx**2*sy**2*(sx**2*cos(t)**2 + sy**2*sin(t)**2) + (sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*cos(t) - sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*sin(t))**2)/(sx**4*sy**4) hmat[j][k] = (sx2*(xsin - ycos)*cost - sy2*(xcos + ysin)*sint)**2 / (sx2**2*sy2**2) hmat[j][k] -= cost**2/sy2 + sint**2/sx2 hmat[j][k] *= model k += 1 if sx_var: # H(yo,sx)/G = -((x - xo)*cos(t) + (y - yo)*sin(t))*(2.0*sx**2*sy**2*sin(t) + 1.0*((x - xo)*cos(t) + (y - yo)*sin(t))*(sx**2*((x - xo)*sin(t) - (y - yo)*cos(t))*cos(t) - sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*sin(t)))/(sx**5*sy**2) hmat[j][k] = -1*(xcos + ysin) hmat[j][k] *= 2*sx2*sy2*sint + (xcos + ysin)*(sx2*(xsin - ycos)*cost - sy2*(xcos + ysin)*sint) hmat[j][k] *= model/(sx**5*sy2) k += 1 if sy_var: # H(yo,sy)/G = ((x - xo)*sin(t) + (-y + yo)*cos(t))*(2.0*sx**2*sy**2*cos(t) - 1.0*((x - xo)*sin(t) + (-y + yo)*cos(t))*(sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*cos(t) - sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*sin(t)))/(sx**2*sy**5) hmat[j][k] = (xsin -ycos) hmat[j][k] *= 2*sx2*sy2*cost - (xsin - ycos)*(sx2*(xsin - ycos)*cost - sy2*(xcos + ysin)*sint) hmat[j][k] *= model/(sx2*sy**5) k += 1 if theta_var: # H(yo,t)/G = 1.0*(sx**2*sy**2*(sx**2*(-x*cos(2*t) + xo*cos(2*t) - y*sin(2*t) + yo*sin(2*t)) + sy**2*(x*cos(2*t) - xo*cos(2*t) + y*sin(2*t) - yo*sin(2*t))) + (1.0*sx**2 - sy**2)*((x - xo)*sin(t) + (-y + yo)*cos(t))*((x - xo)*cos(t) + (y - yo)*sin(t))*(sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*cos(t) - sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*sin(t)))/(sx**4*sy**4) hmat[j][k] = (sx2 - sy2)*(xsin - ycos)*(xcos + ysin) hmat[j][k] *= (sx2*(xsin - ycos)*cost - sy2*(xcos + ysin)*sint) hmat[j][k] += sx2*sy2*(sx2-sy2)*(-x*cos2t + xo*cos2t - y*sin2t + yo*sin2t) hmat[j][k] *= model/(sx**4*sy**4) # k += 1 j += 1 if sx_var: k = npvar if amp_var: # H(sx,amp)/G = H(amp,sx)/G hmat[j][k] = hmat[k][j] k += 1 if xo_var: # H(sx,xo)/G = H(xo,sx)/G hmat[j][k] = hmat[k][j] k += 1 if yo_var: # H(sx,yo)/G = H(yo/sx)/G hmat[j][k] = hmat[k][j] k += 1 # if sx_var: # H(sx,sx)/G = (-3.0*sx**2 + 1.0*((x - xo)*cos(t) + (y - yo)*sin(t))**2)*((x - xo)*cos(t) + (y - yo)*sin(t))**2/sx**6 hmat[j][k] = -3*sx2 + (xcos + ysin)**2 hmat[j][k] *= (xcos + ysin)**2 hmat[j][k] *= model/sx**6 k += 1 if sy_var: # H(sx,sy)/G = 1.0*((x - xo)*sin(t) + (-y + yo)*cos(t))**2*((x - xo)*cos(t) + (y - yo)*sin(t))**2/(sx**3*sy**3) hmat[j][k] = (xsin - ycos)**2 * (xcos + ysin)**2 hmat[j][k] *= model/(sx**3*sy**3) k += 1 if theta_var: # H(sx,t)/G = (-2.0*sx**2*sy**2 + 1.0*(-sx**2 + sy**2)*((x - xo)*cos(t) + (y - yo)*sin(t))**2)*((x - xo)*sin(t) + (-y + yo)*cos(t))*((x - xo)*cos(t) + (y - yo)*sin(t))/(sx**5*sy**2) hmat[j][k] = -2*sx2*sy2 + (sy2 - sx2)*(xcos + ysin)**2 hmat[j][k] *= (xsin -ycos)*(xcos + ysin) hmat[j][k] *= model/(sx**5*sy**2) # k += 1 j += 1 if sy_var: k = npvar if amp_var: # H(sy,amp)/G = H(amp,sy)/G hmat[j][k] = hmat[k][j] k += 1 if xo_var: # H(sy,xo)/G = H(xo,sy)/G hmat[j][k] = hmat[k][j] k += 1 if yo_var: # H(sy,yo)/G = H(yo/sy)/G hmat[j][k] = hmat[k][j] k += 1 if sx_var: # H(sy,sx)/G = H(sx,sy)/G hmat[j][k] = hmat[k][j] k += 1 # if sy_var: # H(sy,sy)/G = (-3.0*sy**2 + 1.0*((x - xo)*sin(t) + (-y + yo)*cos(t))**2)*((x - xo)*sin(t) + (-y + yo)*cos(t))**2/sy**6 hmat[j][k] = -3*sy2 + (xsin - ycos)**2 hmat[j][k] *= (xsin - ycos)**2 hmat[j][k] *= model/sy**6 k += 1 if theta_var: # H(sy,t)/G = (2.0*sx**2*sy**2 + 1.0*(-sx**2 + sy**2)*((x - xo)*sin(t) + (-y + yo)*cos(t))**2)*((x - xo)*sin(t) + (-y + yo)*cos(t))*((x - xo)*cos(t) + (y - yo)*sin(t))/(sx**2*sy**5) hmat[j][k] = 2*sx2*sy2 + (sy2 - sx2)*(xsin - ycos)**2 hmat[j][k] *= (xsin - ycos)*(xcos + ysin) hmat[j][k] *= model/(sx**2*sy**5) # k += 1 j += 1 if theta_var: k = npvar if amp_var: # H(t,amp)/G = H(amp,t)/G hmat[j][k] = hmat[k][j] k += 1 if xo_var: # H(t,xo)/G = H(xo,t)/G hmat[j][k] = hmat[k][j] k += 1 if yo_var: # H(t,yo)/G = H(yo/t)/G hmat[j][k] = hmat[k][j] k += 1 if sx_var: # H(t,sx)/G = H(sx,t)/G hmat[j][k] = hmat[k][j] k += 1 if sy_var: # H(t,sy)/G = H(sy,t)/G hmat[j][k] = hmat[k][j] k += 1 # if theta_var: # H(t,t)/G = (sx**2*sy**2*(sx**2*(((x - xo)*sin(t) + (-y + yo)*cos(t))**2 - 1.0*((x - xo)*cos(t) + (y - yo)*sin(t))**2) + sy**2*(-1.0*((x - xo)*sin(t) + (-y + yo)*cos(t))**2 + ((x - xo)*cos(t) + (y - yo)*sin(t))**2)) + (sx**2 - 1.0*sy**2)**2*((x - xo)*sin(t) + (-y + yo)*cos(t))**2*((x - xo)*cos(t) + (y - yo)*sin(t))**2)/(sx**4*sy**4) hmat[j][k] = sx2*sy2 hmat[j][k] *= sx2*((xsin - ycos)**2 - (xcos + ysin)**2) + sy2*((xcos + ysin)**2 - (xsin - ycos)**2) hmat[j][k] += (sx2 - sy2)**2*(xsin - ycos)**2*(xcos + ysin)**2 hmat[j][k] *= model/(sx**4*sy**4) # j += 1 # save the number of variables for the next iteration # as we need to start our indexing at this number npvar = k return np.array(hmat)
Create a hessian matrix corresponding to the source model 'pars' Only parameters that vary will contribute to the hessian. Thus there will be a total of nvar x nvar entries, each of which is a len(x) x len(y) array. Parameters ---------- pars : lmfit.Parameters The model x, y : list locations at which to evaluate the Hessian Returns ------- h : np.array Hessian. Shape will be (nvar, nvar, len(x), len(y)) See Also -------- :func:`AegeanTools.fitting.emp_hessian`
entailment
def emp_hessian(pars, x, y): """ Calculate the hessian matrix empirically. Create a hessian matrix corresponding to the source model 'pars' Only parameters that vary will contribute to the hessian. Thus there will be a total of nvar x nvar entries, each of which is a len(x) x len(y) array. Parameters ---------- pars : lmfit.Parameters The model x, y : list locations at which to evaluate the Hessian Returns ------- h : np.array Hessian. Shape will be (nvar, nvar, len(x), len(y)) Notes ----- Uses :func:`AegeanTools.fitting.emp_jacobian` to calculate the first order derivatives. See Also -------- :func:`AegeanTools.fitting.hessian` """ eps = 1e-5 matrix = [] for i in range(pars['components'].value): model = emp_jacobian(pars, x, y) prefix = "c{0}_".format(i) for p in ['amp', 'xo', 'yo', 'sx', 'sy', 'theta']: if pars[prefix+p].vary: pars[prefix+p].value += eps dm2didj = emp_jacobian(pars, x, y) - model matrix.append(dm2didj/eps) pars[prefix+p].value -= eps matrix = np.array(matrix) return matrix
Calculate the hessian matrix empirically. Create a hessian matrix corresponding to the source model 'pars' Only parameters that vary will contribute to the hessian. Thus there will be a total of nvar x nvar entries, each of which is a len(x) x len(y) array. Parameters ---------- pars : lmfit.Parameters The model x, y : list locations at which to evaluate the Hessian Returns ------- h : np.array Hessian. Shape will be (nvar, nvar, len(x), len(y)) Notes ----- Uses :func:`AegeanTools.fitting.emp_jacobian` to calculate the first order derivatives. See Also -------- :func:`AegeanTools.fitting.hessian`
entailment
def nan_acf(noise): """ Calculate the autocorrelation function of the noise where the noise is a 2d array that may contain nans Parameters ---------- noise : 2d-array Noise image. Returns ------- acf : 2d-array The ACF. """ corr = np.zeros(noise.shape) ix,jx = noise.shape for i in range(ix): si_min = slice(i, None, None) si_max = slice(None, ix-i, None) for j in range(jx): sj_min = slice(j, None, None) sj_max = slice(None, jx-j, None) if np.all(np.isnan(noise[si_min, sj_min])) or np.all(np.isnan(noise[si_max, sj_max])): corr[i, j] = np.nan else: corr[i, j] = np.nansum(noise[si_min, sj_min] * noise[si_max, sj_max]) # return the normalised acf return corr / np.nanmax(corr)
Calculate the autocorrelation function of the noise where the noise is a 2d array that may contain nans Parameters ---------- noise : 2d-array Noise image. Returns ------- acf : 2d-array The ACF.
entailment
def make_ita(noise, acf=None): """ Create the matrix ita of the noise where the noise may be a masked array where ita(x,y) is the correlation between pixel pairs that have the same separation as x and y. Parameters ---------- noise : 2d-array The noise image acf : 2d-array The autocorrelation matrix. (None = calculate from data). Default = None. Returns ------- ita : 2d-array The matrix ita """ if acf is None: acf = nan_acf(noise) # s should be the number of non-masked pixels s = np.count_nonzero(np.isfinite(noise)) # the indices of the non-masked pixels xm, ym = np.where(np.isfinite(noise)) ita = np.zeros((s, s)) # iterate over the pixels for i, (x1, y1) in enumerate(zip(xm, ym)): for j, (x2, y2) in enumerate(zip(xm, ym)): k = abs(x1-x2) l = abs(y1-y2) ita[i, j] = acf[k, l] return ita
Create the matrix ita of the noise where the noise may be a masked array where ita(x,y) is the correlation between pixel pairs that have the same separation as x and y. Parameters ---------- noise : 2d-array The noise image acf : 2d-array The autocorrelation matrix. (None = calculate from data). Default = None. Returns ------- ita : 2d-array The matrix ita
entailment
def RB_bias(data, pars, ita=None, acf=None): """ Calculate the expected bias on each of the parameters in the model pars. Only parameters that are allowed to vary will have a bias. Calculation follows the description of Refrieger & Brown 1998 (cite). Parameters ---------- data : 2d-array data that was fit pars : lmfit.Parameters The model ita : 2d-array The ita matrix (optional). acf : 2d-array The acf for the data. Returns ------- bias : array The bias on each of the parameters """ log.info("data {0}".format(data.shape)) nparams = np.sum([pars[k].vary for k in pars.keys() if k != 'components']) # masked pixels xm, ym = np.where(np.isfinite(data)) # all pixels x, y = np.indices(data.shape) # Create the jacobian as an AxN array accounting for the masked pixels j = np.array(np.vsplit(lmfit_jacobian(pars, xm, ym).T, nparams)).reshape(nparams, -1) h = hessian(pars, x, y) # mask the hessian to be AxAxN array h = h[:, :, xm, ym] Hij = np.einsum('ik,jk', j, j) Dij = np.linalg.inv(Hij) Bijk = np.einsum('ip,jkp', j, h) Eilkm = np.einsum('il,km', Dij, Dij) Cimn_1 = -1 * np.einsum('krj,ir,km,jn', Bijk, Dij, Dij, Dij) Cimn_2 = -1./2 * np.einsum('rkj,ir,km,jn', Bijk, Dij, Dij, Dij) Cimn = Cimn_1 + Cimn_2 if ita is None: # N is the noise (data-model) N = data - ntwodgaussian_lmfit(pars)(x, y) if acf is None: acf = nan_acf(N) ita = make_ita(N, acf=acf) log.info('acf.shape {0}'.format(acf.shape)) log.info('acf[0] {0}'.format(acf[0])) log.info('ita.shape {0}'.format(ita.shape)) log.info('ita[0] {0}'.format(ita[0])) # Included for completeness but not required # now mask/ravel the noise # N = N[np.isfinite(N)].ravel() # Pi = np.einsum('ip,p', j, N) # Qij = np.einsum('ijp,p', h, N) Vij = np.einsum('ip,jq,pq', j, j, ita) Uijk = np.einsum('ip,jkq,pq', j, h, ita) bias_1 = np.einsum('imn, mn', Cimn, Vij) bias_2 = np.einsum('ilkm, mlk', Eilkm, Uijk) bias = bias_1 + bias_2 log.info('bias {0}'.format(bias)) return bias
Calculate the expected bias on each of the parameters in the model pars. Only parameters that are allowed to vary will have a bias. Calculation follows the description of Refrieger & Brown 1998 (cite). Parameters ---------- data : 2d-array data that was fit pars : lmfit.Parameters The model ita : 2d-array The ita matrix (optional). acf : 2d-array The acf for the data. Returns ------- bias : array The bias on each of the parameters
entailment
def bias_correct(params, data, acf=None): """ Calculate and apply a bias correction to the given fit parameters Parameters ---------- params : lmfit.Parameters The model parameters. These will be modified. data : 2d-array The data which was used in the fitting acf : 2d-array ACF of the data. Default = None. Returns ------- None See Also -------- :func:`AegeanTools.fitting.RB_bias` """ bias = RB_bias(data, params, acf=acf) i = 0 for p in params: if 'theta' in p: continue if params[p].vary: params[p].value -= bias[i] i += 1 return
Calculate and apply a bias correction to the given fit parameters Parameters ---------- params : lmfit.Parameters The model parameters. These will be modified. data : 2d-array The data which was used in the fitting acf : 2d-array ACF of the data. Default = None. Returns ------- None See Also -------- :func:`AegeanTools.fitting.RB_bias`
entailment
def condon_errors(source, theta_n, psf=None): """ Calculate the parameter errors for a fitted source using the description of Condon'97 All parameters are assigned errors, assuming that all params were fit. If some params were held fixed then these errors are overestimated. Parameters ---------- source : :class:`AegeanTools.models.SimpleSource` The source which was fit. theta_n : float or None A measure of the beam sampling. (See Condon'97). psf : :class:`AegeanTools.fits_image.Beam` The psf at the location of the source. Returns ------- None """ # indices for the calculation or rho alphas = {'amp': (3. / 2, 3. / 2), 'major': (5. / 2, 1. / 2), 'xo': (5. / 2, 1. / 2), 'minor': (1. / 2, 5. / 2), 'yo': (1. / 2, 5. / 2), 'pa': (1. / 2, 5. / 2)} major = source.a / 3600. # degrees minor = source.b / 3600. # degrees phi = np.radians(source.pa) # radians if psf is not None: beam = psf.get_beam(source.ra, source.dec) if beam is not None: theta_n = np.hypot(beam.a, beam.b) print(beam, theta_n) if theta_n is None: source.err_a = source.err_b = source.err_peak_flux = source.err_pa = source.err_int_flux = 0.0 return smoothing = major * minor / (theta_n ** 2) factor1 = (1 + (major / theta_n)) factor2 = (1 + (minor / theta_n)) snr = source.peak_flux / source.local_rms # calculation of rho2 depends on the parameter being used so we lambda this into a function rho2 = lambda x: smoothing / 4 * factor1 ** alphas[x][0] * factor2 ** alphas[x][1] * snr ** 2 source.err_peak_flux = source.peak_flux * np.sqrt(2 / rho2('amp')) source.err_a = major * np.sqrt(2 / rho2('major')) * 3600. # arcsec source.err_b = minor * np.sqrt(2 / rho2('minor')) * 3600. # arcsec err_xo2 = 2. / rho2('xo') * major ** 2 / (8 * np.log(2)) # Condon'97 eq 21 err_yo2 = 2. / rho2('yo') * minor ** 2 / (8 * np.log(2)) source.err_ra = np.sqrt(err_xo2 * np.sin(phi)**2 + err_yo2 * np.cos(phi)**2) source.err_dec = np.sqrt(err_xo2 * np.cos(phi)**2 + err_yo2 * np.sin(phi)**2) if (major == 0) or (minor == 0): source.err_pa = ERR_MASK # if major/minor are very similar then we should not be able to figure out what pa is. elif abs(2 * (major-minor) / (major+minor)) < 0.01: source.err_pa = ERR_MASK else: source.err_pa = np.degrees(np.sqrt(4 / rho2('pa')) * (major * minor / (major ** 2 - minor ** 2))) # integrated flux error err2 = (source.err_peak_flux / source.peak_flux) ** 2 err2 += (theta_n ** 2 / (major * minor)) * ((source.err_a / source.a) ** 2 + (source.err_b / source.b) ** 2) source.err_int_flux = source.int_flux * np.sqrt(err2) return
Calculate the parameter errors for a fitted source using the description of Condon'97 All parameters are assigned errors, assuming that all params were fit. If some params were held fixed then these errors are overestimated. Parameters ---------- source : :class:`AegeanTools.models.SimpleSource` The source which was fit. theta_n : float or None A measure of the beam sampling. (See Condon'97). psf : :class:`AegeanTools.fits_image.Beam` The psf at the location of the source. Returns ------- None
entailment
def errors(source, model, wcshelper): """ Convert pixel based errors into sky coord errors Parameters ---------- source : :class:`AegeanTools.models.SimpleSource` The source which was fit. model : lmfit.Parameters The model which was fit. wcshelper : :class:`AegeanTools.wcs_helpers.WCSHelper` WCS information. Returns ------- source : :class:`AegeanTools.models.SimpleSource` The modified source obejct. """ # if the source wasn't fit then all errors are -1 if source.flags & (flags.NOTFIT | flags.FITERR): source.err_peak_flux = source.err_a = source.err_b = source.err_pa = ERR_MASK source.err_ra = source.err_dec = source.err_int_flux = ERR_MASK return source # copy the errors from the model prefix = "c{0}_".format(source.source) err_amp = model[prefix + 'amp'].stderr xo, yo = model[prefix + 'xo'].value, model[prefix + 'yo'].value err_xo = model[prefix + 'xo'].stderr err_yo = model[prefix + 'yo'].stderr sx, sy = model[prefix + 'sx'].value, model[prefix + 'sy'].value err_sx = model[prefix + 'sx'].stderr err_sy = model[prefix + 'sy'].stderr theta = model[prefix + 'theta'].value err_theta = model[prefix + 'theta'].stderr source.err_peak_flux = err_amp pix_errs = [err_xo, err_yo, err_sx, err_sy, err_theta] log.debug("Pix errs: {0}".format(pix_errs)) ref = wcshelper.pix2sky([xo, yo]) # check to see if the reference position has a valid WCS coordinate # It is possible for this to fail, even if the ra/dec conversion works elsewhere if not all(np.isfinite(ref)): source.flags |= flags.WCSERR source.err_peak_flux = source.err_a = source.err_b = source.err_pa = ERR_MASK source.err_ra = source.err_dec = source.err_int_flux = ERR_MASK return source # position errors if model[prefix + 'xo'].vary and model[prefix + 'yo'].vary \ and all(np.isfinite([err_xo, err_yo])): offset = wcshelper.pix2sky([xo + err_xo, yo + err_yo]) source.err_ra = gcd(ref[0], ref[1], offset[0], ref[1]) source.err_dec = gcd(ref[0], ref[1], ref[0], offset[1]) else: source.err_ra = source.err_dec = -1 if model[prefix + 'theta'].vary and np.isfinite(err_theta): # pa error off1 = wcshelper.pix2sky([xo + sx * np.cos(np.radians(theta)), yo + sy * np.sin(np.radians(theta))]) off2 = wcshelper.pix2sky( [xo + sx * np.cos(np.radians(theta + err_theta)), yo + sy * np.sin(np.radians(theta + err_theta))]) source.err_pa = abs(bear(ref[0], ref[1], off1[0], off1[1]) - bear(ref[0], ref[1], off2[0], off2[1])) else: source.err_pa = ERR_MASK if model[prefix + 'sx'].vary and model[prefix + 'sy'].vary \ and all(np.isfinite([err_sx, err_sy])): # major axis error ref = wcshelper.pix2sky([xo + sx * np.cos(np.radians(theta)), yo + sy * np.sin(np.radians(theta))]) offset = wcshelper.pix2sky( [xo + (sx + err_sx) * np.cos(np.radians(theta)), yo + sy * np.sin(np.radians(theta))]) source.err_a = gcd(ref[0], ref[1], offset[0], offset[1]) * 3600 # minor axis error ref = wcshelper.pix2sky([xo + sx * np.cos(np.radians(theta + 90)), yo + sy * np.sin(np.radians(theta + 90))]) offset = wcshelper.pix2sky( [xo + sx * np.cos(np.radians(theta + 90)), yo + (sy + err_sy) * np.sin(np.radians(theta + 90))]) source.err_b = gcd(ref[0], ref[1], offset[0], offset[1]) * 3600 else: source.err_a = source.err_b = ERR_MASK sqerr = 0 sqerr += (source.err_peak_flux / source.peak_flux) ** 2 if source.err_peak_flux > 0 else 0 sqerr += (source.err_a / source.a) ** 2 if source.err_a > 0 else 0 sqerr += (source.err_b / source.b) ** 2 if source.err_b > 0 else 0 if sqerr == 0: source.err_int_flux = ERR_MASK else: source.err_int_flux = abs(source.int_flux * np.sqrt(sqerr)) return source
Convert pixel based errors into sky coord errors Parameters ---------- source : :class:`AegeanTools.models.SimpleSource` The source which was fit. model : lmfit.Parameters The model which was fit. wcshelper : :class:`AegeanTools.wcs_helpers.WCSHelper` WCS information. Returns ------- source : :class:`AegeanTools.models.SimpleSource` The modified source obejct.
entailment
def new_errors(source, model, wcshelper): # pragma: no cover """ Convert pixel based errors into sky coord errors Uses covariance matrix for ra/dec errors and calculus approach to a/b/pa errors Parameters ---------- source : :class:`AegeanTools.models.SimpleSource` The source which was fit. model : lmfit.Parameters The model which was fit. wcshelper : :class:`AegeanTools.wcs_helpers.WCSHelper` WCS information. Returns ------- source : :class:`AegeanTools.models.SimpleSource` The modified source obejct. """ # if the source wasn't fit then all errors are -1 if source.flags & (flags.NOTFIT | flags.FITERR): source.err_peak_flux = source.err_a = source.err_b = source.err_pa = ERR_MASK source.err_ra = source.err_dec = source.err_int_flux = ERR_MASK return source # copy the errors/values from the model prefix = "c{0}_".format(source.source) err_amp = model[prefix + 'amp'].stderr xo, yo = model[prefix + 'xo'].value, model[prefix + 'yo'].value err_xo = model[prefix + 'xo'].stderr err_yo = model[prefix + 'yo'].stderr sx, sy = model[prefix + 'sx'].value, model[prefix + 'sy'].value err_sx = model[prefix + 'sx'].stderr err_sy = model[prefix + 'sy'].stderr theta = model[prefix + 'theta'].value err_theta = model[prefix + 'theta'].stderr # the peak flux error doesn't need to be converted, just copied source.err_peak_flux = err_amp pix_errs = [err_xo, err_yo, err_sx, err_sy, err_theta] # check for inf/nan errors -> these sources have poor fits. if not all(a is not None and np.isfinite(a) for a in pix_errs): source.flags |= flags.FITERR source.err_peak_flux = source.err_a = source.err_b = source.err_pa = ERR_MASK source.err_ra = source.err_dec = source.err_int_flux = ERR_MASK return source # calculate the reference coordinate ref = wcshelper.pix2sky([xo, yo]) # check to see if the reference position has a valid WCS coordinate # It is possible for this to fail, even if the ra/dec conversion works elsewhere if not all(np.isfinite(ref)): source.flags |= flags.WCSERR source.err_peak_flux = source.err_a = source.err_b = source.err_pa = ERR_MASK source.err_ra = source.err_dec = source.err_int_flux = ERR_MASK return source # calculate position errors by transforming the error ellipse if model[prefix + 'xo'].vary and model[prefix + 'yo'].vary: # determine the error ellipse from the Jacobian mat = model.covar[1:3, 1:3] if not(np.all(np.isfinite(mat))): source.err_ra = source.err_dec = ERR_MASK else: (a, b), e = np.linalg.eig(mat) pa = np.degrees(np.arctan2(*e[0])) # transform this ellipse into sky coordinates _, _, major, minor, pa = wcshelper.pix2sky_ellipse([xo, yo], a, b, pa) # now determine the radius of the ellipse along the ra/dec directions. source.err_ra = major*minor / np.hypot(major*np.sin(np.radians(pa)), minor*np.cos(np.radians(pa))) source.err_dec = major*minor / np.hypot(major*np.cos(np.radians(pa)), minor*np.sin(np.radians(pa))) else: source.err_ra = source.err_dec = -1 if model[prefix + 'theta'].vary: # pa error off1 = wcshelper.pix2sky([xo + sx * np.cos(np.radians(theta)), yo + sy * np.sin(np.radians(theta))]) # offset by 1 degree off2 = wcshelper.pix2sky( [xo + sx * np.cos(np.radians(theta + 1)), yo + sy * np.sin(np.radians(theta + 1))]) # scale the initial theta error by this amount source.err_pa = abs(bear(ref[0], ref[1], off1[0], off1[1]) - bear(ref[0], ref[1], off2[0], off2[1])) * err_theta else: source.err_pa = ERR_MASK if model[prefix + 'sx'].vary and model[prefix + 'sy'].vary: # major axis error ref = wcshelper.pix2sky([xo + sx * np.cos(np.radians(theta)), yo + sy * np.sin(np.radians(theta))]) # offset by 0.1 pixels offset = wcshelper.pix2sky( [xo + (sx + 0.1) * np.cos(np.radians(theta)), yo + sy * np.sin(np.radians(theta))]) source.err_a = gcd(ref[0], ref[1], offset[0], offset[1])/0.1 * err_sx * 3600 # minor axis error ref = wcshelper.pix2sky([xo + sx * np.cos(np.radians(theta + 90)), yo + sy * np.sin(np.radians(theta + 90))]) # offset by 0.1 pixels offset = wcshelper.pix2sky( [xo + sx * np.cos(np.radians(theta + 90)), yo + (sy + 0.1) * np.sin(np.radians(theta + 90))]) source.err_b = gcd(ref[0], ref[1], offset[0], offset[1])/0.1*err_sy * 3600 else: source.err_a = source.err_b = ERR_MASK sqerr = 0 sqerr += (source.err_peak_flux / source.peak_flux) ** 2 if source.err_peak_flux > 0 else 0 sqerr += (source.err_a / source.a) ** 2 if source.err_a > 0 else 0 sqerr += (source.err_b / source.b) ** 2 if source.err_b > 0 else 0 source.err_int_flux = abs(source.int_flux * np.sqrt(sqerr)) return source
Convert pixel based errors into sky coord errors Uses covariance matrix for ra/dec errors and calculus approach to a/b/pa errors Parameters ---------- source : :class:`AegeanTools.models.SimpleSource` The source which was fit. model : lmfit.Parameters The model which was fit. wcshelper : :class:`AegeanTools.wcs_helpers.WCSHelper` WCS information. Returns ------- source : :class:`AegeanTools.models.SimpleSource` The modified source obejct.
entailment
def ntwodgaussian_lmfit(params): """ Convert an lmfit.Parameters object into a function which calculates the model. Parameters ---------- params : lmfit.Parameters Model parameters, can have multiple components. Returns ------- model : func A function f(x,y) that will compute the model. """ def rfunc(x, y): """ Compute the model given by params, at pixel coordinates x,y Parameters ---------- x, y : numpy.ndarray The x/y pixel coordinates at which the model is being evaluated Returns ------- result : numpy.ndarray Model """ result = None for i in range(params['components'].value): prefix = "c{0}_".format(i) # I hope this doesn't kill our run time amp = np.nan_to_num(params[prefix + 'amp'].value) xo = params[prefix + 'xo'].value yo = params[prefix + 'yo'].value sx = params[prefix + 'sx'].value sy = params[prefix + 'sy'].value theta = params[prefix + 'theta'].value if result is not None: result += elliptical_gaussian(x, y, amp, xo, yo, sx, sy, theta) else: result = elliptical_gaussian(x, y, amp, xo, yo, sx, sy, theta) return result return rfunc
Convert an lmfit.Parameters object into a function which calculates the model. Parameters ---------- params : lmfit.Parameters Model parameters, can have multiple components. Returns ------- model : func A function f(x,y) that will compute the model.
entailment
def do_lmfit(data, params, B=None, errs=None, dojac=True): """ Fit the model to the data data may contain 'flagged' or 'masked' data with the value of np.NaN Parameters ---------- data : 2d-array Image data params : lmfit.Parameters Initial model guess. B : 2d-array B matrix to be used in residual calculations. Default = None. errs : 1d-array dojac : bool If true then an analytic jacobian will be passed to the fitting routine. Returns ------- result : ? lmfit.minimize result. params : lmfit.Params Fitted model. See Also -------- :func:`AegeanTools.fitting.lmfit_jacobian` """ # copy the params so as not to change the initial conditions # in case we want to use them elsewhere params = copy.deepcopy(params) data = np.array(data) mask = np.where(np.isfinite(data)) def residual(params, **kwargs): """ The residual function required by lmfit Parameters ---------- params: lmfit.Params The parameters of the model being fit Returns ------- result : numpy.ndarray Model - Data """ f = ntwodgaussian_lmfit(params) # A function describing the model model = f(*mask) # The actual model if B is None: return model - data[mask] else: return (model - data[mask]).dot(B) if dojac: result = lmfit.minimize(residual, params, kws={'x': mask[0], 'y': mask[1], 'B': B, 'errs': errs}, Dfun=lmfit_jacobian) else: result = lmfit.minimize(residual, params, kws={'x': mask[0], 'y': mask[1], 'B': B, 'errs': errs}) # Remake the residual so that it is once again (model - data) if B is not None: result.residual = result.residual.dot(inv(B)) return result, params
Fit the model to the data data may contain 'flagged' or 'masked' data with the value of np.NaN Parameters ---------- data : 2d-array Image data params : lmfit.Parameters Initial model guess. B : 2d-array B matrix to be used in residual calculations. Default = None. errs : 1d-array dojac : bool If true then an analytic jacobian will be passed to the fitting routine. Returns ------- result : ? lmfit.minimize result. params : lmfit.Params Fitted model. See Also -------- :func:`AegeanTools.fitting.lmfit_jacobian`
entailment
def covar_errors(params, data, errs, B, C=None): """ Take a set of parameters that were fit with lmfit, and replace the errors with the 1\sigma errors calculated using the covariance matrix. Parameters ---------- params : lmfit.Parameters Model data : 2d-array Image data errs : 2d-array ? Image noise. B : 2d-array B matrix. C : 2d-array C matrix. Optional. If supplied then Bmatrix will not be used. Returns ------- params : lmfit.Parameters Modified model. """ mask = np.where(np.isfinite(data)) # calculate the proper parameter errors and copy them across. if C is not None: try: J = lmfit_jacobian(params, mask[0], mask[1], errs=errs) covar = np.transpose(J).dot(inv(C)).dot(J) onesigma = np.sqrt(np.diag(inv(covar))) except (np.linalg.linalg.LinAlgError, ValueError) as _: C = None if C is None: try: J = lmfit_jacobian(params, mask[0], mask[1], B=B, errs=errs) covar = np.transpose(J).dot(J) onesigma = np.sqrt(np.diag(inv(covar))) except (np.linalg.linalg.LinAlgError, ValueError) as _: onesigma = [-2] * len(mask[0]) for i in range(params['components'].value): prefix = "c{0}_".format(i) j = 0 for p in ['amp', 'xo', 'yo', 'sx', 'sy', 'theta']: if params[prefix + p].vary: params[prefix + p].stderr = onesigma[j] j += 1 return params
Take a set of parameters that were fit with lmfit, and replace the errors with the 1\sigma errors calculated using the covariance matrix. Parameters ---------- params : lmfit.Parameters Model data : 2d-array Image data errs : 2d-array ? Image noise. B : 2d-array B matrix. C : 2d-array C matrix. Optional. If supplied then Bmatrix will not be used. Returns ------- params : lmfit.Parameters Modified model.
entailment
def barrier(events, sid, kind='neighbour'): """ act as a multiprocessing barrier """ events[sid].set() # only wait for the neighbours if kind=='neighbour': if sid > 0: logging.debug("{0} is waiting for {1}".format(sid, sid - 1)) events[sid - 1].wait() if sid < len(bkg_events) - 1: logging.debug("{0} is waiting for {1}".format(sid, sid + 1)) events[sid + 1].wait() # wait for all else: [e.wait() for e in events] return
act as a multiprocessing barrier
entailment
def sigmaclip(arr, lo, hi, reps=3): """ Perform sigma clipping on an array, ignoring non finite values. During each iteration return an array whose elements c obey: mean -std*lo < c < mean + std*hi where mean/std are the mean std of the input array. Parameters ---------- arr : iterable An iterable array of numeric types. lo : float The negative clipping level. hi : float The positive clipping level. reps : int The number of iterations to perform. Default = 3. Returns ------- mean : float The mean of the array, possibly nan std : float The std of the array, possibly nan Notes ----- Scipy v0.16 now contains a comparable method that will ignore nan/inf values. """ clipped = np.array(arr)[np.isfinite(arr)] if len(clipped) < 1: return np.nan, np.nan std = np.std(clipped) mean = np.mean(clipped) for _ in range(int(reps)): clipped = clipped[np.where(clipped > mean-std*lo)] clipped = clipped[np.where(clipped < mean+std*hi)] pstd = std if len(clipped) < 1: break std = np.std(clipped) mean = np.mean(clipped) if 2*abs(pstd-std)/(pstd+std) < 0.2: break return mean, std
Perform sigma clipping on an array, ignoring non finite values. During each iteration return an array whose elements c obey: mean -std*lo < c < mean + std*hi where mean/std are the mean std of the input array. Parameters ---------- arr : iterable An iterable array of numeric types. lo : float The negative clipping level. hi : float The positive clipping level. reps : int The number of iterations to perform. Default = 3. Returns ------- mean : float The mean of the array, possibly nan std : float The std of the array, possibly nan Notes ----- Scipy v0.16 now contains a comparable method that will ignore nan/inf values.
entailment
def _sf2(args): """ A shallow wrapper for sigma_filter. Parameters ---------- args : list A list of arguments for sigma_filter Returns ------- None """ # an easier to debug traceback when multiprocessing # thanks to https://stackoverflow.com/a/16618842/1710603 try: return sigma_filter(*args) except: import traceback raise Exception("".join(traceback.format_exception(*sys.exc_info())))
A shallow wrapper for sigma_filter. Parameters ---------- args : list A list of arguments for sigma_filter Returns ------- None
entailment
def sigma_filter(filename, region, step_size, box_size, shape, domask, sid): """ Calculate the background and rms for a sub region of an image. The results are written to shared memory - irms and ibkg. Parameters ---------- filename : string Fits file to open region : list Region within the fits file that is to be processed. (row_min, row_max). step_size : (int, int) The filtering step size box_size : (int, int) The size of the box over which the filter is applied (each step). shape : tuple The shape of the fits image domask : bool If true then copy the data mask to the output. sid : int The stripe number Returns ------- None """ ymin, ymax = region logging.debug('rows {0}-{1} starting at {2}'.format(ymin, ymax, strftime("%Y-%m-%d %H:%M:%S", gmtime()))) # cut out the region of interest plus 1/2 the box size, but clip to the image size data_row_min = max(0, ymin - box_size[0]//2) data_row_max = min(shape[0], ymax + box_size[0]//2) # Figure out how many axes are in the datafile NAXIS = fits.getheader(filename)["NAXIS"] with fits.open(filename, memmap=True) as a: if NAXIS == 2: data = a[0].section[data_row_min:data_row_max, 0:shape[1]] elif NAXIS == 3: data = a[0].section[0, data_row_min:data_row_max, 0:shape[1]] elif NAXIS == 4: data = a[0].section[0, 0, data_row_min:data_row_max, 0:shape[1]] else: logging.error("Too many NAXIS for me {0}".format(NAXIS)) logging.error("fix your file to be more sane") raise Exception("Too many NAXIS") row_len = shape[1] logging.debug('data size is {0}'.format(data.shape)) def box(r, c): """ calculate the boundaries of the box centered at r,c with size = box_size """ r_min = max(0, r - box_size[0] // 2) r_max = min(data.shape[0] - 1, r + box_size[0] // 2) c_min = max(0, c - box_size[1] // 2) c_max = min(data.shape[1] - 1, c + box_size[1] // 2) return r_min, r_max, c_min, c_max # set up a grid of rows/cols at which we will compute the bkg/rms rows = list(range(ymin-data_row_min, ymax-data_row_min, step_size[0])) rows.append(ymax-data_row_min) cols = list(range(0, shape[1], step_size[1])) cols.append(shape[1]) # store the computed bkg/rms in this smaller array vals = np.zeros(shape=(len(rows),len(cols))) for i, row in enumerate(rows): for j, col in enumerate(cols): r_min, r_max, c_min, c_max = box(row, col) new = data[r_min:r_max, c_min:c_max] new = np.ravel(new) bkg, _ = sigmaclip(new, 3, 3) vals[i,j] = bkg # indices of all the pixels within our region gr, gc = np.mgrid[ymin-data_row_min:ymax-data_row_min, 0:shape[1]] logging.debug("Interpolating bkg to sharemem") ifunc = RegularGridInterpolator((rows, cols), vals) for i in range(gr.shape[0]): row = np.array(ifunc((gr[i], gc[i])), dtype=np.float32) start_idx = np.ravel_multi_index((ymin+i, 0), shape) end_idx = start_idx + row_len ibkg[start_idx:end_idx] = row # np.ctypeslib.as_ctypes(row) del ifunc logging.debug(" ... done writing bkg") # signal that the bkg is done for this region, and wait for neighbours barrier(bkg_events, sid) logging.debug("{0} background subtraction".format(sid)) for i in range(data_row_max - data_row_min): start_idx = np.ravel_multi_index((data_row_min + i, 0), shape) end_idx = start_idx + row_len data[i, :] = data[i, :] - ibkg[start_idx:end_idx] # reset/recycle the vals array vals[:] = 0 for i, row in enumerate(rows): for j, col in enumerate(cols): r_min, r_max, c_min, c_max = box(row, col) new = data[r_min:r_max, c_min:c_max] new = np.ravel(new) _ , rms = sigmaclip(new, 3, 3) vals[i,j] = rms logging.debug("Interpolating rm to sharemem rms") ifunc = RegularGridInterpolator((rows, cols), vals) for i in range(gr.shape[0]): row = np.array(ifunc((gr[i], gc[i])), dtype=np.float32) start_idx = np.ravel_multi_index((ymin+i, 0), shape) end_idx = start_idx + row_len irms[start_idx:end_idx] = row # np.ctypeslib.as_ctypes(row) del ifunc logging.debug(" .. done writing rms") if domask: barrier(mask_events, sid) logging.debug("applying mask") for i in range(gr.shape[0]): mask = np.where(np.bitwise_not(np.isfinite(data[i + ymin-data_row_min,:])))[0] for j in mask: idx = np.ravel_multi_index((i + ymin,j),shape) ibkg[idx] = np.nan irms[idx] = np.nan logging.debug(" ... done applying mask") logging.debug('rows {0}-{1} finished at {2}'.format(ymin, ymax, strftime("%Y-%m-%d %H:%M:%S", gmtime()))) return
Calculate the background and rms for a sub region of an image. The results are written to shared memory - irms and ibkg. Parameters ---------- filename : string Fits file to open region : list Region within the fits file that is to be processed. (row_min, row_max). step_size : (int, int) The filtering step size box_size : (int, int) The size of the box over which the filter is applied (each step). shape : tuple The shape of the fits image domask : bool If true then copy the data mask to the output. sid : int The stripe number Returns ------- None
entailment
def filter_mc_sharemem(filename, step_size, box_size, cores, shape, nslice=None, domask=True): """ Calculate the background and noise images corresponding to the input file. The calculation is done via a box-car approach and uses multiple cores and shared memory. Parameters ---------- filename : str Filename to be filtered. step_size : (int, int) Step size for the filter. box_size : (int, int) Box size for the filter. cores : int Number of cores to use. If None then use all available. nslice : int The image will be divided into this many horizontal stripes for processing. Default = None = equal to cores shape : (int, int) The shape of the image in the given file. domask : bool True(Default) = copy data mask to output. Returns ------- bkg, rms : numpy.ndarray The interpolated background and noise images. """ if cores is None: cores = multiprocessing.cpu_count() if (nslice is None) or (cores==1): nslice = cores img_y, img_x = shape # initialise some shared memory global ibkg # bkg = np.ctypeslib.as_ctypes(np.empty(shape, dtype=np.float32)) # ibkg = multiprocessing.sharedctypes.Array(bkg._type_, bkg, lock=True) ibkg = multiprocessing.Array('f', img_y*img_x) global irms #rms = np.ctypeslib.as_ctypes(np.empty(shape, dtype=np.float32)) #irms = multiprocessing.sharedctypes.Array(rms._type_, rms, lock=True) irms = multiprocessing.Array('f', img_y * img_x) logging.info("using {0} cores".format(cores)) logging.info("using {0} stripes".format(nslice)) if nslice > 1: # box widths should be multiples of the step_size, and not zero width_y = int(max(img_y/nslice/step_size[1], 1) * step_size[1]) # locations of the box edges ymins = list(range(0, img_y, width_y)) ymaxs = list(range(width_y, img_y, width_y)) ymaxs.append(img_y) else: ymins = [0] ymaxs = [img_y] logging.debug("ymins {0}".format(ymins)) logging.debug("ymaxs {0}".format(ymaxs)) # create an event per stripe global bkg_events, mask_events bkg_events = [multiprocessing.Event() for _ in range(len(ymaxs))] mask_events = [multiprocessing.Event() for _ in range(len(ymaxs))] args = [] for i, region in enumerate(zip(ymins, ymaxs)): args.append((filename, region, step_size, box_size, shape, domask, i)) # start a new process for each task, hopefully to reduce residual memory use pool = multiprocessing.Pool(processes=cores, maxtasksperchild=1) try: # chunksize=1 ensures that we only send a single task to each process pool.map_async(_sf2, args, chunksize=1).get(timeout=10000000) except KeyboardInterrupt: logging.error("Caught keyboard interrupt") pool.close() sys.exit(1) pool.close() pool.join() bkg = np.reshape(np.array(ibkg[:], dtype=np.float32), shape) rms = np.reshape(np.array(irms[:], dtype=np.float32), shape) del ibkg, irms return bkg, rms
Calculate the background and noise images corresponding to the input file. The calculation is done via a box-car approach and uses multiple cores and shared memory. Parameters ---------- filename : str Filename to be filtered. step_size : (int, int) Step size for the filter. box_size : (int, int) Box size for the filter. cores : int Number of cores to use. If None then use all available. nslice : int The image will be divided into this many horizontal stripes for processing. Default = None = equal to cores shape : (int, int) The shape of the image in the given file. domask : bool True(Default) = copy data mask to output. Returns ------- bkg, rms : numpy.ndarray The interpolated background and noise images.
entailment
def filter_image(im_name, out_base, step_size=None, box_size=None, twopass=False, cores=None, mask=True, compressed=False, nslice=None): """ Create a background and noise image from an input image. Resulting images are written to `outbase_bkg.fits` and `outbase_rms.fits` Parameters ---------- im_name : str or HDUList Image to filter. Either a string filename or an astropy.io.fits.HDUList. out_base : str The output filename base. Will be modified to make _bkg and _rms files. step_size : (int,int) Tuple of the x,y step size in pixels box_size : (int,int) The size of the box in piexls twopass : bool Perform a second pass calculation to ensure that the noise is not contaminated by the background. Default = False cores : int Number of CPU corse to use. Default = all available nslice : int The image will be divided into this many horizontal stripes for processing. Default = None = equal to cores mask : bool Mask the output array to contain np.nna wherever the input array is nan or not finite. Default = true compressed : bool Return a compressed version of the background/noise images. Default = False Returns ------- None """ header = fits.getheader(im_name) shape = (header['NAXIS2'],header['NAXIS1']) if step_size is None: if 'BMAJ' in header and 'BMIN' in header: beam_size = np.sqrt(abs(header['BMAJ']*header['BMIN'])) if 'CDELT1' in header: pix_scale = np.sqrt(abs(header['CDELT1']*header['CDELT2'])) elif 'CD1_1' in header: pix_scale = np.sqrt(abs(header['CD1_1']*header['CD2_2'])) if 'CD1_2' in header and 'CD2_1' in header: if header['CD1_2'] != 0 or header['CD2_1']!=0: logging.warning("CD1_2 and/or CD2_1 are non-zero and I don't know what to do with them") logging.warning("Ingoring them") else: logging.warning("Cannot determine pixel scale, assuming 4 pixels per beam") pix_scale = beam_size/4. # default to 4x the synthesized beam width step_size = int(np.ceil(4*beam_size/pix_scale)) else: logging.info("BMAJ and/or BMIN not in fits header.") logging.info("Assuming 4 pix/beam, so we have step_size = 16 pixels") step_size = 16 step_size = (step_size, step_size) if box_size is None: # default to 6x the step size so we have ~ 30beams box_size = (step_size[0]*6, step_size[1]*6) if compressed: if not step_size[0] == step_size[1]: step_size = (min(step_size), min(step_size)) logging.info("Changing grid to be {0} so we can compress the output".format(step_size)) logging.info("using grid_size {0}, box_size {1}".format(step_size,box_size)) logging.info("on data shape {0}".format(shape)) bkg, rms = filter_mc_sharemem(im_name, step_size=step_size, box_size=box_size, cores=cores, shape=shape, nslice=nslice, domask=mask) logging.info("done") bkg_out = '_'.join([os.path.expanduser(out_base), 'bkg.fits']) rms_out = '_'.join([os.path.expanduser(out_base), 'rms.fits']) # add a comment to the fits header header['HISTORY'] = 'BANE {0}-({1})'.format(__version__, __date__) # compress if compressed: hdu = fits.PrimaryHDU(bkg) hdu.header = copy.deepcopy(header) hdulist = fits.HDUList([hdu]) compress(hdulist, step_size[0], bkg_out) hdulist[0].header = copy.deepcopy(header) hdulist[0].data = rms compress(hdulist, step_size[0], rms_out) return write_fits(bkg, header, bkg_out) write_fits(rms, header, rms_out)
Create a background and noise image from an input image. Resulting images are written to `outbase_bkg.fits` and `outbase_rms.fits` Parameters ---------- im_name : str or HDUList Image to filter. Either a string filename or an astropy.io.fits.HDUList. out_base : str The output filename base. Will be modified to make _bkg and _rms files. step_size : (int,int) Tuple of the x,y step size in pixels box_size : (int,int) The size of the box in piexls twopass : bool Perform a second pass calculation to ensure that the noise is not contaminated by the background. Default = False cores : int Number of CPU corse to use. Default = all available nslice : int The image will be divided into this many horizontal stripes for processing. Default = None = equal to cores mask : bool Mask the output array to contain np.nna wherever the input array is nan or not finite. Default = true compressed : bool Return a compressed version of the background/noise images. Default = False Returns ------- None
entailment
def write_fits(data, header, file_name): """ Combine data and a fits header to write a fits file. Parameters ---------- data : numpy.ndarray The data to be written. header : astropy.io.fits.hduheader The header for the fits file. file_name : string The file to write Returns ------- None """ hdu = fits.PrimaryHDU(data) hdu.header = header hdulist = fits.HDUList([hdu]) hdulist.writeto(file_name, overwrite=True) logging.info("Wrote {0}".format(file_name)) return
Combine data and a fits header to write a fits file. Parameters ---------- data : numpy.ndarray The data to be written. header : astropy.io.fits.hduheader The header for the fits file. file_name : string The file to write Returns ------- None
entailment
def dec2dec(dec): """ Convert sexegessimal RA string into a float in degrees. Parameters ---------- dec : string A string separated representing the Dec. Expected format is `[+- ]hh:mm[:ss.s]` Colons can be replaced with any whit space character. Returns ------- dec : float The Dec in degrees. """ d = dec.replace(':', ' ').split() if len(d) == 2: d.append(0.0) if d[0].startswith('-') or float(d[0]) < 0: return float(d[0]) - float(d[1]) / 60.0 - float(d[2]) / 3600.0 return float(d[0]) + float(d[1]) / 60.0 + float(d[2]) / 3600.0
Convert sexegessimal RA string into a float in degrees. Parameters ---------- dec : string A string separated representing the Dec. Expected format is `[+- ]hh:mm[:ss.s]` Colons can be replaced with any whit space character. Returns ------- dec : float The Dec in degrees.
entailment
def dec2dms(x): """ Convert decimal degrees into a sexagessimal string in degrees. Parameters ---------- x : float Angle in degrees Returns ------- dms : string String of format [+-]DD:MM:SS.SS or XX:XX:XX.XX if x is not finite. """ if not np.isfinite(x): return 'XX:XX:XX.XX' if x < 0: sign = '-' else: sign = '+' x = abs(x) d = int(math.floor(x)) m = int(math.floor((x - d) * 60)) s = float(( (x - d) * 60 - m) * 60) return '{0}{1:02d}:{2:02d}:{3:05.2f}'.format(sign, d, m, s)
Convert decimal degrees into a sexagessimal string in degrees. Parameters ---------- x : float Angle in degrees Returns ------- dms : string String of format [+-]DD:MM:SS.SS or XX:XX:XX.XX if x is not finite.
entailment
def dec2hms(x): """ Convert decimal degrees into a sexagessimal string in hours. Parameters ---------- x : float Angle in degrees Returns ------- dms : string String of format HH:MM:SS.SS or XX:XX:XX.XX if x is not finite. """ if not np.isfinite(x): return 'XX:XX:XX.XX' # wrap negative RA's if x < 0: x += 360 x /= 15.0 h = int(x) x = (x - h) * 60 m = int(x) s = (x - m) * 60 return '{0:02d}:{1:02d}:{2:05.2f}'.format(h, m, s)
Convert decimal degrees into a sexagessimal string in hours. Parameters ---------- x : float Angle in degrees Returns ------- dms : string String of format HH:MM:SS.SS or XX:XX:XX.XX if x is not finite.
entailment
def gcd(ra1, dec1, ra2, dec2): """ Calculate the great circle distance between to points using the haversine formula [1]_. Parameters ---------- ra1, dec1, ra2, dec2 : float The coordinates of the two points of interest. Units are in degrees. Returns ------- dist : float The distance between the two points in degrees. Notes ----- This duplicates the functionality of astropy but is faster as there is no creation of SkyCoords objects. .. [1] `Haversine formula <https://en.wikipedia.org/wiki/Haversine_formula>`_ """ # TODO: Vincenty formula see - https://en.wikipedia.org/wiki/Great-circle_distance dlon = ra2 - ra1 dlat = dec2 - dec1 a = np.sin(np.radians(dlat) / 2) ** 2 a += np.cos(np.radians(dec1)) * np.cos(np.radians(dec2)) * np.sin(np.radians(dlon) / 2) ** 2 sep = np.degrees(2 * np.arcsin(np.minimum(1, np.sqrt(a)))) return sep
Calculate the great circle distance between to points using the haversine formula [1]_. Parameters ---------- ra1, dec1, ra2, dec2 : float The coordinates of the two points of interest. Units are in degrees. Returns ------- dist : float The distance between the two points in degrees. Notes ----- This duplicates the functionality of astropy but is faster as there is no creation of SkyCoords objects. .. [1] `Haversine formula <https://en.wikipedia.org/wiki/Haversine_formula>`_
entailment
def bear(ra1, dec1, ra2, dec2): """ Calculate the bearing of point 2 from point 1 along a great circle. The bearing is East of North and is in [0, 360), whereas position angle is also East of North but (-180,180] Parameters ---------- ra1, dec1, ra2, dec2 : float The sky coordinates (degrees) of the two points. Returns ------- bear : float The bearing of point 2 from point 1 (degrees). """ rdec1 = np.radians(dec1) rdec2 = np.radians(dec2) rdlon = np.radians(ra2-ra1) y = np.sin(rdlon) * np.cos(rdec2) x = np.cos(rdec1) * np.sin(rdec2) x -= np.sin(rdec1) * np.cos(rdec2) * np.cos(rdlon) return np.degrees(np.arctan2(y, x))
Calculate the bearing of point 2 from point 1 along a great circle. The bearing is East of North and is in [0, 360), whereas position angle is also East of North but (-180,180] Parameters ---------- ra1, dec1, ra2, dec2 : float The sky coordinates (degrees) of the two points. Returns ------- bear : float The bearing of point 2 from point 1 (degrees).
entailment
def translate(ra, dec, r, theta): """ Translate a given point a distance r in the (initial) direction theta, along a great circle. Parameters ---------- ra, dec : float The initial point of interest (degrees). r, theta : float The distance and initial direction to translate (degrees). Returns ------- ra, dec : float The translated position (degrees). """ factor = np.sin(np.radians(dec)) * np.cos(np.radians(r)) factor += np.cos(np.radians(dec)) * np.sin(np.radians(r)) * np.cos(np.radians(theta)) dec_out = np.degrees(np.arcsin(factor)) y = np.sin(np.radians(theta)) * np.sin(np.radians(r)) * np.cos(np.radians(dec)) x = np.cos(np.radians(r)) - np.sin(np.radians(dec)) * np.sin(np.radians(dec_out)) ra_out = ra + np.degrees(np.arctan2(y, x)) return ra_out, dec_out
Translate a given point a distance r in the (initial) direction theta, along a great circle. Parameters ---------- ra, dec : float The initial point of interest (degrees). r, theta : float The distance and initial direction to translate (degrees). Returns ------- ra, dec : float The translated position (degrees).
entailment
def dist_rhumb(ra1, dec1, ra2, dec2): """ Calculate the Rhumb line distance between two points [1]_. A Rhumb line between two points is one which follows a constant bearing. Parameters ---------- ra1, dec1, ra2, dec2 : float The position of the two points (degrees). Returns ------- dist : float The distance between the two points along a line of constant bearing. Notes ----- .. [1] `Rhumb line <https://en.wikipedia.org/wiki/Rhumb_line>`_ """ # verified against website to give correct results phi1 = np.radians(dec1) phi2 = np.radians(dec2) dphi = phi2 - phi1 lambda1 = np.radians(ra1) lambda2 = np.radians(ra2) dpsi = np.log(np.tan(np.pi / 4 + phi2 / 2) / np.tan(np.pi / 4 + phi1 / 2)) if dpsi < 1e-12: q = np.cos(phi1) else: q = dpsi / dphi dlambda = lambda2 - lambda1 if dlambda > np.pi: dlambda -= 2 * np.pi dist = np.hypot(dphi, q * dlambda) return np.degrees(dist)
Calculate the Rhumb line distance between two points [1]_. A Rhumb line between two points is one which follows a constant bearing. Parameters ---------- ra1, dec1, ra2, dec2 : float The position of the two points (degrees). Returns ------- dist : float The distance between the two points along a line of constant bearing. Notes ----- .. [1] `Rhumb line <https://en.wikipedia.org/wiki/Rhumb_line>`_
entailment
def bear_rhumb(ra1, dec1, ra2, dec2): """ Calculate the bearing of point 2 from point 1 along a Rhumb line. The bearing is East of North and is in [0, 360), whereas position angle is also East of North but (-180,180] Parameters ---------- ra1, dec1, ra2, dec2 : float The sky coordinates (degrees) of the two points. Returns ------- dist : float The bearing of point 2 from point 1 along a Rhumb line (degrees). """ # verified against website to give correct results phi1 = np.radians(dec1) phi2 = np.radians(dec2) lambda1 = np.radians(ra1) lambda2 = np.radians(ra2) dlambda = lambda2 - lambda1 dpsi = np.log(np.tan(np.pi / 4 + phi2 / 2) / np.tan(np.pi / 4 + phi1 / 2)) theta = np.arctan2(dlambda, dpsi) return np.degrees(theta)
Calculate the bearing of point 2 from point 1 along a Rhumb line. The bearing is East of North and is in [0, 360), whereas position angle is also East of North but (-180,180] Parameters ---------- ra1, dec1, ra2, dec2 : float The sky coordinates (degrees) of the two points. Returns ------- dist : float The bearing of point 2 from point 1 along a Rhumb line (degrees).
entailment
def translate_rhumb(ra, dec, r, theta): """ Translate a given point a distance r in the (initial) direction theta, along a Rhumb line. Parameters ---------- ra, dec : float The initial point of interest (degrees). r, theta : float The distance and initial direction to translate (degrees). Returns ------- ra, dec : float The translated position (degrees). """ # verified against website to give correct results # with the help of http://williams.best.vwh.net/avform.htm#Rhumb delta = np.radians(r) phi1 = np.radians(dec) phi2 = phi1 + delta * np.cos(np.radians(theta)) dphi = phi2 - phi1 if abs(dphi) < 1e-9: q = np.cos(phi1) else: dpsi = np.log(np.tan(np.pi / 4 + phi2 / 2) / np.tan(np.pi / 4 + phi1 / 2)) q = dphi / dpsi lambda1 = np.radians(ra) dlambda = delta * np.sin(np.radians(theta)) / q lambda2 = lambda1 + dlambda ra_out = np.degrees(lambda2) dec_out = np.degrees(phi2) return ra_out, dec_out
Translate a given point a distance r in the (initial) direction theta, along a Rhumb line. Parameters ---------- ra, dec : float The initial point of interest (degrees). r, theta : float The distance and initial direction to translate (degrees). Returns ------- ra, dec : float The translated position (degrees).
entailment
def galactic2fk5(l, b): """ Convert galactic l/b to fk5 ra/dec Parameters ---------- l, b : float Galactic coordinates in radians. Returns ------- ra, dec : float FK5 ecliptic coordinates in radians. """ a = SkyCoord(l, b, unit=(u.radian, u.radian), frame='galactic') return a.fk5.ra.radian, a.fk5.dec.radian
Convert galactic l/b to fk5 ra/dec Parameters ---------- l, b : float Galactic coordinates in radians. Returns ------- ra, dec : float FK5 ecliptic coordinates in radians.
entailment
def mask_plane(data, wcs, region, negate=False): """ Mask a 2d image (data) such that pixels within 'region' are set to nan. Parameters ---------- data : 2d-array Image array. wcs : astropy.wcs.WCS WCS for the image in question. region : :class:`AegeanTools.regions.Region` A region within which the image pixels will be masked. negate : bool If True then pixels *outside* the region are masked. Default = False. Returns ------- masked : 2d-array The original array, but masked as required. """ # create an array but don't set the values (they are random) indexes = np.empty((data.shape[0]*data.shape[1], 2), dtype=int) # since I know exactly what the index array needs to look like i can construct # it faster than list comprehension would allow # we do this only once and then recycle it idx = np.array([(j, 0) for j in range(data.shape[1])]) j = data.shape[1] for i in range(data.shape[0]): idx[:, 1] = i indexes[i*j:(i+1)*j] = idx # put ALL the pixles into our vectorized functions and minimise our overheads ra, dec = wcs.wcs_pix2world(indexes, 1).transpose() bigmask = region.sky_within(ra, dec, degin=True) if not negate: bigmask = np.bitwise_not(bigmask) # rework our 1d list into a 2d array bigmask = bigmask.reshape(data.shape) # and apply the mask data[bigmask] = np.nan return data
Mask a 2d image (data) such that pixels within 'region' are set to nan. Parameters ---------- data : 2d-array Image array. wcs : astropy.wcs.WCS WCS for the image in question. region : :class:`AegeanTools.regions.Region` A region within which the image pixels will be masked. negate : bool If True then pixels *outside* the region are masked. Default = False. Returns ------- masked : 2d-array The original array, but masked as required.
entailment
def mask_file(regionfile, infile, outfile, negate=False): """ Created a masked version of file, using a region. Parameters ---------- regionfile : str A file which can be loaded as a :class:`AegeanTools.regions.Region`. The image will be masked according to this region. infile : str Input FITS image. outfile : str Output FITS image. negate : bool If True then pixels *outside* the region are masked. Default = False. See Also -------- :func:`AegeanTools.MIMAS.mask_plane` """ # Check that the input file is accessible and then open it if not os.path.exists(infile): raise AssertionError("Cannot locate fits file {0}".format(infile)) im = pyfits.open(infile) if not os.path.exists(regionfile): raise AssertionError("Cannot locate region file {0}".format(regionfile)) region = Region.load(regionfile) try: wcs = pywcs.WCS(im[0].header, naxis=2) except: # TODO: figure out what error is being thrown wcs = pywcs.WCS(str(im[0].header), naxis=2) if len(im[0].data.shape) > 2: data = np.squeeze(im[0].data) else: data = im[0].data print(data.shape) if len(data.shape) == 3: for plane in range(data.shape[0]): mask_plane(data[plane], wcs, region, negate) else: mask_plane(data, wcs, region, negate) im[0].data = data im.writeto(outfile, overwrite=True) logging.info("Wrote {0}".format(outfile)) return
Created a masked version of file, using a region. Parameters ---------- regionfile : str A file which can be loaded as a :class:`AegeanTools.regions.Region`. The image will be masked according to this region. infile : str Input FITS image. outfile : str Output FITS image. negate : bool If True then pixels *outside* the region are masked. Default = False. See Also -------- :func:`AegeanTools.MIMAS.mask_plane`
entailment
def mask_table(region, table, negate=False, racol='ra', deccol='dec'): """ Apply a given mask (region) to the table, removing all the rows with ra/dec inside the region If negate=False then remove the rows with ra/dec outside the region. Parameters ---------- region : :class:`AegeanTools.regions.Region` Region to mask. table : Astropy.table.Table Table to be masked. negate : bool If True then pixels *outside* the region are masked. Default = False. racol, deccol : str The name of the columns in `table` that should be interpreted as ra and dec. Default = 'ra', 'dec' Returns ------- masked : Astropy.table.Table A view of the given table which has been masked. """ inside = region.sky_within(table[racol], table[deccol], degin=True) if not negate: mask = np.bitwise_not(inside) else: mask = inside return table[mask]
Apply a given mask (region) to the table, removing all the rows with ra/dec inside the region If negate=False then remove the rows with ra/dec outside the region. Parameters ---------- region : :class:`AegeanTools.regions.Region` Region to mask. table : Astropy.table.Table Table to be masked. negate : bool If True then pixels *outside* the region are masked. Default = False. racol, deccol : str The name of the columns in `table` that should be interpreted as ra and dec. Default = 'ra', 'dec' Returns ------- masked : Astropy.table.Table A view of the given table which has been masked.
entailment
def mask_catalog(regionfile, infile, outfile, negate=False, racol='ra', deccol='dec'): """ Apply a region file as a mask to a catalog, removing all the rows with ra/dec inside the region If negate=False then remove the rows with ra/dec outside the region. Parameters ---------- regionfile : str A file which can be loaded as a :class:`AegeanTools.regions.Region`. The catalogue will be masked according to this region. infile : str Input catalogue. outfile : str Output catalogue. negate : bool If True then pixels *outside* the region are masked. Default = False. racol, deccol : str The name of the columns in `table` that should be interpreted as ra and dec. Default = 'ra', 'dec' See Also -------- :func:`AegeanTools.MIMAS.mask_table` :func:`AegeanTools.catalogs.load_table` """ logging.info("Loading region from {0}".format(regionfile)) region = Region.load(regionfile) logging.info("Loading catalog from {0}".format(infile)) table = load_table(infile) masked_table = mask_table(region, table, negate=negate, racol=racol, deccol=deccol) write_table(masked_table, outfile) return
Apply a region file as a mask to a catalog, removing all the rows with ra/dec inside the region If negate=False then remove the rows with ra/dec outside the region. Parameters ---------- regionfile : str A file which can be loaded as a :class:`AegeanTools.regions.Region`. The catalogue will be masked according to this region. infile : str Input catalogue. outfile : str Output catalogue. negate : bool If True then pixels *outside* the region are masked. Default = False. racol, deccol : str The name of the columns in `table` that should be interpreted as ra and dec. Default = 'ra', 'dec' See Also -------- :func:`AegeanTools.MIMAS.mask_table` :func:`AegeanTools.catalogs.load_table`
entailment
def mim2reg(mimfile, regfile): """ Convert a MIMAS region (.mim) file into a DS9 region (.reg) file. Parameters ---------- mimfile : str Input file in MIMAS format. regfile : str Output file. """ region = Region.load(mimfile) region.write_reg(regfile) logging.info("Converted {0} -> {1}".format(mimfile, regfile)) return
Convert a MIMAS region (.mim) file into a DS9 region (.reg) file. Parameters ---------- mimfile : str Input file in MIMAS format. regfile : str Output file.
entailment
def mim2fits(mimfile, fitsfile): """ Convert a MIMAS region (.mim) file into a MOC region (.fits) file. Parameters ---------- mimfile : str Input file in MIMAS format. fitsfile : str Output file. """ region = Region.load(mimfile) region.write_fits(fitsfile, moctool='MIMAS {0}-{1}'.format(__version__, __date__)) logging.info("Converted {0} -> {1}".format(mimfile, fitsfile)) return
Convert a MIMAS region (.mim) file into a MOC region (.fits) file. Parameters ---------- mimfile : str Input file in MIMAS format. fitsfile : str Output file.
entailment
def box2poly(line): """ Convert a string that describes a box in ds9 format, into a polygon that is given by the corners of the box Parameters ---------- line : str A string containing a DS9 region command for a box. Returns ------- poly : [ra, dec, ...] The corners of the box in clockwise order from top left. """ words = re.split('[(\s,)]', line) ra = words[1] dec = words[2] width = words[3] height = words[4] if ":" in ra: ra = Angle(ra, unit=u.hour) else: ra = Angle(ra, unit=u.degree) dec = Angle(dec, unit=u.degree) width = Angle(float(width[:-1])/2, unit=u.arcsecond) # strip the " height = Angle(float(height[:-1])/2, unit=u.arcsecond) # strip the " center = SkyCoord(ra, dec) tl = center.ra.degree+width.degree, center.dec.degree+height.degree tr = center.ra.degree-width.degree, center.dec.degree+height.degree bl = center.ra.degree+width.degree, center.dec.degree-height.degree br = center.ra.degree-width.degree, center.dec.degree-height.degree return np.ravel([tl, tr, br, bl]).tolist()
Convert a string that describes a box in ds9 format, into a polygon that is given by the corners of the box Parameters ---------- line : str A string containing a DS9 region command for a box. Returns ------- poly : [ra, dec, ...] The corners of the box in clockwise order from top left.
entailment
def circle2circle(line): """ Parse a string that describes a circle in ds9 format. Parameters ---------- line : str A string containing a DS9 region command for a circle. Returns ------- circle : [ra, dec, radius] The center and radius of the circle. """ words = re.split('[(,\s)]', line) ra = words[1] dec = words[2] radius = words[3][:-1] # strip the " if ":" in ra: ra = Angle(ra, unit=u.hour) else: ra = Angle(ra, unit=u.degree) dec = Angle(dec, unit=u.degree) radius = Angle(radius, unit=u.arcsecond) return [ra.degree, dec.degree, radius.degree]
Parse a string that describes a circle in ds9 format. Parameters ---------- line : str A string containing a DS9 region command for a circle. Returns ------- circle : [ra, dec, radius] The center and radius of the circle.
entailment
def poly2poly(line): """ Parse a string of text containing a DS9 description of a polygon. This function works but is not very robust due to the constraints of healpy. Parameters ---------- line : str A string containing a DS9 region command for a polygon. Returns ------- poly : [ra, dec, ...] The coordinates of the polygon. """ words = re.split('[(\s,)]', line) ras = np.array(words[1::2]) decs = np.array(words[2::2]) coords = [] for ra, dec in zip(ras, decs): if ra.strip() == '' or dec.strip() == '': continue if ":" in ra: pos = SkyCoord(Angle(ra, unit=u.hour), Angle(dec, unit=u.degree)) else: pos = SkyCoord(Angle(ra, unit=u.degree), Angle(dec, unit=u.degree)) # only add this point if it is some distance from the previous one coords.extend([pos.ra.degree, pos.dec.degree]) return coords
Parse a string of text containing a DS9 description of a polygon. This function works but is not very robust due to the constraints of healpy. Parameters ---------- line : str A string containing a DS9 region command for a polygon. Returns ------- poly : [ra, dec, ...] The coordinates of the polygon.
entailment
def reg2mim(regfile, mimfile, maxdepth): """ Parse a DS9 region file and write a MIMAS region (.mim) file. Parameters ---------- regfile : str DS9 region (.reg) file. mimfile : str MIMAS region (.mim) file. maxdepth : str Depth/resolution of the region file. """ logging.info("Reading regions from {0}".format(regfile)) lines = (l for l in open(regfile, 'r') if not l.startswith('#')) poly = [] circles = [] for line in lines: if line.startswith('box'): poly.append(box2poly(line)) elif line.startswith('circle'): circles.append(circle2circle(line)) elif line.startswith('polygon'): logging.warning("Polygons break a lot, but I'll try this one anyway.") poly.append(poly2poly(line)) else: logging.warning("Not sure what to do with {0}".format(line[:-1])) container = Dummy(maxdepth=maxdepth) container.include_circles = circles container.include_polygons = poly region = combine_regions(container) save_region(region, mimfile) return
Parse a DS9 region file and write a MIMAS region (.mim) file. Parameters ---------- regfile : str DS9 region (.reg) file. mimfile : str MIMAS region (.mim) file. maxdepth : str Depth/resolution of the region file.
entailment
def combine_regions(container): """ Return a region that is the combination of those specified in the container. The container is typically a results instance that comes from argparse. Order of construction is: add regions, subtract regions, add circles, subtract circles, add polygons, subtract polygons. Parameters ---------- container : :class:`AegeanTools.MIMAS.Dummy` The regions to be combined. Returns ------- region : :class:`AegeanTools.regions.Region` The constructed region. """ # create empty region region = Region(container.maxdepth) # add/rem all the regions from files for r in container.add_region: logging.info("adding region from {0}".format(r)) r2 = Region.load(r[0]) region.union(r2) for r in container.rem_region: logging.info("removing region from {0}".format(r)) r2 = Region.load(r[0]) region.without(r2) # add circles if len(container.include_circles) > 0: for c in container.include_circles: circles = np.radians(np.array(c)) if container.galactic: l, b, radii = circles.reshape(3, circles.shape[0]//3) ras, decs = galactic2fk5(l, b) else: ras, decs, radii = circles.reshape(3, circles.shape[0]//3) region.add_circles(ras, decs, radii) # remove circles if len(container.exclude_circles) > 0: for c in container.exclude_circles: r2 = Region(container.maxdepth) circles = np.radians(np.array(c)) if container.galactic: l, b, radii = circles.reshape(3, circles.shape[0]//3) ras, decs = galactic2fk5(l, b) else: ras, decs, radii = circles.reshape(3, circles.shape[0]//3) r2.add_circles(ras, decs, radii) region.without(r2) # add polygons if len(container.include_polygons) > 0: for p in container.include_polygons: poly = np.radians(np.array(p)) poly = poly.reshape((poly.shape[0]//2, 2)) region.add_poly(poly) # remove polygons if len(container.exclude_polygons) > 0: for p in container.include_polygons: poly = np.array(np.radians(p)) r2 = Region(container.maxdepth) r2.add_poly(poly) region.without(r2) return region
Return a region that is the combination of those specified in the container. The container is typically a results instance that comes from argparse. Order of construction is: add regions, subtract regions, add circles, subtract circles, add polygons, subtract polygons. Parameters ---------- container : :class:`AegeanTools.MIMAS.Dummy` The regions to be combined. Returns ------- region : :class:`AegeanTools.regions.Region` The constructed region.
entailment
def intersect_regions(flist): """ Construct a region which is the intersection of all regions described in the given list of file names. Parameters ---------- flist : list A list of region filenames. Returns ------- region : :class:`AegeanTools.regions.Region` The intersection of all regions, possibly empty. """ if len(flist) < 2: raise Exception("Require at least two regions to perform intersection") a = Region.load(flist[0]) for b in [Region.load(f) for f in flist[1:]]: a.intersect(b) return a
Construct a region which is the intersection of all regions described in the given list of file names. Parameters ---------- flist : list A list of region filenames. Returns ------- region : :class:`AegeanTools.regions.Region` The intersection of all regions, possibly empty.
entailment
def save_region(region, filename): """ Save the given region to a file Parameters ---------- region : :class:`AegeanTools.regions.Region` A region. filename : str Output file name. """ region.save(filename) logging.info("Wrote {0}".format(filename)) return
Save the given region to a file Parameters ---------- region : :class:`AegeanTools.regions.Region` A region. filename : str Output file name.
entailment
def save_as_image(region, filename): """ Convert a MIMAS region (.mim) file into a image (eg .png) Parameters ---------- region : :class:`AegeanTools.regions.Region` Region of interest. filename : str Output filename. """ import healpy as hp pixels = list(region.get_demoted()) order = region.maxdepth m = np.arange(hp.nside2npix(2**order)) m[:] = 0 m[pixels] = 1 hp.write_map(filename, m, nest=True, coord='C') return
Convert a MIMAS region (.mim) file into a image (eg .png) Parameters ---------- region : :class:`AegeanTools.regions.Region` Region of interest. filename : str Output filename.
entailment
def get_pixinfo(header): """ Return some pixel information based on the given hdu header pixarea - the area of a single pixel in deg2 pixscale - the side lengths of a pixel (assuming they are square) Parameters ---------- header : HDUHeader or dict FITS header information Returns ------- pixarea : float The are of a single pixel at the reference location, in square degrees. pixscale : (float, float) The pixel scale in degrees, at the reference location. Notes ----- The reference location is not always at the image center, and the pixel scale/area may change over the image, depending on the projection. """ if all(a in header for a in ["CDELT1", "CDELT2"]): pixarea = abs(header["CDELT1"]*header["CDELT2"]) pixscale = (header["CDELT1"], header["CDELT2"]) elif all(a in header for a in ["CD1_1", "CD1_2", "CD2_1", "CD2_2"]): pixarea = abs(header["CD1_1"]*header["CD2_2"] - header["CD1_2"]*header["CD2_1"]) pixscale = (header["CD1_1"], header["CD2_2"]) if not (header["CD1_2"] == 0 and header["CD2_1"] == 0): log.warning("Pixels don't appear to be square -> pixscale is wrong") elif all(a in header for a in ["CD1_1", "CD2_2"]): pixarea = abs(header["CD1_1"]*header["CD2_2"]) pixscale = (header["CD1_1"], header["CD2_2"]) else: log.critical("cannot determine pixel area, using zero EVEN THOUGH THIS IS WRONG!") pixarea = 0 pixscale = (0, 0) return pixarea, pixscale
Return some pixel information based on the given hdu header pixarea - the area of a single pixel in deg2 pixscale - the side lengths of a pixel (assuming they are square) Parameters ---------- header : HDUHeader or dict FITS header information Returns ------- pixarea : float The are of a single pixel at the reference location, in square degrees. pixscale : (float, float) The pixel scale in degrees, at the reference location. Notes ----- The reference location is not always at the image center, and the pixel scale/area may change over the image, depending on the projection.
entailment
def get_beam(header): """ Create a :class:`AegeanTools.fits_image.Beam` object from a fits header. BPA may be missing but will be assumed to be zero. if BMAJ or BMIN are missing then return None instead of a beam object. Parameters ---------- header : HDUHeader The fits header. Returns ------- beam : :class:`AegeanTools.fits_image.Beam` Beam object, with a, b, and pa in degrees. """ if "BPA" not in header: log.warning("BPA not present in fits header, using 0") bpa = 0 else: bpa = header["BPA"] if "BMAJ" not in header: log.warning("BMAJ not present in fits header.") bmaj = None else: bmaj = header["BMAJ"] if "BMIN" not in header: log.warning("BMIN not present in fits header.") bmin = None else: bmin = header["BMIN"] if None in [bmaj, bmin, bpa]: return None beam = Beam(bmaj, bmin, bpa) return beam
Create a :class:`AegeanTools.fits_image.Beam` object from a fits header. BPA may be missing but will be assumed to be zero. if BMAJ or BMIN are missing then return None instead of a beam object. Parameters ---------- header : HDUHeader The fits header. Returns ------- beam : :class:`AegeanTools.fits_image.Beam` Beam object, with a, b, and pa in degrees.
entailment
def fix_aips_header(header): """ Search through an image header. If the keywords BMAJ/BMIN/BPA are not set, but there are AIPS history cards, then we can populate the BMAJ/BMIN/BPA. Fix the header if possible, otherwise don't. Either way, don't complain. Parameters ---------- header : HDUHeader Fits header which may or may not have AIPS history cards. Returns ------- header : HDUHeader A header which has BMAJ, BMIN, and BPA keys, as well as a new HISTORY card. """ if 'BMAJ' in header and 'BMIN' in header and 'BPA' in header: # The header already has the required keys so there is nothing to do return header aips_hist = [a for a in header['HISTORY'] if a.startswith("AIPS")] if len(aips_hist) == 0: # There are no AIPS history items to process return header for a in aips_hist: if "BMAJ" in a: # this line looks like # 'AIPS CLEAN BMAJ= 1.2500E-02 BMIN= 1.2500E-02 BPA= 0.00' words = a.split() bmaj = float(words[3]) bmin = float(words[5]) bpa = float(words[7]) break else: # there are AIPS cards but there is no BMAJ/BMIN/BPA return header header['BMAJ'] = bmaj header['BMIN'] = bmin header['BPA'] = bpa header['HISTORY'] = 'Beam information AIPS->fits by AegeanTools' return header
Search through an image header. If the keywords BMAJ/BMIN/BPA are not set, but there are AIPS history cards, then we can populate the BMAJ/BMIN/BPA. Fix the header if possible, otherwise don't. Either way, don't complain. Parameters ---------- header : HDUHeader Fits header which may or may not have AIPS history cards. Returns ------- header : HDUHeader A header which has BMAJ, BMIN, and BPA keys, as well as a new HISTORY card.
entailment
def set_pixels(self, pixels): """ Set the image data. Will not work if the new image has a different shape than the current image. Parameters ---------- pixels : numpy.ndarray New image data Returns ------- None """ if not (pixels.shape == self._pixels.shape): raise AssertionError("Shape mismatch between pixels supplied {0} and existing image pixels {1}".format(pixels.shape,self._pixels.shape)) self._pixels = pixels # reset this so that it is calculated next time the function is called self._rms = None return
Set the image data. Will not work if the new image has a different shape than the current image. Parameters ---------- pixels : numpy.ndarray New image data Returns ------- None
entailment
def get_background_rms(self): """ Calculate the rms of the image. The rms is calculated from the interqurtile range (IQR), to reduce bias from source pixels. Returns ------- rms : float The image rms. Notes ----- The rms value is cached after first calculation. """ # TODO: return a proper background RMS ignoring the sources # This is an approximate method suggested by PaulH. # I have no idea where this magic 1.34896 number comes from... if self._rms is None: # Get the pixels values without the NaNs data = numpy.extract(self.hdu.data > -9999999, self.hdu.data) p25 = scipy.stats.scoreatpercentile(data, 25) p75 = scipy.stats.scoreatpercentile(data, 75) iqr = p75 - p25 self._rms = iqr / 1.34896 return self._rms
Calculate the rms of the image. The rms is calculated from the interqurtile range (IQR), to reduce bias from source pixels. Returns ------- rms : float The image rms. Notes ----- The rms value is cached after first calculation.
entailment
def pix2sky(self, pixel): """ Get the sky coordinates for a given image pixel. Parameters ---------- pixel : (float, float) Image coordinates. Returns ------- ra,dec : float Sky coordinates (degrees) """ pixbox = numpy.array([pixel, pixel]) skybox = self.wcs.all_pix2world(pixbox, 1) return [float(skybox[0][0]), float(skybox[0][1])]
Get the sky coordinates for a given image pixel. Parameters ---------- pixel : (float, float) Image coordinates. Returns ------- ra,dec : float Sky coordinates (degrees)
entailment
def sky2pix(self, skypos): """ Get the pixel coordinates for a given sky position (degrees). Parameters ---------- skypos : (float,float) ra,dec position in degrees. Returns ------- x,y : float Pixel coordinates. """ skybox = [skypos, skypos] pixbox = self.wcs.all_world2pix(skybox, 1) return [float(pixbox[0][0]), float(pixbox[0][1])]
Get the pixel coordinates for a given sky position (degrees). Parameters ---------- skypos : (float,float) ra,dec position in degrees. Returns ------- x,y : float Pixel coordinates.
entailment
def load_sources(filename): """ Open a file, read contents, return a list of all the sources in that file. @param filename: @return: list of OutputSource objects """ catalog = catalogs.table_to_source_list(catalogs.load_table(filename)) logging.info("read {0} sources from {1}".format(len(catalog), filename)) return catalog
Open a file, read contents, return a list of all the sources in that file. @param filename: @return: list of OutputSource objects
entailment
def search_beam(hdulist): """ Will search the beam info from the HISTORY :param hdulist: :return: """ header = hdulist[0].header history = header['HISTORY'] history_str = str(history) #AIPS CLEAN BMAJ= 1.2500E-02 BMIN= 1.2500E-02 BPA= 0.00 if 'BMAJ' in history_str: return True else: return False
Will search the beam info from the HISTORY :param hdulist: :return:
entailment
def fix_shape(source): """ Ensure that a>=b for a given source object. If a<b then swap a/b and increment pa by 90. err_a/err_b are also swapped as needed. Parameters ---------- source : object any object with a/b/pa/err_a/err_b properties """ if source.a < source.b: source.a, source.b = source.b, source.a source.err_a, source.err_b = source.err_b, source.err_a source.pa += 90 return
Ensure that a>=b for a given source object. If a<b then swap a/b and increment pa by 90. err_a/err_b are also swapped as needed. Parameters ---------- source : object any object with a/b/pa/err_a/err_b properties
entailment
def theta_limit(theta): """ Angle theta is periodic with period pi. Constrain theta such that -pi/2<theta<=pi/2. Parameters ---------- theta : float Input angle. Returns ------- theta : float Rotate angle. """ while theta <= -1 * np.pi / 2: theta += np.pi while theta > np.pi / 2: theta -= np.pi return theta
Angle theta is periodic with period pi. Constrain theta such that -pi/2<theta<=pi/2. Parameters ---------- theta : float Input angle. Returns ------- theta : float Rotate angle.
entailment
def scope2lat(telescope): """ Convert a telescope name into a latitude returns None when the telescope is unknown. Parameters ---------- telescope : str Acronym (name) of telescope, eg MWA. Returns ------- lat : float The latitude of the telescope. Notes ----- These values were taken from wikipedia so have varying precision/accuracy """ scopes = {'MWA': -26.703319, "ATCA": -30.3128, "VLA": 34.0790, "LOFAR": 52.9088, "KAT7": -30.721, "MEERKAT": -30.721, "PAPER": -30.7224, "GMRT": 19.096516666667, "OOTY": 11.383404, "ASKAP": -26.7, "MOST": -35.3707, "PARKES": -32.999944, "WSRT": 52.914722, "AMILA": 52.16977, "AMISA": 52.164303, "ATA": 40.817, "CHIME": 49.321, "CARMA": 37.28044, "DRAO": 49.321, "GBT": 38.433056, "LWA": 34.07, "ALMA": -23.019283, "FAST": 25.6525 } if telescope.upper() in scopes: return scopes[telescope.upper()] else: log = logging.getLogger("Aegean") log.warn("Telescope {0} is unknown".format(telescope)) log.warn("integrated fluxes may be incorrect") return None
Convert a telescope name into a latitude returns None when the telescope is unknown. Parameters ---------- telescope : str Acronym (name) of telescope, eg MWA. Returns ------- lat : float The latitude of the telescope. Notes ----- These values were taken from wikipedia so have varying precision/accuracy
entailment
def check_cores(cores): """ Determine how many cores we are able to use. Return 1 if we are not able to make a queue via pprocess. Parameters ---------- cores : int The number of cores that are requested. Returns ------- cores : int The number of cores available. """ cores = min(multiprocessing.cpu_count(), cores) if six.PY3: log = logging.getLogger("Aegean") log.info("Multi-cores not supported in python 3+, using one core") return 1 try: queue = pprocess.Queue(limit=cores, reuse=1) except: # TODO: figure out what error is being thrown cores = 1 else: try: _ = queue.manage(pprocess.MakeReusable(fix_shape)) except: cores = 1 return cores
Determine how many cores we are able to use. Return 1 if we are not able to make a queue via pprocess. Parameters ---------- cores : int The number of cores that are requested. Returns ------- cores : int The number of cores available.
entailment