LSST Applications  21.0.0-147-g0e635eb1+1acddb5be5,22.0.0+052faf71bd,22.0.0+1ea9a8b2b2,22.0.0+6312710a6c,22.0.0+729191ecac,22.0.0+7589c3a021,22.0.0+9f079a9461,22.0.1-1-g7d6de66+b8044ec9de,22.0.1-1-g87000a6+536b1ee016,22.0.1-1-g8e32f31+6312710a6c,22.0.1-10-gd060f87+016f7cdc03,22.0.1-12-g9c3108e+df145f6f68,22.0.1-16-g314fa6d+c825727ab8,22.0.1-19-g93a5c75+d23f2fb6d8,22.0.1-19-gb93eaa13+aab3ef7709,22.0.1-2-g8ef0a89+b8044ec9de,22.0.1-2-g92698f7+9f079a9461,22.0.1-2-ga9b0f51+052faf71bd,22.0.1-2-gac51dbf+052faf71bd,22.0.1-2-gb66926d+6312710a6c,22.0.1-2-gcb770ba+09e3807989,22.0.1-20-g32debb5+b8044ec9de,22.0.1-23-gc2439a9a+fb0756638e,22.0.1-3-g496fd5d+09117f784f,22.0.1-3-g59f966b+1e6ba2c031,22.0.1-3-g849a1b8+f8b568069f,22.0.1-3-gaaec9c0+c5c846a8b1,22.0.1-32-g5ddfab5d3+60ce4897b0,22.0.1-4-g037fbe1+64e601228d,22.0.1-4-g8623105+b8044ec9de,22.0.1-5-g096abc9+d18c45d440,22.0.1-5-g15c806e+57f5c03693,22.0.1-7-gba73697+57f5c03693,master-g6e05de7fdc+c1283a92b8,master-g72cdda8301+729191ecac,w.2021.39
LSST Data Management Base Package
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/geom/Box.h"
46 #include "lsst/geom/Point.h"
47 #include "lsst/afw/image/Calib.h"
48 
49 #include "lsst/sphgeom/LonLat.h"
50 #include "lsst/sphgeom/Circle.h"
52 
53 namespace jointcal = lsst::jointcal;
54 
55 namespace {
56 LOG_LOGGER _log = LOG_GET("jointcal.Associations");
57 }
58 
59 namespace lsst {
60 namespace jointcal {
61 
68  lsst::jointcal::JointcalControl const &control) {
69  auto ccdImage = std::make_shared<CcdImage>(catalog, wcs, visitInfo, bbox, filter, photoCalib, detector,
70  visit, ccd, control.sourceFluxField);
71  ccdImageList.push_back(ccdImage);
72 }
73 
76  centers.reserve(ccdImageList.size());
77  for (auto const &ccdImage : ccdImageList) {
78  centers.push_back(ccdImage->getBoresightRaDec());
79  }
80  auto commonTangentPoint = geom::averageSpherePoint(centers);
81  LOGLS_DEBUG(_log, "Using common tangent point: " << commonTangentPoint.getPosition(geom::degrees));
82  setCommonTangentPoint(commonTangentPoint.getPosition(geom::degrees));
83 }
84 
86  _commonTangentPoint = Point(commonTangentPoint.getX(), commonTangentPoint.getY()); // a jointcal::Point
87  for (auto &ccdImage : ccdImageList) ccdImage->setCommonTangentPoint(_commonTangentPoint);
88 }
89 
91  // Compute the frame on the common tangent plane that contains all input images.
92  Frame tangentPlaneFrame;
93 
94  for (auto const &ccdImage : ccdImageList) {
95  Frame CTPFrame = ccdImage->getPixelToCommonTangentPlane()->apply(ccdImage->getImageFrame(), false);
96  if (tangentPlaneFrame.getArea() == 0)
97  tangentPlaneFrame = CTPFrame;
98  else
99  tangentPlaneFrame += CTPFrame;
100  }
101 
102  // Convert tangent plane coordinates to RaDec.
103  AstrometryTransformLinear identity;
104  TanPixelToRaDec commonTangentPlaneToRaDec(identity, _commonTangentPoint);
105  Frame raDecFrame = commonTangentPlaneToRaDec.apply(tangentPlaneFrame, false);
106 
108  points.reserve(4);
109  // raDecFrame is in on-sky (RA,Dec) degrees stored as an x/y box:
110  // the on-sky bounding box it represents is given by the corners of that box.
111  points.emplace_back(sphgeom::LonLat::fromDegrees(raDecFrame.xMin, raDecFrame.yMin));
112  points.emplace_back(sphgeom::LonLat::fromDegrees(raDecFrame.xMax, raDecFrame.yMin));
113  points.emplace_back(sphgeom::LonLat::fromDegrees(raDecFrame.xMin, raDecFrame.yMax));
114  points.emplace_back(sphgeom::LonLat::fromDegrees(raDecFrame.xMax, raDecFrame.yMax));
115 
117 }
118 
119 void Associations::associateCatalogs(const double matchCutInArcSec, const bool useFittedList,
120  const bool enlargeFittedList) {
121  // clear reference stars
122  refStarList.clear();
123 
124  // clear measurement counts and associations to refstars, but keep fittedStars themselves.
125  for (auto &item : fittedStarList) {
126  item->clearBeforeAssoc();
127  }
128  // clear fitted stars
129  if (!useFittedList) fittedStarList.clear();
130 
131  for (auto &ccdImage : ccdImageList) {
132  std::shared_ptr<AstrometryTransform> toCommonTangentPlane = ccdImage->getPixelToCommonTangentPlane();
133 
134  // Clear the catalog to fit and copy the whole catalog into it.
135  // This allows reassociating from scratch after a fit.
136  ccdImage->resetCatalogForFit();
137  MeasuredStarList &catalog = ccdImage->getCatalogForFit();
138 
139  // Associate with previous lists.
140  /* To speed up the match (more precisely the contruction of the FastFinder), select in the
141  fittedStarList the objects that are within reach of the current ccdImage */
142  Frame ccdImageFrameCPT = toCommonTangentPlane->apply(ccdImage->getImageFrame(), false);
143  ccdImageFrameCPT = ccdImageFrameCPT.rescale(1.10); // add 10 % margin.
144  // We cannot use FittedStarList::ExtractInFrame, because it does an actual copy, which we don't want
145  // here: we want the pointers in the StarMatch to refer to fittedStarList elements.
146  FittedStarList toMatch;
147 
148  for (auto const &fittedStar : fittedStarList) {
149  if (ccdImageFrameCPT.inFrame(*fittedStar)) {
150  toMatch.push_back(fittedStar);
151  }
152  }
153 
154  // divide by 3600 because coordinates in CTP are in degrees.
155  auto starMatchList = listMatchCollect(Measured2Base(catalog), Fitted2Base(toMatch),
156  toCommonTangentPlane.get(), matchCutInArcSec / 3600.);
157 
158  /* should check what this removeAmbiguities does... */
159  LOGLS_DEBUG(_log, "Measured-to-Fitted matches before removing ambiguities " << starMatchList->size());
160  starMatchList->removeAmbiguities(*toCommonTangentPlane);
161  LOGLS_DEBUG(_log, "Measured-to-Fitted matches after removing ambiguities " << starMatchList->size());
162 
163  // Associate MeasuredStar -> FittedStar using the surviving matches.
164 
165  int matchedCount = 0;
166  for (auto const &starMatch : *starMatchList) {
167  auto bs = starMatch.s1;
168  auto ms_const = std::dynamic_pointer_cast<const MeasuredStar>(bs);
169  auto ms = std::const_pointer_cast<MeasuredStar>(ms_const);
170  auto bs2 = starMatch.s2;
171  auto fs_const = std::dynamic_pointer_cast<const FittedStar>(bs2);
172  auto fs = std::const_pointer_cast<FittedStar>(fs_const);
173  ms->setFittedStar(fs);
174  matchedCount++;
175  }
176  LOGLS_INFO(_log, "Matched " << matchedCount << " objects in " << ccdImage->getName());
177 
178  // add unmatched objets to FittedStarList
179  int unMatchedCount = 0;
180  for (auto const &mstar : catalog) {
181  // to check if it was matched, just check if it has a fittedStar Pointer assigned
182  if (mstar->getFittedStar()) continue;
183  if (enlargeFittedList) {
184  auto fs = std::make_shared<FittedStar>(*mstar);
185  // transform coordinates to CommonTangentPlane
186  toCommonTangentPlane->transformPosAndErrors(*fs, *fs);
188  mstar->setFittedStar(fs);
189  }
190  unMatchedCount++;
191  }
192  LOGLS_INFO(_log, "Unmatched objects: " << unMatchedCount);
193  } // end of loop on CcdImages
194 
195  // !!!!!!!!!!!!!!!!!
196  // TODO: DO WE REALLY NEED THIS???
197  // Why do we need to do this, instead of directly computing them in normalizeFittedStars?
198  // What makes the magnitudes special here?
199  // !!!!!!!!!!!!!!!!!
200  // assignMags();
201 }
202 
204  std::string const &fluxField, float refCoordinateErr,
205  bool rejectBadFluxes) {
206  if (refCat.size() == 0) {
208  " reference catalog is empty : stop here "));
209  }
210 
211  afw::table::CoordKey coordKey = refCat.getSchema()["coord"];
212  // Handle reference catalogs that don't have position errors.
213  afw::table::Key<float> raErrKey;
214  afw::table::Key<float> decErrKey;
215  if (std::isnan(refCoordinateErr)) {
216  raErrKey = refCat.getSchema()["coord_raErr"];
217  decErrKey = refCat.getSchema()["coord_decErr"];
218  }
219 
220  auto fluxKey = refCat.getSchema().find<double>(fluxField).key;
221  // Handle reference catalogs that don't have flux errors.
222  afw::table::Key<double> fluxErrKey;
223  try {
224  fluxErrKey = refCat.getSchema().find<double>(fluxField + "Err").key;
225  } catch (pex::exceptions::NotFoundError &) {
226  LOGLS_WARN(_log, "Flux error field ("
227  << fluxField << "Err"
228  << ") not found in reference catalog. Not using ref flux errors.");
229  }
230 
231  // Handle reference catalogs that don't have proper motion & error
232  afw::table::Key<geom::Angle> pmRaKey, pmDecKey;
233  afw::table::Key<float> pmRaErrKey, pmDecErrKey, pmRaDecCovKey;
234  try {
235  pmRaKey = refCat.getSchema().find<geom::Angle>("pm_ra").key;
236  pmDecKey = refCat.getSchema().find<geom::Angle>("pm_dec").key;
238  LOGLS_WARN(_log, "Not loading proper motions: (pm_ra,pm_dec) fields not found in reference catalog.");
239  } catch (pex::exceptions::TypeError &ex) {
240  LOGLS_WARN(_log, "Not loading proper motions: RA/Dec proper motion values must be `geom:Angle`: "
241  << ex.what());
242  }
243  try {
244  pmRaErrKey = refCat.getSchema().find<float>("pm_raErr").key;
245  pmDecErrKey = refCat.getSchema().find<float>("pm_decErr").key;
247  LOGLS_WARN(_log, "Not loading proper motions: error fields not available: " << ex.what());
248  }
249 
250  // TODO: we aren't getting covariances from Gaia yet, so maybe ignore this for now?
251  try {
252  pmRaDecCovKey = refCat.getSchema().find<float>("pm_ra_Dec_Cov").key;
254  LOGLS_WARN(_log, "No ra/dec proper motion covariances in refcat: " << ex.what());
255  }
256 
257  refStarList.clear();
258  for (size_t i = 0; i < refCat.size(); i++) {
259  auto const &record = refCat.get(i);
260 
261  auto coord = record->get(coordKey);
262  double flux = record->get(fluxKey);
263  double fluxErr;
264  if (fluxErrKey.isValid()) {
265  fluxErr = record->get(fluxErrKey);
266  } else {
268  }
269  double ra = lsst::geom::radToDeg(coord.getLongitude());
270  double dec = lsst::geom::radToDeg(coord.getLatitude());
271  auto star = std::make_shared<RefStar>(ra, dec, flux, fluxErr);
272 
273  if (std::isnan(refCoordinateErr)) {
274  // refcat errors are unitless but stored as radians: convert to deg**2
275  star->vx = std::pow(lsst::geom::radToDeg(record->get(raErrKey)), 2);
276  star->vy = std::pow(lsst::geom::radToDeg(record->get(decErrKey)), 2);
277  } else {
278  // Convert the fake errors from mas to deg**2
279  star->vx = std::pow(refCoordinateErr / 1000. / 3600. / std::cos(coord.getLatitude()), 2);
280  star->vy = std::pow(refCoordinateErr / 1000. / 3600., 2);
281  }
282 
283  if (pmRaKey.isValid()) {
284  if (pmRaDecCovKey.isValid()) {
285  star->setProperMotion(std::make_unique<ProperMotion const>(
286  record->get(pmRaKey).asRadians(), record->get(pmDecKey).asRadians(),
287  record->get(pmRaErrKey), record->get(pmDecErrKey), record->get(pmRaDecCovKey)));
288  } else {
289  star->setProperMotion(std::make_unique<ProperMotion const>(
290  record->get(pmRaKey).asRadians(), record->get(pmDecKey).asRadians(),
291  record->get(pmRaErrKey), record->get(pmDecErrKey)));
292  }
293  }
294 
295  // TODO: cook up a covariance as none of our current refcats have it
296  star->vxy = 0.;
297 
298  // Reject sources with non-finite fluxes and flux errors, and fluxErr=0 (which gives chi2=inf).
299  if (rejectBadFluxes && (!std::isfinite(flux) || !std::isfinite(fluxErr) || fluxErr <= 0)) continue;
300  refStarList.push_back(star);
301  }
302 
303  // project on CTP (i.e. RaDec2CTP), in degrees
304  AstrometryTransformLinear identity;
305  TanRaDecToPixel raDecToCommonTangentPlane(identity, _commonTangentPoint);
306 
307  associateRefStars(matchCut.asArcseconds(), &raDecToCommonTangentPlane);
308 }
309 
310 void Associations::associateRefStars(double matchCutInArcSec, const AstrometryTransform *transform) {
311  // associate with FittedStars
312  // 3600 because coordinates are in degrees (in CTP).
314  matchCutInArcSec / 3600.);
315 
316  LOGLS_DEBUG(_log, "Refcat matches before removing ambiguities " << starMatchList->size());
317  starMatchList->removeAmbiguities(*transform);
318  LOGLS_DEBUG(_log, "Refcat matches after removing ambiguities " << starMatchList->size());
319 
320  // actually associate things
321  for (auto const &starMatch : *starMatchList) {
322  const BaseStar &bs = *starMatch.s1;
323  const RefStar &rs_const = dynamic_cast<const RefStar &>(bs);
324  RefStar &rs = const_cast<RefStar &>(rs_const);
325  const BaseStar &bs2 = *starMatch.s2;
326  const FittedStar &fs_const = dynamic_cast<const FittedStar &>(bs2);
327  FittedStar &fs = const_cast<FittedStar &>(fs_const);
328  // rs->setFittedStar(*fs);
329  fs.setRefStar(&rs);
330  }
331 
332  LOGLS_INFO(_log,
333  "Associated " << starMatchList->size() << " reference stars among " << refStarList.size());
334 }
335 
336 void Associations::prepareFittedStars(int minMeasurements) {
337  selectFittedStars(minMeasurements);
338  normalizeFittedStars();
339 }
340 
341 void Associations::selectFittedStars(int minMeasurements) {
342  LOGLS_INFO(_log, "Fitted stars before measurement # cut: " << fittedStarList.size());
343 
344  int totalMeasured = 0, validMeasured = 0;
345 
346  // first pass: remove objects that have less than a certain number of measurements.
347  for (auto const &ccdImage : ccdImageList) {
348  MeasuredStarList &catalog = ccdImage->getCatalogForFit();
349  // Iteration happens internal to the loop, as we may delete measuredStars from catalog.
350  for (MeasuredStarIterator mi = catalog.begin(); mi != catalog.end();) {
351  MeasuredStar &mstar = **mi;
352  ++totalMeasured;
353 
354  auto fittedStar = mstar.getFittedStar();
355  // measuredStar has no fittedStar: move on.
356  if (fittedStar == nullptr) {
357  ++mi;
358  continue;
359  }
360 
361  // keep FittedStars which either have a minimum number of
362  // measurements, or are matched to a RefStar
363  if (!fittedStar->getRefStar() && fittedStar->getMeasurementCount() < minMeasurements) {
364  fittedStar->getMeasurementCount()--;
365  mi = catalog.erase(mi); // mi now points to the next measuredStar.
366  } else {
367  ++validMeasured;
368  ++mi;
369  }
370  } // end loop on objects in catalog
371  } // end loop on catalogs
372 
373  // now FittedStars with less than minMeasurements should have zero measurementCount.
374  for (FittedStarIterator fi = fittedStarList.begin(); fi != fittedStarList.end();) {
375  if ((*fi)->getMeasurementCount() == 0) {
376  fi = fittedStarList.erase(fi);
377  } else {
378  ++fi;
379  }
380  }
381 
382  LOGLS_INFO(_log, "Fitted stars after measurement # cut: " << fittedStarList.size());
383  LOGLS_INFO(_log, "Total, valid number of Measured stars: " << totalMeasured << ", " << validMeasured);
384 }
385 
386 void Associations::normalizeFittedStars() {
387  // Clear positions in order to take the average of the measuredStars.
388  for (auto &fittedStar : fittedStarList) {
389  fittedStar->x = 0.0;
390  fittedStar->y = 0.0;
391  fittedStar->setFlux(0.0);
392  fittedStar->getMag() = 0.0;
393  }
394 
395  // Iterate over measuredStars to add their values into their fittedStars
396  for (auto const &ccdImage : ccdImageList) {
397  std::shared_ptr<AstrometryTransform> toCommonTangentPlane = ccdImage->getPixelToCommonTangentPlane();
398  MeasuredStarList &catalog = ccdImage->getCatalogForFit();
399  for (auto &mi : catalog) {
400  auto fittedStar = mi->getFittedStar();
401  if (fittedStar == nullptr)
402  throw(LSST_EXCEPT(
403  pex::exceptions::RuntimeError,
404  "All measuredStars must have a fittedStar: did you call selectFittedStars()?"));
405  auto point = toCommonTangentPlane->apply(*mi);
406  fittedStar->x += point.x;
407  fittedStar->y += point.y;
408  fittedStar->getFlux() += mi->getFlux();
409  }
410  }
411 
412  _maxMeasuredStars = 0;
413  for (auto &fi : fittedStarList) {
414  auto measurementCount = fi->getMeasurementCount();
415  _maxMeasuredStars += measurementCount;
416  fi->x /= measurementCount;
417  fi->y /= measurementCount;
418  fi->getFlux() /= measurementCount;
419  fi->getMag() = utils::nanojanskyToABMagnitude(fi->getFlux());
420  }
421 }
422 
424  auto iter = fittedStarList.begin();
425  auto end = fittedStarList.end();
426  size_t count = 0;
427  while (iter != end) {
428  auto fittedStar = *iter;
429  if (fittedStar->getMeasurementCount() == 0) {
430  LOGLS_TRACE(_log, "Deleting FittedStar (has no measuredStars): " << *fittedStar);
432  count++;
433  } else {
434  ++iter;
435  }
436  }
437  if (count > 0) {
438  LOGLS_INFO(_log, "Removed " << count << " fittedStars that had no associated measuredStar.");
439  }
440 }
441 
442 void Associations::assignMags() {
443  for (auto const &ccdImage : ccdImageList) {
444  MeasuredStarList &catalog = ccdImage->getCatalogForFit();
445  for (auto const &mstar : catalog) {
446  auto fstar = mstar->getFittedStar();
447  if (!fstar) continue;
448  fstar->addMagMeasurement(mstar->getMag(), mstar->getMagWeight());
449  }
450  }
451 }
452 
454  // By default, Associations::fittedStarList is expressed on the Associations::commonTangentPlane.
455  // For AstrometryFit, we need it on the sky.
457  LOGLS_WARN(_log,
458  "DeprojectFittedStars: Fitted stars are already in sidereal coordinates, nothing done ");
459  return;
460  }
461 
465 }
466 
469  return item->getCatalogForFit().size() > 0;
470  });
471 }
472 
474  size_t count = 0;
475  for (auto const &fittedStar : fittedStarList) {
476  if ((fittedStar != nullptr) & (fittedStar->getRefStar() != nullptr)) count++;
477  }
478  return count;
479 }
480 
481 #ifdef TODO
482 void Associations::collectMCStars(int realization) {
483  CcdImageIterator I;
484  StarMatchIterator smI;
485 
486  for (I = ccdImageList.begin(); I != ccdImageList.end(); I++) {
487  CcdImage &ccdImage = **I;
488  string dbimdir = ccdImage.Dir();
489  string mctruth = dbimdir + "/mc/mctruth.list";
490 
491  if (realization >= 0) {
492  stringstream sstrm;
493  sstrm << dbimdir << "/mc/mctruth_" << realization << ".list";
494  mctruth = sstrm.str();
495  }
496 
497  AstrometryTransformIdentity gti;
498  MeasuredStarList &catalog = ccdImage.getCatalogForFit();
499 
500  // BaseStarWithErrorList mctruthlist(mctruth);
501  DicStarList mctruthlist(mctruth);
502  auto starMatchList =
503  listMatchCollect(Measured2Base(catalog), Dic2Base(mctruthlist), &gti, 1. /* pixel ? */);
504  if (starMatchList)
505  for (smI = starMatchList->begin(); smI != starMatchList->end(); smI++) {
506  StarMatch &sm = *smI;
507  BaseStar *bs = sm.s1;
508  MeasuredStar *mstar = dynamic_cast<MeasuredStar *>(bs);
509  bs = sm.s2;
510  DicStar *dstar = dynamic_cast<DicStar *>(bs);
511  std::unique_ptr<BaseStarWithError> mcstar(new BaseStarWithError(*bs));
512  mcstar->GetMCInfo().iflux = dstar->getval("iflux");
513  mcstar->GetMCInfo().tflux = dstar->getval("sflux");
514  /*
515  mstar->SetMCTruth(mcstar);
516  mstar->SetMCMeas(mcstar);
517  */
518  }
519  else
520  LOGLS_FATAL(_log, "CollectMCStars Unable to match MCTruth w/ catalog!");
521  }
522 }
523 
524 #endif /* TODO */
525 } // namespace jointcal
526 } // namespace lsst
AmpInfoBoxKey bbox
Definition: Amplifier.cc:117
int end
This file declares a class for representing circular regions on the unit sphere.
This file declares a class for representing convex polygons with great circle edges on the unit spher...
table::Key< int > detector
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition: Exception.h:48
Combinatorial searches for linear transformations to go from list1 to list2.
LSST DM logging module built on log4cxx.
#define LOGLS_WARN(logger, message)
Log a warn-level message using an iostream-based interface.
Definition: Log.h:659
#define LOGLS_FATAL(logger, message)
Log a fatal-level message using an iostream-based interface.
Definition: Log.h:699
#define LOG_GET(logger)
Returns a Log object associated with logger.
Definition: Log.h:75
#define LOGLS_INFO(logger, message)
Log a info-level message using an iostream-based interface.
Definition: Log.h:639
#define LOG_LOGGER
Definition: Log.h:714
#define LOGLS_DEBUG(logger, message)
Log a debug-level message using an iostream-based interface.
Definition: Log.h:619
#define LOGLS_TRACE(logger, message)
Log a trace-level message using an iostream-based interface.
Definition: Log.h:599
This file contains a class representing spherical coordinates.
double dec
Definition: Match.cc:41
table::Key< table::Array< std::uint8_t > > wcs
Definition: SkyWcs.cc:66
pairs of points
table::Key< int > transform
T begin(T... args)
size_type size() const
Return the number of elements in the catalog.
Definition: Catalog.h:413
Schema getSchema() const
Return the schema associated with the catalog's table.
Definition: Catalog.h:118
std::shared_ptr< RecordT > const get(size_type i) const
Return a pointer to the record at index i.
Definition: Catalog.h:464
A FunctorKey used to get or set celestial coordinates from a pair of lsst::geom::Angle keys.
Definition: aggregates.h:210
bool isValid() const noexcept
Return true if the key was initialized to valid offset.
Definition: Key.h:97
SchemaItem< T > find(std::string const &name) const
Find a SchemaItem in the Schema by name.
Definition: Schema.cc:467
Custom catalog class for record/table subclasses that are guaranteed to have an ID,...
Definition: SortedCatalog.h:42
A class representing an angle.
Definition: Angle.h:127
constexpr double asArcseconds() const noexcept
Return an Angle's value in arcseconds.
Definition: Angle.h:178
An integer coordinate rectangle.
Definition: Box.h:55
size_t nFittedStarsWithAssociatedRefStar() const
Return the number of fittedStars that have an associated refStar.
void cleanFittedStars()
Remove FittedStars that have no measured stars; this can happen after outlier rejection.
void computeCommonTangentPoint()
Sets a shared tangent point for all ccdImages, using the mean of the centers of all ccdImages.
Definition: Associations.cc:74
lsst::sphgeom::Circle computeBoundingCircle() const
Return the bounding circle in on-sky (RA, Dec) coordinates containing all CcdImages.
Definition: Associations.cc:90
int nCcdImagesValidForFit() const
return the number of CcdImages with non-empty catalogs to-be-fit.
void createCcdImage(afw::table::SourceCatalog &catalog, std::shared_ptr< lsst::afw::geom::SkyWcs > wcs, std::shared_ptr< lsst::afw::image::VisitInfo > visitInfo, lsst::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:62
void setCommonTangentPoint(lsst::geom::Point2D const &commonTangentPoint)
Shared tangent point for all ccdImages (decimal degrees).
Definition: Associations.cc:85
void associateCatalogs(const double matchCutInArcsec=0, const bool useFittedList=false, const bool enlargeFittedList=true)
incrementaly builds a merged catalog of all image catalogs
Point getCommonTangentPoint() const
Shared tangent point for all ccdImages (decimal degrees).
Definition: Associations.h:108
void collectRefStars(afw::table::SimpleCatalog &refCat, geom::Angle matchCut, std::string const &fluxField, float refCoordinateErr, bool rejectBadFluxes=false)
Collect stars from an external reference catalog and associate them with fittedStars.
FittedStarList fittedStarList
Definition: Associations.h:58
void prepareFittedStars(int minMeasurements)
Prepare the fittedStar list by making quality cuts and normalizing measurements.
void deprojectFittedStars()
Sends back the fitted stars coordinates on the sky FittedStarsList::inTangentPlaneCoordinates keeps t...
a virtual (interface) class for geometric transformations.
implements the linear transformations (6 real coefficients).
The base class for handling stars. Used by all matching routines.
Definition: BaseStar.h:51
double getMag() const
Definition: BaseStar.h:105
Handler of an actual image from a single CCD.
Definition: CcdImage.h:64
MeasuredStarList const & getCatalogForFit() const
Gets the catalog to be used for fitting, which may have been cleaned-up.
Definition: CcdImage.h:94
FittedStars are objects whose position or flux is going to be fitted, and which come from the associa...
Definition: FittedStar.h:50
void setRefStar(const RefStar *_refStar)
Set the astrometric reference star associated with this star.
Definition: FittedStar.cc:46
A list of FittedStar s. Such a list is typically constructed by Associations.
Definition: FittedStar.h:116
rectangle with sides parallel to axes.
Definition: Frame.h:38
Frame rescale(const double factor) const
rescale it. The center does not move.
Definition: Frame.cc:110
bool inFrame(double x, double y) const
inside?
Definition: Frame.cc:120
double xMin
coordinate of boundary.
Definition: Frame.h:41
double getArea() const
Definition: Frame.cc:118
Sources measured on images.
Definition: MeasuredStar.h:51
std::shared_ptr< FittedStar > getFittedStar() const
Definition: MeasuredStar.h:118
double getMagWeight() const
the inverse of the mag variance
Definition: MeasuredStar.h:111
A list of MeasuredStar. They are usually filled in Associations::createCcdImage.
Definition: MeasuredStar.h:151
A point in a plane.
Definition: Point.h:37
Objects used as position/flux anchors (e.g.
Definition: RefStar.h:45
void applyTransform(const Operator &op)
enables to apply a geometrical transform if Star is Basestar or derives from it.
Definition: StarList.h:98
The transformation that handles pixels to sideral transformations (Gnomonic, possibly with polynomial...
virtual void apply(const double xIn, const double yIn, double &xOut, double &yOut) const=0
This one is the Tangent Plane (called gnomonic) projection (from celestial sphere to tangent plane)
Reports invalid arguments.
Definition: Runtime.h:66
Reports attempts to access elements using an invalid key.
Definition: Runtime.h:151
Reports errors from accepting an object of an unexpected or inappropriate type.
Definition: Runtime.h:167
Circle is a circular region on the unit sphere that contains its boundary.
Definition: Circle.h:46
static ConvexPolygon convexHull(std::vector< UnitVector3d > const &points)
convexHull returns the convex hull of the given set of points if it exists and throws an exception ot...
Definition: ConvexPolygon.h:65
Circle getBoundingCircle() const override
getBoundingCircle returns a bounding-circle for this region.
static LonLat fromDegrees(double lon, double lat)
Definition: LonLat.h:50
T clear(T... args)
T cos(T... args)
T count(T... args)
T emplace_back(T... args)
T end(T... args)
T erase(T... args)
T get(T... args)
T isfinite(T... args)
T isnan(T... args)
double nanojanskyToABMagnitude(double flux)
Convert a flux in nanojansky to AB magnitude.
Definition: Magnitude.cc:30
SpherePoint averageSpherePoint(std::vector< SpherePoint > const &coords)
Return the average of a list of coordinates.
Definition: SpherePoint.cc:235
constexpr AngleUnit degrees
constant with units of degrees
Definition: Angle.h:109
constexpr double radToDeg(double x) noexcept
Definition: Angle.h:52
BaseStarList & Measured2Base(MeasuredStarList &This)
Definition: MeasuredStar.cc:58
std::unique_ptr< StarMatchList > listMatchCollect(const BaseStarList &list1, const BaseStarList &list2, const AstrometryTransform *guess, const double maxDist)
assembles star matches.
Definition: ListMatch.cc:569
BaseStarList & Fitted2Base(FittedStarList &This)
Definition: FittedStar.cc:64
MeasuredStarList::iterator MeasuredStarIterator
Definition: MeasuredStar.h:159
::std::list< StarMatch >::iterator StarMatchIterator
Definition: StarMatch.h:133
BaseStarList & Ref2Base(RefStarList &This)
Definition: RefStar.cc:42
FittedStarList::iterator FittedStarIterator
Definition: FittedStar.h:125
A base class for image defects.
T pow(T... args)
T push_back(T... args)
T quiet_NaN(T... args)
T reserve(T... args)
T size(T... args)
T str(T... args)
std::string sourceFluxField
"name of flux field in source catalog" ;
Key< int > visitInfo
Definition: Exposure.cc:70
Key< int > photoCalib
Definition: Exposure.cc:67