VisitInfo.cc

Go to the documentation of this file.

// -*- LSST-C++ -*- // fixed format comment for emacs
/*
 * LSST Data Management System
 * Copyright 2016 LSST Corporation.
 *
 * This product includes software developed by the
 * LSST Project (http://www.lsst.org/).
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the LSST License Statement and
 * the GNU General Public License along with this program.  If not,
 * see <http://www.lsstcorp.org/LegalNotices/>.
 */
#include <cmath>
#include <limits>
#include <sstream>
 
#include "boost/algorithm/string/trim.hpp"
 
#include "lsst/cpputils/hashCombine.h"
#include "lsst/pex/exceptions.h"
#include "lsst/geom/Angle.h"
#include "lsst/geom/SpherePoint.h"
#include "lsst/afw/table/Key.h"
#include "lsst/afw/table/aggregates.h"  // for CoordKey
#include "lsst/afw/table/Schema.h"
#include "lsst/afw/table/misc.h"  // for RecordId
#include "lsst/afw/table/io/OutputArchive.h"
#include "lsst/afw/table/io/InputArchive.h"
#include "lsst/afw/table/io/CatalogVector.h"  // needed, but why?
#include "lsst/afw/image/VisitInfo.h"
#include "lsst/afw/table/io/Persistable.cc"
 
using lsst::daf::base::DateTime;
 
namespace lsst {
namespace afw {
 
template std::shared_ptr<image::VisitInfo> table::io::PersistableFacade<image::VisitInfo>::dynamicCast(
        std::shared_ptr<table::io::Persistable> const&);
 
namespace image {
 
// the following persistence-related code emulates that in Calib.cc
 
namespace {
 
// Version history:
// unversioned: original VisitInfo schema
// 1: file versioning, instrument label
// 2: id field
// 3: focusZ field
// 4: observationType, scienceProgram, observationReason, object, hasSimulatedContent fields
// 5: remove exposureId field
int constexpr SERIALIZATION_VERSION = 5;
 
auto const nan = std::numeric_limits<double>::quiet_NaN();

double getDouble(daf::base::PropertySet const& metadata, std::string const& key) {
    try {
        return metadata.exists(key) && !metadata.isUndefined(key) ? metadata.getAsDouble(key) : nan;
    } catch (pex::exceptions::TypeError& err) {
        // If an exposure has an invalid float here (often NaN)
        // it should put NaN in the visitInfo because it's the same
        // as it not being a valid key.
        return nan;
    }
}

lsst::geom::Angle getAngle(daf::base::PropertySet const& metadata, std::string const& key) {
    return getDouble(metadata, key) * lsst::geom::degrees;
}

std::string getString(daf::base::PropertySet const& metadata, std::string const& key) {
    return metadata.exists(key) && !metadata.isUndefined(key) ? metadata.getAsString(key) : "";
}

bool setDouble(daf::base::PropertySet& metadata, std::string const& key, double value,
               std::string const& comment) {
    if (std::isfinite(value)) {
        metadata.set(key, value);
        return true;
    }
    return false;
}

bool setAngle(daf::base::PropertySet& metadata, std::string const& key, lsst::geom::Angle const& angle,
              std::string const& comment) {
    return setDouble(metadata, key, angle.asDegrees(), comment);
}

bool setString(daf::base::PropertySet& metadata, std::string const& key, std::string value,
               std::string const& comment) {
    if (!value.empty()) {
        metadata.set(key, value);
        return true;
    }
    return false;
}

std::string rotTypeStrFromEnum(RotType rotType) {
    switch (rotType) {
        case RotType::UNKNOWN:
            return "UNKNOWN";
        case RotType::SKY:
            return "SKY";
        case RotType::HORIZON:
            return "HORIZON";
        case RotType::MOUNT:
            return "MOUNT";
    }
    std::ostringstream os;
    os << "Unknown RotType enum: " << static_cast<int>(rotType);
    throw LSST_EXCEPT(lsst::pex::exceptions::RuntimeError, os.str());
}

RotType rotTypeEnumFromStr(std::string const& rotTypeName) {
    if (rotTypeName == "UNKNOWN") {
        return RotType::UNKNOWN;
    } else if (rotTypeName == "SKY") {
        return RotType::SKY;
    } else if (rotTypeName == "HORIZON") {
        return RotType::HORIZON;
    } else if (rotTypeName == "MOUNT") {
        return RotType::MOUNT;
    }
    std::ostringstream os;
    os << "Unknown RotType name: \"" << rotTypeName << "\"";
    throw LSST_EXCEPT(lsst::pex::exceptions::RuntimeError, os.str());
}
 
class VisitInfoSchema {
public:
    table::Schema schema;
    table::Key<double> exposureTime;
    table::Key<double> darkTime;
    table::Key<std::int64_t> tai;
    table::Key<double> ut1;
    table::Key<lsst::geom::Angle> era;
    table::CoordKey boresightRaDec;
    table::Key<lsst::geom::Angle> boresightAzAlt_az;
    table::Key<lsst::geom::Angle> boresightAzAlt_alt;
    table::Key<double> boresightAirmass;
    table::Key<lsst::geom::Angle> boresightRotAngle;
    table::Key<int> rotType;
    // observatory data
    table::Key<lsst::geom::Angle> latitude;
    table::Key<lsst::geom::Angle> longitude;
    table::Key<double> elevation;
    // weather data
    table::Key<double> airTemperature;
    table::Key<double> airPressure;
    table::Key<double> humidity;
 
    table::Key<std::string> instrumentLabel;
    table::Key<int> version;
 
    table::Key<table::RecordId> idnum;
 
    table::Key<double> focusZ;
 
    table::Key<std::string> observationType;
    table::Key<std::string> scienceProgram;
    table::Key<std::string> observationReason;
    table::Key<std::string> object;
    table::Key<afw::table::Flag> hasSimulatedContent;
 
    static std::string const VERSION_KEY;
 
    static VisitInfoSchema const& get(int version = SERIALIZATION_VERSION) {
        // This is always the latest version.
        static VisitInfoSchema instanceLatest(SERIALIZATION_VERSION);
        // Versions that need to be preserved (e.g., a removed field) should have a separate instance.
        static VisitInfoSchema instanceWithExposureId(4);
        if (version < 5) {
            return instanceWithExposureId;
        } else {
            return instanceLatest;
        }
    }
 
    // No copying
    VisitInfoSchema(const VisitInfoSchema&) = delete;
    VisitInfoSchema& operator=(const VisitInfoSchema&) = delete;
 
    // No moving
    VisitInfoSchema(VisitInfoSchema&&) = delete;
    VisitInfoSchema& operator=(VisitInfoSchema&&) = delete;
 
private:
    VisitInfoSchema(int _version) : schema() {
        if (_version < 5) {
            // exposureId was removed in version 5, but we need to reserve space in the schema for old files.
            // We don't save the field record, as we don't need to read into it.
            schema.addField<table::RecordId>("exposureid", "exposure ID", "");
        }
        exposureTime = schema.addField<double>("exposuretime", "exposure duration", "s");
        darkTime = schema.addField<double>("darktime", "time from CCD flush to readout", "s");
        tai = schema.addField<std::int64_t>(
                "tai", "TAI date and time at middle of exposure as nsec from unix epoch", "nsec");
        ut1 = schema.addField<double>("ut1", "UT1 date and time at middle of exposure", "MJD");
        era = schema.addField<lsst::geom::Angle>("era", "earth rotation angle at middle of exposure", "");
        boresightRaDec = table::CoordKey::addFields(schema, "boresightradec",
                                                    "sky position of boresight at middle of exposure");
        // CoordKey is intended for ICRS coordinates, so use a pair of lsst::geom::Angle fields
        // to save boresightAzAlt
        boresightAzAlt_az = schema.addField<lsst::geom::Angle>(
                "boresightazalt_az",
                "refracted apparent topocentric position of boresight at middle of exposure", "");
        boresightAzAlt_alt = schema.addField<lsst::geom::Angle>(
                "boresightazalt_alt",
                "refracted apparent topocentric position of boresight at middle of exposure", "");
        boresightAirmass = schema.addField<double>(
                "boresightairmass", "airmass at boresight, relative to zenith at sea level", "");
        boresightRotAngle = schema.addField<lsst::geom::Angle>(
                "boresightrotangle", "rotation angle at boresight at middle of exposure", "");
        rotType =
                schema.addField<int>("rottype", "rotation type; see VisitInfo.getRotType for details", "MJD");
 
        // observatory data
        latitude = schema.addField<lsst::geom::Angle>("latitude",
                                                      "latitude of telescope (+ is east of Greenwich)", "");
        longitude = schema.addField<lsst::geom::Angle>("longitude", "longitude of telescope", "");
        elevation = schema.addField<double>("elevation", "elevation of telescope", "");
 
        // weather data
        airTemperature = schema.addField<double>("airtemperature", "air temperature", "C");
        airPressure = schema.addField<double>("airpressure", "air pressure", "Pascal");
        humidity = schema.addField<double>("humidity", "humidity (%)", "");
 
        instrumentLabel = schema.addField<std::string>(
                "instrumentlabel", "Short name of the instrument that took this data", "", 0);
 
        // for internal support
        version = schema.addField<int>(VERSION_KEY, "version of this VisitInfo");
 
        idnum = schema.addField<table::RecordId>("idnum", "identifier of this full focal plane exposure", "");
 
        focusZ = schema.addField<double>("focusz", "defocal distance", "mm");
 
        observationType = schema.addField<std::string>(
                "observationType", "type of this observation (e.g. science, flat, bias)", "", 0);
        scienceProgram = schema.addField<std::string>(
                "scienceProgram", "observing program (survey or proposal) identifier", "", 0);
        observationReason = schema.addField<std::string>(
                "observationReason", "reason this observation was taken, or its purpose", "", 0);
        object = schema.addField<std::string>("object", "object of interest or field name", "", 0);
        hasSimulatedContent = schema.addField<afw::table::Flag>(
                "hasSimulatedContent", "Was any part of this observation simulated?");
    }
};
std::string const VisitInfoSchema::VERSION_KEY = "version";
 
class VisitInfoFactory : public table::io::PersistableFactory {
public:
    std::shared_ptr<table::io::Persistable> read(InputArchive const& archive,
                                                 CatalogVector const& catalogs) const override {
        LSST_ARCHIVE_ASSERT(catalogs.size() == 1u);
        LSST_ARCHIVE_ASSERT(catalogs.front().size() == 1u);
        table::BaseRecord const& record = catalogs.front().front();
        int version = getVersion(record);
        if (version > SERIALIZATION_VERSION) {
            throw LSST_EXCEPT(pex::exceptions::TypeError, "Cannot read VisitInfo FITS version > " +
                                                                  std::to_string(SERIALIZATION_VERSION) +
                                                                  ", found version " +
                                                                  std::to_string(version));
        }
 
        VisitInfoSchema const& keys = VisitInfoSchema::get(version);
        // Version-dependent fields
        std::string instrumentLabel = version >= 1 ? record.get(keys.instrumentLabel) : "";
        table::RecordId id = version >= 2 ? record.get(keys.idnum) : 0;
        double focusZ = version >= 3 ? record.get(keys.focusZ) : nan;
 
        std::string observationType = version >= 4 ? record.get(keys.observationType) : "";
        std::string scienceProgram = version >= 4 ? record.get(keys.scienceProgram) : "";
        std::string observationReason = version >= 4 ? record.get(keys.observationReason) : "";
        std::string object = version >= 4 ? record.get(keys.object) : "";
        // default false for backwards compatibility
        bool hasSimulatedContent = version >= 4 ? record.get(keys.hasSimulatedContent) : false;
 
        std::shared_ptr<VisitInfo> result(
                new VisitInfo(record.get(keys.exposureTime), record.get(keys.darkTime),
                              ::DateTime(record.get(keys.tai), ::DateTime::TAI), record.get(keys.ut1),
                              record.get(keys.era), record.get(keys.boresightRaDec),
                              lsst::geom::SpherePoint(record.get(keys.boresightAzAlt_az),
                                                      record.get(keys.boresightAzAlt_alt)),
                              record.get(keys.boresightAirmass), record.get(keys.boresightRotAngle),
                              static_cast<RotType>(record.get(keys.rotType)),
                              coord::Observatory(record.get(keys.longitude), record.get(keys.latitude),
                                                 record.get(keys.elevation)),
                              coord::Weather(record.get(keys.airTemperature), record.get(keys.airPressure),
                                             record.get(keys.humidity)),
                              instrumentLabel, id, focusZ, observationType, scienceProgram, observationReason,
                              object, hasSimulatedContent));
        return result;
    }
 
    explicit VisitInfoFactory(std::string const& name) : table::io::PersistableFactory(name) {}
 
private:
    int getVersion(table::BaseRecord const& record) const {
        try {
            // Don't assume version is at same index as in VisitInfoSchema
            auto versionKey = record.getSchema().find<int>(VisitInfoSchema::VERSION_KEY);
            return record.get(versionKey.key);
        } catch (pex::exceptions::NotFoundError const&) {
            // un-versioned files are implicitly version 0
            return 0;
        }
    }
};
 
std::string getVisitInfoPersistenceName() { return "VisitInfo"; }
 
VisitInfoFactory registration(getVisitInfoPersistenceName());
 
}  // namespace
 
namespace detail {
 
int stripVisitInfoKeywords(daf::base::PropertySet& metadata) {
    int nstripped = 0;
 
    std::vector<std::string> keyList = {"EXPTIME",     "DARKTIME",    "DATE-AVG", "TIMESYS",
                                        "TIME-MID",    "MJD-AVG-UT1", "AVG-ERA",  "BORE-RA",
                                        "BORE-DEC",    "BORE-AZ",     "BORE-ALT", "BORE-AIRMASS",
                                        "BORE-ROTANG", "ROTTYPE",     "OBS-LONG", "OBS-LAT",
                                        "OBS-ELEV",    "AIRTEMP",     "AIRPRESS", "HUMIDITY",
                                        "INSTRUMENT",  "IDNUM",       "FOCUSZ",   "OBSTYPE",
                                        "PROGRAM",     "REASON",      "OBJECT",   "HAS-SIMULATED-CONTENT"};
    for (auto&& key : keyList) {
        if (metadata.exists(key)) {
            metadata.remove(key);
            nstripped++;
        }
    }
    return nstripped;
}
int stripVisitInfoKeywords(daf::base::PropertySet& metadata) {…}
 
void setVisitInfoMetadata(daf::base::PropertyList& metadata, VisitInfo const& visitInfo) {
    setDouble(metadata, "EXPTIME", visitInfo.getExposureTime(), "Exposure time (sec)");
    setDouble(metadata, "DARKTIME", visitInfo.getDarkTime(), "Time from CCD flush to readout (sec)");
    if (visitInfo.getDate().isValid()) {
        metadata.set("DATE-AVG", visitInfo.getDate().toString(::DateTime::TAI),
                     "TAI date at middle of observation");
        metadata.set("TIMESYS", "TAI");
    }
    setDouble(metadata, "MJD-AVG-UT1", visitInfo.getUt1(), "UT1 MJD date at ctr of obs");
    setAngle(metadata, "AVG-ERA", visitInfo.getEra(), "Earth rot ang at ctr of obs (deg)");
    auto boresightRaDec = visitInfo.getBoresightRaDec();
    setAngle(metadata, "BORE-RA", boresightRaDec[0], "ICRS RA (deg) at boresight");
    setAngle(metadata, "BORE-DEC", boresightRaDec[1], "ICRS Dec (deg) at boresight");
    auto boresightAzAlt = visitInfo.getBoresightAzAlt();
    setAngle(metadata, "BORE-AZ", boresightAzAlt[0], "Refr app topo az (deg) at bore");
    setAngle(metadata, "BORE-ALT", boresightAzAlt[1], "Refr app topo alt (deg) at bore");
    setDouble(metadata, "BORE-AIRMASS", visitInfo.getBoresightAirmass(), "Airmass at boresight");
    setAngle(metadata, "BORE-ROTANG", visitInfo.getBoresightRotAngle(), "Rotation angle (deg) at boresight");
    metadata.set("ROTTYPE", rotTypeStrFromEnum(visitInfo.getRotType()), "Type of rotation angle");
    auto observatory = visitInfo.getObservatory();
    setAngle(metadata, "OBS-LONG", observatory.getLongitude(), "Telescope longitude (+E, deg)");
    setAngle(metadata, "OBS-LAT", observatory.getLatitude(), "Telescope latitude (deg)");
    setDouble(metadata, "OBS-ELEV", observatory.getElevation(), "Telescope elevation (m)");
    auto weather = visitInfo.getWeather();
    setDouble(metadata, "AIRTEMP", weather.getAirTemperature(), "Outside air temperature (C)");
    setDouble(metadata, "AIRPRESS", weather.getAirPressure(), "Outdoor air pressure (P)");
    setDouble(metadata, "HUMIDITY", weather.getHumidity(), "Relative humidity (%)");
    setString(metadata, "INSTRUMENT", visitInfo.getInstrumentLabel(),
              "Short name of the instrument that took this data");
    if (visitInfo.getId() != 0) {
        metadata.set("IDNUM", visitInfo.getId(), "identifier of this full focal plane exposure");
    }
    setDouble(metadata, "FOCUSZ", visitInfo.getFocusZ(), "Defocal distance (mm)");
    setString(metadata, "OBSTYPE", visitInfo.getObservationType(), "Type of this observation");
    setString(metadata, "PROGRAM", visitInfo.getScienceProgram(),
              "observing program (survey or proposal) identifier");
    setString(metadata, "REASON", visitInfo.getObservationReason(),
              "reason this observation was taken, or its purpose");
    setString(metadata, "OBJECT", visitInfo.getObject(), "object of interest or field name");
    metadata.set("HAS-SIMULATED-CONTENT", visitInfo.getHasSimulatedContent(),
                 "Was any part of this observation simulated?");
}
void setVisitInfoMetadata(daf::base::PropertyList& metadata, VisitInfo const& visitInfo) {…}
 
}  // namespace detail
 
VisitInfo::VisitInfo(daf::base::PropertySet const& metadata)
        : _exposureTime(nan),  // don't use getDouble because str values are also accepted
          _darkTime(getDouble(metadata, "DARKTIME")),
          _date(),
          _ut1(getDouble(metadata, "MJD-AVG-UT1")),
          _era(getAngle(metadata, "AVG-ERA")),
          _boresightRaDec(
                  lsst::geom::SpherePoint(getAngle(metadata, "BORE-RA"), getAngle(metadata, "BORE-DEC"))),
          _boresightAzAlt(
                  lsst::geom::SpherePoint(getAngle(metadata, "BORE-AZ"), getAngle(metadata, "BORE-ALT"))),
          _boresightAirmass(getDouble(metadata, "BORE-AIRMASS")),
          _boresightRotAngle(getAngle(metadata, "BORE-ROTANG")),
          _rotType(RotType::UNKNOWN),
          _observatory(getAngle(metadata, "OBS-LONG"), getAngle(metadata, "OBS-LAT"),
                       getDouble(metadata, "OBS-ELEV")),
          _weather(getDouble(metadata, "AIRTEMP"), getDouble(metadata, "AIRPRESS"),
                   getDouble(metadata, "HUMIDITY")),
          _instrumentLabel(getString(metadata, "INSTRUMENT")),
          _id(0),
          _focusZ(getDouble(metadata, "FOCUSZ")),
          _observationType(getString(metadata, "OBSTYPE")),
          _scienceProgram(getString(metadata, "PROGRAM")),
          _observationReason(getString(metadata, "REASON")),
          _object(getString(metadata, "OBJECT")),
          // default false for backwards compatibility
          _hasSimulatedContent(false) {
    auto key = "IDNUM";
    if (metadata.exists(key) && !metadata.isUndefined(key)) {
        _id = metadata.getAsInt64(key);
    }
 
    key = "EXPTIME";
    if (metadata.exists(key) && !metadata.isUndefined(key)) {
        try {
            _exposureTime = metadata.getAsDouble(key);
        } catch (lsst::pex::exceptions::TypeError& err) {
            // some old exposures have EXPTIME stored as a string
            std::string exptimeStr = metadata.getAsString(key);
            _exposureTime = std::stod(exptimeStr);
        }
    }
 
    key = "DATE-AVG";
    if (metadata.exists(key) && !metadata.isUndefined(key)) {
        if (metadata.exists("TIMESYS")) {
            auto timesysName = boost::algorithm::trim_right_copy(metadata.getAsString("TIMESYS"));
            if (timesysName != "TAI") {
                // rather than try to deal with all the possible choices, which requires
                // appending or deleting a "Z", depending on the time system, just give up.
                // VisitInfo should be used on FITS headers that have been sanitized!
                std::ostringstream os;
                os << "TIMESYS = \"" << timesysName
                   << "\"; VisitInfo requires TIMESYS to exist and to equal \"TAI\"";
                throw LSST_EXCEPT(lsst::pex::exceptions::RuntimeError, os.str());
            }
        } else {
            throw LSST_EXCEPT(lsst::pex::exceptions::RuntimeError,
                              "TIMESYS not found; VistitInfo requires TIMESYS to exist and to equal \"TAI\"");
        }
        _date = ::DateTime(boost::algorithm::trim_right_copy(metadata.getAsString(key)), ::DateTime::TAI);
    } else {
        // DATE-AVG not found. For backwards compatibility look for TIME-MID, an outdated LSST keyword
        // whose time system was UTC, despite a FITS comment claiming it was TAI. Ignore TIMESYS.
        key = "TIME-MID";
        if (metadata.exists(key) && !metadata.isUndefined(key)) {
            _date = ::DateTime(boost::algorithm::trim_right_copy(metadata.getAsString(key)), ::DateTime::UTC);
        }
    }
 
    key = "ROTTYPE";
    if (metadata.exists(key) && !metadata.isUndefined(key)) {
        _rotType = rotTypeEnumFromStr(metadata.getAsString(key));
    }
 
    key = "HAS-SIMULATED-CONTENT";
    if (metadata.exists(key) && !metadata.isUndefined(key)) {
        _hasSimulatedContent = metadata.getAsBool(key);
    }
}
VisitInfo::VisitInfo(daf::base::PropertySet const& metadata) {…}

bool _eqOrNan(double lhs, double rhs) noexcept { return (std::isnan(lhs) && std::isnan(rhs)) || lhs == rhs; }

bool _eqOrNonFinite(lsst::geom::SpherePoint const& lhs, lsst::geom::SpherePoint const& rhs) noexcept {
    return (!lhs.isFinite() && !rhs.isFinite()) || lhs == rhs;
}
bool _eqOrNonFinite(lsst::geom::SpherePoint const& lhs, lsst::geom::SpherePoint const& rhs) noexcept {…}
 
bool VisitInfo::operator==(VisitInfo const& other) const {
    return _eqOrNan(_exposureTime, other.getExposureTime()) && _eqOrNan(_darkTime, other.getDarkTime()) &&
           _date == other.getDate() && _eqOrNan(_ut1, other.getUt1()) && _eqOrNan(_era, other.getEra()) &&
           _eqOrNonFinite(_boresightRaDec, other.getBoresightRaDec()) &&
           _eqOrNonFinite(_boresightAzAlt, other.getBoresightAzAlt()) &&
           _eqOrNan(_boresightAirmass, other.getBoresightAirmass()) &&
           _eqOrNan(_boresightRotAngle, other.getBoresightRotAngle()) && _rotType == other.getRotType() &&
           _observatory == other.getObservatory() && _weather == other.getWeather() &&
           _instrumentLabel == other.getInstrumentLabel() && _id == other.getId() &&
           _eqOrNan(_focusZ, other.getFocusZ()) && _observationType == other.getObservationType() &&
           _scienceProgram == other.getScienceProgram() &&
           _observationReason == other.getObservationReason() && _object == other.getObject() &&
           _hasSimulatedContent == other.getHasSimulatedContent();
}
bool VisitInfo::operator==(VisitInfo const& other) const  {…}
 
std::size_t VisitInfo::hash_value() const noexcept {
    // Completely arbitrary seed
    return cpputils::hashCombine(17, _exposureTime, _darkTime, _date, _ut1, _era, _boresightRaDec,
                              _boresightAzAlt, _boresightAirmass, _boresightRotAngle, _rotType, _observatory,
                              _weather, _instrumentLabel, _id, _focusZ, _observationType, _scienceProgram,
                              _observationReason, _object, _hasSimulatedContent);
}
std::size_t VisitInfo::hash_value() const noexcept {…}
 
std::string VisitInfo::getPersistenceName() const { return getVisitInfoPersistenceName(); }
 
void VisitInfo::write(OutputArchiveHandle& handle) const {
    VisitInfoSchema const& keys = VisitInfoSchema::get();
    table::BaseCatalog cat = handle.makeCatalog(keys.schema);
    std::shared_ptr<table::BaseRecord> record = cat.addNew();
    record->set(keys.exposureTime, getExposureTime());
    record->set(keys.darkTime, getDarkTime());
    record->set(keys.tai, getDate().nsecs(::DateTime::TAI));
    record->set(keys.ut1, getUt1());
    record->set(keys.era, getEra());
    record->set(keys.boresightRaDec, getBoresightRaDec());
    auto boresightAzAlt = getBoresightAzAlt();
    record->set(keys.boresightAzAlt_az, boresightAzAlt[0]);
    record->set(keys.boresightAzAlt_alt, boresightAzAlt[1]);
    record->set(keys.boresightAirmass, getBoresightAirmass());
    record->set(keys.boresightRotAngle, getBoresightRotAngle());
    record->set(keys.rotType, static_cast<int>(getRotType()));
    auto observatory = getObservatory();
    record->set(keys.latitude, observatory.getLatitude());
    record->set(keys.longitude, observatory.getLongitude());
    record->set(keys.elevation, observatory.getElevation());
    auto weather = getWeather();
    record->set(keys.airTemperature, weather.getAirTemperature());
    record->set(keys.airPressure, weather.getAirPressure());
    record->set(keys.humidity, weather.getHumidity());
    record->set(keys.instrumentLabel, getInstrumentLabel());
    record->set(keys.version, SERIALIZATION_VERSION);
    record->set(keys.idnum, getId());
    record->set(keys.focusZ, getFocusZ());
    record->set(keys.observationType, getObservationType());
    record->set(keys.scienceProgram, getScienceProgram());
    record->set(keys.observationReason, getObservationReason());
    record->set(keys.object, getObject());
    record->set(keys.hasSimulatedContent, getHasSimulatedContent());
    handle.saveCatalog(cat);
}
void VisitInfo::write(OutputArchiveHandle& handle) const  {…}
 
lsst::geom::Angle VisitInfo::getLocalEra() const { return getEra() + getObservatory().getLongitude(); }
 
lsst::geom::Angle VisitInfo::getBoresightHourAngle() const { return getLocalEra() - getBoresightRaDec()[0]; }
 
lsst::geom::Angle VisitInfo::getBoresightParAngle() const {
    double _parallactic_y, _parallactic_x, result;
    _parallactic_y = sin(getBoresightHourAngle().asRadians());
    _parallactic_x =
            cos((getBoresightRaDec()[1]).asRadians()) * tan(getObservatory().getLatitude().asRadians()) -
            sin((getBoresightRaDec()[1]).asRadians()) * cos(getBoresightHourAngle().asRadians());
    result = atan2(_parallactic_y, _parallactic_x);
    return result * lsst::geom::radians;
}
lsst::geom::Angle VisitInfo::getBoresightParAngle() const  {…}
 
std::shared_ptr<typehandling::Storable> VisitInfo::cloneStorable() const {
    return std::make_unique<VisitInfo>(*this);
}
std::shared_ptr<typehandling::Storable> VisitInfo::cloneStorable() const  {…}
 
bool VisitInfo::equals(typehandling::Storable const& other) const noexcept {
    return singleClassEquals(*this, other);
}
bool VisitInfo::equals(typehandling::Storable const& other) const noexcept {…}
 
std::string VisitInfo::toString() const {
    std::stringstream buffer;
    buffer << "VisitInfo(";
    buffer << "exposureTime=" << getExposureTime() << ", ";
    buffer << "darkTime=" << getDarkTime() << ", ";
    buffer << "date=" << (getDate().isValid() ? getDate().toString(daf::base::DateTime::TAI) : "<invalid>")
           << ", ";
    buffer << "UT1=" << getUt1() << ", ";
    buffer << "ERA=" << getEra() << ", ";
    buffer << "boresightRaDec=" << getBoresightRaDec() << ", ";
    buffer << "boresightAzAlt=" << getBoresightAzAlt() << ", ";
    buffer << "boresightAirmass=" << getBoresightAirmass() << ", ";
    buffer << "boresightRotAngle=" << getBoresightRotAngle() << ", ";
    buffer << "rotType=" << static_cast<int>(getRotType()) << ", ";
    buffer << "observatory=" << getObservatory() << ", ";
    buffer << "weather=" << getWeather() << ", ";
    buffer << "instrumentLabel='" << getInstrumentLabel() << "', ";
    buffer << "id=" << getId() << ", ";
    buffer << "focusZ=" << getFocusZ() << ", ";
    buffer << "observationType='" << getObservationType() << "', ";
    buffer << "scienceProgram='" << getScienceProgram() << "', ";
    buffer << "observationReason='" << getObservationReason() << "', ";
    buffer << "object='" << getObject() << "', ";
    buffer << "hasSimulatedContent=" << std::boolalpha << getHasSimulatedContent();
    buffer << ")";
    return buffer.str();
}
std::string VisitInfo::toString() const  {…}
 
std::ostream& operator<<(std::ostream& os, VisitInfo const& visitInfo) {
    os << visitInfo.toString();
    return os;
}
std::ostream& operator<<(std::ostream& os, VisitInfo const& visitInfo) {…}
 
}  // namespace image
}  // namespace afw
}  // namespace lsst