JPMTMask.hh

Go to the documentation of this file.

#ifndef __JTRIGGER__JPMTMASK__
#define __JTRIGGER__JPMTMASK__
 
#include <istream>
#include <ostream>
 
#include <string>
 
#include "JIO/JSerialisable.hh"
#include "JDAQ/JDAQRoot.hh"
#include "JDetector/JPMTReadoutAddress.hh"
 
/**
 * \author rbruijn
 */
 
namespace JTRIGGER {}
namespace JPP { using namespace JTRIGGER; }
 
namespace JTRIGGER {
 
  using JIO::JReader;
  using JIO::JWriter;
  using JDETECTOR::JPMTReadoutAddress;
 
 
  /**
   * Type definition of pmt mask.
   */
  typedef unsigned int                            JPMTMask_t;
 
 
  /**
   * Number of pmt bits.
   */
  static const unsigned int NUMBER_OF_PMT_BITS = 31;
 
 
  /**
   * Convert pmt bit to pmt mask.
   *
   * \param  bit        pmt bit
   * \return            pmt mask
   */
  inline JPMTMask_t getPMTMask(const unsigned int bit)
  {
    if (bit < NUMBER_OF_PMT_BITS)
      return JPMTMask_t(1) << bit;
    else
      return 0;
  }
 
 
  /**
   * Auxiliary class for pmt mask.
   */
  class JPMTMask {
  public:
    /**
     * Default constructor.
     */
    JPMTMask() :
      pmt_mask(0)
    {}
 
 
    /**
     * Constructor.
     *
     * \param  mask           pmt mask
     */
    JPMTMask(const JPMTMask_t mask) :
      pmt_mask(mask)
    {}
 
 
    /**
     * Constructor.
     *
     * \param  buffer         pmt bit pattern (i.e. sequence of '0' and '1').
     */
    JPMTMask(const std::string& buffer) :
      pmt_mask(valueOf(buffer).getPMTMask())
    {}
 
 
    /**
     * Virtual destructor.
     */
    virtual ~JPMTMask()
    {}
 
 
    /**
     * Get pmt bit pattern.
     *
     * \return                pmt mask
     */
    JPMTMask_t getPMTMask() const
    {
      return pmt_mask;
    }
 
 
    /**
     * Add pmt pmt mask.
     *
     * \param  mask           pmt mask
     * \return                pmt mask
     */
    JPMTMask& addPMTMask(const JPMTMask_t mask)
    {
      pmt_mask |= mask;
 
      return *this;
    }
 
 
    /** 
     * Add pmt pmt mask.
     *
     * \param  mask           pmted mask
     * \return                pmted mask
     */
    JPMTMask& addPMTMask(const JPMTMask& mask)
    {
      return addPMTMask(mask.getPMTMask());
    }
   
    /**
     * Add pmt bit.
     *
     * \param  bit            pmt bit
     * \return                pmt mask
     */
    inline JPMTMask& addPMTBit(const unsigned int bit)
    {
      pmt_mask |= JTRIGGER::getPMTMask(bit);
 
      return *this;
    }
 
    /**
     * Add pmt channel
     * 
     * \param channel     pmt readout channel
     * \return            pmt mask
     */
    inline JPMTMask& addPMT(const JPMTReadoutAddress& channel)
    {
      return addPMTBit(channel.getTDC());
    }
    
 
    /**
     * Check pmt bit.
     *
     * \param  bit            pmt bit
     * \return                true if bit is set; else false
     */
    inline bool hasPMTBit(const unsigned int bit) const
    {
      return pmt_mask & JTRIGGER::getPMTMask(bit);
    }
 
    /** 
     *  check pmt
     * 
     * \param  channel       PMT channel
     * \return               true if PMT is selected; else false
     */
    inline bool hasPMT(const JPMTReadoutAddress& channel) const
    {
      return hasPMTBit(channel.getTDC());
    }
       
    /**
     * Extract pmt mask.
     *
     * \param  buffer         pmt bit pattern (i.e. sequence of '0' and '1').
     * \return                pmt mask
     */
    static JPMTMask valueOf(const std::string& buffer)
    {
      JPMTMask pmt_mask;
 
      unsigned int bit = 0;
 
      for (std::string::const_reverse_iterator i = buffer.rbegin(); i != buffer.rend() && bit != NUMBER_OF_PMT_BITS; ++i, ++bit) {
        if (*i == '1') {
          pmt_mask.addPMTBit(bit);
        }
      }
 
      return pmt_mask;
    }
 
 
    /**
     * Convert pmt mask.
     *
     * \return                pmt bit pattern (i.e. sequence of '0' and '1').
     */
    std::string toString() const
    {
      std::string buffer(NUMBER_OF_PMT_BITS, '0');
 
      unsigned int bit = 0;
 
      for (std::string::reverse_iterator i = buffer.rbegin(); i != buffer.rend() && bit != NUMBER_OF_PMT_BITS; ++i, ++bit) {
        if (hasPMTBit(bit)) {
          *i = '1';
        }
      }
 
      return buffer;
    }
 
 
    /**
     * Read pmt mask from input.
     *
     * \param  in         input stream
     * \param  mask       pmt mask
     * \return            input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JPMTMask& mask)
    {
      return in >> mask.pmt_mask;
    }
 
 
    /**
     * Write pmt mask to output.
     *
     * \param  out        output stream
     * \param  mask        pmt mask
     * \return            output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JPMTMask& mask)
    {
      return out << mask.pmt_mask;
    }
 
    
    /**
     * Read JPMTMask from input.
     *
     * \param  in             JReader
     * \param  mask           JPMTMask
     * \return                JReader
     */
    friend inline JReader& operator>>(JReader& in, JPMTMask& mask)
    {
      in >> mask.pmt_mask;
 
      return in;
    }
 
 
    /**
     * Write JPMTMask to output.
     *
     * \param  out           JWriter
     * \param  mask          JPMTMask
     * \return               JWriter
     */
    friend inline JWriter& operator<<(JWriter& out, const JPMTMask& mask)
    {
      out << mask.pmt_mask;
 
      return out;
    }
 
    
      virtual JReader& read(JReader & in)
    {
      in>>this->pmt_mask;
      
      return in;
      
    }
    
    
      virtual JWriter& write(JWriter& out) const
    {
      out << this->pmt_mask;
      
      return out;
    }
 
 
    /**
     * Get size of object.
     *
     * \return               number of bytes
     */
    static int sizeOf()
    {
      return sizeof(JPMTMask_t);
    }
 
    //ClassDef(JPMTMask,1);
 
  protected:
    JPMTMask_t  pmt_mask;
  };
}
 
#endif