repository_name
stringlengths 7
55
| func_path_in_repository
stringlengths 4
223
| func_name
stringlengths 1
134
| whole_func_string
stringlengths 75
104k
| language
stringclasses 1
value | func_code_string
stringlengths 75
104k
| func_code_tokens
listlengths 19
28.4k
| func_documentation_string
stringlengths 1
46.9k
| func_documentation_tokens
listlengths 1
1.97k
| split_name
stringclasses 1
value | func_code_url
stringlengths 87
315
|
|---|---|---|---|---|---|---|---|---|---|---|
PaulHancock/Aegean
|
AegeanTools/regions.py
|
Region.sky_within
|
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
|
python
|
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
|
[
"def",
"sky_within",
"(",
"self",
",",
"ra",
",",
"dec",
",",
"degin",
"=",
"False",
")",
":",
"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.
|
[
"Test",
"whether",
"a",
"sky",
"position",
"is",
"within",
"this",
"region"
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/regions.py#L223-L257
|
PaulHancock/Aegean
|
AegeanTools/regions.py
|
Region.union
|
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
|
python
|
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
|
[
"def",
"union",
"(",
"self",
",",
"other",
",",
"renorm",
"=",
"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.
|
[
"Add",
"another",
"Region",
"by",
"performing",
"union",
"on",
"their",
"pixlists",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/regions.py#L259-L285
|
PaulHancock/Aegean
|
AegeanTools/regions.py
|
Region.without
|
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
|
python
|
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
|
[
"def",
"without",
"(",
"self",
",",
"other",
")",
":",
"# 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.
|
[
"Subtract",
"another",
"Region",
"by",
"performing",
"a",
"difference",
"operation",
"on",
"their",
"pixlists",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/regions.py#L287-L305
|
PaulHancock/Aegean
|
AegeanTools/regions.py
|
Region.intersect
|
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
|
python
|
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
|
[
"def",
"intersect",
"(",
"self",
",",
"other",
")",
":",
"# 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.
|
[
"Combine",
"with",
"another",
"Region",
"by",
"performing",
"intersection",
"on",
"their",
"pixlists",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/regions.py#L307-L325
|
PaulHancock/Aegean
|
AegeanTools/regions.py
|
Region.symmetric_difference
|
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
|
python
|
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
|
[
"def",
"symmetric_difference",
"(",
"self",
",",
"other",
")",
":",
"# 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.
|
[
"Combine",
"with",
"another",
"Region",
"by",
"performing",
"the",
"symmetric",
"difference",
"of",
"their",
"pixlists",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/regions.py#L327-L345
|
PaulHancock/Aegean
|
AegeanTools/regions.py
|
Region.write_reg
|
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
|
python
|
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
|
[
"def",
"write_reg",
"(",
"self",
",",
"filename",
")",
":",
"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
|
[
"Write",
"a",
"ds9",
"region",
"file",
"that",
"represents",
"this",
"region",
"as",
"a",
"set",
"of",
"diamonds",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/regions.py#L347-L371
|
PaulHancock/Aegean
|
AegeanTools/regions.py
|
Region.write_fits
|
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
|
python
|
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
|
[
"def",
"write_fits",
"(",
"self",
",",
"filename",
",",
"moctool",
"=",
"''",
")",
":",
"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 = ''
|
[
"Write",
"a",
"fits",
"file",
"representing",
"the",
"MOC",
"of",
"this",
"region",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/regions.py#L373-L402
|
PaulHancock/Aegean
|
AegeanTools/regions.py
|
Region._uniq
|
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)
|
python
|
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)
|
[
"def",
"_uniq",
"(",
"self",
")",
":",
"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.
|
[
"Create",
"a",
"list",
"of",
"all",
"the",
"pixels",
"that",
"cover",
"this",
"region",
".",
"This",
"list",
"contains",
"overlapping",
"pixels",
"of",
"different",
"orders",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/regions.py#L404-L417
|
PaulHancock/Aegean
|
AegeanTools/regions.py
|
Region.radec2sky
|
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
|
python
|
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
|
[
"def",
"radec2sky",
"(",
"ra",
",",
"dec",
")",
":",
"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.
|
[
"Convert",
"[",
"ra",
"]",
"[",
"dec",
"]",
"to",
"[",
"(",
"ra",
"[",
"0",
"]",
"dec",
"[",
"0",
"]",
")",
"....",
"]",
"and",
"also",
"ra",
"dec",
"to",
"[",
"(",
"ra",
"dec",
")",
"]",
"if",
"ra",
"/",
"dec",
"are",
"not",
"iterable"
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/regions.py#L420-L439
|
PaulHancock/Aegean
|
AegeanTools/regions.py
|
Region.sky2ang
|
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
|
python
|
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
|
[
"def",
"sky2ang",
"(",
"sky",
")",
":",
"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.
|
[
"Convert",
"ra",
"dec",
"coordinates",
"to",
"theta",
"phi",
"coordinates",
"ra",
"-",
">",
"phi",
"dec",
"-",
">",
"theta"
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/regions.py#L442-L469
|
PaulHancock/Aegean
|
AegeanTools/regions.py
|
Region.sky2vec
|
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
|
python
|
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
|
[
"def",
"sky2vec",
"(",
"cls",
",",
"sky",
")",
":",
"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`
|
[
"Convert",
"sky",
"positions",
"in",
"to",
"3d",
"-",
"vectors",
"on",
"the",
"unit",
"sphere",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/regions.py#L472-L493
|
PaulHancock/Aegean
|
AegeanTools/regions.py
|
Region.vec2sky
|
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)
|
python
|
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)
|
[
"def",
"vec2sky",
"(",
"cls",
",",
"vec",
",",
"degrees",
"=",
"False",
")",
":",
"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`
|
[
"Convert",
"[",
"x",
"y",
"z",
"]",
"vectors",
"into",
"sky",
"coordinates",
"ra",
"dec"
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/regions.py#L496-L523
|
PaulHancock/Aegean
|
AegeanTools/wcs_helpers.py
|
WCSHelper.from_header
|
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)
|
python
|
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)
|
[
"def",
"from_header",
"(",
"cls",
",",
"header",
",",
"beam",
"=",
"None",
",",
"lat",
"=",
"None",
")",
":",
"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.
|
[
"Create",
"a",
"new",
"WCSHelper",
"class",
"from",
"the",
"given",
"header",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L62-L97
|
PaulHancock/Aegean
|
AegeanTools/wcs_helpers.py
|
WCSHelper.from_file
|
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)
|
python
|
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)
|
[
"def",
"from_file",
"(",
"cls",
",",
"filename",
",",
"beam",
"=",
"None",
")",
":",
"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
|
[
"Create",
"a",
"new",
"WCSHelper",
"class",
"from",
"a",
"given",
"fits",
"file",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L100-L118
|
PaulHancock/Aegean
|
AegeanTools/wcs_helpers.py
|
WCSHelper.pix2sky
|
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]
|
python
|
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]
|
[
"def",
"pix2sky",
"(",
"self",
",",
"pixel",
")",
":",
"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
|
[
"Convert",
"pixel",
"coordinates",
"into",
"sky",
"coordinates",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L120-L137
|
PaulHancock/Aegean
|
AegeanTools/wcs_helpers.py
|
WCSHelper.sky2pix
|
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]]
|
python
|
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]]
|
[
"def",
"sky2pix",
"(",
"self",
",",
"pos",
")",
":",
"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
|
[
"Convert",
"sky",
"coordinates",
"into",
"pixel",
"coordinates",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L139-L156
|
PaulHancock/Aegean
|
AegeanTools/wcs_helpers.py
|
WCSHelper.sky2pix_vec
|
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
|
python
|
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
|
[
"def",
"sky2pix_vec",
"(",
"self",
",",
"pos",
",",
"r",
",",
"pa",
")",
":",
"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.
|
[
"Convert",
"a",
"vector",
"from",
"sky",
"to",
"pixel",
"coords",
".",
"The",
"vector",
"has",
"a",
"magnitude",
"angle",
"and",
"an",
"origin",
"on",
"the",
"sky",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L158-L189
|
PaulHancock/Aegean
|
AegeanTools/wcs_helpers.py
|
WCSHelper.pix2sky_vec
|
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
|
python
|
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
|
[
"def",
"pix2sky_vec",
"(",
"self",
",",
"pixel",
",",
"r",
",",
"theta",
")",
":",
"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).
|
[
"Given",
"and",
"input",
"position",
"and",
"vector",
"in",
"pixel",
"coordinates",
"calculate",
"the",
"equivalent",
"position",
"and",
"vector",
"in",
"sky",
"coordinates",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L191-L220
|
PaulHancock/Aegean
|
AegeanTools/wcs_helpers.py
|
WCSHelper.sky2pix_ellipse
|
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)
|
python
|
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)
|
[
"def",
"sky2pix_ellipse",
"(",
"self",
",",
"pos",
",",
"a",
",",
"b",
",",
"pa",
")",
":",
"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.
|
[
"Convert",
"an",
"ellipse",
"from",
"sky",
"to",
"pixel",
"coordinates",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L222-L261
|
PaulHancock/Aegean
|
AegeanTools/wcs_helpers.py
|
WCSHelper.pix2sky_ellipse
|
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
|
python
|
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
|
[
"def",
"pix2sky_ellipse",
"(",
"self",
",",
"pixel",
",",
"sx",
",",
"sy",
",",
"theta",
")",
":",
"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).
|
[
"Convert",
"an",
"ellipse",
"from",
"pixel",
"to",
"sky",
"coordinates",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L263-L307
|
PaulHancock/Aegean
|
AegeanTools/wcs_helpers.py
|
WCSHelper.get_pixbeam_pixel
|
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)
|
python
|
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)
|
[
"def",
"get_pixbeam_pixel",
"(",
"self",
",",
"x",
",",
"y",
")",
":",
"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.
|
[
"Determine",
"the",
"beam",
"in",
"pixels",
"at",
"the",
"given",
"location",
"in",
"pixel",
"coordinates",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L309-L324
|
PaulHancock/Aegean
|
AegeanTools/wcs_helpers.py
|
WCSHelper.get_beam
|
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)
|
python
|
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)
|
[
"def",
"get_beam",
"(",
"self",
",",
"ra",
",",
"dec",
")",
":",
"# 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
|
[
"Determine",
"the",
"beam",
"at",
"the",
"given",
"sky",
"location",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L326-L346
|
PaulHancock/Aegean
|
AegeanTools/wcs_helpers.py
|
WCSHelper.get_pixbeam
|
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
|
python
|
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
|
[
"def",
"get_pixbeam",
"(",
"self",
",",
"ra",
",",
"dec",
")",
":",
"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.
|
[
"Determine",
"the",
"beam",
"in",
"pixels",
"at",
"the",
"given",
"location",
"in",
"sky",
"coordinates",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L348-L381
|
PaulHancock/Aegean
|
AegeanTools/wcs_helpers.py
|
WCSHelper.get_beamarea_deg2
|
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
|
python
|
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
|
[
"def",
"get_beamarea_deg2",
"(",
"self",
",",
"ra",
",",
"dec",
")",
":",
"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.
|
[
"Calculate",
"the",
"area",
"of",
"the",
"synthesized",
"beam",
"in",
"square",
"degrees",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L383-L400
|
PaulHancock/Aegean
|
AegeanTools/wcs_helpers.py
|
WCSHelper.get_beamarea_pix
|
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
|
python
|
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
|
[
"def",
"get_beamarea_pix",
"(",
"self",
",",
"ra",
",",
"dec",
")",
":",
"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.
|
[
"Calculate",
"the",
"beam",
"area",
"in",
"square",
"pixels",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L402-L419
|
PaulHancock/Aegean
|
AegeanTools/wcs_helpers.py
|
WCSHelper.sky_sep
|
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
|
python
|
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
|
[
"def",
"sky_sep",
"(",
"self",
",",
"pix1",
",",
"pix2",
")",
":",
"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).
|
[
"calculate",
"the",
"GCD",
"sky",
"separation",
"(",
"degrees",
")",
"between",
"two",
"pixels",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L421-L438
|
PaulHancock/Aegean
|
AegeanTools/wcs_helpers.py
|
PSFHelper.get_psf_sky
|
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
|
python
|
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
|
[
"def",
"get_psf_sky",
"(",
"self",
",",
"ra",
",",
"dec",
")",
":",
"# 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.
|
[
"Determine",
"the",
"local",
"psf",
"at",
"a",
"given",
"sky",
"location",
".",
"The",
"psf",
"is",
"returned",
"in",
"degrees",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L474-L504
|
PaulHancock/Aegean
|
AegeanTools/wcs_helpers.py
|
PSFHelper.get_psf_pix
|
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
|
python
|
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
|
[
"def",
"get_psf_pix",
"(",
"self",
",",
"ra",
",",
"dec",
")",
":",
"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.
|
[
"Determine",
"the",
"local",
"psf",
"(",
"a",
"b",
"pa",
")",
"at",
"a",
"given",
"sky",
"location",
".",
"The",
"psf",
"is",
"in",
"pixel",
"coordinates",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L506-L527
|
PaulHancock/Aegean
|
AegeanTools/wcs_helpers.py
|
PSFHelper.get_pixbeam
|
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])
|
python
|
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])
|
[
"def",
"get_pixbeam",
"(",
"self",
",",
"ra",
",",
"dec",
")",
":",
"# 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.
|
[
"Get",
"the",
"psf",
"at",
"the",
"location",
"specified",
"in",
"pixel",
"coordinates",
".",
"The",
"psf",
"is",
"also",
"in",
"pixel",
"coordinates",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L552-L578
|
PaulHancock/Aegean
|
AegeanTools/wcs_helpers.py
|
PSFHelper.get_beam
|
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])
|
python
|
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])
|
[
"def",
"get_beam",
"(",
"self",
",",
"ra",
",",
"dec",
")",
":",
"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.
|
[
"Get",
"the",
"psf",
"as",
"a",
":",
"class",
":",
"AegeanTools",
".",
"fits_image",
".",
"Beam",
"object",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L580-L600
|
PaulHancock/Aegean
|
AegeanTools/wcs_helpers.py
|
PSFHelper.get_beamarea_pix
|
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
|
python
|
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
|
[
"def",
"get_beamarea_pix",
"(",
"self",
",",
"ra",
",",
"dec",
")",
":",
"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.
|
[
"Calculate",
"the",
"area",
"of",
"the",
"beam",
"in",
"square",
"pixels",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L602-L619
|
PaulHancock/Aegean
|
AegeanTools/wcs_helpers.py
|
PSFHelper.get_beamarea_deg2
|
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
|
python
|
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
|
[
"def",
"get_beamarea_deg2",
"(",
"self",
",",
"ra",
",",
"dec",
")",
":",
"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.
|
[
"Calculate",
"the",
"area",
"of",
"the",
"beam",
"in",
"square",
"degrees",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L621-L639
|
PaulHancock/Aegean
|
AegeanTools/msq2.py
|
MarchingSquares.find_start_point
|
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
|
python
|
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
|
[
"def",
"find_start_point",
"(",
"self",
")",
":",
"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
|
[
"Find",
"the",
"first",
"location",
"in",
"our",
"array",
"that",
"is",
"not",
"empty"
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/msq2.py#L36-L43
|
PaulHancock/Aegean
|
AegeanTools/msq2.py
|
MarchingSquares.step
|
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
|
python
|
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
|
[
"def",
"step",
"(",
"self",
",",
"x",
",",
"y",
")",
":",
"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
|
[
"Move",
"from",
"the",
"current",
"location",
"to",
"the",
"next"
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/msq2.py#L45-L92
|
PaulHancock/Aegean
|
AegeanTools/msq2.py
|
MarchingSquares.solid
|
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
|
python
|
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
|
[
"def",
"solid",
"(",
"self",
",",
"x",
",",
"y",
")",
":",
"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.
|
[
"Determine",
"whether",
"the",
"pixel",
"x",
"y",
"is",
"nonzero"
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/msq2.py#L94-L112
|
PaulHancock/Aegean
|
AegeanTools/msq2.py
|
MarchingSquares.walk_perimeter
|
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
|
python
|
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
|
[
"def",
"walk_perimeter",
"(",
"self",
",",
"startx",
",",
"starty",
")",
":",
"# 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.
|
[
"Starting",
"at",
"a",
"point",
"on",
"the",
"perimeter",
"of",
"a",
"region",
"walk",
"the",
"perimeter",
"to",
"return",
"to",
"the",
"starting",
"point",
".",
"Record",
"the",
"path",
"taken",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/msq2.py#L114-L157
|
PaulHancock/Aegean
|
AegeanTools/msq2.py
|
MarchingSquares.do_march
|
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
|
python
|
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
|
[
"def",
"do_march",
"(",
"self",
")",
":",
"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], ...]
|
[
"March",
"about",
"and",
"trace",
"the",
"outline",
"of",
"our",
"object"
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/msq2.py#L159-L170
|
PaulHancock/Aegean
|
AegeanTools/msq2.py
|
MarchingSquares._blank_within
|
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
|
python
|
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
|
[
"def",
"_blank_within",
"(",
"self",
",",
"perimeter",
")",
":",
"# 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.
|
[
"Blank",
"all",
"the",
"pixels",
"within",
"the",
"given",
"perimeter",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/msq2.py#L172-L205
|
PaulHancock/Aegean
|
AegeanTools/msq2.py
|
MarchingSquares.do_march_all
|
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
|
python
|
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
|
[
"def",
"do_march_all",
"(",
"self",
")",
":",
"# 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`
|
[
"Recursive",
"march",
"in",
"the",
"case",
"that",
"we",
"have",
"a",
"fragmented",
"shape",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/msq2.py#L207-L236
|
PaulHancock/Aegean
|
AegeanTools/fitting.py
|
elliptical_gaussian
|
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)
|
python
|
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)
|
[
"def",
"elliptical_gaussian",
"(",
"x",
",",
"y",
",",
"amp",
",",
"xo",
",",
"yo",
",",
"sx",
",",
"sy",
",",
"theta",
")",
":",
"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.
|
[
"Generate",
"a",
"model",
"2d",
"Gaussian",
"with",
"the",
"given",
"parameters",
".",
"Evaluate",
"this",
"model",
"at",
"the",
"given",
"locations",
"x",
"y",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L30-L63
|
PaulHancock/Aegean
|
AegeanTools/fitting.py
|
Cmatrix
|
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
|
python
|
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
|
[
"def",
"Cmatrix",
"(",
"x",
",",
"y",
",",
"sx",
",",
"sy",
",",
"theta",
")",
":",
"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.
|
[
"Construct",
"a",
"correlation",
"matrix",
"corresponding",
"to",
"the",
"data",
".",
"The",
"matrix",
"assumes",
"a",
"gaussian",
"correlation",
"function",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L66-L87
|
PaulHancock/Aegean
|
AegeanTools/fitting.py
|
Bmatrix
|
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
|
python
|
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
|
[
"def",
"Bmatrix",
"(",
"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)
|
[
"Calculate",
"a",
"matrix",
"which",
"is",
"effectively",
"the",
"square",
"root",
"of",
"the",
"correlation",
"matrix",
"C"
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L90-L113
|
PaulHancock/Aegean
|
AegeanTools/fitting.py
|
jacobian
|
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)
|
python
|
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)
|
[
"def",
"jacobian",
"(",
"pars",
",",
"x",
",",
"y",
")",
":",
"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`
|
[
"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",
")",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L116-L188
|
PaulHancock/Aegean
|
AegeanTools/fitting.py
|
lmfit_jacobian
|
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
|
python
|
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
|
[
"def",
"lmfit_jacobian",
"(",
"pars",
",",
"x",
",",
"y",
",",
"errs",
"=",
"None",
",",
"B",
"=",
"None",
",",
"emp",
"=",
"False",
")",
":",
"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`
|
[
"Wrapper",
"around",
":",
"func",
":",
"AegeanTools",
".",
"fitting",
".",
"jacobian",
"and",
":",
"func",
":",
"AegeanTools",
".",
"fitting",
".",
"emp_jacobian",
"which",
"gives",
"the",
"output",
"in",
"a",
"format",
"that",
"is",
"required",
"for",
"lmfit",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L228-L279
|
PaulHancock/Aegean
|
AegeanTools/fitting.py
|
hessian
|
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)
|
python
|
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)
|
[
"def",
"hessian",
"(",
"pars",
",",
"x",
",",
"y",
")",
":",
"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`
|
[
"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",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L282-L572
|
PaulHancock/Aegean
|
AegeanTools/fitting.py
|
emp_hessian
|
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
|
python
|
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
|
[
"def",
"emp_hessian",
"(",
"pars",
",",
"x",
",",
"y",
")",
":",
"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`
|
[
"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",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L575-L615
|
PaulHancock/Aegean
|
AegeanTools/fitting.py
|
nan_acf
|
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)
|
python
|
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)
|
[
"def",
"nan_acf",
"(",
"noise",
")",
":",
"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.
|
[
"Calculate",
"the",
"autocorrelation",
"function",
"of",
"the",
"noise",
"where",
"the",
"noise",
"is",
"a",
"2d",
"array",
"that",
"may",
"contain",
"nans"
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L618-L647
|
PaulHancock/Aegean
|
AegeanTools/fitting.py
|
make_ita
|
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
|
python
|
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
|
[
"def",
"make_ita",
"(",
"noise",
",",
"acf",
"=",
"None",
")",
":",
"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
|
[
"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",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L650-L682
|
PaulHancock/Aegean
|
AegeanTools/fitting.py
|
RB_bias
|
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
|
python
|
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
|
[
"def",
"RB_bias",
"(",
"data",
",",
"pars",
",",
"ita",
"=",
"None",
",",
"acf",
"=",
"None",
")",
":",
"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
|
[
"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",
")",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L685-L757
|
PaulHancock/Aegean
|
AegeanTools/fitting.py
|
bias_correct
|
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
|
python
|
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
|
[
"def",
"bias_correct",
"(",
"params",
",",
"data",
",",
"acf",
"=",
"None",
")",
":",
"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`
|
[
"Calculate",
"and",
"apply",
"a",
"bias",
"correction",
"to",
"the",
"given",
"fit",
"parameters"
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L760-L792
|
PaulHancock/Aegean
|
AegeanTools/fitting.py
|
condon_errors
|
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
|
python
|
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
|
[
"def",
"condon_errors",
"(",
"source",
",",
"theta_n",
",",
"psf",
"=",
"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
|
[
"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",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L795-L868
|
PaulHancock/Aegean
|
AegeanTools/fitting.py
|
errors
|
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
|
python
|
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
|
[
"def",
"errors",
"(",
"source",
",",
"model",
",",
"wcshelper",
")",
":",
"# 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.
|
[
"Convert",
"pixel",
"based",
"errors",
"into",
"sky",
"coord",
"errors"
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L871-L969
|
PaulHancock/Aegean
|
AegeanTools/fitting.py
|
new_errors
|
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
|
python
|
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
|
[
"def",
"new_errors",
"(",
"source",
",",
"model",
",",
"wcshelper",
")",
":",
"# pragma: no cover",
"# 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.
|
[
"Convert",
"pixel",
"based",
"errors",
"into",
"sky",
"coord",
"errors",
"Uses",
"covariance",
"matrix",
"for",
"ra",
"/",
"dec",
"errors",
"and",
"calculus",
"approach",
"to",
"a",
"/",
"b",
"/",
"pa",
"errors"
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L972-L1088
|
PaulHancock/Aegean
|
AegeanTools/fitting.py
|
ntwodgaussian_lmfit
|
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
|
python
|
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
|
[
"def",
"ntwodgaussian_lmfit",
"(",
"params",
")",
":",
"def",
"rfunc",
"(",
"x",
",",
"y",
")",
":",
"\"\"\"\n Compute the model given by params, at pixel coordinates x,y\n\n Parameters\n ----------\n x, y : numpy.ndarray\n The x/y pixel coordinates at which the model is being evaluated\n\n Returns\n -------\n result : numpy.ndarray\n Model\n \"\"\"",
"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.
|
[
"Convert",
"an",
"lmfit",
".",
"Parameters",
"object",
"into",
"a",
"function",
"which",
"calculates",
"the",
"model",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L1091-L1137
|
PaulHancock/Aegean
|
AegeanTools/fitting.py
|
do_lmfit
|
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
|
python
|
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
|
[
"def",
"do_lmfit",
"(",
"data",
",",
"params",
",",
"B",
"=",
"None",
",",
"errs",
"=",
"None",
",",
"dojac",
"=",
"True",
")",
":",
"# 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",
")",
":",
"\"\"\"\n The residual function required by lmfit\n\n Parameters\n ----------\n params: lmfit.Params\n The parameters of the model being fit\n\n Returns\n -------\n result : numpy.ndarray\n Model - Data\n \"\"\"",
"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`
|
[
"Fit",
"the",
"model",
"to",
"the",
"data",
"data",
"may",
"contain",
"flagged",
"or",
"masked",
"data",
"with",
"the",
"value",
"of",
"np",
".",
"NaN"
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L1140-L1210
|
PaulHancock/Aegean
|
AegeanTools/fitting.py
|
covar_errors
|
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
|
python
|
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
|
[
"def",
"covar_errors",
"(",
"params",
",",
"data",
",",
"errs",
",",
"B",
",",
"C",
"=",
"None",
")",
":",
"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.
|
[
"Take",
"a",
"set",
"of",
"parameters",
"that",
"were",
"fit",
"with",
"lmfit",
"and",
"replace",
"the",
"errors",
"with",
"the",
"1",
"\\",
"sigma",
"errors",
"calculated",
"using",
"the",
"covariance",
"matrix",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L1213-L1269
|
PaulHancock/Aegean
|
AegeanTools/BANE.py
|
barrier
|
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
|
python
|
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
|
[
"def",
"barrier",
"(",
"events",
",",
"sid",
",",
"kind",
"=",
"'neighbour'",
")",
":",
"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
|
[
"act",
"as",
"a",
"multiprocessing",
"barrier"
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/BANE.py#L34-L50
|
PaulHancock/Aegean
|
AegeanTools/BANE.py
|
sigmaclip
|
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
|
python
|
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
|
[
"def",
"sigmaclip",
"(",
"arr",
",",
"lo",
",",
"hi",
",",
"reps",
"=",
"3",
")",
":",
"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.
|
[
"Perform",
"sigma",
"clipping",
"on",
"an",
"array",
"ignoring",
"non",
"finite",
"values",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/BANE.py#L53-L102
|
PaulHancock/Aegean
|
AegeanTools/BANE.py
|
_sf2
|
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())))
|
python
|
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())))
|
[
"def",
"_sf2",
"(",
"args",
")",
":",
"# 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
|
[
"A",
"shallow",
"wrapper",
"for",
"sigma_filter",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/BANE.py#L105-L124
|
PaulHancock/Aegean
|
AegeanTools/BANE.py
|
sigma_filter
|
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
|
python
|
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
|
[
"def",
"sigma_filter",
"(",
"filename",
",",
"region",
",",
"step_size",
",",
"box_size",
",",
"shape",
",",
"domask",
",",
"sid",
")",
":",
"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",
")",
":",
"\"\"\"\n calculate the boundaries of the box centered at r,c\n with size = box_size\n \"\"\"",
"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
|
[
"Calculate",
"the",
"background",
"and",
"rms",
"for",
"a",
"sub",
"region",
"of",
"an",
"image",
".",
"The",
"results",
"are",
"written",
"to",
"shared",
"memory",
"-",
"irms",
"and",
"ibkg",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/BANE.py#L127-L267
|
PaulHancock/Aegean
|
AegeanTools/BANE.py
|
filter_mc_sharemem
|
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
|
python
|
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
|
[
"def",
"filter_mc_sharemem",
"(",
"filename",
",",
"step_size",
",",
"box_size",
",",
"cores",
",",
"shape",
",",
"nslice",
"=",
"None",
",",
"domask",
"=",
"True",
")",
":",
"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.
|
[
"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",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/BANE.py#L270-L363
|
PaulHancock/Aegean
|
AegeanTools/BANE.py
|
filter_image
|
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)
|
python
|
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)
|
[
"def",
"filter_image",
"(",
"im_name",
",",
"out_base",
",",
"step_size",
"=",
"None",
",",
"box_size",
"=",
"None",
",",
"twopass",
"=",
"False",
",",
"cores",
"=",
"None",
",",
"mask",
"=",
"True",
",",
"compressed",
"=",
"False",
",",
"nslice",
"=",
"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
|
[
"Create",
"a",
"background",
"and",
"noise",
"image",
"from",
"an",
"input",
"image",
".",
"Resulting",
"images",
"are",
"written",
"to",
"outbase_bkg",
".",
"fits",
"and",
"outbase_rms",
".",
"fits"
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/BANE.py#L366-L461
|
PaulHancock/Aegean
|
AegeanTools/BANE.py
|
write_fits
|
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
|
python
|
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
|
[
"def",
"write_fits",
"(",
"data",
",",
"header",
",",
"file_name",
")",
":",
"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
|
[
"Combine",
"data",
"and",
"a",
"fits",
"header",
"to",
"write",
"a",
"fits",
"file",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/BANE.py#L467-L491
|
PaulHancock/Aegean
|
AegeanTools/angle_tools.py
|
dec2dec
|
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
|
python
|
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
|
[
"def",
"dec2dec",
"(",
"dec",
")",
":",
"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.
|
[
"Convert",
"sexegessimal",
"RA",
"string",
"into",
"a",
"float",
"in",
"degrees",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/angle_tools.py#L38-L59
|
PaulHancock/Aegean
|
AegeanTools/angle_tools.py
|
dec2dms
|
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)
|
python
|
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)
|
[
"def",
"dec2dms",
"(",
"x",
")",
":",
"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.
|
[
"Convert",
"decimal",
"degrees",
"into",
"a",
"sexagessimal",
"string",
"in",
"degrees",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/angle_tools.py#L62-L87
|
PaulHancock/Aegean
|
AegeanTools/angle_tools.py
|
dec2hms
|
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)
|
python
|
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)
|
[
"def",
"dec2hms",
"(",
"x",
")",
":",
"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.
|
[
"Convert",
"decimal",
"degrees",
"into",
"a",
"sexagessimal",
"string",
"in",
"hours",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/angle_tools.py#L90-L115
|
PaulHancock/Aegean
|
AegeanTools/angle_tools.py
|
gcd
|
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
|
python
|
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
|
[
"def",
"gcd",
"(",
"ra1",
",",
"dec1",
",",
"ra2",
",",
"dec2",
")",
":",
"# 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>`_
|
[
"Calculate",
"the",
"great",
"circle",
"distance",
"between",
"to",
"points",
"using",
"the",
"haversine",
"formula",
"[",
"1",
"]",
"_",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/angle_tools.py#L121-L149
|
PaulHancock/Aegean
|
AegeanTools/angle_tools.py
|
bear
|
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))
|
python
|
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))
|
[
"def",
"bear",
"(",
"ra1",
",",
"dec1",
",",
"ra2",
",",
"dec2",
")",
":",
"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).
|
[
"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",
"]"
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/angle_tools.py#L152-L173
|
PaulHancock/Aegean
|
AegeanTools/angle_tools.py
|
translate
|
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
|
python
|
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
|
[
"def",
"translate",
"(",
"ra",
",",
"dec",
",",
"r",
",",
"theta",
")",
":",
"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).
|
[
"Translate",
"a",
"given",
"point",
"a",
"distance",
"r",
"in",
"the",
"(",
"initial",
")",
"direction",
"theta",
"along",
"a",
"great",
"circle",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/angle_tools.py#L176-L200
|
PaulHancock/Aegean
|
AegeanTools/angle_tools.py
|
dist_rhumb
|
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)
|
python
|
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)
|
[
"def",
"dist_rhumb",
"(",
"ra1",
",",
"dec1",
",",
"ra2",
",",
"dec2",
")",
":",
"# 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>`_
|
[
"Calculate",
"the",
"Rhumb",
"line",
"distance",
"between",
"two",
"points",
"[",
"1",
"]",
"_",
".",
"A",
"Rhumb",
"line",
"between",
"two",
"points",
"is",
"one",
"which",
"follows",
"a",
"constant",
"bearing",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/angle_tools.py#L203-L237
|
PaulHancock/Aegean
|
AegeanTools/angle_tools.py
|
bear_rhumb
|
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)
|
python
|
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)
|
[
"def",
"bear_rhumb",
"(",
"ra1",
",",
"dec1",
",",
"ra2",
",",
"dec2",
")",
":",
"# 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).
|
[
"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",
"]"
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/angle_tools.py#L240-L265
|
PaulHancock/Aegean
|
AegeanTools/angle_tools.py
|
translate_rhumb
|
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
|
python
|
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
|
[
"def",
"translate_rhumb",
"(",
"ra",
",",
"dec",
",",
"r",
",",
"theta",
")",
":",
"# 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).
|
[
"Translate",
"a",
"given",
"point",
"a",
"distance",
"r",
"in",
"the",
"(",
"initial",
")",
"direction",
"theta",
"along",
"a",
"Rhumb",
"line",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/angle_tools.py#L268-L303
|
PaulHancock/Aegean
|
AegeanTools/MIMAS.py
|
galactic2fk5
|
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
|
python
|
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
|
[
"def",
"galactic2fk5",
"(",
"l",
",",
"b",
")",
":",
"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.
|
[
"Convert",
"galactic",
"l",
"/",
"b",
"to",
"fk5",
"ra",
"/",
"dec"
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L77-L92
|
PaulHancock/Aegean
|
AegeanTools/MIMAS.py
|
mask_plane
|
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
|
python
|
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
|
[
"def",
"mask_plane",
"(",
"data",
",",
"wcs",
",",
"region",
",",
"negate",
"=",
"False",
")",
":",
"# 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.
|
[
"Mask",
"a",
"2d",
"image",
"(",
"data",
")",
"such",
"that",
"pixels",
"within",
"region",
"are",
"set",
"to",
"nan",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L95-L139
|
PaulHancock/Aegean
|
AegeanTools/MIMAS.py
|
mask_file
|
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
|
python
|
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
|
[
"def",
"mask_file",
"(",
"regionfile",
",",
"infile",
",",
"outfile",
",",
"negate",
"=",
"False",
")",
":",
"# 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`
|
[
"Created",
"a",
"masked",
"version",
"of",
"file",
"using",
"a",
"region",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L142-L191
|
PaulHancock/Aegean
|
AegeanTools/MIMAS.py
|
mask_table
|
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]
|
python
|
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]
|
[
"def",
"mask_table",
"(",
"region",
",",
"table",
",",
"negate",
"=",
"False",
",",
"racol",
"=",
"'ra'",
",",
"deccol",
"=",
"'dec'",
")",
":",
"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.
|
[
"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",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L194-L226
|
PaulHancock/Aegean
|
AegeanTools/MIMAS.py
|
mask_catalog
|
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
|
python
|
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
|
[
"def",
"mask_catalog",
"(",
"regionfile",
",",
"infile",
",",
"outfile",
",",
"negate",
"=",
"False",
",",
"racol",
"=",
"'ra'",
",",
"deccol",
"=",
"'dec'",
")",
":",
"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`
|
[
"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",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L229-L267
|
PaulHancock/Aegean
|
AegeanTools/MIMAS.py
|
mim2reg
|
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
|
python
|
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
|
[
"def",
"mim2reg",
"(",
"mimfile",
",",
"regfile",
")",
":",
"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.
|
[
"Convert",
"a",
"MIMAS",
"region",
"(",
".",
"mim",
")",
"file",
"into",
"a",
"DS9",
"region",
"(",
".",
"reg",
")",
"file",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L270-L286
|
PaulHancock/Aegean
|
AegeanTools/MIMAS.py
|
mim2fits
|
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
|
python
|
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
|
[
"def",
"mim2fits",
"(",
"mimfile",
",",
"fitsfile",
")",
":",
"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.
|
[
"Convert",
"a",
"MIMAS",
"region",
"(",
".",
"mim",
")",
"file",
"into",
"a",
"MOC",
"region",
"(",
".",
"fits",
")",
"file",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L289-L304
|
PaulHancock/Aegean
|
AegeanTools/MIMAS.py
|
box2poly
|
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()
|
python
|
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()
|
[
"def",
"box2poly",
"(",
"line",
")",
":",
"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.
|
[
"Convert",
"a",
"string",
"that",
"describes",
"a",
"box",
"in",
"ds9",
"format",
"into",
"a",
"polygon",
"that",
"is",
"given",
"by",
"the",
"corners",
"of",
"the",
"box"
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L307-L338
|
PaulHancock/Aegean
|
AegeanTools/MIMAS.py
|
circle2circle
|
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]
|
python
|
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]
|
[
"def",
"circle2circle",
"(",
"line",
")",
":",
"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.
|
[
"Parse",
"a",
"string",
"that",
"describes",
"a",
"circle",
"in",
"ds9",
"format",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L341-L365
|
PaulHancock/Aegean
|
AegeanTools/MIMAS.py
|
poly2poly
|
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
|
python
|
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
|
[
"def",
"poly2poly",
"(",
"line",
")",
":",
"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.
|
[
"Parse",
"a",
"string",
"of",
"text",
"containing",
"a",
"DS9",
"description",
"of",
"a",
"polygon",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L368-L397
|
PaulHancock/Aegean
|
AegeanTools/MIMAS.py
|
reg2mim
|
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
|
python
|
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
|
[
"def",
"reg2mim",
"(",
"regfile",
",",
"mimfile",
",",
"maxdepth",
")",
":",
"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.
|
[
"Parse",
"a",
"DS9",
"region",
"file",
"and",
"write",
"a",
"MIMAS",
"region",
"(",
".",
"mim",
")",
"file",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L400-L436
|
PaulHancock/Aegean
|
AegeanTools/MIMAS.py
|
combine_regions
|
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
|
python
|
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
|
[
"def",
"combine_regions",
"(",
"container",
")",
":",
"# 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.
|
[
"Return",
"a",
"region",
"that",
"is",
"the",
"combination",
"of",
"those",
"specified",
"in",
"the",
"container",
".",
"The",
"container",
"is",
"typically",
"a",
"results",
"instance",
"that",
"comes",
"from",
"argparse",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L439-L511
|
PaulHancock/Aegean
|
AegeanTools/MIMAS.py
|
intersect_regions
|
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
|
python
|
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
|
[
"def",
"intersect_regions",
"(",
"flist",
")",
":",
"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.
|
[
"Construct",
"a",
"region",
"which",
"is",
"the",
"intersection",
"of",
"all",
"regions",
"described",
"in",
"the",
"given",
"list",
"of",
"file",
"names",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L514-L534
|
PaulHancock/Aegean
|
AegeanTools/MIMAS.py
|
save_region
|
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
|
python
|
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
|
[
"def",
"save_region",
"(",
"region",
",",
"filename",
")",
":",
"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.
|
[
"Save",
"the",
"given",
"region",
"to",
"a",
"file"
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L537-L551
|
PaulHancock/Aegean
|
AegeanTools/MIMAS.py
|
save_as_image
|
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
|
python
|
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
|
[
"def",
"save_as_image",
"(",
"region",
",",
"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.
|
[
"Convert",
"a",
"MIMAS",
"region",
"(",
".",
"mim",
")",
"file",
"into",
"a",
"image",
"(",
"eg",
".",
"png",
")"
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L554-L573
|
PaulHancock/Aegean
|
AegeanTools/fits_image.py
|
get_pixinfo
|
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
|
python
|
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
|
[
"def",
"get_pixinfo",
"(",
"header",
")",
":",
"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.
|
[
"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",
")"
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fits_image.py#L20-L60
|
PaulHancock/Aegean
|
AegeanTools/fits_image.py
|
get_beam
|
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
|
python
|
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
|
[
"def",
"get_beam",
"(",
"header",
")",
":",
"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.
|
[
"Create",
"a",
":",
"class",
":",
"AegeanTools",
".",
"fits_image",
".",
"Beam",
"object",
"from",
"a",
"fits",
"header",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fits_image.py#L63-L102
|
PaulHancock/Aegean
|
AegeanTools/fits_image.py
|
fix_aips_header
|
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
|
python
|
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
|
[
"def",
"fix_aips_header",
"(",
"header",
")",
":",
"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.
|
[
"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",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fits_image.py#L105-L145
|
PaulHancock/Aegean
|
AegeanTools/fits_image.py
|
FitsImage.set_pixels
|
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
|
python
|
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
|
[
"def",
"set_pixels",
"(",
"self",
",",
"pixels",
")",
":",
"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
|
[
"Set",
"the",
"image",
"data",
".",
"Will",
"not",
"work",
"if",
"the",
"new",
"image",
"has",
"a",
"different",
"shape",
"than",
"the",
"current",
"image",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fits_image.py#L235-L254
|
PaulHancock/Aegean
|
AegeanTools/fits_image.py
|
FitsImage.get_background_rms
|
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
|
python
|
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
|
[
"def",
"get_background_rms",
"(",
"self",
")",
":",
"# 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.
|
[
"Calculate",
"the",
"rms",
"of",
"the",
"image",
".",
"The",
"rms",
"is",
"calculated",
"from",
"the",
"interqurtile",
"range",
"(",
"IQR",
")",
"to",
"reduce",
"bias",
"from",
"source",
"pixels",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fits_image.py#L256-L280
|
PaulHancock/Aegean
|
AegeanTools/fits_image.py
|
FitsImage.pix2sky
|
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])]
|
python
|
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])]
|
[
"def",
"pix2sky",
"(",
"self",
",",
"pixel",
")",
":",
"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)
|
[
"Get",
"the",
"sky",
"coordinates",
"for",
"a",
"given",
"image",
"pixel",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fits_image.py#L282-L299
|
PaulHancock/Aegean
|
AegeanTools/fits_image.py
|
FitsImage.sky2pix
|
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])]
|
python
|
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])]
|
[
"def",
"sky2pix",
"(",
"self",
",",
"skypos",
")",
":",
"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.
|
[
"Get",
"the",
"pixel",
"coordinates",
"for",
"a",
"given",
"sky",
"position",
"(",
"degrees",
")",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fits_image.py#L307-L324
|
PaulHancock/Aegean
|
AegeanTools/AeRes.py
|
load_sources
|
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
|
python
|
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
|
[
"def",
"load_sources",
"(",
"filename",
")",
":",
"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
|
[
"Open",
"a",
"file",
"read",
"contents",
"return",
"a",
"list",
"of",
"all",
"the",
"sources",
"in",
"that",
"file",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/AeRes.py#L19-L27
|
PaulHancock/Aegean
|
scripts/fix_beam.py
|
search_beam
|
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
|
python
|
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
|
[
"def",
"search_beam",
"(",
"hdulist",
")",
":",
"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:
|
[
"Will",
"search",
"the",
"beam",
"info",
"from",
"the",
"HISTORY",
":",
"param",
"hdulist",
":",
":",
"return",
":"
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/scripts/fix_beam.py#L22-L35
|
PaulHancock/Aegean
|
AegeanTools/source_finder.py
|
fix_shape
|
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
|
python
|
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
|
[
"def",
"fix_shape",
"(",
"source",
")",
":",
"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
|
[
"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",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/source_finder.py#L1786-L1802
|
PaulHancock/Aegean
|
AegeanTools/source_finder.py
|
theta_limit
|
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
|
python
|
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
|
[
"def",
"theta_limit",
"(",
"theta",
")",
":",
"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.
|
[
"Angle",
"theta",
"is",
"periodic",
"with",
"period",
"pi",
".",
"Constrain",
"theta",
"such",
"that",
"-",
"pi",
"/",
"2<theta<",
"=",
"pi",
"/",
"2",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/source_finder.py#L1827-L1846
|
PaulHancock/Aegean
|
AegeanTools/source_finder.py
|
scope2lat
|
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
|
python
|
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
|
[
"def",
"scope2lat",
"(",
"telescope",
")",
":",
"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
|
[
"Convert",
"a",
"telescope",
"name",
"into",
"a",
"latitude",
"returns",
"None",
"when",
"the",
"telescope",
"is",
"unknown",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/source_finder.py#L1849-L1898
|
PaulHancock/Aegean
|
AegeanTools/source_finder.py
|
check_cores
|
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
|
python
|
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
|
[
"def",
"check_cores",
"(",
"cores",
")",
":",
"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.
|
[
"Determine",
"how",
"many",
"cores",
"we",
"are",
"able",
"to",
"use",
".",
"Return",
"1",
"if",
"we",
"are",
"not",
"able",
"to",
"make",
"a",
"queue",
"via",
"pprocess",
"."
] |
train
|
https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/source_finder.py#L1901-L1931
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.