lsst::jointcal::FitterBase Class Reference

Base class for fitters. More...

#include <FitterBase.h>

Inheritance diagram for lsst::jointcal::FitterBase:

Public Member Functions
	FitterBase (std::shared_ptr< Associations > associations)
	FitterBase (FitterBase const &)=delete
	No copy or move: there is only ever one fitter of a given type.
	FitterBase (FitterBase &&)=delete
FitterBase &	operator= (FitterBase const &)=delete
FitterBase &	operator= (FitterBase &&)=delete
MinimizeResult	minimize (std::string const &whatToFit, double nSigmaCut=0, double sigmaRelativeTolerance=0, bool doRankUpdate=true, bool doLineSearch=false, std::string const &dumpMatrixFile="")
	Does a 1 step minimization, assuming a linear model.
Chi2Statistic	computeChi2 () const
	Returns the chi2 for the current state.
void	leastSquareDerivatives (TripletList &tripletList, Eigen::VectorXd &grad) const
	Evaluates the chI^2 derivatives (Jacobian and gradient) for the current whatToFit setting.
virtual void	offsetParams (Eigen::VectorXd const &delta)=0
	Offset the parameters by the requested quantities.
virtual void	assignIndices (std::string const &whatToFit)=0
	Set parameters to fit and assign indices in the big matrix.
virtual void	saveChi2Contributions (std::string const &baseName) const
	Save the full chi2 term per star that was used in the minimization, for debugging.
virtual	~FitterBase ()=default

Protected Member Functions
virtual void	saveChi2MeasContributions (std::string const &filename) const =0
	Save a CSV file containing residuals of measurement terms.
virtual void	saveChi2RefContributions (std::string const &filename) const =0
	Save a CSV file containing residuals of reference terms.
std::size_t	findOutliers (double nSigmaCut, MeasuredStarList &msOutliers, FittedStarList &fsOutliers, double &cut) const
	Find Measurements and references contributing more than a cut, computed as.
void	outliersContributions (MeasuredStarList &msOutliers, FittedStarList &fsOutliers, TripletList &tripletList, Eigen::VectorXd &grad)
	Contributions to derivatives from (presumably) outlier terms.
void	removeMeasOutliers (MeasuredStarList &outliers)
	Remove measuredStar outliers from the fit. No Refit done.
void	removeRefOutliers (FittedStarList &outliers)
	Remove refStar outliers from the fit. No Refit done.
virtual void	getIndicesOfMeasuredStar (MeasuredStar const &measuredStar, IndexVector &indices) const =0
	Set the indices of a measured star from the full matrix, for outlier removal.
virtual void	accumulateStatImageList (CcdImageList const &ccdImageList, Chi2Accumulator &accum) const =0
	Compute the chi2 (per star or total, depending on which Chi2Accumulator is used) for measurements.
virtual void	accumulateStatRefStars (Chi2Accumulator &accum) const =0
	Compute the chi2 (per star or total, depending on which Chi2Accumulator is used) for RefStars.
virtual void	leastSquareDerivativesMeasurement (CcdImage const &ccdImage, TripletList &tripletList, Eigen::VectorXd &grad, MeasuredStarList const *measuredStarList=nullptr) const =0
	Compute the derivatives of the measured stars and model for one CcdImage.
virtual void	leastSquareDerivativesReference (FittedStarList const &fittedStarList, TripletList &tripletList, Eigen::VectorXd &grad) const =0
	Compute the derivatives of the reference terms.

Protected Attributes
std::shared_ptr< Associations >	_associations
std::string	_whatToFit
Eigen::Index	_lastNTrip
Eigen::Index	_nTotal
Eigen::Index	_nModelParams
Eigen::Index	_nStarParams
LOG_LOGGER	_log

Detailed Description

Base class for fitters.

Implements minimize and findOutliers. Chi2, residual, derivative, etc. calculations must be implemented in the child class via the virtual methods.

Definition at line 55 of file FitterBase.h.

Constructor & Destructor Documentation

FitterBase() [1/3]

lsst::jointcal::FitterBase::FitterBase ( std::shared_ptr< Associations > associations )

inlineexplicit

Definition at line 57 of file FitterBase.h.

            : _associations(std::move(associations)),
              _whatToFit(""),
              _lastNTrip(0),
              _nTotal(0),
              _nModelParams(0),
              _nStarParams(0) {}

FitterBase() [2/3]

lsst::jointcal::FitterBase::FitterBase ( FitterBase const & )

delete

No copy or move: there is only ever one fitter of a given type.

FitterBase() [3/3]

lsst::jointcal::FitterBase::FitterBase ( FitterBase && )

delete

~FitterBase()

virtual lsst::jointcal::FitterBase::~FitterBase ( )

virtualdefault

Member Function Documentation

accumulateStatImageList()

virtual void lsst::jointcal::FitterBase::accumulateStatImageList ( CcdImageList const & ccdImageList, Chi2Accumulator & accum ) const

protectedpure virtual

Compute the chi2 (per star or total, depending on which Chi2Accumulator is used) for measurements.

Implemented in lsst::jointcal::AstrometryFit, and lsst::jointcal::PhotometryFit.

accumulateStatRefStars()

virtual void lsst::jointcal::FitterBase::accumulateStatRefStars ( Chi2Accumulator & accum ) const

protectedpure virtual

Compute the chi2 (per star or total, depending on which Chi2Accumulator is used) for RefStars.

Implemented in lsst::jointcal::AstrometryFit, and lsst::jointcal::PhotometryFit.

assignIndices()

virtual void lsst::jointcal::FitterBase::assignIndices ( std::string const & whatToFit )

pure virtual

Set parameters to fit and assign indices in the big matrix.

Parameters

[in]

whatToFit

See child class documentation for valid string values.

Implemented in lsst::jointcal::AstrometryFit, and lsst::jointcal::PhotometryFit.

computeChi2()

Chi2Statistic lsst::jointcal::FitterBase::computeChi2

(

)

const

Returns the chi2 for the current state.

Definition at line 43 of file FitterBase.cc.

                                            {
    Chi2Statistic chi2;
    accumulateStatImageList(_associations->getCcdImageList(), chi2);
    accumulateStatRefStars(chi2);
    // chi2.ndof contains the number of squares.
    // So subtract the number of parameters.
    chi2.ndof -= _nTotal;
    return chi2;
}

findOutliers()

std::size_t lsst::jointcal::FitterBase::findOutliers ( double nSigmaCut, MeasuredStarList & msOutliers, FittedStarList & fsOutliers, double & cut ) const

protected

Find Measurements and references contributing more than a cut, computed as.

\[ <chi2> + nSigmaCut + rms(chi2). \]

The outliers are NOT removed, and no refit is done.

After returning from here, there are still measurements that contribute above the cut, but their contribution should be evaluated after a refit before discarding them.

Parameters

[in]	nSigmaCut	Number of sigma to select on.
[out]	msOutliers	list of MeasuredStar outliers to populate
[out]	fsOutliers	list of FittedStar outliers to populate
[out]	cut	value of chi2 that defines which objects are outliers

Returns

Total number of outliers that were removed.

Definition at line 53 of file FitterBase.cc.

                                                                                    {
    // collect chi2 contributions
    Chi2List chi2List;
    chi2List.reserve(_associations->getMaxMeasuredStars() + _associations->refStarList.size());
    // contributions from measurement terms:
    accumulateStatImageList(_associations->ccdImageList, chi2List);
    // and from reference terms
    accumulateStatRefStars(chi2List);
 
    // compute some statistics
    size_t nval = chi2List.size();
    if (nval == 0) return 0;
    sort(chi2List.begin(), chi2List.end());
    double median = (nval & 1) ? chi2List[nval / 2].chi2
                               : 0.5 * (chi2List[nval / 2 - 1].chi2 + chi2List[nval / 2].chi2);
    auto averageAndSigma = chi2List.computeAverageAndSigma();
    LOGLS_DEBUG(_log, "findOutliers chi2 stat: mean/median/sigma " << averageAndSigma.first << '/' << median
                                                                   << '/' << averageAndSigma.second);
    cut = averageAndSigma.first + nSigmaCut * averageAndSigma.second;
    /* For each of the parameters, we will not remove more than 1
       measurement that contributes to constraining it. Keep track using
       of what we are touching using an integer vector. This is the
       trick that Marc Betoule came up to for outlier removals in "star
       flats" fits. */
    Eigen::VectorXi affectedParams(_nTotal);
    affectedParams.setZero();
 
    std::size_t nOutliers = 0;  // returned to the caller
    // start from the strongest outliers.
    for (auto chi2 = chi2List.rbegin(); chi2 != chi2List.rend(); ++chi2) {
        if (chi2->chi2 < cut) break;  // because the array is sorted.
        IndexVector indices;
        /* now, we want to get the indices of the parameters this chi2
           term depends on. We have to figure out which kind of term it
           is; we use for that the type of the star attached to the Chi2Star. */
        auto measuredStar = std::dynamic_pointer_cast<MeasuredStar>(chi2->star);
        std::shared_ptr<FittedStar> fittedStar;  // To add to fsOutliers if it is a reference outlier.
        if (measuredStar == nullptr) {
            // it is a reference outlier
            fittedStar = std::dynamic_pointer_cast<FittedStar>(chi2->star);
            if (fittedStar->getMeasurementCount() == 0) {
                LOGLS_WARN(_log, "FittedStar with no measuredStars found as an outlier: "
                                         << *fittedStar << " chi2: " << chi2->chi2);
                continue;
            }
            if (_nStarParams == 0) {
                LOGLS_TRACE(_log,
                            "RefStar is outlier but not removed when not fitting FittedStar-RefStar values: "
                                    << *(fittedStar->getRefStar()) << " chi2: " << chi2->chi2);
                continue;
            }
            // NOTE: Stars contribute twice to astrometry (x,y), but once to photometry (flux),
            // NOTE: but we only need to mark one index here because both will be removed with that star.
            indices.push_back(fittedStar->getIndexInMatrix());
            LOGLS_TRACE(_log, "Removing refStar " << *(fittedStar->getRefStar()) << " chi2: " << chi2->chi2);
            /* One might think it would be useful to account for PM
               parameters here, but it is just useless */
        } else {
            // it is a measurement outlier
            auto tempFittedStar = measuredStar->getFittedStar();
            if (tempFittedStar->getMeasurementCount() == 1 && tempFittedStar->getRefStar() == nullptr) {
                LOGLS_WARN(_log, "FittedStar with 1 measuredStar and no refStar found as an outlier: "
                                         << *tempFittedStar);
                continue;
            }
            getIndicesOfMeasuredStar(*measuredStar, indices);
            LOGLS_TRACE(_log, "Removing measStar " << *measuredStar << " chi2: " << chi2->chi2);
        }
 
        /* Find out if we already discarded a stronger outlier
        constraining some parameter this one constrains as well. If
         yes, we keep this one, because this stronger outlier could be
         causing the large chi2 we have in hand.  */
        bool drop_it = true;
        for (auto const &i : indices) {
            if (affectedParams(i) != 0) {
                drop_it = false;
            }
        }
 
        if (drop_it)  // store the outlier in one of the lists:
        {
            if (measuredStar == nullptr) {
                // reference term
                fsOutliers.push_back(fittedStar);
            } else {
                // measurement term
                msOutliers.push_back(measuredStar);
            }
            // mark the parameters as directly changed when we discard this chi2 term.
            for (auto const &i : indices) {
                affectedParams(i)++;
            }
            nOutliers++;
        }
    }  // end loop on measurements/references
    LOGLS_DEBUG(_log, "findOutliers: found " << msOutliers.size() << " meas outliers and "
                                             << fsOutliers.size() << " ref outliers ");
 
    return nOutliers;
}

getIndicesOfMeasuredStar()

virtual void lsst::jointcal::FitterBase::getIndicesOfMeasuredStar ( MeasuredStar const & measuredStar, IndexVector & indices ) const

protectedpure virtual

Set the indices of a measured star from the full matrix, for outlier removal.

Implemented in lsst::jointcal::AstrometryFit, and lsst::jointcal::PhotometryFit.

leastSquareDerivatives()

void lsst::jointcal::FitterBase::leastSquareDerivatives	(	TripletList &	tripletList,
		Eigen::VectorXd &	grad ) const

Evaluates the chI^2 derivatives (Jacobian and gradient) for the current whatToFit setting.

The Jacobian is given as triplets in a sparse matrix, the gradient as a dense vector. The parameters which vary, and their indices, are to be set using assignIndices.

Parameters

tripletList	tripletList of (row,col,value) representing the Jacobian of the chi2.
grad	The gradient of the chi2.

Definition at line 347 of file FitterBase.cc.

                                                                                           {
    auto ccdImageList = _associations->getCcdImageList();
    for (auto const &ccdImage : ccdImageList) {
        leastSquareDerivativesMeasurement(*ccdImage, tripletList, grad);
    }
    leastSquareDerivativesReference(_associations->fittedStarList, tripletList, grad);
}

leastSquareDerivativesMeasurement()

virtual void lsst::jointcal::FitterBase::leastSquareDerivativesMeasurement ( CcdImage const & ccdImage, TripletList & tripletList, Eigen::VectorXd & grad, MeasuredStarList const * measuredStarList = nullptr ) const

protectedpure virtual

Compute the derivatives of the measured stars and model for one CcdImage.

The last argument will process a sub-list for outlier removal.

Implemented in lsst::jointcal::PhotometryFit, and lsst::jointcal::AstrometryFit.

leastSquareDerivativesReference()

virtual void lsst::jointcal::FitterBase::leastSquareDerivativesReference ( FittedStarList const & fittedStarList, TripletList & tripletList, Eigen::VectorXd & grad ) const

protectedpure virtual

Compute the derivatives of the reference terms.

Implemented in lsst::jointcal::AstrometryFit, and lsst::jointcal::PhotometryFit.

minimize()

MinimizeResult lsst::jointcal::FitterBase::minimize	(	std::string const &	whatToFit,
		double	nSigmaCut = 0,
		double	sigmaRelativeTolerance = 0,
		bool	doRankUpdate = true,
		bool	doLineSearch = false,
		std::string const &	dumpMatrixFile = "" )

Does a 1 step minimization, assuming a linear model.

This is a complete Newton Raphson step. Compute first and second derivatives, solve for the step and apply it, with an optional line search.

It calls assignIndices, leastSquareDerivatives, solves the linear system and calls offsetParams, then removes outliers in a loop if requested. Relies on sparse linear algebra via Eigen's CholmodSupport package.

Parameters

[in]	whatToFit	See child method assignIndices for valid string values.
[in]	nSigmaCut	How many sigma to reject outliers at. Outlier rejection ignored for nSigmaCut=0.
[in]	sigmaRelativeTolerance	Percentage change in the chi2 cut for outliers tolerated for termination. If value is zero, minimization iterations will continue until there are no outliers.
[in]	doRankUpdate	Use CholmodSimplicialLDLT2.update() to do a fast rank update after outlier removal; otherwise do a slower full recomputation of the matrix. Only matters if nSigmaCut != 0.
[in]	doLineSearch	Use boost's brent_find_minima to perform a line search after the gradient solution is found, and apply the scale factor to the computed offsets. The line search is done in the domain [-1, 2], but if the scale factor is far from 1.0, then the problem is likely in a significantly non-linear regime.
[in]	dumpMatrixFile	Write the pre-fit Hessian matrix and gradient to the files with "-mat.txt" and "-grad.txt". Be aware, this requires a large increase in memory usage to create a dense matrix before writing it; the output file may be large. Writing the matrix can be helpful for debugging bad fits. Read it and compute the real eigenvalues (recall that the Hessian is symmetric by construction) with numpy: hessian = np.matrix(np.loadtxt("dumpMatrixFile-mat.txt")) values, vectors = np.linalg.eigh(hessian)

Returns

Return code describing success/failure of fit.

Note

When fitting one parameter set by itself (e.g. "Model"), the system is purely linear (assuming there are no cross-terms in the derivatives, e.g. the SimpleAstrometryModel), which should result in the optimal chi2 after a single step. This can be used to debug the fitter by fitting that parameter set twice in a row: the second run with the same "whatToFit" will produce no change in the fitted parameters, if the calculations and indices are defined correctly.

Definition at line 179 of file FitterBase.cc.

                                                                     {
    assignIndices(whatToFit);
 
    MinimizeResult returnCode = MinimizeResult::Converged;
 
    // For the initial vector size, use all measured stars + all fitted stars, which should give the
    // maximum possible number of triplets.
    std::size_t nTrip = (_lastNTrip)
                                ? _lastNTrip
                                : _associations->getMaxMeasuredStars() + _associations->fittedStarList.size();
    TripletList tripletList(nTrip);
    Eigen::VectorXd grad(_nTotal);
    grad.setZero();
    double scale = 1.0;
 
    // Fill the triplets
    leastSquareDerivatives(tripletList, grad);
    _lastNTrip = tripletList.size();
 
    LOGLS_DEBUG(_log, "End of triplet filling, ntrip = " << tripletList.size());
 
    SparseMatrixD hessian = createHessian(_nTotal, tripletList);
    tripletList.clear();  // we don't need it any more after we have the hessian.
 
    LOGLS_DEBUG(_log, "Starting factorization, hessian: dim="
                              << hessian.rows() << " non-zeros=" << hessian.nonZeros()
                              << " filling-frac = " << hessian.nonZeros() / std::pow(hessian.rows(), 2));
 
    if (dumpMatrixFile != "") {
        if (hessian.rows() * hessian.cols() > 2e8) {
            LOGLS_WARN(_log, "Hessian matrix is too big to dump to file, with rows, columns: "
                                     << hessian.rows() << ", " << hessian.cols());
        } else {
            dumpMatrixAndGradient(hessian, grad, dumpMatrixFile, _log);
        }
    }
 
    CholmodSimplicialLDLT2<SparseMatrixD> chol(hessian);
    if (chol.info() != Eigen::Success) {
        LOGLS_ERROR(_log, "minimize: factorization failed ");
        return MinimizeResult::Failed;
    }
 
    std::size_t totalMeasOutliers = 0;
    std::size_t totalRefOutliers = 0;
    double oldChi2 = computeChi2().chi2;
    double oldSigmaCut = 0.;
    double sigmaCut = 0.;
 
    while (true) {
        Eigen::VectorXd delta = chol.solve(grad);
        if (doLineSearch) {
            scale = _lineSearch(delta);
        }
        offsetParams(scale * delta);
        Chi2Statistic currentChi2(computeChi2());
        LOGLS_DEBUG(_log, currentChi2);
        if (!isfinite(currentChi2.chi2)) {
            LOGL_ERROR(_log, "chi2 is not finite. Aborting outlier rejection.");
            returnCode = MinimizeResult::NonFinite;
            break;
        }
        if (currentChi2.chi2 > oldChi2 && totalMeasOutliers + totalRefOutliers != 0) {
            LOGL_WARN(_log, "chi2 went up, skipping outlier rejection loop");
            returnCode = MinimizeResult::Chi2Increased;
            break;
        }
        oldChi2 = currentChi2.chi2;
 
        if (nSigmaCut == 0) break;  // no rejection step to perform
        MeasuredStarList msOutliers;
        FittedStarList fsOutliers;
        // keep nOutliers so we don't have to sum msOutliers.size()+fsOutliers.size() twice below.
        std::size_t nOutliers = findOutliers(nSigmaCut, msOutliers, fsOutliers, sigmaCut);
        double relChange = 0.;
        if(oldSigmaCut!=0.) relChange = (1 - sigmaCut / oldSigmaCut);
 
        LOGLS_DEBUG(_log, "findOutliers chi2 cut level: " << sigmaCut << ", relative change: " << relChange);
        // If sigmaRelativeTolerance is set and at least one iteration has been done, break loop when the
        // fractional change in sigmaCut levels is less than the sigmaRelativeTolerance parameter.
        if ((sigmaRelativeTolerance > 0) && (oldSigmaCut > 0 && relChange < sigmaRelativeTolerance)) {
            LOGLS_INFO(_log, "Iterations stopped with chi2 cut at " << sigmaCut << " and relative change of "
                                                                    << relChange);
            break;
        }
        totalMeasOutliers += msOutliers.size();
        totalRefOutliers += fsOutliers.size();
        oldSigmaCut = sigmaCut;
        if (nOutliers == 0) break;
        TripletList outlierTriplets(nOutliers);
        grad.setZero();  // recycle the gradient
        // compute the contributions of outliers to derivatives
        outliersContributions(msOutliers, fsOutliers, outlierTriplets, grad);
        // Remove significant outliers
        removeMeasOutliers(msOutliers);
        removeRefOutliers(fsOutliers);
        if (doRankUpdate) {
            // convert triplet list to eigen internal format
            SparseMatrixD H(_nTotal, outlierTriplets.getNextFreeIndex());
            H.setFromTriplets(outlierTriplets.begin(), outlierTriplets.end());
            chol.update(H, false /* means downdate */);
            // The contribution of outliers to the gradient is the opposite
            // of the contribution of all other terms, because they add up to 0
            grad *= -1;
        } else {
            // don't reuse tripletList because we want a new nextFreeIndex.
            TripletList nextTripletList(_lastNTrip);
            grad.setZero();
            // Rebuild the matrix and gradient
            leastSquareDerivatives(nextTripletList, grad);
            _lastNTrip = nextTripletList.size();
            LOGLS_DEBUG(_log, "Triplets recomputed, ntrip = " << nextTripletList.size());
 
            hessian = createHessian(_nTotal, nextTripletList);
            nextTripletList.clear();  // we don't need it any more after we have the hessian.
 
            LOGLS_DEBUG(_log,
                        "Restarting factorization, hessian: dim="
                                << hessian.rows() << " non-zeros=" << hessian.nonZeros()
                                << " filling-frac = " << hessian.nonZeros() / std::pow(hessian.rows(), 2));
            chol.compute(hessian);
            if (chol.info() != Eigen::Success) {
                LOGLS_ERROR(_log, "minimize: factorization failed ");
                return MinimizeResult::Failed;
            }
        }
    }
 
    if (totalMeasOutliers + totalRefOutliers > 0) {
        _associations->cleanFittedStars();
    }
 
    // only print the outlier summary if outlier rejection was turned on.
    if (nSigmaCut != 0) {
        LOGLS_INFO(_log, "Number of outliers (Measured + Reference = Total): "
                                 << totalMeasOutliers << " + " << totalRefOutliers << " = "
                                 << totalMeasOutliers + totalRefOutliers);
    }
    return returnCode;
}

offsetParams()

virtual void lsst::jointcal::FitterBase::offsetParams ( Eigen::VectorXd const & delta )

pure virtual

Offset the parameters by the requested quantities.

The used parameter layout is the one from the last call to assignIndices or minimize(). There is no easy way to check that the current setting of whatToFit and the provided Delta vector are compatible: we can only test the size.

Parameters

[in]

delta

vector of offsets to apply

Implemented in lsst::jointcal::AstrometryFit, and lsst::jointcal::PhotometryFit.

operator=() [1/2]

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

delete

operator=() [2/2]

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

delete

outliersContributions()

void lsst::jointcal::FitterBase::outliersContributions ( MeasuredStarList & msOutliers, FittedStarList & fsOutliers, TripletList & tripletList, Eigen::VectorXd & grad )

protected

Contributions to derivatives from (presumably) outlier terms.

No discarding done.

Definition at line 322 of file FitterBase.cc.

                                                                                      {
    for (auto &outlier : msOutliers) {
        MeasuredStarList tmp;
        tmp.push_back(outlier);
        const CcdImage &ccdImage = outlier->getCcdImage();
        leastSquareDerivativesMeasurement(ccdImage, tripletList, grad, &tmp);
    }
    leastSquareDerivativesReference(fsOutliers, tripletList, grad);
}

removeMeasOutliers()

void lsst::jointcal::FitterBase::removeMeasOutliers ( MeasuredStarList & outliers )

protected

Remove measuredStar outliers from the fit. No Refit done.

Definition at line 333 of file FitterBase.cc.

                                                              {
    for (auto &measuredStar : outliers) {
        auto fittedStar = measuredStar->getFittedStar();
        measuredStar->setValid(false);
        fittedStar->getMeasurementCount()--;  // could be put in setValid
    }
}

removeRefOutliers()

void lsst::jointcal::FitterBase::removeRefOutliers ( FittedStarList & outliers )

protected

Remove refStar outliers from the fit. No Refit done.

Definition at line 341 of file FitterBase.cc.

                                                           {
    for (auto &fittedStar : outliers) {
        fittedStar->setRefStar(nullptr);
    }
}

saveChi2Contributions()

void lsst::jointcal::FitterBase::saveChi2Contributions ( std::string const & baseName ) const

virtual

Save the full chi2 term per star that was used in the minimization, for debugging.

Saves results to text files "baseName-meas.csv" and "baseName-ref.csv" for the MeasuredStar and RefStar contributions, respectively. This method is mostly useful for debugging: we will probably want to create a better persistence system for jointcal's internal representations in the future (see DM-12446).

Definition at line 355 of file FitterBase.cc.

                                                                      {
    std::string replaceStr = "{type}";
    auto pos = baseName.find(replaceStr);
    std::string measFilename(baseName);
    measFilename.replace(pos, replaceStr.size(), "-meas.csv");
    std::string refFilename(baseName);
    refFilename.replace(pos, replaceStr.size(), "-ref.csv");
    saveChi2MeasContributions(measFilename);
    saveChi2RefContributions(refFilename);
}

saveChi2MeasContributions()

virtual void lsst::jointcal::FitterBase::saveChi2MeasContributions ( std::string const & filename ) const

protectedpure virtual

Save a CSV file containing residuals of measurement terms.

Implemented in lsst::jointcal::AstrometryFit, and lsst::jointcal::PhotometryFit.

saveChi2RefContributions()

virtual void lsst::jointcal::FitterBase::saveChi2RefContributions ( std::string const & filename ) const

protectedpure virtual

Save a CSV file containing residuals of reference terms.

Implemented in lsst::jointcal::AstrometryFit, and lsst::jointcal::PhotometryFit.

Member Data Documentation

_associations

std::shared_ptr<Associations> lsst::jointcal::FitterBase::_associations

protected

Definition at line 165 of file FitterBase.h.

_lastNTrip

Eigen::Index lsst::jointcal::FitterBase::_lastNTrip

protected

Definition at line 168 of file FitterBase.h.

_log

LOG_LOGGER lsst::jointcal::FitterBase::_log

protected

Definition at line 174 of file FitterBase.h.

_nModelParams

Eigen::Index lsst::jointcal::FitterBase::_nModelParams

protected

Definition at line 170 of file FitterBase.h.

_nStarParams

Eigen::Index lsst::jointcal::FitterBase::_nStarParams

protected

Definition at line 171 of file FitterBase.h.

_nTotal

Eigen::Index lsst::jointcal::FitterBase::_nTotal

protected

Definition at line 169 of file FitterBase.h.

_whatToFit

std::string lsst::jointcal::FitterBase::_whatToFit

protected

Definition at line 166 of file FitterBase.h.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-9.0.0/Linux64/jointcal/g82479be7b0+f568feb641/include/lsst/jointcal/FitterBase.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-9.0.0/Linux64/jointcal/g82479be7b0+f568feb641/src/FitterBase.cc