Project CMSSW displayed by LXR |
|
|
|
|||
File indexing completed on 2024-05-22 04:03:13
0001 ////////////////////////////// 0002 // Geometry Checklist // 0003 // Properties of Pt-Modules // 0004 // // 0005 // Nicola Pozzobon - 2011 // 0006 ////////////////////////////// 0007 0008 #include "FWCore/Framework/interface/MakerMacros.h" 0009 #include "FWCore/Framework/interface/one/EDAnalyzer.h" 0010 #include "FWCore/Framework/interface/Event.h" 0011 #include "FWCore/Framework/interface/ESHandle.h" 0012 #include "FWCore/PluginManager/interface/ModuleDef.h" 0013 #include "FWCore/ServiceRegistry/interface/Service.h" 0014 #include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h" 0015 #include "Geometry/CommonDetUnit/interface/PixelGeomDetUnit.h" 0016 #include "Geometry/TrackerNumberingBuilder/interface/GeometricDet.h" 0017 #include "DataFormats/SiPixelDetId/interface/PXBDetId.h" 0018 #include "DataFormats/SiPixelDetId/interface/PXFDetId.h" 0019 #include "CommonTools/UtilAlgos/interface/TFileService.h" 0020 #include <TH2D.h> 0021 #include <TH1D.h> 0022 #include <fstream> 0023 0024 ////////////////////////////// 0025 // // 0026 // CLASS DEFINITION // 0027 // // 0028 ////////////////////////////// 0029 0030 class AnalyzerPrintGeomInfo : public edm::one::EDAnalyzer<edm::one::WatchRuns, edm::one::SharedResources> { 0031 /// Public methods 0032 public: 0033 /// Constructor/destructor 0034 explicit AnalyzerPrintGeomInfo(const edm::ParameterSet& iConfig); 0035 ~AnalyzerPrintGeomInfo() override; 0036 // Typical methods used on Loops over events 0037 void beginJob() override; 0038 void endJob() override; 0039 void beginRun(const edm::Run& iEvent, const edm::EventSetup& iSetup) override {} 0040 void endRun(const edm::Run& iEvent, const edm::EventSetup& iSetup) override {} 0041 void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) override; 0042 0043 /// Private methods and variables 0044 private: 0045 std::string TextOutput; 0046 bool DebugMode; 0047 0048 bool testedGeometry; 0049 bool debugPrintouts; 0050 0051 /// Output file 0052 std::ofstream outputFile; 0053 0054 /// Containers of parameters passed by python 0055 /// configuration file 0056 edm::ParameterSet config; 0057 0058 /// Histograms 0059 TH2D* hPXB_Lay_R; 0060 std::map<unsigned int, TH2D*> mapPXB2Lay_hPXB_Lad_Mod; 0061 std::map<unsigned int, TH2D*> mapPXB2Lay_hPXB_Lad_Phi; 0062 std::map<unsigned int, TH2D*> mapPXB2Lay_hPXB_Mod_Z; 0063 std::map<unsigned int, TH2D*> mapPXB2Lay_hPXB_Lad_R; 0064 std::map<unsigned int, TH2D*> mapPXB2Lay_hPXB_Mod_R; 0065 std::map<unsigned int, TH1D*> mapPXB2Lay_hPXB_R; 0066 0067 TH2D* hPXF_Disk00_Disk; 0068 TH2D* hPXF_Disk00_Side; 0069 TH2D* hPXF_Disk00_Z; 0070 TH2D* hPXF_Disk00_R; 0071 std::map<unsigned int, TH2D*> mapPXF2Disk00_hPXF_Pan_Mod; 0072 std::map<unsigned int, TH2D*> mapPXF2Disk00_hPXF_Bla_Mod; 0073 std::map<unsigned int, TH2D*> mapPXF2Disk00_hPXF_Bla_Pan; 0074 std::map<unsigned int, TH2D*> mapPXF2Disk00_hPXF_Pan_R; 0075 std::map<unsigned int, TH2D*> mapPXF2Disk00_hPXF_Mod_R; 0076 std::map<unsigned int, TH2D*> mapPXF2Disk00_hPXF_Bla_R; 0077 std::map<unsigned int, TH2D*> mapPXF2Disk00_hPXF_Disk_R; 0078 std::map<unsigned int, TH2D*> mapPXF2Disk00_hPXF_Pan_Phi; 0079 std::map<unsigned int, TH2D*> mapPXF2Disk00_hPXF_Mod_Phi; 0080 std::map<unsigned int, TH2D*> mapPXF2Disk00_hPXF_Bla_Phi; 0081 std::map<unsigned int, TH2D*> mapPXF2Disk00_hPXF_Pan_Z; 0082 std::map<unsigned int, TH2D*> mapPXF2Disk00_hPXF_Mod_Z; 0083 std::map<unsigned int, TH2D*> mapPXF2Disk00_hPXF_Bla_Z; 0084 std::map<unsigned int, TH2D*> mapPXF2Disk00_hPXF_Disk_Z; 0085 }; 0086 0087 ////////////////////////////////// 0088 // // 0089 // CLASS IMPLEMENTATION // 0090 // // 0091 ////////////////////////////////// 0092 0093 ////////////// 0094 // CONSTRUCTOR 0095 AnalyzerPrintGeomInfo::AnalyzerPrintGeomInfo(edm::ParameterSet const& iConfig) : config(iConfig) { 0096 /// Insert here what you need to initialize 0097 usesResource("TFileService"); 0098 TextOutput = iConfig.getParameter<std::string>("TextOutput"); 0099 DebugMode = iConfig.getParameter<bool>("DebugMode"); 0100 0101 /// Open the output file 0102 outputFile.open(TextOutput, std::ios::out); 0103 } 0104 0105 ///////////// 0106 // DESTRUCTOR 0107 AnalyzerPrintGeomInfo::~AnalyzerPrintGeomInfo() { 0108 /// Insert here what you need to delete 0109 /// when you close the class instance 0110 } 0111 0112 ////////// 0113 // END JOB 0114 void AnalyzerPrintGeomInfo::endJob() //edm::Run& run, const edm::EventSetup& iSetup 0115 { 0116 /// Things to be done at the exit of the event Loop 0117 outputFile.close(); 0118 0119 std::cerr << " AnalyzerPrintGeomInfo::endJob" << std::endl; 0120 /// End of things to be done at the exit from the event Loop 0121 } 0122 0123 //////////// 0124 // BEGIN JOB 0125 void AnalyzerPrintGeomInfo::beginJob() { 0126 std::ostringstream histoName; 0127 std::ostringstream histoTitle; 0128 0129 /// Things to be done before entering the event Loop 0130 std::cerr << " AnalyzerPrintGeomInfo::beginJob" << std::endl; 0131 0132 edm::Service<TFileService> fs; 0133 0134 hPXB_Lay_R = fs->make<TH2D>("hPXB_Lay_R", "PXB Layer vs R (cm)", 250, 0, 125, 18, -0.5, 17.5); 0135 hPXB_Lay_R->Sumw2(); 0136 0137 for (unsigned int layer = 0; layer < 18; layer++) { 0138 histoName.str(""); 0139 histoName << "hPXB_Lad_Mod_" << layer; 0140 histoTitle.str(""); 0141 histoTitle << "PXB Ladder vs Module, Layer " << layer; 0142 mapPXB2Lay_hPXB_Lad_Mod[layer] = 0143 fs->make<TH2D>(histoName.str().c_str(), histoTitle.str().c_str(), 201, -0.5, 200.5, 201, -0.5, 200.5); 0144 mapPXB2Lay_hPXB_Lad_Mod[layer]->Sumw2(); 0145 0146 histoName.str(""); 0147 histoName << "hPXB_Lad_Phi_" << layer; 0148 histoTitle.str(""); 0149 histoTitle << "PXB Ladder vs #phi, Layer " << layer; 0150 mapPXB2Lay_hPXB_Lad_Phi[layer] = 0151 fs->make<TH2D>(histoName.str().c_str(), histoTitle.str().c_str(), 180, -M_PI, M_PI, 201, -0.5, 200.5); 0152 mapPXB2Lay_hPXB_Lad_Phi[layer]->Sumw2(); 0153 0154 histoName.str(""); 0155 histoName << "hPXB_Mod_Z_" << layer; 0156 histoTitle.str(""); 0157 histoTitle << "PXB Module vs z (cm), Layer " << layer; 0158 mapPXB2Lay_hPXB_Mod_Z[layer] = 0159 fs->make<TH2D>(histoName.str().c_str(), histoTitle.str().c_str(), 600, -300, 300, 201, -0.5, 200.5); 0160 mapPXB2Lay_hPXB_Mod_Z[layer]->Sumw2(); 0161 0162 histoName.str(""); 0163 histoName << "hPXB_Lad_R_" << layer; 0164 histoTitle.str(""); 0165 histoTitle << "PXB Ladder vs R (cm), Layer " << layer; 0166 mapPXB2Lay_hPXB_Lad_R[layer] = 0167 fs->make<TH2D>(histoName.str().c_str(), histoTitle.str().c_str(), 250, 0, 125, 201, -0.5, 200.5); 0168 mapPXB2Lay_hPXB_Lad_R[layer]->Sumw2(); 0169 0170 histoName.str(""); 0171 histoName << "hPXB_Mod_R_" << layer; 0172 histoTitle.str(""); 0173 histoTitle << "PXB Module vs R (cm), Layer " << layer; 0174 mapPXB2Lay_hPXB_Mod_R[layer] = 0175 fs->make<TH2D>(histoName.str().c_str(), histoTitle.str().c_str(), 250, 0, 125, 201, -0.5, 200.5); 0176 mapPXB2Lay_hPXB_Mod_R[layer]->Sumw2(); 0177 0178 histoName.str(""); 0179 histoName << "hPXB_R_" << layer; 0180 histoTitle.str(""); 0181 histoTitle << "PXB R (cm), Layer " << layer; 0182 mapPXB2Lay_hPXB_R[layer] = fs->make<TH1D>(histoName.str().c_str(), histoTitle.str().c_str(), 250, 0, 125); 0183 mapPXB2Lay_hPXB_R[layer]->Sumw2(); 0184 } 0185 0186 hPXF_Disk00_Disk = fs->make<TH2D>("hPXF_Disk00_Disk", "PXF Disk00 vs Disk", 18, -0.5, 17.5, 58, -0.5, 57.5); 0187 hPXF_Disk00_Disk->Sumw2(); 0188 hPXF_Disk00_Side = fs->make<TH2D>("hPXF_Disk00_Side", "PXF Disk00 vs Side", 7, -3.5, 3.5, 58, -0.5, 57.5); 0189 hPXF_Disk00_Side->Sumw2(); 0190 hPXF_Disk00_Z = fs->make<TH2D>("hPXF_Disk00_Z", "PXF Disk00 vs z (cm)", 600, -300, 300, 58, -0.5, 57.5); 0191 hPXF_Disk00_Z->Sumw2(); 0192 hPXF_Disk00_R = fs->make<TH2D>("hPXF_Disk00_R", "PXF Disk00 vs R (cm)", 250, 0, 125, 58, -0.5, 57.5); 0193 hPXF_Disk00_R->Sumw2(); 0194 0195 for (unsigned int disc = 0; disc < 58; disc++) { 0196 histoName.str(""); 0197 histoName << "hPXF_Pan_Mod_" << disc; 0198 histoTitle.str(""); 0199 histoTitle << "PXF Panel vs Module, Disk00 " << disc; 0200 mapPXF2Disk00_hPXF_Pan_Mod[disc] = 0201 fs->make<TH2D>(histoName.str().c_str(), histoTitle.str().c_str(), 201, -0.5, 200.5, 11, -0.5, 10.5); 0202 mapPXF2Disk00_hPXF_Pan_Mod[disc]->Sumw2(); 0203 0204 histoName.str(""); 0205 histoName << "hPXF_Bla_Mod_" << disc; 0206 histoTitle.str(""); 0207 histoTitle << "PXF Blade vs Module, Disk00 " << disc; 0208 mapPXF2Disk00_hPXF_Bla_Mod[disc] = 0209 fs->make<TH2D>(histoName.str().c_str(), histoTitle.str().c_str(), 201, -0.5, 200.5, 85, -0.5, 84.5); 0210 mapPXF2Disk00_hPXF_Bla_Mod[disc]->Sumw2(); 0211 0212 histoName.str(""); 0213 histoName << "hPXF_Bla_Pan_" << disc; 0214 histoTitle.str(""); 0215 histoTitle << "PXF Blade vs Panel, Disk00 " << disc; 0216 mapPXF2Disk00_hPXF_Bla_Pan[disc] = 0217 fs->make<TH2D>(histoName.str().c_str(), histoTitle.str().c_str(), 11, -0.5, 10.5, 85, -0.5, 84.5); 0218 mapPXF2Disk00_hPXF_Bla_Pan[disc]->Sumw2(); 0219 0220 histoName.str(""); 0221 histoName << "hPXF_Pan_R_" << disc; 0222 histoTitle.str(""); 0223 histoTitle << "PXF Panel vs R (cm), Disk00 " << disc; 0224 mapPXF2Disk00_hPXF_Pan_R[disc] = 0225 fs->make<TH2D>(histoName.str().c_str(), histoTitle.str().c_str(), 250, 0, 125, 11, -0.5, 10.5); 0226 mapPXF2Disk00_hPXF_Pan_R[disc]->Sumw2(); 0227 0228 histoName.str(""); 0229 histoName << "hPXF_Mod_R_" << disc; 0230 histoTitle.str(""); 0231 histoTitle << "PXF Module vs R (cm), Disk00 " << disc; 0232 mapPXF2Disk00_hPXF_Mod_R[disc] = 0233 fs->make<TH2D>(histoName.str().c_str(), histoTitle.str().c_str(), 250, 0, 125, 201, -0.5, 200.5); 0234 mapPXF2Disk00_hPXF_Mod_R[disc]->Sumw2(); 0235 0236 histoName.str(""); 0237 histoName << "hPXF_Bla_R_" << disc; 0238 histoTitle.str(""); 0239 histoTitle << "PXF Blade vs R (cm), Disk00 " << disc; 0240 mapPXF2Disk00_hPXF_Bla_R[disc] = 0241 fs->make<TH2D>(histoName.str().c_str(), histoTitle.str().c_str(), 250, 0, 125, 85, -0.5, 84.5); 0242 mapPXF2Disk00_hPXF_Bla_R[disc]->Sumw2(); 0243 0244 histoName.str(""); 0245 histoName << "hPXF_Pan_Z_" << disc; 0246 histoTitle.str(""); 0247 histoTitle << "PXF Panel vs z (cm), Disk00 " << disc; 0248 mapPXF2Disk00_hPXF_Pan_Z[disc] = 0249 fs->make<TH2D>(histoName.str().c_str(), histoTitle.str().c_str(), 600, -300, 300, 11, -0.5, 10.5); 0250 mapPXF2Disk00_hPXF_Pan_Z[disc]->Sumw2(); 0251 0252 histoName.str(""); 0253 histoName << "hPXF_Mod_Z_" << disc; 0254 histoTitle.str(""); 0255 histoTitle << "PXF Module vs z (cm), Disk00 " << disc; 0256 mapPXF2Disk00_hPXF_Mod_Z[disc] = 0257 fs->make<TH2D>(histoName.str().c_str(), histoTitle.str().c_str(), 600, -300, 300, 201, -0.5, 200.5); 0258 mapPXF2Disk00_hPXF_Mod_Z[disc]->Sumw2(); 0259 0260 histoName.str(""); 0261 histoName << "hPXF_Bla_Z_" << disc; 0262 histoTitle.str(""); 0263 histoTitle << "PXF Blade vs z (cm), Disk00 " << disc; 0264 mapPXF2Disk00_hPXF_Bla_Z[disc] = 0265 fs->make<TH2D>(histoName.str().c_str(), histoTitle.str().c_str(), 600, -300, 300, 85, -0.5, 84.5); 0266 mapPXF2Disk00_hPXF_Bla_Z[disc]->Sumw2(); 0267 0268 histoName.str(""); 0269 histoName << "hPXF_Pan_Phi_" << disc; 0270 histoTitle.str(""); 0271 histoTitle << "PXF Panel vs #phi, Disk00 " << disc; 0272 mapPXF2Disk00_hPXF_Pan_Phi[disc] = 0273 fs->make<TH2D>(histoName.str().c_str(), histoTitle.str().c_str(), 180, -M_PI, M_PI, 11, -0.5, 10.5); 0274 mapPXF2Disk00_hPXF_Pan_Phi[disc]->Sumw2(); 0275 0276 histoName.str(""); 0277 histoName << "hPXF_Mod_Phi_" << disc; 0278 histoTitle.str(""); 0279 histoTitle << "PXF Module vs #phi, Disk00 " << disc; 0280 mapPXF2Disk00_hPXF_Mod_Phi[disc] = 0281 fs->make<TH2D>(histoName.str().c_str(), histoTitle.str().c_str(), 180, -M_PI, M_PI, 201, -0.5, 200.5); 0282 mapPXF2Disk00_hPXF_Mod_Phi[disc]->Sumw2(); 0283 0284 histoName.str(""); 0285 histoName << "hPXF_Bla_Phi_" << disc; 0286 histoTitle.str(""); 0287 histoTitle << "PXF Blade vs #phi, Disk00 " << disc; 0288 mapPXF2Disk00_hPXF_Bla_Phi[disc] = 0289 fs->make<TH2D>(histoName.str().c_str(), histoTitle.str().c_str(), 180, -M_PI, M_PI, 85, -0.5, 84.5); 0290 mapPXF2Disk00_hPXF_Bla_Phi[disc]->Sumw2(); 0291 0292 histoName.str(""); 0293 histoName << "hPXF_Disk_R_" << disc; 0294 histoTitle.str(""); 0295 histoTitle << "PXF Disk vs R (cm), Disk00 " << disc; 0296 mapPXF2Disk00_hPXF_Disk_R[disc] = 0297 fs->make<TH2D>(histoName.str().c_str(), histoTitle.str().c_str(), 250, 0, 125, 58, -0.5, 57.5); 0298 mapPXF2Disk00_hPXF_Disk_R[disc]->Sumw2(); 0299 0300 histoName.str(""); 0301 histoName << "hPXF_Disk_Z_" << disc; 0302 histoTitle.str(""); 0303 histoTitle << "PXF Disk vs z (cm), Disk00 " << disc; 0304 mapPXF2Disk00_hPXF_Disk_Z[disc] = 0305 fs->make<TH2D>(histoName.str().c_str(), histoTitle.str().c_str(), 600, -300, 300, 58, -0.5, 57.5); 0306 mapPXF2Disk00_hPXF_Disk_Z[disc]->Sumw2(); 0307 } 0308 0309 /// End of things to be done before entering the event Loop 0310 } 0311 0312 ////////// 0313 // ANALYZE 0314 void AnalyzerPrintGeomInfo::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { 0315 /* 0316 /// Geometry handles etc 0317 edm::ESHandle<TrackerGeometry> geometryHandle; 0318 const TrackerGeometry* theGeometry; 0319 edm::ESHandle<StackedTrackerGeometry> stackedGeometryHandle; 0320 const StackedTrackerGeometry* theStackedGeometry; 0321 StackedTrackerGeometry::StackContainerIterator StackedTrackerIterator; 0322 0323 /// Geometry setup 0324 /// Set pointers to Geometry 0325 iSetup.get<TrackerDigiGeometryRecord>().get(geometryHandle); 0326 theGeometry = &(*geometryHandle); 0327 /// Set pointers to Stacked Modules 0328 iSetup.get<StackedTrackerGeometryRecord>().get(stackedGeometryHandle); 0329 theStackedGeometry = stackedGeometryHandle.product(); /// Note this is different 0330 /// from the "global" geometry 0331 0332 /// GeometricDet 0333 /// This is used to get more information on Modules 0334 const GeometricDet* theTrackerGeometricDet = theGeometry->trackerDet(); 0335 std::vector< const GeometricDet* > theModules = theTrackerGeometricDet->deepComponents(); 0336 0337 /// Loop over Stacks 0338 /// Count how many Stacks there are 0339 /// divide it by Layer etc... 0340 0341 /// Maps to store information by layer 0342 /// Compare to StackedTrackerGeometryBuilder--->Checksums and final summary 0343 0344 /// PXB 0345 std::map< uint32_t, uint32_t > rodsPerLayer; 0346 std::map< uint32_t, uint32_t > modsPerRodPerLayer; /// Assumes all Rods are identical within a Layer 0347 std::map< uint32_t, std::map< uint32_t, bool > > inOutPerRodPerLayer; /// TRUE if innerMod = outerMod + 1 0348 0349 std::map< uint32_t, double > innerModRadPerLayer; 0350 std::map< uint32_t, double > outerModRadPerLayer; 0351 std::map< uint32_t, double > separationPerLayer; 0352 std::map< uint32_t, double > maxLengthPerLayer; 0353 std::map< uint32_t, double > activeSurfacePerLayer; 0354 0355 std::map< uint32_t, float > innerModXPitchPerLayer; 0356 std::map< uint32_t, float > outerModXPitchPerLayer; 0357 std::map< uint32_t, float > innerModYPitchPerLayer; 0358 std::map< uint32_t, float > outerModYPitchPerLayer; 0359 0360 std::map< uint32_t, uint32_t > innerModChannelsPerLayer; 0361 std::map< uint32_t, uint32_t > outerModChannelsPerLayer; 0362 0363 std::map< uint32_t, uint32_t > innerModXROCPerLayer; 0364 std::map< uint32_t, uint32_t > outerModXROCPerLayer; 0365 std::map< uint32_t, uint32_t > innerModYROCPerLayer; 0366 std::map< uint32_t, uint32_t > outerModYROCPerLayer; 0367 std::map< uint32_t, uint32_t > innerModTotROCPerLayer; 0368 std::map< uint32_t, uint32_t > outerModTotROCPerLayer; 0369 0370 std::map< uint32_t, uint32_t > innerModColumnsPerLayer; 0371 std::map< uint32_t, uint32_t > outerModColumnsPerLayer; 0372 std::map< uint32_t, uint32_t > innerModRowsPerLayer; 0373 std::map< uint32_t, uint32_t > outerModRowsPerLayer; 0374 0375 /// PXF 0376 std::map< uint32_t, uint32_t > ringsPerDisk; 0377 std::map< uint32_t, std::map< uint32_t, uint32_t > > modsPerRingPerDisk; /// Assumes all Rings are different within a Disk 0378 std::map< uint32_t, std::map< uint32_t, bool > > inOutPerRingPerDisk; /// TRUE if innerMod = outerMod + 1 0379 0380 std::map< uint32_t, std::map< uint32_t, double > > innerModZPerRingPerDisk; 0381 std::map< uint32_t, std::map< uint32_t, double > > outerModZPerRingPerDisk; 0382 std::map< uint32_t, std::map< uint32_t, double > > separationPerRingPerDisk; 0383 std::map< uint32_t, std::map< uint32_t, double > > maxLengthPerRingPerDisk; 0384 std::map< uint32_t, std::map< uint32_t, double > > activeSurfacePerRingPerDisk; 0385 0386 std::map< uint32_t, std::map< uint32_t, float > > innerModXPitchPerRingPerDisk; 0387 std::map< uint32_t, std::map< uint32_t, float > > outerModXPitchPerRingPerDisk; 0388 std::map< uint32_t, std::map< uint32_t, float > > innerModYPitchPerRingPerDisk; 0389 std::map< uint32_t, std::map< uint32_t, float > > outerModYPitchPerRingPerDisk; 0390 0391 std::map< uint32_t, std::map< uint32_t, uint32_t > > innerModChannelsPerRingPerDisk; 0392 std::map< uint32_t, std::map< uint32_t, uint32_t > > outerModChannelsPerRingPerDisk; 0393 0394 std::map< uint32_t, std::map< uint32_t, uint32_t > > innerModXROCPerRingPerDisk; 0395 std::map< uint32_t, std::map< uint32_t, uint32_t > > outerModXROCPerRingPerDisk; 0396 std::map< uint32_t, std::map< uint32_t, uint32_t > > innerModYROCPerRingPerDisk; 0397 std::map< uint32_t, std::map< uint32_t, uint32_t > > outerModYROCPerRingPerDisk; 0398 std::map< uint32_t, std::map< uint32_t, uint32_t > > innerModTotROCPerRingPerDisk; 0399 std::map< uint32_t, std::map< uint32_t, uint32_t > > outerModTotROCPerRingPerDisk; 0400 0401 std::map< uint32_t, std::map< uint32_t, uint32_t > > innerModColumnsPerRingPerDisk; 0402 std::map< uint32_t, std::map< uint32_t, uint32_t > > outerModColumnsPerRingPerDisk; 0403 std::map< uint32_t, std::map< uint32_t, uint32_t > > innerModRowsPerRingPerDisk; 0404 std::map< uint32_t, std::map< uint32_t, uint32_t > > outerModRowsPerRingPerDisk; 0405 0406 0407 /// Validation maps for Geometry 0408 /// Loop only on different sets of sub-tracker detectors 0409 /// PXB 0410 std::vector<GeomDet*> pxbcont = theGeometry->detsPXB(); 0411 for ( unsigned int i = 0; i < pxbcont.size(); i++ ) 0412 { 0413 DetId id0 = pxbcont[i]->geographicalId(); 0414 PXBDetId detId0 = PXBDetId(id0.rawId()); 0415 0416 unsigned int layer0 = detId0.layer(); 0417 unsigned int ladder0 = detId0.ladder(); 0418 unsigned int module0 = detId0.module(); 0419 0420 /// Get the position of each sensor 0421 double r0 = pxbcont[i]->position().perp(); 0422 double z0 = pxbcont[i]->position().z(); 0423 double phi0 = pxbcont[i]->position().phi(); 0424 0425 hPXB_Lay_R->Fill( r0, layer0 ); 0426 mapPXB2Lay_hPXB_Lad_Mod[ layer0 ]->Fill( module0, ladder0 ); 0427 mapPXB2Lay_hPXB_Lad_Phi[ layer0 ]->Fill( phi0, ladder0 ); 0428 mapPXB2Lay_hPXB_Mod_Z[ layer0 ]->Fill( z0, module0 ); 0429 mapPXB2Lay_hPXB_Lad_R[ layer0 ]->Fill( r0, ladder0 ); 0430 mapPXB2Lay_hPXB_Mod_R[ layer0 ]->Fill( r0, module0 ); 0431 mapPXB2Lay_hPXB_R[ layer0 ]->Fill( r0 ); 0432 } 0433 0434 /// PXF 0435 std::vector<GeomDet*> pxfcont = theGeometry->detsPXF(); 0436 for ( unsigned int i = 0; i < pxfcont.size(); i++ ) 0437 { 0438 DetId id0 = pxfcont[i]->geographicalId(); 0439 PXFDetId detId0 = PXFDetId(id0.rawId()); 0440 0441 unsigned int side0 = detId0.side(); 0442 unsigned int disk0 = detId0.disk(); 0443 unsigned int blade0; 0444 if (disk0 < 4) blade0 = detId0.blade(); 0445 else blade0 = detId0.ring(); 0446 unsigned int panel0 = detId0.panel(); 0447 unsigned int module0 = detId0.module(); 0448 0449 unsigned int disk00 = 2*disk0 + side0%2; 0450 0451 /// Get the position of each sensor 0452 double r0 = pxfcont[i]->position().perp(); 0453 double z0 = pxfcont[i]->position().z(); 0454 double phi0 = pxfcont[i]->position().phi(); 0455 0456 hPXF_Disk00_Disk->Fill( disk0, disk00 ); 0457 hPXF_Disk00_Side->Fill( side0, disk00 ); 0458 hPXF_Disk00_Z->Fill( z0, disk00 ); 0459 hPXF_Disk00_R->Fill( r0, disk00 ); 0460 0461 mapPXF2Disk00_hPXF_Pan_Mod[ disk00 ]->Fill( module0, panel0 ); 0462 mapPXF2Disk00_hPXF_Bla_Mod[ disk00 ]->Fill( module0, blade0 ); 0463 mapPXF2Disk00_hPXF_Bla_Pan[ disk00 ]->Fill( panel0, blade0 ); 0464 mapPXF2Disk00_hPXF_Pan_R[ disk00 ]->Fill( r0, panel0 ); 0465 mapPXF2Disk00_hPXF_Pan_Z[ disk00 ]->Fill( z0, panel0 ); 0466 mapPXF2Disk00_hPXF_Pan_Phi[ disk00 ]->Fill( phi0, panel0 ); 0467 mapPXF2Disk00_hPXF_Mod_R[ disk00 ]->Fill( r0, module0 ); 0468 mapPXF2Disk00_hPXF_Mod_Z[ disk00 ]->Fill( z0, module0 ); 0469 mapPXF2Disk00_hPXF_Mod_Phi[ disk00 ]->Fill( phi0, module0 ); 0470 mapPXF2Disk00_hPXF_Bla_R[ disk00 ]->Fill( r0, blade0 ); 0471 mapPXF2Disk00_hPXF_Bla_Z[ disk00 ]->Fill( z0, blade0 ); 0472 mapPXF2Disk00_hPXF_Bla_Phi[ disk00 ]->Fill( phi0, blade0 ); 0473 mapPXF2Disk00_hPXF_Disk_R[ disk00 ]->Fill( r0, disk0 ); 0474 mapPXF2Disk00_hPXF_Disk_Z[ disk00 ]->Fill( z0, disk0 ); 0475 } 0476 0477 /// Loop over the detector elements 0478 /// Information from each sensor in each PtModule must be retrieved! 0479 for ( StackedTrackerIterator = theStackedGeometry->stacks().begin(); 0480 StackedTrackerIterator != theStackedGeometry->stacks().end(); 0481 ++StackedTrackerIterator ) 0482 { 0483 StackedTrackerDetUnit* stackDetUnit = *StackedTrackerIterator; 0484 StackedTrackerDetId stackDetId = stackDetUnit->Id(); 0485 assert(stackDetUnit == theStackedGeometry->idToStack(stackDetId)); 0486 0487 /// GeomDet and GeomDetUnit are needed to access each 0488 /// DetId and topology and geometric features 0489 /// Convert to specific DetId 0490 const GeomDet* det0 = theStackedGeometry->idToDet(stackDetId, 0); 0491 const GeomDet* det1 = theStackedGeometry->idToDet(stackDetId, 1); 0492 const GeomDetUnit* detUnit0 = theStackedGeometry->idToDetUnit(stackDetId, 0); 0493 const GeomDetUnit* detUnit1 = theStackedGeometry->idToDetUnit(stackDetId, 1); 0494 0495 /// Barrel 0496 if ( stackDetId.isBarrel() ) 0497 { 0498 PXBDetId detId0 = PXBDetId(det0->geographicalId().rawId()); 0499 PXBDetId detId1 = PXBDetId(det1->geographicalId().rawId()); 0500 0501 /// Get the Stack, iPhi, iZ from StackedTrackerDetId 0502 uint32_t iStack = stackDetId.iLayer(); 0503 uint32_t iPhi = stackDetId.iPhi(); 0504 uint32_t iZ = stackDetId.iZ(); 0505 0506 /// Get index-coordinates of each sensor from DetId 0507 uint32_t iLayer0 = detId0.layer(); 0508 uint32_t iLayer1 = detId1.layer(); 0509 uint32_t iRod0 = detId0.ladder(); 0510 uint32_t iRod1 = detId1.ladder(); 0511 uint32_t iModule0 = detId0.module(); 0512 uint32_t iModule1 = detId1.module(); 0513 0514 if ( DebugMode ) 0515 { 0516 std::cerr << "Stack: " << iStack << " from Layers: " << iLayer0 << " " << iLayer1 << std::endl; 0517 std::cerr << "Phi: " << iPhi << " from Rods: " << iRod0 << " " << iRod1 << std::endl; 0518 std::cerr << "Z: " << iZ << " from Modules: " << iModule0 << " " << iModule1 << " >>> " << (iModule0 == iModule1 + 1) << std::endl; 0519 } 0520 0521 /// Store the size of rods and layers 0522 if ( rodsPerLayer.find(iStack) == rodsPerLayer.end() ) 0523 rodsPerLayer.insert( std::make_pair(iStack, 0) ); 0524 if ( iPhi >= rodsPerLayer[iStack] ) 0525 rodsPerLayer[iStack] = iPhi; 0526 0527 if ( modsPerRodPerLayer.find(iStack) == modsPerRodPerLayer.end() ) 0528 modsPerRodPerLayer.insert( std::make_pair(iStack, 0) ); 0529 if ( iZ >= modsPerRodPerLayer[iStack] ) 0530 modsPerRodPerLayer[iStack] = iZ; 0531 0532 /// This is a debug control that checks if 0533 /// the pairing in Z follows index-based logic 0534 /// of innerZ = outerZ + 1 or not 0535 if ( inOutPerRodPerLayer.find(iStack) == inOutPerRodPerLayer.end() ) 0536 { 0537 /// New Layer, new Rod 0538 std::map< uint32_t, bool > tempMap; 0539 tempMap.insert( std::make_pair(iPhi, (iModule1 == (iModule0 + 1))) ); 0540 inOutPerRodPerLayer.insert( std::make_pair(iStack, tempMap) ); 0541 } 0542 else 0543 { 0544 /// Existing Layer 0545 std::map< uint32_t, bool > tempMap = inOutPerRodPerLayer.find(iStack)->second; 0546 if ( tempMap.find(iPhi) == tempMap.end() ) 0547 { 0548 /// New Rod 0549 tempMap.insert( std::make_pair(iPhi, (iModule1 == (iModule0 + 1))) ); 0550 } 0551 else 0552 { 0553 /// Existing Rod 0554 tempMap.find(iPhi)->second = tempMap.find(iPhi)->second && (iModule1 == (iModule0 + 1)); 0555 } 0556 inOutPerRodPerLayer.find(iStack)->second = tempMap; 0557 } 0558 0559 /// Get the radius of each sensor and its z 0560 double r0 = det0->position().perp(); 0561 double r1 = det1->position().perp(); 0562 double z0 = det0->position().z(); 0563 double z1 = det1->position().z(); 0564 0565 /// Store radii to find average radius of inner and outer sensor 0566 /// in each Stack layer, and sensor separation in Stacks as well 0567 if ( innerModRadPerLayer.find(iStack) == innerModRadPerLayer.end() ) 0568 innerModRadPerLayer.insert( std::make_pair(iStack, 0) ); 0569 innerModRadPerLayer[iStack] += r0; 0570 if ( outerModRadPerLayer.find(iStack) == outerModRadPerLayer.end() ) 0571 outerModRadPerLayer.insert( std::make_pair(iStack, 0) ); 0572 outerModRadPerLayer[iStack] += r1; 0573 if ( separationPerLayer.find(iStack) == separationPerLayer.end() ) 0574 separationPerLayer.insert( std::make_pair(iStack, 0) ); 0575 separationPerLayer[iStack] += fabs(r1-r0); 0576 0577 /// Store max length 0578 if ( maxLengthPerLayer.find(iStack) == maxLengthPerLayer.end() ) 0579 maxLengthPerLayer.insert( std::make_pair(iStack, 0) ); 0580 if ( fabs(z0) > maxLengthPerLayer[iStack] ) 0581 maxLengthPerLayer[iStack] = fabs(z0); 0582 if ( fabs(z1) > maxLengthPerLayer[iStack] ) 0583 maxLengthPerLayer[iStack] = fabs(z1); 0584 0585 /// Find pixel pitch and topology related information 0586 const PixelGeomDetUnit* pix0 = dynamic_cast< const PixelGeomDetUnit* >( detUnit0 ); 0587 const PixelGeomDetUnit* pix1 = dynamic_cast< const PixelGeomDetUnit* >( detUnit1 ); 0588 const PixelTopology* top0 = dynamic_cast<const PixelTopology*>( & (pix0->specificTopology() )); 0589 const PixelTopology* top1 = dynamic_cast<const PixelTopology*>( & (pix1->specificTopology() )); 0590 std::pair< float, float > pitch0 = top0->pitch(); 0591 std::pair< float, float > pitch1 = top1->pitch(); 0592 0593 /// Store pixel pitch etc 0594 /// NOTE: this assumes that innermost sensor in a stack layer 0595 /// has ALWAYS the very same pixel pitch 0596 if ( innerModXPitchPerLayer.find(iStack) == innerModXPitchPerLayer.end() ) 0597 innerModXPitchPerLayer.insert( std::make_pair(iStack, 0) ); 0598 innerModXPitchPerLayer[iStack] += pitch0.first; 0599 if ( outerModXPitchPerLayer.find(iStack) == outerModXPitchPerLayer.end() ) 0600 outerModXPitchPerLayer.insert( std::make_pair(iStack, 0) ); 0601 outerModXPitchPerLayer[iStack] += pitch1.first; 0602 0603 if ( innerModYPitchPerLayer.find(iStack) == innerModYPitchPerLayer.end() ) 0604 innerModYPitchPerLayer.insert( std::make_pair(iStack, 0) ); 0605 innerModYPitchPerLayer[iStack] += pitch0.second; 0606 if ( outerModYPitchPerLayer.find(iStack) == outerModYPitchPerLayer.end() ) 0607 outerModYPitchPerLayer.insert( std::make_pair(iStack, 0) ); 0608 outerModYPitchPerLayer[iStack] += pitch1.second; 0609 0610 if ( innerModChannelsPerLayer.find(iStack) == innerModChannelsPerLayer.end() ) 0611 innerModChannelsPerLayer.insert( std::make_pair(iStack, 0) ); 0612 innerModChannelsPerLayer[iStack] += top0->nrows()*top0->ncolumns(); 0613 if ( outerModChannelsPerLayer.find(iStack) == outerModChannelsPerLayer.end() ) 0614 outerModChannelsPerLayer.insert( std::make_pair(iStack, 0) ); 0615 outerModChannelsPerLayer[iStack] += top1->nrows()*top1->ncolumns(); 0616 0617 if ( innerModRowsPerLayer.find(iStack) == innerModRowsPerLayer.end() ) 0618 innerModRowsPerLayer.insert( std::make_pair(iStack, 0) ); 0619 innerModRowsPerLayer[iStack] += top0->nrows(); 0620 if ( outerModRowsPerLayer.find(iStack) == outerModRowsPerLayer.end() ) 0621 outerModRowsPerLayer.insert( std::make_pair(iStack, 0) ); 0622 outerModRowsPerLayer[iStack] += top1->nrows(); 0623 0624 if ( innerModColumnsPerLayer.find(iStack) == innerModColumnsPerLayer.end() ) 0625 innerModColumnsPerLayer.insert( std::make_pair(iStack, 0) ); 0626 innerModColumnsPerLayer[iStack] += top0->ncolumns(); 0627 if ( outerModColumnsPerLayer.find(iStack) == outerModColumnsPerLayer.end() ) 0628 outerModColumnsPerLayer.insert( std::make_pair(iStack, 0) ); 0629 outerModColumnsPerLayer[iStack] += top1->ncolumns(); 0630 0631 /// This loops on GeometricDet to get more detailed information 0632 /// In particular, we are interested in active surface 0633 if ( activeSurfacePerLayer.find(iStack) == activeSurfacePerLayer.end() ) 0634 activeSurfacePerLayer.insert( std::make_pair( iStack, 0 ) ); 0635 if ( innerModXROCPerLayer.find(iStack) == innerModXROCPerLayer.end() ) 0636 innerModXROCPerLayer.insert( std::make_pair(iStack, 0) ); 0637 if ( innerModYROCPerLayer.find(iStack) == innerModYROCPerLayer.end() ) 0638 innerModYROCPerLayer.insert( std::make_pair(iStack, 0) ); 0639 if ( innerModTotROCPerLayer.find(iStack) == innerModTotROCPerLayer.end() ) 0640 innerModTotROCPerLayer.insert( std::make_pair(iStack, 0) ); 0641 if ( outerModXROCPerLayer.find(iStack) == outerModXROCPerLayer.end() ) 0642 outerModXROCPerLayer.insert( std::make_pair(iStack, 0) ); 0643 if ( outerModYROCPerLayer.find(iStack) == outerModYROCPerLayer.end() ) 0644 outerModYROCPerLayer.insert( std::make_pair(iStack, 0) ); 0645 if ( outerModTotROCPerLayer.find(iStack) == outerModTotROCPerLayer.end() ) 0646 outerModTotROCPerLayer.insert( std::make_pair(iStack, 0) ); 0647 0648 bool fastExit0 = false; 0649 bool fastExit1 = false; 0650 for ( unsigned int iMod = 0; iMod < theModules.size() && !(fastExit0 && fastExit1); iMod++ ) 0651 { 0652 const GeometricDet* thisModule = theModules.at(iMod); 0653 if ( thisModule->geographicalId() == det0->geographicalId() || 0654 thisModule->geographicalId() == det1->geographicalId() ) 0655 { 0656 double thisSurface = thisModule->bounds()->length()*thisModule->bounds()->width(); /// cm^2 0657 activeSurfacePerLayer[iStack] += thisSurface; 0658 0659 if ( thisModule->geographicalId() == det0->geographicalId() ) 0660 { 0661 innerModXROCPerLayer[iStack] += thisModule->pixROCx(); 0662 innerModYROCPerLayer[iStack] += thisModule->pixROCy(); 0663 innerModTotROCPerLayer[iStack] += thisModule->pixROCx()*thisModule->pixROCy(); 0664 fastExit0 = true; 0665 } 0666 if ( thisModule->geographicalId() == det1->geographicalId() ) 0667 { 0668 outerModXROCPerLayer[iStack] += thisModule->pixROCx(); 0669 outerModYROCPerLayer[iStack] += thisModule->pixROCy(); 0670 outerModTotROCPerLayer[iStack] += thisModule->pixROCx()*thisModule->pixROCy(); 0671 fastExit1 = true; 0672 } 0673 } 0674 } 0675 } 0676 0677 /// Endcap 0678 if ( stackDetId.isEndcap() ) 0679 { 0680 PXFDetId detId0 = PXFDetId(det0->geographicalId().rawId()); 0681 PXFDetId detId1 = PXFDetId(det1->geographicalId().rawId()); 0682 0683 /// Get the Stack, iPhi, iZ from StackedTrackerDetId 0684 uint32_t iSide = stackDetId.iSide(); 0685 uint32_t iStack = stackDetId.iDisk(); 0686 uint32_t iRing = stackDetId.iRing(); 0687 uint32_t iPhi = stackDetId.iPhi(); 0688 0689 /// Get index-coordinates of each sensor from DetId 0690 uint32_t iDisk0 = detId0.disk(); 0691 uint32_t iRing0 = detId0.ring(); 0692 uint32_t iModule0 = detId0.module(); 0693 uint32_t iDisk1 = detId1.disk(); 0694 uint32_t iRing1 = detId1.ring(); 0695 uint32_t iModule1 = detId1.module(); 0696 0697 if ( DebugMode ) 0698 { 0699 std::cerr << "Side: " << iSide << std::endl; 0700 std::cerr << "Stack: " << iStack << " from Disks: " << iDisk0 << " " << iDisk1 << std::endl; 0701 std::cerr << "Ring: " << iRing << " from Rings: " << iRing0 << " " << iRing1 << std::endl; 0702 std::cerr << "Phi: " << iPhi << " from Modules: " << iModule0 << " " << iModule1 << " >>> " << (iModule0 == iModule1 + 1) << std::endl; 0703 } 0704 0705 /// Store the size of rods and layers 0706 if ( ringsPerDisk.find(iStack) == ringsPerDisk.end() ) 0707 ringsPerDisk.insert( std::make_pair(iStack, 0) ); 0708 if ( iRing >= ringsPerDisk[iStack] ) 0709 ringsPerDisk[iStack] = iRing; 0710 0711 if ( modsPerRingPerDisk.find(iStack) == modsPerRingPerDisk.end() ) 0712 { 0713 std::map< uint32_t, uint32_t > tempMap; 0714 tempMap.insert( std::make_pair(iRing, 0) ); 0715 modsPerRingPerDisk.insert( std::make_pair(iStack, tempMap) ); 0716 } 0717 if ( modsPerRingPerDisk.find(iStack)->second.find(iRing) == modsPerRingPerDisk.find(iStack)->second.end() ) 0718 modsPerRingPerDisk.find(iStack)->second.insert( std::make_pair( iRing, 0 ) ); 0719 if ( iRing >= ringsPerDisk[iStack] ) 0720 ringsPerDisk[iStack] = iRing; 0721 if ( iPhi >= modsPerRingPerDisk.find(iStack)->second.find(iRing)->second ) 0722 modsPerRingPerDisk.find(iStack)->second.find(iRing)->second = iPhi; 0723 0724 /// This is a debug control that checks if 0725 /// the pairing in Phi follows index-based logic 0726 /// of innerPhi = outerPhi + 1 or not 0727 if ( inOutPerRingPerDisk.find(iStack) == inOutPerRingPerDisk.end() ) 0728 { 0729 /// New Disk, new Ring 0730 std::map< uint32_t, bool > tempMap; 0731 tempMap.insert( std::make_pair(iRing, (iModule1 == (iModule0 + 1))) ); 0732 inOutPerRingPerDisk.insert( std::make_pair(iStack, tempMap) ); 0733 } 0734 else 0735 { 0736 /// Existing Disk 0737 std::map< uint32_t, bool > tempMap = inOutPerRingPerDisk.find(iStack)->second; 0738 if ( tempMap.find(iRing) == tempMap.end() ) 0739 { 0740 /// New Ring 0741 tempMap.insert( std::make_pair(iRing, (iModule1 == (iModule0 + 1))) ); 0742 } 0743 else { 0744 /// Existing Ring 0745 tempMap.find(iRing)->second = tempMap.find(iRing)->second && (iModule1 == (iModule0 + 1)); 0746 } 0747 inOutPerRingPerDisk.find(iStack)->second = tempMap; 0748 } 0749 0750 /// Get the z of each sensor 0751 double z0 = det0->position().z(); 0752 double z1 = det1->position().z(); 0753 0754 /// Store radii to find average radius of inner and outer sensor 0755 /// in each Stack layer, and sensor separation in Stacks as well 0756 if ( innerModZPerRingPerDisk.find(iStack) == innerModZPerRingPerDisk.end() ) 0757 { 0758 std::map< uint32_t, double > tempMap; 0759 tempMap.insert( std::make_pair(iRing, 0) ); 0760 innerModZPerRingPerDisk.insert( std::make_pair(iStack, tempMap) ); 0761 } 0762 else 0763 { 0764 std::map< uint32_t, double > tempMap = innerModZPerRingPerDisk.find(iStack)->second; 0765 if ( tempMap.find(iRing) == tempMap.end() ) 0766 { 0767 tempMap.insert( std::make_pair(iRing, 0) ); 0768 innerModZPerRingPerDisk.find(iStack)->second = tempMap; 0769 } 0770 } 0771 innerModZPerRingPerDisk[iStack].find(iRing)->second += fabs(z0); 0772 if ( outerModZPerRingPerDisk.find(iStack) == outerModZPerRingPerDisk.end() ) 0773 { 0774 std::map< uint32_t, double > tempMap; 0775 tempMap.insert( std::make_pair(iRing, 0) ); 0776 outerModZPerRingPerDisk.insert( std::make_pair(iStack, tempMap) ); 0777 } 0778 else 0779 { 0780 std::map< uint32_t, double > tempMap = outerModZPerRingPerDisk.find(iStack)->second; 0781 if ( tempMap.find(iRing) == tempMap.end() ) 0782 { 0783 tempMap.insert( std::make_pair(iRing, 0) ); 0784 outerModZPerRingPerDisk.find(iStack)->second = tempMap; 0785 } 0786 } 0787 outerModZPerRingPerDisk[iStack].find(iRing)->second += fabs(z1); 0788 if ( separationPerRingPerDisk.find(iStack) == separationPerRingPerDisk.end() ) 0789 { 0790 std::map< uint32_t, double > tempMap; 0791 tempMap.insert( std::make_pair(iRing, 0) ); 0792 separationPerRingPerDisk.insert( std::make_pair(iStack, tempMap) ); 0793 } 0794 else 0795 { 0796 std::map< uint32_t, double > tempMap = separationPerRingPerDisk.find(iStack)->second; 0797 if ( tempMap.find(iRing) == tempMap.end() ) 0798 { 0799 tempMap.insert( std::make_pair(iRing, 0) ); 0800 separationPerRingPerDisk.find(iStack)->second = tempMap; 0801 } 0802 } 0803 separationPerRingPerDisk[iStack].find(iRing)->second += fabs(z1 - z0); 0804 0805 /// Find pixel pitch and topology related information 0806 const PixelGeomDetUnit* pix0 = dynamic_cast< const PixelGeomDetUnit* >( detUnit0 ); 0807 const PixelGeomDetUnit* pix1 = dynamic_cast< const PixelGeomDetUnit* >( detUnit1 ); 0808 const PixelTopology* top0 = dynamic_cast<const PixelTopology*>( & (pix0->specificTopology() )); 0809 const PixelTopology* top1 = dynamic_cast<const PixelTopology*>( & (pix1->specificTopology() )); 0810 std::pair< float, float > pitch0 = top0->pitch(); 0811 std::pair< float, float > pitch1 = top1->pitch(); 0812 0813 /// Store pixel pitch etc 0814 /// NOTE: this assumes that innermost sensor in a stack layer 0815 /// has ALWAYS the very same pixel pitch 0816 if ( innerModXPitchPerRingPerDisk.find(iStack) == innerModXPitchPerRingPerDisk.end() ) 0817 { 0818 std::map< uint32_t, float > tempMap; 0819 tempMap.insert( std::make_pair(iRing, 0) ); 0820 innerModXPitchPerRingPerDisk.insert( std::make_pair(iStack, tempMap) ); 0821 } 0822 else 0823 { 0824 std::map< uint32_t, float > tempMap = innerModXPitchPerRingPerDisk.find(iStack)->second; 0825 if ( tempMap.find(iRing) == tempMap.end() ) 0826 { 0827 tempMap.insert( std::make_pair(iRing, 0) ); 0828 innerModXPitchPerRingPerDisk.find(iStack)->second = tempMap; 0829 } 0830 } 0831 innerModXPitchPerRingPerDisk[iStack].find(iRing)->second += pitch0.first; 0832 if ( outerModXPitchPerRingPerDisk.find(iStack) == outerModXPitchPerRingPerDisk.end() ) 0833 { 0834 std::map< uint32_t, float > tempMap; 0835 tempMap.insert( std::make_pair(iRing, 0) ); 0836 outerModXPitchPerRingPerDisk.insert( std::make_pair(iStack, tempMap) ); 0837 } 0838 else 0839 { 0840 std::map< uint32_t, float > tempMap = outerModXPitchPerRingPerDisk.find(iStack)->second; 0841 if ( tempMap.find(iRing) == tempMap.end() ) 0842 { 0843 tempMap.insert( std::make_pair(iRing, 0) ); 0844 outerModXPitchPerRingPerDisk.find(iStack)->second = tempMap; 0845 } 0846 } 0847 outerModXPitchPerRingPerDisk[iStack].find(iRing)->second += pitch1.first; 0848 0849 if ( innerModYPitchPerRingPerDisk.find(iStack) == innerModYPitchPerRingPerDisk.end() ) 0850 { 0851 std::map< uint32_t, float > tempMap; 0852 tempMap.insert( std::make_pair(iRing, 0) ); 0853 innerModYPitchPerRingPerDisk.insert( std::make_pair(iStack, tempMap) ); 0854 } 0855 else 0856 { 0857 std::map< uint32_t, float > tempMap = innerModYPitchPerRingPerDisk.find(iStack)->second; 0858 if ( tempMap.find(iRing) == tempMap.end() ) 0859 { 0860 tempMap.insert( std::make_pair(iRing, 0) ); 0861 innerModYPitchPerRingPerDisk.find(iStack)->second = tempMap; 0862 } 0863 } 0864 innerModYPitchPerRingPerDisk[iStack].find(iRing)->second += pitch0.second; 0865 if ( outerModYPitchPerRingPerDisk.find(iStack) == outerModYPitchPerRingPerDisk.end() ) 0866 { 0867 std::map< uint32_t, float > tempMap; 0868 tempMap.insert( std::make_pair(iRing, 0) ); 0869 outerModYPitchPerRingPerDisk.insert( std::make_pair(iStack, tempMap) ); 0870 } 0871 else 0872 { 0873 std::map< uint32_t, float > tempMap = outerModYPitchPerRingPerDisk.find(iStack)->second; 0874 if ( tempMap.find(iRing) == tempMap.end() ) 0875 { 0876 tempMap.insert( std::make_pair(iRing, 0) ); 0877 outerModYPitchPerRingPerDisk.find(iStack)->second = tempMap; 0878 } 0879 } 0880 outerModYPitchPerRingPerDisk[iStack].find(iRing)->second += pitch1.second; 0881 0882 if ( innerModChannelsPerRingPerDisk.find(iStack) == innerModChannelsPerRingPerDisk.end() ) 0883 { 0884 std::map< uint32_t, uint32_t > tempMap; 0885 tempMap.insert( std::make_pair(iRing, 0) ); 0886 innerModChannelsPerRingPerDisk.insert( std::make_pair(iStack, tempMap) ); 0887 } 0888 else 0889 { 0890 std::map< uint32_t, uint32_t > tempMap = innerModChannelsPerRingPerDisk.find(iStack)->second; 0891 if ( tempMap.find(iRing) == tempMap.end() ) 0892 { 0893 tempMap.insert( std::make_pair(iRing, 0) ); 0894 innerModChannelsPerRingPerDisk.find(iStack)->second = tempMap; 0895 } 0896 } 0897 innerModChannelsPerRingPerDisk[iStack].find(iRing)->second += top0->nrows()*top0->ncolumns(); 0898 if ( outerModChannelsPerRingPerDisk.find(iStack) == outerModChannelsPerRingPerDisk.end() ) 0899 { 0900 std::map< uint32_t, uint32_t > tempMap; 0901 tempMap.insert( std::make_pair(iRing, 0) ); 0902 outerModChannelsPerRingPerDisk.insert( std::make_pair(iStack, tempMap) ); 0903 } 0904 else 0905 { 0906 std::map< uint32_t, uint32_t > tempMap = outerModChannelsPerRingPerDisk.find(iStack)->second; 0907 if ( tempMap.find(iRing) == tempMap.end() ) 0908 { 0909 tempMap.insert( std::make_pair(iRing, 0) ); 0910 outerModChannelsPerRingPerDisk.find(iStack)->second = tempMap; 0911 } 0912 } 0913 outerModChannelsPerRingPerDisk[iStack].find(iRing)->second += top1->nrows()*top1->ncolumns(); 0914 0915 if ( innerModRowsPerRingPerDisk.find(iStack) == innerModRowsPerRingPerDisk.end() ) 0916 { 0917 std::map< uint32_t, uint32_t > tempMap; 0918 tempMap.insert( std::make_pair(iRing, 0) ); 0919 innerModRowsPerRingPerDisk.insert( std::make_pair(iStack, tempMap) ); 0920 } 0921 else 0922 { 0923 std::map< uint32_t, uint32_t > tempMap = innerModRowsPerRingPerDisk.find(iStack)->second; 0924 if ( tempMap.find(iRing) == tempMap.end() ) 0925 { 0926 tempMap.insert( std::make_pair(iRing, 0) ); 0927 innerModRowsPerRingPerDisk.find(iStack)->second = tempMap; 0928 } 0929 } 0930 innerModRowsPerRingPerDisk[iStack].find(iRing)->second += top0->nrows(); 0931 if ( outerModRowsPerRingPerDisk.find(iStack) == outerModRowsPerRingPerDisk.end() ) 0932 { 0933 std::map< uint32_t, uint32_t > tempMap; 0934 tempMap.insert( std::make_pair(iRing, 0) ); 0935 outerModRowsPerRingPerDisk.insert( std::make_pair(iStack, tempMap) ); 0936 } 0937 else 0938 { 0939 std::map< uint32_t, uint32_t > tempMap = outerModRowsPerRingPerDisk.find(iStack)->second; 0940 if ( tempMap.find(iRing) == tempMap.end() ) 0941 { 0942 tempMap.insert( std::make_pair(iRing, 0) ); 0943 outerModRowsPerRingPerDisk.find(iStack)->second = tempMap; 0944 } 0945 } 0946 outerModRowsPerRingPerDisk[iStack].find(iRing)->second += top1->nrows(); 0947 0948 if ( innerModColumnsPerRingPerDisk.find(iStack) == innerModColumnsPerRingPerDisk.end() ) 0949 { 0950 std::map< uint32_t, uint32_t > tempMap; 0951 tempMap.insert( std::make_pair(iRing, 0) ); 0952 innerModColumnsPerRingPerDisk.insert( std::make_pair(iStack, tempMap) ); 0953 } 0954 else 0955 { 0956 std::map< uint32_t, uint32_t > tempMap = innerModColumnsPerRingPerDisk.find(iStack)->second; 0957 if ( tempMap.find(iRing) == tempMap.end() ) 0958 { 0959 tempMap.insert( std::make_pair(iRing, 0) ); 0960 innerModColumnsPerRingPerDisk.find(iStack)->second = tempMap; 0961 } 0962 } 0963 innerModColumnsPerRingPerDisk[iStack].find(iRing)->second += top0->ncolumns(); 0964 if ( outerModColumnsPerRingPerDisk.find(iStack) == outerModColumnsPerRingPerDisk.end() ) 0965 { 0966 std::map< uint32_t, uint32_t > tempMap; 0967 tempMap.insert( std::make_pair(iRing, 0) ); 0968 outerModColumnsPerRingPerDisk.insert( std::make_pair(iStack, tempMap) ); 0969 } 0970 else 0971 { 0972 std::map< uint32_t, uint32_t > tempMap = outerModColumnsPerRingPerDisk.find(iStack)->second; 0973 if ( tempMap.find(iRing) == tempMap.end() ) 0974 { 0975 tempMap.insert( std::make_pair(iRing, 0) ); 0976 outerModColumnsPerRingPerDisk.find(iStack)->second = tempMap; 0977 } 0978 } 0979 outerModColumnsPerRingPerDisk[iStack].find(iRing)->second += top1->ncolumns(); 0980 0981 /// This loops on GeometricDet to get more detailed information 0982 /// In particular, we are interested in active surface 0983 if ( activeSurfacePerRingPerDisk.find(iStack) == activeSurfacePerRingPerDisk.end() ) 0984 { 0985 std::map< uint32_t, double > tempMap; 0986 tempMap.insert( std::make_pair(iRing, 0) ); 0987 activeSurfacePerRingPerDisk.insert( std::make_pair(iStack, tempMap) ); 0988 } 0989 else 0990 { 0991 std::map< uint32_t, double > tempMap = activeSurfacePerRingPerDisk.find(iStack)->second; 0992 if ( tempMap.find(iRing) == tempMap.end() ) 0993 { 0994 tempMap.insert( std::make_pair(iRing, 0) ); 0995 activeSurfacePerRingPerDisk.find(iStack)->second = tempMap; 0996 } 0997 } 0998 0999 if ( innerModXROCPerRingPerDisk.find(iStack) == innerModXROCPerRingPerDisk.end() ) 1000 { 1001 std::map< uint32_t, uint32_t > tempMap; 1002 tempMap.insert( std::make_pair(iRing, 0) ); 1003 innerModXROCPerRingPerDisk.insert( std::make_pair(iStack, tempMap) ); 1004 } 1005 else 1006 { 1007 std::map< uint32_t, uint32_t > tempMap = innerModXROCPerRingPerDisk.find(iStack)->second; 1008 if ( tempMap.find(iRing) == tempMap.end() ) 1009 { 1010 tempMap.insert( std::make_pair(iRing, 0) ); 1011 innerModXROCPerRingPerDisk.find(iStack)->second = tempMap; 1012 } 1013 } 1014 if ( outerModXROCPerRingPerDisk.find(iStack) == outerModXROCPerRingPerDisk.end() ) 1015 { 1016 std::map< uint32_t, uint32_t > tempMap; 1017 tempMap.insert( std::make_pair(iRing, 0) ); 1018 outerModXROCPerRingPerDisk.insert( std::make_pair(iStack, tempMap) ); 1019 } 1020 else 1021 { 1022 std::map< uint32_t, uint32_t > tempMap = outerModXROCPerRingPerDisk.find(iStack)->second; 1023 if ( tempMap.find(iRing) == tempMap.end() ) 1024 { 1025 tempMap.insert( std::make_pair(iRing, 0) ); 1026 outerModXROCPerRingPerDisk.find(iStack)->second = tempMap; 1027 } 1028 } 1029 1030 if ( innerModYROCPerRingPerDisk.find(iStack) == innerModYROCPerRingPerDisk.end() ) 1031 { 1032 std::map< uint32_t, uint32_t > tempMap; 1033 tempMap.insert( std::make_pair(iRing, 0) ); 1034 innerModYROCPerRingPerDisk.insert( std::make_pair(iStack, tempMap) ); 1035 } 1036 else 1037 { 1038 std::map< uint32_t, uint32_t > tempMap = innerModYROCPerRingPerDisk.find(iStack)->second; 1039 if ( tempMap.find(iRing) == tempMap.end() ) 1040 { 1041 tempMap.insert( std::make_pair(iRing, 0) ); 1042 innerModYROCPerRingPerDisk.find(iStack)->second = tempMap; 1043 } 1044 } 1045 if ( outerModYROCPerRingPerDisk.find(iStack) == outerModYROCPerRingPerDisk.end() ) 1046 { 1047 std::map< uint32_t, uint32_t > tempMap; 1048 tempMap.insert( std::make_pair(iRing, 0) ); 1049 outerModYROCPerRingPerDisk.insert( std::make_pair(iStack, tempMap) ); 1050 } 1051 else 1052 { 1053 std::map< uint32_t, uint32_t > tempMap = outerModYROCPerRingPerDisk.find(iStack)->second; 1054 if ( tempMap.find(iRing) == tempMap.end() ) 1055 { 1056 tempMap.insert( std::make_pair(iRing, 0) ); 1057 outerModYROCPerRingPerDisk.find(iStack)->second = tempMap; 1058 } 1059 } 1060 1061 if ( innerModTotROCPerRingPerDisk.find(iStack) == innerModTotROCPerRingPerDisk.end() ) 1062 { 1063 std::map< uint32_t, uint32_t > tempMap; 1064 tempMap.insert( std::make_pair(iRing, 0) ); 1065 innerModTotROCPerRingPerDisk.insert( std::make_pair(iStack, tempMap) ); 1066 } 1067 else 1068 { 1069 std::map< uint32_t, uint32_t > tempMap = innerModTotROCPerRingPerDisk.find(iStack)->second; 1070 if ( tempMap.find(iRing) == tempMap.end() ) 1071 { 1072 tempMap.insert( std::make_pair(iRing, 0) ); 1073 innerModTotROCPerRingPerDisk.find(iStack)->second = tempMap; 1074 } 1075 } 1076 if ( outerModTotROCPerRingPerDisk.find(iStack) == outerModTotROCPerRingPerDisk.end() ) 1077 { 1078 std::map< uint32_t, uint32_t > tempMap; 1079 tempMap.insert( std::make_pair(iRing, 0) ); 1080 outerModTotROCPerRingPerDisk.insert( std::make_pair(iStack, tempMap) ); 1081 } 1082 else 1083 { 1084 std::map< uint32_t, uint32_t > tempMap = outerModTotROCPerRingPerDisk.find(iStack)->second; 1085 if ( tempMap.find(iRing) == tempMap.end() ) 1086 { 1087 tempMap.insert( std::make_pair(iRing, 0) ); 1088 outerModTotROCPerRingPerDisk.find(iStack)->second = tempMap; 1089 } 1090 } 1091 1092 bool fastExit0 = false; 1093 bool fastExit1 = false; 1094 for ( unsigned int iMod = 0; iMod < theModules.size() && !fastExit0 && !fastExit1; iMod++ ) 1095 { 1096 const GeometricDet* thisModule = theModules.at(iMod); 1097 if ( thisModule->geographicalId() == det0->geographicalId() || 1098 thisModule->geographicalId() == det1->geographicalId() ) 1099 { 1100 double thisSurface = thisModule->bounds()->length()*thisModule->bounds()->width(); /// cm^2 1101 activeSurfacePerRingPerDisk[iStack].find(iRing)->second += thisSurface; 1102 1103 if ( thisModule->geographicalId() == det0->geographicalId() ) 1104 { 1105 innerModXROCPerRingPerDisk[iStack].find(iRing)->second += thisModule->pixROCx(); 1106 innerModYROCPerRingPerDisk[iStack].find(iRing)->second += thisModule->pixROCy(); 1107 innerModTotROCPerRingPerDisk[iStack].find(iRing)->second += thisModule->pixROCx()*thisModule->pixROCy(); 1108 fastExit0 = true; 1109 } 1110 if ( thisModule->geographicalId() == det1->geographicalId() ) 1111 { 1112 outerModXROCPerRingPerDisk[iStack].find(iRing)->second += thisModule->pixROCx(); 1113 outerModYROCPerRingPerDisk[iStack].find(iRing)->second += thisModule->pixROCy(); 1114 outerModTotROCPerRingPerDisk[iStack].find(iRing)->second += thisModule->pixROCx()*thisModule->pixROCy(); 1115 fastExit1 = true; 1116 } 1117 } 1118 } 1119 } 1120 } 1121 1122 outputFile << " *****************" << std::endl; 1123 outputFile << " * FINAL SUMMARY *" << std::endl; 1124 outputFile << " *****************" << std::endl; 1125 1126 for ( std::map< uint32_t, uint32_t >::iterator iterMap = rodsPerLayer.begin(); 1127 iterMap != rodsPerLayer.end(); 1128 ++iterMap ) 1129 { 1130 /// Index-coordinates and number of modules 1131 outputFile << std::endl; 1132 outputFile << " - - - - - - - - - - - - - - - - - - - - - - - - - - - - -" << std::endl; 1133 outputFile << " Barrel Stack Layer: " << iterMap->first << std::endl; 1134 outputFile << " # Rods: " << iterMap->second << std::endl; 1135 outputFile << " # Modules/Rod: " << modsPerRodPerLayer[iterMap->first] << std::endl; 1136 outputFile << " # Modules " << modsPerRodPerLayer[iterMap->first] * iterMap->second << std::endl; 1137 if ( DebugMode ) 1138 { 1139 outputFile << " In/Out Correct Order ? "; 1140 for ( std::map< uint32_t, bool >::iterator iterAux = inOutPerRodPerLayer[iterMap->first].begin(); 1141 iterAux != inOutPerRodPerLayer[iterMap->first].end(); 1142 ++iterAux ) 1143 { 1144 outputFile << iterAux->second; 1145 } 1146 outputFile << std::endl; 1147 } 1148 1149 /// Average radii and separation 1150 outputFile << " Inner sensor average radius: " << 1151 innerModRadPerLayer[iterMap->first]/(double)(modsPerRodPerLayer[iterMap->first] * iterMap->second) << " [cm]" << std::endl; 1152 outputFile << " Outer sensor average radius: " << 1153 outerModRadPerLayer[iterMap->first]/(double)(modsPerRodPerLayer[iterMap->first] * iterMap->second) << " [cm]" << std::endl; 1154 outputFile << " Average sensor separation: " << 1155 separationPerLayer[iterMap->first]/(double)(modsPerRodPerLayer[iterMap->first] * iterMap->second) * 10 << " [mm]" << std::endl; 1156 1157 /// Stack length and surface 1158 outputFile << " Max length of Stack Layer: " << 1159 maxLengthPerLayer[iterMap->first] << " [cm]" << std::endl; 1160 outputFile << " Total active surface: " << 1161 activeSurfacePerLayer[iterMap->first] << " [cm^2]" << std::endl; 1162 1163 /// Topology 1164 outputFile << " Inner sensor channels: " << 1165 innerModChannelsPerLayer[iterMap->first]/(double)(modsPerRodPerLayer[iterMap->first] * iterMap->second) << std::endl; 1166 outputFile << " rows: " << 1167 innerModRowsPerLayer[iterMap->first]/(double)(modsPerRodPerLayer[iterMap->first] * iterMap->second) << std::endl; 1168 outputFile << " columns: " << 1169 innerModColumnsPerLayer[iterMap->first]/(double)(modsPerRodPerLayer[iterMap->first] * iterMap->second) << std::endl; 1170 outputFile << " Inner sensor average pitch X: " << 1171 double(int(0.5+(10000*innerModXPitchPerLayer[iterMap->first]/(double)(modsPerRodPerLayer[iterMap->first] * iterMap->second) ))) << " [um]" << std::endl; 1172 outputFile << " Y: " << 1173 double(int(0.5+(10000*innerModYPitchPerLayer[iterMap->first]/(double)(modsPerRodPerLayer[iterMap->first] * iterMap->second) ))) << " [um]" << std::endl; 1174 outputFile << " Inner sensor ROCs X: " << 1175 innerModXROCPerLayer[iterMap->first]/(double)(modsPerRodPerLayer[iterMap->first] * iterMap->second) << std::endl; 1176 outputFile << " Y: " << 1177 innerModYROCPerLayer[iterMap->first]/(double)(modsPerRodPerLayer[iterMap->first] * iterMap->second) << std::endl; 1178 outputFile << " total: " << 1179 innerModTotROCPerLayer[iterMap->first]/(double)(modsPerRodPerLayer[iterMap->first] * iterMap->second) << std::endl; 1180 outputFile << " Outer sensor channels: " << 1181 outerModChannelsPerLayer[iterMap->first]/(double)(modsPerRodPerLayer[iterMap->first] * iterMap->second) << std::endl; 1182 outputFile << " rows: " << 1183 outerModRowsPerLayer[iterMap->first]/(double)(modsPerRodPerLayer[iterMap->first] * iterMap->second) << std::endl; 1184 outputFile << " columns: " << 1185 outerModColumnsPerLayer[iterMap->first]/(double)(modsPerRodPerLayer[iterMap->first] * iterMap->second) << std::endl; 1186 outputFile << " Outer sensor average pitch X: " << 1187 double(int(0.5+(10000*outerModXPitchPerLayer[iterMap->first]/(double)(modsPerRodPerLayer[iterMap->first] * iterMap->second) ))) << " [um]" << std::endl; 1188 outputFile << " Y: " << 1189 double(int(0.5+(10000*outerModYPitchPerLayer[iterMap->first]/(double)(modsPerRodPerLayer[iterMap->first] * iterMap->second) ))) << " [um]" << std::endl; 1190 outputFile << " Outer sensor ROCs X: " << 1191 outerModXROCPerLayer[iterMap->first]/(double)(modsPerRodPerLayer[iterMap->first] * iterMap->second) << std::endl; 1192 outputFile << " Y: " << 1193 outerModYROCPerLayer[iterMap->first]/(double)(modsPerRodPerLayer[iterMap->first] * iterMap->second) << std::endl; 1194 outputFile << " total: " << 1195 outerModTotROCPerLayer[iterMap->first]/(double)(modsPerRodPerLayer[iterMap->first] * iterMap->second) << std::endl; 1196 } 1197 1198 for ( std::map< uint32_t, uint32_t >::iterator iterMap = ringsPerDisk.begin(); 1199 iterMap != ringsPerDisk.end(); 1200 ++iterMap ) 1201 { 1202 /// Index-coordinates and number of modules 1203 outputFile << std::endl; 1204 outputFile << " - - - - - - - - - - - - - - - - - - - - - - - - - - - - -" << std::endl; 1205 outputFile << " Endcap Stack Layer: " << iterMap->first << std::endl; 1206 outputFile << " # Rings: " << iterMap->second << std::endl; 1207 1208 uint32_t countMods = 0; 1209 1210 for ( std::map< uint32_t, uint32_t >::iterator iterOther = modsPerRingPerDisk[iterMap->first].begin(); 1211 iterOther != modsPerRingPerDisk[iterMap->first].end(); 1212 iterOther++ ) 1213 { 1214 outputFile << " # Modules/Ring: " << iterOther->second << " in Ring " << iterOther->first << std::endl; 1215 countMods += iterOther->second; 1216 } 1217 1218 outputFile << " # Modules " << countMods << std::endl; 1219 if ( DebugMode ) 1220 { 1221 outputFile << " In/Out Correct Order ? "; 1222 for ( std::map< uint32_t, bool >::iterator iterAux = inOutPerRingPerDisk[iterMap->first].begin(); 1223 iterAux != inOutPerRingPerDisk[iterMap->first].end(); 1224 ++iterAux ) 1225 { 1226 outputFile << iterAux->second; 1227 } 1228 outputFile << std::endl; 1229 } 1230 1231 /// Average radii and separation 1232 for ( std::map< uint32_t, double >::iterator iterOther = innerModZPerRingPerDisk[iterMap->first].begin(); 1233 iterOther != innerModZPerRingPerDisk[iterMap->first].end(); 1234 ++iterOther ) 1235 { 1236 outputFile << " Inner sensor average z: " << 1237 iterOther->second/(double)modsPerRingPerDisk[iterMap->first].find(iterOther->first)->second/2.0 << 1238 " [cm] in Ring " << iterOther->first << std::endl; 1239 } 1240 for ( std::map< uint32_t, double >::iterator iterOther = outerModZPerRingPerDisk[iterMap->first].begin(); 1241 iterOther != outerModZPerRingPerDisk[iterMap->first].end(); 1242 ++iterOther ) 1243 { 1244 outputFile << " Outer sensor average z: " << 1245 iterOther->second/(double)modsPerRingPerDisk[iterMap->first].find(iterOther->first)->second/2.0 << 1246 " [cm] in Ring " << iterOther->first << std::endl; 1247 } 1248 for ( std::map< uint32_t, double >::iterator iterOther = separationPerRingPerDisk[iterMap->first].begin(); 1249 iterOther != separationPerRingPerDisk[iterMap->first].end(); 1250 ++iterOther ) 1251 { 1252 outputFile << " Average sensor separation: " << 1253 iterOther->second/(double)modsPerRingPerDisk[iterMap->first].find(iterOther->first)->second * 10 / 2.0 << 1254 " [mm] in Ring " << iterOther->first << std::endl; 1255 } 1256 1257 /// Stack length and surface 1258 for ( std::map< uint32_t, double >::iterator iterOther = activeSurfacePerRingPerDisk[iterMap->first].begin(); 1259 iterOther != activeSurfacePerRingPerDisk[iterMap->first].end(); 1260 ++iterOther ) 1261 { 1262 outputFile << " Total active surface: " << 1263 iterOther->second << // /(double)modsPerRingPerDisk[iterMap->first].find(iterOther->first)->second/2.0 << 1264 " [cm^2] in Ring " << iterOther->first << std::endl; 1265 } 1266 1267 /// Topology 1268 for ( std::map< uint32_t, uint32_t >::iterator iterOther = innerModChannelsPerRingPerDisk[iterMap->first].begin(); 1269 iterOther != innerModChannelsPerRingPerDisk[iterMap->first].end(); 1270 ++iterOther ) 1271 { 1272 outputFile << " Inner sensor channels: " << 1273 iterOther->second/(double)modsPerRingPerDisk[iterMap->first].find(iterOther->first)->second/2.0 << 1274 " in Ring " << iterOther->first << std::endl; 1275 } 1276 for ( std::map< uint32_t, uint32_t >::iterator iterOther = innerModRowsPerRingPerDisk[iterMap->first].begin(); 1277 iterOther != innerModRowsPerRingPerDisk[iterMap->first].end(); 1278 ++iterOther ) 1279 { 1280 outputFile << " rows: " << 1281 iterOther->second/(double)modsPerRingPerDisk[iterMap->first].find(iterOther->first)->second/2.0 << 1282 " in Ring " << iterOther->first << std::endl; 1283 } 1284 for ( std::map< uint32_t, uint32_t >::iterator iterOther = innerModColumnsPerRingPerDisk[iterMap->first].begin(); 1285 iterOther != innerModColumnsPerRingPerDisk[iterMap->first].end(); 1286 ++iterOther ) 1287 { 1288 outputFile << " columns: " << 1289 iterOther->second/(double)modsPerRingPerDisk[iterMap->first].find(iterOther->first)->second/2.0 << 1290 " in Ring " << iterOther->first << std::endl; 1291 } 1292 for ( std::map< uint32_t, float >::iterator iterOther = innerModXPitchPerRingPerDisk[iterMap->first].begin(); 1293 iterOther != innerModXPitchPerRingPerDisk[iterMap->first].end(); 1294 ++iterOther ) 1295 { 1296 outputFile << " Inner sensor average pitch X: " << 1297 double(int(0.5+(10000*iterOther->second)))/(double)modsPerRingPerDisk[iterMap->first].find(iterOther->first)->second/2.0 << 1298 " [um] in Ring " << iterOther->first << std::endl; 1299 } 1300 for ( std::map< uint32_t, float >::iterator iterOther = innerModYPitchPerRingPerDisk[iterMap->first].begin(); 1301 iterOther != innerModYPitchPerRingPerDisk[iterMap->first].end(); 1302 ++iterOther ) 1303 { 1304 outputFile << " Y: " << 1305 double(int(0.5+(10000*iterOther->second)))/(double)modsPerRingPerDisk[iterMap->first].find(iterOther->first)->second/2.0 << 1306 " [um] in Ring " << iterOther->first << std::endl; 1307 } 1308 for ( std::map< uint32_t, uint32_t >::iterator iterOther = innerModXROCPerRingPerDisk[iterMap->first].begin(); 1309 iterOther != innerModXROCPerRingPerDisk[iterMap->first].end(); 1310 ++iterOther ) 1311 { 1312 outputFile << " Inner sensor ROCs X: " << 1313 iterOther->second/(double)modsPerRingPerDisk[iterMap->first].find(iterOther->first)->second/2.0 << 1314 " in Ring " << iterOther->first << std::endl; 1315 } 1316 for ( std::map< uint32_t, uint32_t >::iterator iterOther = innerModYROCPerRingPerDisk[iterMap->first].begin(); 1317 iterOther != innerModYROCPerRingPerDisk[iterMap->first].end(); 1318 ++iterOther ) 1319 { 1320 outputFile << " Y: " << 1321 iterOther->second/(double)modsPerRingPerDisk[iterMap->first].find(iterOther->first)->second/2.0 << 1322 " in Ring " << iterOther->first << std::endl; 1323 } 1324 for ( std::map< uint32_t, uint32_t >::iterator iterOther = innerModTotROCPerRingPerDisk[iterMap->first].begin(); 1325 iterOther != innerModTotROCPerRingPerDisk[iterMap->first].end(); 1326 ++iterOther ) 1327 { 1328 outputFile << " total: " << 1329 iterOther->second/(double)modsPerRingPerDisk[iterMap->first].find(iterOther->first)->second/2.0 << 1330 " in Ring " << iterOther->first << std::endl; 1331 } 1332 1333 for ( std::map< uint32_t, uint32_t >::iterator iterOther = outerModChannelsPerRingPerDisk[iterMap->first].begin(); 1334 iterOther != outerModChannelsPerRingPerDisk[iterMap->first].end(); 1335 ++iterOther ) 1336 { 1337 outputFile << " Outer sensor channels: " << 1338 iterOther->second/(double)modsPerRingPerDisk[iterMap->first].find(iterOther->first)->second/2.0 << 1339 " in Ring " << iterOther->first << std::endl; 1340 } 1341 for ( std::map< uint32_t, uint32_t >::iterator iterOther = outerModRowsPerRingPerDisk[iterMap->first].begin(); 1342 iterOther != outerModRowsPerRingPerDisk[iterMap->first].end(); 1343 ++iterOther ) 1344 { 1345 outputFile << " rows: " << 1346 iterOther->second/(double)modsPerRingPerDisk[iterMap->first].find(iterOther->first)->second/2.0 << 1347 " in Ring " << iterOther->first << std::endl; 1348 } 1349 for ( std::map< uint32_t, uint32_t >::iterator iterOther = outerModColumnsPerRingPerDisk[iterMap->first].begin(); 1350 iterOther != outerModColumnsPerRingPerDisk[iterMap->first].end(); 1351 ++iterOther ) 1352 { 1353 outputFile << " columns: " << 1354 iterOther->second/(double)modsPerRingPerDisk[iterMap->first].find(iterOther->first)->second/2.0 << 1355 " in Ring " << iterOther->first << std::endl; 1356 } 1357 for ( std::map< uint32_t, float >::iterator iterOther = outerModXPitchPerRingPerDisk[iterMap->first].begin(); 1358 iterOther != outerModXPitchPerRingPerDisk[iterMap->first].end(); 1359 ++iterOther ) 1360 { 1361 outputFile << " Outer sensor average pitch X: " << 1362 double(int(0.5+(10000*iterOther->second)))/(double)modsPerRingPerDisk[iterMap->first].find(iterOther->first)->second/2.0 << 1363 " [um] in Ring " << iterOther->first << std::endl; 1364 } 1365 for ( std::map< uint32_t, float >::iterator iterOther = outerModYPitchPerRingPerDisk[iterMap->first].begin(); 1366 iterOther != outerModYPitchPerRingPerDisk[iterMap->first].end(); 1367 ++iterOther ) 1368 { 1369 outputFile << " Y: " << 1370 double(int(0.5+(10000*iterOther->second)))/(double)modsPerRingPerDisk[iterMap->first].find(iterOther->first)->second/2.0 << 1371 " [um] in Ring " << iterOther->first << std::endl; 1372 } 1373 for ( std::map< uint32_t, uint32_t >::iterator iterOther = outerModXROCPerRingPerDisk[iterMap->first].begin(); 1374 iterOther != outerModXROCPerRingPerDisk[iterMap->first].end(); 1375 ++iterOther ) 1376 { 1377 outputFile << " Outer sensor ROCs X: " << 1378 iterOther->second/(double)modsPerRingPerDisk[iterMap->first].find(iterOther->first)->second/2.0 << 1379 " in Ring " << iterOther->first << std::endl; 1380 } 1381 for ( std::map< uint32_t, uint32_t >::iterator iterOther = outerModYROCPerRingPerDisk[iterMap->first].begin(); 1382 iterOther != outerModYROCPerRingPerDisk[iterMap->first].end(); 1383 ++iterOther ) 1384 { 1385 outputFile << " Y: " << 1386 iterOther->second/(double)modsPerRingPerDisk[iterMap->first].find(iterOther->first)->second/2.0 << 1387 " in Ring " << iterOther->first << std::endl; 1388 } 1389 for ( std::map< uint32_t, uint32_t >::iterator iterOther = outerModTotROCPerRingPerDisk[iterMap->first].begin(); 1390 iterOther != outerModTotROCPerRingPerDisk[iterMap->first].end(); 1391 ++iterOther ) 1392 { 1393 outputFile << " total: " << 1394 iterOther->second/(double)modsPerRingPerDisk[iterMap->first].find(iterOther->first)->second/2.0 << 1395 " in Ring " << iterOther->first << std::endl; 1396 } 1397 } 1398 */ 1399 } /// End of analyze() 1400 1401 /////////////////////////// 1402 // DEFINE THIS AS A PLUG-IN 1403 DEFINE_FWK_MODULE(AnalyzerPrintGeomInfo);
| [ Source navigation ] | [ Diff markup ] | [ Identifier search ] | [ general search ] |
|
This page was automatically generated by the 2.2.1 LXR engine. The LXR team |
|