CSCSegAlgoTC.h

Go to the documentation of this file.

#ifndef CSCSegment_CSCSegAlgoTC_h
#define CSCSegment_CSCSegAlgoTC_h

#include <RecoLocalMuon/CSCSegment/src/CSCSegmentAlgorithm.h>

#include <DataFormats/CSCRecHit/interface/CSCRecHit2D.h>

#include <deque>
#include <vector>


class CSCSegAlgoTC : public CSCSegmentAlgorithm {
 public:
  
  // Tim tried using map as basic container of all (space-point) RecHit's in a chamber:
  // The 'key' is a pseudo-layer number (1-6 but with 1 always closest to IP).
  // The 'value' is a vector of the RecHit's on that layer.
  // Using the layer number like this removes the need to sort in global z.
  // Instead we just have to ensure the layer index is correctly adjusted 
  // to enforce the requirement that 'layer 1' is closest in the chamber
  // to the IP.
  // However a map is very painful to use when handling the original 'SK' algorithm,
  // particularly when we need to flag a hit as 'used'. Because of this I am now
  // favouring a pair of vectors, vector<RecHit> and vector<int> for the layer id.
  
  typedef std::vector<int> LayerIndex;
  typedef std::vector<const CSCRecHit2D*> ChamberHitContainer;
  typedef ChamberHitContainer::const_iterator ChamberHitContainerCIt;
  
  // We need to be able to flag a hit as 'used' and so need a container
  // of bool's. Naively, this would be vector<bool>... but AVOID that since it's
  // non-standard i.e. packed-bit implementation which is not a standard STL container. 
  // We don't need what it offers and it could lead to unexpected trouble in the future
  
  typedef std::deque<bool> BoolContainer;
  
  explicit CSCSegAlgoTC(const edm::ParameterSet& ps);
  virtual ~CSCSegAlgoTC() {};
  
  std::vector<CSCSegment> buildSegments(const ChamberHitContainer& rechits);
  
  std::vector<CSCSegment> run(const CSCChamber* aChamber, const ChamberHitContainer& rechits);
  
 private:
  
  
  bool addHit(const CSCRecHit2D* aHit, int layer);
  bool replaceHit(const CSCRecHit2D* h, int layer);
  void compareProtoSegment(const CSCRecHit2D* h, int layer);
  void increaseProtoSegment(const CSCRecHit2D* h, int layer);
  AlgebraicSymMatrix calculateError() const;
  CLHEP::HepMatrix derivativeMatrix() const;
  AlgebraicSymMatrix weightMatrix() const;
  void flipErrors(AlgebraicSymMatrix&) const;
  
  bool areHitsCloseInLocalX(const CSCRecHit2D* h1, const CSCRecHit2D* h2) const;
  
  bool areHitsCloseInGlobalPhi(const CSCRecHit2D* h1, const CSCRecHit2D* h2) const;
  
  bool hasHitOnLayer(int layer) const;
  
  bool isHitNearSegment(const CSCRecHit2D* h) const;
  
  void dumpHits(const ChamberHitContainer& rechits) const;
  
  void tryAddingHitsToSegment(const ChamberHitContainer& rechits, 
                  const ChamberHitContainerCIt i1, 
                  const ChamberHitContainerCIt i2);
  
  bool isSegmentGood(std::vector<ChamberHitContainer>::iterator is, 
             std::vector<double>::iterator ichi,
             const ChamberHitContainer& rechitsInChamber,  
             BoolContainer& used) const;
  
  void flagHitsAsUsed(std::vector<ChamberHitContainer>::iterator is, 
              const ChamberHitContainer& rechitsInChamber, BoolContainer& used) const;
  
  void pruneTheSegments(const ChamberHitContainer& rechitsInChamber);
  void segmentSort();  
  
  float phiAtZ(float z) const;  
  void fillLocalDirection();
  void fillChiSquared();
  void fitSlopes();
  void updateParameters();
  
  // ================
  
  const CSCChamber* theChamber;
  std::vector<ChamberHitContainer> candidates;
  std::vector<LocalPoint> origins;
  std::vector<LocalVector> directions;
  std::vector<AlgebraicSymMatrix> errors;
  std::vector<double> chi2s;

  ChamberHitContainer proto_segment;
  double theChi2;
  LocalPoint theOrigin;
  LocalVector theDirection;
  float uz, vz;
  
  float chi2Max;
  
  float chi2ndfProbMin;

  float dRPhiFineMax;
  
  float dPhiFineMax;
  
  float dRPhiMax;
  
  float dPhiMax;
  
  int minLayersApart;
  
  int SegmentSorting;

  const std::string myName;
  bool debugInfo;
};

#endif