Detectors.h

Go to the documentation of this file.

/* Detectors - succinct representation of the detectors
 *
 * 2008/3/11 bv@bnl.gov
 */

#ifndef DETECTORS_H
#define DETECTORS_H

#include "Conventions/DetectorId.h"
#include "Conventions/Site.h"

#include <string>
#include <ostream>

namespace DayaBay {

    class Detector {
    public:
        Detector(Site::Site_t site,
                 DetectorId::DetectorId_t det);

        Detector(const Detector& det) { m_data = det.m_data; }

        Detector(int fullPackedData);

        Detector(short int sitedet);

        Detector(std::string name) { m_data = (Detector::siteDetPackedFromString(name) << 16); }

        Detector();

        static Detector from_short(short int sitedet);

        virtual ~Detector();

        // Assignment Operator
        Detector& operator=(const Detector& det)
          { m_data = det.m_data; return *this; }

        void set(Site::Site_t site, DetectorId::DetectorId_t det);

        std::string asString() const;

        std::string detName() const;

        DetectorId::DetectorId_t detectorId() const;

        Site::Site_t site() const;

        int fullPackedData() const;

        short int siteDetPackedData() const;

        static short int siteDetPackedFromString(const std::string str);

        bool isAD() const { return DetectorId::isAD(this->detectorId()); }

        bool isWaterShield() const { return DetectorId::isWaterShield(this->detectorId()); }

        bool isRPC() const { return DetectorId::isRPC(this->detectorId()); }

        virtual bool bogus() const;

        bool operator==(const Detector& rhs) const { return this->m_data == rhs.m_data; }
        bool operator!=(const Detector& rhs) const { return !(*this == rhs); }

    protected:
        unsigned int m_data;
    };

    class DetectorSensor : public Detector {
    public:
        DetectorSensor() : Detector(0) {}
        DetectorSensor(unsigned int sensor_id,
                       Site::Site_t site,
                       DetectorId::DetectorId_t det);
        DetectorSensor(const DetectorSensor& sensor) : Detector(sensor) {}
        DetectorSensor(int data) : Detector(data) {}
        virtual ~DetectorSensor();
        // Assignment Operator
        DetectorSensor& operator=(const DetectorSensor& sensor)
          { m_data = sensor.m_data; return *this; }

        int sensorId() const;

        virtual bool bogus() const;

    };

    class AdPmtSensor : public DetectorSensor {
    public:
        AdPmtSensor() : DetectorSensor(0) {}
        AdPmtSensor(int ring, int column,
                    Site::Site_t site, DetectorId::DetectorId_t detid);
        AdPmtSensor(int ring, int column,
                    Site::Site_t site, int ad_number);
        AdPmtSensor(const AdPmtSensor& sensor) : DetectorSensor(sensor) {}
        AdPmtSensor(int data) : DetectorSensor(data) {}
        virtual ~AdPmtSensor();
        // Assignment Operator
        AdPmtSensor& operator=(const AdPmtSensor& sensor)
          { m_data = sensor.m_data; return *this; }

        int ring() const;

        int column() const;

        bool baseBogus() const;

        virtual bool bogus() const;

        bool is2inch() const;

        bool is8inch() const;

        bool isRefSig() const;
    };

    class AdFadcSensor : public DetectorSensor {
    public:
        AdFadcSensor() : DetectorSensor(0) {}
        AdFadcSensor(int ring, int column, 
                           Site::Site_t site, DetectorId::DetectorId_t detid);
        AdFadcSensor(int ring, int column,
                           Site::Site_t site, int ad_number);
        AdFadcSensor(int /* ring */, const AdFadcSensor& sensor) : DetectorSensor(sensor) {}
        AdFadcSensor(int data) : DetectorSensor(data) {}
        virtual ~AdFadcSensor();

        int channel() const;

        // Assignment Operator
        AdFadcSensor& operator=(const AdFadcSensor& sensor)
          { m_data = sensor.m_data; return *this; }

        virtual bool bogus() const;
    };

    class PoolPmtSensor : public DetectorSensor {
    public:
        PoolPmtSensor() : DetectorSensor(0) {}
        PoolPmtSensor(int wall_number, int wall_spot, bool inward_facing,
                      Site::Site_t site, DetectorId::DetectorId_t detid);
        PoolPmtSensor(const PoolPmtSensor& sensor) : DetectorSensor(sensor) {}
        PoolPmtSensor(int data) : DetectorSensor(data) {}
        virtual ~PoolPmtSensor();
        // Assignment Operator
        PoolPmtSensor& operator=(const PoolPmtSensor& sensor)
          { m_data = sensor.m_data; return *this; }

        int wallNumber() const;
        int wallSpot() const;
        bool inwardFacing() const;

        virtual bool bogus() const;
    };

    class RpcSensor : public DetectorSensor {
    public:
        RpcSensor() : DetectorSensor(0) {}
        RpcSensor(int panelRow, int panelColumn, int layer, int strip,
                  Site::Site_t site, DetectorId::DetectorId_t detid);
        RpcSensor(const RpcSensor& sensor) : DetectorSensor(sensor) {}
        RpcSensor(int data) : DetectorSensor(data) {}
        virtual ~RpcSensor();
        // Assignment Operator
        RpcSensor& operator=(const RpcSensor& sensor)
          { m_data = sensor.m_data; return *this; }

        RpcSensor panel() const;

        int panelRow() const;
        int panelColumn() const;
        int layer() const;
        int strip() const;

        virtual bool bogus() const;
    };



    std::ostream& operator<<(std::ostream& str, const DayaBay::Detector& det);
    std::ostream& operator<<(std::ostream& str, const DayaBay::DetectorSensor& detsens);
    std::ostream& operator<<(std::ostream& str, const DayaBay::AdPmtSensor& adsens);
    std::ostream& operator<<(std::ostream& str, const DayaBay::AdFadcSensor& adsens);
    std::ostream& operator<<(std::ostream& str, const DayaBay::PoolPmtSensor& adsens);
    std::ostream& operator<<(std::ostream& str, const DayaBay::RpcSensor& rpcsens);

    bool operator<(const DayaBay::Detector& a, const DayaBay::Detector& b);


}      // namespace DayaBay
#endif  // DETECTORS_H