Merge pull request #2250 from calabria/ForGemMuonReco

For gem muon reco

DQM/DTMonitorModule/src/DTChamberEfficiency.cc

@@ -82,7 +82,7 @@ DTChamberEfficiency::DTChamberEfficiency(const ParameterSet& pSet)
   thecscSegments = pSet.getParameter<InputTag>("cscSegments");
 
   theMeasurementExtractor = new MuonDetLayerMeasurements(thedt4DSegments,thecscSegments,
-							 labelRPCRecHits,true,false,false); 
+							 labelRPCRecHits,InputTag(),true,false,false,false); 
 
   theNavigationType = pSet.getParameter<string>("NavigationType");
 

RecoLocalMuon/GEMRecHit/src/GEMEtaPartitionMask.h

@@ -4,7 +4,7 @@
 #include <bitset>
 #include <vector>
 
-const int maskSIZE=384;
+const int maskSIZE=768;
 typedef std::bitset<maskSIZE> EtaPartitionMask;
 
 #endif

RecoMuon/CosmicMuonProducer/src/CosmicMuonTrajectoryBuilder.cc

@@ -50,6 +50,7 @@ CosmicMuonTrajectoryBuilder::CosmicMuonTrajectoryBuilder(const edm::ParameterSet
   bool enableDTMeasurement = par.getParameter<bool>("EnableDTMeasurement");
   bool enableCSCMeasurement = par.getParameter<bool>("EnableCSCMeasurement");
   bool enableRPCMeasurement = par.getParameter<bool>("EnableRPCMeasurement");
+  //bool enableGEMMeasurement = par.getParameter<bool>("EnableGEMMeasurement");
 
 //  if(enableDTMeasurement)
   InputTag DTRecSegmentLabel = par.getParameter<InputTag>("DTRecSegmentLabel");
@@ -60,12 +61,17 @@ CosmicMuonTrajectoryBuilder::CosmicMuonTrajectoryBuilder(const edm::ParameterSet
 //  if(enableRPCMeasurement)
   InputTag RPCRecSegmentLabel = par.getParameter<InputTag>("RPCRecSegmentLabel");
 
+//  if(enableGEMMeasurement)
+  //InputTag GEMRecSegmentLabel = par.getParameter<InputTag>("GEMRecSegmentLabel");
+
   theLayerMeasurements= new MuonDetLayerMeasurements(DTRecSegmentLabel,
                                                      CSCRecSegmentLabel,
                                                      RPCRecSegmentLabel,
+                                                     edm::InputTag(),
 						     enableDTMeasurement,
 						     enableCSCMeasurement,
-						     enableRPCMeasurement);
+						     enableRPCMeasurement,
+						     false);
 
   ParameterSet muonUpdatorPSet = par.getParameter<ParameterSet>("MuonTrajectoryUpdatorParameters");
 

RecoMuon/DetLayers/interface/MuonDetLayerGeometry.h

@@ -5,9 +5,8 @@
  *
  *  Provide access to the DetLayers of muon detectors.
  *
- *  $Date: 2009/07/03 09:12:47 $
- *  $Revision: 1.13 $
  *  \author N. Amapane - CERN
+ *  \modified by R. Radogna & C. Calabria
  */
 
 #include "DataFormats/DetId/interface/DetId.h"
@@ -40,6 +39,19 @@ class MuonDetLayerGeometry : public DetLayerGeometry{
   /// return the backward (-Z) CSC DetLayers, inside-out
   const std::vector<DetLayer*>& backwardCSCLayers() const;
 
+/////////////////////////////// GEMs
+
+  /// return the GEM DetLayers (endcap), -Z to +Z
+  const std::vector<DetLayer*>& allGEMLayers() const;
+
+  /// return the forward (+Z) GEM DetLayers, inside-out
+  const std::vector<DetLayer*>& forwardGEMLayers() const;
+
+  /// return the backward (-Z) GEM DetLayers, inside-out
+  const std::vector<DetLayer*>& backwardGEMLayers() const;
+
+//////////////////////////////
+
   /// return all RPC DetLayers, order: backward, barrel, forward
   const std::vector<DetLayer*>& allRPCLayers() const;
 
@@ -61,14 +73,27 @@ class MuonDetLayerGeometry : public DetLayerGeometry{
   /// return all barrel DetLayers (DT+RPC), inside-out
   const std::vector<DetLayer*>& allBarrelLayers() const;
 
-  /// return all endcap DetLayers (CSC+RPC), -Z to +Z
+  /// return all endcap DetLayers (CSC+RPC+GEM), -Z to +Z
   const std::vector<DetLayer*>& allEndcapLayers() const;
 
-  /// return all forward (+Z) layers (CSC+RPC), inside-out
+  /// return all forward (+Z) layers (CSC+RPC+GEM), inside-out
   const std::vector<DetLayer*>& allForwardLayers() const;
 
-  /// return all backward (-Z) layers (CSC+RPC), inside-out
+  /// return all backward (-Z) layers (CSC+RPC+GEM), inside-out
   const std::vector<DetLayer*>& allBackwardLayers() const;
+
+/////////////////////////////// GEMs
+
+  /// return all endcap DetLayers (CSC+GEM), -Z to +Z
+  const std::vector<DetLayer*>& allEndcapCscGemLayers() const;
+
+  /// return all endcap DetLayers (CSC+GEM), -Z to +Z
+  const std::vector<DetLayer*>& allCscGemForwardLayers() const;
+
+  /// return all endcap DetLayers (CSC+GEM), -Z to +Z
+  const std::vector<DetLayer*>& allCscGemBackwardLayers() const;
+
+//////////////////////////////
 
   /// return the DetLayer which correspond to a certain DetId
   virtual const DetLayer* idToLayer(const DetId& detId) const;
@@ -87,6 +112,15 @@ class MuonDetLayerGeometry : public DetLayerGeometry{
   /// All three vectors are ASSUMED to be sorted inside-out
   void addRPCLayers(std::vector<DetLayer*> barrelRPCLayers, std::pair<std::vector<DetLayer*>, std::vector<DetLayer*> > endcapRPCLayers);
 
+/////////////////////////////// GEMs
+
+  /// Add GEM layers 
+  /// gemlayers.first=forward (+Z), gemlayers.second=backward (-Z)
+  /// both vectors are ASSUMED to be sorted inside-out
+  void addGEMLayers(std::pair<std::vector<DetLayer*>, std::vector<DetLayer*> > gemlayers);
+
+//////////////////////////////
+
 
   DetId makeDetLayerId(const DetLayer* detLayer) const;
 
@@ -95,6 +129,15 @@ class MuonDetLayerGeometry : public DetLayerGeometry{
   std::vector<DetLayer*> cscLayers_fw;
   std::vector<DetLayer*> cscLayers_bk;
   std::vector<DetLayer*> cscLayers_all;
+
+/////////////////////////////// GEMs
+
+  std::vector<DetLayer*> gemLayers_fw;
+  std::vector<DetLayer*> gemLayers_bk;
+  std::vector<DetLayer*> gemLayers_all;
+
+//////////////////////////////
+
   std::vector<DetLayer*> rpcLayers_all;
   std::vector<DetLayer*> rpcLayers_endcap;
   std::vector<DetLayer*> rpcLayers_fw;
@@ -106,6 +149,14 @@ class MuonDetLayerGeometry : public DetLayerGeometry{
   std::vector<DetLayer*> allEndcap;
   std::vector<DetLayer*> allBarrel;
   std::vector<DetLayer*> allDetLayers;
+
+/////////////////////////////// GEMs
+
+  std::vector<DetLayer*> allEndcapCscGem;
+  std::vector<DetLayer*> allCscGemForward;
+  std::vector<DetLayer*> allCscGemBackward;
+
+//////////////////////////////
 
   std::map<DetId,DetLayer*> detLayersMap;
 };

RecoMuon/DetLayers/plugins/BuildFile.xml

@@ -3,6 +3,7 @@
   <use   name="FWCore/MessageLogger"/>
   <use   name="FWCore/ParameterSet"/>
   <use   name="Geometry/CSCGeometry"/>
+  <use   name="Geometry/GEMGeometry"/>
   <use   name="Geometry/DTGeometry"/>
   <use   name="Geometry/RPCGeometry"/>
   <use   name="Geometry/Records"/>

RecoMuon/DetLayers/plugins/MuonDetLayerGeometryESProducer.cc

@@ -1,8 +1,7 @@
 /** \file
  *
- *  $Date: 2007/04/18 15:12:01 $
- *  $Revision: 1.1 $
  *  \author N. Amapane - CERN
+ *  \modified by R. Radogna & C. Calabria
  */
 
 #include <RecoMuon/DetLayers/plugins/MuonDetLayerGeometryESProducer.h>
@@ -11,9 +10,11 @@
 #include <Geometry/DTGeometry/interface/DTGeometry.h>
 #include <Geometry/CSCGeometry/interface/CSCGeometry.h>
 #include <Geometry/RPCGeometry/interface/RPCGeometry.h>
+#include <Geometry/GEMGeometry/interface/GEMGeometry.h>
 
 #include <RecoMuon/DetLayers/src/MuonCSCDetLayerGeometryBuilder.h>
 #include <RecoMuon/DetLayers/src/MuonRPCDetLayerGeometryBuilder.h>
+#include <RecoMuon/DetLayers/src/MuonGEMDetLayerGeometryBuilder.h>
 #include <RecoMuon/DetLayers/src/MuonDTDetLayerGeometryBuilder.h>
 
 #include <FWCore/Framework/interface/EventSetup.h>
@@ -63,6 +64,18 @@ MuonDetLayerGeometryESProducer::produce(const MuonRecoGeometryRecord & record) {
     // No CSC geo available: trap the exception.
     LogInfo(metname) << "No CSC geometry is available.";
   }
+
+  // Build GEM layers
+  try {
+    edm::ESHandle<GEMGeometry> gem;
+    record.getRecord<MuonGeometryRecord>().get(gem);
+    if (gem.isValid()) {
+      muonDetLayerGeometry->addGEMLayers(MuonGEMDetLayerGeometryBuilder::buildEndcapLayers(*gem));
+    }
+  } catch (edm::eventsetup::NoProxyException<GEMGeometry>& e) {
+    // No GEM geo available: trap the exception.
+    LogInfo(metname) << "No GEM geometry is available.";
+  }
 
   // Build RPC layers
   try {

RecoMuon/DetLayers/src/MuonDetLayerGeometry.cc

@@ -1,8 +1,7 @@
 /** \file
  *
- *  $Date: 2009/07/03 09:12:48 $
- *  $Revision: 1.20 $
  *  \author N. Amapane - CERN
+ *  \modified by R. Radogna & C. Calabria
  */
 
 #include <RecoMuon/DetLayers/interface/MuonDetLayerGeometry.h>
@@ -12,6 +11,7 @@
 #include <DataFormats/MuonDetId/interface/CSCDetId.h>
 #include <DataFormats/MuonDetId/interface/DTChamberId.h>
 #include <DataFormats/MuonDetId/interface/RPCDetId.h>
+#include <DataFormats/MuonDetId/interface/GEMDetId.h>
 
 #include <Utilities/General/interface/precomputed_value_sort.h>
 #include <DataFormats/GeometrySurface/interface/GeometricSorting.h>
@@ -54,6 +54,29 @@ void MuonDetLayerGeometry::addCSCLayers(pair<vector<DetLayer*>, vector<DetLayer*
   }    
 }    
 
+void MuonDetLayerGeometry::addGEMLayers(pair<vector<DetLayer*>, vector<DetLayer*> > gemlayers) {
+
+  vector<DetLayer*>::const_iterator it;
+  for(it=gemlayers.first.begin(); it!=gemlayers.first.end(); it++) {
+    gemLayers_fw.push_back(*it);
+    //    gemLayers_all.push_back(*it);
+    allForward.push_back(*it);
+    //    allEndcap.push_back(*it);
+    //    allDetLayers.push_back(*it);
+
+    detLayersMap[ makeDetLayerId(*it) ] = *it;
+  }
+  for(it=gemlayers.second.begin(); it!=gemlayers.second.end(); it++) {
+    gemLayers_bk.push_back(*it);
+    //    gemLayers_all.push_back(*it);
+    allBackward.push_back(*it);
+    //    allEndcap.push_back(*it);
+    //    allDetLayers.push_back(*it);
+
+    detLayersMap[ makeDetLayerId(*it) ] = *it;
+  }
+}
+
 void MuonDetLayerGeometry::addRPCLayers(vector<DetLayer*> barrelLayers, pair<vector<DetLayer*>, vector<DetLayer*> > endcapLayers) {
 
   vector<DetLayer*>::const_iterator it;
@@ -129,6 +152,10 @@ DetId MuonDetLayerGeometry::makeDetLayerId(const DetLayer* detLayer) const{
     RPCDetId id( detLayer->basicComponents().front()->geographicalId().rawId());
     return RPCDetId(id.region(),0,id.station(),0,id.layer(),0,0);
   }
+  else if( detLayer->subDetector()== GeomDetEnumerators::GEM){
+    GEMDetId id( detLayer->basicComponents().front()->geographicalId().rawId());
+    return GEMDetId(id.region(),1,id.station(),id.layer(),0,0);
+  }
   else throw cms::Exception("InvalidModuleIdentification"); // << detLayer->module();
 }
 
@@ -156,6 +183,28 @@ MuonDetLayerGeometry::backwardCSCLayers() const {
 }
 
 
+//////////////////// GEMs
+
+const vector<DetLayer*>&
+MuonDetLayerGeometry::allGEMLayers() const {
+    return gemLayers_all;
+}
+
+
+const vector<DetLayer*>&
+MuonDetLayerGeometry::forwardGEMLayers() const {
+    return gemLayers_fw;
+}
+
+
+const vector<DetLayer*>&
+MuonDetLayerGeometry::backwardGEMLayers() const {
+    return gemLayers_bk;
+}
+
+////////////////////
+
+
 const vector<DetLayer*>& 
 MuonDetLayerGeometry::allRPCLayers() const {
     return rpcLayers_all;    
@@ -214,6 +263,29 @@ MuonDetLayerGeometry::allBackwardLayers() const {
     return allBackward;    
 }    
 
+
+//////////////////// GEMs
+
+const vector<DetLayer*>&
+MuonDetLayerGeometry::allEndcapCscGemLayers() const {
+    return allEndcapCscGem;    
+}    
+
+
+const vector<DetLayer*>&
+MuonDetLayerGeometry::allCscGemForwardLayers() const {
+    return allCscGemForward;    
+}    
+
+
+const vector<DetLayer*>&
+MuonDetLayerGeometry::allCscGemBackwardLayers() const {
+    return allCscGemBackward;    
+}    
+
+////////////////////
+
+
 const DetLayer* MuonDetLayerGeometry::idToLayer(const DetId &detId) const{
 
   DetId id;
@@ -241,7 +313,10 @@ const DetLayer* MuonDetLayerGeometry::idToLayer(const DetId &detId) const{
     RPCDetId rpcId(detId.rawId() );
     id = RPCDetId(rpcId.region(),0,rpcId.station(),0,rpcId.layer(),0,0);
   }
-
+  else if (detId.subdetId() == MuonSubdetId::GEM){
+    GEMDetId gemId(detId.rawId() );
+    id = GEMDetId(gemId.region(),1,gemId.station(),gemId.layer(),0,0);
+  }
   else throw cms::Exception("InvalidSubdetId")<< detId.subdetId();
 
   std::map<DetId,DetLayer*>::const_iterator layer = detLayersMap.find(id);
@@ -285,6 +360,12 @@ void MuonDetLayerGeometry::sortLayers() {
   std::reverse(cscLayers_all.begin(),cscLayers_all.end());
   std::copy(cscLayers_fw.begin(),cscLayers_fw.end(),back_inserter(cscLayers_all));
 
+  //gemLayers_all: from -Z to +Z
+  gemLayers_all.reserve(gemLayers_bk.size()+gemLayers_fw.size());
+  std::copy(gemLayers_bk.begin(),gemLayers_bk.end(),back_inserter(gemLayers_all));
+  std::reverse(gemLayers_all.begin(),gemLayers_all.end());
+  std::copy(gemLayers_fw.begin(),gemLayers_fw.end(),back_inserter(gemLayers_all));
+
   //rpcLayers_endcap: from -Z to +Z
   rpcLayers_endcap.reserve(rpcLayers_bk.size()+rpcLayers_fw.size());
   std::copy(rpcLayers_bk.begin(),rpcLayers_bk.end(),back_inserter(rpcLayers_endcap));
@@ -304,6 +385,24 @@ void MuonDetLayerGeometry::sortLayers() {
   std::reverse(allEndcap.begin(),allEndcap.end());
   std::copy(allForward.begin(),allForward.end(),back_inserter(allEndcap));
 
+  // allEndcapCSCGEM: order is  all bw, all fw
+  allEndcapCscGem.reserve(cscLayers_bk.size()+cscLayers_fw.size()+gemLayers_bk.size()+gemLayers_fw.size());
+  std::copy(cscLayers_bk.begin(),cscLayers_bk.end(),back_inserter(allEndcapCscGem));
+  std::copy(gemLayers_bk.begin(),gemLayers_bk.end(),back_inserter(allEndcapCscGem));
+  std::reverse(allEndcapCscGem.begin(),allEndcapCscGem.end());
+  std::copy(cscLayers_fw.begin(),cscLayers_fw.end(),back_inserter(allEndcapCscGem));
+  std::copy(gemLayers_fw.begin(),gemLayers_fw.end(),back_inserter(allEndcapCscGem));
+
+  // allCscGemForward
+  allCscGemForward.reserve(cscLayers_fw.size()+gemLayers_fw.size());
+  std::copy(cscLayers_fw.begin(),cscLayers_fw.end(),back_inserter(allCscGemForward));
+  std::copy(gemLayers_fw.begin(),gemLayers_fw.end(),back_inserter(allCscGemForward));
+
+  // allCscGemBackward
+  allCscGemBackward.reserve(cscLayers_bk.size()+gemLayers_bk.size());
+  std::copy(cscLayers_bk.begin(),cscLayers_bk.end(),back_inserter(allCscGemBackward));
+  std::copy(gemLayers_bk.begin(),gemLayers_bk.end(),back_inserter(allCscGemBackward));
+
   // allDetLayers: order is  all bw, all barrel, all fw
   allDetLayers.reserve(allBackward.size()+allBarrel.size()+allForward.size());
   std::copy(allBackward.begin(),allBackward.end(),back_inserter(allDetLayers));