AmpInfo.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
/*
 * LSST Data Management System
 * Copyright 2008, 2009, 2010, 2011 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/>.
 */
#ifndef AFW_TABLE_AmpInfo_h_INCLUDED
#define AFW_TABLE_AmpInfo_h_INCLUDED

#include "lsst/afw/table/BaseRecord.h"
#include "lsst/afw/table/BaseTable.h"
#include "lsst/afw/table/Catalog.h"
#include "lsst/afw/table/BaseColumnView.h"
#include "lsst/afw/table/aggregates.h"

namespace lsst {
namespace afw {
namespace table {

enum ReadoutCorner {
    LL,
    LR,
    UR,
    UL,
};

class AmpInfoRecord;
class AmpInfoTable;

class AmpInfoRecord : public BaseRecord {
public:
    typedef AmpInfoTable Table;
    typedef ColumnViewT<AmpInfoRecord> ColumnView;
    typedef CatalogT<AmpInfoRecord> Catalog;
    typedef CatalogT<AmpInfoRecord const> ConstCatalog;

    AmpInfoRecord(AmpInfoRecord const &) = delete;
    AmpInfoRecord(AmpInfoRecord &&) = delete;
    AmpInfoRecord &operator=(AmpInfoRecord const &) = delete;
    AmpInfoRecord &operator=(AmpInfoRecord &&) = delete;
    ~AmpInfoRecord() override;

    AmpInfoRecord(ConstructionToken const & token, detail::RecordData && data) :
        BaseRecord(token, std::move(data))
    {}

    std::shared_ptr<AmpInfoTable const> getTable() const {
        return std::static_pointer_cast<AmpInfoTable const>(BaseRecord::getTable());
    }

    std::string getName() const;
    void setName(std::string const &name);  

    lsst::geom::Box2I getBBox() const;
    void setBBox(lsst::geom::Box2I const &bbox);  

    double getGain() const;
    void setGain(double gain);  

    double getReadNoise() const;
    void setReadNoise(double readNoise);  

    double getSaturation() const;
    void setSaturation(double saturation);  

    double getSuspectLevel() const;
    void setSuspectLevel(
            double suspectLevel);  

    ReadoutCorner getReadoutCorner() const;
    void setReadoutCorner(ReadoutCorner val);  

    std::vector<double> getLinearityCoeffs() const;
    void setLinearityCoeffs(std::vector<double> const &coeffs);  

    std::string getLinearityType() const;
    void setLinearityType(std::string const &type);  

    bool getHasRawInfo() const;
    void setHasRawInfo(bool hasRawInfo);  

    lsst::geom::Box2I getRawBBox() const;
    void setRawBBox(lsst::geom::Box2I const &bbox);  

    lsst::geom::Box2I getRawDataBBox() const;
    void setRawDataBBox(
            lsst::geom::Box2I const &bbox);  

    bool getRawFlipX() const;
    void setRawFlipX(bool rawFlipX);  

    bool getRawFlipY() const;
    void setRawFlipY(bool rawFlipY);  

    lsst::geom::Extent2I getRawXYOffset() const;
    void setRawXYOffset(lsst::geom::Extent2I const
                                &xy);  

    lsst::geom::Box2I getRawHorizontalOverscanBBox() const;
    void setRawHorizontalOverscanBBox(
            lsst::geom::Box2I const &bbox);  

    lsst::geom::Box2I getRawVerticalOverscanBBox() const;
    void setRawVerticalOverscanBBox(
            lsst::geom::Box2I const &bbox);  

    lsst::geom::Box2I getRawPrescanBBox() const;
    void setRawPrescanBBox(lsst::geom::Box2I const &bbox);  


private:
    friend class AmpInfoTable;
};

class AmpInfoTable : public BaseTable {
public:
    typedef AmpInfoRecord Record;
    typedef ColumnViewT<AmpInfoRecord> ColumnView;
    typedef CatalogT<Record> Catalog;
    typedef CatalogT<Record const> ConstCatalog;
    static int const MAX_NAME_LENGTH = 64;            // max length for amplifier name
    static int const MAX_LINEARITY_COEFFS = 4;        // max number of linearity coefficients
    static int const MAX_LINEARITY_TYPE_LENGTH = 64;  // max length for linearity type

    AmpInfoTable &operator=(AmpInfoTable const &) = delete;
    AmpInfoTable &operator=(AmpInfoTable &&) = delete;
    ~AmpInfoTable() override;

    static std::shared_ptr<AmpInfoTable> make(Schema const &schema);

    static Schema makeMinimalSchema() {
        Schema r = getMinimalSchema().schema;
        r.disconnectAliases();
        return r;
    }

    static bool checkSchema(Schema const &other) { return other.contains(getMinimalSchema().schema); }


    static Key<std::string> getNameKey() { return getMinimalSchema().name; }
    static PointKey<int> getBBoxMinKey() { return getMinimalSchema().bboxMin; }
    static PointKey<int> getBBoxExtentKey() { return getMinimalSchema().bboxExtent; }
    static Key<double> getGainKey() { return getMinimalSchema().gain; }
    static Key<double> getReadNoiseKey() { return getMinimalSchema().readNoise; }
    static Key<double> getSaturationKey() { return getMinimalSchema().saturation; }
    static Key<double> getSuspectLevelKey() { return getMinimalSchema().suspectLevel; }
    static Key<int> getReadoutCornerKey() { return getMinimalSchema().readoutCorner; }
    static Key<Array<double> > getLinearityCoeffsKey() { return getMinimalSchema().linearityCoeffs; }
    static Key<std::string> getLinearityTypeKey() { return getMinimalSchema().linearityType; }
    static Key<Flag> getHasRawInfoKey() { return getMinimalSchema().hasRawInfo; }
    static PointKey<int> getRawBBoxMinKey() { return getMinimalSchema().rawBBoxMin; }
    static PointKey<int> getRawBBoxExtentKey() { return getMinimalSchema().rawBBoxExtent; }
    static PointKey<int> getRawDataBBoxMinKey() { return getMinimalSchema().rawDataBBoxMin; }
    static PointKey<int> getRawDataBBoxExtentKey() { return getMinimalSchema().rawDataBBoxExtent; }
    static Key<Flag> getRawFlipXKey() { return getMinimalSchema().rawFlipX; }
    static Key<Flag> getRawFlipYKey() { return getMinimalSchema().rawFlipY; }
    static PointKey<int> getRawXYOffsetKey() { return getMinimalSchema().rawXYOffset; }
    static PointKey<int> getRawHorizontalOverscanBBoxMinKey() {
        return getMinimalSchema().rawHorizontalOverscanBBoxMin;
    }
    static PointKey<int> getRawHorizontalOverscanBBoxExtentKey() {
        return getMinimalSchema().rawHorizontalOverscanBBoxExtent;
    }
    static PointKey<int> getRawVerticalOverscanBBoxMinKey() {
        return getMinimalSchema().rawVerticalOverscanBBoxMin;
    }
    static PointKey<int> getRawVerticalOverscanBBoxExtentKey() {
        return getMinimalSchema().rawVerticalOverscanBBoxExtent;
    }
    static PointKey<int> getRawPrescanBBoxMinKey() { return getMinimalSchema().rawPrescanBBoxMin; }
    static PointKey<int> getRawPrescanBBoxExtentKey() { return getMinimalSchema().rawPrescanBBoxExtent; }

    std::shared_ptr<AmpInfoTable> clone() const { return std::static_pointer_cast<AmpInfoTable>(_clone()); }

    std::shared_ptr<AmpInfoRecord> makeRecord() {
        return std::static_pointer_cast<AmpInfoRecord>(_makeRecord());
    }

    std::shared_ptr<AmpInfoRecord> copyRecord(BaseRecord const &other) {
        return std::static_pointer_cast<AmpInfoRecord>(BaseTable::copyRecord(other));
    }

    std::shared_ptr<AmpInfoRecord> copyRecord(BaseRecord const &other, SchemaMapper const &mapper) {
        return std::static_pointer_cast<AmpInfoRecord>(BaseTable::copyRecord(other, mapper));
    }

protected:
    explicit AmpInfoTable(Schema const &schema);

    explicit AmpInfoTable(AmpInfoTable const &other);
    explicit AmpInfoTable(AmpInfoTable &&other);

    std::shared_ptr<BaseTable> _clone() const override;

    std::shared_ptr<BaseRecord> _makeRecord() override;

private:
    // Struct that holds the minimal schema and the special keys we've added to it.
    struct MinimalSchema {
        Schema schema;
        Key<std::string> name;
        PointKey<int> bboxMin;
        PointKey<int> bboxExtent;
        Key<double> gain;
        Key<double> readNoise;
        Key<double> saturation;
        Key<double> suspectLevel;
        Key<int> readoutCorner;
        Key<Array<double> > linearityCoeffs;
        Key<std::string> linearityType;
        Key<Flag> hasRawInfo;
        PointKey<int> rawBBoxMin;
        PointKey<int> rawBBoxExtent;
        PointKey<int> rawDataBBoxMin;
        PointKey<int> rawDataBBoxExtent;
        Key<Flag> rawFlipX;
        Key<Flag> rawFlipY;
        PointKey<int> rawXYOffset;
        PointKey<int> rawHorizontalOverscanBBoxMin;
        PointKey<int> rawHorizontalOverscanBBoxExtent;
        PointKey<int> rawVerticalOverscanBBoxMin;
        PointKey<int> rawVerticalOverscanBBoxExtent;
        PointKey<int> rawPrescanBBoxMin;
        PointKey<int> rawPrescanBBoxExtent;
        MinimalSchema();
    };

    // Return the singleton minimal schema.
    static MinimalSchema &getMinimalSchema();

    friend class io::FitsWriter;

    // Return a writer object that knows how to save in FITS format.  See also FitsWriter.
    std::shared_ptr<io::FitsWriter> makeFitsWriter(fits::Fits *fitsfile, int flags) const override;
};
}  // namespace table
}  // namespace afw
}  // namespace lsst

#endif  // !AFW_TABLE_AmpInfo_h_INCLUDED