File indexing completed on 2024-09-11 04:33:27
0001 #include "Validation/MuonIdentification/interface/MuonIdVal.h"
0002
0003 MuonIdVal::MuonIdVal(const edm::ParameterSet &ps)
0004 : trackingGeomToken_(esConsumes<GlobalTrackingGeometry, GlobalTrackingGeometryRecord>()) {
0005 iConfig = ps;
0006 inputMuonCollection_ = iConfig.getParameter<edm::InputTag>("inputMuonCollection");
0007 inputDTRecSegment4DCollection_ = iConfig.getParameter<edm::InputTag>("inputDTRecSegment4DCollection");
0008 inputCSCSegmentCollection_ = iConfig.getParameter<edm::InputTag>("inputCSCSegmentCollection");
0009 inputMuonTimeExtraValueMap_ = iConfig.getParameter<edm::InputTag>("inputMuonTimeExtraValueMap");
0010 inputMuonCosmicCompatibilityValueMap_ = iConfig.getParameter<edm::InputTag>("inputMuonCosmicCompatibilityValueMap");
0011 inputMuonShowerInformationValueMap_ = iConfig.getParameter<edm::InputTag>("inputMuonShowerInformationValueMap");
0012 useTrackerMuons_ = iConfig.getUntrackedParameter<bool>("useTrackerMuons");
0013 useGlobalMuons_ = iConfig.getUntrackedParameter<bool>("useGlobalMuons");
0014 useTrackerMuonsNotGlobalMuons_ = iConfig.getUntrackedParameter<bool>("useTrackerMuonsNotGlobalMuons");
0015 useGlobalMuonsNotTrackerMuons_ = iConfig.getUntrackedParameter<bool>("useGlobalMuonsNotTrackerMuons");
0016 makeEnergyPlots_ = iConfig.getUntrackedParameter<bool>("makeEnergyPlots");
0017 makeTimePlots_ = iConfig.getUntrackedParameter<bool>("makeTimePlots");
0018 make2DPlots_ = iConfig.getUntrackedParameter<bool>("make2DPlots");
0019 makeAllChamberPlots_ = iConfig.getUntrackedParameter<bool>("makeAllChamberPlots");
0020 makeCosmicCompatibilityPlots_ = iConfig.getUntrackedParameter<bool>("makeCosmicCompatibilityPlots");
0021 makeShowerInformationPlots_ = iConfig.getUntrackedParameter<bool>("makeShowerInformationPlots");
0022 baseFolder_ = iConfig.getUntrackedParameter<std::string>("baseFolder");
0023
0024 inputMuonCollectionToken_ = consumes<reco::MuonCollection>(inputMuonCollection_);
0025 inputDTRecSegment4DCollectionToken_ = consumes<DTRecSegment4DCollection>(inputDTRecSegment4DCollection_);
0026 inputCSCSegmentCollectionToken_ = consumes<CSCSegmentCollection>(inputCSCSegmentCollection_);
0027 inputMuonTimeExtraValueMapCombToken_ =
0028 consumes<reco::MuonTimeExtraMap>(edm::InputTag(inputMuonTimeExtraValueMap_.label(), "combined"));
0029 inputMuonTimeExtraValueMapDTToken_ =
0030 consumes<reco::MuonTimeExtraMap>(edm::InputTag(inputMuonTimeExtraValueMap_.label(), "csc"));
0031 inputMuonTimeExtraValueMapCSCToken_ =
0032 consumes<reco::MuonTimeExtraMap>(edm::InputTag(inputMuonTimeExtraValueMap_.label(), "dt"));
0033 inputMuonCosmicCompatibilityValueMapToken_ =
0034 consumes<edm::ValueMap<reco::MuonCosmicCompatibility>>(inputMuonCosmicCompatibilityValueMap_);
0035 inputMuonShowerInformationValueMapToken_ =
0036 consumes<edm::ValueMap<reco::MuonShower>>(inputMuonShowerInformationValueMap_);
0037
0038 subsystemname_ = iConfig.getUntrackedParameter<std::string>("subSystemFolder", "YourSubsystem");
0039 }
0040
0041 MuonIdVal::~MuonIdVal() {}
0042
0043 void MuonIdVal::bookHistograms(DQMStore::IBooker &ibooker, const edm::Run &, const edm::EventSetup &) {
0044 char name[100], title[200];
0045 ibooker.setCurrentFolder(baseFolder_);
0046
0047
0048
0049 for (unsigned int i = 0; i < 4; i++) {
0050 if ((i == 0 && !useTrackerMuons_) || (i == 1 && !useGlobalMuons_))
0051 continue;
0052 if ((i == 2 && !useTrackerMuonsNotGlobalMuons_) || (i == 3 && !useGlobalMuonsNotTrackerMuons_))
0053 continue;
0054 if (i == 0)
0055 ibooker.setCurrentFolder(baseFolder_ + "/TrackerMuons");
0056 if (i == 1)
0057 ibooker.setCurrentFolder(baseFolder_ + "/GlobalMuons");
0058 if (i == 2)
0059 ibooker.setCurrentFolder(baseFolder_ + "/TrackerMuonsNotGlobalMuons");
0060 if (i == 3)
0061 ibooker.setCurrentFolder(baseFolder_ + "/GlobalMuonsNotTrackerMuons");
0062
0063 if (makeEnergyPlots_) {
0064 hEnergyEMBarrel[i] = ibooker.book1D("hEnergyEMBarrel", "Energy in ECAL Barrel", 100, -0.5, 2.);
0065 hEnergyHABarrel[i] = ibooker.book1D("hEnergyHABarrel", "Energy in HCAL Barrel", 100, -4., 12.);
0066 hEnergyHO[i] = ibooker.book1D("hEnergyHO", "Energy HO", 100, -2., 5.);
0067 hEnergyEMEndcap[i] = ibooker.book1D("hEnergyEMEndcap", "Energy in ECAL Endcap", 100, -0.5, 2.);
0068 hEnergyHAEndcap[i] = ibooker.book1D("hEnergyHAEndcap", "Energy in HCAL Endcap", 100, -4., 12.);
0069 }
0070
0071 if (makeTimePlots_) {
0072 hMuonTimeNDOF[i] = ibooker.book1D("hMuonTimeNDOF", "MuonTime NDOF", 52, -1.5, 50.5);
0073 hMuonTimeTimeAtIpInOut[i] = ibooker.book1D("hMuonTimeTimeAtIpInOut", "MuonTime TimeAtIpInOut", 100, -20., 20.);
0074 hMuonTimeTimeAtIpInOutErr[i] =
0075 ibooker.book1D("hMuonTimeTimeAtIpInOutErr", "MuonTime TimeAtIpInOutErr", 100, 0., 8.);
0076 hMuonTimeTimeAtIpOutIn[i] = ibooker.book1D("hMuonTimeTimeAtIpOutIn", "MuonTime TimeAtIpOutIn", 100, -1., 75.);
0077 hMuonTimeTimeAtIpOutInErr[i] =
0078 ibooker.book1D("hMuonTimeTimeAtIpOutInErr", "MuonTime TimeAtIpOutInErr", 100, 0., 8.);
0079 hMuonTimeExtraCombinedNDOF[i] =
0080 ibooker.book1D("hMuonTimeExtraCombinedNDOF", "MuonTimeExtra Combined NDOF", 52, -1.5, 50.5);
0081 hMuonTimeExtraCombinedTimeAtIpInOut[i] =
0082 ibooker.book1D("hMuonTimeExtraCombinedTimeAtIpInOut", "MuonTimeExtra Combined TimeAtIpInOut", 100, -20., 20.);
0083 hMuonTimeExtraCombinedTimeAtIpInOutErr[i] = ibooker.book1D(
0084 "hMuonTimeExtraCombinedTimeAtIpInOutErr", "MuonTimeExtra Combined TimeAtIpInOutErr", 100, 0., 8.);
0085 hMuonTimeExtraCombinedTimeAtIpOutIn[i] =
0086 ibooker.book1D("hMuonTimeExtraCombinedTimeAtIpOutIn", "MuonTimeExtra Combined TimeAtIpOutIn", 100, -1., 75.);
0087 hMuonTimeExtraCombinedTimeAtIpOutInErr[i] = ibooker.book1D(
0088 "hMuonTimeExtraCombinedTimeAtIpOutInErr", "MuonTimeExtra Combined TimeAtIpOutInErr", 100, 0., 8.);
0089 hMuonTimeExtraCSCNDOF[i] = ibooker.book1D("hMuonTimeExtraCSCNDOF", "MuonTimeExtra CSC NDOF", 52, -1.5, 50.5);
0090 hMuonTimeExtraCSCTimeAtIpInOut[i] =
0091 ibooker.book1D("hMuonTimeExtraCSCTimeAtIpInOut", "MuonTimeExtra CSC TimeAtIpInOut", 100, -20., 20.);
0092 hMuonTimeExtraCSCTimeAtIpInOutErr[i] =
0093 ibooker.book1D("hMuonTimeExtraCSCTimeAtIpInOutErr", "MuonTimeExtra CSC TimeAtIpInOutErr", 100, 0., 8.);
0094 hMuonTimeExtraCSCTimeAtIpOutIn[i] =
0095 ibooker.book1D("hMuonTimeExtraCSCTimeAtIpOutIn", "MuonTimeExtra CSC TimeAtIpOutIn", 100, -1., 75.);
0096 hMuonTimeExtraCSCTimeAtIpOutInErr[i] =
0097 ibooker.book1D("hMuonTimeExtraCSCTimeAtIpOutInErr", "MuonTimeExtra CSC TimeAtIpOutInErr", 100, 0., 8.);
0098 hMuonTimeExtraDTNDOF[i] = ibooker.book1D("hMuonTimeExtraDTNDOF", "MuonTimeExtra DT NDOF", 52, -1.5, 50.5);
0099 hMuonTimeExtraDTTimeAtIpInOut[i] =
0100 ibooker.book1D("hMuonTimeExtraDTTimeAtIpInOut", "MuonTimeExtra DT TimeAtIpInOut", 100, -20., 20.);
0101 hMuonTimeExtraDTTimeAtIpInOutErr[i] =
0102 ibooker.book1D("hMuonTimeExtraDTTimeAtIpInOutErr", "MuonTimeExtra DT TimeAtIpInOutErr", 100, 0., 8.);
0103 hMuonTimeExtraDTTimeAtIpOutIn[i] =
0104 ibooker.book1D("hMuonTimeExtraDTTimeAtIpOutIn", "MuonTimeExtra DT TimeAtIpOutIn", 100, -1., 75.);
0105 hMuonTimeExtraDTTimeAtIpOutInErr[i] =
0106 ibooker.book1D("hMuonTimeExtraDTTimeAtIpOutInErr", "MuonTimeExtra DT TimeAtIpOutInErr", 100, 0., 8.);
0107 }
0108
0109 hCaloCompat[i] = ibooker.book1D("hCaloCompat", "Calo Compatibility", 101, -0.05, 1.05);
0110 hSegmentCompat[i] = ibooker.book1D("hSegmentCompat", "Segment Compatibility", 101, -0.05, 1.05);
0111 if (make2DPlots_)
0112 hCaloSegmentCompat[i] = ibooker.book2D(
0113 "hCaloSegmentCompat", "Calo Compatibility vs. Segment Compatibility", 101, -0.05, 1.05, 101, -0.05, 1.05);
0114 hMuonQualityTrkRelChi2[i] = ibooker.book1D("hMuonQualityTrkRelChi2", "MuonQuality TrkRelChi2", 100, 0., 1.5);
0115 hMuonQualityStaRelChi2[i] = ibooker.book1D("hMuonQualityStaRelChi2", "MuonQuality StaRelChi2", 100, 0., 3.);
0116 hMuonQualityTrkKink[i] = ibooker.book1D("hMuonQualityTrkKink", "MuonQuality TrkKink", 100, 0., 150.);
0117 hGlobalMuonPromptTightBool[i] =
0118 ibooker.book1D("hGlobalMuonPromptTightBool", "GlobalMuonPromptTight Boolean", 2, -0.5, 1.5);
0119 hTMLastStationLooseBool[i] = ibooker.book1D("hTMLastStationLooseBool", "TMLastStationLoose Boolean", 2, -0.5, 1.5);
0120 hTMLastStationTightBool[i] = ibooker.book1D("hTMLastStationTightBool", "TMLastStationTight Boolean", 2, -0.5, 1.5);
0121 hTM2DCompatibilityLooseBool[i] =
0122 ibooker.book1D("hTM2DCompatibilityLooseBool", "TM2DCompatibilityLoose Boolean", 2, -0.5, 1.5);
0123 hTM2DCompatibilityTightBool[i] =
0124 ibooker.book1D("hTM2DCompatibilityTightBool", "TM2DCompatibilityTight Boolean", 2, -0.5, 1.5);
0125 hTMOneStationLooseBool[i] = ibooker.book1D("hTMOneStationLooseBool", "TMOneStationLoose Boolean", 2, -0.5, 1.5);
0126 hTMOneStationTightBool[i] = ibooker.book1D("hTMOneStationTightBool", "TMOneStationTight Boolean", 2, -0.5, 1.5);
0127 hTMLastStationOptimizedLowPtLooseBool[i] = ibooker.book1D(
0128 "hTMLastStationOptimizedLowPtLooseBool", "TMLastStationOptimizedLowPtLoose Boolean", 2, -0.5, 1.5);
0129 hTMLastStationOptimizedLowPtTightBool[i] = ibooker.book1D(
0130 "hTMLastStationOptimizedLowPtTightBool", "TMLastStationOptimizedLowPtTight Boolean", 2, -0.5, 1.5);
0131 hGMTkChiCompatibilityBool[i] =
0132 ibooker.book1D("hGMTkChiCompatibilityBool", "GMTkChiCompatibility Boolean", 2, -0.5, 1.5);
0133 hGMStaChiCompatibilityBool[i] =
0134 ibooker.book1D("hGMStaChiCompatibilityBool", "GMStaChiCompatibility Boolean", 2, -0.5, 1.5);
0135 hGMTkKinkTightBool[i] = ibooker.book1D("hGMTkKinkTightBool", "GMTkKinkTight Boolean", 2, -0.5, 1.5);
0136 hTMLastStationAngLooseBool[i] =
0137 ibooker.book1D("hTMLastStationAngLooseBool", "TMLastStationAngLoose Boolean", 2, -0.5, 1.5);
0138 hTMLastStationAngTightBool[i] =
0139 ibooker.book1D("hTMLastStationAngTightBool", "TMLastStationAngTight Boolean", 2, -0.5, 1.5);
0140 hTMOneStationAngLooseBool[i] =
0141 ibooker.book1D("hTMOneStationAngLooseBool", "TMOneStationAngLoose Boolean", 2, -0.5, 1.5);
0142 hTMOneStationAngTightBool[i] =
0143 ibooker.book1D("hTMOneStationAngTightBool", "TMOneStationAngTight Boolean", 2, -0.5, 1.5);
0144 hTMLastStationOptimizedBarrelLowPtLooseBool[i] = ibooker.book1D(
0145 "hTMLastStationOptimizedBarrelLowPtLooseBool", "TMLastStationOptimizedBarrelLowPtLoose Boolean", 2, -0.5, 1.5);
0146 hTMLastStationOptimizedBarrelLowPtTightBool[i] = ibooker.book1D(
0147 "hTMLastStationOptimizedBarrelLowPtTightBool", "TMLastStationOptimizedBarrelLowPtTight Boolean", 2, -0.5, 1.5);
0148
0149 if (makeCosmicCompatibilityPlots_) {
0150 hCombinedCosmicCompat[i] =
0151 ibooker.book1D("hCombinedCosmicCompat", "hCombinedCosmicCompatibility float", 40, 0., 10.);
0152 hTimeCosmicCompat[i] = ibooker.book1D("hTimeCosmicCompat", "hTimeCosmicCompatibility float", 6, 0., 3.);
0153 hB2BCosmicCompat[i] = ibooker.book1D("hB2BCosmicCompat", "Number of back-to-back partners", 10, 0, 10);
0154 hOverlapCosmicCompat[i] = ibooker.book1D("hOverlapCosmicCompat", "Overlap between muons and 1Leg", 2, 0, 2);
0155 }
0156
0157
0158 for (int station = 0; station < 4; ++station) {
0159 if (makeShowerInformationPlots_) {
0160 sprintf(name, "hMuonShowerSizeT%i", station + 1);
0161 sprintf(title, "Station %i Transverse Cluster Size", station + 1);
0162 hMuonShowerSizeT[i][station] = ibooker.book1D(name, title, 1000, 0, 500);
0163 sprintf(name, "hMuonShowerDeltaR%i", station + 1);
0164 sprintf(title, "Station %i DeltaR", station + 1);
0165 hMuonShowerDeltaR[i][station] = ibooker.book1D(name, title, 5000, 0, 0.5);
0166 sprintf(name, "hMuonAllHits%i", station + 1);
0167 sprintf(title, "Station %i Number of 1D DT or 2D CSC RecHits", station + 1);
0168 hMuonAllHits[i][station] = ibooker.book1D(name, title, 400, 0, 400);
0169 sprintf(name, "hMuonHitsFromSegments%i", station + 1);
0170 sprintf(title, "Station %i Hits used by 4D DT or 3D CSC Segments", station + 1);
0171 hMuonHitsFromSegments[i][station] = ibooker.book1D(name, title, 400, 0, 400);
0172 sprintf(name, "hMuonUncorrelatedHits%i", station + 1);
0173 sprintf(title, "Station %i Uncorrelated Hits", station + 1);
0174 hMuonUncorrelatedHits[i][station] = ibooker.book1D(name, title, 400, 0, 400);
0175 }
0176
0177 sprintf(name, "hDT%iPullxPropErr", station + 1);
0178 sprintf(title, "DT Station %i Pull X w/ Propagation Error Only", station + 1);
0179 hDTPullxPropErr[i][station] = ibooker.book1D(name, title, 100, -20., 20.);
0180
0181 sprintf(name, "hDT%iPulldXdZPropErr", station + 1);
0182 sprintf(title, "DT Station %i Pull DxDz w/ Propagation Error Only", station + 1);
0183 hDTPulldXdZPropErr[i][station] = ibooker.book1D(name, title, 100, -20., 20.);
0184
0185 if (station < 3) {
0186 sprintf(name, "hDT%iPullyPropErr", station + 1);
0187 sprintf(title, "DT Station %i Pull Y w/ Propagation Error Only", station + 1);
0188 hDTPullyPropErr[i][station] = ibooker.book1D(name, title, 100, -20., 20.);
0189
0190 sprintf(name, "hDT%iPulldYdZPropErr", station + 1);
0191 sprintf(title, "DT Station %i Pull DyDz w/ Propagation Error Only", station + 1);
0192 hDTPulldYdZPropErr[i][station] = ibooker.book1D(name, title, 100, -20., 20.);
0193 }
0194
0195 sprintf(name, "hDT%iDistWithSegment", station + 1);
0196 sprintf(title, "DT Station %i Dist When There Is A Segment", station + 1);
0197 hDTDistWithSegment[i][station] = ibooker.book1D(name, title, 100, -140., 30.);
0198
0199 sprintf(name, "hDT%iDistWithNoSegment", station + 1);
0200 sprintf(title, "DT Station %i Dist When There Is No Segment", station + 1);
0201 hDTDistWithNoSegment[i][station] = ibooker.book1D(name, title, 100, -140., 30.);
0202
0203 sprintf(name, "hDT%iPullDistWithSegment", station + 1);
0204 sprintf(title, "DT Station %i Pull Dist When There Is A Segment", station + 1);
0205 hDTPullDistWithSegment[i][station] = ibooker.book1D(name, title, 100, -140., 30.);
0206
0207 sprintf(name, "hDT%iPullDistWithNoSegment", station + 1);
0208 sprintf(title, "DT Station %i Pull Dist When There Is No Segment", station + 1);
0209 hDTPullDistWithNoSegment[i][station] = ibooker.book1D(name, title, 100, -140., 30.);
0210
0211 sprintf(name, "hCSC%iPullxPropErr", station + 1);
0212 sprintf(title, "CSC Station %i Pull X w/ Propagation Error Only", station + 1);
0213 hCSCPullxPropErr[i][station] = ibooker.book1D(name, title, 100, -20., 20.);
0214
0215 sprintf(name, "hCSC%iPulldXdZPropErr", station + 1);
0216 sprintf(title, "CSC Station %i Pull DxDz w/ Propagation Error Only", station + 1);
0217 hCSCPulldXdZPropErr[i][station] = ibooker.book1D(name, title, 100, -20., 20.);
0218
0219 sprintf(name, "hCSC%iPullyPropErr", station + 1);
0220 sprintf(title, "CSC Station %i Pull Y w/ Propagation Error Only", station + 1);
0221 hCSCPullyPropErr[i][station] = ibooker.book1D(name, title, 100, -20., 20.);
0222
0223 sprintf(name, "hCSC%iPulldYdZPropErr", station + 1);
0224 sprintf(title, "CSC Station %i Pull DyDz w/ Propagation Error Only", station + 1);
0225 hCSCPulldYdZPropErr[i][station] = ibooker.book1D(name, title, 100, -50., 50.);
0226
0227 sprintf(name, "hCSC%iDistWithSegment", station + 1);
0228 sprintf(title, "CSC Station %i Dist When There Is A Segment", station + 1);
0229 hCSCDistWithSegment[i][station] = ibooker.book1D(name, title, 100, -70., 20.);
0230
0231 sprintf(name, "hCSC%iDistWithNoSegment", station + 1);
0232 sprintf(title, "CSC Station %i Dist When There Is No Segment", station + 1);
0233 hCSCDistWithNoSegment[i][station] = ibooker.book1D(name, title, 100, -70., 20.);
0234
0235 sprintf(name, "hCSC%iPullDistWithSegment", station + 1);
0236 sprintf(title, "CSC Station %i Pull Dist When There Is A Segment", station + 1);
0237 hCSCPullDistWithSegment[i][station] = ibooker.book1D(name, title, 100, -70., 20.);
0238
0239 sprintf(name, "hCSC%iPullDistWithNoSegment", station + 1);
0240 sprintf(title, "CSC Station %i Pull Dist When There Is No Segment", station + 1);
0241 hCSCPullDistWithNoSegment[i][station] = ibooker.book1D(name, title, 100, -70., 20.);
0242 }
0243 }
0244
0245 if (make2DPlots_) {
0246 ibooker.setCurrentFolder(baseFolder_);
0247 hSegmentIsAssociatedRZ =
0248 ibooker.book2D("hSegmentIsAssociatedRZ", "R-Z of Associated Segments", 2140, -1070., 1070., 850, 0., 850.);
0249 hSegmentIsAssociatedXY =
0250 ibooker.book2D("hSegmentIsAssociatedXY", "X-Y of Associated Segments", 1700, -850., 850., 1700, -850., 850.);
0251 hSegmentIsNotAssociatedRZ = ibooker.book2D(
0252 "hSegmentIsNotAssociatedRZ", "R-Z of Not Associated Segments", 2140, -1070., 1070., 850, 0., 850.);
0253 hSegmentIsNotAssociatedXY = ibooker.book2D(
0254 "hSegmentIsNotAssociatedXY", "X-Y of Not Associated Segments", 1700, -850., 850., 1700, -850., 850.);
0255 hSegmentIsBestDrAssociatedRZ = ibooker.book2D("hSegmentIsBestDrAssociatedRZ",
0256 "R-Z of Best in Station by #DeltaR Associated Segments",
0257 2140,
0258 -1070.,
0259 1070.,
0260 850,
0261 0.,
0262 850.);
0263 hSegmentIsBestDrAssociatedXY = ibooker.book2D("hSegmentIsBestDrAssociatedXY",
0264 "X-Y of Best in Station by #DeltaR Associated Segments",
0265 1700,
0266 -850.,
0267 850.,
0268 1700,
0269 -850.,
0270 850.);
0271 hSegmentIsBestDrNotAssociatedRZ = ibooker.book2D("hSegmentIsBestDrNotAssociatedRZ",
0272 "R-Z of Best in Station by #DeltaR Not Associated Segments",
0273 2140,
0274 -1070.,
0275 1070.,
0276 850,
0277 0.,
0278 850.);
0279 hSegmentIsBestDrNotAssociatedXY = ibooker.book2D("hSegmentIsBestDrNotAssociatedXY",
0280 "X-Y of Best in Station by #DeltaR Not Associated Segments",
0281 1700,
0282 -850.,
0283 850.,
0284 1700,
0285 -850.,
0286 850.);
0287 }
0288
0289 if (useTrackerMuons_ && makeAllChamberPlots_) {
0290 ibooker.setCurrentFolder(baseFolder_ + "/TrackerMuons");
0291
0292
0293 for (int station = 0; station < 4; ++station) {
0294
0295 for (int wheel = 0; wheel < 5; ++wheel) {
0296
0297 for (int sector = 0; sector < 14; ++sector) {
0298 sprintf(name, "hDTChamberDx_%i_%i_%i", station + 1, wheel - 2, sector + 1);
0299 sprintf(title, "DT Chamber Delta X: Station %i Wheel %i Sector %i", station + 1, wheel - 2, sector + 1);
0300 hDTChamberDx[station][wheel][sector] = ibooker.book1D(name, title, 100, -100., 100.);
0301
0302 if (station < 3) {
0303 sprintf(name, "hDTChamberDy_%i_%i_%i", station + 1, wheel - 2, sector + 1);
0304 sprintf(title, "DT Chamber Delta Y: Station %i Wheel %i Sector %i", station + 1, wheel - 2, sector + 1);
0305 hDTChamberDy[station][wheel][sector] = ibooker.book1D(name, title, 100, -150., 150.);
0306 }
0307
0308 sprintf(name, "hDTChamberEdgeXWithSegment_%i_%i_%i", station + 1, wheel - 2, sector + 1);
0309 sprintf(title,
0310 "DT Chamber Edge X When There Is A Segment: Station %i Wheel "
0311 "%i Sector %i",
0312 station + 1,
0313 wheel - 2,
0314 sector + 1);
0315 hDTChamberEdgeXWithSegment[station][wheel][sector] = ibooker.book1D(name, title, 100, -140., 30.);
0316
0317 sprintf(name, "hDTChamberEdgeXWithNoSegment_%i_%i_%i", station + 1, wheel - 2, sector + 1);
0318 sprintf(title,
0319 "DT Chamber Edge X When There Is No Segment: Station %i "
0320 "Wheel %i Sector %i",
0321 station + 1,
0322 wheel - 2,
0323 sector + 1);
0324 hDTChamberEdgeXWithNoSegment[station][wheel][sector] = ibooker.book1D(name, title, 100, -140., 30.);
0325
0326 sprintf(name, "hDTChamberEdgeYWithSegment_%i_%i_%i", station + 1, wheel - 2, sector + 1);
0327 sprintf(title,
0328 "DT Chamber Edge Y When There Is A Segment: Station %i Wheel "
0329 "%i Sector %i",
0330 station + 1,
0331 wheel - 2,
0332 sector + 1);
0333 hDTChamberEdgeYWithSegment[station][wheel][sector] = ibooker.book1D(name, title, 100, -140., 30.);
0334
0335 sprintf(name, "hDTChamberEdgeYWithNoSegment_%i_%i_%i", station + 1, wheel - 2, sector + 1);
0336 sprintf(title,
0337 "DT Chamber Edge Y When There Is No Segment: Station %i "
0338 "Wheel %i Sector %i",
0339 station + 1,
0340 wheel - 2,
0341 sector + 1);
0342 hDTChamberEdgeYWithNoSegment[station][wheel][sector] = ibooker.book1D(name, title, 100, -140., 30.);
0343 }
0344 }
0345
0346
0347 for (int endcap = 0; endcap < 2; ++endcap) {
0348
0349 for (int ring = 0; ring < 4; ++ring) {
0350
0351 for (int chamber = 0; chamber < 36; ++chamber) {
0352 sprintf(name, "hCSCChamberDx_%i_%i_%i_%i", endcap + 1, station + 1, ring + 1, chamber + 1);
0353 sprintf(title,
0354 "CSC Chamber Delta X: Endcap %i Station %i Ring %i Chamber %i",
0355 endcap + 1,
0356 station + 1,
0357 ring + 1,
0358 chamber + 1);
0359 hCSCChamberDx[endcap][station][ring][chamber] = ibooker.book1D(name, title, 100, -50., 50.);
0360
0361 sprintf(name, "hCSCChamberDy_%i_%i_%i_%i", endcap + 1, station + 1, ring + 1, chamber + 1);
0362 sprintf(title,
0363 "CSC Chamber Delta Y: Endcap %i Station %i Ring %i Chamber %i",
0364 endcap + 1,
0365 station + 1,
0366 ring + 1,
0367 chamber + 1);
0368 hCSCChamberDy[endcap][station][ring][chamber] = ibooker.book1D(name, title, 100, -50., 50.);
0369
0370 sprintf(name, "hCSCChamberEdgeXWithSegment_%i_%i_%i_%i", endcap + 1, station + 1, ring + 1, chamber + 1);
0371 sprintf(title,
0372 "CSC Chamber Edge X When There Is A Segment: Endcap %i "
0373 "Station %i Ring %i Chamber %i",
0374 endcap + 1,
0375 station + 1,
0376 ring + 1,
0377 chamber + 1);
0378 hCSCChamberEdgeXWithSegment[endcap][station][ring][chamber] = ibooker.book1D(name, title, 100, -70., 20.);
0379
0380 sprintf(name, "hCSCChamberEdgeXWithNoSegment_%i_%i_%i_%i", endcap + 1, station + 1, ring + 1, chamber + 1);
0381 sprintf(title,
0382 "CSC Chamber Edge X When There Is No Segment: Endcap %i "
0383 "Station %i Ring %i Chamber %i",
0384 endcap + 1,
0385 station + 1,
0386 ring + 1,
0387 chamber + 1);
0388 hCSCChamberEdgeXWithNoSegment[endcap][station][ring][chamber] = ibooker.book1D(name, title, 100, -70., 20.);
0389
0390 sprintf(name, "hCSCChamberEdgeYWithSegment_%i_%i_%i_%i", endcap + 1, station + 1, ring + 1, chamber + 1);
0391 sprintf(title,
0392 "CSC Chamber Edge Y When There Is A Segment: Endcap %i "
0393 "Station %i Ring %i Chamber %i",
0394 endcap + 1,
0395 station + 1,
0396 ring + 1,
0397 chamber + 1);
0398 hCSCChamberEdgeYWithSegment[endcap][station][ring][chamber] = ibooker.book1D(name, title, 100, -70., 20.);
0399
0400 sprintf(name, "hCSCChamberEdgeYWithNoSegment_%i_%i_%i_%i", endcap + 1, station + 1, ring + 1, chamber + 1);
0401 sprintf(title,
0402 "CSC Chamber Edge Y When There Is No Segment: Endcap %i "
0403 "Station %i Ring %i Chamber %i",
0404 endcap + 1,
0405 station + 1,
0406 ring + 1,
0407 chamber + 1);
0408 hCSCChamberEdgeYWithNoSegment[endcap][station][ring][chamber] = ibooker.book1D(name, title, 100, -70., 20.);
0409 }
0410 }
0411 }
0412 }
0413 }
0414 }
0415
0416 void MuonIdVal::analyze(const edm::Event &iEvent, const edm::EventSetup &iSetup) {
0417 using namespace edm;
0418 using namespace reco;
0419
0420 iEvent.getByToken(inputMuonCollectionToken_, muonCollectionH_);
0421 iEvent.getByToken(inputDTRecSegment4DCollectionToken_, dtSegmentCollectionH_);
0422 iEvent.getByToken(inputCSCSegmentCollectionToken_, cscSegmentCollectionH_);
0423 iEvent.getByToken(inputMuonTimeExtraValueMapCombToken_, combinedMuonTimeExtraValueMapH_);
0424 iEvent.getByToken(inputMuonTimeExtraValueMapCSCToken_, cscMuonTimeExtraValueMapH_);
0425 iEvent.getByToken(inputMuonTimeExtraValueMapDTToken_, dtMuonTimeExtraValueMapH_);
0426 iEvent.getByToken(inputMuonShowerInformationValueMapToken_, muonShowerInformationValueMapH_);
0427 iEvent.getByToken(inputMuonCosmicCompatibilityValueMapToken_, muonCosmicCompatibilityValueMapH_);
0428
0429 geometry_ = iSetup.getHandle(trackingGeomToken_);
0430
0431 unsigned int muonIdx = 0;
0432 for (MuonCollection::const_iterator muon = muonCollectionH_->begin(); muon != muonCollectionH_->end(); ++muon) {
0433
0434
0435 for (unsigned int i = 0; i < 4; i++) {
0436 if (i == 0 && (!useTrackerMuons_ || !muon->isTrackerMuon()))
0437 continue;
0438 if (i == 1 && (!useGlobalMuons_ || !muon->isGlobalMuon()))
0439 continue;
0440 if (i == 2 && (!useTrackerMuonsNotGlobalMuons_ || (!(muon->isTrackerMuon() && !muon->isGlobalMuon()))))
0441 continue;
0442 if (i == 3 && (!useGlobalMuonsNotTrackerMuons_ || (!(muon->isGlobalMuon() && !muon->isTrackerMuon()))))
0443 continue;
0444
0445 if (makeEnergyPlots_ && muon->isEnergyValid()) {
0446
0447 if (fabs(muon->eta()) > 1.479)
0448 hEnergyEMEndcap[i]->Fill(muon->calEnergy().em);
0449 else
0450 hEnergyEMBarrel[i]->Fill(muon->calEnergy().em);
0451
0452 if (fabs(muon->eta()) > 1.4)
0453 hEnergyHAEndcap[i]->Fill(muon->calEnergy().had);
0454 else
0455 hEnergyHABarrel[i]->Fill(muon->calEnergy().had);
0456
0457 if (fabs(muon->eta()) < 1.26)
0458 hEnergyHO[i]->Fill(muon->calEnergy().ho);
0459 }
0460
0461 if (makeTimePlots_) {
0462 if (muon->isTimeValid()) {
0463 hMuonTimeNDOF[i]->Fill(muon->time().nDof);
0464 hMuonTimeTimeAtIpInOut[i]->Fill(muon->time().timeAtIpInOut);
0465 hMuonTimeTimeAtIpInOutErr[i]->Fill(muon->time().timeAtIpInOutErr);
0466 hMuonTimeTimeAtIpOutIn[i]->Fill(muon->time().timeAtIpOutIn);
0467 hMuonTimeTimeAtIpOutInErr[i]->Fill(muon->time().timeAtIpOutInErr);
0468 }
0469
0470 MuonRef muonRef(muonCollectionH_, muonIdx);
0471 MuonTimeExtra combinedMuonTimeExtra = (*combinedMuonTimeExtraValueMapH_)[muonRef];
0472 MuonTimeExtra cscMuonTimeExtra = (*cscMuonTimeExtraValueMapH_)[muonRef];
0473 MuonTimeExtra dtMuonTimeExtra = (*dtMuonTimeExtraValueMapH_)[muonRef];
0474
0475 hMuonTimeExtraCombinedNDOF[i]->Fill(combinedMuonTimeExtra.nDof());
0476 hMuonTimeExtraCombinedTimeAtIpInOut[i]->Fill(combinedMuonTimeExtra.timeAtIpInOut());
0477 hMuonTimeExtraCombinedTimeAtIpInOutErr[i]->Fill(combinedMuonTimeExtra.timeAtIpInOutErr());
0478 hMuonTimeExtraCombinedTimeAtIpOutIn[i]->Fill(combinedMuonTimeExtra.timeAtIpOutIn());
0479 hMuonTimeExtraCombinedTimeAtIpOutInErr[i]->Fill(combinedMuonTimeExtra.timeAtIpOutInErr());
0480 hMuonTimeExtraCSCNDOF[i]->Fill(cscMuonTimeExtra.nDof());
0481 hMuonTimeExtraCSCTimeAtIpInOut[i]->Fill(cscMuonTimeExtra.timeAtIpInOut());
0482 hMuonTimeExtraCSCTimeAtIpInOutErr[i]->Fill(cscMuonTimeExtra.timeAtIpInOutErr());
0483 hMuonTimeExtraCSCTimeAtIpOutIn[i]->Fill(cscMuonTimeExtra.timeAtIpOutIn());
0484 hMuonTimeExtraCSCTimeAtIpOutInErr[i]->Fill(cscMuonTimeExtra.timeAtIpOutInErr());
0485 hMuonTimeExtraDTNDOF[i]->Fill(dtMuonTimeExtra.nDof());
0486 hMuonTimeExtraDTTimeAtIpInOut[i]->Fill(dtMuonTimeExtra.timeAtIpInOut());
0487 hMuonTimeExtraDTTimeAtIpInOutErr[i]->Fill(dtMuonTimeExtra.timeAtIpInOutErr());
0488 hMuonTimeExtraDTTimeAtIpOutIn[i]->Fill(dtMuonTimeExtra.timeAtIpOutIn());
0489 hMuonTimeExtraDTTimeAtIpOutInErr[i]->Fill(dtMuonTimeExtra.timeAtIpOutInErr());
0490 }
0491
0492 if (muon->isCaloCompatibilityValid())
0493 hCaloCompat[i]->Fill(muon->caloCompatibility());
0494 hSegmentCompat[i]->Fill(muon::segmentCompatibility(*muon));
0495 if (make2DPlots_ && muon->isCaloCompatibilityValid())
0496 hCaloSegmentCompat[i]->Fill(muon->caloCompatibility(), muon::segmentCompatibility(*muon));
0497 if (muon->isQualityValid()) {
0498 hMuonQualityTrkRelChi2[i]->Fill(muon->combinedQuality().trkRelChi2);
0499 hMuonQualityStaRelChi2[i]->Fill(muon->combinedQuality().staRelChi2);
0500 hMuonQualityTrkKink[i]->Fill(muon->combinedQuality().trkKink);
0501 }
0502 hGlobalMuonPromptTightBool[i]->Fill(muon::isGoodMuon(*muon, muon::GlobalMuonPromptTight));
0503 hTMLastStationLooseBool[i]->Fill(muon::isGoodMuon(*muon, muon::TMLastStationLoose));
0504 hTMLastStationTightBool[i]->Fill(muon::isGoodMuon(*muon, muon::TMLastStationTight));
0505 hTM2DCompatibilityLooseBool[i]->Fill(muon::isGoodMuon(*muon, muon::TM2DCompatibilityLoose));
0506 hTM2DCompatibilityTightBool[i]->Fill(muon::isGoodMuon(*muon, muon::TM2DCompatibilityTight));
0507 hTMOneStationLooseBool[i]->Fill(muon::isGoodMuon(*muon, muon::TMOneStationLoose));
0508 hTMOneStationTightBool[i]->Fill(muon::isGoodMuon(*muon, muon::TMOneStationTight));
0509 hTMLastStationOptimizedLowPtLooseBool[i]->Fill(muon::isGoodMuon(*muon, muon::TMLastStationOptimizedLowPtLoose));
0510 hTMLastStationOptimizedLowPtTightBool[i]->Fill(muon::isGoodMuon(*muon, muon::TMLastStationOptimizedLowPtTight));
0511 hGMTkChiCompatibilityBool[i]->Fill(muon::isGoodMuon(*muon, muon::GMTkChiCompatibility));
0512 hGMStaChiCompatibilityBool[i]->Fill(muon::isGoodMuon(*muon, muon::GMStaChiCompatibility));
0513 hGMTkKinkTightBool[i]->Fill(muon::isGoodMuon(*muon, muon::GMTkKinkTight));
0514 hTMLastStationAngLooseBool[i]->Fill(muon::isGoodMuon(*muon, muon::TMLastStationAngLoose));
0515 hTMLastStationAngTightBool[i]->Fill(muon::isGoodMuon(*muon, muon::TMLastStationAngTight));
0516 hTMOneStationAngLooseBool[i]->Fill(muon::isGoodMuon(*muon, muon::TMOneStationAngLoose));
0517 hTMOneStationAngTightBool[i]->Fill(muon::isGoodMuon(*muon, muon::TMOneStationAngTight));
0518 hTMLastStationOptimizedBarrelLowPtLooseBool[i]->Fill(
0519 muon::isGoodMuon(*muon, muon::TMLastStationOptimizedBarrelLowPtLoose));
0520 hTMLastStationOptimizedBarrelLowPtTightBool[i]->Fill(
0521 muon::isGoodMuon(*muon, muon::TMLastStationOptimizedBarrelLowPtTight));
0522
0523 if (makeCosmicCompatibilityPlots_) {
0524 MuonRef muonRef(muonCollectionH_, muonIdx);
0525 MuonCosmicCompatibility muonCosmicCompatibility = (*muonCosmicCompatibilityValueMapH_)[muonRef];
0526 hCombinedCosmicCompat[i]->Fill(muonCosmicCompatibility.cosmicCompatibility);
0527 hTimeCosmicCompat[i]->Fill(muonCosmicCompatibility.timeCompatibility);
0528 hB2BCosmicCompat[i]->Fill(muonCosmicCompatibility.backToBackCompatibility);
0529 hOverlapCosmicCompat[i]->Fill(muonCosmicCompatibility.overlapCompatibility);
0530 }
0531
0532
0533 for (int station = 0; station < 4; ++station) {
0534 if (makeShowerInformationPlots_) {
0535 MuonRef muonRef(muonCollectionH_, muonIdx);
0536 MuonShower muonShowerInformation = (*muonShowerInformationValueMapH_)[muonRef];
0537
0538 hMuonShowerSizeT[i][station]->Fill((muonShowerInformation.stationShowerSizeT).at(station));
0539 hMuonShowerDeltaR[i][station]->Fill((muonShowerInformation.stationShowerDeltaR.at(station)));
0540 hMuonAllHits[i][station]->Fill((muonShowerInformation.nStationHits.at(station)));
0541 hMuonHitsFromSegments[i][station]->Fill((muonShowerInformation.nStationCorrelatedHits.at(station)));
0542 hMuonUncorrelatedHits[i][station]->Fill((muonShowerInformation.nStationHits.at(station)) -
0543 muonShowerInformation.nStationCorrelatedHits.at(station));
0544 }
0545
0546 Fill(hDTPullxPropErr[i][station],
0547 muon->pullX(station + 1, MuonSubdetId::DT, Muon::SegmentAndTrackArbitration, false));
0548 Fill(hDTPulldXdZPropErr[i][station],
0549 muon->pullDxDz(station + 1, MuonSubdetId::DT, Muon::SegmentAndTrackArbitration, false));
0550
0551 if (station < 3) {
0552 Fill(hDTPullyPropErr[i][station],
0553 muon->pullY(station + 1, MuonSubdetId::DT, Muon::SegmentAndTrackArbitration, false));
0554 Fill(hDTPulldYdZPropErr[i][station],
0555 muon->pullDyDz(station + 1, MuonSubdetId::DT, Muon::SegmentAndTrackArbitration, false));
0556 }
0557
0558 float distance = muon->trackDist(station + 1, MuonSubdetId::DT);
0559 float error = muon->trackDistErr(station + 1, MuonSubdetId::DT);
0560 if (error == 0)
0561 error = 0.000001;
0562
0563 if (muon->numberOfSegments(station + 1, MuonSubdetId::DT, Muon::NoArbitration) > 0) {
0564 Fill(hDTDistWithSegment[i][station], distance);
0565 Fill(hDTPullDistWithSegment[i][station], distance / error);
0566 } else {
0567 Fill(hDTDistWithNoSegment[i][station], distance);
0568 Fill(hDTPullDistWithNoSegment[i][station], distance / error);
0569 }
0570
0571 Fill(hCSCPullxPropErr[i][station],
0572 muon->pullX(station + 1, MuonSubdetId::CSC, Muon::SegmentAndTrackArbitration, false));
0573 Fill(hCSCPulldXdZPropErr[i][station],
0574 muon->pullDxDz(station + 1, MuonSubdetId::CSC, Muon::SegmentAndTrackArbitration, false));
0575 Fill(hCSCPullyPropErr[i][station],
0576 muon->pullY(station + 1, MuonSubdetId::CSC, Muon::SegmentAndTrackArbitration, false));
0577 Fill(hCSCPulldYdZPropErr[i][station],
0578 muon->pullDyDz(station + 1, MuonSubdetId::CSC, Muon::SegmentAndTrackArbitration, false));
0579
0580 distance = muon->trackDist(station + 1, MuonSubdetId::CSC);
0581 error = muon->trackDistErr(station + 1, MuonSubdetId::CSC);
0582 if (error == 0)
0583 error = 0.000001;
0584
0585 if (muon->numberOfSegments(station + 1, MuonSubdetId::CSC, Muon::NoArbitration) > 0) {
0586 Fill(hCSCDistWithSegment[i][station], distance);
0587 Fill(hCSCPullDistWithSegment[i][station], distance / error);
0588 } else {
0589 Fill(hCSCDistWithNoSegment[i][station], distance);
0590 Fill(hCSCPullDistWithNoSegment[i][station], distance / error);
0591 }
0592 }
0593 }
0594
0595 if (!useTrackerMuons_ || !muon->isTrackerMuon())
0596 continue;
0597 if (makeAllChamberPlots_) {
0598
0599 for (std::vector<MuonChamberMatch>::const_iterator chamberMatch = muon->matches().begin();
0600 chamberMatch != muon->matches().end();
0601 ++chamberMatch) {
0602 int station = chamberMatch->station();
0603
0604 if (chamberMatch->detector() == MuonSubdetId::DT) {
0605 DTChamberId dtId(chamberMatch->id.rawId());
0606 int wheel = dtId.wheel();
0607 int sector = dtId.sector();
0608
0609 if (chamberMatch->segmentMatches.empty()) {
0610 Fill(hDTChamberEdgeXWithNoSegment[station - 1][wheel + 2][sector - 1], chamberMatch->edgeX);
0611 Fill(hDTChamberEdgeYWithNoSegment[station - 1][wheel + 2][sector - 1], chamberMatch->edgeY);
0612 } else {
0613 Fill(hDTChamberEdgeXWithSegment[station - 1][wheel + 2][sector - 1], chamberMatch->edgeX);
0614 Fill(hDTChamberEdgeYWithSegment[station - 1][wheel + 2][sector - 1], chamberMatch->edgeY);
0615
0616 for (std::vector<MuonSegmentMatch>::const_iterator segmentMatch = chamberMatch->segmentMatches.begin();
0617 segmentMatch != chamberMatch->segmentMatches.end();
0618 ++segmentMatch) {
0619 if (segmentMatch->isMask(MuonSegmentMatch::BestInChamberByDR)) {
0620 Fill(hDTChamberDx[station - 1][wheel + 2][sector - 1], chamberMatch->x - segmentMatch->x);
0621 if (station < 4)
0622 Fill(hDTChamberDy[station - 1][wheel + 2][sector - 1], chamberMatch->y - segmentMatch->y);
0623 break;
0624 }
0625 }
0626 }
0627
0628 continue;
0629 }
0630
0631 if (chamberMatch->detector() == MuonSubdetId::CSC) {
0632 CSCDetId cscId(chamberMatch->id.rawId());
0633 int endcap = cscId.endcap();
0634 int ring = cscId.ring();
0635 int chamber = cscId.chamber();
0636
0637 if (chamberMatch->segmentMatches.empty()) {
0638 Fill(hCSCChamberEdgeXWithNoSegment[endcap - 1][station - 1][ring - 1][chamber - 1], chamberMatch->edgeX);
0639 Fill(hCSCChamberEdgeYWithNoSegment[endcap - 1][station - 1][ring - 1][chamber - 1], chamberMatch->edgeY);
0640 } else {
0641 Fill(hCSCChamberEdgeXWithSegment[endcap - 1][station - 1][ring - 1][chamber - 1], chamberMatch->edgeX);
0642 Fill(hCSCChamberEdgeYWithSegment[endcap - 1][station - 1][ring - 1][chamber - 1], chamberMatch->edgeY);
0643
0644 for (std::vector<MuonSegmentMatch>::const_iterator segmentMatch = chamberMatch->segmentMatches.begin();
0645 segmentMatch != chamberMatch->segmentMatches.end();
0646 ++segmentMatch) {
0647 if (segmentMatch->isMask(MuonSegmentMatch::BestInChamberByDR)) {
0648 Fill(hCSCChamberDx[endcap - 1][station - 1][ring - 1][chamber - 1], chamberMatch->x - segmentMatch->x);
0649 Fill(hCSCChamberDy[endcap - 1][station - 1][ring - 1][chamber - 1], chamberMatch->y - segmentMatch->y);
0650 break;
0651 }
0652 }
0653 }
0654 }
0655 }
0656 }
0657 ++muonIdx;
0658 }
0659
0660 if (!make2DPlots_)
0661 return;
0662
0663 for (DTRecSegment4DCollection::const_iterator segment = dtSegmentCollectionH_->begin();
0664 segment != dtSegmentCollectionH_->end();
0665 ++segment) {
0666 LocalPoint segmentLocalPosition = segment->localPosition();
0667 LocalVector segmentLocalDirection = segment->localDirection();
0668 LocalError segmentLocalPositionError = segment->localPositionError();
0669 LocalError segmentLocalDirectionError = segment->localDirectionError();
0670 const GeomDet *segmentGeomDet = geometry_->idToDet(segment->geographicalId());
0671 GlobalPoint segmentGlobalPosition = segmentGeomDet->toGlobal(segment->localPosition());
0672 bool segmentFound = false;
0673 bool segmentBestDrFound = false;
0674
0675 for (MuonCollection::const_iterator muon = muonCollectionH_->begin(); muon != muonCollectionH_->end(); ++muon) {
0676 if (!muon->isMatchesValid())
0677 continue;
0678
0679 for (std::vector<MuonChamberMatch>::const_iterator chamberMatch = muon->matches().begin();
0680 chamberMatch != muon->matches().end();
0681 ++chamberMatch) {
0682 for (std::vector<MuonSegmentMatch>::const_iterator segmentMatch = chamberMatch->segmentMatches.begin();
0683 segmentMatch != chamberMatch->segmentMatches.end();
0684 ++segmentMatch) {
0685 if (fabs(segmentMatch->x - segmentLocalPosition.x()) < 1E-6 &&
0686 fabs(segmentMatch->y - segmentLocalPosition.y()) < 1E-6 &&
0687 fabs(segmentMatch->dXdZ - segmentLocalDirection.x() / segmentLocalDirection.z()) < 1E-6 &&
0688 fabs(segmentMatch->dYdZ - segmentLocalDirection.y() / segmentLocalDirection.z()) < 1E-6 &&
0689 fabs(segmentMatch->xErr - sqrt(segmentLocalPositionError.xx())) < 1E-6 &&
0690 fabs(segmentMatch->yErr - sqrt(segmentLocalPositionError.yy())) < 1E-6 &&
0691 fabs(segmentMatch->dXdZErr - sqrt(segmentLocalDirectionError.xx())) < 1E-6 &&
0692 fabs(segmentMatch->dYdZErr - sqrt(segmentLocalDirectionError.yy())) < 1E-6) {
0693 segmentFound = true;
0694 if (segmentMatch->isMask(reco::MuonSegmentMatch::BestInStationByDR))
0695 segmentBestDrFound = true;
0696 break;
0697 }
0698 }
0699 if (segmentFound)
0700 break;
0701 }
0702 if (segmentFound)
0703 break;
0704 }
0705
0706 if (segmentFound) {
0707 hSegmentIsAssociatedRZ->Fill(segmentGlobalPosition.z(), segmentGlobalPosition.perp());
0708 hSegmentIsAssociatedXY->Fill(segmentGlobalPosition.x(), segmentGlobalPosition.y());
0709
0710 if (segmentBestDrFound) {
0711 hSegmentIsBestDrAssociatedRZ->Fill(segmentGlobalPosition.z(), segmentGlobalPosition.perp());
0712 hSegmentIsBestDrAssociatedXY->Fill(segmentGlobalPosition.x(), segmentGlobalPosition.y());
0713 }
0714 } else {
0715 hSegmentIsNotAssociatedRZ->Fill(segmentGlobalPosition.z(), segmentGlobalPosition.perp());
0716 hSegmentIsNotAssociatedXY->Fill(segmentGlobalPosition.x(), segmentGlobalPosition.y());
0717 hSegmentIsBestDrNotAssociatedRZ->Fill(segmentGlobalPosition.z(), segmentGlobalPosition.perp());
0718 hSegmentIsBestDrNotAssociatedXY->Fill(segmentGlobalPosition.x(), segmentGlobalPosition.y());
0719 }
0720 }
0721
0722 for (CSCSegmentCollection::const_iterator segment = cscSegmentCollectionH_->begin();
0723 segment != cscSegmentCollectionH_->end();
0724 ++segment) {
0725 LocalPoint segmentLocalPosition = segment->localPosition();
0726 LocalVector segmentLocalDirection = segment->localDirection();
0727 LocalError segmentLocalPositionError = segment->localPositionError();
0728 LocalError segmentLocalDirectionError = segment->localDirectionError();
0729 const GeomDet *segmentGeomDet = geometry_->idToDet(segment->geographicalId());
0730 GlobalPoint segmentGlobalPosition = segmentGeomDet->toGlobal(segment->localPosition());
0731 bool segmentFound = false;
0732 bool segmentBestDrFound = false;
0733
0734 for (MuonCollection::const_iterator muon = muonCollectionH_->begin(); muon != muonCollectionH_->end(); ++muon) {
0735 if (!muon->isMatchesValid())
0736 continue;
0737
0738 for (std::vector<MuonChamberMatch>::const_iterator chamberMatch = muon->matches().begin();
0739 chamberMatch != muon->matches().end();
0740 ++chamberMatch) {
0741 for (std::vector<MuonSegmentMatch>::const_iterator segmentMatch = chamberMatch->segmentMatches.begin();
0742 segmentMatch != chamberMatch->segmentMatches.end();
0743 ++segmentMatch) {
0744 if (fabs(segmentMatch->x - segmentLocalPosition.x()) < 1E-6 &&
0745 fabs(segmentMatch->y - segmentLocalPosition.y()) < 1E-6 &&
0746 fabs(segmentMatch->dXdZ - segmentLocalDirection.x() / segmentLocalDirection.z()) < 1E-6 &&
0747 fabs(segmentMatch->dYdZ - segmentLocalDirection.y() / segmentLocalDirection.z()) < 1E-6 &&
0748 fabs(segmentMatch->xErr - sqrt(segmentLocalPositionError.xx())) < 1E-6 &&
0749 fabs(segmentMatch->yErr - sqrt(segmentLocalPositionError.yy())) < 1E-6 &&
0750 fabs(segmentMatch->dXdZErr - sqrt(segmentLocalDirectionError.xx())) < 1E-6 &&
0751 fabs(segmentMatch->dYdZErr - sqrt(segmentLocalDirectionError.yy())) < 1E-6) {
0752 segmentFound = true;
0753 if (segmentMatch->isMask(reco::MuonSegmentMatch::BestInStationByDR))
0754 segmentBestDrFound = true;
0755 break;
0756 }
0757 }
0758 if (segmentFound)
0759 break;
0760 }
0761 if (segmentFound)
0762 break;
0763 }
0764
0765 if (segmentFound) {
0766 hSegmentIsAssociatedRZ->Fill(segmentGlobalPosition.z(), segmentGlobalPosition.perp());
0767 hSegmentIsAssociatedXY->Fill(segmentGlobalPosition.x(), segmentGlobalPosition.y());
0768
0769 if (segmentBestDrFound) {
0770 hSegmentIsBestDrAssociatedRZ->Fill(segmentGlobalPosition.z(), segmentGlobalPosition.perp());
0771 hSegmentIsBestDrAssociatedXY->Fill(segmentGlobalPosition.x(), segmentGlobalPosition.y());
0772 }
0773 } else {
0774 hSegmentIsNotAssociatedRZ->Fill(segmentGlobalPosition.z(), segmentGlobalPosition.perp());
0775 hSegmentIsNotAssociatedXY->Fill(segmentGlobalPosition.x(), segmentGlobalPosition.y());
0776 hSegmentIsBestDrNotAssociatedRZ->Fill(segmentGlobalPosition.z(), segmentGlobalPosition.perp());
0777 hSegmentIsBestDrNotAssociatedXY->Fill(segmentGlobalPosition.x(), segmentGlobalPosition.y());
0778 }
0779 }
0780 }
0781
0782 void MuonIdVal::Fill(MonitorElement *me, float f) {
0783 if (fabs(f) > 900000)
0784 return;
0785
0786 me->Fill(f);
0787 }
0788
0789
0790 DEFINE_FWK_MODULE(MuonIdVal);
