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 imageList, double epoch=0)
	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...
size_t	getMaxMeasuredStars () const
	The number of MeasuredStars at the start of fitting, before any outliers are removed. More...
void	createCcdImage (afw::table::SourceCatalog &catalog, const std::shared_ptr< lsst::afw::geom::SkyWcs > &wcs, const std::shared_ptr< lsst::afw::image::VisitInfo > &visitInfo, const lsst::geom::Box2I &bbox, const std::string &filter, const std::shared_ptr< afw::image::PhotoCalib > &photoCalib, const std::shared_ptr< afw::cameraGeom::Detector > &detector, int visit, int ccd, const lsst::jointcal::JointcalControl &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 (double matchCutInArcsec=0, bool useFittedList=false, 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)
	Prepare the fittedStar list by making quality cuts and normalizing measurements. More...
void	cleanFittedStars ()
	Remove FittedStars that have no measured stars; this can happen after outlier rejection. 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...
void	setCommonTangentPoint (lsst::geom::Point2D const &commonTangentPoint)
	Shared tangent point for all ccdImages (decimal degrees). More...
Point	getCommonTangentPoint () const
	Shared tangent point for all ccdImages (decimal degrees). More...
double	getEpoch () const
	Common epoch of all of the ccdImages as a Julian Epoch Year (e.g. More...
void	setEpoch (double epoch)
	Common epoch of all of the ccdImages as a Julian Epoch Year (e.g. More...

Public Attributes
CcdImageList	ccdImageList
RefStarList	refStarList
FittedStarList	fittedStarList

Detailed Description

The class that implements the relations between MeasuredStar and FittedStar.

Definition at line 55 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 70 of file Associations.h.

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

Associations() [2/4]

lsst::jointcal::Associations::Associations ( CcdImageList  imageList, double  epoch = 0  )

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.
epoch	The julian epoch year to which all proper motion corrections should be made.

Definition at line 84 of file Associations.h.

            : ccdImageList(std::move(imageList)),
              _commonTangentPoint(Point(std::numeric_limits<double>::quiet_NaN(),
                                        std::numeric_limits<double>::quiet_NaN())),
              _maxMeasuredStars(0),
              _epoch(epoch) {}

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 146 of file Associations.h.

{ ccdImageList.push_back(ccdImage); }

associateCatalogs()

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

incrementaly builds a merged catalog of all image catalogs

Definition at line 120 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_DEBUG(_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_DEBUG(_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();
}

cleanFittedStars()

void lsst::jointcal::Associations::cleanFittedStars

(

)

Remove FittedStars that have no measured stars; this can happen after outlier rejection.

Use this to perform e.g. position minimization with outlier rejection after model minimization has removed measuredStar outliers, to prevent the matrix from becoming non-positive definite. Once this has been called, prepareFittedStars() has to be called again if the full measuredStar->FittedStar relationship needs to be reconstructed.

Definition at line 424 of file Associations.cc.

                                    {
    auto iter = fittedStarList.begin();
    auto end = fittedStarList.end();
    size_t count = 0;
    while (iter != end) {
        auto fittedStar = *iter;
        if (fittedStar->getMeasurementCount() == 0) {
            LOGLS_TRACE(_log, "Deleting FittedStar (has no measuredStars): " << *fittedStar);
            iter = fittedStarList.erase(iter);
            count++;
        } else {
            ++iter;
        }
    }
    if (count > 0) {
        LOGLS_INFO(_log, "Removed " << count << " fittedStars that had no associated measuredStar.");
    }
}

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 204 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.");
    }
 
    // Handle reference catalogs that don't have proper motion & error
    afw::table::Key<geom::Angle> pmRaKey, pmDecKey;
    afw::table::Key<float> pmRaErrKey, pmDecErrKey, pmRaDecCovKey;
    try {
        pmRaKey = refCat.getSchema().find<geom::Angle>("pm_ra").key;
        pmDecKey = refCat.getSchema().find<geom::Angle>("pm_dec").key;
    } catch (pex::exceptions::NotFoundError &ex) {
        LOGLS_WARN(_log, "Not loading proper motions: (pm_ra,pm_dec) fields not found in reference catalog.");
    } catch (pex::exceptions::TypeError &ex) {
        LOGLS_WARN(_log, "Not loading proper motions: RA/Dec proper motion values must be `geom:Angle`: "
                                 << ex.what());
    }
    try {
        pmRaErrKey = refCat.getSchema().find<float>("pm_raErr").key;
        pmDecErrKey = refCat.getSchema().find<float>("pm_decErr").key;
    } catch (pex::exceptions::NotFoundError &ex) {
        LOGLS_WARN(_log, "Not loading proper motions: error fields not available: " << ex.what());
    }
 
    // TODO: we aren't getting covariances from Gaia yet, so maybe ignore this for now?
    try {
        pmRaDecCovKey = refCat.getSchema().find<float>("pm_ra_Dec_Cov").key;
    } catch (pex::exceptions::NotFoundError &ex) {
        LOGLS_WARN(_log, "No ra/dec proper motion covariances in refcat: " << ex.what());
    }
 
    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)) {
            // refcat errors are unitless but stored as radians: convert to deg**2
            star->vx = std::pow(lsst::geom::radToDeg(record->get(raErrKey)), 2);
            star->vy = std::pow(lsst::geom::radToDeg(record->get(decErrKey)), 2);
        } else {
            // Convert the fake errors from mas to deg**2
            star->vx = std::pow(refCoordinateErr / 1000. / 3600. / std::cos(coord.getLatitude()), 2);
            star->vy = std::pow(refCoordinateErr / 1000. / 3600., 2);
        }
 
        if (pmRaKey.isValid()) {
            if (pmRaDecCovKey.isValid()) {
                star->setProperMotion(std::make_unique<ProperMotion const>(
                        record->get(pmRaKey).asRadians(), record->get(pmDecKey).asRadians(),
                        record->get(pmRaErrKey), record->get(pmDecErrKey), record->get(pmRaDecCovKey)));
            } else {
                star->setProperMotion(std::make_unique<ProperMotion const>(
                        record->get(pmRaKey).asRadians(), record->get(pmDecKey).asRadians(),
                        record->get(pmRaErrKey), record->get(pmDecErrKey)));
            }
        }
 
        // 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 90 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.
    LOGLS_INFO(_log, "Computed tangent plane box for data (degrees): " << raDecFrame);
    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 74 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,
		const std::shared_ptr< lsst::afw::geom::SkyWcs > &	wcs,
		const std::shared_ptr< lsst::afw::image::VisitInfo > &	visitInfo,
		const lsst::geom::Box2I &	bbox,
		const std::string &	filter,
		const std::shared_ptr< afw::image::PhotoCalib > &	photoCalib,
		const std::shared_ptr< afw::cameraGeom::Detector > &	detector,
		int	visit,
		int	ccd,
		const lsst::jointcal::JointcalControl &	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);
}

deprojectFittedStars()

void lsst::jointcal::Associations::deprojectFittedStars

(

)

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

Definition at line 454 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 64 of file Associations.h.

{ return fittedStarList.size(); }

getCcdImageList()

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

inline

Definition at line 189 of file Associations.h.

{ return ccdImageList; }

getCommonTangentPoint()

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

inline

Shared tangent point for all ccdImages (decimal degrees).

Used to project sidereal coordinates related to the images onto a single plane.

Definition at line 109 of file Associations.h.

{ return _commonTangentPoint; }

getEpoch()

double lsst::jointcal::Associations::getEpoch ( ) const

inline

Common epoch of all of the ccdImages as a Julian Epoch Year (e.g.

2000.0 for J2000).

Definition at line 119 of file Associations.h.

{ return _epoch; }

getMaxMeasuredStars()

size_t lsst::jointcal::Associations::getMaxMeasuredStars ( ) const

inline

The number of MeasuredStars at the start of fitting, before any outliers are removed.

Definition at line 113 of file Associations.h.

{ return _maxMeasuredStars; }

getNFilters()

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

inline

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

Definition at line 192 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 468 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 474 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

)

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

                                                         {
    selectFittedStars(minMeasurements);
    normalizeFittedStars();
}

refStarListSize()

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

inline

Definition at line 63 of file Associations.h.

{ return refStarList.size(); }

setCommonTangentPoint()

void lsst::jointcal::Associations::setCommonTangentPoint

(

lsst::geom::Point2D const &

commonTangentPoint

)

Shared tangent point for all ccdImages (decimal degrees).

Used to project sidereal coordinates related to the images onto a single plane.

Definition at line 85 of file Associations.cc.

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

setEpoch()

void lsst::jointcal::Associations::setEpoch ( double  epoch )

inline

Common epoch of all of the ccdImages as a Julian Epoch Year (e.g.

2000.0 for J2000).

Definition at line 120 of file Associations.h.

{ _epoch = epoch; }

Member Data Documentation

ccdImageList

CcdImageList lsst::jointcal::Associations::ccdImageList

Definition at line 57 of file Associations.h.

fittedStarList

FittedStarList lsst::jointcal::Associations::fittedStarList

Definition at line 59 of file Associations.h.

refStarList

RefStarList lsst::jointcal::Associations::refStarList

Definition at line 58 of file Associations.h.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-5.0.0/Linux64/jointcal/gc9534b9d65+35b9f25267/include/lsst/jointcal/Associations.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-5.0.0/Linux64/jointcal/gc9534b9d65+35b9f25267/src/Associations.cc