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; }

    [[deprecated("Amplifier objects always have raw information; will be removed after 19.0.")]] // DM-21711
    bool getHasRawInfo() const { return true; }

    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; }

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;
    }

protected:
    Fields const & getFields() const override { return _fields; }
private:
    Fields _fields;
};



}  // namespace cameraGeom
}  // namespace afw
}  // namespace lsst

#endif  // !LSST_AFW_CAMERAGEOM_AMPLIFIER_H_INCLUDED