CSCSegAlgoSK.h

Go to the documentation of this file.

#ifndef CSCSegment_CSCSegAlgoSK_h
#define CSCSegment_CSCSegAlgoSK_h

#include <RecoLocalMuon/CSCSegment/src/CSCSegmentAlgorithm.h>
#include <DataFormats/CSCRecHit/interface/CSCRecHit2D.h>

//#include <DataFormats/GeometryVector/interface/GlobalPoint.h>

#include <deque>
#include <vector>

class CSCSegAlgoSK : 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.
    
    
    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::deque<bool> BoolContainer;
    
    explicit CSCSegAlgoSK(const edm::ParameterSet& ps);
    virtual ~CSCSegAlgoSK() {};

    std::vector<CSCSegment> buildSegments(const ChamberHitContainer& rechits);

    std::vector<CSCSegment> run(const CSCChamber* aChamber, const ChamberHitContainer& rechits); 

private:

    // Could be static at the moment, but in principle one
    // might like CSCSegmentizer-specific behaviour?
    bool areHitsCloseInLocalX(const CSCRecHit2D* h1, const CSCRecHit2D* h2) const;
    bool areHitsCloseInGlobalPhi(const CSCRecHit2D* h1, const CSCRecHit2D* h2) const;
    bool isHitNearSegment(const CSCRecHit2D* h) const;

    void dumpHits(const ChamberHitContainer& rechits) const;

    void tryAddingHitsToSegment(const ChamberHitContainer& rechitsInChamber,
        const BoolContainer& used, const LayerIndex& layerIndex,
        const ChamberHitContainerCIt i1, const ChamberHitContainerCIt i2);

    bool isSegmentGood(const ChamberHitContainer& rechitsInChamber) const;

    void flagHitsAsUsed(const ChamberHitContainer& rechitsInChamber, BoolContainer& used) const;
    
    bool addHit(const CSCRecHit2D* hit, int layer);
    void updateParameters(void);
    void fitSlopes(void);
    void fillChiSquared(void);
    void fillLocalDirection(void);
    float phiAtZ(float z) const;
    bool hasHitOnLayer(int layer) const;
    bool replaceHit(const CSCRecHit2D* h, int layer);
    void compareProtoSegment(const CSCRecHit2D* h, int layer);
    void increaseProtoSegment(const CSCRecHit2D* h, int layer);
    CLHEP::HepMatrix derivativeMatrix(void) const;
    AlgebraicSymMatrix weightMatrix(void) const;
    AlgebraicSymMatrix calculateError(void) const;
    void flipErrors(AlgebraicSymMatrix&) const;
        
    // Member variables
    // ================

    const CSCChamber* theChamber;
    ChamberHitContainer proto_segment;
    const std::string myName; 
        
    double theChi2;
    LocalPoint theOrigin;
    LocalVector theDirection;
    float uz, vz;
    float windowScale;
    float dRPhiMax ;
    float dPhiMax;
    float dRPhiFineMax;
    float dPhiFineMax;
    float chi2Max;
    float wideSeg;
    int minLayersApart;
    bool debugInfo;
};

#endif