StripClusterizerAlgorithm.h

Go to the documentation of this file.

#ifndef RecoLocalTracker_StripClusterizerAlgorithm_h
#define RecoLocalTracker_StripClusterizerAlgorithm_h

namespace edm{class EventSetup;}
class SiStripDigi;
#include "DataFormats/SiStripCluster/interface/SiStripCluster.h"
#include "DataFormats/Common/interface/DetSetVector.h"
#include "DataFormats/Common/interface/DetSetVectorNew.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "CalibFormats/SiStripObjects/interface/SiStripGain.h"
#include "CondFormats/SiStripObjects/interface/SiStripNoises.h"
#include "CalibFormats/SiStripObjects/interface/SiStripQuality.h"
#include "EventFilter/SiStripRawToDigi/interface/SiStripFEDBuffer.h"
#include <limits>


class FedChannelConnection;

class StripClusterizerAlgorithm {
  
 public:
  static constexpr unsigned short invalidI = std::numeric_limits<unsigned short>::max();
  
  // state of detID
  struct Det {
    bool valid() const { return ind!=invalidI; }
    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 quality->IsStripBad( qualityRange, strip ); }
    bool allBadBetween(uint16_t L, const uint16_t& R) const { while( ++L < R  &&  bad(L)) {}; return L == R; }
    SiStripQuality const * quality;
    SiStripApvGain::Range gainRange;
    SiStripNoises::Range  noiseRange;
    SiStripQuality::Range qualityRange;
    uint32_t detId=0;
    unsigned short ind=invalidI;
  };
  
  //state of the candidate cluster
  struct State {
    State(Det const & idet) : m_det(idet) { ADCs.reserve(128);}
    Det const & det() const { return m_det;}
    std::vector<uint8_t> ADCs;  
    uint16_t lastStrip=0;
    float noiseSquared=0;
    bool candidateLacksSeed=true;
  private:
    Det const & m_det;
  };
  
  
  virtual ~StripClusterizerAlgorithm() {}
  virtual void initialize(const edm::EventSetup&);


  //Offline DetSet interface
  typedef edmNew::DetSetVector<SiStripCluster> output_t;
  void clusterize(const    edm::DetSetVector<SiStripDigi> &, output_t &) const;
  void clusterize(const edmNew::DetSetVector<SiStripDigi> &, output_t &) const;
  virtual void clusterizeDetUnit(const    edm::DetSet<SiStripDigi> &, output_t::TSFastFiller &) const = 0;
  virtual void clusterizeDetUnit(const edmNew::DetSet<SiStripDigi> &, output_t::TSFastFiller &) const = 0;

  //HLT stripByStrip interface
  virtual Det stripByStripBegin(uint32_t id)const  = 0;

  virtual void addFed(Det const & det, sistrip::FEDZSChannelUnpacker & unpacker, uint16_t ipair, std::vector<SiStripCluster>& out)  const {}
  virtual void stripByStripAdd(State & state, uint16_t strip, uint8_t adc, std::vector<SiStripCluster>& out)  const{}
  virtual void stripByStripEnd(State & state, std::vector<SiStripCluster>& out)  const {}

  virtual void addFed(State & state, sistrip::FEDZSChannelUnpacker & unpacker, uint16_t ipair, output_t::TSFastFiller & out)  const {}
  virtual void stripByStripAdd(State & state, uint16_t strip, uint8_t adc, output_t::TSFastFiller & out)  const {}
  virtual void stripByStripEnd(State & state, output_t::TSFastFiller & out)  const {}


  struct InvalidChargeException : public cms::Exception { public: InvalidChargeException(const SiStripDigi&); };


  SiStripDetCabling const * cabling() const { return theCabling;} 
  std::vector<uint32_t> const & allDetIds() const { return detIds;}

  std::vector<const FedChannelConnection *> const & currentConnection(const Det& det) const { return connections[det.ind]; }

 protected:

  StripClusterizerAlgorithm() : qualityLabel(""), noise_cache_id(0), gain_cache_id(0), quality_cache_id(0) {}

  Det findDetId(const uint32_t) const;
  bool isModuleBad(const uint32_t& id)  const { return qualityHandle->IsModuleBad( id ); }
  bool isModuleUsable(const uint32_t& id)  const { return qualityHandle->IsModuleUsable( id ); }

  std::string qualityLabel;

 private:

  template<class T> void clusterize_(const T& input, output_t& output) const {
    for(typename T::const_iterator it = input.begin(); it!=input.end(); it++) {
      output_t::TSFastFiller ff(output, it->detId());   
      clusterizeDetUnit(*it, ff);   
      if(ff.empty()) ff.abort();    
    }   
  }

  struct Index { 
    unsigned short 
    gi=invalidI,
      ni=invalidI,
      qi=invalidI;
  };
  std::vector<uint32_t> detIds; // from cabling (connected and not bad)
  std::vector<std::vector<const FedChannelConnection *> > connections;
  std::vector<Index> indices;
  edm::ESHandle<SiStripGain> gainHandle;
  edm::ESHandle<SiStripNoises> noiseHandle;
  edm::ESHandle<SiStripQuality> qualityHandle;
  SiStripDetCabling const * theCabling = nullptr;
  uint32_t noise_cache_id, gain_cache_id, quality_cache_id;
    

};
#endif