Reference Manual

Go to the documentation of this file.
00001 // Package:    SiPixelMonitorTrack
00002 // Class:      SiPixelHitEfficiencyModule
00003 // 
00004 // class SiPixelHitEfficiencyModule SiPixelHitEfficiencyModule.cc 
00005 //       DQM/SiPixelMonitorTrack/src/SiPixelHitEfficiencyModule.cc
00006 //
00007 // Description: SiPixel hit efficiency data quality monitoring modules
00008 // Implementation: prototype -> improved -> never final - end of the 1st step 
00009 //
00010 // Original Authors: Romain Rougny & Luca Mucibello
00011 //         Created: Mar Nov 10 13:29:00 CET nbinangle9
00012 
00013 
00014 
00015 #include <string>
00016 #include <iostream>
00017 
00018 #include "DQMServices/Core/interface/DQMStore.h"
00019 #include "FWCore/ParameterSet/interface/ParameterSet.h"
00020 #include "FWCore/ServiceRegistry/interface/Service.h"
00021 #include "FWCore/Utilities/interface/InputTag.h"
00022 #include "DQM/SiPixelCommon/interface/SiPixelHistogramId.h"
00023 #include "DQM/SiPixelMonitorTrack/interface/SiPixelHitEfficiencyModule.h"
00024 
00025 // Data Formats
00026 #include "DataFormats/SiPixelDetId/interface/PixelBarrelName.h"
00027 #include "DataFormats/SiPixelDetId/interface/PixelEndcapName.h"
00028 #include "DataFormats/DetId/interface/DetId.h"
00029 #include "DataFormats/SiPixelDetId/interface/PixelSubdetector.h"
00030 
00031 
00032 using namespace std; 
00033 
00034 
00035 SiPixelHitEfficiencyModule::SiPixelHitEfficiencyModule() : id_(0) {
00036   bBookTracks = true;
00037 }
00038 
00039 
00040 SiPixelHitEfficiencyModule::SiPixelHitEfficiencyModule(uint32_t id) : id_(id) { 
00041   bBookTracks = true;
00042 }
00043 
00044 
00045 SiPixelHitEfficiencyModule::~SiPixelHitEfficiencyModule() { 
00046  
00047 }
00048 
00049 
00050 void SiPixelHitEfficiencyModule::book(const edm::ParameterSet& iConfig, int type) {
00051   DQMStore* dbe = edm::Service<DQMStore>().operator->();
00052 
00053   bool barrel = DetId(id_).subdetId() == static_cast<int>(PixelSubdetector::PixelBarrel);
00054   bool endcap = DetId(id_).subdetId() == static_cast<int>(PixelSubdetector::PixelEndcap);
00055   bool isHalfModule = false;
00056   if(barrel){
00057     isHalfModule = PixelBarrelName(DetId(id_)).isHalfModule(); 
00058   }
00059 
00060   edm::InputTag src = iConfig.getParameter<edm::InputTag>("src");
00061   debug_ = iConfig.getUntrackedParameter<bool>("debug",false);
00062   updateEfficiencies = iConfig.getUntrackedParameter<bool>("updateEfficiencies",false);
00063   std::string hisID;
00064   
00065   int nbinangle = 28;
00066   int nbinX = 45;
00067   int nbinY = 40;
00068 
00069   if(type==0){
00070     SiPixelHistogramId* theHistogramId = new SiPixelHistogramId(src.label());
00071     
00072     if(updateEfficiencies){
00073       //EFFICIENCY
00074       hisID = theHistogramId->setHistoId("efficiency",id_);
00075       meEfficiency_ = dbe->book1D(hisID,"Hit efficiency",1,0,1.);
00076       meEfficiency_->setAxisTitle("Hit efficiency",1);
00077     
00078       hisID = theHistogramId->setHistoId("efficiencyX",id_);
00079       meEfficiencyX_ = dbe->book1D(hisID,"Hit efficiency in X",nbinX,-1.5,1.5);
00080       meEfficiencyX_->setAxisTitle("Hit efficiency in X",1);
00081     
00082       hisID = theHistogramId->setHistoId("efficiencyY",id_);
00083       meEfficiencyY_ = dbe->book1D(hisID,"Hit efficiency in Y",nbinY,-4.,4.);
00084       meEfficiencyY_->setAxisTitle("Hit efficiency in Y",1);
00085     
00086       hisID = theHistogramId->setHistoId("efficiencyAlpha",id_);
00087       meEfficiencyAlpha_ = dbe->book1D(hisID,"Hit efficiency in Alpha",nbinangle,-3.5,3.5);
00088       meEfficiencyAlpha_->setAxisTitle("Hit efficiency in Alpha",1);
00089     
00090       hisID = theHistogramId->setHistoId("efficiencyBeta",id_);
00091       meEfficiencyBeta_ = dbe->book1D(hisID,"Hit efficiency in Beta",nbinangle,-3.5,3.5);
00092       meEfficiencyBeta_->setAxisTitle("Hit efficiency in Beta",1);
00093     }
00094 
00095     //VALID
00096     hisID = theHistogramId->setHistoId("valid",id_);
00097     meValid_ = dbe->book1D(hisID,"# Valid hits",1,0,1.);
00098     meValid_->setAxisTitle("# Valid hits",1);
00099     
00100     /*hisID = theHistogramId->setHistoId("validX",id_);
00101     meValidX_ = dbe->book1D(hisID,"# Valid hits in X",nbinX,-1.5,1.5);
00102     meValidX_->setAxisTitle("# Valid hits in X",1);
00103     
00104     hisID = theHistogramId->setHistoId("validY",id_);
00105     meValidY_ = dbe->book1D(hisID,"# Valid hits in Y",nbinY,-4.,4.);
00106     meValidY_->setAxisTitle("# Valid hits in Y",1);
00107     
00108     hisID = theHistogramId->setHistoId("validAlpha",id_);
00109     meValidAlpha_ = dbe->book1D(hisID,"# Valid hits in Alpha",nbinangle,-3.5,3.5);
00110     meValidAlpha_->setAxisTitle("# Valid hits in Alpha",1);
00111     
00112     hisID = theHistogramId->setHistoId("validBeta",id_);
00113     meValidBeta_ = dbe->book1D(hisID,"# Valid hits in Beta",nbinangle,-3.5,3.5);
00114     meValidBeta_->setAxisTitle("# Valid hits in Beta",1);*/
00115 
00116     //MISSING
00117     hisID = theHistogramId->setHistoId("missing",id_);
00118     meMissing_ = dbe->book1D(hisID,"# Missing hits",1,0,1.);
00119     meMissing_->setAxisTitle("# Missing hits",1);
00120     
00121     /*hisID = theHistogramId->setHistoId("missingX",id_);
00122     meMissingX_ = dbe->book1D(hisID,"# Missing hits in X",nbinX,-1.5,1.5);
00123     meMissingX_->setAxisTitle("# Missing hits in X",1);
00124     
00125     hisID = theHistogramId->setHistoId("missingY",id_);
00126     meMissingY_ = dbe->book1D(hisID,"# Missing hits in Y",nbinY,-4.,4.);
00127     meMissingY_->setAxisTitle("# Missing hits in Y",1);
00128     
00129     hisID = theHistogramId->setHistoId("missingAlpha",id_);
00130     meMissingAlpha_ = dbe->book1D(hisID,"# Missing hits in Alpha",nbinangle,-3.5,3.5);
00131     meMissingAlpha_->setAxisTitle("# Missing hits in Alpha",1);
00132     
00133     hisID = theHistogramId->setHistoId("missingBeta",id_);
00134     meMissingBeta_ = dbe->book1D(hisID,"# Missing hits in Beta",nbinangle,-3.5,3.5);
00135     meMissingBeta_->setAxisTitle("# Missing hits in Beta",1);*/
00136     
00137     delete theHistogramId;
00138   }
00139 
00140   if(type==1 && barrel){
00141     uint32_t DBladder = PixelBarrelName(DetId(id_)).ladderName();
00142     char sladder[80]; sprintf(sladder,"Ladder_%02i",DBladder);
00143     hisID = src.label() + "_" + sladder;
00144     if(isHalfModule) hisID += "H";
00145     else hisID += "F";
00146     
00147     if(updateEfficiencies){
00148       //EFFICIENCY
00149       meEfficiencyLad_ = dbe->book1D("efficiency_"+hisID,"Hit efficiency",1,0,1.);
00150       meEfficiencyLad_->setAxisTitle("Hit efficiency",1);
00151     
00152       meEfficiencyXLad_ = dbe->book1D("efficiencyX_"+hisID,"Hit efficiency in X",nbinX,-1.5,1.5);
00153       meEfficiencyXLad_->setAxisTitle("Hit efficiency in X",1);
00154     
00155       meEfficiencyYLad_ = dbe->book1D("efficiencyY_"+hisID,"Hit efficiency in Y",nbinY,-4.,4.);
00156       meEfficiencyYLad_->setAxisTitle("Hit efficiency in Y",1);
00157     
00158       meEfficiencyAlphaLad_ = dbe->book1D("efficiencyAlpha_"+hisID,"Hit efficiency in Alpha",nbinangle,-3.5,3.5);
00159       meEfficiencyAlphaLad_->setAxisTitle("Hit efficiency in Alpha",1);
00160     
00161       meEfficiencyBetaLad_ = dbe->book1D("efficiencyBeta_"+hisID,"Hit efficiency in Beta",nbinangle,-3.5,3.5);
00162       meEfficiencyBetaLad_->setAxisTitle("Hit efficiency in Beta",1);
00163     }
00164     
00165     //VALID
00166     meValidLad_ = dbe->book1D("valid_"+hisID,"# Valid hits",1,0,1.);
00167     meValidLad_->setAxisTitle("# Valid hits",1);
00168     
00169     meValidXLad_ = dbe->book1D("validX_"+hisID,"# Valid hits in X",nbinX,-1.5,1.5);
00170     meValidXLad_->setAxisTitle("# Valid hits in X",1);
00171     
00172     meValidYLad_ = dbe->book1D("validY_"+hisID,"# Valid hits in Y",nbinY,-4.,4.);
00173     meValidYLad_->setAxisTitle("# Valid hits in Y",1);
00174     
00175     meValidAlphaLad_ = dbe->book1D("validAlpha_"+hisID,"# Valid hits in Alpha",nbinangle,-3.5,3.5);
00176     meValidAlphaLad_->setAxisTitle("# Valid hits in Alpha",1);
00177     
00178     meValidBetaLad_ = dbe->book1D("validBeta_"+hisID,"# Valid hits in Beta",nbinangle,-3.5,3.5);
00179     meValidBetaLad_->setAxisTitle("# Valid hits in Beta",1);
00180 
00181     //MISSING
00182     meMissingLad_ = dbe->book1D("missing_"+hisID,"# Missing hits",1,0,1.);
00183     meMissingLad_->setAxisTitle("# Missing hits",1);
00184     
00185     meMissingXLad_ = dbe->book1D("missingX_"+hisID,"# Missing hits in X",nbinX,-1.5,1.5);
00186     meMissingXLad_->setAxisTitle("# Missing hits in X",1);
00187     
00188     meMissingYLad_ = dbe->book1D("missingY_"+hisID,"# Missing hits in Y",nbinY,-4.,4.);
00189     meMissingYLad_->setAxisTitle("# Missing hits in Y",1);
00190     
00191     meMissingAlphaLad_ = dbe->book1D("missingAlpha_"+hisID,"# Missing hits in Alpha",nbinangle,-3.5,3.5);
00192     meMissingAlphaLad_->setAxisTitle("# Missing hits in Alpha",1);
00193     
00194     meMissingBetaLad_ = dbe->book1D("missingBeta_"+hisID,"# Missing hits in Beta",nbinangle,-3.5,3.5);
00195     meMissingBetaLad_->setAxisTitle("# Missing hits in Beta",1);
00196   }
00197   
00198   if(type==2 && barrel){
00199     uint32_t DBlayer = PixelBarrelName(DetId(id_)).layerName();
00200     char slayer[80]; sprintf(slayer,"Layer_%i",DBlayer);
00201     hisID = src.label() + "_" + slayer;
00202 
00203 
00204     if(updateEfficiencies){
00205       //EFFICIENCY
00206       meEfficiencyLay_ = dbe->book1D("efficiency_"+hisID,"Hit efficiency",1,0,1.);
00207       meEfficiencyLay_->setAxisTitle("Hit efficiency",1);
00208     
00209       meEfficiencyXLay_ = dbe->book1D("efficiencyX_"+hisID,"Hit efficiency in X",nbinX,-1.5,1.5);
00210       meEfficiencyXLay_->setAxisTitle("Hit efficiency in X",1);
00211     
00212       meEfficiencyYLay_ = dbe->book1D("efficiencyY_"+hisID,"Hit efficiency in Y",nbinY,-4.,4.);
00213       meEfficiencyYLay_->setAxisTitle("Hit efficiency in Y",1);
00214     
00215       meEfficiencyAlphaLay_ = dbe->book1D("efficiencyAlpha_"+hisID,"Hit efficiency in Alpha",nbinangle,-3.5,3.5);
00216       meEfficiencyAlphaLay_->setAxisTitle("Hit efficiency in Alpha",1);
00217     
00218       meEfficiencyBetaLay_ = dbe->book1D("efficiencyBeta_"+hisID,"Hit efficiency in Beta",nbinangle,-3.5,3.5);
00219       meEfficiencyBetaLay_->setAxisTitle("Hit efficiency in Beta",1);
00220     }
00221     
00222     //VALID
00223     meValidLay_ = dbe->book1D("valid_"+hisID,"# Valid hits",1,0,1.);
00224     meValidLay_->setAxisTitle("# Valid hits",1);
00225     
00226     meValidXLay_ = dbe->book1D("validX_"+hisID,"# Valid hits in X",nbinX,-1.5,1.5);
00227     meValidXLay_->setAxisTitle("# Valid hits in X",1);
00228     
00229     meValidYLay_ = dbe->book1D("validY_"+hisID,"# Valid hits in Y",nbinY,-4.,4.);
00230     meValidYLay_->setAxisTitle("# Valid hits in Y",1);
00231     
00232     meValidAlphaLay_ = dbe->book1D("validAlpha_"+hisID,"# Valid hits in Alpha",nbinangle,-3.5,3.5);
00233     meValidAlphaLay_->setAxisTitle("# Valid hits in Alpha",1);
00234     
00235     meValidBetaLay_ = dbe->book1D("validBeta_"+hisID,"# Valid hits in Beta",nbinangle,-3.5,3.5);
00236     meValidBetaLay_->setAxisTitle("# Valid hits in Beta",1);
00237 
00238     //MISSING
00239     meMissingLay_ = dbe->book1D("missing_"+hisID,"# Missing hits",1,0,1.);
00240     meMissingLay_->setAxisTitle("# Missing hits",1);
00241     
00242     meMissingXLay_ = dbe->book1D("missingX_"+hisID,"# Missing hits in X",nbinX,-1.5,1.5);
00243     meMissingXLay_->setAxisTitle("# Missing hits in X",1);
00244     
00245     meMissingYLay_ = dbe->book1D("missingY_"+hisID,"# Missing hits in Y",nbinY,-4.,4.);
00246     meMissingYLay_->setAxisTitle("# Missing hits in Y",1);
00247     
00248     meMissingAlphaLay_ = dbe->book1D("missingAlpha_"+hisID,"# Missing hits in Alpha",nbinangle,-3.5,3.5);
00249     meMissingAlphaLay_->setAxisTitle("# Missing hits in Alpha",1);
00250     
00251     meMissingBetaLay_ = dbe->book1D("missingBeta_"+hisID,"# Missing hits in Beta",nbinangle,-3.5,3.5);
00252     meMissingBetaLay_->setAxisTitle("# Missing hits in Beta",1);
00253   }
00254   
00255   if(type==3 && barrel){
00256     uint32_t DBmodule = PixelBarrelName(DetId(id_)).moduleName();
00257     char smodule[80]; sprintf(smodule,"Ring_%i",DBmodule);
00258     hisID = src.label() + "_" + smodule;
00259     
00260     if(updateEfficiencies){
00261       //EFFICIENCY
00262       meEfficiencyPhi_ = dbe->book1D("efficiency_"+hisID,"Hit efficiency",1,0,1.);
00263       meEfficiencyPhi_->setAxisTitle("Hit efficiency",1);
00264     
00265       meEfficiencyXPhi_ = dbe->book1D("efficiencyX_"+hisID,"Hit efficiency in X",nbinX,-1.5,1.5);
00266       meEfficiencyXPhi_->setAxisTitle("Hit efficiency in X",1);
00267     
00268       meEfficiencyYPhi_ = dbe->book1D("efficiencyY_"+hisID,"Hit efficiency in Y",nbinY,-4.,4.);
00269       meEfficiencyYPhi_->setAxisTitle("Hit efficiency in Y",1);
00270     
00271       meEfficiencyAlphaPhi_ = dbe->book1D("efficiencyAlpha_"+hisID,"Hit efficiency in Alpha",nbinangle,-3.5,3.5);
00272       meEfficiencyAlphaPhi_->setAxisTitle("Hit efficiency in Alpha",1);
00273     
00274       meEfficiencyBetaPhi_ = dbe->book1D("efficiencyBeta_"+hisID,"Hit efficiency in Beta",nbinangle,-3.5,3.5);
00275       meEfficiencyBetaPhi_->setAxisTitle("Hit efficiency in Beta",1);
00276     }
00277     
00278     //VALID
00279     meValidPhi_ = dbe->book1D("valid_"+hisID,"# Valid hits",1,0,1.);
00280     meValidPhi_->setAxisTitle("# Valid hits",1);
00281     
00282     meValidXPhi_ = dbe->book1D("validX_"+hisID,"# Valid hits in X",nbinX,-1.5,1.5);
00283     meValidXPhi_->setAxisTitle("# Valid hits in X",1);
00284     
00285     meValidYPhi_ = dbe->book1D("validY_"+hisID,"# Valid hits in Y",nbinY,-4.,4.);
00286     meValidYPhi_->setAxisTitle("# Valid hits in Y",1);
00287     
00288     meValidAlphaPhi_ = dbe->book1D("validAlpha_"+hisID,"# Valid hits in Alpha",nbinangle,-3.5,3.5);
00289     meValidAlphaPhi_->setAxisTitle("# Valid hits in Alpha",1);
00290     
00291     meValidBetaPhi_ = dbe->book1D("validBeta_"+hisID,"# Valid hits in Beta",nbinangle,-3.5,3.5);
00292     meValidBetaPhi_->setAxisTitle("# Valid hits in Beta",1);
00293 
00294     //MISSING
00295     meMissingPhi_ = dbe->book1D("missing_"+hisID,"# Missing hits",1,0,1.);
00296     meMissingPhi_->setAxisTitle("# Missing hits",1);
00297     
00298     meMissingXPhi_ = dbe->book1D("missingX_"+hisID,"# Missing hits in X",nbinX,-1.5,1.5);
00299     meMissingXPhi_->setAxisTitle("# Missing hits in X",1);
00300     
00301     meMissingYPhi_ = dbe->book1D("missingY_"+hisID,"# Missing hits in Y",nbinY,-4.,4.);
00302     meMissingYPhi_->setAxisTitle("# Missing hits in Y",1);
00303     
00304     meMissingAlphaPhi_ = dbe->book1D("missingAlpha_"+hisID,"# Missing hits in Alpha",nbinangle,-3.5,3.5);
00305     meMissingAlphaPhi_->setAxisTitle("# Missing hits in Alpha",1);
00306     
00307     meMissingBetaPhi_ = dbe->book1D("missingBeta_"+hisID,"# Missing hits in Beta",nbinangle,-3.5,3.5);
00308     meMissingBetaPhi_->setAxisTitle("# Missing hits in Beta",1); 
00309   }
00310   
00311   if(type==4 && endcap){
00312     uint32_t blade= PixelEndcapName(DetId(id_)).bladeName();
00313     
00314     char sblade[80]; sprintf(sblade, "Blade_%02i",blade);
00315     hisID = src.label() + "_" + sblade;
00316     
00317     if(updateEfficiencies){
00318       //EFFICIENCY
00319       meEfficiencyBlade_ = dbe->book1D("efficiency_"+hisID,"Hit efficiency",1,0,1.);
00320       meEfficiencyBlade_->setAxisTitle("Hit efficiency",1);
00321     
00322       meEfficiencyXBlade_ = dbe->book1D("efficiencyX_"+hisID,"Hit efficiency in X",nbinX,-1.5,1.5);
00323       meEfficiencyXBlade_->setAxisTitle("Hit efficiency in X",1);
00324     
00325       meEfficiencyYBlade_ = dbe->book1D("efficiencyY_"+hisID,"Hit efficiency in Y",nbinY,-4.,4.);
00326       meEfficiencyYBlade_->setAxisTitle("Hit efficiency in Y",1);
00327     
00328       meEfficiencyAlphaBlade_ = dbe->book1D("efficiencyAlpha_"+hisID,"Hit efficiency in Alpha",nbinangle,-3.5,3.5);
00329       meEfficiencyAlphaBlade_->setAxisTitle("Hit efficiency in Alpha",1);
00330     
00331       meEfficiencyBetaBlade_ = dbe->book1D("efficiencyBeta_"+hisID,"Hit efficiency in Beta",nbinangle,-3.5,3.5);
00332       meEfficiencyBetaBlade_->setAxisTitle("Hit efficiency in Beta",1);
00333     }
00334     
00335     //VALID
00336     meValidBlade_ = dbe->book1D("valid_"+hisID,"# Valid hits",1,0,1.);
00337     meValidBlade_->setAxisTitle("# Valid hits",1);
00338     
00339     meValidXBlade_ = dbe->book1D("validX_"+hisID,"# Valid hits in X",nbinX,-1.5,1.5);
00340     meValidXBlade_->setAxisTitle("# Valid hits in X",1);
00341     
00342     meValidYBlade_ = dbe->book1D("validY_"+hisID,"# Valid hits in Y",nbinY,-4.,4.);
00343     meValidYBlade_->setAxisTitle("# Valid hits in Y",1);
00344     
00345     meValidAlphaBlade_ = dbe->book1D("validAlpha_"+hisID,"# Valid hits in Alpha",nbinangle,-3.5,3.5);
00346     meValidAlphaBlade_->setAxisTitle("# Valid hits in Alpha",1);
00347     
00348     meValidBetaBlade_ = dbe->book1D("validBeta_"+hisID,"# Valid hits in Beta",nbinangle,-3.5,3.5);
00349     meValidBetaBlade_->setAxisTitle("# Valid hits in Beta",1);
00350 
00351     //MISSING
00352     meMissingBlade_ = dbe->book1D("missing_"+hisID,"# Missing hits",1,0,1.);
00353     meMissingBlade_->setAxisTitle("# Missing hits",1);
00354     
00355     meMissingXBlade_ = dbe->book1D("missingX_"+hisID,"# Missing hits in X",nbinX,-1.5,1.5);
00356     meMissingXBlade_->setAxisTitle("# Missing hits in X",1);
00357     
00358     meMissingYBlade_ = dbe->book1D("missingY_"+hisID,"# Missing hits in Y",nbinY,-4.,4.);
00359     meMissingYBlade_->setAxisTitle("# Missing hits in Y",1);
00360     
00361     meMissingAlphaBlade_ = dbe->book1D("missingAlpha_"+hisID,"# Missing hits in Alpha",nbinangle,-3.5,3.5);
00362     meMissingAlphaBlade_->setAxisTitle("# Missing hits in Alpha",1);
00363     
00364     meMissingBetaBlade_ = dbe->book1D("missingBeta_"+hisID,"# Missing hits in Beta",nbinangle,-3.5,3.5);
00365     meMissingBetaBlade_->setAxisTitle("# Missing hits in Beta",1); 
00366   }
00367   
00368   if(type==5 && endcap){
00369     uint32_t disk = PixelEndcapName(DetId(id_)).diskName();
00370     
00371     char sdisk[80]; sprintf(sdisk, "Disk_%i",disk);
00372     hisID = src.label() + "_" + sdisk;
00373     
00374     if(updateEfficiencies){
00375       //EFFICIENCY
00376       meEfficiencyDisk_ = dbe->book1D("efficiency_"+hisID,"Hit efficiency",1,0,1.);
00377       meEfficiencyDisk_->setAxisTitle("Hit efficiency",1);
00378     
00379       meEfficiencyXDisk_ = dbe->book1D("efficiencyX_"+hisID,"Hit efficiency in X",nbinX,-1.5,1.5);
00380       meEfficiencyXDisk_->setAxisTitle("Hit efficiency in X",1);
00381     
00382       meEfficiencyYDisk_ = dbe->book1D("efficiencyY_"+hisID,"Hit efficiency in Y",nbinY,-4.,4.);
00383       meEfficiencyYDisk_->setAxisTitle("Hit efficiency in Y",1);
00384     
00385       meEfficiencyAlphaDisk_ = dbe->book1D("efficiencyAlpha_"+hisID,"Hit efficiency in Alpha",nbinangle,-3.5,3.5);
00386       meEfficiencyAlphaDisk_->setAxisTitle("Hit efficiency in Alpha",1);
00387     
00388       meEfficiencyBetaDisk_ = dbe->book1D("efficiencyBeta_"+hisID,"Hit efficiency in Beta",nbinangle,-3.5,3.5);
00389       meEfficiencyBetaDisk_->setAxisTitle("Hit efficiency in Beta",1);
00390     }
00391     
00392     //VALID
00393     meValidDisk_ = dbe->book1D("valid_"+hisID,"# Valid hits",1,0,1.);
00394     meValidDisk_->setAxisTitle("# Valid hits",1);
00395     
00396     meValidXDisk_ = dbe->book1D("validX_"+hisID,"# Valid hits in X",nbinX,-1.5,1.5);
00397     meValidXDisk_->setAxisTitle("# Valid hits in X",1);
00398     
00399     meValidYDisk_ = dbe->book1D("validY_"+hisID,"# Valid hits in Y",nbinY,-4.,4.);
00400     meValidYDisk_->setAxisTitle("# Valid hits in Y",1);
00401     
00402     meValidAlphaDisk_ = dbe->book1D("validAlpha_"+hisID,"# Valid hits in Alpha",nbinangle,-3.5,3.5);
00403     meValidAlphaDisk_->setAxisTitle("# Valid hits in Alpha",1);
00404     
00405     meValidBetaDisk_ = dbe->book1D("validBeta_"+hisID,"# Valid hits in Beta",nbinangle,-3.5,3.5);
00406     meValidBetaDisk_->setAxisTitle("# Valid hits in Beta",1);
00407 
00408     //MISSING
00409     meMissingDisk_ = dbe->book1D("missing_"+hisID,"# Missing hits",1,0,1.);
00410     meMissingDisk_->setAxisTitle("# Missing hits",1);
00411     
00412     meMissingXDisk_ = dbe->book1D("missingX_"+hisID,"# Missing hits in X",nbinX,-1.5,1.5);
00413     meMissingXDisk_->setAxisTitle("# Missing hits in X",1);
00414     
00415     meMissingYDisk_ = dbe->book1D("missingY_"+hisID,"# Missing hits in Y",nbinY,-4.,4.);
00416     meMissingYDisk_->setAxisTitle("# Missing hits in Y",1);
00417     
00418     meMissingAlphaDisk_ = dbe->book1D("missingAlpha_"+hisID,"# Missing hits in Alpha",nbinangle,-3.5,3.5);
00419     meMissingAlphaDisk_->setAxisTitle("# Missing hits in Alpha",1);
00420     
00421     meMissingBetaDisk_ = dbe->book1D("missingBeta_"+hisID,"# Missing hits in Beta",nbinangle,-3.5,3.5);
00422     meMissingBetaDisk_->setAxisTitle("# Missing hits in Beta",1);
00423   }
00424     
00425    
00426   if(type==6 && endcap){
00427     uint32_t panel= PixelEndcapName(DetId(id_)).pannelName();
00428     uint32_t module= PixelEndcapName(DetId(id_)).plaquetteName();
00429     char slab[80]; sprintf(slab, "Panel_%i_Ring_%i",panel, module);
00430     hisID = src.label() + "_" + slab;
00431     
00432     if(updateEfficiencies){
00433       //EFFICIENCY
00434       meEfficiencyRing_ = dbe->book1D("efficiency_"+hisID,"Hit efficiency",1,0,1.);
00435       meEfficiencyRing_->setAxisTitle("Hit efficiency",1);
00436     
00437       meEfficiencyXRing_ = dbe->book1D("efficiencyX_"+hisID,"Hit efficiency in X",nbinX,-1.5,1.5);
00438       meEfficiencyXRing_->setAxisTitle("Hit efficiency in X",1);
00439     
00440       meEfficiencyYRing_ = dbe->book1D("efficiencyY_"+hisID,"Hit efficiency in Y",nbinY,-4.,4.);
00441       meEfficiencyYRing_->setAxisTitle("Hit efficiency in Y",1);
00442     
00443       meEfficiencyAlphaRing_ = dbe->book1D("efficiencyAlpha_"+hisID,"Hit efficiency in Alpha",nbinangle,-3.5,3.5);
00444       meEfficiencyAlphaRing_->setAxisTitle("Hit efficiency in Alpha",1);
00445     
00446       meEfficiencyBetaRing_ = dbe->book1D("efficiencyBeta_"+hisID,"Hit efficiency in Beta",nbinangle,-3.5,3.5);
00447       meEfficiencyBetaRing_->setAxisTitle("Hit efficiency in Beta",1);
00448     }
00449     
00450     //VALID
00451     meValidRing_ = dbe->book1D("valid_"+hisID,"# Valid hits",1,0,1.);
00452     meValidRing_->setAxisTitle("# Valid hits",1);
00453     
00454     meValidXRing_ = dbe->book1D("validX_"+hisID,"# Valid hits in X",nbinX,-1.5,1.5);
00455     meValidXRing_->setAxisTitle("# Valid hits in X",1);
00456     
00457     meValidYRing_ = dbe->book1D("validY_"+hisID,"# Valid hits in Y",nbinY,-4.,4.);
00458     meValidYRing_->setAxisTitle("# Valid hits in Y",1);
00459     
00460     meValidAlphaRing_ = dbe->book1D("validAlpha_"+hisID,"# Valid hits in Alpha",nbinangle,-3.5,3.5);
00461     meValidAlphaRing_->setAxisTitle("# Valid hits in Alpha",1);
00462     
00463     meValidBetaRing_ = dbe->book1D("validBeta_"+hisID,"# Valid hits in Beta",nbinangle,-3.5,3.5);
00464     meValidBetaRing_->setAxisTitle("# Valid hits in Beta",1);
00465 
00466     //MISSING
00467     meMissingRing_ = dbe->book1D("missing_"+hisID,"# Missing hits",1,0,1.);
00468     meMissingRing_->setAxisTitle("# Missing hits",1);
00469     
00470     meMissingXRing_ = dbe->book1D("missingX_"+hisID,"# Missing hits in X",nbinX,-1.5,1.5);
00471     meMissingXRing_->setAxisTitle("# Missing hits in X",1);
00472     
00473     meMissingYRing_ = dbe->book1D("missingY_"+hisID,"# Missing hits in Y",nbinY,-4.,4.);
00474     meMissingYRing_->setAxisTitle("# Missing hits in Y",1);
00475     
00476     meMissingAlphaRing_ = dbe->book1D("missingAlpha_"+hisID,"# Missing hits in Alpha",nbinangle,-3.5,3.5);
00477     meMissingAlphaRing_->setAxisTitle("# Missing hits in Alpha",1);
00478     
00479     meMissingBetaRing_ = dbe->book1D("missingBeta_"+hisID,"# Missing hits in Beta",nbinangle,-3.5,3.5);
00480     meMissingBetaRing_->setAxisTitle("# Missing hits in Beta",1);
00481   }
00482 }
00483 
00484 
00485 void SiPixelHitEfficiencyModule::fill(LocalTrajectoryParameters ltp, bool isHitValid, bool modon, bool ladon, bool layon, bool phion, bool bladeon, bool diskon, bool ringon) {
00486 
00487   bool barrel = DetId(id_).subdetId() == static_cast<int>(PixelSubdetector::PixelBarrel);
00488   bool endcap = DetId(id_).subdetId() == static_cast<int>(PixelSubdetector::PixelEndcap);
00489 
00490   LocalVector localDir = ltp.momentum()/ltp.momentum().mag();
00491   float prediction_alpha = atan2(localDir.z(), localDir.x());
00492   float prediction_beta = atan2(localDir.z(), localDir.y());
00493   float prediction_x = ltp.position().x();
00494   float prediction_y = ltp.position().y();
00495   
00496   if(isHitValid){
00497     if(modon){
00498       meValid_->Fill(0.5);
00499       /*meValidX_->Fill(prediction_x);
00500       meValidY_->Fill(prediction_y);
00501       meValidAlpha_->Fill(prediction_alpha);
00502       meValidBeta_->Fill(prediction_beta);*/
00503     }
00504     if(barrel && ladon){
00505       meValidLad_->Fill(0.5);
00506       meValidXLad_->Fill(prediction_x);
00507       meValidYLad_->Fill(prediction_y);
00508       meValidAlphaLad_->Fill(prediction_alpha);
00509       meValidBetaLad_->Fill(prediction_beta);
00510     }
00511     if(barrel && layon){
00512       meValidLay_->Fill(0.5);
00513       meValidXLay_->Fill(prediction_x);
00514       meValidYLay_->Fill(prediction_y);
00515       meValidAlphaLay_->Fill(prediction_alpha);
00516       meValidBetaLay_->Fill(prediction_beta);
00517     }   
00518     if(barrel && phion){
00519       meValidPhi_->Fill(0.5);
00520       meValidXPhi_->Fill(prediction_x);
00521       meValidYPhi_->Fill(prediction_y);
00522       meValidAlphaPhi_->Fill(prediction_alpha);
00523       meValidBetaPhi_->Fill(prediction_beta);
00524     }
00525     if(endcap && bladeon){
00526       meValidBlade_->Fill(0.5);
00527       meValidXBlade_->Fill(prediction_x);
00528       meValidYBlade_->Fill(prediction_y);
00529       meValidAlphaBlade_->Fill(prediction_alpha);
00530       meValidBetaBlade_->Fill(prediction_beta);
00531     }
00532     if(endcap && diskon){
00533       meValidDisk_->Fill(0.5);
00534       meValidXDisk_->Fill(prediction_x);
00535       meValidYDisk_->Fill(prediction_y);
00536       meValidAlphaDisk_->Fill(prediction_alpha);
00537       meValidBetaDisk_->Fill(prediction_beta);
00538     }
00539     if(endcap && ringon){
00540       meValidRing_->Fill(0.5);
00541       meValidXRing_->Fill(prediction_x);
00542       meValidYRing_->Fill(prediction_y);
00543       meValidAlphaRing_->Fill(prediction_alpha);
00544       meValidBetaRing_->Fill(prediction_beta);
00545     }
00546   }
00547   else {
00548     if(modon){
00549       meMissing_->Fill(0.5);
00550       /*meMissingX_->Fill(prediction_x);
00551       meMissingY_->Fill(prediction_y);
00552       meMissingAlpha_->Fill(prediction_alpha);
00553       meMissingBeta_->Fill(prediction_beta);*/
00554     }
00555     if(barrel && ladon){
00556       meMissingLad_->Fill(0.5);
00557       meMissingXLad_->Fill(prediction_x);
00558       meMissingYLad_->Fill(prediction_y);
00559       meMissingAlphaLad_->Fill(prediction_alpha);
00560       meMissingBetaLad_->Fill(prediction_beta);
00561     }
00562     if(barrel && layon){
00563       meMissingLay_->Fill(0.5);
00564       meMissingXLay_->Fill(prediction_x);
00565       meMissingYLay_->Fill(prediction_y);
00566       meMissingAlphaLay_->Fill(prediction_alpha);
00567       meMissingBetaLay_->Fill(prediction_beta);
00568     }   
00569     if(barrel && phion){
00570       meMissingPhi_->Fill(0.5);
00571       meMissingXPhi_->Fill(prediction_x);
00572       meMissingYPhi_->Fill(prediction_y);
00573       meMissingAlphaPhi_->Fill(prediction_alpha);
00574       meMissingBetaPhi_->Fill(prediction_beta);
00575     }
00576     if(endcap && bladeon){
00577       meMissingBlade_->Fill(0.5);
00578       meMissingXBlade_->Fill(prediction_x);
00579       meMissingYBlade_->Fill(prediction_y);
00580       meMissingAlphaBlade_->Fill(prediction_alpha);
00581       meMissingBetaBlade_->Fill(prediction_beta);
00582     }
00583     if(endcap && diskon){
00584       meMissingDisk_->Fill(0.5);
00585       meMissingXDisk_->Fill(prediction_x);
00586       meMissingYDisk_->Fill(prediction_y);
00587       meMissingAlphaDisk_->Fill(prediction_alpha);
00588       meMissingBetaDisk_->Fill(prediction_beta);
00589     }
00590     if(endcap && ringon){
00591       meMissingRing_->Fill(0.5);
00592       meMissingXRing_->Fill(prediction_x);
00593       meMissingYRing_->Fill(prediction_y);
00594       meMissingAlphaRing_->Fill(prediction_alpha);
00595       meMissingBetaRing_->Fill(prediction_beta);
00596     }
00597   }
00598   
00599   if(updateEfficiencies)
00600     computeEfficiencies(modon, ladon, layon, phion, bladeon, diskon, ringon);
00601 }
00602 
00603 void SiPixelHitEfficiencyModule::computeEfficiencies(bool modon, bool ladon, bool layon, bool phion, bool bladeon, bool diskon, bool ringon) {
00604   
00605   if(debug_)
00606     std::cout<<"Now Filling histos for detid "<<id_<<std::endl;
00607   
00608   bool barrel = DetId(id_).subdetId() == static_cast<int>(PixelSubdetector::PixelBarrel);
00609   bool endcap = DetId(id_).subdetId() == static_cast<int>(PixelSubdetector::PixelEndcap);
00610   
00611   if(modon){
00612     meEfficiency_->setBinContent(1,(eff(meValid_->getBinContent(1),meMissing_->getBinContent(1))).first);
00613     meEfficiency_->setBinError(1,(eff(meValid_->getBinContent(1),meMissing_->getBinContent(1))).second);
00614     /*for(int i=1;i<=meValidX_->getNbinsX();++i){
00615       meEfficiencyX_->setBinContent(i,(eff(meValidX_->getBinContent(i),meMissingX_->getBinContent(i))).first);
00616       meEfficiencyX_->setBinError(i,(eff(meValidX_->getBinContent(i),meMissingX_->getBinContent(i))).second);
00617     }
00618     for(int i=1;i<=meValidY_->getNbinsX();++i){
00619       meEfficiencyY_->setBinContent(i,(eff(meValidY_->getBinContent(i),meMissingY_->getBinContent(i))).first);
00620       meEfficiencyY_->setBinError(i,(eff(meValidY_->getBinContent(i),meMissingY_->getBinContent(i))).second);
00621     }
00622     for(int i=1;i<=meValidAlpha_->getNbinsX();++i){
00623       meEfficiencyAlpha_->setBinContent(i,(eff(meValidAlpha_->getBinContent(i),meMissingAlpha_->getBinContent(i))).first);
00624       meEfficiencyAlpha_->setBinError(i,(eff(meValidAlpha_->getBinContent(i),meMissingAlpha_->getBinContent(i))).second);
00625     }
00626     for(int i=1;i<=meValidBeta_->getNbinsX();++i){
00627       meEfficiencyBeta_->setBinContent(i,(eff(meValidBeta_->getBinContent(i),meMissingBeta_->getBinContent(i))).first);
00628       meEfficiencyBeta_->setBinError(i,(eff(meValidBeta_->getBinContent(i),meMissingBeta_->getBinContent(i))).second);
00629     }*/
00630   }
00631   if(ladon && barrel){
00632     meEfficiencyLad_->setBinContent(1,(eff(meValidLad_->getBinContent(1),meMissingLad_->getBinContent(1))).first);
00633     meEfficiencyLad_->setBinError(1,(eff(meValidLad_->getBinContent(1),meMissingLad_->getBinContent(1))).second);
00634     for(int i=1;i<=meValidXLad_->getNbinsX();++i){
00635       meEfficiencyXLad_->setBinContent(i,(eff(meValidXLad_->getBinContent(i),meMissingXLad_->getBinContent(i))).first);
00636       meEfficiencyXLad_->setBinError(i,(eff(meValidXLad_->getBinContent(i),meMissingXLad_->getBinContent(i))).second);
00637     }
00638     for(int i=1;i<=meValidYLad_->getNbinsX();++i){
00639       meEfficiencyYLad_->setBinContent(i,(eff(meValidYLad_->getBinContent(i),meMissingYLad_->getBinContent(i))).first);
00640       meEfficiencyYLad_->setBinError(i,(eff(meValidYLad_->getBinContent(i),meMissingYLad_->getBinContent(i))).second);
00641     }
00642     for(int i=1;i<=meValidAlphaLad_->getNbinsX();++i){
00643       meEfficiencyAlphaLad_->setBinContent(i,(eff(meValidAlphaLad_->getBinContent(i),meMissingAlphaLad_->getBinContent(i))).first);
00644       meEfficiencyAlphaLad_->setBinError(i,(eff(meValidAlphaLad_->getBinContent(i),meMissingAlphaLad_->getBinContent(i))).second);
00645     }
00646     for(int i=1;i<=meValidBetaLad_->getNbinsX();++i){
00647       meEfficiencyBetaLad_->setBinContent(i,(eff(meValidBetaLad_->getBinContent(i),meMissingBetaLad_->getBinContent(i))).first);
00648       meEfficiencyBetaLad_->setBinError(i,(eff(meValidBetaLad_->getBinContent(i),meMissingBetaLad_->getBinContent(i))).second);
00649     }
00650   }
00651   
00652   if(layon && barrel){
00653     meEfficiencyLay_->setBinContent(1,(eff(meValidLay_->getBinContent(1),meMissingLay_->getBinContent(1))).first);
00654     meEfficiencyLay_->setBinError(1,(eff(meValidLay_->getBinContent(1),meMissingLay_->getBinContent(1))).second);
00655     for(int i=1;i<=meValidXLay_->getNbinsX();++i){
00656       meEfficiencyXLay_->setBinContent(i,(eff(meValidXLay_->getBinContent(i),meMissingXLay_->getBinContent(i))).first);
00657       meEfficiencyXLay_->setBinError(i,(eff(meValidXLay_->getBinContent(i),meMissingXLay_->getBinContent(i))).second);
00658     }
00659     for(int i=1;i<=meValidYLay_->getNbinsX();++i){
00660       meEfficiencyYLay_->setBinContent(i,(eff(meValidYLay_->getBinContent(i),meMissingYLay_->getBinContent(i))).first);
00661       meEfficiencyYLay_->setBinError(i,(eff(meValidYLay_->getBinContent(i),meMissingYLay_->getBinContent(i))).second);
00662     }
00663     for(int i=1;i<=meValidAlphaLay_->getNbinsX();++i){
00664       meEfficiencyAlphaLay_->setBinContent(i,(eff(meValidAlphaLay_->getBinContent(i),meMissingAlphaLay_->getBinContent(i))).first);
00665       meEfficiencyAlphaLay_->setBinError(i,(eff(meValidAlphaLay_->getBinContent(i),meMissingAlphaLay_->getBinContent(i))).second);
00666     }
00667     for(int i=1;i<=meValidBetaLay_->getNbinsX();++i){
00668       meEfficiencyBetaLay_->setBinContent(i,(eff(meValidBetaLay_->getBinContent(i),meMissingBetaLay_->getBinContent(i))).first);
00669       meEfficiencyBetaLay_->setBinError(i,(eff(meValidBetaLay_->getBinContent(i),meMissingBetaLay_->getBinContent(i))).second);
00670     }
00671   }
00672   
00673   if(phion && barrel){
00674     meEfficiencyPhi_->setBinContent(1,(eff(meValidPhi_->getBinContent(1),meMissingPhi_->getBinContent(1))).first);
00675     meEfficiencyPhi_->setBinError(1,(eff(meValidPhi_->getBinContent(1),meMissingPhi_->getBinContent(1))).second);
00676     for(int i=1;i<=meValidXPhi_->getNbinsX();++i){
00677       meEfficiencyXPhi_->setBinContent(i,(eff(meValidXPhi_->getBinContent(i),meMissingXPhi_->getBinContent(i))).first);
00678       meEfficiencyXPhi_->setBinError(i,(eff(meValidXPhi_->getBinContent(i),meMissingXPhi_->getBinContent(i))).second);
00679     }
00680     for(int i=1;i<=meValidYPhi_->getNbinsX();++i){
00681       meEfficiencyYPhi_->setBinContent(i,(eff(meValidYPhi_->getBinContent(i),meMissingYPhi_->getBinContent(i))).first);
00682       meEfficiencyYPhi_->setBinError(i,(eff(meValidYPhi_->getBinContent(i),meMissingYPhi_->getBinContent(i))).second);
00683     }
00684     for(int i=1;i<=meValidAlphaPhi_->getNbinsX();++i){
00685       meEfficiencyAlphaPhi_->setBinContent(i,(eff(meValidAlphaPhi_->getBinContent(i),meMissingAlphaPhi_->getBinContent(i))).first);
00686       meEfficiencyAlphaPhi_->setBinError(i,(eff(meValidAlphaPhi_->getBinContent(i),meMissingAlphaPhi_->getBinContent(i))).second);
00687     }
00688     for(int i=1;i<=meValidBetaPhi_->getNbinsX();++i){
00689       meEfficiencyBetaPhi_->setBinContent(i,(eff(meValidBetaPhi_->getBinContent(i),meMissingBetaPhi_->getBinContent(i))).first);
00690       meEfficiencyBetaPhi_->setBinError(i,(eff(meValidBetaPhi_->getBinContent(i),meMissingBetaPhi_->getBinContent(i))).second);
00691     }
00692   }
00693   if(bladeon && endcap){
00694     meEfficiencyBlade_->setBinContent(1,(eff(meValidBlade_->getBinContent(1),meMissingBlade_->getBinContent(1))).first);
00695     meEfficiencyBlade_->setBinError(1,(eff(meValidBlade_->getBinContent(1),meMissingBlade_->getBinContent(1))).second);
00696     for(int i=1;i<=meValidXBlade_->getNbinsX();++i){
00697       meEfficiencyXBlade_->setBinContent(i,(eff(meValidXBlade_->getBinContent(i),meMissingXBlade_->getBinContent(i))).first);
00698       meEfficiencyXBlade_->setBinError(i,(eff(meValidXBlade_->getBinContent(i),meMissingXBlade_->getBinContent(i))).second);
00699     }
00700     for(int i=1;i<=meValidYBlade_->getNbinsX();++i){
00701       meEfficiencyYBlade_->setBinContent(i,(eff(meValidYBlade_->getBinContent(i),meMissingYBlade_->getBinContent(i))).first);
00702       meEfficiencyYBlade_->setBinError(i,(eff(meValidYBlade_->getBinContent(i),meMissingYBlade_->getBinContent(i))).second);
00703     }
00704     for(int i=1;i<=meValidAlphaBlade_->getNbinsX();++i){
00705       meEfficiencyAlphaBlade_->setBinContent(i,(eff(meValidAlphaBlade_->getBinContent(i),meMissingAlphaBlade_->getBinContent(i))).first);
00706       meEfficiencyAlphaBlade_->setBinError(i,(eff(meValidAlphaBlade_->getBinContent(i),meMissingAlphaBlade_->getBinContent(i))).second);
00707     }
00708     for(int i=1;i<=meValidBetaBlade_->getNbinsX();++i){
00709       meEfficiencyBetaBlade_->setBinContent(i,(eff(meValidBetaBlade_->getBinContent(i),meMissingBetaBlade_->getBinContent(i))).first);
00710       meEfficiencyBetaBlade_->setBinError(i,(eff(meValidBetaBlade_->getBinContent(i),meMissingBetaBlade_->getBinContent(i))).second);
00711     }
00712   }
00713   if(diskon && endcap){
00714     meEfficiencyDisk_->setBinContent(1,(eff(meValidDisk_->getBinContent(1),meMissingDisk_->getBinContent(1))).first);
00715     meEfficiencyDisk_->setBinError(1,(eff(meValidDisk_->getBinContent(1),meMissingDisk_->getBinContent(1))).second);
00716     for(int i=1;i<=meValidXDisk_->getNbinsX();++i){
00717       meEfficiencyXDisk_->setBinContent(i,(eff(meValidXDisk_->getBinContent(i),meMissingXDisk_->getBinContent(i))).first);
00718       meEfficiencyXDisk_->setBinError(i,(eff(meValidXDisk_->getBinContent(i),meMissingXDisk_->getBinContent(i))).second);
00719     }
00720     for(int i=1;i<=meValidYDisk_->getNbinsX();++i){
00721       meEfficiencyYDisk_->setBinContent(i,(eff(meValidYDisk_->getBinContent(i),meMissingYDisk_->getBinContent(i))).first);
00722       meEfficiencyYDisk_->setBinError(i,(eff(meValidYDisk_->getBinContent(i),meMissingYDisk_->getBinContent(i))).second);
00723     }
00724     for(int i=1;i<=meValidAlphaDisk_->getNbinsX();++i){
00725       meEfficiencyAlphaDisk_->setBinContent(i,(eff(meValidAlphaDisk_->getBinContent(i),meMissingAlphaDisk_->getBinContent(i))).first);
00726       meEfficiencyAlphaDisk_->setBinError(i,(eff(meValidAlphaDisk_->getBinContent(i),meMissingAlphaDisk_->getBinContent(i))).second);
00727     }
00728     for(int i=1;i<=meValidBetaDisk_->getNbinsX();++i){
00729       meEfficiencyBetaDisk_->setBinContent(i,(eff(meValidBetaDisk_->getBinContent(i),meMissingBetaDisk_->getBinContent(i))).first);
00730       meEfficiencyBetaDisk_->setBinError(i,(eff(meValidBetaDisk_->getBinContent(i),meMissingBetaDisk_->getBinContent(i))).second);
00731     }
00732   }
00733   if(ringon && endcap){
00734     meEfficiencyRing_->setBinContent(1,(eff(meValidRing_->getBinContent(1),meMissingRing_->getBinContent(1))).first);
00735     meEfficiencyRing_->setBinError(1,(eff(meValidRing_->getBinContent(1),meMissingRing_->getBinContent(1))).second);
00736     for(int i=1;i<=meValidXRing_->getNbinsX();++i){
00737       meEfficiencyXRing_->setBinContent(i,(eff(meValidXRing_->getBinContent(i),meMissingXRing_->getBinContent(i))).first);
00738       meEfficiencyXRing_->setBinError(i,(eff(meValidXRing_->getBinContent(i),meMissingXRing_->getBinContent(i))).second);
00739     }
00740     for(int i=1;i<=meValidYRing_->getNbinsX();++i){
00741       meEfficiencyYRing_->setBinContent(i,(eff(meValidYRing_->getBinContent(i),meMissingYRing_->getBinContent(i))).first);
00742       meEfficiencyYRing_->setBinError(i,(eff(meValidYRing_->getBinContent(i),meMissingYRing_->getBinContent(i))).second);
00743     }
00744     for(int i=1;i<=meValidAlphaRing_->getNbinsX();++i){
00745       meEfficiencyAlphaRing_->setBinContent(i,(eff(meValidAlphaRing_->getBinContent(i),meMissingAlphaRing_->getBinContent(i))).first);
00746       meEfficiencyAlphaRing_->setBinError(i,(eff(meValidAlphaRing_->getBinContent(i),meMissingAlphaRing_->getBinContent(i))).second);
00747     }
00748     for(int i=1;i<=meValidBetaRing_->getNbinsX();++i){
00749       meEfficiencyBetaRing_->setBinContent(i,(eff(meValidBetaRing_->getBinContent(i),meMissingBetaRing_->getBinContent(i))).first);
00750       meEfficiencyBetaRing_->setBinError(i,(eff(meValidBetaRing_->getBinContent(i),meMissingBetaRing_->getBinContent(i))).second);
00751     }
00752   }
00753 
00754 }
00755 
00756 std::pair<double,double> SiPixelHitEfficiencyModule::eff(double nValid, double nMissing){
00757   double efficiency = 0, error = 0 ;
00758   if(nValid+nMissing!=0){
00759     efficiency=nValid/(nValid+nMissing);
00760     error=sqrt(efficiency*(1.-efficiency)/(nValid+nMissing));
00761   }
00762   return make_pair(efficiency,error);
00763 }
CMSSW_4_4_3_patch1/src/DQM/SiPixelMonitorTrack/src/SiPixelHitEfficiencyModule.cc
