CSCSegAlgoRU.h

Go to the documentation of this file.

#ifndef CSCSegment_CSCSegAlgoRU_h
#define CSCSegment_CSCSegAlgoRU_h
 
#include <RecoLocalMuon/CSCSegment/src/CSCSegmentAlgorithm.h>
#include <DataFormats/CSCRecHit/interface/CSCRecHit2D.h>
#include "CSCSegFit.h"
 
#include <Math/Functions.h>
#include <Math/SVector.h>
#include <Math/SMatrix.h>
 
#include <vector>
 
class CSCSegFit;
 
class CSCSegAlgoRU : 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.
 
 
  // 4-dim vector
  typedef ROOT::Math::SVector<double, 6> SVector6;
 
  typedef std::vector<int> LayerIndex;
  typedef std::vector<const CSCRecHit2D*> ChamberHitContainer;
  typedef std::vector<const CSCRecHit2D*>::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::vector<bool> BoolContainer;
 
  explicit CSCSegAlgoRU(const edm::ParameterSet& ps);
  ~CSCSegAlgoRU() override{};
 
  std::vector<CSCSegment> buildSegments(const CSCChamber* aChamber, const ChamberHitContainer& rechits) const;
 
  //    std::vector<CSCSegment> assambleRechitsInSegments(const ChamberHitContainer& rechits, int iadd, BoolContainer& used, BoolContainer& used3p, int *recHits_per_layer, const LayerIndex& layerIndex, std::vector<CSCSegment> segments);
 
  std::vector<CSCSegment> run(const CSCChamber* aChamber, const ChamberHitContainer& rechits) override {
    return buildSegments(aChamber, rechits);
  }
 
private:
  struct AlgoState {
    const CSCChamber* aChamber = nullptr;
    float windowScale = 0;
    int strip_iadd = 0;
    int chi2D_iadd = 0;
    std::unique_ptr<CSCSegFit> sfit = nullptr;
    ChamberHitContainer proto_segment;
 
    //adjustable configuration
    bool doCollisions;
    bool enlarge;
    float dRMax;
    float dPhiMax;
    float dRIntMax;
    float dPhiIntMax;
    float chi2Max;
    float chi2_str_;
    float chi2Norm_2D_;
  };
  // Could be static at the moment, but in principle one
  // might like CSCSegmentizer-specific behaviour?
  bool areHitsCloseInR(const AlgoState& aState, const CSCRecHit2D* h1, const CSCRecHit2D* h2) const;
  bool areHitsCloseInGlobalPhi(const AlgoState& aState, const CSCRecHit2D* h1, const CSCRecHit2D* h2) const;
  bool isHitNearSegment(const AlgoState& aState, const CSCRecHit2D* h) const;
 
  void tryAddingHitsToSegment(AlgoState& aState,
                              const ChamberHitContainer& rechitsInChamber,
                              const BoolContainer& used,
                              const LayerIndex& layerIndex,
                              const ChamberHitContainerCIt i1,
                              const ChamberHitContainerCIt i2) const;
 
  bool isSegmentGood(const AlgoState& aState, const ChamberHitContainer& rechitsInChamber) const;
 
  void flagHitsAsUsed(const AlgoState& aState, const ChamberHitContainer& rechitsInChamber, BoolContainer& used) const;
 
  bool addHit(AlgoState& aState, const CSCRecHit2D* hit, int layer) const;
  void updateParameters(AlgoState& aState) const;
  float fit_r_phi(const AlgoState& aState, const SVector6& points, int layer) const;
  float fitX(const AlgoState& aState, SVector6 points, SVector6 errors, int ir, int ir2, float& chi2_str) const;
  void baseline(AlgoState& aState, int n_seg_min) const;  //function for arasing bad hits in case of bad chi2/NDOF
  float phiAtZ(const AlgoState& aState, float z) const;
  bool hasHitOnLayer(const AlgoState& aState, int layer) const;
  bool replaceHit(AlgoState& aState, const CSCRecHit2D* h, int layer) const;
  void compareProtoSegment(AlgoState& aState, const CSCRecHit2D* h, int layer) const;
  void increaseProtoSegment(AlgoState& aState, const CSCRecHit2D* h, int layer, int chi2_factor) const;
 
  // Member variables
  // ================
 
  const std::string myName;
 
  double theChi2;
  LocalPoint theOrigin;
  LocalVector theDirection;
  float uz, vz;
  bool doCollisions;
  float dRMax;
  float dPhiMax;
  float dRIntMax;
  float dPhiIntMax;
  float chi2Max;
  float chi2_str_;
  float chi2Norm_2D_;
  float wideSeg;
  int minLayersApart;
  bool debugInfo;
  bool enlarge;
};
 
#endif