From ee108996d508519f2e4e51d62eb036c764cb848f Mon Sep 17 00:00:00 2001 From: Cesare Date: Wed, 29 Jan 2014 02:16:19 +0100 Subject: [PATCH 1/6] Files for the reconstruction with GEMs --- DQM/DTMonitorModule/src/DTChamberEfficiency.cc | 2 +- RecoLocalMuon/GEMRecHit/src/GEMEtaPartitionMask.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/DQM/DTMonitorModule/src/DTChamberEfficiency.cc b/DQM/DTMonitorModule/src/DTChamberEfficiency.cc index ac1981715442b..63f97c8501403 100644 --- a/DQM/DTMonitorModule/src/DTChamberEfficiency.cc +++ b/DQM/DTMonitorModule/src/DTChamberEfficiency.cc @@ -82,7 +82,7 @@ DTChamberEfficiency::DTChamberEfficiency(const ParameterSet& pSet) thecscSegments = pSet.getParameter("cscSegments"); theMeasurementExtractor = new MuonDetLayerMeasurements(thedt4DSegments,thecscSegments, - labelRPCRecHits,true,false,false); + labelRPCRecHits,InputTag(),true,false,false,false); theNavigationType = pSet.getParameter("NavigationType"); diff --git a/RecoLocalMuon/GEMRecHit/src/GEMEtaPartitionMask.h b/RecoLocalMuon/GEMRecHit/src/GEMEtaPartitionMask.h index aab403d6445ed..e1ad3e43fa355 100644 --- a/RecoLocalMuon/GEMRecHit/src/GEMEtaPartitionMask.h +++ b/RecoLocalMuon/GEMRecHit/src/GEMEtaPartitionMask.h @@ -4,7 +4,7 @@ #include #include -const int maskSIZE=384; +const int maskSIZE=768; typedef std::bitset EtaPartitionMask; #endif From 2318b39815d126570fa32debbcbac8bddd1a4034 Mon Sep 17 00:00:00 2001 From: Cesare Date: Wed, 29 Jan 2014 02:51:17 +0100 Subject: [PATCH 2/6] Files for the reconstruction with GEMs --- .../src/CosmicMuonTrajectoryBuilder.cc | 8 +- .../interface/MuonDetLayerGeometry.h | 61 +++++- RecoMuon/DetLayers/plugins/BuildFile.xml | 1 + .../plugins/MuonDetLayerGeometryESProducer.cc | 17 +- .../DetLayers/src/MuonDetLayerGeometry.cc | 105 ++++++++++- .../src/MuonGEMDetLayerGeometryBuilder.cc | 178 ++++++++++++++++++ .../src/MuonGEMDetLayerGeometryBuilder.h | 40 ++++ RecoMuon/MeasurementDet/BuildFile.xml | 1 + .../interface/MuonDetLayerMeasurements.h | 15 +- .../src/MuonDetLayerMeasurements.cc | 71 +++++-- .../plugins/CosmicMuonSeedGenerator.cc | 4 +- .../MuonSeedGenerator/src/MuonSeedBuilder.cc | 4 +- .../src/MuonSeedOrcaPatternRecognition.cc | 4 +- .../MuonSeedGenerator/src/RPCSeedGenerator.cc | 2 +- .../interface/MuonNavigationPrinter.h | 6 +- .../interface/MuonNavigationSchool.h | 4 +- .../Navigation/src/MuonNavigationPrinter.cc | 15 +- .../Navigation/src/MuonNavigationSchool.cc | 14 +- .../interface/StandAloneMuonFilter.h | 11 +- .../src/StandAloneMuonFilter.cc | 14 +- .../src/StandAloneTrajectoryBuilder.cc | 15 +- .../interface/MuonServiceProxy.h | 4 + .../python/MuonServiceProxy_cff.py | 2 + .../src/MuonPatternRecoDumper.cc | 5 + .../TrackingTools/src/MuonServiceProxy.cc | 16 +- .../src/MuonTrajectoryUpdator.cc | 11 ++ 26 files changed, 568 insertions(+), 60 deletions(-) create mode 100644 RecoMuon/DetLayers/src/MuonGEMDetLayerGeometryBuilder.cc create mode 100644 RecoMuon/DetLayers/src/MuonGEMDetLayerGeometryBuilder.h diff --git a/RecoMuon/CosmicMuonProducer/src/CosmicMuonTrajectoryBuilder.cc b/RecoMuon/CosmicMuonProducer/src/CosmicMuonTrajectoryBuilder.cc index f36b930c21d46..a6a0c5d3613a1 100644 --- a/RecoMuon/CosmicMuonProducer/src/CosmicMuonTrajectoryBuilder.cc +++ b/RecoMuon/CosmicMuonProducer/src/CosmicMuonTrajectoryBuilder.cc @@ -50,6 +50,7 @@ CosmicMuonTrajectoryBuilder::CosmicMuonTrajectoryBuilder(const edm::ParameterSet bool enableDTMeasurement = par.getParameter("EnableDTMeasurement"); bool enableCSCMeasurement = par.getParameter("EnableCSCMeasurement"); bool enableRPCMeasurement = par.getParameter("EnableRPCMeasurement"); + //bool enableGEMMeasurement = par.getParameter("EnableGEMMeasurement"); // if(enableDTMeasurement) InputTag DTRecSegmentLabel = par.getParameter("DTRecSegmentLabel"); @@ -60,12 +61,17 @@ CosmicMuonTrajectoryBuilder::CosmicMuonTrajectoryBuilder(const edm::ParameterSet // if(enableRPCMeasurement) InputTag RPCRecSegmentLabel = par.getParameter("RPCRecSegmentLabel"); +// if(enableGEMMeasurement) + //InputTag GEMRecSegmentLabel = par.getParameter("GEMRecSegmentLabel"); + theLayerMeasurements= new MuonDetLayerMeasurements(DTRecSegmentLabel, CSCRecSegmentLabel, RPCRecSegmentLabel, + edm::InputTag(), enableDTMeasurement, enableCSCMeasurement, - enableRPCMeasurement); + enableRPCMeasurement, + false); ParameterSet muonUpdatorPSet = par.getParameter("MuonTrajectoryUpdatorParameters"); diff --git a/RecoMuon/DetLayers/interface/MuonDetLayerGeometry.h b/RecoMuon/DetLayers/interface/MuonDetLayerGeometry.h index b5b57ec36cce0..43ad37879a586 100644 --- a/RecoMuon/DetLayers/interface/MuonDetLayerGeometry.h +++ b/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& backwardCSCLayers() const; +/////////////////////////////// GEMs + + /// return the GEM DetLayers (endcap), -Z to +Z + const std::vector& allGEMLayers() const; + + /// return the forward (+Z) GEM DetLayers, inside-out + const std::vector& forwardGEMLayers() const; + + /// return the backward (-Z) GEM DetLayers, inside-out + const std::vector& backwardGEMLayers() const; + +////////////////////////////// + /// return all RPC DetLayers, order: backward, barrel, forward const std::vector& allRPCLayers() const; @@ -61,14 +73,27 @@ class MuonDetLayerGeometry : public DetLayerGeometry{ /// return all barrel DetLayers (DT+RPC), inside-out const std::vector& allBarrelLayers() const; - /// return all endcap DetLayers (CSC+RPC), -Z to +Z + /// return all endcap DetLayers (CSC+RPC+GEM), -Z to +Z const std::vector& allEndcapLayers() const; - /// return all forward (+Z) layers (CSC+RPC), inside-out + /// return all forward (+Z) layers (CSC+RPC+GEM), inside-out const std::vector& allForwardLayers() const; - /// return all backward (-Z) layers (CSC+RPC), inside-out + /// return all backward (-Z) layers (CSC+RPC+GEM), inside-out const std::vector& allBackwardLayers() const; + +/////////////////////////////// GEMs + + /// return all endcap DetLayers (CSC+GEM), -Z to +Z + const std::vector& allEndcapCscGemLayers() const; + + /// return all endcap DetLayers (CSC+GEM), -Z to +Z + const std::vector& allCscGemForwardLayers() const; + + /// return all endcap DetLayers (CSC+GEM), -Z to +Z + const std::vector& 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 barrelRPCLayers, std::pair, std::vector > 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 > gemlayers); + +////////////////////////////// + DetId makeDetLayerId(const DetLayer* detLayer) const; @@ -95,6 +129,15 @@ class MuonDetLayerGeometry : public DetLayerGeometry{ std::vector cscLayers_fw; std::vector cscLayers_bk; std::vector cscLayers_all; + +/////////////////////////////// GEMs + + std::vector gemLayers_fw; + std::vector gemLayers_bk; + std::vector gemLayers_all; + +////////////////////////////// + std::vector rpcLayers_all; std::vector rpcLayers_endcap; std::vector rpcLayers_fw; @@ -106,6 +149,14 @@ class MuonDetLayerGeometry : public DetLayerGeometry{ std::vector allEndcap; std::vector allBarrel; std::vector allDetLayers; + +/////////////////////////////// GEMs + + std::vector allEndcapCscGem; + std::vector allCscGemForward; + std::vector allCscGemBackward; + +////////////////////////////// std::map detLayersMap; }; diff --git a/RecoMuon/DetLayers/plugins/BuildFile.xml b/RecoMuon/DetLayers/plugins/BuildFile.xml index 2dee63628784e..93d42041597a8 100644 --- a/RecoMuon/DetLayers/plugins/BuildFile.xml +++ b/RecoMuon/DetLayers/plugins/BuildFile.xml @@ -3,6 +3,7 @@ + diff --git a/RecoMuon/DetLayers/plugins/MuonDetLayerGeometryESProducer.cc b/RecoMuon/DetLayers/plugins/MuonDetLayerGeometryESProducer.cc index a35f024f52e15..86def77fca941 100644 --- a/RecoMuon/DetLayers/plugins/MuonDetLayerGeometryESProducer.cc +++ b/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 @@ -11,9 +10,11 @@ #include #include #include +#include #include #include +#include #include #include @@ -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 gem; + record.getRecord().get(gem); + if (gem.isValid()) { + muonDetLayerGeometry->addGEMLayers(MuonGEMDetLayerGeometryBuilder::buildEndcapLayers(*gem)); + } + } catch (edm::eventsetup::NoProxyException& e) { + // No GEM geo available: trap the exception. + LogInfo(metname) << "No GEM geometry is available."; + } // Build RPC layers try { diff --git a/RecoMuon/DetLayers/src/MuonDetLayerGeometry.cc b/RecoMuon/DetLayers/src/MuonDetLayerGeometry.cc index ea251b3ec683d..20fe1d3a1bfb2 100644 --- a/RecoMuon/DetLayers/src/MuonDetLayerGeometry.cc +++ b/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 @@ -12,6 +11,7 @@ #include #include #include +#include #include #include @@ -54,6 +54,29 @@ void MuonDetLayerGeometry::addCSCLayers(pair, vector, vector > gemlayers) { + + vector::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 barrelLayers, pair, vector > endcapLayers) { vector::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& +MuonDetLayerGeometry::allGEMLayers() const { + return gemLayers_all; +} + + +const vector& +MuonDetLayerGeometry::forwardGEMLayers() const { + return gemLayers_fw; +} + + +const vector& +MuonDetLayerGeometry::backwardGEMLayers() const { + return gemLayers_bk; +} + +//////////////////// + + const vector& MuonDetLayerGeometry::allRPCLayers() const { return rpcLayers_all; @@ -214,6 +263,29 @@ MuonDetLayerGeometry::allBackwardLayers() const { return allBackward; } + +//////////////////// GEMs + +const vector& +MuonDetLayerGeometry::allEndcapCscGemLayers() const { + return allEndcapCscGem; +} + + +const vector& +MuonDetLayerGeometry::allCscGemForwardLayers() const { + return allCscGemForward; +} + + +const vector& +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::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)); diff --git a/RecoMuon/DetLayers/src/MuonGEMDetLayerGeometryBuilder.cc b/RecoMuon/DetLayers/src/MuonGEMDetLayerGeometryBuilder.cc new file mode 100644 index 0000000000000..b45841f1ea116 --- /dev/null +++ b/RecoMuon/DetLayers/src/MuonGEMDetLayerGeometryBuilder.cc @@ -0,0 +1,178 @@ +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include "Utilities/BinningTools/interface/ClusterizingHistogram.h" + +#include + +#include + +using namespace std; + +MuonGEMDetLayerGeometryBuilder::~MuonGEMDetLayerGeometryBuilder() { +} + + +// Builds the forward (first) and backward (second) layers +pair, vector > +MuonGEMDetLayerGeometryBuilder::buildEndcapLayers(const GEMGeometry& geo) { + + vector result[2]; + + for (int endcap = -1; endcap<=1; endcap+=2) { + int iendcap = (endcap==1) ? 0 : 1; // +1: forward, -1: backward + + for(int station = GEMDetId::minStationId; station < GEMDetId::maxStationId; ++station) { + for(int layer = GEMDetId::minLayerId; layer <= GEMDetId::maxLayerId; ++layer) { + vector rolls; + std::vector rings; + std::vector chambers; + for(int ring = GEMDetId::minRingId; ring <= GEMDetId::maxRingId; ++ring) { + rings.push_back(ring); + } + for(int roll = GEMDetId::minRollId+1; roll <= GEMDetId::maxRollId; ++roll) { + rolls.push_back(roll); + } + for(int chamber = GEMDetId::minChamberId; chamber <= GEMDetId::maxChamberId; chamber++ ){ + chambers.push_back(chamber); + } + + MuRingForwardDoubleLayer* ringLayer = buildLayer(endcap, rings, station, layer, chambers, rolls, geo); + + if (ringLayer) result[iendcap].push_back(ringLayer); + + } + + } + + + } + pair, vector > res_pair(result[0], result[1]); + + return res_pair; + +} + + + +MuRingForwardDoubleLayer* +MuonGEMDetLayerGeometryBuilder::buildLayer(int endcap,vector& rings, int station, + int layer, + vector& chambers, + vector& rolls, + const GEMGeometry& geo) { + + const std::string metname = "Muon|RecoMuon|RecoMuonDetLayers|MuonGEMDetLayerGeometryBuilder"; + MuRingForwardDoubleLayer * result = 0; + vector frontRings, backRings; + + +// for (std::vector::iterator ring=rings.begin(); ring!=rings.end();ring++){ + for (std::vector::iterator ring=rings.begin(); ring!=rings.end()-2;ring++){ + + for (vector::iterator roll = rolls.begin(); roll!=rolls.end(); roll++) { + + vector frontDets, backDets; + + for(std::vector::iterator chamber=chambers.begin()+1; chamberposition().z() + << " R1: " << result->specificSurface().innerRadius() + << " R2: " << result->specificSurface().outerRadius(); + + return result; + +} + + +bool MuonGEMDetLayerGeometryBuilder::isFront(const GEMDetId & gemId) +{ + + bool result = false; +// int ring = gemId.ring(); +// int station = gemId.station(); + int chamber = gemId.chamber(); + +// 20 degree rings are a little weird! not anymore from 17x +// if(ring == 1 && station > 1) +// { +// result = (gemId.subsector() != 2); + if(chamber%2 == 0) result = !result; + + return result; +// } +// else +// { + // 10 degree rings have odd subsectors in front +// result = (gemId.subsector()%2 == 0); +// } +// return result; +} + +MuDetRing * MuonGEMDetLayerGeometryBuilder::makeDetRing(vector & geomDets) +{ + const std::string metname = "Muon|RecoMuon|RecoMuonDetLayers|MuonGEMDetLayerGeometryBuilder"; + + + precomputed_value_sort(geomDets.begin(), geomDets.end(), geomsort::DetPhi()); + MuDetRing * result = new MuDetRing(geomDets); + LogTrace(metname) << "New MuDetRing with " << geomDets.size() + << " chambers at z="<< result->position().z() + << " R1: " << result->specificSurface().innerRadius() + << " R2: " << result->specificSurface().outerRadius(); + return result; +} diff --git a/RecoMuon/DetLayers/src/MuonGEMDetLayerGeometryBuilder.h b/RecoMuon/DetLayers/src/MuonGEMDetLayerGeometryBuilder.h new file mode 100644 index 0000000000000..7d8dd379f8355 --- /dev/null +++ b/RecoMuon/DetLayers/src/MuonGEMDetLayerGeometryBuilder.h @@ -0,0 +1,40 @@ +#ifndef MuonGEMDetLayerGeometryBuilder_h +#define MuonGEMDetLayerGeometryBuilder_h + +/** \class MuonGEMDetLayerGeometryBuilder + * + * Build the GEM DetLayers. + * + * \author R. Radogna + */ + +class DetLayer; +class MuRingForwardDoubleLayer; +//class MuRodBarrelLayer; +class MuDetRing; + + +#include +#include "RecoMuon/DetLayers/interface/MuDetRod.h" +#include + +class MuonGEMDetLayerGeometryBuilder { + public: + /// Constructor (disabled, only static access is allowed) + MuonGEMDetLayerGeometryBuilder(){} + + /// Destructor + virtual ~MuonGEMDetLayerGeometryBuilder(); + + /// Builds the forward (+Z, return.first) and backward (-Z, return.second) layers. + /// Both vectors are sorted inside-out + static std::pair, std::vector > buildEndcapLayers(const GEMGeometry& geo); + + private: + static MuRingForwardDoubleLayer* buildLayer(int endcap,std::vector& rings, int station,int layer,std::vector& chambers,std::vector& rolls,const GEMGeometry& geo); + static bool isFront(const GEMDetId & gemId); + static MuDetRing * makeDetRing(std::vector & geomDets); + +}; +#endif + diff --git a/RecoMuon/MeasurementDet/BuildFile.xml b/RecoMuon/MeasurementDet/BuildFile.xml index c1a684be40a53..e0bebd25afc60 100644 --- a/RecoMuon/MeasurementDet/BuildFile.xml +++ b/RecoMuon/MeasurementDet/BuildFile.xml @@ -1,6 +1,7 @@ + diff --git a/RecoMuon/MeasurementDet/interface/MuonDetLayerMeasurements.h b/RecoMuon/MeasurementDet/interface/MuonDetLayerMeasurements.h index 2bef2a0dd31d0..d40568efbe377 100644 --- a/RecoMuon/MeasurementDet/interface/MuonDetLayerMeasurements.h +++ b/RecoMuon/MeasurementDet/interface/MuonDetLayerMeasurements.h @@ -4,9 +4,8 @@ /** \class MuonDetLayerMeasurements * The class to access recHits and TrajectoryMeasurements from DetLayer. * - * $Date: 2012/05/29 08:23:55 $ - * $Revision: 1.21 $ * \author C. Liu, R. Bellan, N. Amapane + * \modified by C. Calabria to include GEMs * */ @@ -20,7 +19,7 @@ #include "DataFormats/DTRecHit/interface/DTRecSegment4DCollection.h" #include "DataFormats/CSCRecHit/interface/CSCSegmentCollection.h" #include "DataFormats/RPCRecHit/interface/RPCRecHitCollection.h" -#include "DataFormats/RPCRecHit/interface/RPCRecHitCollection.h" +#include "DataFormats/GEMRecHit/interface/GEMRecHitCollection.h" #include "FWCore/Utilities/interface/InputTag.h" #include @@ -42,9 +41,11 @@ class MuonDetLayerMeasurements { MuonDetLayerMeasurements(edm::InputTag dtlabel, edm::InputTag csclabel, edm::InputTag rpclabel, + edm::InputTag gemlabel, bool enableDT = true, bool enableCSC = true, - bool enableRPC = true); + bool enableRPC = true, + bool enableGEM = true); virtual ~MuonDetLayerMeasurements(); @@ -122,24 +123,29 @@ class MuonDetLayerMeasurements { edm::InputTag theDTRecHitLabel; edm::InputTag theCSCRecHitLabel; edm::InputTag theRPCRecHitLabel; + edm::InputTag theGEMRecHitLabel; bool enableDTMeasurement; bool enableCSCMeasurement; bool enableRPCMeasurement; + bool enableGEMMeasurement; // caches that should get filled once per event edm::Handle theDTRecHits; edm::Handle theCSCRecHits; edm::Handle theRPCRecHits; + edm::Handle theGEMRecHits; void checkDTRecHits(); void checkCSCRecHits(); void checkRPCRecHits(); + void checkGEMRecHits(); // keeps track of which event the cache holds edm::EventID theDTEventID; edm::EventID theCSCEventID; edm::EventID theRPCEventID; + edm::EventID theGEMEventID; const edm::Event* theEvent; @@ -147,6 +153,7 @@ class MuonDetLayerMeasurements { std::string theDTCheckName; std::string theRPCCheckName; std::string theCSCCheckName; + std::string theGEMCheckName; }; #endif diff --git a/RecoMuon/MeasurementDet/src/MuonDetLayerMeasurements.cc b/RecoMuon/MeasurementDet/src/MuonDetLayerMeasurements.cc index ae77090a042b6..4ef051246a982 100644 --- a/RecoMuon/MeasurementDet/src/MuonDetLayerMeasurements.cc +++ b/RecoMuon/MeasurementDet/src/MuonDetLayerMeasurements.cc @@ -1,9 +1,8 @@ /** \class MuonDetLayerMeasurements * The class to access recHits and TrajectoryMeasurements from DetLayer. * - * $Date: 2010/05/12 23:01:23 $ - * $Revision: 1.31 $ * \author C. Liu, R. Bellan, N. Amapane + * \modified by C. Calabria to include GEMs * */ @@ -26,32 +25,40 @@ typedef MuonTransientTrackingRecHit::MuonRecHitContainer MuonRecHitContainer; MuonDetLayerMeasurements::MuonDetLayerMeasurements(edm::InputTag dtlabel, edm::InputTag csclabel, edm::InputTag rpclabel, - bool enableDT, bool enableCSC, bool enableRPC): + edm::InputTag gemlabel, + bool enableDT, bool enableCSC, bool enableRPC, bool enableGEM): theDTRecHitLabel(dtlabel), theCSCRecHitLabel(csclabel), theRPCRecHitLabel(rpclabel), + theGEMRecHitLabel(gemlabel), enableDTMeasurement(enableDT), enableCSCMeasurement(enableCSC), enableRPCMeasurement(enableRPC), + enableGEMMeasurement(enableGEM), theDTRecHits(), theCSCRecHits(), theRPCRecHits(), + theGEMRecHits(), theDTEventID(), theCSCEventID(), theRPCEventID(), + theGEMEventID(), theEvent(0){ - static int procInstance(0); - std::ostringstream sDT; - sDT<<"MuonDetLayerMeasurements::checkDTRecHits::" << procInstance; - theDTCheckName = sDT.str(); - std::ostringstream sRPC; - sRPC<<"MuonDetLayerMeasurements::checkRPCRecHits::" << procInstance; - theRPCCheckName = sRPC.str(); - std::ostringstream sCSC; - sCSC<<"MuonDetLayerMeasurements::checkCSCRecHits::" << procInstance; - theCSCCheckName = sCSC.str(); - procInstance++; -} + static int procInstance(0); + std::ostringstream sDT; + sDT<<"MuonDetLayerMeasurements::checkDTRecHits::" << procInstance; + theDTCheckName = sDT.str(); + std::ostringstream sRPC; + sRPC<<"MuonDetLayerMeasurements::checkRPCRecHits::" << procInstance; + theRPCCheckName = sRPC.str(); + std::ostringstream sCSC; + sCSC<<"MuonDetLayerMeasurements::checkCSCRecHits::" << procInstance; + theCSCCheckName = sCSC.str(); + std::ostringstream sGEM; + sGEM<<"MuonDetLayerMeasurements::checkGEMRecHits::" << procInstance; + theGEMCheckName = sGEM.str(); + procInstance++; + } MuonDetLayerMeasurements::~MuonDetLayerMeasurements(){} @@ -118,6 +125,24 @@ MuonRecHitContainer MuonDetLayerMeasurements::recHits(const GeomDet* geomDet, result.push_back(MuonTransientTrackingRecHit::specificBuild(geomDet,&*rechit)); } } + else if (geoId.subdetId() == MuonSubdetId::GEM) { + if(enableGEMMeasurement) + { + checkGEMRecHits(); + + // Create the chamber Id + GEMDetId chamberId(geoId.rawId()); + // LogTrace("Muon|RecoMuon|MuonDetLayerMeasurements") << "(GEM): "<get(chamberId); + + // Create the MuonTransientTrackingRecHit + for (GEMRecHitCollection::const_iterator rechit = range.first; + rechit!=range.second; ++rechit) + result.push_back(MuonTransientTrackingRecHit::specificBuild(geomDet,&*rechit)); + } + } else { // wrong type throw cms::Exception("MuonDetLayerMeasurements") << "The DetLayer with det " << geoId.det() << " subdet " << geoId.subdetId() << " is not a valid Muon DetLayer. "; @@ -174,6 +199,22 @@ void MuonDetLayerMeasurements::checkRPCRecHits() } +void MuonDetLayerMeasurements::checkGEMRecHits() +{ + checkEvent(); + if (!edm::Service()->checkOnce(theGEMCheckName)) return; + + { + theGEMEventID = theEvent->id(); + theEvent->getByLabel(theGEMRecHitLabel, theGEMRecHits); + } + if(!theGEMRecHits.isValid()) + { + throw cms::Exception("MuonDetLayerMeasurements") << "Cannot get GEM RecHits"; + } +} + + ///measurements method if already got the Event MeasurementContainer MuonDetLayerMeasurements::measurements( const DetLayer* layer, diff --git a/RecoMuon/MuonSeedGenerator/plugins/CosmicMuonSeedGenerator.cc b/RecoMuon/MuonSeedGenerator/plugins/CosmicMuonSeedGenerator.cc index 6e9b137ca95a3..ac0b612375122 100644 --- a/RecoMuon/MuonSeedGenerator/plugins/CosmicMuonSeedGenerator.cc +++ b/RecoMuon/MuonSeedGenerator/plugins/CosmicMuonSeedGenerator.cc @@ -105,8 +105,8 @@ void CosmicMuonSeedGenerator::produce(edm::Event& event, const edm::EventSetup& vector cscBackwardLayers = theMuonLayers->backwardCSCLayers(); MuonDetLayerMeasurements muonMeasurements(theDTRecSegmentLabel,theCSCRecSegmentLabel, - InputTag(), - theEnableDTFlag,theEnableCSCFlag,false); + InputTag(),InputTag(), + theEnableDTFlag,theEnableCSCFlag,false,false); muonMeasurements.setEvent(event); diff --git a/RecoMuon/MuonSeedGenerator/src/MuonSeedBuilder.cc b/RecoMuon/MuonSeedGenerator/src/MuonSeedBuilder.cc index ed587cb3058f0..4011c54d0a824 100644 --- a/RecoMuon/MuonSeedGenerator/src/MuonSeedBuilder.cc +++ b/RecoMuon/MuonSeedGenerator/src/MuonSeedBuilder.cc @@ -123,8 +123,8 @@ int MuonSeedBuilder::build( edm::Event& event, const edm::EventSetup& eventSetup std::vector nSegOnSeed; // Instantiate the accessor (get the segments: DT + CSC but not RPC=false) - MuonDetLayerMeasurements muonMeasurements(theDTSegmentLabel,theCSCSegmentLabel,edm::InputTag(), - enableDTMeasurement,enableCSCMeasurement,false); + MuonDetLayerMeasurements muonMeasurements(theDTSegmentLabel,theCSCSegmentLabel,edm::InputTag(),edm::InputTag(), + enableDTMeasurement,enableCSCMeasurement,false,false); // Instantiate the accessor (get the segments: DT + CSC but not RPC=false) // MuonDetLayerMeasurements muonMeasurements(enableDTMeasurement,enableCSCMeasurement,false, diff --git a/RecoMuon/MuonSeedGenerator/src/MuonSeedOrcaPatternRecognition.cc b/RecoMuon/MuonSeedGenerator/src/MuonSeedOrcaPatternRecognition.cc index 817dd612281bd..8dad742ca31ff 100644 --- a/RecoMuon/MuonSeedGenerator/src/MuonSeedOrcaPatternRecognition.cc +++ b/RecoMuon/MuonSeedGenerator/src/MuonSeedOrcaPatternRecognition.cc @@ -95,8 +95,8 @@ void MuonSeedOrcaPatternRecognition::produce(const edm::Event& event, const edm: // instantiate the accessor // Don not use RPC for seeding - MuonDetLayerMeasurements muonMeasurements(theDTRecSegmentLabel.label(),theCSCRecSegmentLabel,edm::InputTag(), - enableDTMeasurement,enableCSCMeasurement,false); + MuonDetLayerMeasurements muonMeasurements(theDTRecSegmentLabel.label(),theCSCRecSegmentLabel,edm::InputTag(),edm::InputTag(), + enableDTMeasurement,enableCSCMeasurement,false,false); double barreldThetaCut = 0.2; // still lose good muons to a tighter cut double endcapdThetaCut = 1.0; diff --git a/RecoMuon/MuonSeedGenerator/src/RPCSeedGenerator.cc b/RecoMuon/MuonSeedGenerator/src/RPCSeedGenerator.cc index 19d5d0a59c083..b6f9e8bdeee6b 100644 --- a/RecoMuon/MuonSeedGenerator/src/RPCSeedGenerator.cc +++ b/RecoMuon/MuonSeedGenerator/src/RPCSeedGenerator.cc @@ -208,7 +208,7 @@ RPCSeedGenerator::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) const DetLayer* REP3L = RPCEndcapLayers[5]; // Get RPC recHits by MuonDetLayerMeasurements, while CSC and DT is set to false and with empty InputTag - MuonDetLayerMeasurements muonMeasurements(edm::InputTag(), edm::InputTag(), theRPCRecHits, false, false, true); + MuonDetLayerMeasurements muonMeasurements(edm::InputTag(), edm::InputTag(), theRPCRecHits, edm::InputTag(), false, false, true, false); // Dispatch RPC recHits to the corresponding DetLayer, 6 layers for barrel and 3 layers for each endcap MuonRecHitContainer recHitsRPC[RPCLayerNumber]; diff --git a/RecoMuon/Navigation/interface/MuonNavigationPrinter.h b/RecoMuon/Navigation/interface/MuonNavigationPrinter.h index f10f1a6cf8543..8f50f7a2b46ae 100644 --- a/RecoMuon/Navigation/interface/MuonNavigationPrinter.h +++ b/RecoMuon/Navigation/interface/MuonNavigationPrinter.h @@ -16,6 +16,9 @@ * Chang Liu: * The class prints nextLayers and compatibleLayers * Add new constructor for MuonTkNavigationSchool + * + * Cesare Calabria: + * GEMs implementation. */ class DetLayer; @@ -27,7 +30,7 @@ class GeometricSearchTracker; class MuonNavigationPrinter { public: - MuonNavigationPrinter(const MuonDetLayerGeometry *, bool enableRPC = true ); + MuonNavigationPrinter(const MuonDetLayerGeometry *, bool enableRPC = true, bool enableCSC = true, bool enableGEM = true ); MuonNavigationPrinter(const MuonDetLayerGeometry *,const GeometricSearchTracker *); private: @@ -40,3 +43,4 @@ class MuonNavigationPrinter { }; #endif + diff --git a/RecoMuon/Navigation/interface/MuonNavigationSchool.h b/RecoMuon/Navigation/interface/MuonNavigationSchool.h index 4858b47a922ce..34fc2af2b1b58 100644 --- a/RecoMuon/Navigation/interface/MuonNavigationSchool.h +++ b/RecoMuon/Navigation/interface/MuonNavigationSchool.h @@ -18,6 +18,8 @@ * Chang Liu: * The class links maps for nextLayers and compatibleLayers in the same time. * + * Cesare Calabria: + * GEMs implementation. */ @@ -37,7 +39,7 @@ class MuonNavigationSchool : public NavigationSchool { public: ///Constructor - MuonNavigationSchool(const MuonDetLayerGeometry *, bool enableRPC = true); + MuonNavigationSchool(const MuonDetLayerGeometry *, bool enableRPC = true, bool enableCSC = true, bool enableGEM = true); /// Destructor ~MuonNavigationSchool(); /// return navigable layers, from base class diff --git a/RecoMuon/Navigation/src/MuonNavigationPrinter.cc b/RecoMuon/Navigation/src/MuonNavigationPrinter.cc index 37993842fe29c..4b374117b32da 100644 --- a/RecoMuon/Navigation/src/MuonNavigationPrinter.cc +++ b/RecoMuon/Navigation/src/MuonNavigationPrinter.cc @@ -13,6 +13,9 @@ * Chang Liu: * add compatibleLayers * add constructor for MuonTkNavigation + * + * Cesare Calabria: + * GEMs implementation. */ #include "RecoMuon/Navigation/interface/MuonNavigationPrinter.h" @@ -30,7 +33,7 @@ #include using namespace std; -MuonNavigationPrinter::MuonNavigationPrinter(const MuonDetLayerGeometry * muonLayout, bool enableRPC) { +MuonNavigationPrinter::MuonNavigationPrinter(const MuonDetLayerGeometry * muonLayout, bool enableCSC, bool enableRPC, bool enableGEM) { edm::LogInfo ("MuonNavigationPrinter")<< "MuonNavigationPrinter::MuonNavigationPrinter" ; vector::const_iterator iter; @@ -46,7 +49,10 @@ MuonNavigationPrinter::MuonNavigationPrinter(const MuonDetLayerGeometry * muonLa edm::LogInfo ("MuonNavigationPrinter") << "BACKWARD:"; vector backward; - if ( enableRPC ) backward = muonLayout->allBackwardLayers(); + if ( enableCSC & enableGEM & enableRPC ) backward = muonLayout->allBackwardLayers(); + else if ( enableCSC & enableGEM & !enableRPC ) backward = muonLayout->allCscGemBackwardLayers(); // CSC + GEM + else if ( !enableCSC & enableGEM & !enableRPC ) backward = muonLayout->backwardGEMLayers(); //GEM only + else if ( enableCSC & !enableGEM & !enableRPC ) backward = muonLayout->backwardCSCLayers(); //CSC only else backward = muonLayout->backwardCSCLayers(); edm::LogInfo ("MuonNavigationPrinter")<<"There are "< forward; - if ( enableRPC ) forward = muonLayout->allForwardLayers(); + if ( enableCSC & enableGEM & enableRPC ) forward = muonLayout->allForwardLayers(); + else if ( enableCSC & enableGEM & !enableRPC ) forward = muonLayout->allCscGemForwardLayers(); // CSC + GEM + else if ( !enableCSC & enableGEM & !enableRPC ) forward = muonLayout->forwardGEMLayers(); //GEM only + else if ( enableCSC & !enableGEM & !enableRPC ) forward = muonLayout->forwardCSCLayers(); //CSC only else forward = muonLayout->forwardCSCLayers(); edm::LogInfo ("MuonNavigationPrinter")<<"There are "<allLayers(); @@ -52,10 +54,13 @@ MuonNavigationSchool::MuonNavigationSchool(const MuonDetLayerGeometry * muonLayo addBarrelLayer(mbp); } - // get all endcap DetLayers (CSC + optional RPC) + // get all endcap DetLayers (CSC + optional RPC, GEM) vector endcap; - if ( enableRPC ) endcap = muonLayout->allEndcapLayers(); - else endcap = muonLayout->allCSCLayers(); + if ( enableCSC & enableGEM & enableRPC ) endcap = muonLayout->allEndcapLayers(); //CSC + RPC + GEM + else if ( enableCSC & enableGEM & !enableRPC ) endcap = muonLayout->allEndcapCscGemLayers(); // CSC + GEM + else if ( !enableCSC & enableGEM & !enableRPC ) endcap = muonLayout->allGEMLayers(); //GEM only + else if ( enableCSC & !enableGEM & !enableRPC ) endcap = muonLayout->allCSCLayers(); //CSC only + else endcap = muonLayout->allCSCLayers(); //CSC only for all the remaining cases for ( vector::const_iterator i = endcap.begin(); i != endcap.end(); i++ ) { ForwardDetLayer* mep = dynamic_cast(*i); @@ -376,3 +381,4 @@ void MuonNavigationSchool::createInverseLinks() const { } } + diff --git a/RecoMuon/StandAloneTrackFinder/interface/StandAloneMuonFilter.h b/RecoMuon/StandAloneTrackFinder/interface/StandAloneMuonFilter.h index 95c336a9a6a46..866d28dbc5399 100644 --- a/RecoMuon/StandAloneTrackFinder/interface/StandAloneMuonFilter.h +++ b/RecoMuon/StandAloneTrackFinder/interface/StandAloneMuonFilter.h @@ -8,6 +8,8 @@ * $Revision: 1.4 $ * \author R. Bellan - INFN Torino * D. Trocino - INFN Torino + * + * Modified by C. Calabria */ #include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h" @@ -65,18 +67,21 @@ class StandAloneMuonFilter { int getDTChamberUsed() const {return dtChambers;} int getCSCChamberUsed() const {return cscChambers;} int getRPCChamberUsed() const {return rpcChambers;} + int getGEMChamberUsed() const {return gemChambers;} int getTotalCompatibleChambers() const {return totalCompatibleChambers;} int getDTCompatibleChambers() const {return dtCompatibleChambers;} int getCSCCompatibleChambers() const {return cscCompatibleChambers;} int getRPCCompatibleChambers() const {return rpcCompatibleChambers;} + int getGEMCompatibleChambers() const {return gemCompatibleChambers;} + inline bool goodState() const {return totalChambers >= 2 && - ((dtChambers + cscChambers) >0 || + ((dtChambers + cscChambers + gemChambers) >0 || onlyRPC());} inline bool isCompatibilitySatisfied() const {return totalCompatibleChambers >= 2 && - ((dtCompatibleChambers + cscCompatibleChambers) >0 || + ((dtCompatibleChambers + cscCompatibleChambers + gemCompatibleChambers) >0 || onlyRPC());} /// return the layer used for the refit @@ -184,11 +189,13 @@ class StandAloneMuonFilter { int dtChambers; int cscChambers; int rpcChambers; + int gemChambers; int totalCompatibleChambers; int dtCompatibleChambers; int cscCompatibleChambers; int rpcCompatibleChambers; + int gemCompatibleChambers; const MuonServiceProxy *theService; bool theOverlappingChambersFlag; diff --git a/RecoMuon/StandAloneTrackFinder/src/StandAloneMuonFilter.cc b/RecoMuon/StandAloneTrackFinder/src/StandAloneMuonFilter.cc index 659c22a9b5b1f..0b4205f516ac5 100644 --- a/RecoMuon/StandAloneTrackFinder/src/StandAloneMuonFilter.cc +++ b/RecoMuon/StandAloneTrackFinder/src/StandAloneMuonFilter.cc @@ -5,6 +5,8 @@ * $Revision: 1.10 $ * \author R. Bellan - INFN Torino * D. Trocino - INFN Torino + * + * Modified by C. Calabria */ #include "RecoMuon/StandAloneTrackFinder/interface/StandAloneMuonFilter.h" @@ -88,13 +90,16 @@ StandAloneMuonFilter::StandAloneMuonFilter(const ParameterSet& par, bool enableDTMeasurement = par.getParameter("EnableDTMeasurement"); bool enableCSCMeasurement = par.getParameter("EnableCSCMeasurement"); bool enableRPCMeasurement = par.getParameter("EnableRPCMeasurement"); + bool enableGEMMeasurement = par.getParameter("EnableGEMMeasurement"); theMeasurementExtractor = new MuonDetLayerMeasurements(par.getParameter("DTRecSegmentLabel"), par.getParameter("CSCRecSegmentLabel"), par.getParameter("RPCRecSegmentLabel"), + par.getParameter("GEMRecSegmentLabel"), enableDTMeasurement, enableCSCMeasurement, - enableRPCMeasurement); + enableRPCMeasurement, + enableGEMMeasurement); theRPCLoneliness = (!(enableDTMeasurement && enableCSCMeasurement)) ? enableRPCMeasurement : false; } @@ -123,8 +128,8 @@ PropagationDirection StandAloneMuonFilter::propagationDirection() const{ void StandAloneMuonFilter::reset(){ - totalChambers = dtChambers = cscChambers = rpcChambers = 0; - totalCompatibleChambers = dtCompatibleChambers = cscCompatibleChambers = rpcCompatibleChambers = 0; + totalChambers = dtChambers = cscChambers = rpcChambers = gemChambers = 0; + totalCompatibleChambers = dtCompatibleChambers = cscCompatibleChambers = rpcCompatibleChambers = gemCompatibleChambers = 0; theLastCompatibleTSOS = theLastUpdatedTSOS = theLastButOneUpdatedTSOS = TrajectoryStateOnSurface(); @@ -143,6 +148,7 @@ void StandAloneMuonFilter::incrementChamberCounters(const DetLayer *layer){ if(layer->subDetector()==GeomDetEnumerators::DT) dtChambers++; else if(layer->subDetector()==GeomDetEnumerators::CSC) cscChambers++; else if(layer->subDetector()==GeomDetEnumerators::RPCBarrel || layer->subDetector()==GeomDetEnumerators::RPCEndcap) rpcChambers++; + else if(layer->subDetector()==GeomDetEnumerators::GEM) gemChambers++; else LogError("Muon|RecoMuon|StandAloneMuonFilter") << "Unrecognized module type in incrementChamberCounters"; @@ -157,6 +163,7 @@ void StandAloneMuonFilter::incrementCompatibleChamberCounters(const DetLayer *la if(layer->subDetector()==GeomDetEnumerators::DT) dtCompatibleChambers++; else if(layer->subDetector()==GeomDetEnumerators::CSC) cscCompatibleChambers++; else if(layer->subDetector()==GeomDetEnumerators::RPCBarrel || layer->subDetector()==GeomDetEnumerators::RPCEndcap) rpcCompatibleChambers++; + else if(layer->subDetector()==GeomDetEnumerators::GEM) gemCompatibleChambers++; else LogError("Muon|RecoMuon|StandAloneMuonFilter") << "Unrecognized module type in incrementCompatibleChamberCounters"; @@ -164,7 +171,6 @@ void StandAloneMuonFilter::incrementCompatibleChamberCounters(const DetLayer *la totalCompatibleChambers++; } - vector StandAloneMuonFilter::compatibleLayers(const DetLayer *initialLayer, FreeTrajectoryState& fts, PropagationDirection propDir){ diff --git a/RecoMuon/StandAloneTrackFinder/src/StandAloneTrajectoryBuilder.cc b/RecoMuon/StandAloneTrackFinder/src/StandAloneTrajectoryBuilder.cc index 2cd45947e016b..d2e88de9fd7a4 100644 --- a/RecoMuon/StandAloneTrackFinder/src/StandAloneTrajectoryBuilder.cc +++ b/RecoMuon/StandAloneTrackFinder/src/StandAloneTrajectoryBuilder.cc @@ -6,6 +6,8 @@ * \author R. Bellan - INFN Torino * \author Stefano Lacaprara - INFN Legnaro * \author D. Trocino - INFN Torino + * + * Modified by C. Calabria */ #include "RecoMuon/StandAloneTrackFinder/interface/StandAloneTrajectoryBuilder.h" @@ -233,15 +235,17 @@ StandAloneMuonTrajectoryBuilder::trajectories(const TrajectorySeed& seed){ LogTrace(metname) << "Compatibility NOT satisfied after Forward filter! No trajectory will be loaded!" << endl; LogTrace(metname) << "Total compatible chambers: " << filter()->getTotalCompatibleChambers() << "; DT: " << filter()->getDTCompatibleChambers() << "; CSC: " << filter()->getCSCCompatibleChambers() - << "; RPC: " << filter()->getRPCCompatibleChambers() << endl; + << "; RPC: " << filter()->getRPCCompatibleChambers() + << "; GEM: " << filter()->getGEMCompatibleChambers() << endl; return trajectoryContainer; } // -- end 2nd attempt - LogTrace(metname) << "Number of DT/CSC/RPC chamber used (fw): " + LogTrace(metname) << "Number of DT/CSC/RPC/GEM chamber used (fw): " << filter()->getDTChamberUsed() << "/" << filter()->getCSCChamberUsed() << "/" - << filter()->getRPCChamberUsed() <getRPCChamberUsed() << "/" + << filter()->getGEMChamberUsed() <momentum(); @@ -309,10 +313,11 @@ StandAloneMuonTrajectoryBuilder::trajectories(const TrajectorySeed& seed){ LogTrace(metname) << "Number of RecHits: " << trajectoryBW.foundHits() << "\n" - << "Number of DT/CSC/RPC chamber used (bw): " + << "Number of DT/CSC/RPC/GEM chamber used (bw): " << bwfilter()->getDTChamberUsed() << "/" << bwfilter()->getCSCChamberUsed() << "/" - << bwfilter()->getRPCChamberUsed(); + << bwfilter()->getRPCChamberUsed() << "/" + << bwfilter()->getGEMChamberUsed(); // -- The trajectory is "good" if there are at least 2 chambers used in total and at // least 1 is "tracking" (DT or CSC) diff --git a/RecoMuon/TrackingTools/interface/MuonServiceProxy.h b/RecoMuon/TrackingTools/interface/MuonServiceProxy.h index 885b9206bd1fa..510bdb5b1b712 100644 --- a/RecoMuon/TrackingTools/interface/MuonServiceProxy.h +++ b/RecoMuon/TrackingTools/interface/MuonServiceProxy.h @@ -11,6 +11,8 @@ * $Revision: 1.10 $ * \author N. Amapane - CERN * \author R. Bellan - INFN Torino + * + * Modified by C. Calabria */ #include "FWCore/Framework/interface/ESHandle.h" @@ -69,6 +71,8 @@ class MuonServiceProxy { const edm::EventSetup *theEventSetup; bool theMuonNavigationFlag; bool theRPCLayer; + bool theCSCLayer; + bool theGEMLayer; const MuonNavigationSchool* theSchool; propagators thePropagators; diff --git a/RecoMuon/TrackingTools/python/MuonServiceProxy_cff.py b/RecoMuon/TrackingTools/python/MuonServiceProxy_cff.py index e65298bac9b67..8106d6100323c 100644 --- a/RecoMuon/TrackingTools/python/MuonServiceProxy_cff.py +++ b/RecoMuon/TrackingTools/python/MuonServiceProxy_cff.py @@ -37,6 +37,8 @@ 'SmartPropagatorAnyRK', 'StraightLinePropagator'), RPCLayers = cms.bool(True), + CSCLayers = cms.untracked.bool(True), + GEMLayers = cms.untracked.bool(True), UseMuonNavigation = cms.untracked.bool(True) ) ) diff --git a/RecoMuon/TrackingTools/src/MuonPatternRecoDumper.cc b/RecoMuon/TrackingTools/src/MuonPatternRecoDumper.cc index 1af915baef83d..6a8b86c4c5fd0 100644 --- a/RecoMuon/TrackingTools/src/MuonPatternRecoDumper.cc +++ b/RecoMuon/TrackingTools/src/MuonPatternRecoDumper.cc @@ -12,6 +12,7 @@ #include "DataFormats/MuonDetId/interface/DTWireId.h" #include "DataFormats/MuonDetId/interface/CSCDetId.h" #include "DataFormats/MuonDetId/interface/RPCDetId.h" +#include "DataFormats/MuonDetId/interface/GEMDetId.h" #include @@ -79,6 +80,10 @@ string MuonPatternRecoDumper::dumpMuonId(const DetId &id) const{ CSCDetId chamberId(id.rawId()); output<<"(CSC): "< * \author R. Bellan - INFN Torino + * + * Modified by C. Calabria */ // Class Header @@ -41,8 +43,16 @@ MuonServiceProxy::MuonServiceProxy(const edm::ParameterSet& par):theTrackingGeom vector propagatorNames; theMuonNavigationFlag = par.getUntrackedParameter("UseMuonNavigation",true); - if(theMuonNavigationFlag) theRPCLayer = par.getParameter("RPCLayers"); - else theRPCLayer = true; + if(theMuonNavigationFlag) { + theRPCLayer = par.getParameter("RPCLayers"); + theCSCLayer = par.getUntrackedParameter("CSCLayers",true); + theGEMLayer = par.getUntrackedParameter("GEMLayers",false); + } + else { + theRPCLayer = true; + theCSCLayer = true; + theGEMLayer = true; + } propagatorNames = par.getUntrackedParameter >("Propagators", noPropagators); @@ -109,7 +119,7 @@ void MuonServiceProxy::update(const edm::EventSetup& setup){ // the NavigableLayers (this is implemented in MuonNavigationSchool's dtor) if ( theMuonNavigationFlag ) { if(theSchool) delete theSchool; - theSchool = new MuonNavigationSchool(&*theDetLayerGeometry,theRPCLayer); + theSchool = new MuonNavigationSchool(&*theDetLayerGeometry,theRPCLayer,theCSCLayer,theGEMLayer); } } diff --git a/RecoMuon/TrackingTools/src/MuonTrajectoryUpdator.cc b/RecoMuon/TrackingTools/src/MuonTrajectoryUpdator.cc index 2fec8694f4cc2..057e076ce1b6e 100644 --- a/RecoMuon/TrackingTools/src/MuonTrajectoryUpdator.cc +++ b/RecoMuon/TrackingTools/src/MuonTrajectoryUpdator.cc @@ -11,6 +11,8 @@ * $Revision: 1.38 $ * \author R. Bellan - INFN Torino * \author S. Lacaprara - INFN Legnaro + * + * Modified by C. Calabria: GEM Implementation */ @@ -271,4 +273,13 @@ void MuonTrajectoryUpdator::sort(TransientTrackingRecHit::ConstRecHitContainer& else LogError("Muon|RecoMuon|MuonTrajectoryUpdator") <<"MuonTrajectoryUpdator::sort: Wrong propagation direction!!"; } + + else if(detLayer->subDetector()==GeomDetEnumerators::GEM){ + if(fitDirection() == insideOut) + stable_sort(recHitsForFit.begin(),recHitsForFit.end(), ZedComparatorInOut() ); + else if(fitDirection() == outsideIn) + stable_sort(recHitsForFit.begin(),recHitsForFit.end(), ZedComparatorOutIn() ); + else + LogError("Muon|RecoMuon|MuonTrajectoryUpdator") <<"MuonTrajectoryUpdator::sort: Wrong propagation direction!!"; + } } From c552b225c5e844f8ee2c535be99865417baa06c3 Mon Sep 17 00:00:00 2001 From: Cesare Date: Wed, 29 Jan 2014 02:59:16 +0100 Subject: [PATCH 3/6] Files for the reconstruction with GEMs --- RecoMuon/StandAloneMuonProducer/python/standAloneMuons_cfi.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/RecoMuon/StandAloneMuonProducer/python/standAloneMuons_cfi.py b/RecoMuon/StandAloneMuonProducer/python/standAloneMuons_cfi.py index 98a9eca0ac9fe..5f4601432c699 100644 --- a/RecoMuon/StandAloneMuonProducer/python/standAloneMuons_cfi.py +++ b/RecoMuon/StandAloneMuonProducer/python/standAloneMuons_cfi.py @@ -34,6 +34,8 @@ CSCRecSegmentLabel = cms.InputTag("cscSegments"), EnableRPCMeasurement = cms.bool(True), RPCRecSegmentLabel = cms.InputTag("rpcRecHits"), + EnableGEMMeasurement = cms.bool(False), + GEMRecSegmentLabel = cms.InputTag("gemRecHits"), NumberOfSigma = cms.double(3.0), MaxChi2 = cms.double(1000.0), Propagator = cms.string('SteppingHelixPropagatorAny'), @@ -56,6 +58,8 @@ CSCRecSegmentLabel = cms.InputTag("cscSegments"), EnableRPCMeasurement = cms.bool(True), RPCRecSegmentLabel = cms.InputTag("rpcRecHits"), + EnableGEMMeasurement = cms.bool(False), + GEMRecSegmentLabel = cms.InputTag("gemRecHits"), NumberOfSigma = cms.double(3.0), MaxChi2 = cms.double(100.0), Propagator = cms.string('SteppingHelixPropagatorAny'), From 32f47b21873278572b721e6f7de19ffa7caa1d0c Mon Sep 17 00:00:00 2001 From: Cesare Date: Wed, 29 Jan 2014 17:56:44 +0100 Subject: [PATCH 4/6] Files for the reconstruction with GEMs --- .gitmodules | 3 +++ GEMCode | 1 + SLHCUpgradeSimulations/Configuration/python/gemCustoms.py | 3 ++- 3 files changed, 6 insertions(+), 1 deletion(-) create mode 100644 .gitmodules create mode 160000 GEMCode diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000000000..11629cb71d07e --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "GEMCode"] + path = GEMCode + url = git://github.com/gem-sw/GEMCode.git diff --git a/GEMCode b/GEMCode new file mode 160000 index 0000000000000..3c2568a214b6b --- /dev/null +++ b/GEMCode @@ -0,0 +1 @@ +Subproject commit 3c2568a214b6b0e5fb5f800f1847c47b47ce1422 diff --git a/SLHCUpgradeSimulations/Configuration/python/gemCustoms.py b/SLHCUpgradeSimulations/Configuration/python/gemCustoms.py index 62cc89a9fbe48..15649d65be5df 100644 --- a/SLHCUpgradeSimulations/Configuration/python/gemCustoms.py +++ b/SLHCUpgradeSimulations/Configuration/python/gemCustoms.py @@ -62,8 +62,9 @@ def customise_Reco(process): process.load('RecoLocalMuon.GEMRecHit.gemRecHits_cfi') process.gemRecHits.gemDigiLabel = cms.InputTag("simMuonGEMDigis") process.muonlocalreco += process.gemRecHits - process=outputCustoms(process) + process.standAloneMuons.STATrajBuilderParameters.EnableGEMMeasurement = cms.bool(True) + process.standAloneMuons.STATrajBuilderParameters.BWFilterParameters.EnableGEMMeasurement = cms.bool(True) return process def customise_DQM(process): From 1c04e05052e00fa27dff016fa7a3a19bc13c6ccc Mon Sep 17 00:00:00 2001 From: Cesare Date: Wed, 29 Jan 2014 18:33:03 +0100 Subject: [PATCH 5/6] Files for the reconstruction with GEMs --- GEMCode | 1 - 1 file changed, 1 deletion(-) delete mode 160000 GEMCode diff --git a/GEMCode b/GEMCode deleted file mode 160000 index 3c2568a214b6b..0000000000000 --- a/GEMCode +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 3c2568a214b6b0e5fb5f800f1847c47b47ce1422 From 59051c0a728f340ec7c68d8baf462d160a99e01f Mon Sep 17 00:00:00 2001 From: Cesare Date: Wed, 29 Jan 2014 20:28:17 +0100 Subject: [PATCH 6/6] Files for the reconstruction with GEMs --- .gitmodules | 3 --- 1 file changed, 3 deletions(-) delete mode 100644 .gitmodules diff --git a/.gitmodules b/.gitmodules deleted file mode 100644 index 11629cb71d07e..0000000000000 --- a/.gitmodules +++ /dev/null @@ -1,3 +0,0 @@ -[submodule "GEMCode"] - path = GEMCode - url = git://github.com/gem-sw/GEMCode.git