lsst::jointcal Namespace Reference

Namespaces
namespace	cameraGeometry
namespace	check_logged_chi2
namespace	dataIds
namespace	jointcal
namespace	testUtils
namespace	version

Classes
class	Associations
	The class that implements the relations between MeasuredStar and FittedStar. More...
class	AstrometryFit
	Class that handles the astrometric least squares problem. More...
class	AstrometryMapping
	virtual class needed in the abstraction of the distortion model More...
class	AstrometryModel
	Interface between AstrometryFit and the combinations of Mappings from pixels to some tangent plane (aka distortions). More...
class	AstrometryTransform
	a virtual (interface) class for geometric transformations. More...
class	AstrometryTransformComposition
	Private class to handle AstrometryTransform compositions (i.e. More...
class	AstrometryTransformIdentity
	A do-nothing transformation. It anyway has dummy routines to mimick a AstrometryTransform. More...
class	AstrometryTransformInverse
class	AstrometryTransformLinear
	implements the linear transformations (6 real coefficients). More...
class	AstrometryTransformLinearRot
	just here to provide a specialized constructor, and fit. More...
class	AstrometryTransformLinearScale
	just here to provide specialized constructors. AstrometryTransformLinear fit routine. More...
class	AstrometryTransformLinearShift
	just here to provide a specialized constructor, and fit. More...
class	AstrometryTransformPolynomial
	Polynomial transformation class. More...
class	AstrometryTransformSkyWcs
	A AstrometryTransform that holds a SkyWcs. More...
class	BaseStar
	The base class for handling stars. Used by all matching routines. More...
class	BaseTanWcs
class	CcdImage
	Handler of an actual image from a single CCD. More...
struct	CcdImageKey
	For hashing a ccdImage: the pair of (visit, ccd) IDs should be unique to each ccdImage. More...
class	Chi2Accumulator
	Base class for Chi2Statistic and Chi2List, to allow addEntry inside Fitter for either class. More...
class	Chi2List
	Structure to accumulate the chi2 contributions per each star (to help find outliers). More...
struct	Chi2Star
class	Chi2Statistic
	Simple structure to accumulate chi2 and ndof. More...
class	ChipVisitAstrometryMapping
	The mapping with two transforms in a row. More...
class	ChipVisitFluxMapping
class	ChipVisitMagnitudeMapping
class	ChipVisitPhotometryMapping
	A two-level photometric transform: one for the ccd and one for the visit. More...
class	ConstrainedAstrometryModel
	A multi-component model, fitting mappings for sensors and visits simultaneously. More...
class	ConstrainedFluxModel
class	ConstrainedMagnitudeModel
class	ConstrainedPhotometryModel
	Photometry model with constraints, \(M(x,y) = M_CCD(x,y)*M_visit(u,v)\). More...
class	FastFinder
	This is an auxillary class for matching objects from starlists. More...
class	FatPoint
	A Point with uncertainties. More...
class	FittedStar
	FittedStars are objects whose position or flux is going to be fitted, and which come from the association of multiple MeasuredStars. More...
class	FittedStarList
	A list of FittedStar s. Such a list is typically constructed by Associations. More...
class	FitterBase
	Base class for fitters. More...
class	FluxTransformChebyshev
	nth-order 2d Chebyshev photometry transform, times the input flux. More...
class	FluxTransformSpatiallyInvariant
	Photometric offset independent of position, defined as (fluxMag0)^-1. More...
class	Frame
	rectangle with sides parallel to axes. More...
class	Histo2d
class	IdentityProjectionHandler
	The simplest implementation of ProjectionHandler. More...
struct	JointcalControl
class	MagnitudeTransformChebyshev
	nth-order 2d Chebyshev photometry transform, plus the input flux. More...
class	MagnitudeTransformSpatiallyInvariant
	Photometric offset independent of position, defined as -2.5 * log(flux / fluxMag0). More...
struct	MatchConditions
	Parameters to be provided to combinatorial searches. More...
class	MeasuredStar
	Sources measured on images. More...
class	MeasuredStarList
	A list of MeasuredStar. They are usually filled in Associations::createCcdImage. More...
class	OneTPPerVisitHandler
	A projection handler in which all CCDs from the same visit have the same tangent point. More...
class	PhotometryFit
	Class that handles the photometric least squares problem. More...
class	PhotometryMapping
	A mapping containing a single photometryTransform. More...
class	PhotometryMappingBase
	Relates transform(s) to their position in the fitting matrix and allows interaction with the transform(s). More...
class	PhotometryModel
class	PhotometryTransform
	A photometric transform, defined in terms of the input flux or magnitude. More...
class	PhotometryTransformChebyshev
	nth-order 2d Chebyshev photometry transform. More...
class	PhotometryTransformSpatiallyInvariant
	Photometry offset independent of position. More...
class	Point
	A point in a plane. More...
class	PolyXY
struct	ProjectionHandler
	This is a virtual class that allows a lot of freedom in the choice of the projection from "Sky" (where coodinates are reported) to tangent plane (where they are compared to transformed measurements) More...
class	ProperMotion
	Proper motion data for a reference star or fitted star. More...
class	RefStar
	Objects used as position/flux anchors (e.g. More...
class	RefStarList
struct	Segment
class	SegmentList
struct	SegmentPair
class	SimpleAstrometryMapping
class	SimpleAstrometryModel
	A model where there is one independent transform per CcdImage. More...
class	SimpleFluxModel
class	SimpleMagnitudeModel
class	SimplePhotometryModel
	Photometric response model which has a single photometric factor per CcdImage. More...
class	SimplePolyMapping
	Mapping implementation for a polynomial transformation. More...
class	SparseHisto4d
	A class to histogram in 4 dimensions. More...
class	StarList
	std::lists of Stars. More...
class	StarMatch
	A hanger for star associations. More...
class	StarMatchList
class	TanPixelToRaDec
	The transformation that handles pixels to sideral transformations (Gnomonic, possibly with polynomial distortions). More...
class	TanRaDecToPixel
	This one is the Tangent Plane (called gnomonic) projection (from celestial sphere to tangent plane) More...
class	TanSipPixelToRaDec
	Implements the (forward) SIP distorsion scheme. More...
class	TripletList
class	UserTransform
	A run-time transform that allows users to define a AstrometryTransform with minimal coding (just the apply routine). More...

Typedefs
using	RefFluxMapType = std::map< std::string, std::vector< double > >
using	AstrometryTransformFun = void(const double, const double, double &, double &, const void *)
	signature of the user-provided routine that actually does the coordinate transform for UserTransform. More...
using	BaseStarList = StarList< BaseStar >
using	BaseStarCIterator = BaseStarList::const_iterator
using	BaseStarIterator = BaseStarList::iterator
using	CcdImageList = std::list< std::shared_ptr< CcdImage > >
using	VisitIdType = long
using	CcdIdType = int
using	FittedStarCIterator = FittedStarList::const_iterator
using	FittedStarIterator = FittedStarList::iterator
using	MeasuredStarCIterator = MeasuredStarList::const_iterator
using	MeasuredStarIterator = MeasuredStarList::iterator
using	RefStarCIterator = RefStarList::const_iterator
using	RefStarIterator = RefStarList::iterator
using	StarMatchIterator = ::std::list< StarMatch >::iterator
using	StarMatchCIterator = ::std::list< StarMatch >::const_iterator
using	Trip = Eigen::Triplet< double >
using	Iterator = FastFinder::Iterator
using	SegmentIterator = std::list< Segment >::iterator
using	SegmentCIterator = std::list< Segment >::const_iterator
using	SegmentPairList = std::list< SegmentPair >
using	SegmentPairListIterator = SegmentPairList::iterator
using	SegmentPairListCIterator = SegmentPairList::const_iterator
using	SolList = std::list< std::unique_ptr< StarMatchList > >

Enumerations
enum class	MinimizeResult { Converged , Chi2Increased , Failed , NonFinite }
	Return value of minimize() More...

Functions
std::ostream &	operator<< (std::ostream &stream, AstrometryMapping const &mapping)
std::ostream &	operator<< (std::ostream &stream, AstrometryModel const &model)
std::ostream &	operator<< (std::ostream &stream, AstrometryTransform const &transform)
std::unique_ptr< AstrometryTransform >	compose (AstrometryTransform const &left, AstrometryTransform const &right)
	Returns a pointer to a composition of transforms, representing left(right()). More...
std::unique_ptr< AstrometryTransform >	compose (AstrometryTransform const &left, AstrometryTransformIdentity const &right)
bool	isIntegerShift (const AstrometryTransform *transform)
	Shorthand test to tell if a transform is a simple integer shift. More...
std::shared_ptr< AstrometryTransformPolynomial >	inversePolyTransform (AstrometryTransform const &forward, Frame const &domain, double precision, std::size_t maxOrder=9, std::size_t nSteps=50)
	Approximate the inverse by a polynomial, to some precision. More...
AstrometryTransformLinear	normalizeCoordinatesTransform (const Frame &frame)
	Returns the transformation that maps the input frame along both axes to [-1,1]. More...
std::unique_ptr< AstrometryTransform >	astrometryTransformRead (const std::string &fileName)
	The virtual constructor from a file. More...
std::unique_ptr< AstrometryTransform >	astrometryTransformRead (std::istream &s)
	The virtual constructor from a file. More...
std::ostream &	operator<< (std::ostream &out, CcdImageKey const &key)
BaseStarList &	Fitted2Base (FittedStarList &This)
BaseStarList *	Fitted2Base (FittedStarList *This)
const BaseStarList &	Fitted2Base (const FittedStarList &This)
const BaseStarList *	Fitted2Base (const FittedStarList *This)
std::unique_ptr< StarMatchList >	matchSearchRotShift (BaseStarList &list1, BaseStarList &list2, const MatchConditions &conditions)
	searches a geometrical transformation that goes from list1 to list2. More...
std::unique_ptr< StarMatchList >	matchSearchRotShiftFlip (BaseStarList &list1, BaseStarList &list2, const MatchConditions &conditions)
	same as above but searches also a flipped solution. More...
std::unique_ptr< StarMatchList >	listMatchCollect (const BaseStarList &list1, const BaseStarList &list2, const AstrometryTransform *guess, double maxDist)
	assembles star matches. More...
std::unique_ptr< StarMatchList >	listMatchCollect (const BaseStarList &list1, const BaseStarList &list2, double maxDist)
	same as before except that the transform is the identity More...
std::unique_ptr< AstrometryTransformLinear >	listMatchupShift (const BaseStarList &list1, const BaseStarList &list2, const AstrometryTransform &transform, double maxShift, double binSize=0)
	searches for a 2 dimensional shift using a very crude histogram method. More...
std::unique_ptr< AstrometryTransform >	listMatchCombinatorial (const BaseStarList &list1, const BaseStarList &list2, const MatchConditions &conditions=MatchConditions())
std::unique_ptr< AstrometryTransform >	listMatchRefine (const BaseStarList &list1, const BaseStarList &list2, std::unique_ptr< AstrometryTransform > transform, int maxOrder=3)
BaseStarList &	Measured2Base (MeasuredStarList &This)
BaseStarList *	Measured2Base (MeasuredStarList *This)
const BaseStarList &	Measured2Base (const MeasuredStarList &This)
const BaseStarList *	Measured2Base (const MeasuredStarList *This)
std::ostream &	operator<< (std::ostream &stream, const Point &point)
std::ostream &	operator<< (std::ostream &stream, ProjectionHandler const &projectionHandler)
BaseStarList &	Ref2Base (RefStarList &This)
BaseStarList *	Ref2Base (RefStarList *This)
const BaseStarList &	Ref2Base (const RefStarList &This)
const BaseStarList *	Ref2Base (const RefStarList *This)
template<class Star >
std::ostream &	operator<< (std::ostream &stream, const StarList< Star > &list)
	enables More...
bool	compareStar1 (const StarMatch &one, const StarMatch &two)
bool	sameStar1 (const StarMatch &one, const StarMatch &two)
bool	compareStar2 (const StarMatch &one, const StarMatch &two)
bool	sameStar2 (const StarMatch &one, const StarMatch &two)
std::ostream &	operator<< (std::ostream &stream, const StarMatch &match)
std::ostream &	operator<< (std::ostream &stream, const StarMatchList &starMatchList)
	A std::list of star matches,. More...
double	computeDist2 (const StarMatchList &S, const AstrometryTransform &transform)
	sum of distance squared More...
double	computeChi2 (const StarMatchList &L, const AstrometryTransform &transform)
	the actual chi2 More...
std::ostream &	operator<< (std::ostream &s, Chi2List const &chi2List)
std::ostream &	operator<< (std::ostream &stream, ProperMotion const &pm)

Typedef Documentation

AstrometryTransformFun

using lsst::jointcal::AstrometryTransformFun = typedef void (const double, const double, double &, double &, const void *)

signature of the user-provided routine that actually does the coordinate transform for UserTransform.

Definition at line 754 of file AstrometryTransform.h.

BaseStarCIterator

using lsst::jointcal::BaseStarCIterator = typedef BaseStarList::const_iterator

Definition at line 123 of file BaseStar.h.

BaseStarIterator

using lsst::jointcal::BaseStarIterator = typedef BaseStarList::iterator

Definition at line 124 of file BaseStar.h.

BaseStarList

using lsst::jointcal::BaseStarList = typedef StarList<BaseStar>

Definition at line 121 of file BaseStar.h.

CcdIdType

using lsst::jointcal::CcdIdType = typedef int

Definition at line 49 of file CcdImage.h.

CcdImageList

using lsst::jointcal::CcdImageList = typedef std::list<std::shared_ptr<CcdImage> >

Definition at line 46 of file CcdImage.h.

FittedStarCIterator

using lsst::jointcal::FittedStarCIterator = typedef FittedStarList::const_iterator

Definition at line 124 of file FittedStar.h.

FittedStarIterator

using lsst::jointcal::FittedStarIterator = typedef FittedStarList::iterator

Definition at line 125 of file FittedStar.h.

Iterator

using lsst::jointcal::Iterator = typedef FastFinder::Iterator

Definition at line 178 of file FastFinder.cc.

MeasuredStarCIterator

using lsst::jointcal::MeasuredStarCIterator = typedef MeasuredStarList::const_iterator

Definition at line 158 of file MeasuredStar.h.

MeasuredStarIterator

using lsst::jointcal::MeasuredStarIterator = typedef MeasuredStarList::iterator

Definition at line 159 of file MeasuredStar.h.

RefFluxMapType

using lsst::jointcal::RefFluxMapType = typedef std::map<std::string, std::vector<double> >

Definition at line 52 of file Associations.h.

RefStarCIterator

using lsst::jointcal::RefStarCIterator = typedef RefStarList::const_iterator

Definition at line 89 of file RefStar.h.

RefStarIterator

using lsst::jointcal::RefStarIterator = typedef RefStarList::iterator

Definition at line 90 of file RefStar.h.

SegmentCIterator

using lsst::jointcal::SegmentCIterator = typedef std::list<Segment>::const_iterator

Definition at line 92 of file ListMatch.cc.

SegmentIterator

using lsst::jointcal::SegmentIterator = typedef std::list<Segment>::iterator

Definition at line 91 of file ListMatch.cc.

SegmentPairList

using lsst::jointcal::SegmentPairList = typedef std::list<SegmentPair>

Definition at line 119 of file ListMatch.cc.

SegmentPairListCIterator

using lsst::jointcal::SegmentPairListCIterator = typedef SegmentPairList::const_iterator

Definition at line 121 of file ListMatch.cc.

SegmentPairListIterator

using lsst::jointcal::SegmentPairListIterator = typedef SegmentPairList::iterator

Definition at line 120 of file ListMatch.cc.

SolList

using lsst::jointcal::SolList = typedef std::list<std::unique_ptr<StarMatchList> >

Definition at line 156 of file ListMatch.cc.

StarMatchCIterator

using lsst::jointcal::StarMatchCIterator = typedef ::std::list<StarMatch>::const_iterator

Definition at line 135 of file StarMatch.h.

StarMatchIterator

using lsst::jointcal::StarMatchIterator = typedef ::std::list<StarMatch>::iterator

Definition at line 134 of file StarMatch.h.

Trip

using lsst::jointcal::Trip = typedef Eigen::Triplet<double>

Definition at line 35 of file Tripletlist.h.

VisitIdType

using lsst::jointcal::VisitIdType = typedef long

Definition at line 48 of file CcdImage.h.

Enumeration Type Documentation

MinimizeResult

enum class lsst::jointcal::MinimizeResult

strong

Return value of minimize()

Enumerator
Converged
Chi2Increased
Failed
NonFinite

Definition at line 42 of file FitterBase.h.

                          {
    Converged,      // fit has converged - no more outliers
    Chi2Increased,  // still some ouliers but chi2 increases
    Failed,         // factorization failed
    NonFinite       // non-finite chi2 statistic
};

Function Documentation

astrometryTransformRead() [1/2]

std::unique_ptr< AstrometryTransform > lsst::jointcal::astrometryTransformRead

(

const std::string &

fileName

)

The virtual constructor from a file.

Definition at line 1811 of file AstrometryTransform.cc.

                                                                                      {
    ifstream s(fileName.c_str());
    if (!s)
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError,
                          " astrometryTransformRead : cannot open " + fileName);
    try {
        std::unique_ptr<AstrometryTransform> res(astrometryTransformRead(s));
        s.close();
        return res;
    } catch (pex::exceptions::InvalidParameterError &e) {
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError,
                          std::string(e.what()) + " in file " + fileName);
    }
}

astrometryTransformRead() [2/2]

std::unique_ptr< AstrometryTransform > lsst::jointcal::astrometryTransformRead

(

std::istream &

s

)

The virtual constructor from a file.

Definition at line 1826 of file AstrometryTransform.cc.

                                                                       {
    std::string type;
    s >> type;
    if (s.fail())
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError,
                          "astrometryTransformRead : could not find a AstrometryTransformtype");
    if (type == "AstrometryTransformIdentity") {
        std::unique_ptr<AstrometryTransformIdentity> res(new AstrometryTransformIdentity());
        res->read(s);
        return std::move(res);
    } else if (type == "AstrometryTransformPolynomial") {
        std::unique_ptr<AstrometryTransformPolynomial> res(new AstrometryTransformPolynomial());
        res->read(s);
        return std::move(res);
    } else
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError,
                          " astrometryTransformRead : No reader for AstrometryTransform type " + type);
}

compareStar1()

bool lsst::jointcal::compareStar1 ( const StarMatch &  one, const StarMatch &  two  )

inline

Definition at line 116 of file StarMatch.h.

                                                                     {
    return ((one.s1 == two.s1) ? (one.distance < two.distance) : (&(*one.s1) > &(*two.s1)));
}

compareStar2()

bool lsst::jointcal::compareStar2 ( const StarMatch &  one, const StarMatch &  two  )

inline

Definition at line 122 of file StarMatch.h.

                                                                     {
    return ((one.s2 == two.s2) ? (one.distance < two.distance) : (&(*one.s2) > &(*two.s2)));
}

compose() [1/2]

std::unique_ptr< AstrometryTransform > lsst::jointcal::compose	(	AstrometryTransform const &	left,
		AstrometryTransform const &	right
	)

Returns a pointer to a composition of transforms, representing left(right()).

Deletion of returned value to be done by caller.

If left->composeAndReduce(right) returns NULL, build a AstrometryTransformComposition and return it. This routine implements "run-time" compositions. When there is a possible "reduction" (e.g. compositions of polynomials), compose detects it and returns a genuine AstrometryTransform.

Returns

The composed transform.

Definition at line 427 of file AstrometryTransform.cc.

                                                                               {
    // Try to use the composeAndReduce method from left. If absent, AstrometryTransform::composeAndReduce
    // returns NULL. composeAndReduce is non trivial for polynomials.
    std::unique_ptr<AstrometryTransform> composition(left.composeAndReduce(right));
    // composition == NULL means no reduction: just build a Composition that pipelines "left" and "right".
    if (composition == nullptr)
        return std::make_unique<AstrometryTransformComposition>(left, right);
    else
        return composition;
}

compose() [2/2]

std::unique_ptr< AstrometryTransform > lsst::jointcal::compose	(	AstrometryTransform const &	left,
		AstrometryTransformIdentity const &	right
	)

Definition at line 422 of file AstrometryTransform.cc.

                                                                                       {
    return left.clone();
}

computeChi2()

double lsst::jointcal::computeChi2	(	const StarMatchList &	L,
		const AstrometryTransform &	transform
	)

the actual chi2

Definition at line 244 of file StarMatch.cc.

                                                                                             {
    auto chi2s(chi2_array(starMatchList, transform));
    double chi2 = 0;
    for (auto const &c : chi2s) chi2 += c;
    return chi2;
}

computeDist2()

double lsst::jointcal::computeDist2	(	const StarMatchList &	S,
		const AstrometryTransform &	transform
	)

sum of distance squared

Definition at line 237 of file StarMatch.cc.

                                                                                              {
    double dist2 = 0;
    for (auto const &starMatch : starMatchList)
        dist2 += transform.apply(starMatch.point1).computeDist2(starMatch.point2);
    return dist2;
}

Fitted2Base() [1/4]

const BaseStarList & lsst::jointcal::Fitted2Base

(

const FittedStarList &

This

)

Definition at line 68 of file FittedStar.cc.

{ return (const BaseStarList &)This; }

Fitted2Base() [2/4]

const BaseStarList * lsst::jointcal::Fitted2Base

(

const FittedStarList *

This

)

Definition at line 70 of file FittedStar.cc.

{ return (BaseStarList *)This; }

Fitted2Base() [3/4]

BaseStarList & lsst::jointcal::Fitted2Base

(

FittedStarList &

This

)

Definition at line 64 of file FittedStar.cc.

{ return (BaseStarList &)This; }

Fitted2Base() [4/4]

BaseStarList * lsst::jointcal::Fitted2Base

(

FittedStarList *

This

)

Definition at line 66 of file FittedStar.cc.

{ return (BaseStarList *)This; }

inversePolyTransform()

std::shared_ptr< AstrometryTransformPolynomial > lsst::jointcal::inversePolyTransform	(	AstrometryTransform const &	forward,
		Frame const &	domain,
		double	precision,
		std::size_t	maxOrder = 9,
		std::size_t	nSteps = 50
	)

Approximate the inverse by a polynomial, to some precision.

Parameters

	forward	Transform to be inverted.
[in]	domain	The domain of forward.
[in]	precision	Require that \(chi2 / (nsteps^2) < precision^2\).
[in]	maxOrder	The maximum order allowed of the inverse polynomial.
[in]	nSteps	The number of sample points per axis (nSteps^2 total points).

Returns

A polynomial that best approximates forward.

Definition at line 1149 of file AstrometryTransform.cc.

                                                                                      {
    StarMatchList sm;
    double xStart = domain.xMin;
    double yStart = domain.yMin;
    double xStep = domain.getWidth() / (nSteps - 1);
    double yStep = domain.getHeight() / (nSteps - 1);
    for (std::size_t i = 0; i < nSteps; ++i) {
        for (std::size_t j = 0; j < nSteps; ++j) {
            Point in(xStart + i * xStep, yStart + j * yStep);
            Point out(forward.apply(in));
            sm.push_back(StarMatch(out, in, nullptr, nullptr));
        }
    }
    std::size_t npairs = sm.size();
    std::size_t order;
    std::shared_ptr<AstrometryTransformPolynomial> poly;
    std::shared_ptr<AstrometryTransformPolynomial> oldPoly;
    double chi2 = 0;
    double oldChi2 = std::numeric_limits<double>::infinity();
    for (order = 1; order <= maxOrder; ++order) {
        poly.reset(new AstrometryTransformPolynomial(order));
        auto success = poly->fit(sm);
        if (success == -1) {
            std::stringstream errMsg;
            errMsg << "Cannot fit a polynomial of order " << order << " with " << nSteps << "^2 points";
            throw pexExcept::RuntimeError(errMsg.str());
        }
        // compute the chi2 ignoring errors:
        chi2 = 0;
        for (auto const &i : sm) chi2 += i.point2.computeDist2(poly->apply((i.point1)));
        LOGLS_TRACE(_log, "inversePoly order " << order << ": " << chi2 << " / " << npairs << " = "
                                               << chi2 / npairs << " < " << precision * precision);
 
        if (chi2 / npairs < precision * precision) break;
 
        // If this triggers, we know we did not reach the required precision.
        if (chi2 > oldChi2) {
            LOGLS_WARN(_log, "inversePolyTransform: chi2 increases ("
                                     << chi2 << " > " << oldChi2 << "); ending fit with order: " << order);
            LOGLS_WARN(_log, "inversePolyTransform: requested precision not reached: "
                                     << chi2 << " / " << npairs << " = " << chi2 / npairs << " < "
                                     << precision * precision);
            poly = std::move(oldPoly);
            order--;
            break;
        } else {
            oldChi2 = chi2;
            // Clone it so we don't lose it in the next iteration.
            oldPoly = dynamic_pointer_cast<AstrometryTransformPolynomial>(
                    std::shared_ptr<AstrometryTransform>(poly->clone()));
        }
    }
    if (order > maxOrder)
        LOGLS_WARN(_log, "inversePolyTransform: Reached max order without reaching requested precision: "
                                 << chi2 << " / " << npairs << " = " << chi2 / npairs << " < "
                                 << precision * precision);
    return poly;
}

isIntegerShift()

bool lsst::jointcal::isIntegerShift

(

const AstrometryTransform *

transform

)

Shorthand test to tell if a transform is a simple integer shift.

Definition at line 57 of file AstrometryTransform.cc.

                                                          {
    const auto *shift =
            dynamic_cast<const AstrometryTransformPolynomial *>(transform);
    if (shift == nullptr) return false;
 
    static const double eps = 1e-5;
 
    double dx = shift->getCoefficient(0, 0, 0);
    double dy = shift->getCoefficient(0, 0, 1);
 
    static Point dumb(4000, 4000);
    if (fabs(dx - int(floor(dx + 0.5))) < eps && fabs(dy - int(floor(dy + 0.5))) < eps &&
        fabs(dumb.x + dx - shift->apply(dumb).x) < eps && fabs(dumb.y + dy - shift->apply(dumb).y) < eps)
        return true;
 
    return false;
}

listMatchCollect() [1/2]

std::unique_ptr< StarMatchList > lsst::jointcal::listMatchCollect	(	const BaseStarList &	list1,
		const BaseStarList &	list2,
		const AstrometryTransform *	guess,
		double	maxDist
	)

assembles star matches.

It picks stars in list1, transforms them through guess, and collects closest star in list2, and builds a match if closer than maxDist).

Definition at line 568 of file ListMatch.cc.

                                                                                                        {
    std::unique_ptr<StarMatchList> matches(new StarMatchList);
    /****** Collect ***********/
    FastFinder finder(list2);
    for (const auto & si : list1) {
        auto p1 = si;
        Point p2 = guess->apply(*p1);
        auto neighbour = finder.findClosest(p2, maxDist);
        if (!neighbour) continue;
        double distance = p2.Distance(*neighbour);
        if (distance < maxDist) {
            matches->push_back(StarMatch(*p1, *neighbour, p1, neighbour));
            // assign the distance, since we have it in hand:
            matches->back().distance = distance;
        }
    }
    matches->setTransform(guess);
 
    return matches;
}

listMatchCollect() [2/2]

std::unique_ptr< StarMatchList > lsst::jointcal::listMatchCollect	(	const BaseStarList &	list1,
		const BaseStarList &	list2,
		double	maxDist
	)

same as before except that the transform is the identity

Definition at line 614 of file ListMatch.cc.

                                                                      {
    std::unique_ptr<StarMatchList> matches(new StarMatchList);
    FastFinder finder(list2);
    for (const auto & si : list1) {
        auto p1 = si;
        auto neighbour = finder.findClosest(*p1, maxDist);
        if (!neighbour) continue;
        double distance = p1->Distance(*neighbour);
        if (distance < maxDist) {
            matches->push_back(StarMatch(*p1, *neighbour, p1, neighbour));
            // assign the distance, since we have it in hand:
            matches->back().distance = distance;
        }
    }
 
    matches->setTransform(std::make_shared<AstrometryTransformIdentity>());
 
    return matches;
}

listMatchCombinatorial()

std::unique_ptr< AstrometryTransform > lsst::jointcal::listMatchCombinatorial	(	const BaseStarList &	list1,
		const BaseStarList &	list2,
		const MatchConditions &	conditions = MatchConditions()
	)

Definition at line 679 of file ListMatch.cc.

                                                                                               {
    BaseStarList list1, list2;
    List1.copyTo(list1);
    list1.fluxSort();
    List2.copyTo(list2);
    list2.fluxSort();
 
    LOGLS_INFO(_log, "listMatchCombinatorial: find match between " << list1.size() << " and " << list2.size()
                                                                   << " stars...");
    auto match = matchSearchRotShiftFlip(list1, list2, conditions);
    double pixSizeRatio2 = std::pow(conditions.sizeRatio, 2);
    size_t nmin =
            std::min(size_t(10), size_t(std::min(List1.size(), List2.size()) * conditions.minMatchRatio));
 
    std::unique_ptr<AstrometryTransform> transform;
    if (is_transform_ok(match.get(), pixSizeRatio2, nmin))
        transform = match->getTransform()->clone();
    else {
        LOGL_ERROR(_log, "listMatchCombinatorial: direct transform failed, trying reverse");
        match = matchSearchRotShiftFlip(list2, list1, conditions);
        if (is_transform_ok(match.get(), pixSizeRatio2, nmin))
            transform = match->inverseTransform();
        else {
            LOGL_FATAL(_log, "FAILED");
        }
    }
 
    if (transform) {
        LOGL_INFO(_log, "FOUND");
        if (conditions.printLevel >= 1) {
            LOGL_DEBUG(_log, " listMatchCombinatorial: found the following transform.");
            LOGLS_DEBUG(_log, *transform);
        }
    } else
        LOGL_ERROR(_log, "listMatchCombinatorial: failed to find a transform");
    return transform;
}

listMatchRefine()

std::unique_ptr< AstrometryTransform > lsst::jointcal::listMatchRefine	(	const BaseStarList &	list1,
		const BaseStarList &	list2,
		std::unique_ptr< AstrometryTransform >	transform,
		int	maxOrder = 3
	)

Definition at line 719 of file ListMatch.cc.

                                                                         {
    if (!transform) {
        return std::unique_ptr<AstrometryTransform>(nullptr);
    }
 
    // some hard-coded constants that could go in a param file
    const double brightDist = 2.;  // distance in pixels in a match
    const double fullDist = 4.;    // distance in pixels in a match between entire lists
    const double nSigmas = 3.;     // k-sigma clipping on residuals
    const size_t nStars = 500;     // max number of bright stars to fit
 
    int order = 1;
    size_t nstarmin = 3;
 
    BaseStarList list1, list2;
    List1.copyTo(list1);
    list1.fluxSort();
    list1.cutTail(nStars);
    List2.copyTo(list2);
    list2.fluxSort();
    list2.cutTail(nStars);
 
    auto fullMatch = listMatchCollect(List1, List2, transform.get(), fullDist);
    auto brightMatch = listMatchCollect(list1, list2, transform.get(), brightDist);
    double curChi2 = computeChi2(*brightMatch, *transform) / brightMatch->size();
 
    LOGLS_INFO(_log, "listMatchRefine: start: med.resid " << median_distance(fullMatch.get(), transform.get())
                                                          << " #match " << fullMatch->size());
 
    do {  // loop on transform order on full list of stars
        auto curTransform = brightMatch->getTransform()->clone();
        unsigned iter = 0;
        double transDiff;
        do {  // loop on transform diff only on bright stars
            brightMatch->setTransformOrder(order);
            brightMatch->refineTransform(nSigmas);
            transDiff = transform_diff(list1, brightMatch->getTransform().get(), curTransform.get());
            curTransform = brightMatch->getTransform()->clone();
            brightMatch = listMatchCollect(list1, list2, curTransform.get(), brightDist);
        } while (brightMatch->size() > nstarmin && transDiff > 0.05 && ++iter < 5);
 
        double prevChi2 = curChi2;
        curChi2 = computeChi2(*brightMatch, *curTransform) / brightMatch->size();
 
        fullMatch = listMatchCollect(List1, List2, curTransform.get(), fullDist);
        LOGLS_INFO(_log, "listMatchRefine: order " << order << " med.resid "
                                                   << median_distance(fullMatch.get(), curTransform.get())
                                                   << " #match " << fullMatch->size());
        if (((prevChi2 - curChi2) > 0.01 * curChi2) && curChi2 > 0) {
            LOGLS_INFO(_log, " listMatchRefine: order " << order << " was a better guess.");
            transform = brightMatch->getTransform()->clone();
        }
        nstarmin = brightMatch->getTransform()->getNpar();
    } while (++order <= maxOrder);
 
    return transform;
}

listMatchupShift()

std::unique_ptr< AstrometryTransformLinear > lsst::jointcal::listMatchupShift	(	const BaseStarList &	list1,
		const BaseStarList &	list2,
		const AstrometryTransform &	transform,
		double	maxShift,
		double	binSize = 0
	)

searches for a 2 dimensional shift using a very crude histogram method.

Definition at line 490 of file ListMatch.cc.

                                                                                             {
    int nx;
    if (binSize == 0) {
        int ncomb = list1.size() * list2.size();
        if (ncomb > 10000)
            nx = 100;
        else
            nx = (int)sqrt(double(ncomb));
        if (!ncomb) return std::unique_ptr<AstrometryTransformLinear>(nullptr);
    } else
        nx = int(2 * maxShift / binSize + 0.5);
 
    Histo2d histo(nx, -maxShift, maxShift, nx, -maxShift, maxShift);
    double binSizeNew = 2 * maxShift / nx;
 
    BaseStarCIterator s1;
    FastFinder finder(list2);
    double x1, y1;
    for (s1 = list1.begin(); s1 != list1.end(); ++s1) {
        transform.apply((*s1)->x, (*s1)->y, x1, y1);
        FastFinder::Iterator it = finder.beginScan(Point(x1, y1), maxShift);
        while (*it) {
            auto s2 = *it;
            histo.fill(s2->x - x1, s2->y - y1);
            ++it;
        }
    }
    SolList Solutions;
    for (int i = 0; i < 4; ++i) {
        double dx = 0, dy = 0;
        double count = histo.maxBin(dx, dy);
        histo.fill(dx, dy, -count);  // zero the maxbin
        AstrometryTransformLinearShift shift(dx, dy);
        auto newGuess = compose(shift, transform);
        auto raw_matches = listMatchCollect(list1, list2, newGuess.get(), binSizeNew);
        std::unique_ptr<StarMatchList> matches(new StarMatchList);
        raw_matches->applyTransform(*matches, &transform);
        matches->setTransformOrder(1);
        matches->refineTransform(3.);
        Solutions.push_back(std::move(matches));
    }
    Solutions.sort(DecreasingQuality);
    std::unique_ptr<AstrometryTransformLinear> best(
            new AstrometryTransformLinear(*std::const_pointer_cast<AstrometryTransformLinear>(
                    std::dynamic_pointer_cast<const AstrometryTransformLinear>(
                            Solutions.front()->getTransform()))));
    return best;
}

matchSearchRotShift()

std::unique_ptr< StarMatchList > lsst::jointcal::matchSearchRotShift	(	BaseStarList &	list1,
		BaseStarList &	list2,
		const MatchConditions &	conditions
	)

searches a geometrical transformation that goes from list1 to list2.

The found transformation is a field of the returned object, as well as the star pairs (the matches) that were constructed. (see StarMatchList class definition for more details). The various cuts are contained in conditions (see listmatch.h) for its contents. This routine searches a transformation that involves a shift and a rotation.

Definition at line 424 of file ListMatch.cc.

                                                                                      {
    list1.fluxSort();
    list2.fluxSort();
 
    return ListMatchupRotShift(list1, list2, AstrometryTransformIdentity(), conditions);
}

matchSearchRotShiftFlip()

std::unique_ptr< StarMatchList > lsst::jointcal::matchSearchRotShiftFlip	(	BaseStarList &	list1,
		BaseStarList &	list2,
		const MatchConditions &	conditions
	)

same as above but searches also a flipped solution.

Definition at line 432 of file ListMatch.cc.

                                                                                          {
    list1.fluxSort();
    list2.fluxSort();
 
    AstrometryTransformLinear flip(0, 0, 1, 0, 0, -1);
    std::unique_ptr<StarMatchList> flipped(ListMatchupRotShift(list1, list2, flip, conditions));
    std::unique_ptr<StarMatchList> unflipped(
            ListMatchupRotShift(list1, list2, AstrometryTransformIdentity(), conditions));
    if (!flipped || !unflipped) return std::unique_ptr<StarMatchList>(nullptr);
    if (conditions.printLevel >= 1) {
        LOGLS_DEBUG(_log,
                    "unflipped Residual " << unflipped->computeResidual() << " nused " << unflipped->size());
        LOGLS_DEBUG(_log, "flipped Residual " << flipped->computeResidual() << " nused " << flipped->size());
    }
    if (DecreasingQuality(flipped, unflipped)) {
        if (conditions.printLevel >= 1) LOGL_DEBUG(_log, "Keeping flipped solution.");
        // One should NOT apply the flip to the result because the matchlist
        // (even the flipped one) contains the actual coordinates of stars.
        // MatchListExtract is always called with AstrometryTransformIdentity() as last parameter
        return flipped;
    } else {
        if (conditions.printLevel >= 1) LOGL_DEBUG(_log, "Keeping unflipped solution.");
        return unflipped;
    }
}

Measured2Base() [1/4]

const BaseStarList & lsst::jointcal::Measured2Base

(

const MeasuredStarList &

This

)

Definition at line 62 of file MeasuredStar.cc.

{ return (const BaseStarList &)This; }

Measured2Base() [2/4]

const BaseStarList * lsst::jointcal::Measured2Base

(

const MeasuredStarList *

This

)

Definition at line 64 of file MeasuredStar.cc.

{ return (BaseStarList *)This; }

Measured2Base() [3/4]

BaseStarList & lsst::jointcal::Measured2Base

(

MeasuredStarList &

This

)

Definition at line 58 of file MeasuredStar.cc.

{ return (BaseStarList &)This; }

Measured2Base() [4/4]

BaseStarList * lsst::jointcal::Measured2Base

(

MeasuredStarList *

This

)

Definition at line 60 of file MeasuredStar.cc.

{ return (BaseStarList *)This; }

normalizeCoordinatesTransform()

AstrometryTransformLinear lsst::jointcal::normalizeCoordinatesTransform

(

const Frame &

frame

)

Returns the transformation that maps the input frame along both axes to [-1,1].

Definition at line 834 of file AstrometryTransform.cc.

                                                                            {
    Point center = frame.getCenter();
    return AstrometryTransformLinearScale(2. / frame.getWidth(), 2. / frame.getHeight()) *
           AstrometryTransformLinearShift(-center.x, -center.y);
}

operator<<() [1/11]

std::ostream & lsst::jointcal::operator<<	(	std::ostream &	out,
		CcdImageKey const &	key
	)

Definition at line 53 of file CcdImage.cc.

                                                                {
    out << "(visit: " << key.visit << ", detector: " << key.ccd << ")";
    return out;
}

operator<<() [2/11]

std::ostream & lsst::jointcal::operator<<	(	std::ostream &	s,
		Chi2List const &	chi2List
	)

Definition at line 45 of file Chi2.cc.

                                                                {
    s << "chi2 per star : ";
    for (const auto& chi2 : chi2List) {
        s << *(chi2.star) << " chi2: " << chi2.chi2 << " ; ";
    }
    s << std::endl;
    return s;
}

operator<<() [3/11]

std::ostream & lsst::jointcal::operator<< ( std::ostream &  stream, AstrometryMapping const &  mapping  )

inline

Definition at line 78 of file AstrometryMapping.h.

                                                                                    {
    mapping.print(stream);
    return stream;
}

operator<<() [4/11]

std::ostream & lsst::jointcal::operator<<	(	std::ostream &	stream,
		AstrometryModel const &	model
	)

Definition at line 42 of file AstrometryModel.cc.

                                                                         {
    model.print(stream);
    return stream;
}

operator<<() [5/11]

ostream & lsst::jointcal::operator<<	(	std::ostream &	stream,
		AstrometryTransform const &	transform
	)

Definition at line 242 of file AstrometryTransform.cc.

                                                                           {
    transform.print(stream);
    return stream;
}

operator<<() [6/11]

std::ostream & lsst::jointcal::operator<<	(	std::ostream &	stream,
		const Point &	point
	)

Definition at line 70 of file Point.h.

                                                                          {
        point.print(stream);
        return stream;
    }

operator<<() [7/11]

template<class Star >

std::ostream & lsst::jointcal::operator<<	(	std::ostream &	stream,
		const StarList< Star > &	list
	)

enables

std::cout << my_list; 

Definition at line 105 of file StarList.h.

                                                                       {
    list.print(stream);
    return stream;
}

operator<<() [8/11]

std::ostream & lsst::jointcal::operator<<	(	std::ostream &	stream,
		const StarMatch &	match
	)

Definition at line 55 of file StarMatch.cc.

                                                                   {
    stream << match.point1.x << ' ' << match.point1.y << ' ' << match.point2.x << ' ' << match.point2.y << ' '
           << match.distance << std::endl;
    return stream;
}

operator<<() [9/11]

std::ostream & lsst::jointcal::operator<<	(	std::ostream &	stream,
		const StarMatchList &	starMatchList
	)

A std::list of star matches,.

To be used as the argument to AstrometryTransform::fit routines. There is as well a StarMatch::fit routine which fits a polynomial by default, although the transform may be user-provided. The StarMatchList::refineTransform is a convenient tool to reject outliers. Given two catalogs, one can assemble a StarMatchList using utilities such as listMatchCollect. StarMatchList's have write capabilities. NStarMatchList is a generalization of this 2-match to n-matches.

Definition at line 61 of file StarMatch.cc.

                                                                               {
    stream << " number of elements " << starMatchList.size() << std::endl;
    copy(starMatchList.begin(), starMatchList.end(), std::ostream_iterator<StarMatch>(stream));
    return stream;
}

operator<<() [10/11]

std::ostream & lsst::jointcal::operator<<	(	std::ostream &	stream,
		ProjectionHandler const &	projectionHandler
	)

Definition at line 34 of file Projectionhandler.cc.

                                                                                       {
    projectionHandler.print(stream);
    return stream;
}

operator<<() [11/11]

std::ostream & lsst::jointcal::operator<<	(	std::ostream &	stream,
		ProperMotion const &	pm
	)

Definition at line 44 of file ProperMotion.cc.

                                                                   {
    stream << "pm_ra*cos(dec)=" << pm._ra << "rad/yr, pm_dec=" << pm._dec << "rad/yr, pm_raErr=" << pm._raErr
           << "rad/yr, pm_decErr=" << pm._decErr << "rad/yr, pm_raDecCov=" << pm._raDecCov;
    return stream;
}

Ref2Base() [1/4]

const BaseStarList & lsst::jointcal::Ref2Base

(

const RefStarList &

This

)

Definition at line 46 of file RefStar.cc.

{ return (const BaseStarList &)This; }

Ref2Base() [2/4]

const BaseStarList * lsst::jointcal::Ref2Base

(

const RefStarList *

This

)

Definition at line 48 of file RefStar.cc.

{ return (BaseStarList *)This; }

Ref2Base() [3/4]

BaseStarList & lsst::jointcal::Ref2Base

(

RefStarList &

This

)

Definition at line 42 of file RefStar.cc.

{ return (BaseStarList &)This; }

Ref2Base() [4/4]

BaseStarList * lsst::jointcal::Ref2Base

(

RefStarList *

This

)

Definition at line 44 of file RefStar.cc.

{ return (BaseStarList *)This; }

sameStar1()

bool lsst::jointcal::sameStar1 ( const StarMatch &  one, const StarMatch &  two  )

inline

Definition at line 120 of file StarMatch.h.

{ return (one.s1 == two.s1); }

sameStar2()

bool lsst::jointcal::sameStar2 ( const StarMatch &  one, const StarMatch &  two  )

inline

Definition at line 126 of file StarMatch.h.

{ return (one.s2 == two.s2); }