MuonShowerInformationFiller.h

Go to the documentation of this file.

#ifndef MuonIdentification_MuonShowerInformationFiller_h
#define MuonIdentification_MuonShowerInformationFiller_h

#include <vector>

#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "DataFormats/Common/interface/ValueMap.h"

#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/Math/interface/deltaPhi.h"
#include "DataFormats/Math/interface/deltaR.h"
#include "DataFormats/CSCRecHit/interface/CSCRecHit2DCollection.h"
#include "DataFormats/DTRecHit/interface/DTRecHitCollection.h"
#include "DataFormats/DTRecHit/interface/DTRecSegment4DCollection.h"
#include "DataFormats/CSCRecHit/interface/CSCSegmentCollection.h"
#include "RecoMuon/TransientTrackingRecHit/interface/MuonTransientTrackingRecHit.h"
#include "DataFormats/MuonReco/interface/MuonFwd.h"
#include "DataFormats/MuonReco/interface/Muon.h"
#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"

#include "Geometry/DTGeometry/interface/DTGeometry.h"
#include "Geometry/CSCGeometry/interface/CSCGeometry.h"

#include "DataFormats/MuonReco/interface/MuonShower.h"

#include "FWCore/Framework/interface/ConsumesCollector.h"

namespace edm {class ParameterSet; class Event; class EventSetup;}
namespace reco {class TransientTrack; class MuonShower;}

class MuonServiceProxy;
class Trajectory;
class Cylinder;
class Disk;
class BarrelDetLayer;
class ForwardDetLayer;
class TransientTrackingRecHitBuilder;
class GeometricSearchTracker;
class GlobalTrackingGeometry;
class MuonDetLayerGeometry;


class MuonShowerInformationFiller {

  public:

    typedef TransientTrackingRecHit::ConstRecHitContainer ConstRecHitContainer;
    typedef MuonTransientTrackingRecHit::MuonRecHitContainer MuonRecHitContainer;
    typedef MuonTransientTrackingRecHit::ConstMuonRecHitPointer ConstMuonRecHitPointer;
    
  public:

    MuonShowerInformationFiller() {};
    MuonShowerInformationFiller(const edm::ParameterSet&,edm::ConsumesCollector&);

    virtual ~MuonShowerInformationFiller();
   
    reco::MuonShower fillShowerInformation( const reco::Muon& muon, const edm::Event&, const edm::EventSetup&);

    virtual void setEvent(const edm::Event&);

    void setServices(const edm::EventSetup&);

    //set the data members
    void fillHitsByStation(const reco::Muon&);

  protected:

    const MuonServiceProxy* getService() const { return theService; }

  private:

    std::vector<float> theStationShowerDeltaR;
    std::vector<float> theStationShowerTSize;
    std::vector<int>   theAllStationHits;
    std::vector<int>   theCorrelatedStationHits;

    MuonServiceProxy* theService;

    GlobalPoint crossingPoint(const GlobalPoint&, const GlobalPoint&, const BarrelDetLayer* ) const;
    GlobalPoint crossingPoint(const GlobalPoint&, const GlobalPoint&, const Cylinder& ) const;
    GlobalPoint crossingPoint(const GlobalPoint&, const GlobalPoint&, const ForwardDetLayer* ) const;
    GlobalPoint crossingPoint(const GlobalPoint&, const GlobalPoint&, const Disk& ) const;
    std::vector<const GeomDet*> dtPositionToDets(const GlobalPoint&) const;
    std::vector<const GeomDet*> cscPositionToDets(const GlobalPoint&) const;
    MuonRecHitContainer findPerpCluster(MuonRecHitContainer& muonRecHits) const;
    TransientTrackingRecHit::ConstRecHitContainer findThetaCluster(TransientTrackingRecHit::ConstRecHitContainer&, const GlobalPoint&) const;
    TransientTrackingRecHit::ConstRecHitContainer hitsFromSegments(const GeomDet*,edm::Handle<DTRecSegment4DCollection>, edm::Handle<CSCSegmentCollection>) const;
    std::vector<const GeomDet*> getCompatibleDets(const reco::Track&) const;

   struct LessMag {
       LessMag(const GlobalPoint& point) : thePoint(point) {}
       bool operator()(const GlobalPoint& lhs,
                       const GlobalPoint& rhs) const{ 
            return (lhs - thePoint).mag() < (rhs -thePoint).mag();
        }
        bool operator()(const MuonTransientTrackingRecHit::MuonRecHitPointer& lhs,
                       const MuonTransientTrackingRecHit::MuonRecHitPointer& rhs) const{
           return (lhs->globalPosition() - thePoint).mag() < (rhs->globalPosition() -thePoint).mag();
        }
      GlobalPoint thePoint;
   };

   struct LessDPhi {
        LessDPhi(const GlobalPoint& point) : thePoint(point) {}
        bool operator()(const MuonTransientTrackingRecHit::MuonRecHitPointer& lhs,
                       const MuonTransientTrackingRecHit::MuonRecHitPointer& rhs) const{
           return deltaPhi(lhs->globalPosition().barePhi(), thePoint.barePhi()) < deltaPhi(rhs->globalPosition().barePhi(), thePoint.barePhi());
        }
      GlobalPoint thePoint;
    };

    struct AbsLessDPhi {
        AbsLessDPhi(const GlobalPoint& point) : thePoint(point) {}
        bool operator()(const MuonTransientTrackingRecHit::MuonRecHitPointer& lhs,
                       const MuonTransientTrackingRecHit::MuonRecHitPointer& rhs) const{
           return ( fabs(deltaPhi(lhs->globalPosition().barePhi(), thePoint.barePhi())) < fabs(deltaPhi(rhs->globalPosition().barePhi(), thePoint.barePhi())) );
        }
      GlobalPoint thePoint;
    };

    struct AbsLessDTheta {
        AbsLessDTheta(const GlobalPoint& point) : thePoint(point) {}
        bool operator()(const TransientTrackingRecHit::ConstRecHitPointer& lhs,
                       const TransientTrackingRecHit::ConstRecHitPointer& rhs) const{
           return ( fabs(lhs->globalPosition().bareTheta() - thePoint.bareTheta()) < fabs(rhs->globalPosition().bareTheta() - thePoint.bareTheta()) );
        }
      GlobalPoint thePoint;
    };

    struct LessPhi {
        LessPhi() : thePoint(0,0,0) {}
        bool operator()(const MuonTransientTrackingRecHit::MuonRecHitPointer& lhs,
                       const MuonTransientTrackingRecHit::MuonRecHitPointer& rhs) const{
           return (lhs->globalPosition().barePhi() < rhs->globalPosition().barePhi());
        }
        GlobalPoint thePoint;
    };

    struct LessPerp {
        LessPerp() : thePoint(0,0,0) {}
        bool operator()(const MuonTransientTrackingRecHit::MuonRecHitPointer& lhs,
                       const MuonTransientTrackingRecHit::MuonRecHitPointer& rhs) const{
           return (lhs->globalPosition().perp() < rhs->globalPosition().perp());
        }
      GlobalPoint thePoint;
    };

    struct LessAbsMag {
        LessAbsMag() : thePoint(0,0,0) {}
        bool operator()(const MuonTransientTrackingRecHit::MuonRecHitPointer& lhs,
                       const MuonTransientTrackingRecHit::MuonRecHitPointer& rhs) const{
           return (lhs->globalPosition().mag() < rhs->globalPosition().mag());
        }
      GlobalPoint thePoint;
    };

    std::string category_;

    unsigned long long theCacheId_TRH;
    unsigned long long theCacheId_MT;

    std::string theTrackerRecHitBuilderName;
    edm::ESHandle<TransientTrackingRecHitBuilder> theTrackerRecHitBuilder;

    std::string theMuonRecHitBuilderName;
    edm::ESHandle<TransientTrackingRecHitBuilder> theMuonRecHitBuilder;

    edm::InputTag theDTRecHitLabel;
    edm::InputTag theCSCRecHitLabel;
    edm::InputTag theCSCSegmentsLabel;
    edm::InputTag theDT4DRecSegmentLabel;

    edm::Handle<DTRecHitCollection> theDTRecHits;
    edm::Handle<CSCRecHit2DCollection> theCSCRecHits;
    edm::Handle<CSCSegmentCollection> theCSCSegments;
    edm::Handle<DTRecSegment4DCollection> theDT4DRecSegments;

    edm::EDGetTokenT<DTRecHitCollection> theDTRecHitToken;
    edm::EDGetTokenT<CSCRecHit2DCollection> theCSCRecHitToken;
    edm::EDGetTokenT<CSCSegmentCollection> theCSCSegmentsToken;
    edm::EDGetTokenT<DTRecSegment4DCollection> theDT4DRecSegmentToken;




    // geometry
    edm::ESHandle<GeometricSearchTracker> theTracker;
    edm::ESHandle<GlobalTrackingGeometry> theTrackingGeometry;
    edm::ESHandle<MagneticField> theField;
    edm::ESHandle<CSCGeometry> theCSCGeometry;
    edm::ESHandle<DTGeometry> theDTGeometry;

};
#endif