/data/doxygen/doxygen-1.7.3/gen/CMSSW_4_2_8/src/RecoTracker/MeasurementDet/interface/TkStripMeasurementDet.h

Go to the documentation of this file.

#ifndef TkStripMeasurementDet_H
#define TkStripMeasurementDet_H

#include "TrackingTools/MeasurementDet/interface/MeasurementDet.h"
#include "RecoLocalTracker/ClusterParameterEstimator/interface/StripClusterParameterEstimator.h"
#include "DataFormats/SiStripCluster/interface/SiStripClusterCollection.h"
#include "Geometry/TrackerGeometryBuilder/interface/StripGeomDetUnit.h"
#include "DataFormats/Common/interface/DetSetVector.h"
#include "DataFormats/Common/interface/DetSetVectorNew.h"
#include "DataFormats/SiStripCluster/interface/SiStripCluster.h"
#include "DataFormats/Common/interface/Handle.h"
#include "CondFormats/SiStripObjects/interface/SiStripNoises.h"
#include "CondFormats/SiStripObjects/interface/SiStripBadStrip.h"
#include "DataFormats/Common/interface/RefGetter.h"
#include "DataFormats/TrackerRecHit2D/interface/SiStripRecHit2D.h"

#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

class TransientTrackingRecHit;

class TkStripMeasurementDet : public MeasurementDet {
public:

  typedef StripClusterParameterEstimator::LocalValues    LocalValues;
  typedef StripClusterParameterEstimator::VLocalValues    VLocalValues;

  typedef SiStripRecHit2D::ClusterRef SiStripClusterRef;

  typedef edm::LazyGetter<SiStripCluster>::value_ref  SiStripRegionalClusterRef;

  typedef edmNew::DetSet<SiStripCluster> detset;
  typedef detset::const_iterator new_const_iterator;

  typedef std::vector<SiStripCluster>::const_iterator const_iterator;

  virtual ~TkStripMeasurementDet(){}

  TkStripMeasurementDet( const GeomDet* gdet,
                         const StripClusterParameterEstimator* cpe,
                         bool regional);

  void update( const detset &detSet, 
               const edm::Handle<edmNew::DetSetVector<SiStripCluster> > h,
               unsigned int id ) { 
    detSet_ = detSet; 
    handle_ = h;
    id_ = id;
    empty = false;
    isRegional = false;
  }

  void update( std::vector<SiStripCluster>::const_iterator begin ,std::vector<SiStripCluster>::const_iterator end, 
               const edm::Handle<edm::LazyGetter<SiStripCluster> > h,
               unsigned int id ) { 
    regionalHandle_ = h;
    beginClusterI_ = begin - regionalHandle_->begin_record();
    endClusterI_ = end - regionalHandle_->begin_record();
    id_ = id;
    empty = false;
    activeThisEvent_ = true;
    isRegional = true;
  }
  
  bool isActive() const { return activeThisEvent_ && activeThisPeriod_; }
                 
  //TO BE IMPLEMENTED
  bool hasBadComponents( const TrajectoryStateOnSurface &tsos ) const {return false;}


  void setEmpty(){empty = true; activeThisEvent_ = true; }
  
  virtual RecHitContainer recHits( const TrajectoryStateOnSurface&) const;
  void simpleRecHits( const TrajectoryStateOnSurface& ts, std::vector<SiStripRecHit2D> &result) const ;

  virtual std::vector<TrajectoryMeasurement> 
  fastMeasurements( const TrajectoryStateOnSurface& stateOnThisDet, 
                    const TrajectoryStateOnSurface& startingState, 
                    const Propagator&, 
                    const MeasurementEstimator&) const;

  const StripGeomDetUnit& specificGeomDet() const {return *theStripGDU;}

  TransientTrackingRecHit::RecHitPointer
  buildRecHit( const SiStripClusterRef&, const TrajectoryStateOnSurface& ltp) const;

  TransientTrackingRecHit::RecHitPointer
  buildRecHit( const SiStripRegionalClusterRef&, const TrajectoryStateOnSurface& ltp) const;

    
  TkStripMeasurementDet::RecHitContainer 
  buildRecHits( const SiStripClusterRef&, const TrajectoryStateOnSurface& ltp) const;
  
  TkStripMeasurementDet::RecHitContainer 
  buildRecHits( const SiStripRegionalClusterRef&, const TrajectoryStateOnSurface& ltp) const;


  bool  isEmpty() {return empty;}

  unsigned int rawId() const { return id_; }


  const detset& theSet() {return detSet_;}
  int  size() const {return endClusterI_ - beginClusterI_ ; }

  void setActive(bool active) { activeThisPeriod_ = active; activeThisEvent_ = true; if (!active) empty = true; }
  void setActiveThisEvent(bool active) { activeThisEvent_ = active;  if (!active) empty = true; }

  bool hasAllGoodChannels() const { return !hasAny128StripBad_ && badStripBlocks_.empty(); }

  void set128StripStatus(bool good, int idx=-1);

  struct BadStripCuts {
     BadStripCuts() : maxBad(9999), maxConsecutiveBad(9999) {}
     BadStripCuts(const edm::ParameterSet &pset) :
        maxBad(pset.getParameter<uint32_t>("maxBad")),
        maxConsecutiveBad(pset.getParameter<uint32_t>("maxConsecutiveBad")) {}
     uint16_t maxBad, maxConsecutiveBad;
  };

  bool testStrips(float utraj, float uerr) const;

  void setBadStripCuts(BadStripCuts cuts) { badStripCuts_ = cuts; }

  struct BadStripBlock {
      short first;
      short last;
      BadStripBlock(const SiStripBadStrip::data &data) : first(data.firstStrip), last(data.firstStrip+data.range-1) { }
  };
  std::vector<BadStripBlock> &getBadStripBlocks() { return badStripBlocks_; }

  void setMaskBad128StripBlocks(bool maskThem) { maskBad128StripBlocks_ = maskThem; }

private:

  bool isRegional;

  bool empty;

  bool activeThisEvent_,activeThisPeriod_;

  unsigned int id_;

  detset detSet_;
  edm::Handle<edmNew::DetSetVector<SiStripCluster> > handle_;


  const StripGeomDetUnit*               theStripGDU;
  const StripClusterParameterEstimator* theCPE;



  bool bad128Strip_[6];
  bool hasAny128StripBad_, maskBad128StripBlocks_;

  std::vector<BadStripBlock> badStripBlocks_;  
  int totalStrips_;
  BadStripCuts badStripCuts_;
 

  // --- regional unpacking
  edm::Handle<edm::LazyGetter<SiStripCluster> > regionalHandle_;
  uint beginClusterI_;
  uint endClusterI_;

  inline bool isMasked(const SiStripCluster &cluster) const {
      if ( bad128Strip_[cluster.firstStrip() >> 7] ) {
          if ( bad128Strip_[(cluster.firstStrip()+cluster.amplitudes().size())  >> 7] ||
               bad128Strip_[static_cast<int32_t>(cluster.barycenter()-0.499999) >> 7] ) {
              return true;
          }
      } else {
          if ( bad128Strip_[(cluster.firstStrip()+cluster.amplitudes().size())  >> 7] &&
               bad128Strip_[static_cast<int32_t>(cluster.barycenter()-0.499999) >> 7] ) {
              return true;
          }
      }
      return false;
  }
  
  template<class ClusterRefT>
    void buildSimpleRecHit( const ClusterRefT& cluster,
                            const TrajectoryStateOnSurface& ltp,
                            std::vector<SiStripRecHit2D>& res) const;
  
  
  std::set<SiStripClusterRef> skipClusters_;
  std::set<SiStripRegionalClusterRef> skipRegClusters_;
  
 public:
  inline bool accept(SiStripClusterRef & r) const {
    return (skipClusters_.find(r) == skipClusters_.end());
  }
  inline bool accept(SiStripRegionalClusterRef &r) const{
    return (skipRegClusters_.find(r) == skipRegClusters_.end());
  }

  void unset(){
    skipClusters_.clear();
    skipRegClusters_.clear();
  }
  template <typename IT>
    void setClusterToSkip(IT begin, IT end){
    skipClusters_.clear();
    skipClusters_.insert(begin,end);
  }
  template <typename IT>
    void setRegionalClustersToSkip(IT begin, IT end){
    skipRegClusters_.clear();
    skipRegClusters_.insert(begin,end);
  }
  
};

#endif