JPMT.hh

Go to the documentation of this file.

#ifndef __JDETECTOR__JPMT__
#define __JDETECTOR__JPMT__

#include <istream>
#include <ostream>
#include <string>
#include <vector>
#include <map>

#include "JLang/JType.hh"
#include "JLang/JObjectID.hh"
#include "JLang/JMultiEquals.hh"
#include "JLang/JException.hh"
#include "JGeometry3D/JAxis3D.hh"
#include "JDetector/JCalibration.hh"
#include "JDetector/JDetectorVersion.hh"
#include "Jeep/JStatus.hh"
#include "Jeep/JVersion.hh"
#include "Jeep/JeepToolkit.hh"
#include "JIO/JSerialisable.hh"


/**
 * \file
 *
 * Data structure for PMT geometry and calibration.
 * \author mdejong
 */
namespace JDETECTOR {}
namespace JPP { using namespace JDETECTOR; }

namespace JDETECTOR {

  using JLANG::JType;
  using JLANG::JObjectID;
  using JLANG::JMultiEquals;
  using JLANG::JTYPELIST;
  using JLANG::JTypeInformationException;
  using JGEOMETRY3D::JAxis3D;
  using JEEP::JStatus;
  using JEEP::JVersion;
  using JIO::JReader;
  using JIO::JWriter;


  /**
   * Data structure for PMT geometry and calibration.
   *
   * N.B. 
   * The axis of the PMT points in the direction of the field of view of the photo-cathode.
   */
  class JPMT :
    public JObjectID,
    public JAxis3D,
    public JCalibration,
    public JStatus,
    public JMultiEquals<JPMT, JTYPELIST<JObjectID>::typelist>
  {
  public:
    /**
     * Enumeration of status bits.\n
     * Additional status bits should be included in JGetPMTStatusBit::JGetPMTStatusBit.
     */
    enum JPMTStatusBits_t {
      PMT_STATUS     =  0   //!< General status.
    };


    /**
     * Default constructor.
     */
    JPMT() :
      JObjectID(),
      JAxis3D(),
      JCalibration(),
      JStatus()
    {}


    /**
     * Constructor.
     *
     * \param  id         identifier
     * \param  axis       axis
     * \param  status     status
     */
    JPMT(const int&     id,
         const JAxis3D& axis,
         const JStatus& status = JStatus()) : 
      JObjectID(id),
      JAxis3D(axis),
      JCalibration(),
      JStatus(status)
    {}


    /**
     * Constructor.
     *
     * \param  id         identifier
     * \param  axis       axis
     * \param  cal        calibration
     * \param  status     status
     */
    JPMT(const int&          id,
         const JAxis3D&      axis,
         const JCalibration& cal,
         const JStatus&      status = JStatus()) : 
      JObjectID(id),
      JAxis3D(axis),
      JCalibration(cal),
      JStatus(status)
    {}


    /**
     * Get detector version.
     */
    static JDetectorVersion& getVersion()
    {
      static JDetectorVersion version;

      return version;
    }


    /**
     * Set detector version.
     *
     * \param  version    version
     */
    static void setVersion(const JVersion& version)
    {
      getVersion() = JDetectorVersion(version);
    }


    /**
     * Test PMT status.
     *
     * \param  bit        bit
     */
    bool has(const JPMTStatusBits_t bit) const
    {
      return (this->getStatus() & (1<<bit)) != 0;
    }
 

    /**
     * Set PMT status.
     *
     * \param  bit        bit
     */
    void set(const JPMTStatusBits_t bit)
    {
      this->getStatus() |= (1<<bit);
    }


    /**
     * Reset PMT status.
     *
     * \param  bit        bit
     */
    void reset(const JPMTStatusBits_t bit)
    {
      this->getStatus() &= ~(1<<bit);
    }


    /**
     * Dot product.
     *
     * The dot product is evaluated for the PMT orientation.
     *
     * \param  pmt        PMT
     * \return            dot product
     */
    inline double getDot(const JPMT& pmt) const
    {
      return this->getDirection().getDot(pmt.getDirection());
    }


    /**
     * Read PMT from input.
     *
     * \param  in         input stream
     * \param  pmt        PMT
     * \return            input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JPMT& pmt)
    {
      in >> static_cast<JObjectID&>   (pmt);
      in >> static_cast<JAxis3D&>     (pmt);
      in >> static_cast<JCalibration&>(pmt);

      if (getDetectorVersion(getVersion()) >= JDetectorVersion::V3) {
        in >> static_cast<JStatus&>(pmt);
      }

      return in;
    }


    /**
     * Write PMT to output.
     *
     * \param  out        output stream
     * \param  pmt        PMT
     * \return            output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JPMT& pmt)
    {
      out << static_cast<const JObjectID&>   (pmt);
      out << ' ';
      out << static_cast<const JAxis3D&>     (pmt);
      out << ' ';
      out << static_cast<const JCalibration&>(pmt);

      if (getDetectorVersion(getVersion()) >= JDetectorVersion::V3) {
        out << ' ';
        out << static_cast<const JStatus&>(pmt);
      }

      return out;
    }


    /**
     * Read PMT from input.
     *
     * \param  in         reader
     * \param  pmt        PMT
     * \return            reader
     */
    friend inline JReader& operator>>(JReader& in, JPMT& pmt)
    {
      in >> static_cast<JObjectID&>   (pmt);
      in >> static_cast<JAxis3D&>     (pmt);
      in >> static_cast<JCalibration&>(pmt);

      if (getDetectorVersion(getVersion()) >= JDetectorVersion::V3) {
        in >> static_cast<JStatus&>(pmt);
      }

      return in;
    }


    /**
     * Write PMT to output.
     *
     * \param  out      writer
     * \param  pmt      PMT
     * \return          writer
     */
    friend inline JWriter& operator<<(JWriter& out, const JPMT& pmt)
    {
      out << static_cast<const JObjectID&>   (pmt);
      out << static_cast<const JAxis3D&>     (pmt);
      out << static_cast<const JCalibration&>(pmt);

      if (getDetectorVersion(getVersion()) >= JDetectorVersion::V3) {
        out << static_cast<const JStatus&>(pmt);
      }

      return out;
    }
  };



  /**
   * Auxiliary class to map key to PMT status bit.
   */
  struct JGetPMTStatusBit :
    public std::map<std::string, JPMT::JPMTStatusBits_t>
  {
    /**
     * Default constructor.
     */
    JGetPMTStatusBit()
    {
      using namespace JPP;

#define MAKE_ENTRY(A) std::make_pair(getClassname(#A), A)

      this->insert(MAKE_ENTRY(JPMT::PMT_STATUS));

#undef MAKE_ENTRY
    }


    /**
     * Get PMT status bit.
     *
     * \param  key         key
     * \return             bit
     */
    JPMT::JPMTStatusBits_t operator()(const std::string& key) const
    {
      const_iterator i = this->find(key);

      if (i != this->end()) {

        return i->second;

      } else {
        
        THROW(JTypeInformationException, "Invalid key <" << key << ">");
      }
    }
  };


  /**
   * Auxiliary class to map PMT status bit to key.
   */
  struct JPutPMTStatusBit :
    public std::map<JPMT::JPMTStatusBits_t, std::string>
  {
    /**
     * Constructor.
     *
     * \param  input       PMT status bits
     */
    JPutPMTStatusBit(const JGetPMTStatusBit& input)
    {
      using namespace std;

      for (JGetPMTStatusBit::const_iterator i = input.begin(); i != input.end(); ++i) {
        this->insert(make_pair(i->second, i->first));
      }
    }


    /**
     * Put PMT status bit.
     *
     * \param  bit        bit
     * \return            bit
     */
    const std::string& operator()(const JPMT::JPMTStatusBits_t bit) const
    {
      using namespace JPP;

      const_iterator i = this->find(bit);

      if (i != this->end()) {

        return i->second;

      } else {
        
        THROW(JTypeInformationException, "Invalid status bit <" << bit << ">");
      }
    }
  };


  /**
   * Function object to map key to PMT status bit.
   */
  static const JGetPMTStatusBit getPMTStatusBit;


  /**
   * Function object to map PMT status bit to key.
   */
  static const JPutPMTStatusBit putPMTStatusBit(getPMTStatusBit);


  /**
   * Get PMT status bits.
   *
   * \param  type       type
   * \return            status bits
   */
  inline std::vector<std::string> getPMTStatusBits(const JType<std::string>& type)
  {
    std::vector<std::string> buffer;
    
    for (JPutPMTStatusBit::const_iterator i = putPMTStatusBit.begin(); i != putPMTStatusBit.end(); ++i) {
      buffer.push_back(i->second);
    }
    
    return buffer;
  }


  /**
   * Get PMT status bits.
   *
   * \param  type       type
   * \return            status bits
   */
  inline std::vector<JPMT::JPMTStatusBits_t> getPMTStatusBits(const JType<JPMT::JPMTStatusBits_t>& type)
  {
    std::vector<JPMT::JPMTStatusBits_t> buffer;
    
    for (JPutPMTStatusBit::const_iterator i = putPMTStatusBit.begin(); i != putPMTStatusBit.end(); ++i) {
      buffer.push_back(i->first);
    }
    
    return buffer;
  }


  /**
   * Get PMT status bits.
   *
   * \return            status bits
   */
  template<class T>
  inline std::vector<T> getPMTStatusBits()
  {
    return getPMTStatusBits(JType<T>());
  }
}

#endif