RPCSeedPattern.h

Go to the documentation of this file.

#ifndef MRecoMuon_MuonSeedGenerator_RPCSeedPattern_H
#define MRecoMuon_MuonSeedGenerator_RPCSeedPattern_H

#include "FWCore/Framework/interface/EventSetup.h"
#include <DataFormats/TrajectorySeed/interface/TrajectorySeed.h>
#include <RecoMuon/TransientTrackingRecHit/interface/MuonTransientTrackingRecHit.h>
#include <MagneticField/Engine/interface/MagneticField.h>
#include <FWCore/Framework/interface/ESHandle.h>
#include <FWCore/ParameterSet/interface/ParameterSet.h>
#include <TrackingTools/TrajectoryParametrization/interface/LocalTrajectoryError.h>
#include <vector>

#ifndef upper_limit_pt
#define upper_limit_pt 100
#endif

#ifndef lower_limit_pt
#define lower_limit_pt 3.0
#endif


class RPCSeedPattern {

    typedef MuonTransientTrackingRecHit::MuonRecHitPointer MuonRecHitPointer;
    typedef MuonTransientTrackingRecHit::ConstMuonRecHitPointer ConstMuonRecHitPointer;
    typedef MuonTransientTrackingRecHit::MuonRecHitContainer MuonRecHitContainer;
    typedef MuonTransientTrackingRecHit::ConstMuonRecHitContainer ConstMuonRecHitContainer;

    public:
    typedef std::pair<ConstMuonRecHitPointer, ConstMuonRecHitPointer> RPCSegment;
    typedef std::pair<TrajectorySeed, double> weightedTrajectorySeed;

    public:
    RPCSeedPattern(); 
    ~RPCSeedPattern();
    void configure(const edm::ParameterSet& iConfig);
    void clear() { theRecHits.clear(); }
    void add(const ConstMuonRecHitPointer& hit) { theRecHits.push_back(hit); }   
    unsigned int nrhit() const { return theRecHits.size(); }

    private:
    friend class RPCSeedFinder;
    weightedTrajectorySeed seed(const edm::EventSetup& eSetup, int& isGoodSeed); 
    void ThreePointsAlgorithm();
    void MiddlePointsAlgorithm();
    void SegmentAlgorithm();
    void SegmentAlgorithmSpecial(const edm::EventSetup& eSetup);
    bool checkSegment() const;
    ConstMuonRecHitPointer FirstRecHit() const; 
    ConstMuonRecHitPointer BestRefRecHit() const;
    LocalTrajectoryError getSpecialAlgorithmErrorMatrix(const ConstMuonRecHitPointer& first, const ConstMuonRecHitPointer& best);
    weightedTrajectorySeed createFakeSeed(int& isGoodSeed, const edm::EventSetup& eSetup);
    weightedTrajectorySeed createSeed(int& isGoodSeed, const edm::EventSetup& eSetup);
    double getDistance(const ConstMuonRecHitPointer& precHit, const GlobalVector& Center) const;
    bool checkStraightwithThreerecHits(ConstMuonRecHitPointer (&precHit)[3], double MinDeltaPhi) const;
    GlobalVector computePtwithThreerecHits(double& pt, double& pt_err, ConstMuonRecHitPointer (&precHit)[3]) const;
    bool checkStraightwithSegment(const RPCSegment& Segment1, const RPCSegment& Segment2, double MinDeltaPhi) const;
    GlobalVector computePtwithSegment(const RPCSegment& Segment1, const RPCSegment& Segment2) const;
    bool checkStraightwithThreerecHits(double (&x)[3], double (&y)[3], double MinDeltaPhi) const;
    GlobalVector computePtWithThreerecHits(double& pt, double& pt_err, double (&x)[3], double (&y)[3]) const;

    void checkSimplePattern(const edm::EventSetup& eSetup);
    void checkSegmentAlgorithmSpecial(const edm::EventSetup& eSetup);
    double extropolateStep(const GlobalPoint& startPosition, const GlobalVector& startMomentum, ConstMuonRecHitContainer::const_iterator iter, const int ClockwiseDirection, double& tracklength, const edm::EventSetup& eSetup);
    
    //void computeBestPt(double* pt, double* spt, double& ptmean0, double& sptmean0, unsigned int NumberofPt) const;

    // ----------member data ---------------------------

    // parameters for configuration
    double MaxRSD;
    double deltaRThreshold;
    unsigned int AlgorithmType;
    bool autoAlgorithmChoose;
    double ZError;
    double MinDeltaPhi;
    double stepLength;
    unsigned int sampleCount;
    // Signals for run seed()
    bool isConfigured;
    // recHits of a pattern
    ConstMuonRecHitContainer theRecHits;
    // Complex pattern
    double MagnecticFieldThreshold;
    GlobalVector meanMagneticField2;
    bool isStraight2;
    GlobalVector Center2;
    double meanRadius2;
    RPCSegment SegmentRB[2];
    GlobalPoint entryPosition;
    GlobalPoint leavePosition;
    double lastPhi;
    double S;
    // Simple pattern
    bool isStraight;
    GlobalVector Center;
    double meanRadius;
    double meanBz;
    double deltaBz;
    // Pattern estimation part
    bool isPatternChecked;
    int isGoodPattern;
    int isClockwise;
    int isParralZ;
    int Charge;
    double meanPt;
    double meanSpt;
    GlobalVector Momentum;
};

#endif