lsst.jointcal  16.0-28-gfc9ea6c+15
Associations.cc
Go to the documentation of this file.
1 // -*- LSST-C++ -*-
2 /*
3  * This file is part of jointcal.
4  *
5  * Developed for the LSST Data Management System.
6  * This product includes software developed by the LSST Project
7  * (https://www.lsst.org).
8  * See the COPYRIGHT file at the top-level directory of this distribution
9  * for details of code ownership.
10  *
11  * This program is free software: you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation, either version 3 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program. If not, see <https://www.gnu.org/licenses/>.
23  */
24 
25 #include <cmath>
26 #include <iostream>
27 #include <limits>
28 #include <sstream>
29 
30 #include "lsst/log/Log.h"
32 #include "lsst/jointcal/CcdImage.h"
35 #include "lsst/jointcal/Frame.h"
36 #include "lsst/jointcal/FatPoint.h"
39 
40 #include "lsst/afw/image/Image.h"
43 
44 #include "lsst/pex/exceptions.h"
45 #include "lsst/afw/geom/Box.h"
46 #include "lsst/afw/geom/Point.h"
47 #include "lsst/afw/image/Calib.h"
48 
49 namespace jointcal = lsst::jointcal;
50 
51 namespace {
52 LOG_LOGGER _log = LOG_GET("jointcal.Associations");
53 }
54 
55 namespace lsst {
56 namespace jointcal {
57 
61  lsst::afw::geom::Box2I const &bbox, std::string const &filter,
63  std::shared_ptr<afw::cameraGeom::Detector> detector, int visit, int ccd,
64  lsst::jointcal::JointcalControl const &control) {
65  auto ccdImage = std::make_shared<CcdImage>(catalog, wcs, visitInfo, bbox, filter, photoCalib, detector,
66  visit, ccd, control.sourceFluxField);
67  ccdImageList.push_back(ccdImage);
68  LOGLS_DEBUG(_log, "Catalog " << ccdImage->getName() << " has " << ccdImage->getWholeCatalog().size()
69  << " objects.");
70 }
71 
74  centers.reserve(ccdImageList.size());
75  for (auto const &ccdImage : ccdImageList) {
76  centers.push_back(ccdImage->getBoresightRaDec());
77  }
78  auto commonTangentPoint = afw::geom::averageSpherePoint(centers);
79  LOGLS_DEBUG(_log, "Using common tangent point: " << commonTangentPoint.getPosition(afw::geom::degrees));
80  setCommonTangentPoint(commonTangentPoint.getPosition(afw::geom::degrees));
81 }
82 
83 void Associations::setCommonTangentPoint(lsst::afw::geom::Point2D const &commonTangentPoint) {
84  _commonTangentPoint = Point(commonTangentPoint.getX(), commonTangentPoint.getY()); // a jointcal::Point
85  for (auto &ccdImage : ccdImageList) ccdImage->setCommonTangentPoint(_commonTangentPoint);
86 }
87 
88 void Associations::associateCatalogs(const double matchCutInArcSec, const bool useFittedList,
89  const bool enlargeFittedList) {
90  // clear reference stars
91  refStarList.clear();
92 
93  // clear measurement counts and associations to refstars, but keep fittedStars themselves.
94  for (auto &item : fittedStarList) {
95  item->clearBeforeAssoc();
96  }
97  // clear fitted stars
98  if (!useFittedList) fittedStarList.clear();
99 
100  for (auto &ccdImage : ccdImageList) {
101  std::shared_ptr<AstrometryTransform> toCommonTangentPlane = ccdImage->getPixelToCommonTangentPlane();
102 
103  // Clear the catalog to fit and copy the whole catalog into it.
104  // This allows reassociating from scratch after a fit.
105  ccdImage->resetCatalogForFit();
106  MeasuredStarList &catalog = ccdImage->getCatalogForFit();
107 
108  // Associate with previous lists.
109  /* To speed up the match (more precisely the contruction of the FastFinder), select in the
110  fittedStarList the objects that are within reach of the current ccdImage */
111  Frame ccdImageFrameCPT = toCommonTangentPlane->apply(ccdImage->getImageFrame(), false);
112  ccdImageFrameCPT = ccdImageFrameCPT.rescale(1.10); // add 10 % margin.
113  // We cannot use FittedStarList::ExtractInFrame, because it does an actual copy, which we don't want
114  // here: we want the pointers in the StarMatch to refer to fittedStarList elements.
115  FittedStarList toMatch;
116 
117  for (auto const &fittedStar : fittedStarList) {
118  if (ccdImageFrameCPT.inFrame(*fittedStar)) {
119  toMatch.push_back(fittedStar);
120  }
121  }
122 
123  // divide by 3600 because coordinates in CTP are in degrees.
124  auto starMatchList = listMatchCollect(Measured2Base(catalog), Fitted2Base(toMatch),
125  toCommonTangentPlane.get(), matchCutInArcSec / 3600.);
126 
127  /* should check what this removeAmbiguities does... */
128  LOGLS_DEBUG(_log, "Measured-to-Fitted matches before removing ambiguities " << starMatchList->size());
129  starMatchList->removeAmbiguities(*toCommonTangentPlane);
130  LOGLS_DEBUG(_log, "Measured-to-Fitted matches after removing ambiguities " << starMatchList->size());
131 
132  // Associate MeasuredStar -> FittedStar using the surviving matches.
133 
134  int matchedCount = 0;
135  for (auto const &starMatch : *starMatchList) {
136  auto bs = starMatch.s1;
137  auto ms_const = std::dynamic_pointer_cast<const MeasuredStar>(bs);
138  auto ms = std::const_pointer_cast<MeasuredStar>(ms_const);
139  auto bs2 = starMatch.s2;
140  auto fs_const = std::dynamic_pointer_cast<const FittedStar>(bs2);
141  auto fs = std::const_pointer_cast<FittedStar>(fs_const);
142  ms->setFittedStar(fs);
143  matchedCount++;
144  }
145  LOGLS_INFO(_log, "Matched " << matchedCount << " objects in " << ccdImage->getName());
146 
147  // add unmatched objets to FittedStarList
148  int unMatchedCount = 0;
149  for (auto const &mstar : catalog) {
150  // to check if it was matched, just check if it has a fittedStar Pointer assigned
151  if (mstar->getFittedStar()) continue;
152  if (enlargeFittedList) {
153  auto fs = std::make_shared<FittedStar>(*mstar);
154  // transform coordinates to CommonTangentPlane
155  toCommonTangentPlane->transformPosAndErrors(*fs, *fs);
156  fittedStarList.push_back(fs);
157  mstar->setFittedStar(fs);
158  }
159  unMatchedCount++;
160  }
161  LOGLS_INFO(_log, "Unmatched objects: " << unMatchedCount);
162  } // end of loop on CcdImages
163 
164  // !!!!!!!!!!!!!!!!!
165  // TODO: DO WE REALLY NEED THIS???
166  // Why do we need to do this, instead of directly computing them in normalizeFittedStars?
167  // What makes the magnitudes special here?
168  // !!!!!!!!!!!!!!!!!
169  // assignMags();
170 }
171 
172 void Associations::collectRefStars(afw::table::SimpleCatalog &refCat, afw::geom::Angle matchCut,
173  std::string const &fluxField,
174  std::map<std::string, std::vector<double>> const &refFluxMap,
175  std::map<std::string, std::vector<double>> const &refFluxErrMap,
176  bool rejectBadFluxes) {
177  if (refCat.size() == 0) {
179  " reference catalog is empty : stop here "));
180  }
181 
182  afw::table::CoordKey coordKey = refCat.getSchema()["coord"];
183  auto fluxKey = refCat.getSchema().find<double>(fluxField).key;
184  // Don't blow up if the reference catalog doesn't contain errors.
185  afw::table::Key<double> fluxErrKey;
186  try {
187  fluxErrKey = refCat.getSchema().find<double>(fluxField + "Err").key;
188  } catch (pex::exceptions::NotFoundError &) {
189  LOGLS_WARN(_log, "Flux error field ("
190  << fluxField << "Err"
191  << ") not found in reference catalog. Not using ref flux errors.");
192  }
193  _filterMap.clear();
194  _filterMap.reserve(refFluxMap.size());
195  size_t nFilters = 0;
196  for (auto const &filter : refFluxMap) {
197  _filterMap[filter.first] = nFilters;
198  nFilters++;
199  }
200 
201  refStarList.clear();
202  for (size_t i = 0; i < refCat.size(); i++) {
203  auto const &record = refCat.get(i);
204 
205  auto coord = record->get(coordKey);
206  double defaultFlux = record->get(fluxKey);
207  double defaultFluxErr;
208  if (fluxErrKey.isValid()) {
209  defaultFluxErr = record->get(fluxErrKey);
210  } else {
211  defaultFluxErr = std::numeric_limits<double>::quiet_NaN();
212  }
213  std::vector<double> fluxList(nFilters);
214  std::vector<double> fluxErrList(nFilters);
215  for (auto const &filter : _filterMap) {
216  fluxList[filter.second] = refFluxMap.at(filter.first).at(i);
217  fluxErrList[filter.second] = refFluxErrMap.at(filter.first).at(i);
218  }
219  double ra = lsst::afw::geom::radToDeg(coord.getLongitude());
220  double dec = lsst::afw::geom::radToDeg(coord.getLatitude());
221  auto star = std::make_shared<RefStar>(ra, dec, defaultFlux, defaultFluxErr, fluxList, fluxErrList);
222 
223  // TODO DM-10826: RefCats aren't guaranteed to have position errors.
224  // TODO: Need to devise a way to check whether the refCat has position errors
225  // TODO: and use them instead, if available.
226  // cook up errors: 100 mas per cooordinate
227  star->vx = std::pow(0.1 / 3600 / cos(coord.getLatitude()), 2);
228  star->vy = std::pow(0.1 / 3600, 2);
229  star->vxy = 0.;
230 
231  // Reject sources with non-finite fluxes and flux errors, and fluxErr=0 (which gives chi2=inf).
232  if (rejectBadFluxes &&
233  (!std::isfinite(defaultFlux) || !std::isfinite(defaultFluxErr) || defaultFluxErr == 0))
234  continue;
235  refStarList.push_back(star);
236  }
237 
238  // project on CTP (i.e. RaDec2CTP), in degrees
239  AstrometryTransformLinear identity;
240  TanRaDecToPixel raDecToCommonTangentPlane(identity, _commonTangentPoint);
241 
242  associateRefStars(matchCut.asArcseconds(), &raDecToCommonTangentPlane);
243 }
244 
245 const lsst::afw::geom::Box2D Associations::getRaDecBBox() {
246  // compute the frame on the CTP that contains all input images
247  Frame tangentPlaneFrame;
248 
249  for (auto const &ccdImage : ccdImageList) {
250  Frame CTPFrame = ccdImage->getPixelToCommonTangentPlane()->apply(ccdImage->getImageFrame(), false);
251  if (tangentPlaneFrame.getArea() == 0)
252  tangentPlaneFrame = CTPFrame;
253  else
254  tangentPlaneFrame += CTPFrame;
255  }
256 
257  // convert tangent plane coordinates to RaDec:
258  AstrometryTransformLinear identity;
259  TanPixelToRaDec commonTangentPlaneToRaDec(identity, _commonTangentPoint);
260  Frame raDecFrame = commonTangentPlaneToRaDec.apply(tangentPlaneFrame, false);
261 
262  lsst::afw::geom::Point<double> min(raDecFrame.xMin, raDecFrame.yMin);
263  lsst::afw::geom::Point<double> max(raDecFrame.xMax, raDecFrame.yMax);
264  lsst::afw::geom::Box2D box(min, max);
265 
266  return box;
267 }
268 
269 void Associations::associateRefStars(double matchCutInArcSec, const AstrometryTransform *transform) {
270  // associate with FittedStars
271  // 3600 because coordinates are in degrees (in CTP).
272  auto starMatchList = listMatchCollect(Ref2Base(refStarList), Fitted2Base(fittedStarList), transform,
273  matchCutInArcSec / 3600.);
274 
275  LOGLS_DEBUG(_log, "Refcat matches before removing ambiguities " << starMatchList->size());
276  starMatchList->removeAmbiguities(*transform);
277  LOGLS_DEBUG(_log, "Refcat matches after removing ambiguities " << starMatchList->size());
278 
279  // actually associate things
280  for (auto const &starMatch : *starMatchList) {
281  const BaseStar &bs = *starMatch.s1;
282  const RefStar &rs_const = dynamic_cast<const RefStar &>(bs);
283  RefStar &rs = const_cast<RefStar &>(rs_const);
284  const BaseStar &bs2 = *starMatch.s2;
285  const FittedStar &fs_const = dynamic_cast<const FittedStar &>(bs2);
286  FittedStar &fs = const_cast<FittedStar &>(fs_const);
287  // rs->setFittedStar(*fs);
288  fs.setRefStar(&rs);
289  }
290 
291  LOGLS_INFO(_log,
292  "Associated " << starMatchList->size() << " reference stars among " << refStarList.size());
293 }
294 
295 void Associations::prepareFittedStars(int minMeasurements) {
296  selectFittedStars(minMeasurements);
297  normalizeFittedStars();
298 }
299 
300 void Associations::selectFittedStars(int minMeasurements) {
301  LOGLS_INFO(_log, "Fitted stars before measurement # cut: " << fittedStarList.size());
302 
303  // first pass: remove objects that have less than a certain number of measurements.
304  for (auto const &ccdImage : ccdImageList) {
305  MeasuredStarList &catalog = ccdImage->getCatalogForFit();
306  // Iteration happens internal to the loop, as we may delete measuredStars from catalog.
307  for (MeasuredStarIterator mi = catalog.begin(); mi != catalog.end();) {
308  MeasuredStar &mstar = **mi;
309 
310  auto fittedStar = mstar.getFittedStar();
311  // measuredStar has no fittedStar: move on.
312  if (fittedStar == nullptr) {
313  ++mi;
314  continue;
315  }
316 
317  // keep FittedStars which either have a minimum number of
318  // measurements, or are matched to a RefStar
319  if (!fittedStar->getRefStar() && fittedStar->getMeasurementCount() < minMeasurements) {
320  fittedStar->getMeasurementCount()--;
321  mi = catalog.erase(mi); // mi now points to the next measuredStar.
322  } else {
323  ++mi;
324  }
325  } // end loop on objects in catalog
326  } // end loop on catalogs
327 
328  // now FittedStars with less than minMeasurements should have zero measurementCount.
329  for (FittedStarIterator fi = fittedStarList.begin(); fi != fittedStarList.end();) {
330  if ((*fi)->getMeasurementCount() == 0) {
331  fi = fittedStarList.erase(fi);
332  } else {
333  ++fi;
334  }
335  }
336 
337  LOGLS_INFO(_log, "Fitted stars after measurement # cut: " << fittedStarList.size());
338 }
339 
340 void Associations::normalizeFittedStars() const {
341  // Clear positions in order to take the average of the measuredStars.
342  for (auto &fittedStar : fittedStarList) {
343  fittedStar->x = 0.0;
344  fittedStar->y = 0.0;
345  fittedStar->setFlux(0.0);
346  fittedStar->getMag() = 0.0;
347  }
348 
349  // Iterate over measuredStars to add their values into their fittedStars
350  for (auto const &ccdImage : ccdImageList) {
351  std::shared_ptr<AstrometryTransform> toCommonTangentPlane = ccdImage->getPixelToCommonTangentPlane();
352  MeasuredStarList &catalog = ccdImage->getCatalogForFit();
353  for (auto &mi : catalog) {
354  auto fittedStar = mi->getFittedStar();
355  if (fittedStar == nullptr)
356  throw(LSST_EXCEPT(
358  "All measuredStars must have a fittedStar: did you call selectFittedStars()?"));
359  auto point = toCommonTangentPlane->apply(*mi);
360  fittedStar->x += point.x;
361  fittedStar->y += point.y;
362  fittedStar->getFlux() += mi->getFlux();
363  }
364  }
365 
366  for (auto &fi : fittedStarList) {
367  auto measurementCount = fi->getMeasurementCount();
368  fi->x /= measurementCount;
369  fi->y /= measurementCount;
370  fi->getFlux() /= measurementCount;
371  fi->getMag() = utils::nanojanskyToABMagnitude(fi->getFlux());
372  }
373 }
374 
375 void Associations::assignMags() {
376  for (auto const &ccdImage : ccdImageList) {
377  MeasuredStarList &catalog = ccdImage->getCatalogForFit();
378  for (auto const &mstar : catalog) {
379  auto fstar = mstar->getFittedStar();
380  if (!fstar) continue;
381  fstar->addMagMeasurement(mstar->getMag(), mstar->getMagWeight());
382  }
383  }
384 }
385 
387  // By default, Associations::fittedStarList is expressed on the Associations::commonTangentPlane.
388  // For AstrometryFit, we need it on the sky.
389  if (!fittedStarList.inTangentPlaneCoordinates) {
390  LOGLS_WARN(_log,
391  "DeprojectFittedStars: Fitted stars are already in sidereal coordinates, nothing done ");
392  return;
393  }
394 
395  TanPixelToRaDec ctp2Sky(AstrometryTransformLinear(), getCommonTangentPoint());
396  fittedStarList.applyTransform(ctp2Sky);
397  fittedStarList.inTangentPlaneCoordinates = false;
398 }
399 
401  return std::count_if(ccdImageList.begin(), ccdImageList.end(), [](std::shared_ptr<CcdImage> const &item) {
402  return item->getCatalogForFit().size() > 0;
403  });
404 }
405 
407  size_t count = 0;
408  for (auto const &fittedStar : fittedStarList) {
409  if ((fittedStar != nullptr) & (fittedStar->getRefStar() != nullptr)) count++;
410  }
411  return count;
412 }
413 
414 #ifdef TODO
415 void Associations::collectMCStars(int realization) {
416  CcdImageIterator I;
417  StarMatchIterator smI;
418 
419  for (I = ccdImageList.begin(); I != ccdImageList.end(); I++) {
420  CcdImage &ccdImage = **I;
421  string dbimdir = ccdImage.Dir();
422  string mctruth = dbimdir + "/mc/mctruth.list";
423 
424  if (realization >= 0) {
425  stringstream sstrm;
426  sstrm << dbimdir << "/mc/mctruth_" << realization << ".list";
427  mctruth = sstrm.str();
428  }
429 
431  MeasuredStarList &catalog = ccdImage.getCatalogForFit();
432 
433  // BaseStarWithErrorList mctruthlist(mctruth);
434  DicStarList mctruthlist(mctruth);
435  auto starMatchList =
436  listMatchCollect(Measured2Base(catalog), Dic2Base(mctruthlist), &gti, 1. /* pixel ? */);
437  if (starMatchList)
438  for (smI = starMatchList->begin(); smI != starMatchList->end(); smI++) {
439  StarMatch &sm = *smI;
440  BaseStar *bs = sm.s1;
441  MeasuredStar *mstar = dynamic_cast<MeasuredStar *>(bs);
442  bs = sm.s2;
443  DicStar *dstar = dynamic_cast<DicStar *>(bs);
444  std::unique_ptr<BaseStarWithError> mcstar(new BaseStarWithError(*bs));
445  mcstar->GetMCInfo().iflux = dstar->getval("iflux");
446  mcstar->GetMCInfo().tflux = dstar->getval("sflux");
447  /*
448  mstar->SetMCTruth(mcstar);
449  mstar->SetMCMeas(mcstar);
450  */
451  }
452  else
453  LOGLS_FATAL(_log, "CollectMCStars Unable to match MCTruth w/ catalog!");
454  }
455 }
456 
457 void Associations::setFittedStarColors(std::string dicStarListName, std::string color,
458  double matchCutArcSec) {
459  // decode color string in case it is x-y
460  size_t pos_minus = color.find('-');
461  bool compute_diff = (pos_minus != string::npos);
462  std::string c1, c2;
463  c1 = color.substr(0, pos_minus); // if pos_minus == npos, means "up to the end"
464  if (compute_diff) c2 = color.substr(pos_minus + 1, string::npos);
465  DicStarList cList(dicStarListName);
466  if (!cList.HasKey(c1))
467  throw(GastroException("Associations::SetFittedstarColors : " + dicStarListName +
468  " misses a key named \"" + c1 + "\""));
469  if (compute_diff && !cList.HasKey(c2))
470  throw(GastroException("Associations::SetFittedstarColors : " + dicStarListName +
471  " misses a key named \"" + c2 + "\""));
472  // we associate in some tangent plane. The reference catalog is expressed on the sky,
473  // but FittedStar's may be still in this tangent plane.
474  BaseStarList &l1 = (BaseStarList &)fittedStarList;
476  TanRaDecToPixel proj(AstrometryTransformLinear(), getCommonTangentPoint());
477  // project or not ?
478  AstrometryTransform *id_or_proj = &proj;
479  if (fittedStarList.inTangentPlaneCoordinates) id_or_proj = &id;
480  // The color List is to be projected:
481  TStarList projected_cList((BaseStarList &)cList, proj);
482  // Associate
483  auto starMatchList = listMatchCollect(Fitted2Base(fittedStarList), (const BaseStarList &)projected_cList,
484  id_or_proj, matchCutArcSec / 3600);
485 
486  LOGLS_INFO(_log, "Matched " << starMatchList->size() << '/' << fittedStarList.size()
487  << " FittedStars to color catalog");
488  // Evaluate and assign colors.
489  for (auto i = starMatchList->begin(); i != starMatchList->end(); ++i) {
490  BaseStar *s1 = i->s1;
491  FittedStar *fs = dynamic_cast<FittedStar *>(s1);
492  BaseStar *s2 = i->s2;
493  const TStar *ts = dynamic_cast<const TStar *>(s2);
494  const DicStar *ds = dynamic_cast<const DicStar *>(ts->get_original());
495  fs->color = ds->getval(c1);
496  if (compute_diff) fs->color -= ds->getval(c2);
497  }
498 }
499 
500 #endif /* TODO */
501 } // namespace jointcal
502 } // namespace lsst
#define LOGLS_WARN(logger, message)
Objects used as position anchors, typically USNO stars.
Definition: RefStar.h:39
The transformation that handles pixels to sideral transformations (Gnomonic, possibly with polynomial...
double dec
int nCcdImagesValidForFit() const
return the number of CcdImages with non-empty catalogs to-be-fit.
MeasuredStarList::iterator MeasuredStarIterator
Definition: MeasuredStar.h:154
A hanger for star associations.
Definition: StarMatch.h:54
implements the linear transformations (6 real coefficients).
A point in a plane.
Definition: Point.h:36
double getArea() const
Definition: Frame.cc:118
void apply(const double xIn, const double yIn, double &xOut, double &yOut) const
Transform pixels to ICRS RA, Dec in degrees.
double xMin
coordinate of boundary.
Definition: Frame.h:41
T end(T... args)
std::unique_ptr< StarMatchList > listMatchCollect(const BaseStarList &list1, const BaseStarList &list2, const AstrometryTransform *guess, const double maxDist)
assembles star matches.
Definition: ListMatch.cc:569
STL class.
void associateCatalogs(const double matchCutInArcsec=0, const bool useFittedList=false, const bool enlargeFittedList=true)
incrementaly builds a merged catalog of all image catalogs
Definition: Associations.cc:88
A list of MeasuredStar. They are usually filled in Associations::createCcdImage.
Definition: MeasuredStar.h:146
Frame rescale(const double factor) const
rescale it. The center does not move.
Definition: Frame.cc:110
STL class.
pairs of points
The base class for handling stars. Used by all matching routines.
Definition: BaseStar.h:50
T at(T... args)
void prepareFittedStars(int minMeasurements)
Set the color field of FittedStar &#39;s from a colored catalog.
size_t nFittedStarsWithAssociatedRefStar() const
Return the number of fittedStars that have an associated refStar.
T push_back(T... args)
void collectRefStars(afw::table::SimpleCatalog &refCat, afw::geom::Angle matchCut, std::string const &fluxField, RefFluxMapType const &refFluxMap=RefFluxMapType(), RefFluxMapType const &refFluxErrMap=RefFluxMapType(), bool rejectBadFluxes=false)
Collect stars from an external reference catalog and associate them with fittedStars.
std::lists of Stars.
Definition: StarList.h:58
rectangle with sides parallel to axes.
Definition: Frame.h:38
#define LOGLS_DEBUG(logger, message)
SchemaItem< T > find(std::string const &name) const
Class for a simple mapping implementing a generic AstrometryTransform.
void setRefStar(const RefStar *_refStar)
Set the astrometric reference star associated with this star.
Definition: FittedStar.cc:46
table::Key< int > transform
void computeCommonTangentPoint()
Sets a shared tangent point for all ccdImages, using the mean of the centers of all ccdImages...
Definition: Associations.cc:72
FittedStarList::iterator FittedStarIterator
Definition: FittedStar.h:131
int max
T erase(T... args)
A list of FittedStar s. Such a list is typically constructed by Associations.
Definition: FittedStar.h:122
Key< U > key
T str(T... args)
This one is the Tangent Plane (called gnomonic) projection (from celestial sphere to tangent plane) ...
T isfinite(T... args)
T cos(T... args)
objects measured on actual images.
Definition: MeasuredStar.h:46
T dynamic_pointer_cast(T... args)
::std::list< StarMatch >::iterator StarMatchIterator
Definition: StarMatch.h:133
void deprojectFittedStars()
Sends back the fitted stars coordinates on the sky FittedStarsList::inTangentPlaneCoordinates keeps t...
table::Key< int > id
T count_if(T... args)
#define LOGLS_INFO(logger, message)
void setCommonTangentPoint(lsst::afw::geom::Point2D const &commonTangentPoint)
Sets a shared tangent point for all ccdImages.
Definition: Associations.cc:83
A do-nothing transformation. It anyway has dummy routines to mimick a AstrometryTransform.
T get(T... args)
bool inFrame(double x, double y) const
inside?
Definition: Frame.cc:120
T find(T... args)
#define LSST_EXCEPT(type,...)
void createCcdImage(afw::table::SourceCatalog &catalog, std::shared_ptr< lsst::afw::geom::SkyWcs > wcs, std::shared_ptr< lsst::afw::image::VisitInfo > visitInfo, lsst::afw::geom::Box2I const &bbox, std::string const &filter, std::shared_ptr< afw::image::PhotoCalib > photoCalib, std::shared_ptr< afw::cameraGeom::Detector > detector, int visit, int ccd, lsst::jointcal::JointcalControl const &control)
Create a ccdImage from an exposure catalog and metadata, and add it to the list.
Definition: Associations.cc:58
STL class.
STL class.
int min
a virtual (interface) class for geometric transformations.
T begin(T... args)
T pow(T... args)
MeasuredStarList const & getCatalogForFit() const
Gets the catalog to be used for fitting, which may have been cleaned-up.
Definition: CcdImage.h:94
Combinatorial searches for linear transformations to go from list1 to list2.
BaseStarList & Fitted2Base(FittedStarList &This)
Definition: FittedStar.cc:64
std::shared_ptr< const BaseStar > s2
Definition: StarMatch.h:62
const lsst::afw::geom::Box2D getRaDecBBox()
BaseStarList & Measured2Base(MeasuredStarList &This)
Definition: MeasuredStar.cc:58
std::shared_ptr< RecordT > const get(size_type i) const
std::shared_ptr< const BaseStar > s1
Definition: StarMatch.h:62
T substr(T... args)
std::string sourceFluxField
"name of flux field in source catalog" ;
T quiet_NaN(T... args)
#define LOGLS_FATAL(logger, message)
Handler of an actual image from a single CCD.
Definition: CcdImage.h:64
#define LOG_GET(logger)
std::shared_ptr< FittedStar > getFittedStar() const
Definition: MeasuredStar.h:113
The objects which have been measured several times.
Definition: FittedStar.h:60
T reserve(T... args)
BaseStarList & Ref2Base(RefStarList &This)
Definition: RefStar.cc:34