Back to home page

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);