Use and enforce Astropy compliant units

include/lsst/ip/diffim/DipoleAlgorithms.h

@@ -236,8 +236,8 @@ class NaiveDipoleFlux : public DipoleFluxAlgorithm {
 
     NaiveDipoleFlux(Control const & ctrl, std::string const & name, afw::table::Schema & schema) :
         DipoleFluxAlgorithm(ctrl, name, schema, "raw flux counts"),
-        _numPositiveKey(schema.addField<int>(name+"_npos", "number of positive pixels", "dn")),
-        _numNegativeKey(schema.addField<int>(name+"_nneg", "number of negative pixels", "dn"))
+        _numPositiveKey(schema.addField<int>(name+"_npos", "number of positive pixels", "count")),
+        _numNegativeKey(schema.addField<int>(name+"_nneg", "number of negative pixels", "count"))
     {
     }
 

include/lsst/ip/diffim/ImageStatistics.h

@@ -37,10 +37,11 @@
 
 #include <limits>
 #include <memory>
+#include <cmath>
+
 #include "lsst/afw/image.h"
 #include "lsst/pex/policy/Policy.h"
 #include "lsst/pex/logging/Trace.h"
-#include "lsst/utils/ieee.h"
 
 namespace lsst { 
 namespace ip { 
@@ -108,15 +109,15 @@ namespace diffim {
                      ptr != end; ++ptr) {
                     if (!((*ptr).mask() & _bpMask)) {
                         double const ivar = 1. / (*ptr).variance();
-                        if (lsst::utils::lsst_isfinite(ivar)) {
+                        if (std::isfinite(ivar)) {
                             _xsum  += (*ptr).image() * sqrt(ivar);
                             _x2sum += (*ptr).image() * (*ptr).image() * ivar;
                             _npix  += 1;
                         }
                     }
                 }
             }
-            if ((!lsst::utils::lsst_isfinite(_xsum)) || (!lsst::utils::lsst_isfinite(_x2sum))) {
+            if ((!std::isfinite(_xsum)) || (!std::isfinite(_x2sum))) {
                 throw LSST_EXCEPT(pexExcept::Exception, 
                                   "Nan/Inf in ImageStatistics.apply");
             }

python/lsst/ip/diffim/dipoleFitTask.py

@@ -843,37 +843,37 @@ def _setupSchema(self, config, name, schema, metadata):
         for pos_neg in ['pos', 'neg']:
 
             key = schema.addField(
-                schema.join(name, pos_neg, "flux"), type=float, units="dn",
+                schema.join(name, pos_neg, "flux"), type=float, units="count",
                 doc="Dipole {0} lobe flux".format(pos_neg))
             setattr(self, ''.join((pos_neg, 'FluxKey')), key)
 
             key = schema.addField(
-                schema.join(name, pos_neg, "fluxSigma"), type=float, units="pixels",
+                schema.join(name, pos_neg, "fluxSigma"), type=float, units="pixel",
                 doc="1-sigma uncertainty for {0} dipole flux".format(pos_neg))
             setattr(self, ''.join((pos_neg, 'FluxSigmaKey')), key)
 
             for x_y in ['x', 'y']:
                 key = schema.addField(
-                    schema.join(name, pos_neg, "centroid", x_y), type=float, units="pixels",
+                    schema.join(name, pos_neg, "centroid", x_y), type=float, units="pixel",
                     doc="Dipole {0} lobe centroid".format(pos_neg))
                 setattr(self, ''.join((pos_neg, 'CentroidKey', x_y.upper())), key)
 
         for x_y in ['x', 'y']:
             key = schema.addField(
-                schema.join(name, "centroid", x_y), type=float, units="pixels",
+                schema.join(name, "centroid", x_y), type=float, units="pixel",
                 doc="Dipole centroid")
             setattr(self, ''.join(('centroidKey', x_y.upper())), key)
 
         self.fluxKey = schema.addField(
-            schema.join(name, "flux"), type=float, units="dn",
+            schema.join(name, "flux"), type=float, units="count",
             doc="Dipole overall flux")
 
         self.orientationKey = schema.addField(
             schema.join(name, "orientation"), type=float, units="deg",
             doc="Dipole orientation")
 
         self.separationKey = schema.addField(
-            schema.join(name, "separation"), type=float, units="pixels",
+            schema.join(name, "separation"), type=float, units="pixel",
             doc="Pixel separation between positive and negative lobes of dipole")
 
         self.chi2dofKey = schema.addField(

python/lsst/ip/diffim/kernelCandidateQa.py

@@ -89,10 +89,10 @@ def makeMetricMap(self):
                        ("Anderson-Darling significance levels for the Normal distribution", 5),
                        ("Reduced chi^2 of the residual.", "likelihood"),
                        ("Mean squared error in diffim : Variance + Bias**2",),
-                       ("Centroid in X for this Kernel", "pixels"),
-                       ("Centroid in Y for this Kernel", "pixels"),
-                       ("Standard deviation in X for this Kernel", "pixels"),
-                       ("Standard deviation in Y for this Kernel", "pixels"),
+                       ("Centroid in X for this Kernel", "pixel"),
+                       ("Centroid in Y for this Kernel", "pixel"),
+                       ("Standard deviation in X for this Kernel", "pixel"),
+                       ("Standard deviation in Y for this Kernel", "pixel"),
                        ("Id for this KernelCandidate",)]
         metricMap = {}
         for name, mtype, comment in zip(nameList, typeList, commentList):

tests/KernelCandidateAndSolution.py

@@ -19,7 +19,7 @@ class DiffimTestCases(unittest.TestCase):
 
     def setUp(self):
         schema = afwTable.SourceTable.makeMinimalSchema()
-        afwTable.Point2DKey.addFields(schema, "Centroid", "input centroid", "pixels")
+        afwTable.Point2DKey.addFields(schema, "Centroid", "input centroid", "pixel")
         schema.addField("PsfFlux_flux", type=float)
         schema.addField("PsfFlux_fluxSigma", type=float)
         schema.addField("PsfFlux_flag", type="Flag")