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