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;
      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;

};

#endif