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 its width:
  // the old shifts (16, 20) overlapped in bits 20-23, making flags unreadable.
  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 RawHit SOLHitToRawHit(const SOLData &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;
}
 
#endif