rootio_HitPattern.cc

Go to the documentation of this file.

#include "DataFormats/TrackReco/interface/HitPattern.h"

/* This file contains the function used to read back v12 versions of HitPatterns from a ROOT file.
   The function is called by a ROOT IO rule.
 */

using namespace reco;

namespace {
  constexpr unsigned short HitSize = 11;
  constexpr unsigned short PatternSize = 50;
  constexpr int MaxHitsV12 = (PatternSize * sizeof(uint16_t) * 8) / HitSize;
  
  auto getHitFromOldHitPattern(const uint16_t hitPattern[], const int position) {
    const uint16_t bitEndOffset = (position + 1) * HitSize;
    const uint8_t secondWord   = (bitEndOffset >> 4);
    const uint8_t secondWordBits = bitEndOffset & (16 - 1); // that is, bitEndOffset % 32
    if (secondWordBits >= HitSize) {
      // full block is in this word
     const  uint8_t lowBitsToTrash = secondWordBits - HitSize;
      return (hitPattern[secondWord] >> lowBitsToTrash) & ((1 << HitSize) - 1);
    }
    const uint8_t  firstWordBits   = HitSize - secondWordBits;
    const uint16_t firstWordBlock  = hitPattern[secondWord - 1] >> (16 - firstWordBits);
    const uint16_t secondWordBlock = hitPattern[secondWord] & ((1 << secondWordBits) - 1);
    return firstWordBlock + (secondWordBlock << firstWordBits);
  }

  auto hitTypeFromOldHitPattern(const uint16_t pattern) {
    // for this version we just have to add a 0 bit to the top of the pattern
    constexpr unsigned short HitTypeMask = 0x3;
    constexpr unsigned short HitTypeOffset = 0;                
    
    constexpr uint16_t VALID_CONST = (uint16_t) TrackingRecHit::valid;
    constexpr uint16_t MISSING_CONST = (uint16_t) TrackingRecHit::missing;
    constexpr uint16_t INACTIVE_CONST = (uint16_t) TrackingRecHit::inactive;
    constexpr  uint16_t BAD_CONST = (uint16_t) TrackingRecHit::bad;
    
    const uint16_t rawHitType = (pattern >> HitTypeOffset) & HitTypeMask;                
    
    TrackingRecHit::Type hitType = TrackingRecHit::valid;
    switch (rawHitType) {
    case VALID_CONST:
      hitType = TrackingRecHit::valid;
      break;
    case MISSING_CONST:
      hitType = TrackingRecHit::missing;
      break;
    case INACTIVE_CONST:
      hitType = TrackingRecHit::inactive;
      break;
    case BAD_CONST:
      hitType = TrackingRecHit::bad;
      break;
    }
    return hitType;
  };
}

bool 
reco::HitPattern::fillNewHitPatternWithOldHitPattern_v12(const uint16_t oldHitPattern[], 
                                                         uint8_t hitCount,
                                                         uint8_t beginTrackHits, uint8_t endTrackHits,
                                                         uint8_t beginInner, uint8_t endInner,
                                                         uint8_t beginOuter, uint8_t endOuter,
                                                         HitPattern* newObj) {
  newObj->clear();
  bool ret = true;
  for (int i = 0; i < MaxHitsV12; i++) {
    uint16_t pattern = getHitFromOldHitPattern(oldHitPattern, i);
    if (pattern == 0) {
      break;
    }
    if(! newObj->appendHit(pattern, hitTypeFromOldHitPattern(pattern)) ) {
      ret = false;
      break;
    }
  }
  newObj->hitCount = hitCount;
  newObj->beginTrackHits =beginTrackHits;
  newObj->endTrackHits = endTrackHits;
  newObj->beginInner = beginInner;
  newObj->endInner = endInner;
  newObj->beginOuter = beginOuter;
  newObj->endOuter = endOuter;
  return ret;
}