In This Package:

Hardware.h

Go to the documentation of this file.

#ifndef CONVENTIONS_HARDWARE_H
#define CONVENTIONS_HARDWARE_H 1

#include <string>
#include <ostream>

namespace DayaBay {
  
  // Define the types of hardware
  namespace Hardware {
    enum Hardware_t {
      kUnknown = 0,
      kPmt8inch,
      kPmt2inch,
      kRpc,
      kFee,
      kFec,
      kRot,
      kRom,
      kHighVoltage
    };

    // Convert type enum back and forth to string.
    const char* AsString(Hardware_t type);
    Hardware_t  FromString(const char* str);  
  }

  /* Uniquely define a piece of physical hardware by an ID number.
   *
   * Data is packed into a single integer as follows:
   * Bits: |   8   |   8   |   8   |   8   |
   * Data: | type  |        id number      |
   */
  class HardwareId {
  public:
    HardwareId() : m_data(0) {}
    // Define an ID based on packed data
    HardwareId(int data) { m_data = data; }
    // Define an ID based on the id / hardware type combination
    HardwareId(unsigned int id, Hardware::Hardware_t hardware)
      { m_data = (hardware << 24) | (0x00ffffff & id); }
    // Assignment Operator
    HardwareId& operator=(const HardwareId& id) 
      { m_data = id.m_data; return *this; }

    // Destructor
    virtual ~HardwareId();
    
    // Return the full ID as a raw packed integer.  If created by
    // subclass, this may include values in the lower three
    // bytes.
    int fullPackedData() const { return m_data; }

    // Hardware type
    Hardware::Hardware_t type() const
      { return (Hardware::Hardware_t)((m_data&0xff000000)>>24); }
    // Return the ID only
    int id() const { return (m_data & 0x00ffffff); }

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

  protected:
    unsigned int m_data;
  };

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

  // Identify a physical PMT + base assembly
  class PmtHardwareId : public HardwareId {
  public:
    PmtHardwareId() : HardwareId(0) {}
    PmtHardwareId(unsigned int id, Hardware::Hardware_t hardware) 
      : HardwareId(id, hardware) {}
    PmtHardwareId(int data) : HardwareId(data) {}    
    virtual ~PmtHardwareId() {}
    // Assignment Operator
    PmtHardwareId& operator=(const PmtHardwareId& id) 
      { m_data = id.m_data; return *this; }
    // Return the pmt ID only
    int id() const { return (m_data & 0x00ffffff); }
  };

  /* Identify a physical Rpc assembly
   *
   * Can be used to identify a full 2x2m RPC panel, as well as a
   * specific layer and strip.  The data is stored as follows:
   * Bits: |   8   |   8   |   8   |   8   |
   * Data: | type  |panelId| layer | strip |
   * Layers are indexed from 1 to 4 starting from the lowest layer of the panel
   * Strips are indexed from 1 to 8.
   * For layers with strips oriented parallel to the readout edge, the
   * numbering starts closest to the readout edge.  For layers with
   * strips oriented perpendicular to the readout edge, the numbering
   * starts at the right when looking from the direction of the
   * readout edge.
   */
  class RpcHardwareId : public HardwareId {
  public:
    RpcHardwareId() : HardwareId(0) {}
    RpcHardwareId(int panelId, int layer, int strip) : 
      HardwareId((0x000000ff & panelId)<<16 |
                 (0x000000ff & layer)<<8 |
                 (0x000000ff & strip), 
                 Hardware::kRpc) {}
    RpcHardwareId(int data) : HardwareId(data) {}
    virtual ~RpcHardwareId() {}
    // Assignment Operator
    RpcHardwareId& operator=(const RpcHardwareId& id) 
      { m_data = id.m_data; return *this; }

    // Return the panel ID only
    int panelId() const { return (m_data & 0x00ff0000) >> 16; }

    // Return the layer index only
    int layer() const { return (m_data & 0x0000ff00) >> 8; }

    // Return the strip index only
    int strip() const { return (m_data & 0x000000ff); }
  };

  /* Identify a physical Front-end electronics board
   *
   * Can be used to identify an entire FEE board, as well as a
   * specific connector on the board.  The data is stored as follows:
   * Bits: |   8   |   8   |   8   |   8       |
   * Data: | type  |       |boardId| connector |
   * Connectors are indexed from 1 to 16 starting from the top edge of the board
   */
  class FeeHardwareId : public HardwareId {
  public:
    FeeHardwareId() : HardwareId(0) {}
    FeeHardwareId(int boardId, int connector) : 
      HardwareId((0x000000ff & boardId)<<8 |
                 (0x000000ff & connector),
                 Hardware::kFee) {}
    FeeHardwareId(int data) : HardwareId(data) {}
    virtual ~FeeHardwareId() {}
    // Assignment Operator
    FeeHardwareId& operator=(const FeeHardwareId& id) 
      { m_data = id.m_data; return *this; }

    // Return the board ID only
    int boardId() const { return (m_data & 0x0000ff00) >> 8; }

    // Return the connector only
    int connector() const { return (m_data & 0x000000ff); }
  };

  /* Identify a physical RPC Front-end card
   *
   * Can be used to identify an entire FEC board, as well as a
   * specific connector on the board.  The data is stored as follows:
   * Bits: |   8   |   8   |   8   |   8       |
   * Data: | type  |       |boardId| connector |
   * Connectors are indexed from 1 to 32 starting from the left-most
   * on the board when looking at the connectors edge-on.
   */
  class FecHardwareId : public HardwareId {
  public:
    FecHardwareId() : HardwareId(0) {}
    FecHardwareId(int boardId, int connector) : 
      HardwareId((0x000000ff & boardId)<<8 |
                 (0x000000ff & connector),
                 Hardware::kFee) {}
    FecHardwareId(int data) : HardwareId(data) {}
    virtual ~FecHardwareId() {}
    // Assignment Operator
    FecHardwareId& operator=(const FecHardwareId& id) 
      { m_data = id.m_data; return *this; }

    // Return the board ID only
    int boardId() const { return (m_data & 0x0000ff00) >> 8; }

    // Return the connector only
    int connector() const { return (m_data & 0x000000ff); }
  };

  // Helper functions for printing hardware IDs
  std::ostream& operator<<(std::ostream& str, 
                           const DayaBay::HardwareId& hardwareId);
  std::ostream& operator<<(std::ostream& str, 
                           const DayaBay::PmtHardwareId& pmtHrdwId);
  std::ostream& operator<<(std::ostream& str, 
                           const DayaBay::RpcHardwareId& rpcHrdwId);
  std::ostream& operator<<(std::ostream& str, 
                           const DayaBay::FeeHardwareId& feeHrdwId);
  std::ostream& operator<<(std::ostream& str, 
                           const DayaBay::FecHardwareId& fecHrdwId);
  
}

#endif  // CONVENTIONS_HARDWARE_H

---