File indexing completed on 2024-04-06 12:31:43
0001 #include "FWCore/Framework/interface/one/EDAnalyzer.h"
0002 #include "FWCore/Framework/interface/ESHandle.h"
0003 #include "FWCore/Framework/interface/Event.h"
0004 #include "FWCore/Framework/interface/Frameworkfwd.h"
0005 #include "FWCore/Framework/interface/MakerMacros.h" //For define_fwk_module
0006
0007 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0008 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0009 #include "FWCore/Utilities/interface/InputTag.h"
0010
0011
0012
0013
0014
0015 #include "DataFormats/MuonDetId/interface/CSCDetId.h"
0016 #include "DataFormats/MuonDetId/interface/DTWireId.h"
0017 #include "DataFormats/MuonDetId/interface/RPCDetId.h"
0018 #include "Geometry/CSCGeometry/interface/CSCGeometry.h"
0019 #include "Geometry/DTGeometry/interface/DTGeometry.h"
0020 #include "Geometry/RPCGeometry/interface/RPCGeometry.h"
0021 #include "Geometry/Records/interface/IdealGeometryRecord.h"
0022 #include "Geometry/Records/interface/MuonGeometryRecord.h"
0023
0024
0025 #include "MagneticField/Engine/interface/MagneticField.h"
0026 #include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
0027 #include "SimG4Core/MagneticField/interface/Field.h"
0028 #include "SimG4Core/MagneticField/interface/FieldBuilder.h"
0029
0030
0031 #include "TrackPropagation/Geant4e/interface/ConvertFromToCLHEP.h"
0032 #include "TrackPropagation/Geant4e/interface/Geant4ePropagator.h"
0033 #include "TrackingTools/TrajectoryState/interface/FreeTrajectoryState.h"
0034 #include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
0035
0036
0037 #include "SimDataFormats/Track/interface/SimTrack.h"
0038 #include "SimDataFormats/Track/interface/SimTrackContainer.h"
0039 #include "SimDataFormats/TrackingHit/interface/PSimHit.h"
0040 #include "SimDataFormats/TrackingHit/interface/PSimHitContainer.h"
0041 #include "SimDataFormats/Vertex/interface/SimVertex.h"
0042 #include "SimDataFormats/Vertex/interface/SimVertexContainer.h"
0043
0044
0045 #include "G4TransportationManager.hh"
0046
0047
0048 #include "TFile.h"
0049 #include "TH1.h"
0050 #include "TH2.h"
0051
0052 using namespace std;
0053
0054 enum testMuChamberType { DT, RPC, CSC };
0055
0056 class Geant4ePropagatorAnalyzer : public edm::one::EDAnalyzer<> {
0057 public:
0058 explicit Geant4ePropagatorAnalyzer(const edm::ParameterSet &);
0059 ~Geant4ePropagatorAnalyzer() override = default;
0060
0061 void analyze(const edm::Event &, const edm::EventSetup &) override;
0062 void endJob() override;
0063 void beginJob() override;
0064 void iterateOverHits(edm::Handle<edm::PSimHitContainer> simHits,
0065 testMuChamberType muonChamberType,
0066 unsigned int trkIndex,
0067 const FreeTrajectoryState &ftsTrack);
0068
0069 protected:
0070
0071 const edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> magFieldToken;
0072 const edm::ESGetToken<DTGeometry, MuonGeometryRecord> dtGeomToken;
0073 const edm::ESGetToken<RPCGeometry, MuonGeometryRecord> rpcGeomToken;
0074 const edm::ESGetToken<CSCGeometry, MuonGeometryRecord> cscGeomToken;
0075
0076 int theRun;
0077 int theEvent;
0078
0079 Propagator *thePropagator;
0080
0081
0082
0083 edm::ESHandle<DTGeometry> theDTGeomESH;
0084 edm::ESHandle<RPCGeometry> theRPCGeomESH;
0085 edm::ESHandle<CSCGeometry> theCSCGeomESH;
0086
0087
0088 int fStudyStation;
0089
0090
0091 float fBeamCenter;
0092 float fBeamInterval;
0093
0094
0095 TFile *theRootFile;
0096
0097 TH1F *fDistanceSHLayer;
0098
0099 TH1F *fDistance;
0100 TH1F *fDistanceSt[4];
0101
0102 TH1F *fHitR;
0103 TH1F *fHitRho;
0104 TH1F *fHitEta;
0105 TH1F *fHitPhi;
0106 TH1F *fHitPhi1L;
0107 TH2F *fHitRVsPhi;
0108
0109 TH1F *fLayerR;
0110 TH1F *fLayerRho;
0111 TH1F *fLayerEta;
0112 TH1F *fLayerPhi;
0113 TH2F *fLayerRVsPhi;
0114
0115 TH1F *fExtrapR;
0116 TH1F *fExtrapRho;
0117 TH1F *fExtrapEta;
0118 TH1F *fExtrapPhi;
0119 TH2F *fExtrapRVsPhi;
0120
0121 TH1F *fDeltaRo;
0122 TH1F *fDeltaEta;
0123 TH1F *fDeltaPhi;
0124
0125
0126 TH1F *fStationPosPhi;
0127 TH1F *fSectorPosPhi;
0128 TH1F *fSLayerPosPhi;
0129 TH1F *fLayerPosPhi;
0130
0131 TH1F *fStationNegPhi;
0132 TH1F *fSectorNegPhi;
0133 TH1F *fSLayerNegPhi;
0134 TH1F *fLayerNegPhi;
0135
0136
0137 edm::InputTag G4TrkSrc_;
0138 edm::InputTag G4VtxSrc_;
0139 const edm::EDGetTokenT<edm::SimTrackContainer> simTrackToken_;
0140 const edm::EDGetTokenT<edm::SimVertexContainer> simVertexToken_;
0141 const edm::EDGetTokenT<edm::PSimHitContainer> simHitsDTToken_;
0142 const edm::EDGetTokenT<edm::PSimHitContainer> simHitsCSCToken_;
0143 const edm::EDGetTokenT<edm::PSimHitContainer> simHitsRPCToken_;
0144 };
0145
0146 Geant4ePropagatorAnalyzer::Geant4ePropagatorAnalyzer(const edm::ParameterSet &iConfig)
0147 : magFieldToken(esConsumes()),
0148 dtGeomToken(esConsumes()),
0149 rpcGeomToken(esConsumes()),
0150 cscGeomToken(esConsumes()),
0151 theRun(-1),
0152 theEvent(-1),
0153 thePropagator(nullptr),
0154 G4TrkSrc_(iConfig.getParameter<edm::InputTag>("G4TrkSrc")),
0155 G4VtxSrc_(iConfig.getParameter<edm::InputTag>("G4VtxSrc")),
0156 simTrackToken_(consumes<edm::SimTrackContainer>(G4TrkSrc_)),
0157 simVertexToken_(consumes<edm::SimVertexContainer>(G4VtxSrc_)),
0158 simHitsDTToken_(consumes<edm::PSimHitContainer>(edm::InputTag("g4SimHits", "MuonDTHits"))),
0159 simHitsCSCToken_(consumes<edm::PSimHitContainer>(edm::InputTag("g4SimHits", "MuonCSCHits"))),
0160 simHitsRPCToken_(consumes<edm::PSimHitContainer>(edm::InputTag("g4SimHits", "MuonRPCHits"))) {
0161
0162 fStudyStation = iConfig.getParameter<int>("StudyStation");
0163
0164 fBeamCenter = iConfig.getParameter<double>("BeamCenter");
0165 fBeamInterval = iConfig.getParameter<double>("BeamInterval");
0166
0167
0168
0169
0170
0171
0172 theRootFile = new TFile(iConfig.getParameter<std::string>("RootFile").c_str(), "recreate");
0173
0174
0175 fDistanceSHLayer = new TH1F("fDistanceSHLayer", "Distance(sim hit - layer)", 200, -1, 1);
0176
0177
0178 fDistance = new TH1F("fDistance", "Distance(sim hit - extrap)", 150, 0, 300);
0179
0180 fDistanceSt[0] = new TH1F("fDistance_St1", "Distance(sim hit - extrap) for station 1", 150, 0, 300);
0181 fDistanceSt[1] = new TH1F("fDistance_St2", "Distance(sim hit - extrap) for station 2", 150, 0, 300);
0182 fDistanceSt[2] = new TH1F("fDistance_St3", "Distance(sim hit - extrap) for station 3", 150, 0, 300);
0183 fDistanceSt[3] = new TH1F("fDistance_St4", "Distance(sim hit - extrap) for station 4", 150, 0, 300);
0184
0185
0186 fHitR = new TH1F("fHitR", "R^{sim hit}", 300, 400, 1000);
0187 fHitRho = new TH1F("fHitRho", "#rho^{sim hit}", 300, 400, 1000);
0188 fHitEta = new TH1F("fHitEta", "#eta^{sim hit}", 100, -0.1, 0.1);
0189 fHitPhi = new TH1F("fHitPhi", "#varphi^{sim hit}", 160, fBeamCenter - fBeamInterval, fBeamCenter + fBeamInterval);
0190 fHitPhi1L = new TH1F(
0191 "fHitPhi1L", "#varphi^{sim hit} for 1st layer", 160, fBeamCenter - fBeamInterval, fBeamCenter + fBeamInterval);
0192
0193 fHitRVsPhi = new TH2F("fHitRVsPhi",
0194 "R vs. #varphi for sim hits",
0195 60,
0196 400,
0197 1000,
0198 80,
0199 fBeamCenter - fBeamInterval,
0200 fBeamCenter + fBeamInterval);
0201
0202
0203 fLayerR = new TH1F("fLayerR", "R^{layer}", 300, 400, 1000);
0204 fLayerRho = new TH1F("fLayerRho", "#rho^{layer}", 300, 400, 1000);
0205 fLayerEta = new TH1F("fLayerEta", "#eta^{layer}", 100, -0.1, 0.1);
0206 fLayerPhi = new TH1F("fLayerPhi", "#varphi^{layer}", 160, fBeamCenter - fBeamInterval, fBeamCenter + fBeamInterval);
0207 fLayerRVsPhi = new TH2F("fLayerRVsPhi",
0208 "R vs. #varphi for layers",
0209 60,
0210 400,
0211 1000,
0212 80,
0213 fBeamCenter - fBeamInterval,
0214 fBeamCenter + fBeamInterval);
0215
0216
0217 fExtrapR = new TH1F("fExtrapR", "R^{extrap. hit}", 300, 400, 1000);
0218 fExtrapRho = new TH1F("fExtrapRho", "#rho^{extrap. hit}", 300, 400, 1000);
0219 fExtrapEta = new TH1F("fExtrapEta", "#eta^{extrap. hit}", 100, -0.1, 0.1);
0220 fExtrapPhi =
0221 new TH1F("fExtrapPhi", "#varphi^{extrap. hit}", 160, fBeamCenter - fBeamInterval, fBeamCenter + fBeamInterval);
0222
0223 fExtrapRVsPhi = new TH2F("fExtrapRVsPhi",
0224 "R vs. #varphi for extrap. hits",
0225 60,
0226 400,
0227 1000,
0228 80,
0229 fBeamCenter - fBeamInterval,
0230 fBeamCenter + fBeamInterval);
0231
0232
0233 fDeltaRo = new TH1F("fDeltaRo", "#Delta(#rho^{sim}, #rho^{extrap})", 100, 0, 200);
0234 fDeltaEta = new TH1F("fDeltaEta", "#Delta(#eta^{sim}, #eta^{extrap})", 100, -1, 1);
0235 fDeltaPhi = new TH1F("fDeltaPhi", "#Delta(#varphi^{sim}, #varphi^{extrap})", 120, -30, 30);
0236
0237
0238 fStationPosPhi = new TH1F("fStationPosPhi", "Station with positive #varphi", 6, -0.5, 5.5);
0239 fSectorPosPhi = new TH1F("fSectorPosPhi", "Sector with positive #varphi", 6, -0.5, 5.5);
0240 fSLayerPosPhi = new TH1F("fSLayerPosPhi", "Superlayer with positive #varphi", 6, -0.5, 5.5);
0241 fLayerPosPhi = new TH1F("fLayerPosPhi", "Layer with positive #varphi", 6, -0.5, 5.5);
0242 fStationNegPhi = new TH1F("fStationNegPhi", "Station with negative #varphi", 6, -0.5, 5.5);
0243 fSectorNegPhi = new TH1F("fSectorNegPhi", "Sector with negative #varphi", 6, -0.5, 5.5);
0244 fSLayerNegPhi = new TH1F("fSLayerNegPhi", "Superlayer with negative #varphi", 6, -0.5, 5.5);
0245 fLayerNegPhi = new TH1F("fLayerNegPhi", "Layer with negative #varphi", 6, -0.5, 5.5);
0246
0247
0248
0249 }
0250
0251 void Geant4ePropagatorAnalyzer::beginJob() { LogDebug("Geant4e") << "Nothing done in beginJob..."; }
0252
0253 void Geant4ePropagatorAnalyzer::endJob() {
0254 fDistanceSHLayer->Write();
0255 fDistance->Write();
0256 for (unsigned int i = 0; i < 4; i++)
0257 fDistanceSt[i]->Write();
0258
0259 fHitR->Write();
0260 fHitRho->Write();
0261 fHitEta->Write();
0262 fHitPhi->Write();
0263 fHitPhi1L->Write();
0264 fHitRVsPhi->Write();
0265
0266 fLayerR->Write();
0267 fLayerRho->Write();
0268 fLayerEta->Write();
0269 fLayerPhi->Write();
0270 fLayerRVsPhi->Write();
0271
0272 fExtrapR->Write();
0273 fExtrapRho->Write();
0274 fExtrapEta->Write();
0275 fExtrapPhi->Write();
0276 fExtrapRVsPhi->Write();
0277
0278 fDeltaRo->Write();
0279 fDeltaEta->Write();
0280 fDeltaPhi->Write();
0281
0282
0283 fStationPosPhi->Write();
0284 fSectorPosPhi->Write();
0285 fSLayerPosPhi->Write();
0286 fLayerPosPhi->Write();
0287 fStationNegPhi->Write();
0288 fSectorNegPhi->Write();
0289 fSLayerNegPhi->Write();
0290 fLayerNegPhi->Write();
0291
0292 theRootFile->Close();
0293
0294 }
0295
0296 void Geant4ePropagatorAnalyzer::analyze(const edm::Event &iEvent, const edm::EventSetup &iSetup) {
0297 using namespace edm;
0298
0299 LogDebug("Geant4e") << "Starting analyze...";
0300
0301
0302
0303 const ESHandle<MagneticField> bField = iSetup.getHandle(magFieldToken);
0304 if (bField.isValid())
0305 LogDebug("Geant4e") << "G4e -- Magnetic field is valid. Value in (0,0,0): "
0306 << bField->inTesla(GlobalPoint(0, 0, 0)).mag() << " Tesla";
0307 else
0308 LogError("Geant4e") << "G4e -- NO valid Magnetic field";
0309
0310
0311
0312
0313
0314 theDTGeomESH = iSetup.getHandle(dtGeomToken);
0315 LogDebug("Geant4e") << "Got DTGeometry";
0316
0317
0318 theCSCGeomESH = iSetup.getHandle(cscGeomToken);
0319 LogDebug("Geant4e") << "Got CSCGeometry";
0320
0321
0322 theRPCGeomESH = iSetup.getHandle(rpcGeomToken);
0323 LogDebug("Geant4e") << "Got RPCGeometry";
0324
0325
0326
0327 theRun = (int)iEvent.id().run();
0328 theEvent = (int)iEvent.id().event();
0329 LogDebug("Geant4e") << "G4e -- Begin for run/event ==" << theRun << "/" << theEvent
0330 << " ---------------------------------";
0331
0332
0333
0334 if (!thePropagator)
0335 thePropagator = new Geant4ePropagator(&*bField);
0336
0337 if (thePropagator)
0338 LogDebug("Geant4e") << "Propagator built!";
0339 else
0340 LogError("Geant4e") << "Could not build propagator!";
0341
0342
0343
0344 Handle<SimTrackContainer> simTracks = iEvent.getHandle(simTrackToken_);
0345 if (!simTracks.isValid()) {
0346 LogWarning("Geant4e") << "No tracks found" << std::endl;
0347 return;
0348 }
0349 LogDebug("Geant4e") << "G4e -- Got simTracks of size " << simTracks->size();
0350
0351 Handle<SimVertexContainer> simVertices = iEvent.getHandle(simVertexToken_);
0352 if (!simVertices.isValid()) {
0353 LogWarning("Geant4e") << "No vertices found" << std::endl;
0354 return;
0355 }
0356 LogDebug("Geant4e") << "Got simVertices of size " << simVertices->size();
0357
0358
0359
0360 Handle<PSimHitContainer> simHitsDT = iEvent.getHandle(simHitsDTToken_);
0361 if (!simHitsDT.isValid()) {
0362 LogWarning("Geant4e") << "No hits found" << std::endl;
0363 return;
0364 }
0365 LogDebug("Geant4e") << "Got MuonDTHits of size " << simHitsDT->size();
0366
0367 Handle<PSimHitContainer> simHitsCSC = iEvent.getHandle(simHitsCSCToken_);
0368 if (!simHitsCSC.isValid()) {
0369 LogWarning("Geant4e") << "No hits found" << std::endl;
0370 return;
0371 }
0372 LogDebug("Geant4e") << "Got MuonCSCHits of size " << simHitsCSC->size();
0373
0374 Handle<PSimHitContainer> simHitsRPC = iEvent.getHandle(simHitsRPCToken_);
0375 if (!simHitsRPC.isValid()) {
0376 LogWarning("Geant4e") << "No hits found" << std::endl;
0377 return;
0378 }
0379 LogDebug("Geant4e") << "Got MuonRPCHits of size " << simHitsRPC->size();
0380
0381
0382
0383
0384
0385 unsigned int counter = 0;
0386
0387 for (SimTrackContainer::const_iterator simTracksIt = simTracks->begin(); simTracksIt != simTracks->end();
0388 simTracksIt++) {
0389
0390 counter++;
0391 LogDebug("Geant4e") << "G4e -- Iterating over " << counter << "rd track. Number: " << simTracksIt->genpartIndex()
0392 << "------------------";
0393
0394
0395 int simTrackPDG = simTracksIt->type();
0396 if (abs(simTrackPDG) != 13) {
0397 continue;
0398 }
0399 LogDebug("Geant4e") << "G4e -- Track PDG " << simTrackPDG;
0400
0401
0402
0403
0404
0405 int trkPDG = simTracksIt->type();
0406 if (abs(trkPDG) != 13) {
0407 LogDebug("Geant4e") << "Track is not a muon: " << trkPDG;
0408 continue;
0409 } else
0410 LogDebug("Geant4e") << "Found a muon track " << trkPDG;
0411
0412
0413 GlobalVector p3T = TrackPropagation::hep3VectorToGlobalVector(
0414 CLHEP::Hep3Vector(simTracksIt->momentum().x(), simTracksIt->momentum().y(), simTracksIt->momentum().z()));
0415 if (p3T.perp() < 2.) {
0416 LogDebug("Geant4e") << "Track PT is too low: " << p3T.perp();
0417 continue;
0418 } else {
0419 LogDebug("Geant4e") << "*** Phi (rad): " << p3T.phi() << " - Phi(deg)" << p3T.phi().degrees();
0420 LogDebug("Geant4e") << "Track PT is enough.";
0421 LogDebug("Geant4e") << "Track P.: " << p3T << "\nTrack P.: PT=" << p3T.perp() << "\tEta=" << p3T.eta()
0422 << "\tPhi=" << p3T.phi().degrees() << "--> Rad: Phi=" << p3T.phi();
0423 }
0424
0425
0426 int vtxInd = simTracksIt->vertIndex();
0427 GlobalPoint r3T(0., 0., 0.);
0428 if (vtxInd < 0)
0429 LogDebug("Geant4e") << "Track with no vertex, defaulting to (0,0,0)";
0430 else
0431
0432 r3T = TrackPropagation::hep3VectorToGlobalPoint(CLHEP::Hep3Vector((*simVertices)[vtxInd].position().x(),
0433 (*simVertices)[vtxInd].position().y(),
0434 (*simVertices)[vtxInd].position().z()));
0435
0436 LogDebug("Geant4e") << "Init point: " << r3T << "\nInit point Ro=" << r3T.perp() << "\tEta=" << r3T.eta()
0437 << "\tPhi=" << r3T.phi().degrees();
0438
0439
0440 int charge = trkPDG > 0 ? -1 : 1;
0441 LogDebug("Geant4e") << "Track charge = " << charge;
0442
0443
0444 CurvilinearTrajectoryError covT;
0445
0446
0447
0448 GlobalTrajectoryParameters trackPars(r3T, p3T, charge, &*bField);
0449 FreeTrajectoryState ftsTrack(trackPars, covT);
0450
0451
0452 unsigned int trkInd = simTracksIt->genpartIndex();
0453
0454
0455
0456 iterateOverHits(simHitsDT, DT, trkInd, ftsTrack);
0457
0458
0459
0460
0461
0462
0463
0464 }
0465 }
0466
0467 void Geant4ePropagatorAnalyzer::iterateOverHits(edm::Handle<edm::PSimHitContainer> simHits,
0468 testMuChamberType muonChamberType,
0469 unsigned int trkIndex,
0470 const FreeTrajectoryState &ftsTrack) {
0471 using namespace edm;
0472
0473 if (muonChamberType == DT)
0474 LogDebug("Geant4e") << "G4e -- Iterating over DT hits...";
0475 else if (muonChamberType == RPC)
0476 LogDebug("Geant4e") << "G4e -- Iterating over RPC hits...";
0477 else if (muonChamberType == CSC)
0478 LogDebug("Geant4e") << "G4e -- Iterating over CSC hits...";
0479
0480 for (PSimHitContainer::const_iterator simHitIt = simHits->begin(); simHitIt != simHits->end(); simHitIt++) {
0481
0482
0483 if (simHitIt->trackId() != trkIndex) {
0484 LogDebug("Geant4e") << "Hit (in tr " << simHitIt->trackId() << ") does not belong to track " << trkIndex;
0485 continue;
0486 }
0487
0488 LogDebug("Geant4e") << "G4e -- Hit belongs to track " << trkIndex;
0489
0490
0491
0492 int trkPDG = simHitIt->particleType();
0493 if (abs(trkPDG) != 13) {
0494 LogDebug("Geant4e") << "Associated track is not a muon: " << trkPDG;
0495 continue;
0496 }
0497 LogDebug("Geant4e") << "G4e -- Found a hit corresponding to a muon " << trkPDG;
0498
0499
0500
0501
0502 const GeomDet *layer = nullptr;
0503
0504 DTWireId *wIdDT = nullptr;
0505 if (muonChamberType == DT) {
0506 wIdDT = new DTWireId(simHitIt->detUnitId());
0507 int station = wIdDT->station();
0508 LogDebug("Geant4e") << "G4e -- DT Chamber. Station: " << station << ". DetId: " << wIdDT->layerId();
0509
0510 if (fStudyStation != -1 && fStudyStation != station)
0511 continue;
0512
0513 layer = theDTGeomESH->layer(*wIdDT);
0514 if (layer == nullptr) {
0515 LogDebug("Geant4e") << "Failed to get detector unit";
0516 continue;
0517 }
0518 }
0519
0520 else if (muonChamberType == RPC) {
0521 RPCDetId rpcId(simHitIt->detUnitId());
0522 layer = theRPCGeomESH->idToDet(rpcId);
0523 if (layer == nullptr) {
0524 LogDebug("Geant4e") << "Failed to get detector unit";
0525 continue;
0526 }
0527 }
0528
0529
0530 else if (muonChamberType == CSC) {
0531 CSCDetId cscId(simHitIt->detUnitId());
0532 layer = theCSCGeomESH->idToDet(cscId);
0533 if (layer == nullptr) {
0534 LogDebug("Geant4e") << "Failed to get detector unit";
0535 continue;
0536 }
0537 }
0538
0539 const Surface &surf = layer->surface();
0540 if (layer->geographicalId() != DTLayerId(simHitIt->detUnitId()))
0541 LogError("Geant4e") << "ERROR: wrong DetId";
0542
0543
0544
0545
0546
0547
0548
0549
0550
0551
0552
0553 GlobalVector p3Hit = surf.toGlobal(simHitIt->momentumAtEntry());
0554 if (p3Hit.perp() < 0.5)
0555 continue;
0556 GlobalPoint posHit = surf.toGlobal(simHitIt->localPosition());
0557 Point3DBase<float, GlobalTag> surfpos = surf.position();
0558 LogDebug("Geant4e") << "G4e -- Layer position: " << surfpos << " cm"
0559 << "\nG4e -- Ro=" << surfpos.perp() << "\tEta=" << surfpos.eta()
0560 << "\tPhi=" << surfpos.phi().degrees() << "deg";
0561 LogDebug("Geant4e") << "G4e -- Sim Hit position: " << posHit << " cm"
0562 << "\nG4e -- Ro=" << posHit.perp() << "\tEta=" << posHit.eta()
0563 << "\tPhi=" << posHit.phi().degrees() << "deg"
0564 << "\t localpos=" << simHitIt->localPosition();
0565
0566 const Plane *bp = dynamic_cast<const Plane *>(&surf);
0567 if (bp != nullptr) {
0568 Float_t distance = bp->localZ(posHit);
0569 LogDebug("Geant4e") << "\nG4e -- Distance from plane to sim hit: " << distance << "cm";
0570 fDistanceSHLayer->Fill(distance);
0571 } else {
0572 LogWarning("Geant4e") << "G4e -- Layer is not a Plane!!!";
0573 fDistanceSHLayer->Fill(-1);
0574 }
0575
0576 LogDebug("Geant4e") << "Sim Hit Momentum PT=" << p3Hit.perp() << "\tEta=" << p3Hit.eta()
0577 << "\tPhi=" << p3Hit.phi().degrees() << "deg";
0578
0579
0580
0581 TrajectoryStateOnSurface tSOSDest = thePropagator->propagate(ftsTrack, surf);
0582
0583
0584
0585 GlobalPoint posExtrap = tSOSDest.freeState()->position();
0586
0587
0588
0589
0590 GlobalVector posDistance = posExtrap - posHit;
0591 float distance = posDistance.mag();
0592 float simhitphi = posHit.phi().degrees();
0593 float layerphi = surfpos.phi().degrees();
0594 float extrapphi = posExtrap.phi().degrees();
0595 LogDebug("Geant4e") << "G4e -- Difference between hit and final position: " << distance << " cm\n"
0596 << "G4e -- Transversal difference between hit and final position: " << posDistance.perp()
0597 << " cm.";
0598 LogDebug("Geant4e") << "G4e -- Extrapolated position:" << posExtrap << " cm\n"
0599 << "G4e -- (Rho, eta, phi): (" << posExtrap.perp() << " cm, " << posExtrap.eta() << ", "
0600 << extrapphi << " deg)";
0601 LogDebug("Geant4e") << "G4e -- Hit position: " << posHit << " cm\n"
0602 << "G4e -- (Rho, eta, phi): (" << posHit.perp() << " cm, " << posHit.eta() << ", "
0603 << simhitphi << " deg)";
0604
0605 fDistance->Fill(distance);
0606 fDistanceSt[wIdDT->station() - 1]->Fill(distance);
0607
0608 fHitR->Fill(posHit.mag());
0609 fHitRho->Fill(posHit.perp());
0610 fHitEta->Fill(posHit.eta());
0611 fHitPhi->Fill(simhitphi);
0612 if (posHit.perp() < 500)
0613 fHitPhi1L->Fill(simhitphi);
0614 fHitRVsPhi->Fill(posHit.mag(), simhitphi);
0615
0616 fLayerR->Fill(surfpos.mag());
0617 fLayerRho->Fill(surfpos.perp());
0618 fLayerEta->Fill(surfpos.eta());
0619 fLayerPhi->Fill(layerphi);
0620 fLayerRVsPhi->Fill(surfpos.mag(), layerphi);
0621
0622 fExtrapR->Fill(posExtrap.mag());
0623 fExtrapRho->Fill(posExtrap.perp());
0624 fExtrapEta->Fill(posExtrap.eta());
0625 fExtrapPhi->Fill(extrapphi);
0626 fExtrapRVsPhi->Fill(posExtrap.mag(), extrapphi);
0627
0628 fDeltaRo->Fill(posExtrap.perp() - posHit.perp());
0629 fDeltaEta->Fill(posExtrap.eta() - posHit.eta());
0630 fDeltaPhi->Fill(extrapphi - simhitphi);
0631
0632 if (wIdDT) {
0633 if (simhitphi > 0) {
0634 fStationPosPhi->Fill(wIdDT->station());
0635 fSectorPosPhi->Fill(wIdDT->sector());
0636 fSLayerPosPhi->Fill(wIdDT->superlayer());
0637 fLayerPosPhi->Fill(wIdDT->layer());
0638 } else {
0639 fStationNegPhi->Fill(wIdDT->station());
0640 fSectorNegPhi->Fill(wIdDT->sector());
0641 fSLayerNegPhi->Fill(wIdDT->superlayer());
0642 fLayerNegPhi->Fill(wIdDT->layer());
0643 }
0644
0645 delete wIdDT;
0646 }
0647
0648 }
0649 }
0650
0651
0652 DEFINE_FWK_MODULE(Geant4ePropagatorAnalyzer);