CbmTofAddress.h

Go to the documentation of this file.

 
#ifndef CBMTOFADDRESS_H
#define CBMTOFADDRESS_H 1
 
#include "CbmAddress.h"             // for CbmAddress, CbmAddress::fgkSystem...
#include "CbmDefs.h"                // for kTof
#include "CbmTofDetectorId.h"       // for CbmTofDetectorInfo
#include "CbmTofDetectorId_v12b.h"  // for CbmTofDetectorId_v12b
#include <RtypesCore.h>             // for Int_t, UInt_t, Bool_t, kFALSE, kTRUE
 
class CbmTofAddress : public CbmAddress {
public:
  CbmTofAddress() {};
 
  virtual ~CbmTofAddress() {};
 
  static Int_t GetNofSmIdBits() { return fgkSmIdBits; };
  static Int_t GetNofSmTypeBits() { return fgkSmTypeBits; };
  static Int_t GetNofRpcIdBits() { return fgkRpcIdBits; };
  static Int_t GetNofChannelIdBits() { return fgkChannelIdBits; };
  static Int_t GetNofChSideBits() { return fgkChannelSideBits; };
 
  static Int_t GetSmId(UInt_t address) {
    return ((address >> fgkSmIdOffset) & ((1 << fgkSmIdBits) - 1));
  };
  static Int_t GetSmType(UInt_t address) {
    return ((address >> fgkSmTypeOffset) & ((1 << fgkSmTypeBits) - 1));
  };
  static Int_t GetRpcId(UInt_t address) {
    return ((address >> fgkRpcIdOffset) & ((1 << fgkRpcIdBits) - 1));
  };
  static Int_t GetChannelId(UInt_t address) {
    return ((address >> fgkChannelIdOffset) & ((1 << fgkChannelIdBits) - 1));
  };
  static Int_t GetChannelSide(UInt_t address) {
    return ((address >> fgkChannelSideOffset)
            & ((1 << fgkChannelSideBits) - 1));
  };
  static Int_t GetModFullId(UInt_t address) {
    return (address & fgkiModFullIdMask);
  };
 
  static UInt_t GetUniqueAddress(UInt_t Sm,
                                 UInt_t Rpc,
                                 UInt_t Channel,
                                 UInt_t Side   = 0,
                                 UInt_t SmType = 0) {
    return (UInt_t)(
      ((ToIntegralType(ECbmModuleId::kTof) & ((1 << fgkSystemBits) - 1)))
      + ((Sm & ((1 << fgkSmIdBits) - 1)) << fgkSmIdOffset)
      + ((SmType & ((1 << fgkSmTypeBits) - 1)) << fgkSmTypeOffset)
      + ((Side & ((1 << fgkChannelSideBits) - 1)) << fgkChannelSideOffset)
      + ((Rpc & ((1 << fgkRpcIdBits) - 1)) << fgkRpcIdOffset)
      + ((Channel & ((1 << fgkChannelIdBits) - 1)) << fgkChannelIdOffset));
  };
 
  static Bool_t SameModule(UInt_t addressA, UInt_t addressB) {
    return (GetModFullId(addressA) == GetModFullId(addressB)) ? kTRUE : kFALSE;
  };
 
  static UInt_t ConvertCbmTofDetectorInfo(CbmTofDetectorInfo infoInput) {
    // For now assume that the system ID will always be correct
    // Otherwise would need including CbmDetectorList.h
    //   if( kTof != infoInput.fDetectorSystem)
    //      return 0;
 
    return GetUniqueAddress(infoInput.fSModule,
                            infoInput.fCounter,
                            infoInput.fCell,
                            0,
                            infoInput.fSMtype);
  };
  static UInt_t ConvertCbmTofDetectorId(Int_t detIdInput) {
    // For now assume that the system ID will always be correct
    // Otherwise would need including CbmDetectorList.h
    //         if( kTof != CbmTofDetectorId::GetSystemId( detIdInput ) )
    //            return 0;
    CbmTofDetectorId_v12b detId;
    return GetUniqueAddress(detId.GetSModule(detIdInput),
                            detId.GetCounter(detIdInput),
                            detId.GetCell(detIdInput),
                            0,
                            detId.GetSMType(detIdInput));
  };
 
private:
  static const Int_t fgkSmIdBits = 8;
  static const Int_t fgkSmTypeBits = 4;
  static const Int_t fgkRpcIdBits = 7;
  static const Int_t fgkChannelSideBits = 1;
  static const Int_t fgkChannelIdBits = 8;
 
  static const Int_t fgkSmIdOffset;
  static const Int_t fgkSmTypeOffset;
  static const Int_t fgkChannelSideOffset;
  static const Int_t fgkRpcIdOffset;
  static const Int_t fgkChannelIdOffset;
 
  static const Int_t fgkiModFullIdMask;
};
 
#endif  // CBMTOFADDRESS_H