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::afw::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::afw::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	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, afw::geom::Angle matchCut, std::string const &fluxField, 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...
const lsst::afw::geom::Box2D	getRaDecBBox ()
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 53 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 68 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 80 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

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 88 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,
		afw::geom::Angle	matchCut,
		std::string const &	fluxField,
		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.
	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 172 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"];
    auto fluxKey = refCat.getSchema().find<double>(fluxField).key;
    // Don't blow up if the reference catalog doesn't contain 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::afw::geom::radToDeg(coord.getLongitude());
        double dec = lsst::afw::geom::radToDeg(coord.getLatitude());
        auto star = std::make_shared<RefStar>(ra, dec, flux, fluxErr);

        // TODO DM-10826: RefCats aren't guaranteed to have position errors.
        // TODO: Need to devise a way to check whether the refCat has position errors
        // TODO: and use them instead, if available.
        // cook up errors: 100 mas per cooordinate
        star->vx = std::pow(0.1 / 3600 / cos(coord.getLatitude()), 2);
        star->vy = std::pow(0.1 / 3600, 2);
        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);
}

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 72 of file Associations.cc.

                                             {
    std::vector<afw::geom::SpherePoint> centers;
    centers.reserve(ccdImageList.size());
    for (auto const &ccdImage : ccdImageList) {
        centers.push_back(ccdImage->getBoresightRaDec());
    }
    auto commonTangentPoint = afw::geom::averageSpherePoint(centers);
    LOGLS_DEBUG(_log, "Using common tangent point: " << commonTangentPoint.getPosition(afw::geom::degrees));
    setCommonTangentPoint(commonTangentPoint.getPosition(afw::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::afw::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 58 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 368 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 62 of file Associations.h.

{ return fittedStarList.size(); }

getCcdImageList()

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

inline

Definition at line 162 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 104 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 165 of file Associations.h.

{ return 1; }

getRaDecBBox()

const lsst::afw::geom::Box2D lsst::jointcal::Associations::getRaDecBBox

(

)

Definition at line 227 of file Associations.cc.

                                                  {
    // compute the frame on the CTP 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);

    lsst::afw::geom::Point<double> min(raDecFrame.xMin, raDecFrame.yMin);
    lsst::afw::geom::Point<double> max(raDecFrame.xMax, raDecFrame.yMax);
    lsst::afw::geom::Box2D box(min, max);

    return box;
}

nCcdImagesValidForFit()

int lsst::jointcal::Associations::nCcdImagesValidForFit

(

)

const

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

Definition at line 382 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 388 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 const &  )

delete

operator=() [2/2]

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

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 277 of file Associations.cc.

                                                         {
    selectFittedStars(minMeasurements);
    normalizeFittedStars();
}

refStarListSize()

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

inline

Definition at line 61 of file Associations.h.

{ return refStarList.size(); }

setCommonTangentPoint()

void lsst::jointcal::Associations::setCommonTangentPoint

(

lsst::afw::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 83 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 55 of file Associations.h.

fittedStarList

FittedStarList lsst::jointcal::Associations::fittedStarList

Definition at line 57 of file Associations.h.

refStarList

RefStarList lsst::jointcal::Associations::refStarList

Definition at line 56 of file Associations.h.

---

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

• /j/snowflake/release/lsstsw/stack/Linux64/jointcal/16.0-32-g88a4f23+5/include/lsst/jointcal/Associations.h
• /j/snowflake/release/lsstsw/stack/Linux64/jointcal/16.0-32-g88a4f23+5/src/Associations.cc