Amplifier.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
/*
 * Developed for the LSST Data Management System.
 * This product includes software developed by the LSST Project
 * (https://www.lsst.org).
 * See the COPYRIGHT file at the top-level directory of this distribution
 * for details of code ownership.
 *
 * 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 GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
#ifndef LSST_AFW_CAMERAGEOM_AMPLIFIER_H_INCLUDED
#define LSST_AFW_CAMERAGEOM_AMPLIFIER_H_INCLUDED
 
#include <string>
 
#include "lsst/afw/table/fwd.h"
#include "lsst/geom/Box.h"
#include "lsst/geom/Extent.h"
 
namespace lsst {
namespace afw {
namespace cameraGeom {
 
enum class ReadoutCorner {
    LL,
    LR,
    UR,
    UL,
};
 
enum class AssemblyState {
    RAW,
    SCIENCE,
};
 
class Amplifier {
public:
 
    class Builder;
 
    static table::Schema getRecordSchema();
 
    virtual ~Amplifier() noexcept = default;
 
    void toRecord(table::BaseRecord & record) const;
 
    Builder rebuild() const;
 
    std::string getName() const { return getFields().name; }
 
    lsst::geom::Box2I getBBox() const { return getFields().bbox; }
 
    double getGain() const { return getFields().gain; }
 
    double getReadNoise() const { return getFields().readNoise; }
 
    double getSaturation() const { return getFields().saturation; }
 
    double getSuspectLevel() const { return getFields().suspectLevel; }
 
    ReadoutCorner getReadoutCorner() const { return getFields().readoutCorner; }
 
    ndarray::Array<double const, 1, 1> getLinearityCoeffs() const { return getFields().linearityCoeffs; }
 
    std::string getLinearityType() const { return getFields().linearityType; }
 
    double getLinearityThreshold() const { return getFields().linearityThreshold; }
 
    double getLinearityMaximum() const { return getFields().linearityMaximum; }
 
    std::string getLinearityUnits() const { return getFields().linearityUnits; }
 
    lsst::geom::Box2I getRawBBox() const { return getFields().rawBBox; }
 
    lsst::geom::Box2I getRawDataBBox() const { return getFields().rawDataBBox; }
 
    bool getRawFlipX() const { return getFields().rawFlipX; }
 
    bool getRawFlipY() const { return getFields().rawFlipY; }
 
    lsst::geom::Extent2I getRawXYOffset() const { return getFields().rawXYOffset; }
 
    lsst::geom::Box2I getRawHorizontalOverscanBBox() const { return getFields().rawHorizontalOverscanBBox; }
 
    lsst::geom::Box2I getRawVerticalOverscanBBox() const { return getFields().rawVerticalOverscanBBox; }
 
    lsst::geom::Box2I getRawPrescanBBox() const { return getFields().rawPrescanBBox; }
 
    lsst::geom::Box2I getRawSerialOverscanBBox() const { return getFields().rawHorizontalOverscanBBox; }
 
    lsst::geom::Box2I getRawParallelOverscanBBox() const { return getFields().rawVerticalOverscanBBox; }
 
    lsst::geom::Box2I getRawSerialPrescanBBox() const { return getFields().rawPrescanBBox; }
 
    lsst::geom::Box2I getRawHorizontalPrescanBBox() const { return getFields().rawPrescanBBox; }
 
protected:
 
    struct Fields {
        std::string name;
        lsst::geom::Box2I bbox;
        double gain = 0.0;
        double readNoise = 0.0;
        double saturation = 0.0;
        double suspectLevel = 0.0;
        ReadoutCorner readoutCorner = ReadoutCorner::LL;
        ndarray::Array<double const, 1, 1> linearityCoeffs;
        std::string linearityType;
        double linearityThreshold;
        double linearityMaximum;
        std::string linearityUnits;
        lsst::geom::Box2I rawBBox;
        lsst::geom::Box2I rawDataBBox;
        bool rawFlipX = false;
        bool rawFlipY = false;
        lsst::geom::Extent2I rawXYOffset;
        lsst::geom::Box2I rawHorizontalOverscanBBox;
        lsst::geom::Box2I rawVerticalOverscanBBox;
        lsst::geom::Box2I rawPrescanBBox;
    };
 
    // Amplifier construction and assignment is protected to avoid type-slicing
    // but permit derived classes to implement safe versions of these.
 
    Amplifier() = default;
 
    Amplifier(Amplifier const &) = default;
    Amplifier(Amplifier &&) = default;
    Amplifier & operator=(Amplifier const &) = default;
    Amplifier & operator=(Amplifier &&) = default;
 
    virtual Fields const & getFields() const = 0;
 
};
 
class Amplifier::Builder final : public Amplifier {
public:
 
    static Builder fromRecord(table::BaseRecord const & record);
 
    Builder() = default;
 
    Builder(Builder const &) = default;
 
    Builder(Builder &&) = default;
 
    Builder(Amplifier const & other);
 
    Builder & operator=(Builder const &) = default;
 
    Builder & operator=(Builder &&) = default;
 
    Builder & operator=(Amplifier const & other);
 
    ~Builder() noexcept override = default;
 
    std::shared_ptr<Amplifier const> finish() const;
 
    void setName(std::string const &name) { _fields.name = name; }
 
    void setBBox(lsst::geom::Box2I const &bbox) { _fields.bbox = bbox; }
 
    void setGain(double gain) { _fields.gain = gain; }
 
    void setReadNoise(double readNoise) { _fields.readNoise = readNoise; }
 
    void setSaturation(double saturation) { _fields.saturation = saturation; }
 
    void setSuspectLevel(double suspectLevel) { _fields.suspectLevel = suspectLevel; }
 
    void setReadoutCorner(ReadoutCorner readoutCorner) { _fields.readoutCorner = readoutCorner; }
 
    void setLinearityCoeffs(ndarray::Array<double const, 1, 1> const & coeffs) {
        _fields.linearityCoeffs = coeffs;
    }
 
    void setLinearityType(std::string const & type) { _fields.linearityType = type; }
 
    void setLinearityThreshold(double threshold) { _fields.linearityThreshold = threshold; }
 
    void setLinearityMaximum(double maximum) { _fields.linearityMaximum = maximum; }
 
    void setLinearityUnits(std::string const & units) { _fields.linearityUnits = units; }
 
    void setRawBBox(lsst::geom::Box2I const &bbox) { _fields.rawBBox = bbox; }
 
    void setRawDataBBox(lsst::geom::Box2I const &bbox) { _fields.rawDataBBox = bbox; }
 
    void setRawFlipX(bool rawFlipX) { _fields.rawFlipX = rawFlipX; }
 
    void setRawFlipY(bool rawFlipY) { _fields.rawFlipY = rawFlipY; }
 
    void setRawXYOffset(lsst::geom::Extent2I const &xy) { _fields.rawXYOffset = xy; }
 
    void setRawHorizontalOverscanBBox(lsst::geom::Box2I const &bbox) {
        _fields.rawHorizontalOverscanBBox = bbox;
    }
 
    void setRawVerticalOverscanBBox(lsst::geom::Box2I const &bbox) {
        _fields.rawVerticalOverscanBBox = bbox;
    }
 
    void setRawPrescanBBox(lsst::geom::Box2I const &bbox) {
        _fields.rawPrescanBBox = bbox;
    }
 
    void setRawSerialOverscanBBox(lsst::geom::Box2I const &bbox) {
        _fields.rawHorizontalOverscanBBox = bbox;
    }
 
    void setRawParallelOverscanBBox(lsst::geom::Box2I const &bbox) {
        _fields.rawVerticalOverscanBBox = bbox;
    }
 
    void setRawSerialPrescanBBox(lsst::geom::Box2I const &bbox) {
        _fields.rawPrescanBBox = bbox;
    }
 
    void setRawHorizontalPrescanBBox(lsst::geom::Box2I const &bbox) {
        _fields.rawPrescanBBox = bbox;
    }
 
protected:
    Fields const & getFields() const override { return _fields; }
private:
    Fields _fields;
};
 
 
 
}  // namespace cameraGeom
}  // namespace afw
}  // namespace lsst
 
#endif  // !LSST_AFW_CAMERAGEOM_AMPLIFIER_H_INCLUDED