lsst::jointcal::Associations Class Reference

The class that implements the relations between MeasuredStar and FittedStar. More...

#include <Associations.h>

Public Member Functions
size_t	refStarListSize ()
size_t	fittedStarListSize ()
	Associations ()
	Source selection is performed in python, so Associations' constructor only initializes a couple of variables. More...
	Associations (CcdImageList const &imageList)
	Create an Associations object from a pre-built list of ccdImages. More...
	Associations (Associations const &)=delete
	No moves or copies: jointcal only ever needs one Associations object. More...
	Associations (Associations &&)=delete
Associations &	operator= (Associations const &)=delete
Associations &	operator= (Associations &&)=delete
void	computeCommonTangentPoint ()
	Sets a shared tangent point for all ccdImages, using the mean of the centers of all ccdImages. More...
void	setCommonTangentPoint (lsst::geom::Point2D const &commonTangentPoint)
	Sets a shared tangent point for all ccdImages. More...
Point	getCommonTangentPoint () const
	can be used to project sidereal coordinates related to the image set on a plane. More...
void	createCcdImage (afw::table::SourceCatalog &catalog, std::shared_ptr< lsst::afw::geom::SkyWcs > wcs, std::shared_ptr< lsst::afw::image::VisitInfo > visitInfo, lsst::geom::Box2I const &bbox, std::string const &filter, std::shared_ptr< afw::image::PhotoCalib > photoCalib, std::shared_ptr< afw::cameraGeom::Detector > detector, int visit, int ccd, lsst::jointcal::JointcalControl const &control)
	Create a ccdImage from an exposure catalog and metadata, and add it to the list. More...
void	addCcdImage (std::shared_ptr< CcdImage > const ccdImage)
	Add a pre-constructed ccdImage to the ccdImageList. More...
void	associateCatalogs (const double matchCutInArcsec=0, const bool useFittedList=false, const bool enlargeFittedList=true)
	incrementaly builds a merged catalog of all image catalogs More...
void	collectRefStars (afw::table::SimpleCatalog &refCat, geom::Angle matchCut, std::string const &fluxField, float refCoordinateErr, bool rejectBadFluxes=false)
	Collect stars from an external reference catalog and associate them with fittedStars. More...
void	deprojectFittedStars ()
	Sends back the fitted stars coordinates on the sky FittedStarsList::inTangentPlaneCoordinates keeps track of that. More...
void	prepareFittedStars (int minMeasurements)
	Set the color field of FittedStar 's from a colored catalog. More...
CcdImageList const &	getCcdImageList () const
unsigned	getNFilters () const
	Number of different bands in the input image list. Not implemented so far. More...
lsst::sphgeom::Circle	computeBoundingCircle () const
	Return the bounding circle in on-sky (RA, Dec) coordinates containing all CcdImages. More...
int	nCcdImagesValidForFit () const
	return the number of CcdImages with non-empty catalogs to-be-fit. More...
size_t	nFittedStarsWithAssociatedRefStar () const
	Return the number of fittedStars that have an associated refStar. More...

Public Attributes
CcdImageList	ccdImageList
RefStarList	refStarList
FittedStarList	fittedStarList

Detailed Description

The class that implements the relations between MeasuredStar and FittedStar.

Definition at line 54 of file Associations.h.

Constructor & Destructor Documentation

Associations() [1/4]

lsst::jointcal::Associations::Associations ( )

inline

Source selection is performed in python, so Associations' constructor only initializes a couple of variables.

Definition at line 69 of file Associations.h.

            : _commonTangentPoint(Point(std::numeric_limits<double>::quiet_NaN(),
                                        std::numeric_limits<double>::quiet_NaN())) {}

Associations() [2/4]

lsst::jointcal::Associations::Associations ( CcdImageList const &  imageList )

inline

Create an Associations object from a pre-built list of ccdImages.

This is primarily useful for tests that build their own ccdImageList, but it could be used to help parallelize the creation of the ccdImages.

Parameters

imageList

A pre-built ccdImage list.

Definition at line 81 of file Associations.h.

            : ccdImageList(imageList),
              _commonTangentPoint(Point(std::numeric_limits<double>::quiet_NaN(),
                                        std::numeric_limits<double>::quiet_NaN())) {}

Associations() [3/4]

lsst::jointcal::Associations::Associations ( Associations const &  )

delete

No moves or copies: jointcal only ever needs one Associations object.

Associations() [4/4]

lsst::jointcal::Associations::Associations ( Associations &&  )

delete

Member Function Documentation

addCcdImage()

void lsst::jointcal::Associations::addCcdImage ( std::shared_ptr< CcdImage > const  ccdImage )

inline

Add a pre-constructed ccdImage to the ccdImageList.

Definition at line 131 of file Associations.h.

{ ccdImageList.push_back(ccdImage); }

associateCatalogs()

void lsst::jointcal::Associations::associateCatalogs	(	const double	matchCutInArcsec = 0,
		const bool	useFittedList = false,
		const bool	enlargeFittedList = true
	)

incrementaly builds a merged catalog of all image catalogs

Definition at line 121 of file Associations.cc.

                                                                   {
    // clear reference stars
    refStarList.clear();
 
    // clear measurement counts and associations to refstars, but keep fittedStars themselves.
    for (auto &item : fittedStarList) {
        item->clearBeforeAssoc();
    }
    // clear fitted stars
    if (!useFittedList) fittedStarList.clear();
 
    for (auto &ccdImage : ccdImageList) {
        std::shared_ptr<AstrometryTransform> toCommonTangentPlane = ccdImage->getPixelToCommonTangentPlane();
 
        // Clear the catalog to fit and copy the whole catalog into it.
        // This allows reassociating from scratch after a fit.
        ccdImage->resetCatalogForFit();
        MeasuredStarList &catalog = ccdImage->getCatalogForFit();
 
        // Associate with previous lists.
        /* To speed up the match (more precisely the contruction of the FastFinder), select in the
         fittedStarList the objects that are within reach of the current ccdImage */
        Frame ccdImageFrameCPT = toCommonTangentPlane->apply(ccdImage->getImageFrame(), false);
        ccdImageFrameCPT = ccdImageFrameCPT.rescale(1.10);  // add 10 % margin.
        // We cannot use FittedStarList::ExtractInFrame, because it does an actual copy, which we don't want
        // here: we want the pointers in the StarMatch to refer to fittedStarList elements.
        FittedStarList toMatch;
 
        for (auto const &fittedStar : fittedStarList) {
            if (ccdImageFrameCPT.inFrame(*fittedStar)) {
                toMatch.push_back(fittedStar);
            }
        }
 
        // divide by 3600 because coordinates in CTP are in degrees.
        auto starMatchList = listMatchCollect(Measured2Base(catalog), Fitted2Base(toMatch),
                                              toCommonTangentPlane.get(), matchCutInArcSec / 3600.);
 
        /* should check what this removeAmbiguities does... */
        LOGLS_DEBUG(_log, "Measured-to-Fitted matches before removing ambiguities " << starMatchList->size());
        starMatchList->removeAmbiguities(*toCommonTangentPlane);
        LOGLS_DEBUG(_log, "Measured-to-Fitted matches after removing ambiguities " << starMatchList->size());
 
        // Associate MeasuredStar -> FittedStar using the surviving matches.
 
        int matchedCount = 0;
        for (auto const &starMatch : *starMatchList) {
            auto bs = starMatch.s1;
            auto ms_const = std::dynamic_pointer_cast<const MeasuredStar>(bs);
            auto ms = std::const_pointer_cast<MeasuredStar>(ms_const);
            auto bs2 = starMatch.s2;
            auto fs_const = std::dynamic_pointer_cast<const FittedStar>(bs2);
            auto fs = std::const_pointer_cast<FittedStar>(fs_const);
            ms->setFittedStar(fs);
            matchedCount++;
        }
        LOGLS_INFO(_log, "Matched " << matchedCount << " objects in " << ccdImage->getName());
 
        // add unmatched objets to FittedStarList
        int unMatchedCount = 0;
        for (auto const &mstar : catalog) {
            // to check if it was matched, just check if it has a fittedStar Pointer assigned
            if (mstar->getFittedStar()) continue;
            if (enlargeFittedList) {
                auto fs = std::make_shared<FittedStar>(*mstar);
                // transform coordinates to CommonTangentPlane
                toCommonTangentPlane->transformPosAndErrors(*fs, *fs);
                fittedStarList.push_back(fs);
                mstar->setFittedStar(fs);
            }
            unMatchedCount++;
        }
        LOGLS_INFO(_log, "Unmatched objects: " << unMatchedCount);
    }  // end of loop on CcdImages
 
    // !!!!!!!!!!!!!!!!!
    // TODO: DO WE REALLY NEED THIS???
    // Why do we need to do this, instead of directly computing them in normalizeFittedStars?
    // What makes the magnitudes special here?
    // !!!!!!!!!!!!!!!!!
    // assignMags();
}

collectRefStars()

void lsst::jointcal::Associations::collectRefStars	(	afw::table::SimpleCatalog &	refCat,
		geom::Angle	matchCut,
		std::string const &	fluxField,
		float	refCoordinateErr,
		bool	rejectBadFluxes = false
	)

Collect stars from an external reference catalog and associate them with fittedStars.

Parameters

	refCat	The catalog of reference sources
[in]	matchCut	Separation radius to match fitted and reference stars.
	fluxField	The field name in refCat to get the flux from.
	refCoordinateErr	Error on reference catalog coordinates [mas]. If not NaN, this overrides the coord_*_err values in the reference catalog itself. This value is divided by cos(dec) before being used for ra_err.
	rejectBadFluxes	Reject reference sources with flux=NaN or 0 and/or fluxErr=NaN or 0. Typically false for astrometry and true for photometry.

Definition at line 205 of file Associations.cc.

                                                         {
    if (refCat.size() == 0) {
        throw(LSST_EXCEPT(pex::exceptions::InvalidParameterError,
                          " reference catalog is empty : stop here "));
    }
 
    afw::table::CoordKey coordKey = refCat.getSchema()["coord"];
    // Handle reference catalogs that don't have position errors.
    afw::table::Key<float> raErrKey;
    afw::table::Key<float> decErrKey;
    if (std::isnan(refCoordinateErr)) {
        raErrKey = refCat.getSchema()["coord_raErr"];
        decErrKey = refCat.getSchema()["coord_decErr"];
    }
 
    auto fluxKey = refCat.getSchema().find<double>(fluxField).key;
    // Handle reference catalogs that don't have flux errors.
    afw::table::Key<double> fluxErrKey;
    try {
        fluxErrKey = refCat.getSchema().find<double>(fluxField + "Err").key;
    } catch (pex::exceptions::NotFoundError &) {
        LOGLS_WARN(_log, "Flux error field ("
                                 << fluxField << "Err"
                                 << ") not found in reference catalog. Not using ref flux errors.");
    }
 
    refStarList.clear();
    for (size_t i = 0; i < refCat.size(); i++) {
        auto const &record = refCat.get(i);
 
        auto coord = record->get(coordKey);
        double flux = record->get(fluxKey);
        double fluxErr;
        if (fluxErrKey.isValid()) {
            fluxErr = record->get(fluxErrKey);
        } else {
            fluxErr = std::numeric_limits<double>::quiet_NaN();
        }
        double ra = lsst::geom::radToDeg(coord.getLongitude());
        double dec = lsst::geom::radToDeg(coord.getLatitude());
        auto star = std::make_shared<RefStar>(ra, dec, flux, fluxErr);
 
        if (std::isnan(refCoordinateErr)) {
            star->vx = record->get(raErrKey);
            star->vy = record->get(decErrKey);
        } else {
            // Compute and use the fake errors
            star->vx = std::pow(refCoordinateErr / 1000. / 3600. / std::cos(coord.getLatitude()), 2);
            star->vy = std::pow(refCoordinateErr / 1000. / 3600., 2);
        }
        // TODO: cook up a covariance as none of our current refcats have it
        star->vxy = 0.;
 
        // Reject sources with non-finite fluxes and flux errors, and fluxErr=0 (which gives chi2=inf).
        if (rejectBadFluxes && (!std::isfinite(flux) || !std::isfinite(fluxErr) || fluxErr <= 0)) continue;
        refStarList.push_back(star);
    }
 
    // project on CTP (i.e. RaDec2CTP), in degrees
    AstrometryTransformLinear identity;
    TanRaDecToPixel raDecToCommonTangentPlane(identity, _commonTangentPoint);
 
    associateRefStars(matchCut.asArcseconds(), &raDecToCommonTangentPlane);
}

computeBoundingCircle()

lsst::sphgeom::Circle lsst::jointcal::Associations::computeBoundingCircle

(

)

const

Return the bounding circle in on-sky (RA, Dec) coordinates containing all CcdImages.

Requires that computeCommonTangentPoint() be called first, so that sensor bounding boxes can be transformed into the common tangent plane.

Definition at line 92 of file Associations.cc.

                                                            {
    // Compute the frame on the common tangent plane that contains all input images.
    Frame tangentPlaneFrame;
 
    for (auto const &ccdImage : ccdImageList) {
        Frame CTPFrame = ccdImage->getPixelToCommonTangentPlane()->apply(ccdImage->getImageFrame(), false);
        if (tangentPlaneFrame.getArea() == 0)
            tangentPlaneFrame = CTPFrame;
        else
            tangentPlaneFrame += CTPFrame;
    }
 
    // Convert tangent plane coordinates to RaDec.
    AstrometryTransformLinear identity;
    TanPixelToRaDec commonTangentPlaneToRaDec(identity, _commonTangentPoint);
    Frame raDecFrame = commonTangentPlaneToRaDec.apply(tangentPlaneFrame, false);
 
    std::vector<sphgeom::UnitVector3d> points;
    points.reserve(4);
    // raDecFrame is in on-sky (RA,Dec) degrees stored as an x/y box:
    // the on-sky bounding box it represents is given by the corners of that box.
    points.emplace_back(sphgeom::LonLat::fromDegrees(raDecFrame.xMin, raDecFrame.yMin));
    points.emplace_back(sphgeom::LonLat::fromDegrees(raDecFrame.xMax, raDecFrame.yMin));
    points.emplace_back(sphgeom::LonLat::fromDegrees(raDecFrame.xMin, raDecFrame.yMax));
    points.emplace_back(sphgeom::LonLat::fromDegrees(raDecFrame.xMax, raDecFrame.yMax));
 
    return sphgeom::ConvexPolygon::convexHull(points).getBoundingCircle();
}

computeCommonTangentPoint()

void lsst::jointcal::Associations::computeCommonTangentPoint

(

)

Sets a shared tangent point for all ccdImages, using the mean of the centers of all ccdImages.

Definition at line 76 of file Associations.cc.

                                             {
    std::vector<geom::SpherePoint> centers;
    centers.reserve(ccdImageList.size());
    for (auto const &ccdImage : ccdImageList) {
        centers.push_back(ccdImage->getBoresightRaDec());
    }
    auto commonTangentPoint = geom::averageSpherePoint(centers);
    LOGLS_DEBUG(_log, "Using common tangent point: " << commonTangentPoint.getPosition(geom::degrees));
    setCommonTangentPoint(commonTangentPoint.getPosition(geom::degrees));
}

createCcdImage()

void lsst::jointcal::Associations::createCcdImage	(	afw::table::SourceCatalog &	catalog,
		std::shared_ptr< lsst::afw::geom::SkyWcs >	wcs,
		std::shared_ptr< lsst::afw::image::VisitInfo >	visitInfo,
		lsst::geom::Box2I const &	bbox,
		std::string const &	filter,
		std::shared_ptr< afw::image::PhotoCalib >	photoCalib,
		std::shared_ptr< afw::cameraGeom::Detector >	detector,
		int	visit,
		int	ccd,
		lsst::jointcal::JointcalControl const &	control
	)

Create a ccdImage from an exposure catalog and metadata, and add it to the list.

Parameters

[in]	catalog	The extracted source catalog, selected for good astrometric sources.
[in]	wcs	The exposure's original wcs
[in]	visitInfo	The exposure's visitInfo object
[in]	bbox	The bounding box of the exposure
[in]	filter	The exposure's filter
[in]	photoCalib	The exposure's photometric calibration
[in]	detector	The exposure's detector
[in]	visit	The visit identifier
[in]	ccd	The ccd identifier
[in]	control	The JointcalControl object

Definition at line 62 of file Associations.cc.

                                                                              {
    auto ccdImage = std::make_shared<CcdImage>(catalog, wcs, visitInfo, bbox, filter, photoCalib, detector,
                                               visit, ccd, control.sourceFluxField);
    ccdImageList.push_back(ccdImage);
    LOGLS_DEBUG(_log, "Catalog " << ccdImage->getName() << " has " << ccdImage->getWholeCatalog().size()
                                 << " objects.");
}

deprojectFittedStars()

void lsst::jointcal::Associations::deprojectFittedStars

(

)

Sends back the fitted stars coordinates on the sky FittedStarsList::inTangentPlaneCoordinates keeps track of that.

Definition at line 394 of file Associations.cc.

                                        {
    // By default, Associations::fittedStarList is expressed on the Associations::commonTangentPlane.
    // For AstrometryFit, we need it on the sky.
    if (!fittedStarList.inTangentPlaneCoordinates) {
        LOGLS_WARN(_log,
                   "DeprojectFittedStars: Fitted stars are already in sidereal coordinates, nothing done ");
        return;
    }
 
    TanPixelToRaDec ctp2Sky(AstrometryTransformLinear(), getCommonTangentPoint());
    fittedStarList.applyTransform(ctp2Sky);
    fittedStarList.inTangentPlaneCoordinates = false;
}

fittedStarListSize()

size_t lsst::jointcal::Associations::fittedStarListSize ( )

inline

Definition at line 63 of file Associations.h.

{ return fittedStarList.size(); }

getCcdImageList()

CcdImageList const& lsst::jointcal::Associations::getCcdImageList ( ) const

inline

Definition at line 171 of file Associations.h.

{ return ccdImageList; }

getCommonTangentPoint()

Point lsst::jointcal::Associations::getCommonTangentPoint ( ) const

inline

can be used to project sidereal coordinates related to the image set on a plane.

Definition at line 105 of file Associations.h.

{ return _commonTangentPoint; }

getNFilters()

unsigned lsst::jointcal::Associations::getNFilters ( ) const

inline

Number of different bands in the input image list. Not implemented so far.

Definition at line 174 of file Associations.h.

{ return 1; }

nCcdImagesValidForFit()

int lsst::jointcal::Associations::nCcdImagesValidForFit

(

)

const

return the number of CcdImages with non-empty catalogs to-be-fit.

Definition at line 408 of file Associations.cc.

                                              {
    return std::count_if(ccdImageList.begin(), ccdImageList.end(), [](std::shared_ptr<CcdImage> const &item) {
        return item->getCatalogForFit().size() > 0;
    });
}

nFittedStarsWithAssociatedRefStar()

size_t lsst::jointcal::Associations::nFittedStarsWithAssociatedRefStar

(

)

const

Return the number of fittedStars that have an associated refStar.

Definition at line 414 of file Associations.cc.

                                                             {
    size_t count = 0;
    for (auto const &fittedStar : fittedStarList) {
        if ((fittedStar != nullptr) & (fittedStar->getRefStar() != nullptr)) count++;
    }
    return count;
}

operator=() [1/2]

Associations& lsst::jointcal::Associations::operator= ( Associations &&  )

delete

operator=() [2/2]

Associations& lsst::jointcal::Associations::operator= ( Associations const &  )

delete

prepareFittedStars()

void lsst::jointcal::Associations::prepareFittedStars

(

int

minMeasurements

)

Set the color field of FittedStar 's from a colored catalog.

Prepare the fittedStar list by making quality cuts and normalizing measurements.

Parameters

[in]

minMeasurements

The minimum number of measuredStars for a FittedStar to be included.

Definition at line 298 of file Associations.cc.

                                                         {
    selectFittedStars(minMeasurements);
    normalizeFittedStars();
}

refStarListSize()

size_t lsst::jointcal::Associations::refStarListSize ( )

inline

Definition at line 62 of file Associations.h.

{ return refStarList.size(); }

setCommonTangentPoint()

void lsst::jointcal::Associations::setCommonTangentPoint

(

lsst::geom::Point2D const &

commonTangentPoint

)

Sets a shared tangent point for all ccdImages.

Parameters

commonTangentPoint

The common tangent point of all input images (decimal degrees).

Definition at line 87 of file Associations.cc.

                                                                                  {
    _commonTangentPoint = Point(commonTangentPoint.getX(), commonTangentPoint.getY());  // a jointcal::Point
    for (auto &ccdImage : ccdImageList) ccdImage->setCommonTangentPoint(_commonTangentPoint);
}

Member Data Documentation

ccdImageList

CcdImageList lsst::jointcal::Associations::ccdImageList

Definition at line 56 of file Associations.h.

fittedStarList

FittedStarList lsst::jointcal::Associations::fittedStarList

Definition at line 58 of file Associations.h.

refStarList

RefStarList lsst::jointcal::Associations::refStarList

Definition at line 57 of file Associations.h.

---

The documentation for this class was generated from the following files:

• /j/snowflake/release/lsstsw/stack/1a1d771/Linux64/jointcal/20.0.0/include/lsst/jointcal/Associations.h
• /j/snowflake/release/lsstsw/stack/1a1d771/Linux64/jointcal/20.0.0/src/Associations.cc