def makePluginAndCat(alg,
name,
control=None,
metadata=False,
centroid=None,
psfflux=None):
print("Making plugin ", alg, name)
if control is None:
control = alg.ConfigClass()
schema = afwTable.SourceTable.makeMinimalSchema()
if centroid:
lsst.afw.table.Point2DKey.addFields(schema, centroid, "centroid",
"pixel")
schema.getAliasMap().set("slot_Centroid", centroid)
if psfflux:
base.PsfFluxAlgorithm(base.PsfFluxControl(), psfflux, schema)
schema.getAliasMap().set("slot_PsfFlux", psfflux)
if metadata:
plugin = alg(control, name, schema, PropertySet())
else:
plugin = alg(control, name, schema)
cat = afwTable.SourceCatalog(schema)
if centroid:
cat.defineCentroid(centroid)
return plugin, cat
def main():
date = datetime.datetime.now().strftime("%a %Y-%m-%d %H:%M:%S")
########################################################################
# command line arguments and options
########################################################################
parser = optparse.OptionParser(usage = __doc__)
#parser.add_option("-a", "--aa", dest="aa", type=float,
# default=1.0, help="default=%default")
opts, args = parser.parse_args()
if len(args) == 0:
r1, r2, dr = 3.0, 3.0, 0.5
elif len(args) == 3:
r1, r2, dr = map(float, args)
else:
parser.print_help()
sys.exit(1)
# make a list of radii to compute the growthcurve points
radius = []
nR = int( (r2 - r1)/dr + 1 )
for iR in range(nR):
radius.append(r1 + iR*dr)
# make an image big enough to hold the largest requested aperture
xwidth = 2*(0 + 128)
ywidth = xwidth
# initializations
sigmas = [1.5, 2.5] # the Gaussian widths of the psfs we'll use
nS = len(sigmas)
a = 100.0
aptaper = 2.0
xcen = xwidth/2
ycen = ywidth/2
alg = measBase.PsfFluxAlgorithm
schema = afwTable.SourceTable.makeMinimalSchema()
schema.addField("centroid_x", type=float)
schema.addField("centroid_y", type=float)
plugin = alg(measBase.PsfFluxControl(), "test", schema)
cat = afwTable.SourceCatalog(schema)
cat.defineCentroid("centroid")
print "# sig rad Naive Sinc Psf"
for iS in range(nS):
sigma = sigmas[iS];
# make a Gaussian star to measure
gauss = afwMath.GaussianFunction2D(sigma, sigma)
kernel = afwMath.AnalyticKernel(xwidth, ywidth, gauss)
kimg = afwImage.ImageD(kernel.getDimensions())
kernel.computeImage(kimg, False)
kimg *= 100.0
mimg = afwImage.MaskedImageF(kimg.convertFloat(),
afwImage.MaskU(kimg.getDimensions(), 0x0),
afwImage.ImageF(kimg.getDimensions(), 0.0))
exposure = afwImage.ExposureF(mimg)
# loop over all the radii in the growthcurve
for iR in range(nR):
psfH = int(2.0*(r2 + 2.0)) + 1
psfW = int(2.0*(r2 + 2.0)) + 1
# this test uses a single Gaussian instead of the original double gaussian
psf = afwDet.GaussianPsf(psfW, psfH, sigma)
# get the aperture fluxes for Naive and Sinc methods
axes = afwGeom.ellipses.Axes(radius[iR], radius[iR], math.radians(0));
center = afwGeom.Point2D(0,0)
ellipse = afwGeom.ellipses.Ellipse(axes, center)
resultSinc = measBase.ApertureFluxAlgorithm.computeSincFlux(mimg.getImage(), ellipse)
resultNaive = measBase.ApertureFluxAlgorithm.computeNaiveFlux(mimg.getImage(), ellipse)
source = cat.addNew()
source["centroid_x"] = 0
source["centroid_y"] = 0
exposure.setPsf(psf)
plugin.measure(source, exposure)
fluxNaive = resultNaive.flux
fluxSinc = resultSinc.flux
fluxPsf = source["test_flux"]
# get the exact flux for the theoretical smooth PSF
# rpsf = RGaussian(sigma, a, radius[iR], aptaper)
# *** not sure how to integrate a python functor ***
print "%.2f %.2f %.3f %.3f %.3f" % (sigma, radius[iR], fluxNaive, fluxSinc, fluxPsf)