Me0 muons in 76 x commitv2

CommonTools/RecoAlgos/plugins/ME0MuonTrackCollProducer.cc

@@ -0,0 +1,95 @@
+
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
+#include "DataFormats/TrackReco/interface/TrackFwd.h"
+#include "DataFormats/TrackReco/interface/Track.h"
+#include "DataFormats/MuonDetId/interface/CSCDetId.h"
+#include "DataFormats/MuonDetId/interface/DTChamberId.h"
+#include "DataFormats/MuonDetId/interface/MuonSubdetId.h"
+#include "DataFormats/VertexReco/interface/Vertex.h"
+#include "DataFormats/VertexReco/interface/VertexFwd.h"
+#include "DataFormats/MuonReco/interface/Muon.h"
+#include "DataFormats/TrackReco/interface/Track.h"
+#include "DataFormats/TrackReco/interface/TrackFwd.h" 
+#include "RecoMuon/MuonIdentification/plugins/ME0MuonSelector.cc"
+#include "FWCore/Framework/interface/ESHandle.h"
+
+#include <sstream>
+
+#include <memory>
+#include "FWCore/Framework/interface/stream/EDProducer.h"
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "DataFormats/MuonReco/interface/MuonFwd.h"
+#include "DataFormats/MuonReco/interface/ME0Muon.h"
+#include "DataFormats/MuonReco/interface/ME0MuonCollection.h"
+#include "DataFormats/CSCRecHit/interface/CSCSegmentCollection.h"
+#include "DataFormats/DTRecHit/interface/DTRecSegment4DCollection.h"
+#include "DataFormats/HepMCCandidate/interface/GenParticle.h"
+
+class ME0MuonTrackCollProducer : public edm::stream::EDProducer<> {
+public:
+  explicit ME0MuonTrackCollProducer(const edm::ParameterSet&);
+  //std::vector<double> findSimVtx(edm::Event& iEvent);
+  ~ME0MuonTrackCollProducer();
+
+private:
+  virtual void produce(edm::Event&, const edm::EventSetup&) override;
+  edm::Handle <std::vector<reco::ME0Muon> > OurMuons;
+  //edm::Handle<reco::ME0MuonCollection> muonCollectionH;
+  edm::InputTag OurMuonsTag;
+  std::vector<std::string> selectionTags;
+  const edm::ParameterSet parset_;
+  edm::EDGetTokenT<ME0MuonCollection> OurMuonsToken_;
+};
+
+
+#include "FWCore/PluginManager/interface/ModuleDef.h"
+#include "FWCore/Framework/interface/MakerMacros.h"
+
+DEFINE_FWK_MODULE(ME0MuonTrackCollProducer);
+
+
+ME0MuonTrackCollProducer::ME0MuonTrackCollProducer(const edm::ParameterSet& parset) :
+  OurMuonsTag(parset.getParameter<edm::InputTag>("me0MuonTag")),
+  selectionTags(parset.getParameter< std::vector<std::string> >("selectionTags")),
+  parset_(parset)
+{
+  produces<reco::TrackCollection>();
+  OurMuonsToken_ = consumes<ME0MuonCollection>(OurMuonsTag);
+}
+
+ME0MuonTrackCollProducer::~ME0MuonTrackCollProducer() {
+}
+
+void ME0MuonTrackCollProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup)
+{
+  using namespace reco;
+  using namespace edm;
+  Handle <ME0MuonCollection> OurMuons;
+  iEvent.getByToken(OurMuonsToken_,OurMuons);
+
+
+  std::auto_ptr<reco::TrackCollection> selectedTracks(new reco::TrackCollection);
+
+  reco::TrackRefProd rTracks = iEvent.getRefBeforePut<reco::TrackCollection>();
+
+
+
+  for(std::vector<reco::ME0Muon>::const_iterator thismuon = OurMuons->begin();
+       thismuon != OurMuons->end(); ++thismuon) {
+
+    if (!muon::isGoodMuon(*thismuon, muon::Tight)) continue;
+    reco::TrackRef trackref;    
+
+    if (thismuon->innerTrack().isNonnull()) trackref = thismuon->innerTrack();
+
+      const reco::Track* trk = &(*trackref);
+      // pointer to old track:
+      //reco::Track* newTrk = new reco::Track(*trk);
+
+      selectedTracks->push_back( *trk );
+      //selectedTrackExtras->push_back( *newExtra );
+  }
+  iEvent.put(selectedTracks);
+
+}

CommonTools/RecoAlgos/python/me0Associator.py

@@ -0,0 +1,12 @@
+import FWCore.ParameterSet.Config as cms
+
+
+#----------ME0Muon Collection Production for association by chi2
+me0muon = cms.EDProducer("ME0MuonTrackCollProducer",
+                         me0MuonTag = cms.InputTag("me0SegmentMatching"),
+                         selectionTags = cms.vstring('All'),
+                         )
+#--------------------
+me0muonColl_seq = cms.Sequence(
+                             me0muon
+                             )

DataFormats/MuonReco/BuildFile.xml

@@ -4,8 +4,8 @@
 <use   name="DataFormats/TrackReco"/>
 <use   name="DataFormats/DTRecHit"/>
 <use   name="DataFormats/CSCRecHit"/>
+<use   name="DataFormats/GEMRecHit"/>
 <use   name="DataFormats/VertexReco"/>
-
 <use   name="rootmath"/>
 <export>
   <lib   name="1"/>

DataFormats/MuonReco/interface/EmulatedME0Segment.h

@@ -0,0 +1,76 @@
+#ifndef DataFormats_MuonReco_EmulatedME0Segment_h
+#define DataFormats_MuonReco_EmulatedME0Segment_h
+
+/** \class EmulatedME0Segment
+ *  Describes a simulated track segment in a z-plane modeling an ME0 chamber.
+ *  It is modeled after CSCSegment, so it is a 4-dimensional object ( origin (x,y) , direction (x,y) )
+ *  Formally it must be defined as a LocalPoint and LocalError but we actually use the global coordinate system.
+ *  
+ *  
+ *  \author David Nash
+ */
+
+#include <DataFormats/TrackingRecHit/interface/RecSegment.h>
+
+#include <iosfwd>
+
+class EmulatedME0Segment : public RecSegment {
+
+public:
+
+    /// Default constructor
+ EmulatedME0Segment() : theOrigin(0,0,0), theLocalDirection(0,0,0), theCovMatrix(4,0),theChi2(0.) {}
+
+    /// Constructor
+    EmulatedME0Segment(const LocalPoint& origin, const LocalVector& direction, const AlgebraicSymMatrix& errors, const double chi2);
+
+    /// Destructor
+    virtual ~EmulatedME0Segment();
+
+    //--- Base class interface
+    EmulatedME0Segment* clone() const { return new EmulatedME0Segment(*this); }
+
+    virtual LocalPoint localPosition() const { return theOrigin; }
+    LocalError localPositionError() const ;
+
+    LocalVector localDirection() const { return theLocalDirection; }
+    LocalError localDirectionError() const ;
+
+    /// Parameters of the segment, for the track fit in the order (dx/dz, dy/dz, x, y )
+    AlgebraicVector parameters() const;
+
+    /// Covariance matrix of parameters()
+    virtual AlgebraicSymMatrix parametersError() const { return theCovMatrix; }
+
+    /// The projection matrix relates the trajectory state parameters to the segment parameters(). 
+    AlgebraicMatrix projectionMatrix() const;
+
+    virtual std::vector<const TrackingRecHit*> recHits() const {return std::vector<const TrackingRecHit*> (); }
+
+    virtual std::vector<TrackingRecHit*> recHits() {return std::vector<TrackingRecHit*>();}
+
+    virtual double chi2() const { return theChi2; }
+
+    virtual int dimension() const { return 4; }
+
+    virtual int degreesOfFreedom() const { return -1;}	 //Maybe  change later?
+
+    //--- Extension of the interface
+
+    int nRecHits() const { return 0;}  //theME0RecHits.size(); }        
+
+    void print() const;		
+
+ private:
+
+    //std::vector<ME0RecHit2D> theME0RecHits;
+    //  CAVEAT: these "Local" paramaters will in fact be filled by global coordinates
+    LocalPoint theOrigin;   // in chamber frame - the GeomDet local coordinate system
+    LocalVector theLocalDirection; // in chamber frame - the GeomDet local coordinate system
+    AlgebraicSymMatrix theCovMatrix; // the covariance matrix
+    double theChi2;
+};
+
+std::ostream& operator<<(std::ostream& os, const EmulatedME0Segment& seg);
+
+#endif // ME0RecHit_EmulatedME0Segment_h

DataFormats/MuonReco/interface/EmulatedME0SegmentCollection.h

@@ -0,0 +1,23 @@
+
+#ifndef DataFormats_EmulatedME0SegmentCollection_H
+#define DataFormats_EmulatedME0SegmentCollection_H
+
+/** \class EmulatedME0SegmentCollection
+ *
+ * The collection of EmulatedME0Segment's. See \ref EmulatedME0SegmentCollection.h for details.
+ *
+ *  \author Matteo Sani
+ */
+
+#include <DataFormats/MuonReco/interface/EmulatedME0Segment.h>
+#include <DataFormats/Common/interface/Ref.h>
+
+/// collection of EmulatedME0Segments
+typedef std::vector<EmulatedME0Segment> EmulatedME0SegmentCollection;
+
+/// persistent reference to a EmulatedME0Segment
+typedef edm::Ref<EmulatedME0SegmentCollection> EmulatedME0SegmentRef;
+
+#endif
+
+

DataFormats/MuonReco/interface/ME0Muon.h

@@ -0,0 +1,87 @@
+#ifndef MuonReco_ME0Muon_h
+#define MuonReco_ME0Muon_h
+/** \class reco::ME0Muon ME0Muon.h DataFormats/MuonReco/interface/ME0Muon.h
+ *  
+ * \author David Nash NEU
+ *
+ *
+ */
+#include "DataFormats/TrackReco/interface/TrackFwd.h"
+#include "DataFormats/TrackReco/interface/Track.h"
+#include "DataFormats/GeometryVector/interface/GlobalPoint.h"
+#include "DataFormats/GeometryVector/interface/GlobalVector.h"
+#include "DataFormats/Math/interface/AlgebraicROOTObjects.h"
+
+#include <DataFormats/GEMRecHit/interface/ME0SegmentCollection.h>
+
+#include "DataFormats/RecoCandidate/interface/RecoCandidate.h"
+
+namespace reco {
+
+  class ME0Muon : public RecoCandidate{
+  public:
+    ME0Muon();
+    //ME0Muon( const TrackRef & t, const ME0Segment & s) { innerTrack_ = t; me0Segment_ = s;}
+    ME0Muon( const TrackRef & t, const ME0Segment & s, const int v, const double c) { innerTrack_ = t; me0Segment_ = s; me0segid_=v; trackCharge_ = c;}
+    virtual ~ME0Muon(){}     
+
+    /// reference to Track reconstructed in the tracker only
+    TrackRef innerTrack() const { return innerTrack_; }
+    virtual TrackRef track() const { return innerTrack(); }
+    /// set reference to Track
+    void setInnerTrack( const TrackRef & t ) { innerTrack_ = t; }
+    void setTrack( const TrackRef & t ) { setInnerTrack(t); }
+    /// set reference to our new ME0Segment type
+    void setME0Segment( const ME0Segment & s ) { me0Segment_ = s; }
+
+    const ME0Segment& me0segment() const { return me0Segment_; }
+
+    //Added for testing
+    void setme0segid( const int v){me0segid_=v;}
+    int me0segid() const {return me0segid_;}
+
+
+    const GlobalPoint& globalTrackPosAtSurface() const { return globalTrackPosAtSurface_; }
+    const GlobalVector& globalTrackMomAtSurface() const { return globalTrackMomAtSurface_; }
+    const LocalPoint& localTrackPosAtSurface() const { return localTrackPosAtSurface_; }
+    const LocalVector& localTrackMomAtSurface() const { return localTrackMomAtSurface_; }
+
+    int trackCharge() const { return trackCharge_; }
+    const AlgebraicSymMatrix66& globalTrackCov() const { return globalTrackCov_; }
+    const AlgebraicSymMatrix55& localTrackCov() const { return localTrackCov_; }
+
+    void setGlobalTrackPosAtSurface(const GlobalPoint& globalTrackPosAtSurface) { globalTrackPosAtSurface_ = globalTrackPosAtSurface; }
+    void setGlobalTrackMomAtSurface(const GlobalVector& globalTrackMomAtSurface) { globalTrackMomAtSurface_ = globalTrackMomAtSurface; }
+    void setLocalTrackPosAtSurface(const LocalPoint& localTrackPosAtSurface) { localTrackPosAtSurface_ = localTrackPosAtSurface; }
+    void setLocalTrackMomAtSurface(const LocalVector& localTrackMomAtSurface) { localTrackMomAtSurface_ = localTrackMomAtSurface; }
+    void setTrackCharge(const int& trackCharge) { trackCharge_ = trackCharge; }
+    void setGlobalTrackCov(const AlgebraicSymMatrix66& trackCov) { globalTrackCov_ = trackCov; }
+    void setLocalTrackCov(const AlgebraicSymMatrix55& trackCov) { localTrackCov_ = trackCov; }
+
+  private:
+    /// check overlap with another candidate
+    virtual bool overlap( const Candidate & ) const;
+
+    /// reference to Track reconstructed in the tracker only
+    TrackRef innerTrack_;
+    ME0Segment me0Segment_;
+    int me0segid_;
+
+    GlobalPoint globalTrackPosAtSurface_;
+    GlobalVector globalTrackMomAtSurface_;
+
+    LocalPoint localTrackPosAtSurface_;
+    LocalVector localTrackMomAtSurface_;
+    int trackCharge_;
+    AlgebraicSymMatrix66 globalTrackCov_;
+    AlgebraicSymMatrix55 localTrackCov_;
+
+    //double xpull_,ypull_,xdiff_,ydiff_,phidirdiff_;
+  };
+
+}
+
+
+#endif
+
+

DataFormats/MuonReco/interface/ME0MuonCollection.h

@@ -0,0 +1,22 @@
+#ifndef DataFormats_ME0MuonCollection_H
+#define DataFormats_ME0MuonCollection_H
+
+/** \class ME0MuonCollection
+ *
+ * The collection of ME0Muon's. See \ref ME0MuonCollection.h for details.
+ *
+ *  $Date: 2010/03/12 13:08:15 $
+ *  \author David Nash
+ */
+
+#include "DataFormats/MuonReco/interface/ME0Muon.h"
+#include "DataFormats/Common/interface/Ref.h"
+
+/// collection of ME0Muons
+typedef std::vector<reco::ME0Muon> ME0MuonCollection;
+
+/// persistent reference to a ME0Muon
+typedef edm::Ref<ME0MuonCollection> ME0MuonRef;
+
+
+#endif