clusterizer caches connected detid and offsets in calibrations

CalibFormats/SiStripObjects/interface/SiStripDetCabling.h

@@ -59,6 +59,8 @@ class SiStripDetCabling
   uint32_t undetectedNumber(const std::string & subDet, const uint16_t layer) const { return detNumber(subDet, layer, 2); }
   inline const SiStripFedCabling * fedCabling() const {return fedCabling_;}
 
+  std::map< uint32_t, std::vector<int> > const & connected() const { return connected_;}
+
  private:
   SiStripDetCabling(const SiStripDetCabling&); // stop default
   const SiStripDetCabling& operator=(const SiStripDetCabling&); // stop default

CalibFormats/SiStripObjects/interface/SiStripGain.h

@@ -63,7 +63,8 @@ class SiStripGain
   // getters
   // For the product of all apvGains
   // -------------------------------
-  const SiStripApvGain::Range getRange(const uint32_t& detID) const { return apvgain_->getRange(detID);} 
+  const SiStripApvGain::Range getRange(uint32_t detID) const { return apvgain_->getRange(detID);}
+  SiStripApvGain::Range getRangeByPos(unsigned short pos) const { return apvgain_->getRangeByPos(pos);}
   static float getStripGain(const uint16_t& strip, const SiStripApvGain::Range& range) { return  SiStripApvGain::getStripGain(strip, range);}
   static float getApvGain(const uint16_t& apv, const SiStripApvGain::Range& range) {  return SiStripApvGain::getApvGain(apv, range); }
 

CalibFormats/SiStripObjects/interface/SiStripQuality.h

@@ -123,6 +123,10 @@ class SiStripQuality GCC11_FINAL : public SiStripBadStrip {
   inline void setPrintDebugOutput(const bool printDebug) { printDebug_ = printDebug; }
   inline void setUseEmptyRunInfo(const bool useEmptyRunInfo) { useEmptyRunInfo_ = useEmptyRunInfo; }
 
+
+  SiStripDetCabling const * cabling() const { return SiStripDetCabling_;}
+
+
  private:
 
   void compact(std::vector<unsigned int>&,std::vector<unsigned int>&,unsigned short&);

CondFormats/SiStripObjects/interface/SiStripApvGain.h

@@ -62,7 +62,8 @@ class SiStripApvGain {
 
 
   bool put(const uint32_t& detID, Range input);
-  const Range getRange(const uint32_t& detID) const;
+  const Range getRange(const uint32_t  detID) const;
+  Range getRangeByPos(unsigned short pos) const;
   void getDetIds(std::vector<uint32_t>& DetIds_) const;
 
 

CondFormats/SiStripObjects/src/SiStripApvGain.cc

@@ -26,7 +26,7 @@ bool SiStripApvGain::put(const uint32_t& DetId, Range input) {
   return true;
 }
 
-const SiStripApvGain::Range SiStripApvGain::getRange(const uint32_t& DetId) const {
+const SiStripApvGain::Range SiStripApvGain::getRange(const uint32_t DetId) const {
   // get SiStripApvGain Range of DetId
   RegistryConstIterator p = std::lower_bound(v_detids.begin(),v_detids.end(),DetId);
   if (p==v_detids.end() || *p!=DetId) 
@@ -40,6 +40,14 @@ const SiStripApvGain::Range SiStripApvGain::getRange(const uint32_t& DetId) cons
   }
 }
 
+SiStripApvGain::Range  SiStripApvGain::getRangeByPos(unsigned short pos) const {
+    unsigned int ibegin = *(v_ibegin.begin()+pos);
+    unsigned int iend   = *(v_iend.begin()+pos);
+    __builtin_prefetch((&v_gains.front())+ibegin);
+    return SiStripApvGain::Range(v_gains.begin()+ibegin,v_gains.begin()+iend);
+}
+
+
 void SiStripApvGain::getDetIds(std::vector<uint32_t>& DetIds_) const {
   // returns vector of DetIds in map
   //  DetIds_=v_detids;

RecoLocalTracker/SiStripClusterizer/interface/StripClusterizerAlgorithm.h

@@ -11,7 +11,7 @@ class SiStripDigi;
 #include "CondFormats/SiStripObjects/interface/SiStripNoises.h"
 #include "CalibFormats/SiStripObjects/interface/SiStripQuality.h"
 #include "EventFilter/SiStripRawToDigi/interface/SiStripFEDBuffer.h"
-
+#include <limits>
 
 class StripClusterizerAlgorithm {
 
@@ -40,7 +40,7 @@ class StripClusterizerAlgorithm {
   StripClusterizerAlgorithm() : qualityLabel(""), noise_cache_id(0), gain_cache_id(0), quality_cache_id(0) {}
 
   uint32_t currentId() {return detId;}
-  virtual void setDetId(const uint32_t);
+  bool setDetId(const uint32_t);
   float noise(const uint16_t& strip) const { return SiStripNoises::getNoise( strip, noiseRange ); }
   float gain(const uint16_t& strip)  const { return SiStripGain::getStripGain( strip, gainRange ); }
   bool bad(const uint16_t& strip)    const { return qualityHandle->IsStripBad( qualityRange, strip ); }
@@ -60,15 +60,23 @@ class StripClusterizerAlgorithm {
     }	
   }
 
-  std::vector<uint32_t> detIds;
+  static constexpr unsigned short invalidI = std::numeric_limits<unsigned short>::max();
+  struct Index { 
+    unsigned short 
+    gi=invalidI,
+      ni=invalidI,
+      qi=invalidI;
+  };
+  std::vector<uint32_t> detIds; // from cabling (connected)
+  std::vector<Index> indices;
   SiStripApvGain::Range gainRange;
   SiStripNoises::Range  noiseRange;
   SiStripQuality::Range qualityRange;
   edm::ESHandle<SiStripGain> gainHandle;
   edm::ESHandle<SiStripNoises> noiseHandle;
   edm::ESHandle<SiStripQuality> qualityHandle;
-  uint32_t noise_cache_id, gain_cache_id, quality_cache_id, detId;
-
+  uint32_t noise_cache_id, gain_cache_id, quality_cache_id, detId=0;
+  unsigned short ind=0;
 
 };
 #endif

RecoLocalTracker/SiStripClusterizer/src/StripClusterizerAlgorithm.cc

@@ -6,39 +6,123 @@
 #include "CalibTracker/Records/interface/SiStripQualityRcd.h"
 #include "DataFormats/SiStripDigi/interface/SiStripDigi.h"
 #include "DataFormats/SiStripCluster/interface/SiStripCluster.h"
+#include "CalibFormats/SiStripObjects/interface/SiStripDetCabling.h"
+
 #include <string>
+#include <algorithm>
+#include <cassert>
 
 void StripClusterizerAlgorithm::
 initialize(const edm::EventSetup& es) {
   uint32_t n_cache_id = es.get<SiStripNoisesRcd>().cacheIdentifier();
   uint32_t g_cache_id = es.get<SiStripGainRcd>().cacheIdentifier();
   uint32_t q_cache_id = es.get<SiStripQualityRcd>().cacheIdentifier();
 
+  bool mod=false;
   if(g_cache_id != gain_cache_id) {
     es.get<SiStripGainRcd>().get( gainHandle );
     gain_cache_id = g_cache_id;
-    if (detIds.empty()) gainHandle->getDetIds(detIds);
-    std::vector<uint32_t> dum; gainHandle->getDetIds(dum); assert(detIds==dum);
+    mod=true;
   }
   if(n_cache_id != noise_cache_id) {
     es.get<SiStripNoisesRcd>().get( noiseHandle );
     noise_cache_id = n_cache_id;
-    std::vector<uint32_t> dum; noiseHandle->getDetIds(dum); assert(detIds==dum);
+    mod=true;
   }
   if(q_cache_id != quality_cache_id) {
     es.get<SiStripQualityRcd>().get( qualityLabel, qualityHandle );
     quality_cache_id = q_cache_id;
-    std::vector<uint32_t> dum; qualityHandle->getDetIds(dum); assert(detIds==dum);
+    mod=true;
+  }
+  if (mod) { 
+    // redo indexing!
+    SiStripDetCabling const * cabling = qualityHandle->cabling();
+    auto const & conn = cabling->connected();
+    assert(cabling); std::cout << "cabling " << conn.size() << std::endl;
+    detIds.reserve(conn.size());
+    for (auto const & c : conn) detIds.push_back(c.first);
+    indices.resize(detIds.size());
+
+    { // quality
+      std::vector<uint32_t> dum; qualityHandle->getDetIds(dum); 
+      assert(dum.size()<invalidI);
+      unsigned short j=0, i=0;
+      while (i<dum.size() && j<detIds.size()) {
+	if (dum[i]<detIds[j]) ++i;
+	else if (detIds[j]<dum[i]) {indices[j].qi=invalidI; ++j;}
+	else {
+	  indices[j].qi=i; ++i; ++j;
+	}
+      }
+      unsigned int  nn=0;
+      for(auto k=0U; k<detIds.size();++k) { if (indices[k].qi<invalidI) {++nn; assert(dum[indices[k].qi]==detIds[k]);}}
+      assert(nn<=dum.size());
+      std::cout << "quality " << dum.size() << " " <<nn<< std::endl;
+    }
+    { //noise
+      std::vector<uint32_t> dum; noiseHandle->getDetIds(dum); 
+      assert(dum.size()<invalidI);
+      unsigned short j=0, i=0;
+      while (i<dum.size() && j<detIds.size()) {
+	if (dum[i]<detIds[j]) ++i;
+	else if (detIds[j]<dum[i]) {indices[j].ni=invalidI; ++j;}
+	else {
+	  indices[j].ni=i; ++i; ++j;
+	}
+      }
+      unsigned int  nn=0;
+      for(auto k=0U; k<detIds.size();++k) { if (indices[k].ni<invalidI) {++nn; assert(dum[indices[k].ni]==detIds[k]);}}
+      assert(nn<=dum.size());
+      std::cout << "noise " << dum.size() << " " <<nn<< std::endl;
+    }
+    { //gain
+      std::vector<uint32_t> dum; gainHandle->getDetIds(dum); 
+      assert(dum.size()<invalidI);
+      unsigned short j=0, i=0;
+      while (i<dum.size() && j<detIds.size()) {
+	if (dum[i]<detIds[j]) ++i;
+	else if (detIds[j]<dum[i]) {indices[j].gi=invalidI; ++j;}
+	else {
+	  indices[j].gi=i; ++i; ++j;
+	}
+      }
+      unsigned int  nn=0;
+      for(auto k=0U; k<detIds.size();++k) { if (indices[k].gi<invalidI) {++nn; assert(dum[indices[k].gi]==detIds[k]);}}
+      assert(nn<=dum.size());
+      std::cout << "gain " << dum.size() << " " <<nn<< std::endl;
+    }
+
+
   }
+
 }
 
 
-void StripClusterizerAlgorithm::
+bool StripClusterizerAlgorithm::
 setDetId(const uint32_t id) {
-  gainRange =  gainHandle->getRange(id); 
+  if (id==detId) return true; // rare....
+  auto b = detIds.begin();
+  auto e = detIds.end();
+  if (id>detId) b+=ind;
+  else e=b+ind;
+  auto p = std::lower_bound(b,e,id);
+  if (p==e || id!=(*p)) {
+    std::cout << "id " << id << " not connected. impossible at HLT" << std::endl;
+    std::cout << "old id " << detId << std::endl;
+    return false;
+  }
+  detId = id;
+  ind = p-detIds.begin();
+  assert(detIds[ind]==detId); 
+
+  gainRange = gainHandle->getRangeByPos(indices[ind].gi);
+  auto old =  gainHandle->getRange(id);
+  assert(old==gainRange);
+
   noiseRange = noiseHandle->getRange(id);
   qualityRange = qualityHandle->getRange(id);
   detId = id;
+  return true;
 }
 
 void StripClusterizerAlgorithm::clusterize(const   edm::DetSetVector<SiStripDigi>& input,  output_t& output) {clusterize_(input, output);}