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)