HitAdapter.hpp

Go to the documentation of this file.

#ifndef HIT_ADAPTER_HPP
#define HIT_ADAPTER_HPP
 
#include "BinaryUtils.hpp"
#include <Rtypes.h>


namespace SOLFlags {
const UInt_t PILEUP = 0x01;           
const UInt_t EVENT_SATURATION = 0x04; 
const UInt_t POST_SATURATION = 0x08;  
const UInt_t CHARGE_OVERFLOW = 0x10;  
const UInt_t SCA_SELECTED = 0x20;     
const UInt_t FINE_TS_VALID = 0x40;    

const UInt_t EXT_INHIBIT = 0x0001;    
const UInt_t UNDER_SAT = 0x0002;      
const UInt_t OVER_SAT = 0x0004;       
const UInt_t EXT_TRIGGER = 0x0008;    
const UInt_t GLOBAL_TRIGGER = 0x0010; 
const UInt_t SW_TRIGGER = 0x0020;     
const UInt_t SELF_TRIGGER = 0x0040;   
const UInt_t LVDS_TRIGGER = 0x0080;   
const UInt_t TRIGGER_64CH = 0x0100;   
const UInt_t ITLA_TRIGGER = 0x0200;   
const UInt_t ITLB_TRIGGER = 0x0400;   
} // namespace SOLFlags

namespace SOLPack {
const Int_t LOW_SHIFT = 16;    
const UInt_t LOW_MASK = 0x7FF; 
const Int_t HIGH_SHIFT = 27;   
const Int_t HIGH_SKIP = 2;     
const UInt_t HIGH_MASK = 0x1F; 
} // namespace SOLPack

inline UInt_t MapSOLFlagsToCoMPASS(UShort_t sol_flags_high,
                                   UShort_t sol_flags_low) {
  UInt_t mapped = 0;
 
  // SOLARIS high-priority pileup -> CoMPASS PILEUP
  if (sol_flags_high & SOLFlags::PILEUP) {
    mapped |= CoMPASSData::PILEUP;
  }
 
  // SOLARIS event saturation -> CoMPASS SATURATION_IN_GATE
  if (sol_flags_high & SOLFlags::EVENT_SATURATION) {
    mapped |= CoMPASSData::SATURATION_IN_GATE;
  }
 
  // SOLARIS post-saturation -> CoMPASS INPUT_SATURATING
  if (sol_flags_high & SOLFlags::POST_SATURATION) {
    mapped |= CoMPASSData::INPUT_SATURATING;
  }
 
  // The rest, packed per the layout above. Each word is masked to the width it
  // actually defines; the previous shifts (16 and 20) overlapped in bits 20-23,
  // so flags_high bits 4-7 and flags_low bits 0-3 were ORed on top of each
  // other and neither could be read back.
  mapped |= (static_cast<UInt_t>(sol_flags_low) & SOLPack::LOW_MASK)
            << SOLPack::LOW_SHIFT;
  mapped |= ((static_cast<UInt_t>(sol_flags_high) >> SOLPack::HIGH_SKIP) &
             SOLPack::HIGH_MASK)
            << SOLPack::HIGH_SHIFT;
 
  return mapped;
}

inline UShort_t SOLFlagsLowFrom(UInt_t mapped) {
  return UShort_t((mapped >> SOLPack::LOW_SHIFT) & SOLPack::LOW_MASK);
}

inline UShort_t SOLFlagsHighFrom(UInt_t mapped) {
  return UShort_t(((mapped >> SOLPack::HIGH_SHIFT) & SOLPack::HIGH_MASK)
                  << SOLPack::HIGH_SKIP);
}

inline RawHit SOLHitToRawHit(const SOLHit &sol) {
  RawHit raw;
  raw.board = 0;
  raw.channel = sol.channel;
  raw.energy = sol.energy;
  raw.timestamp = sol.timestamp * 1000;
  raw.flags = MapSOLFlagsToCoMPASS(sol.flags_high, sol.flags_low);
  return raw;
}

inline std::vector<RawHit>
SOLHitsToRawHits(const std::vector<SOLHit> &sol_hits) {
  std::vector<RawHit> raw_hits;
  raw_hits.reserve(sol_hits.size());
  for (Int_t i = 0; i < Int_t(sol_hits.size()); i++) {
    raw_hits.push_back(SOLHitToRawHit(sol_hits[i]));
  }
  return raw_hits;
}
 
#endif