CMSSW Reference Manual

ZeeCalibration::ZeeCalibration ( const edm::ParameterSet & iConfig )

Constructor.

Definition at line 87 of file ZeeCalibration.cc.

References barrelfile_, calibMode_, coefficientDistanceAtIteration, GenMuonPlsPt100GeV_cfg::cout, electronCollection_, electronProducer_, electronSelection_, endcapfile_, lat::endl(), erechitCollection_, erechitProducer_, etaBins_, etaMax_, etaMin_, etBins_, etMax_, etMin_, EcalIndexingTools::getInstance(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), hlTriggerResults_, i, loopArray, mass4tree, massDiff4tree, maxInvMassCut_, mcProducer_, minInvMassCut_, myTree, outputFile_, outputFileName_, produceEcalIntercalibConstants(), rechitCollection_, rechitProducer_, scCollection_, scIslandCollection_, scIslandProducer_, scProducer_, EcalIndexingTools::setBinRange(), edm::ESProducer::setWhatProduced(), sigmaArray, sigmaErrorArray, theAlgorithm_, theMaxLoops, theParameterSet, and wantEtaCorrection_.

00088 {
00089 
00090 #ifdef DEBUG
00091   std::cout<<"[ZeeCalibration] Starting the ctor"<<std::endl;
00092 #endif
00093 
00094   theMaxLoops =  iConfig.getUntrackedParameter<unsigned int>("maxLoops",0);
00095 
00096   wantEtaCorrection_ = iConfig.getUntrackedParameter<bool>("wantEtaCorrection",true);   
00097 
00098   outputFileName_  = iConfig.getParameter<std::string>("outputFile");
00099 
00100   minInvMassCut_ = iConfig.getUntrackedParameter<double>("minInvMassCut", 70.);   
00101   maxInvMassCut_ = iConfig.getUntrackedParameter<double>("maxInvMassCut", 110.);   
00102 
00103   rechitProducer_ = iConfig.getParameter<std::string>("rechitProducer");
00104   rechitCollection_ = iConfig.getParameter<std::string>("rechitCollection");
00105 
00106   erechitProducer_ = iConfig.getParameter<std::string>("erechitProducer");
00107   erechitCollection_ = iConfig.getParameter<std::string>("erechitCollection");
00108 
00109   scProducer_ = iConfig.getParameter<std::string>("scProducer");
00110   scCollection_ = iConfig.getParameter<std::string>("scCollection");
00111 
00112   scIslandProducer_ = iConfig.getParameter<std::string>("scIslandProducer");
00113   scIslandCollection_ = iConfig.getParameter<std::string>("scIslandCollection");
00114 
00115   calibMode_ = iConfig.getUntrackedParameter<std::string>("ZCalib_CalibType");
00116 
00117   mcProducer_ = iConfig.getUntrackedParameter<std::string>("mcProducer","");
00118 
00119 
00120   electronProducer_ = iConfig.getParameter<std::string > ("electronProducer");
00121   electronCollection_ = iConfig.getParameter<std::string > ("electronCollection");
00122 
00123   outputFile_ = TFile::Open(outputFileName_.c_str(),"RECREATE"); // open output file to store histograms  
00124   
00125   myTree = new TTree("myTree","myTree");
00126   //  myTree->Branch("zMass","zMass", &mass);
00127   myTree->Branch("zMass",&mass4tree,"mass/F");
00128   myTree->Branch("zMassDiff",&massDiff4tree,"massDiff/F");
00129 
00130   barrelfile_=iConfig.getUntrackedParameter<std::string> ("initialMiscalibrationBarrel","");
00131   endcapfile_=iConfig.getUntrackedParameter<std::string> ("initialMiscalibrationEndcap","");
00132 
00133   electronSelection_=iConfig.getUntrackedParameter<unsigned int> ("electronSelection",0);//option for electron selection
00134 
00135   etaBins_ = iConfig.getUntrackedParameter<unsigned int>("etaBins", 10);   
00136   etBins_ = iConfig.getUntrackedParameter<unsigned int>("etBins", 10);   
00137 
00138   etaMin_ = iConfig.getUntrackedParameter<double>("etaMin", 0.);   
00139   etMin_ = iConfig.getUntrackedParameter<double>("etMin", 0.);   
00140   etaMax_ = iConfig.getUntrackedParameter<double>("etaMax", 3.);   
00141   etMax_ = iConfig.getUntrackedParameter<double>("etMax", 100.);   
00142 
00143  
00144   //  new ZeePlots("zeePlots.root");
00145   //  ZeePlots->bookHistos();
00146 
00147   //ZeeCalibrationPLots("zeeCalibPlots");
00148   //ZeecaPlots->bookHistos(maxsIter); 
00149   
00150   hlTriggerResults_ = iConfig.getParameter<edm::InputTag> ("HLTriggerResults");
00151 
00152   theParameterSet=iConfig;
00153   EcalIndexingTools* myIndexTool=0;
00154 
00155   
00156   myIndexTool = EcalIndexingTools::getInstance();
00157   
00158   myIndexTool->setBinRange( etaBins_, etaMin_, etaMax_, etBins_, etMin_, etMax_ );
00159   
00160   //creating the algorithm
00161   theAlgorithm_ = new ZIterativeAlgorithmWithFit(iConfig);
00162   
00163   // Tell the framework what data is being produced
00164   //setWhatProduced(this);
00165   setWhatProduced (this, &ZeeCalibration::produceEcalIntercalibConstants ) ;
00166   findingRecord<EcalIntercalibConstantsRcd> () ;
00167 
00168   for(int i = 0; i<50; i++){
00169 
00170     coefficientDistanceAtIteration[i] = -1.;
00171     loopArray[i] = -1.;
00172     sigmaArray[i] = -1.;
00173     sigmaErrorArray[i] = -1.;
00174 
00175   }
00176 
00177 #ifdef DEBUG
00178   std::cout<<"[ZeeCalibration] Done with the ctor"<<std::endl;
00179 #endif
00180 
00181 }

ZeeCalibration::~ZeeCalibration ( )

Destructor.

Definition at line 184 of file ZeeCalibration.cc.

00185 {
00186 //   if (theAlgorithm_)
00187 //     delete theAlgorithm_;
00188 }

void ZeeCalibration::beginOfJob ( const edm::EventSetup & iSetup ) [virtual]

Called at beginning of job.

Reimplemented from edm::EDLooper.

Definition at line 200 of file ZeeCalibration.cc.

References barrelfile_, bookHistograms(), calibCoeff, calibCoeffError, calibMode_, GenMuonPlsPt100GeV_cfg::cout, EcalBarrel, EcalEndcap, endcapfile_, lat::endl(), edm::EventSetup::get(), CaloMiscalibMapEcal::get(), EcalRingCalibrationTools::getDetIdsInECAL(), EcalRingCalibrationTools::getDetIdsInModule(), EcalRingCalibrationTools::getDetIdsInRing(), EcalCondObjectContainer< T >::getMap(), ZIterativeAlgorithmWithFit::getNumberOfChannels(), h2_xtalMiscalibCoeffBarrel_, h2_xtalMiscalibCoeffEndcapMinus_, h2_xtalMiscalibCoeffEndcapPlus_, ical, EBDetId::ieta(), init_, initCalibCoeff, EBDetId::iphi(), EEDetId::ix(), EEDetId::iy(), k, loopFlag_, myZeePlots_, outputFile_, MiscalibReaderFromXML::parseXMLMiscalibFile(), CaloMiscalibMapEcal::prefillMap(), read_events, EcalRingCalibrationTools::setCaloGeometry(), theAlgorithm_, and EEDetId::zside().

00201 {
00202 #ifdef DEBUG
00203   std::cout<<"[ZeeCalibration] Entering beginOfJob"<<std::endl;
00204 #endif
00205 
00206 //inizializzare la geometria di ecal
00207   edm::ESHandle<CaloGeometry> pG;
00208   iSetup.get<CaloGeometryRecord>().get(pG);     
00209   EcalRingCalibrationTools::setCaloGeometry(&(*pG));  
00210      
00211   myZeePlots_ = new ZeePlots( "zeePlots.root" );
00212   //  myZeeRescaleFactorPlots_ = new ZeeRescaleFactorPlots("zeeRescaleFactorPlots.root");
00213 
00214 // go to *OUR* rootfile and book histograms                                                                                                                
00215   outputFile_->cd();
00216   bookHistograms();
00217 
00218   std::cout<<"[ZeeCalibration::beginOfJob] Histograms booked "<<std::endl;
00219 
00220   loopFlag_ = 0;
00221 
00222   //Read miscalibration map if requested
00223   CaloMiscalibMapEcal* miscalibMap=0;
00224   if (!barrelfile_.empty() || !barrelfile_.empty())
00225     {
00226       miscalibMap=new CaloMiscalibMapEcal();
00227       miscalibMap->prefillMap();
00228     }
00229 
00230 
00231   if(!barrelfile_.empty())
00232     {
00233       MiscalibReaderFromXMLEcalBarrel barrelreader_(*miscalibMap);
00234       barrelreader_.parseXMLMiscalibFile(barrelfile_);
00235 #ifdef DEBUG
00236   std::cout<<"[ZeeCalibration::beginOfJob] Parsed EB miscal file"<<std::endl;
00237 #endif
00238     }
00239 
00240   if(!endcapfile_.empty())
00241     {
00242       MiscalibReaderFromXMLEcalEndcap endcapreader_(*miscalibMap);
00243       endcapreader_.parseXMLMiscalibFile(endcapfile_);
00244 #ifdef DEBUG
00245   std::cout<<"[ZeeCalibration::beginOfJob] Parsed EE miscal file"<<std::endl;
00246 #endif
00247     }
00248 
00249   std::cout << "  theAlgorithm_->getNumberOfChannels() "
00250             << theAlgorithm_->getNumberOfChannels() << std::endl;
00251 
00252 
00254   for(int k = 0; k < theAlgorithm_->getNumberOfChannels(); k++)
00255     {
00256       calibCoeff[k]=1.;
00257       calibCoeffError[k]=0.;
00258      
00259       std::vector<DetId> ringIds;
00260 
00261       if(calibMode_ == "RING")
00262         ringIds = EcalRingCalibrationTools::getDetIdsInRing(k);
00263 
00264       if(calibMode_ == "MODULE")
00265         ringIds = EcalRingCalibrationTools::getDetIdsInModule(k);
00266 
00267       if(calibMode_ == "ABS_SCALE" || calibMode_ == "ETA_ET_MODE" )
00268         ringIds = EcalRingCalibrationTools::getDetIdsInECAL();
00269       
00270       if (miscalibMap)
00271         {
00272           initCalibCoeff[k]=0.;       
00273           for (unsigned int iid=0; iid<ringIds.size();++iid)
00274             {
00275               float miscalib=* (miscalibMap->get().getMap().find(ringIds[iid])  );
00276               //              float miscalib=miscalibMap->get().getMap().find(ringIds[iid])->second; ////////AP
00277               initCalibCoeff[k]+=miscalib;
00278             }
00279           initCalibCoeff[k]/=(float)ringIds.size();
00280           std::cout << k << " " << initCalibCoeff[k] << " " << ringIds.size() << std::endl;
00281         }
00282       else
00283         {
00284           initCalibCoeff[k]=1.;
00285         }
00286     }
00287 
00288   ical = boost::shared_ptr<EcalIntercalibConstants>( new EcalIntercalibConstants() );
00289   
00290   for(int k = 0; k < theAlgorithm_->getNumberOfChannels(); k++)
00291     {
00292       //      std::vector<DetId> ringIds = EcalRingCalibrationTools::getDetIdsInRing(k);
00293 
00294       std::vector<DetId> ringIds;
00295 
00296       if(calibMode_ == "RING")
00297         ringIds = EcalRingCalibrationTools::getDetIdsInRing(k);
00298 
00299       if(calibMode_ == "MODULE")
00300         ringIds = EcalRingCalibrationTools::getDetIdsInModule(k);
00301 
00302       if(calibMode_ == "ABS_SCALE" || calibMode_ == "ETA_ET_MODE")
00303         ringIds = EcalRingCalibrationTools::getDetIdsInECAL();
00304       
00305       
00306       for (unsigned int iid=0; iid<ringIds.size();++iid){
00307         //      ical->setValue( ringIds[iid], 1. * initCalibCoeff[k] );
00308         
00309         if(ringIds[iid].subdetId() == EcalBarrel){
00310           EBDetId myEBDetId(ringIds[iid]);  
00311           h2_xtalMiscalibCoeffBarrel_->SetBinContent( myEBDetId.ieta() + 86, myEBDetId.iphi(), * (miscalibMap->get().getMap().find(ringIds[iid]) ) );//fill TH2 with miscalibCoeff
00312          
00313         }
00314 
00315         if(ringIds[iid].subdetId() == EcalEndcap){
00316           EEDetId myEEDetId(ringIds[iid]);
00317           if(myEEDetId.zside() < 0)
00318             h2_xtalMiscalibCoeffEndcapMinus_->SetBinContent( myEEDetId.ix(), myEEDetId.iy(), * ( miscalibMap->get().getMap().find(ringIds[iid]) ) );//fill TH2 with miscalibCoeff
00319 
00320           if(myEEDetId.zside() > 0)
00321             h2_xtalMiscalibCoeffEndcapPlus_->SetBinContent( myEEDetId.ix(), myEEDetId.iy(), * (miscalibMap->get().getMap().find(ringIds[iid]) ) );//fill TH2 with miscalibCoeff
00322           
00323         }
00324         
00325         ical->setValue( ringIds[iid], *(miscalibMap->get().getMap().find(ringIds[iid])  ) );
00326 
00327       }
00328 
00329   
00330   read_events = 0;
00331   init_ = false;
00332 
00333 
00334     }
00335 #ifdef DEBUG
00336   std::cout<<"[ZeeCalibration] Done with beginOfJob"<<std::endl;
00337 #endif
00338 
00339 }

void ZeeCalibration::bookHistograms ( ) [private]

Definition at line 1692 of file ZeeCalibration.cc.

References ZeePlots::bookEleHistograms(), ZeePlots::bookEleMCHistograms(), ZeePlots::bookZHistograms(), ZeePlots::bookZMCHistograms(), h1_borderElectronClassification_, h1_eleClasses_, h1_electronCosTheta_SC_, h1_electronCosTheta_SC_TK_, h1_electronCosTheta_TK_, h1_eleEtaResol_, h1_elePhiResol_, h1_eventsAfterBorderSelection_, h1_eventsAfterEWKSelection_, h1_eventsBeforeBorderSelection_, h1_eventsBeforeEWKSelection_, h1_mc_, h1_mcEB_, h1_mcEBParz_, h1_mcEE_, h1_mcEEParz_, h1_mcParz_, h1_nEleReco_, h1_occupancy_, h1_occupancyBarrel_, h1_occupancyEndcap_, h1_occupancyVsEta_, h1_preshowerOverSC_, h1_reco_ZMass_, h1_reco_ZMassCorr_, h1_reco_ZMassCorrBB_, h1_reco_ZMassCorrEE_, h1_seedOverSC_, h1_weightSumMeanBarrel_, h1_weightSumMeanEndcap_, h1_ZCandMult_, h1_zEtaResol_, h1_zMassResol_, h1_zPhiResol_, h2_chi2_, h2_coeffVsEta_, h2_coeffVsEtaGrouped_, h2_coeffVsLoop_, h2_fEtaBarrelBad_, h2_fEtaBarrelGood_, h2_fEtaEndcapBad_, h2_fEtaEndcapGood_, h2_iterations_, h2_miscalRecal_, h2_miscalRecalEB_, h2_miscalRecalEE_, h2_residualSigma_, h2_xtalMiscalibCoeffBarrel_, h2_xtalMiscalibCoeffEndcapMinus_, h2_xtalMiscalibCoeffEndcapPlus_, h2_xtalRecalibCoeffBarrel_, h2_xtalRecalibCoeffEndcapMinus_, h2_xtalRecalibCoeffEndcapPlus_, h2_zMassDiffVsLoop_, h2_zMassVsLoop_, h2_zWidthVsLoop_, h_eleEffEta_, h_eleEffPhi_, h_eleEffPt_, h_ESCcorrEtrue_, h_ESCcorrEtrueVsEta_, h_ESCEtrue_, h_ESCEtrueVsEta_, i, and myZeePlots_.

Referenced by beginOfJob().

01693 {
01694 
01695   h1_eventsBeforeEWKSelection_=  new TH1F("h1_eventsBeforeEWKSelection", "h1_eventsBeforeEWKSelection", 5,0,5); 
01696   h1_eventsAfterEWKSelection_ =  new TH1F("h1_eventsAfterEWKSelection", "h1_eventsAfterEWKSelection", 5,0,5);
01697 
01698   h1_eventsBeforeBorderSelection_=  new TH1F("h1_eventsBeforeBorderSelection", "h1_eventsBeforeBorderSelection", 5,0,5); 
01699   h1_eventsAfterBorderSelection_ =  new TH1F("h1_eventsAfterBorderSelection", "h1_eventsAfterBorderSelection", 5,0,5);
01700 
01701   h1_seedOverSC_= new TH1F("h1_seedOverSC", "h1_seedOverSC", 400, 0., 2.);
01702 
01703   myZeePlots_ -> bookHLTHistograms();
01704   
01705   h1_borderElectronClassification_ = new TH1F("h1_borderElectronClassification", "h1_borderElectronClassification", 55, -5 , 50);
01706   h1_preshowerOverSC_= new TH1F("h1_preshowerOverSC", "h1_preshowerOverSC", 400, 0., 1.);
01707   
01708   h2_fEtaBarrelGood_ = new TH2F("fEtaBarrelGood","fEtaBarrelGood",800,-4.,4.,800,0.8,1.2);
01709   h2_fEtaBarrelGood_->SetXTitle("Eta");
01710   h2_fEtaBarrelGood_->SetYTitle("1/fEtaBarrelGood");
01711   
01712   h2_fEtaBarrelBad_ = new TH2F("fEtaBarrelBad","fEtaBarrelBad",800,-4.,4.,800,0.8,1.2);
01713   h2_fEtaBarrelBad_->SetXTitle("Eta");
01714   h2_fEtaBarrelBad_->SetYTitle("1/fEtaBarrelBad");
01715   
01716   h2_fEtaEndcapGood_ = new TH2F("fEtaEndcapGood","fEtaEndcapGood",800,-4.,4.,800,0.8,1.2);
01717   h2_fEtaEndcapGood_->SetXTitle("Eta");
01718   h2_fEtaEndcapGood_->SetYTitle("1/fEtaEndcapGood");
01719   
01720   h2_fEtaEndcapBad_ = new TH2F("fEtaEndcapBad","fEtaEndcapBad",800,-4.,4.,800,0.8,1.2);
01721   h2_fEtaEndcapBad_->SetXTitle("Eta");
01722   h2_fEtaEndcapBad_->SetYTitle("1/fEtaEndcapBad");
01723   
01724   for (int i=0;i<2;i++)
01725     {
01726       char histoName[50];
01727 
01728       sprintf(histoName,"h_eleEffEta_%d",i);
01729       h_eleEffEta_[i] = new TH1F(histoName,histoName, 150, 0., 2.7);
01730       h_eleEffEta_[i]->SetXTitle("|#eta|");
01731 
01732       sprintf(histoName,"h_eleEffPhi_%d",i);
01733       h_eleEffPhi_[i] = new TH1F(histoName,histoName, 400, -4., 4.);
01734       h_eleEffPhi_[i]->SetXTitle("Phi");
01735 
01736       sprintf(histoName,"h_eleEffPt_%d",i);
01737       h_eleEffPt_[i] = new TH1F(histoName,histoName, 200, 0., 200.);
01738       h_eleEffPt_[i]->SetXTitle("p_{T}(GeV/c)");
01739    }
01740   
01741   h2_xtalMiscalibCoeffBarrel_ = new TH2F("h2_xtalMiscalibCoeffBarrel","h2_xtalMiscalibCoeffBarrel", 171, -85, 85, 360, 0, 360);
01742   h2_xtalMiscalibCoeffEndcapMinus_ = new TH2F("h2_xtalMiscalibCoeffEndcapMinus", "h2_xtalMiscalibCoeffEndcapMinus", 100, 0,100, 100, 0, 100);
01743   h2_xtalMiscalibCoeffEndcapPlus_ = new TH2F("h2_xtalMiscalibCoeffEndcapPlus", "h2_xtalMiscalibCoeffEndcapPlus", 100, 0,100, 100, 0, 100);
01744 
01745   h2_xtalMiscalibCoeffBarrel_ ->SetXTitle("ieta");
01746   h2_xtalMiscalibCoeffBarrel_ ->SetYTitle("iphi");
01747 
01748   h2_xtalMiscalibCoeffEndcapMinus_->SetXTitle("ix");
01749   h2_xtalMiscalibCoeffEndcapMinus_->SetYTitle("iy");
01750 
01751   for (int i=0;i<25;i++)
01752     {
01753       
01754       char histoName[50];
01755       sprintf(histoName,"h_ESCEtrueVsEta_%d",i);
01756       
01757       h_ESCEtrueVsEta_[i] = new TH2F(histoName,histoName, 150, 0., 2.7, 300,0.,1.5);
01758       h_ESCEtrueVsEta_[i]->SetXTitle("|#eta|");
01759       h_ESCEtrueVsEta_[i]->SetYTitle("E_{SC,raw}/E_{MC}");
01760       
01761       sprintf(histoName,"h_ESCEtrue_%d",i);
01762 
01763       h_ESCEtrue_[i] = new TH1F(histoName,histoName, 300,0.,1.5);
01764 
01765       sprintf(histoName,"h2_chi2_%d",i);
01766       h2_chi2_[i] = new TH2F(histoName,histoName, 1000,-150,150, 1000, -1, 5);
01767 
01768       sprintf(histoName,"h2_iterations_%d",i);
01769       h2_iterations_[i] = new TH2F(histoName,histoName, 1000,-150,150, 1000, -1, 15);
01770 
01771       sprintf(histoName,"h_ESCcorrEtrueVsEta_%d",i);
01772       
01773       h_ESCcorrEtrueVsEta_[i] = new TH2F(histoName,histoName, 150, 0., 2.7, 300,0.,1.5);
01774       h_ESCcorrEtrueVsEta_[i]->SetXTitle("|#eta|");
01775       h_ESCcorrEtrueVsEta_[i]->SetYTitle("E_{SC,#eta-corr}/E_{MC}");
01776       
01777       sprintf(histoName,"h_ESCcorrEtrue_%d",i);
01778 
01779       h_ESCcorrEtrue_[i] = new TH1F(histoName,histoName, 300,0.,1.5);
01780 
01781       sprintf(histoName,"h2_xtalRecalibCoeffBarrel_%d",i);
01782       h2_xtalRecalibCoeffBarrel_[i] = new TH2F(histoName,histoName, 171, -85, 85, 360, 0, 360);
01783       
01784       h2_xtalRecalibCoeffBarrel_[i]->SetXTitle("ieta");
01785       h2_xtalRecalibCoeffBarrel_[i]->SetYTitle("iphi");
01786 
01787       sprintf(histoName,"h2_xtalRecalibCoeffEndcapMinus_%d",i);
01788       h2_xtalRecalibCoeffEndcapMinus_[i] = new TH2F(histoName,histoName, 100, 0,100, 100, 0, 100);
01789       h2_xtalRecalibCoeffEndcapMinus_[i]->SetXTitle("ix");
01790       h2_xtalRecalibCoeffEndcapMinus_[i]->SetYTitle("iy");
01791 
01792       sprintf(histoName,"h2_xtalRecalibCoeffEndcapPlus_%d",i);
01793       h2_xtalRecalibCoeffEndcapPlus_[i] = new TH2F(histoName,histoName, 100, 0,100, 100, 0, 100);
01794       h2_xtalRecalibCoeffEndcapPlus_[i]->SetXTitle("ix");
01795       h2_xtalRecalibCoeffEndcapPlus_[i]->SetYTitle("iy");
01796       
01797     }                         
01798                                                                      
01799   /*
01800   for (int i=0;i<15;i++)
01801     {
01802                                                                                                                              
01803       char histoName[50];
01804 
01805       sprintf(histoName,"h_DiffZMassDistr_%d",i);
01806       h_DiffZMassDistr_[i] = new TH1F(histoName,histoName, 400, -20., 20.);
01807       h_DiffZMassDistr_[i]->SetXTitle("M_{Z, reco} - M_{Z, MC}");
01808       h_DiffZMassDistr_[i]->SetYTitle("events");
01809 
01810       sprintf(histoName,"h_ZMassDistr_%d",i);
01811       h_ZMassDistr_[i] = new TH1F(histoName,histoName, 200, 0., 150.);
01812       h_ZMassDistr_[i]->SetXTitle("RecoZmass (GeV)");
01813       h_ZMassDistr_[i]->SetYTitle("events");
01814 
01815     }
01816   */
01817   
01818   h1_zMassResol_ = new TH1F("zMassResol", "zMassResol", 200, -50., 50.);
01819   h1_zMassResol_->SetXTitle("M_{Z, reco} - M_{Z, MC}");
01820   h1_zMassResol_->SetYTitle("events");
01821 
01822   h1_eleEtaResol_ = new TH1F("eleEtaResol", "eleEtaResol", 100, -0.01, 0.01);
01823   h1_eleEtaResol_->SetXTitle("#eta_{reco} - #eta_{MC}");
01824   h1_eleEtaResol_->SetYTitle("events");
01825 
01826   h1_electronCosTheta_TK_ = new TH1F("electronCosTheta_TK", "electronCosTheta_TK", 100, -1, 1);
01827   h1_electronCosTheta_TK_->SetXTitle("cos #theta_{12}");
01828   h1_electronCosTheta_TK_->SetYTitle("events");
01829 
01830   h1_electronCosTheta_SC_ = new TH1F("electronCosTheta_SC", "electronCosTheta_SC", 100, -1, 1);
01831   h1_electronCosTheta_SC_->SetXTitle("cos #theta_{12}");
01832   h1_electronCosTheta_SC_->SetYTitle("events");
01833 
01834   h1_electronCosTheta_SC_TK_ = new TH1F("electronCosTheta_SC_TK", "electronCosTheta_SC_TK", 200, -0.1, 0.1);
01835   h1_electronCosTheta_SC_TK_->SetXTitle("cos #theta_{12}^{SC}/ cos #theta_{12}^{TK} - 1");
01836   h1_electronCosTheta_SC_TK_->SetYTitle("events");
01837 
01838   h1_elePhiResol_ = new TH1F("elePhiResol", "elePhiResol", 100, -0.01, 0.01);
01839   h1_elePhiResol_->SetXTitle("#phi_{reco} - #phi_{MC}");
01840   h1_elePhiResol_->SetYTitle("events");
01841 
01842 
01843   h1_zEtaResol_ = new TH1F("zEtaResol", "zEtaResol", 200, -1., 1.);
01844   h1_zEtaResol_->SetXTitle("#eta_{Z, reco} - #eta_{Z, MC}");
01845   h1_zEtaResol_->SetYTitle("events");
01846 
01847 
01848   h1_zPhiResol_ = new TH1F("zPhiResol", "zPhiResol", 200, -1., 1.);
01849   h1_zPhiResol_->SetXTitle("#phi_{Z, reco} - #phi_{Z, MC}");
01850   h1_zPhiResol_->SetYTitle("events");
01851 
01852   h1_nEleReco_ = new TH1F("nEleReco","Number of reco electrons",10,-0.5,10.5);
01853   h1_nEleReco_->SetXTitle("nEleReco");
01854   h1_nEleReco_->SetYTitle("events");
01855   
01856   //  h1_occupancyVsEta_ = new TH1F("occupancyVsEta","occupancyVsEta",EcalRingCalibrationTools::N_RING_TOTAL,0,(float)EcalRingCalibrationTools::N_RING_TOTAL);
01857 
01858   h1_occupancyVsEta_ = new TH1F("occupancyVsEta","occupancyVsEta",249, -124, 124);
01859   h1_occupancyVsEta_->SetYTitle("Weighted electron statistics");
01860   h1_occupancyVsEta_->SetXTitle("Eta channel");
01861 
01862   h1_weightSumMeanBarrel_= new TH1F("weightSumMeanBarrel","weightSumMeanBarrel",10000, 0, 10000);
01863   h1_weightSumMeanEndcap_= new TH1F("weightSumMeanEndcap","weightSumMeanEndcap",10000, 0, 10000);
01864   
01865   h1_occupancy_ = new TH1F("occupancy","occupancy",1000,0,10000);
01866   h1_occupancy_->SetXTitle("Weighted electron statistics");
01867 
01868   h1_occupancyBarrel_ = new TH1F("occupancyBarrel","occupancyBarrel",1000,0,10000);
01869   h1_occupancyBarrel_->SetXTitle("Weighted electron statistics");
01870 
01871   h1_occupancyEndcap_ = new TH1F("occupancyEndcap","occupancyEndcap",1000,0,10000);
01872   h1_occupancyEndcap_->SetXTitle("Weighted electron statistics");
01873  
01874 
01875   h1_eleClasses_= new TH1F("eleClasses","eleClasses",301,-1,300);
01876   h1_eleClasses_->SetXTitle("classCode");
01877   h1_eleClasses_->SetYTitle("#");
01878   
01879 
01880 
01881  myZeePlots_ ->bookZMCHistograms();
01882 
01883  myZeePlots_ ->bookZHistograms();
01884  
01885  myZeePlots_ ->bookEleMCHistograms();   
01886  
01887  myZeePlots_ ->bookEleHistograms();             
01888  
01889 
01890   h1_ZCandMult_ =new TH1F("ZCandMult","Multiplicity of Z candidates in one event",10,-0.5,10.5);
01891   h1_ZCandMult_ ->SetXTitle("ZCandMult");
01892   
01893   h1_reco_ZMass_ = new TH1F("reco_ZMass","Inv. mass of 2 reco Electrons",200,0.,150.);
01894   h1_reco_ZMass_->SetXTitle("reco_ZMass (GeV)");
01895   h1_reco_ZMass_->SetYTitle("events");
01896 
01897   h1_reco_ZMassCorr_ = new TH1F("reco_ZMassCorr","Inv. mass of 2 corrected reco Electrons",200,0.,150.);
01898   h1_reco_ZMassCorr_->SetXTitle("reco_ZMass (GeV)");
01899   h1_reco_ZMassCorr_->SetYTitle("events");
01900 
01901   h1_reco_ZMassCorrBB_ = new TH1F("reco_ZMassCorrBB","Inv. mass of 2 corrected reco Electrons",200,0.,150.);
01902   h1_reco_ZMassCorrBB_->SetXTitle("reco_ZMass (GeV)");
01903   h1_reco_ZMassCorrBB_->SetYTitle("events");
01904 
01905   h1_reco_ZMassCorrEE_ = new TH1F("reco_ZMassCorrEE","Inv. mass of 2 corrected reco Electrons",200,0.,150.);
01906   h1_reco_ZMassCorrEE_->SetXTitle("reco_ZMass (GeV)");
01907   h1_reco_ZMassCorrEE_->SetYTitle("events");
01908 
01909   //  h2_coeffVsEta_= new TH2F("h2_calibCoeffVsEta","h2_calibCoeffVsEta",EcalRingCalibrationTools::N_RING_TOTAL,0, (double)EcalRingCalibrationTools::N_RING_TOTAL, 200, 0., 2.);
01910 
01911   h2_coeffVsEta_= new TH2F("h2_calibCoeffVsEta","h2_calibCoeffVsEta",249,-124,125, 200, 0., 2.);
01912   h2_coeffVsEta_->SetXTitle("Eta channel");
01913   h2_coeffVsEta_->SetYTitle("recalibCoeff");
01914 
01915   h2_coeffVsEtaGrouped_= new TH2F("h2_calibCoeffVsEtaGrouped","h2_calibCoeffVsEtaGrouped", 200, 0., 3., 200, 0.6, 1.4);
01916   h2_coeffVsEtaGrouped_->SetXTitle("|#eta|");
01917   h2_coeffVsEtaGrouped_->SetYTitle("recalibCoeff");
01918 
01919   h2_zMassVsLoop_= new TH2F("h2_zMassVsLoop","h2_zMassVsLoop",1000,0,40, 90, 80.,95.);
01920 
01921   h2_zMassDiffVsLoop_= new TH2F("h2_zMassDiffVsLoop","h2_zMassDiffVsLoop",1000,0,40, 100, -1., 1.);
01922   h2_zMassDiffVsLoop_->SetXTitle("Iteration");
01923   h2_zMassDiffVsLoop_->SetYTitle("M_{Z, reco peak} - M_{Z, true}");
01924 
01925   h2_zWidthVsLoop_= new TH2F("h2_zWidthVsLoop","h2_zWidthVsLoop",1000,0,40, 100, 0.,10.);
01926 
01927   h2_coeffVsLoop_= new TH2F("h2_coeffVsLoop","h2_coeffVsLoop",1000,0,40, 100, 0., 2.);
01928 
01929   h2_residualSigma_= new TH2F("h2_residualSigma","h2_residualSigma",1000, 0, 40, 100, 0., .5);
01930 
01931   h2_miscalRecal_ = new TH2F("h2_miscalRecal","h2_miscalRecal", 500, 0., 2., 500, 0., 2.);
01932   h2_miscalRecal_->SetXTitle("initCalibCoeff");
01933   h2_miscalRecal_->SetYTitle("1/RecalibCoeff");
01934  
01935   h2_miscalRecalEB_ = new TH2F("h2_miscalRecalEB","h2_miscalRecalEB", 500, 0., 2., 500, 0., 2.);
01936   h2_miscalRecalEB_->SetXTitle("initCalibCoeff");
01937   h2_miscalRecalEB_->SetYTitle("1/RecalibCoeff");
01938 
01939   h2_miscalRecalEE_ = new TH2F("h2_miscalRecalEE","h2_miscalRecalEE", 500, 0., 2., 500, 0., 2.);
01940   h2_miscalRecalEE_->SetXTitle("initCalibCoeff");
01941   h2_miscalRecalEE_->SetYTitle("1/RecalibCoeff");
01942 
01943   h1_mc_ = new TH1F("h1_residualMiscalib","h1_residualMiscalib", 200, -0.2, 0.2);
01944   h1_mcEB_ = new TH1F("h1_residualMiscalibEB","h1_residualMiscalibEB", 200, -0.2, 0.2);
01945   h1_mcEE_ = new TH1F("h1_residualMiscalibEE","h1_residualMiscalibEE", 200, -0.2, 0.2);
01946  
01947   for (int i=0;i<25;i++)
01948     {
01949       char histoName[50];
01950       /*     
01951              sprintf(histoName,"h2_miscalRecalParz_%d",i);
01952              h2_miscalRecalParz_[i] = new TH2F(histoName,histoName,500, 0., 2., 500, 0., 2.);
01953              h2_miscalRecalParz_[i]->SetXTitle("initCalibCoeff");
01954              h2_miscalRecalParz_[i]->SetYTitle("1/recalibCoeff");
01955              
01956              sprintf(histoName,"h2_miscalRecalEBParz_%d",i);
01957              h2_miscalRecalEBParz_[i] = new TH2F(histoName,histoName,500, 0., 2., 500, 0., 2.);
01958              h2_miscalRecalEBParz_[i]->SetXTitle("initCalibCoeff");
01959              h2_miscalRecalEBParz_[i]->SetYTitle("1/recalibCoeff");
01960              
01961       sprintf(histoName,"h2_miscalRecalEEParz_%d",i);
01962       h2_miscalRecalEEParz_[i] = new TH2F(histoName,histoName,500, 0., 2., 500, 0., 2.);
01963       h2_miscalRecalEEParz_[i]->SetXTitle("initCalibCoeff");
01964       h2_miscalRecalEEParz_[i]->SetYTitle("1/recalibCoeff");
01965       */
01966       
01967       sprintf(histoName,"h1_residualMiscalibParz_%d",i);
01968       h1_mcParz_[i] = new TH1F(histoName,histoName, 200, -0.2, 0.2);
01969       sprintf(histoName,"h1_residualMiscalibEBParz_%d",i);
01970       h1_mcEBParz_[i] = new TH1F(histoName,histoName, 200, -0.2, 0.2);
01971       sprintf(histoName,"h1_residualMiscalibEEParz_%d",i);
01972       h1_mcEEParz_[i] = new TH1F(histoName,histoName, 200, -0.2, 0.2);
01973       
01974     }
01975  
01976 
01977 }

float ZeeCalibration::computeCoefficientDistanceAtIteration	(	float	v1[250],
		float	v2[250],
		int	size
	)			`[private]`

Definition at line 2255 of file ZeeCalibration.cc.

References funct::abs(), calibMode_, dist(), i, funct::pow(), ringNumberCorrector(), and funct::sqrt().

Referenced by endOfLoop().

02255                                                                                                    {
02256 
02257   float dist(0.);
02258  
02259   for(int i =0; i < size; i++){
02260     
02261     //    std::cout<< "[ZeeCalibration::computeCoefficientDistanceAtIteration] Adding term "<<pow( v1[i]-v2[i], 2 )<<" from v1 "<<v1[i]<<" and v2 "<<v2[i]<<std::endl;
02262     
02263     bool isNearCrack = false;
02264 
02265     if( calibMode_ == "RING"){//exclude non-calibrated rings from computation
02266 
02267       isNearCrack = ( abs( ringNumberCorrector(i) ) == 1 || abs( ringNumberCorrector(i) ) == 25 ||
02268                       abs( ringNumberCorrector(i) ) == 26 || abs( ringNumberCorrector(i) ) == 45 ||
02269                       abs( ringNumberCorrector(i) ) == 46 || abs( ringNumberCorrector(i) ) == 65 ||
02270                       abs( ringNumberCorrector(i) ) == 66 || abs( ringNumberCorrector(i) ) == 85 ||
02271                       abs( ringNumberCorrector(i) ) == 86 || abs( ringNumberCorrector(i) ) == 124 );
02272     }
02273     
02274     if(!isNearCrack)
02275       dist += pow( v1[i]-v2[i], 2 );
02276   }
02277   
02278   dist = sqrt(dist) / size;
02279   
02280   return dist;
02281   
02282 }

edm::EDLooper::Status ZeeCalibration::duringLoop	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)			`[virtual]`

Called at each event.

START HERE....

Implements edm::EDLooper.

Definition at line 803 of file ZeeCalibration.cc.

References funct::abs(), ZIterativeAlgorithmWithFit::addEvent(), aHLTResults, BARREL_ELECTRONS_AFTER_BORDER_CUT, BARREL_ELECTRONS_BEFORE_BORDER_CUT, BBZN, BBZN_gg, BBZN_t0, BBZN_tt, ZeeKinematicTools::calculateZMass_withTK(), ZeeKinematicTools::calculateZMassWithCorrectedElectrons_withTK(), TestMuL1L2Filter_cff::cerr, ZeeKinematicTools::cosThetaElectrons_SC(), ZeeKinematicTools::cosThetaElectrons_TK(), GenMuonPlsPt100GeV_cfg::cout, CRACK_ELECTRONS_IN_BARREL, CRACK_ELECTRONS_IN_ENDCAP, EBZN, EBZN_gg, EBZN_t0, EBZN_tt, EcalBarrel, EEZN, EEZN_gg, EEZN_t0, EEZN_tt, electronCollection_, electronProducer_, electronSelection_, lat::endl(), erechitCollection_, erechitProducer_, eta, exception, funct::exp(), ZeePlots::fillEleInfo(), fillEleInfo(), ZeePlots::fillEleMCInfo(), ZeePlots::fillHLTInfo(), fillMCmap(), ZeePlots::fillZInfo(), ZeePlots::fillZMCInfo(), first, edm::Event::getByLabel(), getEtaCorrection(), getHottestDetId(), GOLDEN_ELECTRONS_IN_BARREL, GOLDEN_ELECTRONS_IN_ENDCAP, h1_borderElectronClassification_, h1_eleClasses_, h1_electronCosTheta_SC_, h1_electronCosTheta_SC_TK_, h1_electronCosTheta_TK_, h1_eventsAfterBorderSelection_, h1_eventsAfterEWKSelection_, h1_eventsBeforeBorderSelection_, h1_eventsBeforeEWKSelection_, h1_reco_ZMass_, h1_reco_ZMassCorr_, h1_reco_ZMassCorrBB_, h1_reco_ZMassCorrEE_, h1_ZCandMult_, h1_zMassResol_, hltCount, hlTriggerResults_, i, edm::Handle< T >::isValid(), edm::EDLooper::kContinue, loopFlag_, mass, mass4tree, massDiff4tree, maxInvMassCut_, mcProducer_, MCZBB, MCZEB, MCZEE, minInvMassCut_, myTree, myZeePlots_, MZ, NEVT, p, read_events, rechitCollection_, rechitProducer_, scCollection_, scIslandCollection_, scIslandProducer_, scProducer_, edm::second(), SHOWER_ELECTRONS_IN_BARREL, SHOWER_ELECTRONS_IN_ENDCAP, SILVER_ELECTRONS_IN_BARREL, SILVER_ELECTRONS_IN_ENDCAP, funct::sin(), edm::SortedCollection< T, SORT >::size(), funct::sqrt(), DetId::subdetId(), theAlgorithm_, TOTAL_ELECTRONS_IN_BARREL, TOTAL_ELECTRONS_IN_ENDCAP, wantEtaCorrection_, and xtalIsOnModuleBorder().

00804 {
00805   using namespace edm;
00806 
00807 #ifdef DEBUG
00808   std::cout<<"[ZeeCalibration] Entering duringLoop"<<std::endl;
00809 #endif
00810  
00811   
00813   
00814   for(unsigned int iHLT=0; iHLT<200; ++iHLT) {
00815     aHLTResults[iHLT] = false;
00816   }
00817 
00818 #ifdef DEBUG
00819   std::cout<<"[ZeeCalibration::duringLoop] Done with initializing aHLTresults[] "<<std::endl;
00820 #endif
00821 
00822   edm::Handle<edm::TriggerResults> hltTriggerResultHandle;
00823   iEvent.getByLabel(hlTriggerResults_, hltTriggerResultHandle);
00824   
00825   if(!hltTriggerResultHandle.isValid()) {
00826     //std::cout << "invalid handle for HLT TriggerResults" << std::endl;
00827   } else {
00828 
00829     hltCount = hltTriggerResultHandle->size();
00830 
00831     if (loopFlag_ == 0)
00832       myZeePlots_->fillHLTInfo(hltTriggerResultHandle);
00833     
00834 #ifdef DEBUG
00835   std::cout<<"[ZeeCalibration::duringLoop] Done with myZeePlots_->fillHLTInfo(hltTriggerResultHandle); "<<std::endl;
00836 #endif
00837 
00838     for(int i = 0 ; i < hltCount ; i++) {
00839       aHLTResults[i] = hltTriggerResultHandle->accept(i);
00840     
00841       //HLT bit 32 = HLT1Electron
00842     //HLT bit 34 = HLT2Electron
00843     //HLT bit 35 = HLT2ElectronRelaxed
00844 
00845      }
00846 
00847       if(!aHLTResults[32] && !aHLTResults[34] && !aHLTResults[35])
00848         return kContinue;
00849       
00850   }
00851   
00852 #ifdef DEBUG
00853   std::cout<<"[ZeeCalibration::duringLoop] End HLT section"<<std::endl;
00854 #endif
00855   
00857   
00858 
00859   std::vector<HepMC::GenParticle*> mcEle;
00860 
00861   float myGenZMass(-1);
00862       
00863   if (!mcProducer_.empty())
00864     {
00865 
00866       //DUMP GENERATED Z MASS - BEGIN
00867       Handle< HepMCProduct > hepProd ;
00868       //   iEvent.getByLabel( "source", hepProd ) ;
00869       iEvent.getByLabel( mcProducer_.c_str(), hepProd ) ;
00870                                                                                                                              
00871       const HepMC::GenEvent * myGenEvent = hepProd->GetEvent();
00872       
00873       if (loopFlag_ == 0)
00874         myZeePlots_->fillZMCInfo( & (*myGenEvent) );
00875       
00876 #ifdef DEBUG
00877   std::cout<<"[ZeeCalibration::duringLoop] Done with myZeePlots_->fillZMCInfo( & (*myGenEvent) ); "<<std::endl;
00878 #endif
00879   
00880       HepMC::GenParticle* genZ=0;
00881       
00882       
00883       for ( HepMC::GenEvent::particle_const_iterator p = myGenEvent->particles_begin();
00884             p != myGenEvent->particles_end(); ++p ) {
00885         //return a pointer to MC Z in the event
00886         if ( (*p)->pdg_id() == 23 && (*p)->status()==2){
00887 
00888           myGenZMass = (*p)->momentum().m();
00889                           genZ=(*p);
00890         }
00891       }
00892       //DUMP GENERATED Z MASS - END
00893      
00894 
00895       if (loopFlag_ == 0)
00896         myZeePlots_ ->fillEleMCInfo( & (*myGenEvent) );
00897       
00898             
00899       //loop over MC positrons and find the closest MC positron in (eta,phi) phace space - begin
00900       HepMC::GenParticle MCele;
00901       
00902       for ( HepMC::GenEvent::particle_const_iterator p = myGenEvent->particles_begin();
00903             p != myGenEvent->particles_end(); ++p ) {
00904         
00905         if (  abs( (*p)->pdg_id() ) == 11 )
00906           {
00907             mcEle.push_back( (*p) );
00908             MCele=*(*p);
00909             
00910           }
00911       }
00912       
00913       
00914       if(mcEle.size()==2 && fabs(mcEle[0]->momentum().eta())<2.4 &&  fabs(mcEle[1]->momentum().eta())<2.4 ){
00915         NEVT++;
00916         
00917         if( fabs(mcEle[0]->momentum().eta())<1.479 && fabs(mcEle[1]->momentum().eta())<1.479 )MCZBB++;
00918         
00919         if( (fabs(mcEle[0]->momentum().eta())>1.479 && fabs(mcEle[1]->momentum().eta())<1.479) || (fabs(mcEle[0]->momentum().eta())<1.479 && fabs(mcEle[1]->momentum().eta())>1.479) )MCZEB++;
00920         
00921         if( fabs(mcEle[0]->momentum().eta())>1.479 && fabs(mcEle[1]->momentum().eta())>1.479 )MCZEE++;
00922         
00923         
00924       }
00925       
00926     }    
00927   
00928   
00929   
00930   // Get EBRecHits
00931   Handle<EBRecHitCollection> phits;
00932   try {
00933     iEvent.getByLabel( rechitProducer_, rechitCollection_, phits);
00934   } catch (std::exception& ex) {
00935     std::cerr << "Error! can't get the product EBRecHitCollection " << std::endl;
00936   }
00937   const EBRecHitCollection* hits = phits.product(); // get a ptr to the product
00938 
00939   // Get EERecHits
00940   Handle<EERecHitCollection> ephits;
00941   try {
00942     iEvent.getByLabel( erechitProducer_, erechitCollection_, ephits);
00943   } catch (std::exception& ex) {
00944     std::cerr << "Error! can't get the product EERecHitCollection " << std::endl;
00945   }
00946   const EERecHitCollection* ehits = ephits.product(); // get a ptr to the product
00947 
00948   
00949   //Get Hybrid SuperClusters
00950   Handle<reco::SuperClusterCollection> pSuperClusters;
00951   try {
00952     iEvent.getByLabel(scProducer_, scCollection_, pSuperClusters);
00953   } catch (std::exception& ex ) {
00954     std::cerr << "Error! can't get the product SuperClusterCollection "<< std::endl;
00955   }
00956   const reco::SuperClusterCollection* scCollection = pSuperClusters.product();
00957 
00958 #ifdef DEBUG
00959   std::cout<<"scCollection->size()"<<scCollection->size()<<std::endl;
00960   for(reco::SuperClusterCollection::const_iterator scIt = scCollection->begin();   scIt != scCollection->end(); scIt++)
00961     {
00962       std::cout<<scIt->energy()<<std::endl;
00963     }
00964 #endif
00965   
00966   //Get Island SuperClusters
00967   Handle<reco::SuperClusterCollection> pIslandSuperClusters;
00968   try {
00969     iEvent.getByLabel(scIslandProducer_, scIslandCollection_, pIslandSuperClusters);
00970   } catch (std::exception& ex ) {
00971     std::cerr << "Error! can't get the product IslandSuperClusterCollection "<< std::endl;
00972   }
00973   const reco::SuperClusterCollection* scIslandCollection = pIslandSuperClusters.product();
00974 
00975 #ifdef DEBUG
00976   std::cout<<"scCollection->size()"<<scIslandCollection->size()<<std::endl;
00977 #endif
00978 
00979   if(  ( scCollection->size()+scIslandCollection->size() ) < 2) 
00980     return kContinue;
00981 
00982   // Get Electrons
00983   Handle<reco::PixelMatchGsfElectronCollection> pElectrons;
00984   try {
00985     iEvent.getByLabel(electronProducer_, electronCollection_, pElectrons);
00986   } catch (std::exception& ex ) {
00987     std::cerr << "Error! can't get the product ElectronCollection "<< std::endl;
00988   }
00989   const reco::PixelMatchGsfElectronCollection* electronCollection = pElectrons.product();
00990 
00991   /*
00992   //reco-mc association map
00993   std::map<HepMC::GenParticle*,const reco::PixelMatchGsfElectron*> myMCmap;
00994   
00995     fillMCmap(&(*electronCollection),mcEle,myMCmap);
00996     
00997     fillEleInfo(mcEle,myMCmap);
00998   */
00999   
01000   if(electronCollection->size() < 2) 
01001     return kContinue;
01002   
01003   if ( !hits && !ehits){
01004     std::cout << "!hits" << std::endl;   
01005     return kContinue;
01006   }
01007   
01008   if (hits->size() == 0 && ehits->size() == 0){
01009     std::cout << "hits->size() == 0" << std::endl;   
01010     return kContinue;
01011   }  
01012   
01013   if (!electronCollection){
01014     std::cout << "!electronCollection" << std::endl;
01015     return kContinue;
01016   }
01017   
01018   if (electronCollection->size() == 0){
01019     std::cout << "electronCollection->size() == 0" << std::endl;
01020     return kContinue;
01021   }
01022 
01023 
01024   
01028   
01029   read_events++;
01030   
01031   //  std::cout << "read_events = " << read_events << std::endl;
01032   
01034   
01035 #ifdef DEBUG
01036   std::cout <<" Starting with myZeePlots_->fillEleInfo(electronCollection); " << std::endl; 
01037 #endif
01038 
01039   if (loopFlag_ == 0)
01040     myZeePlots_->fillEleInfo(electronCollection);
01041   
01042 #ifdef DEBUG
01043   std::cout <<" Done with myZeePlots_->fillEleInfo(electronCollection); " << std::endl; 
01044 #endif
01045 
01046   //FILL an electron vector - end
01047   //###################################Electron-SC association: begin#####################################################
01048   //Filling new ElectronCollection with new SC ref and calibElectron container
01049   std::vector<calib::CalibElectron> calibElectrons;
01050   //std::map< const calib::CalibElectron* , const reco::SuperCluster* > eleScMap;
01051   
01052   
01053 
01054   //#####################################Electron-SC association map: end#####################################################  
01055   for(unsigned int e_it = 0 ; e_it != electronCollection->size() ; e_it++)
01056     {
01057       calibElectrons.push_back(calib::CalibElectron(&((*electronCollection)[e_it]),hits,ehits));
01058 #ifdef DEBUG
01059       std::cout << calibElectrons.back().getRecoElectron()->superCluster()->energy() << " " << calibElectrons.back().getRecoElectron()->energy() << endl;
01060 #endif
01061       //      h1_recoEleEnergy_->Fill(calibElectrons.back().getRecoElectron()->superCluster()->energy());
01062     }
01063   //  if (iLoop == 0)
01064   //fillCalibElectrons(calibElectrons);
01065 
01066 #ifdef DEBUG
01067   std::cout << "Filled histos" << std::endl;
01068 #endif  
01069   
01070   //COMBINATORY FOR Z MASS - begin                                                                                                                           
01071   std::vector< pair<calib::CalibElectron*,calib::CalibElectron*> > zeeCandidates;
01072   int  myBestZ=-1;
01073   
01074   mass = -1.;
01075   double DeltaMinvMin(5000.);
01076   
01077   if (calibElectrons.size() < 2)
01078     return kContinue;
01079 
01080   for(unsigned int e_it = 0 ; e_it != calibElectrons.size() - 1 ; e_it++){
01081     for(unsigned int p_it = e_it + 1 ; p_it != calibElectrons.size() ; p_it++)
01082       {
01083 #ifdef DEBUG
01084         std::cout << e_it << " " << calibElectrons[e_it].getRecoElectron()->charge() << " " << p_it << " " << calibElectrons[p_it].getRecoElectron()->charge() << std::endl;
01085 #endif          
01086         if (calibElectrons[e_it].getRecoElectron()->charge() * calibElectrons[p_it].getRecoElectron()->charge() != -1)
01087           continue;
01088         
01089         mass =  ZeeKinematicTools::calculateZMass_withTK(std::pair<calib::CalibElectron*,calib::CalibElectron*>(&(calibElectrons[e_it]),&(calibElectrons[p_it])));
01090         
01091         if (mass<0)
01092           continue;
01093         
01094 #ifdef DEBUG
01095         std::cout << "#######################mass "<<mass << std::endl;
01096 #endif
01097         
01098         zeeCandidates.push_back(std::pair<calib::CalibElectron*,calib::CalibElectron*>(&(calibElectrons[e_it]),&(calibElectrons[p_it])));
01099         double DeltaMinv = fabs(mass - MZ); 
01100         
01101         if( DeltaMinv < DeltaMinvMin)
01102           {
01103             DeltaMinvMin = DeltaMinv;
01104             myBestZ=zeeCandidates.size()-1;
01105           }
01106       }
01107   }      
01108   
01109   //  h_DeltaZMassDistr_[loopFlag_]->Fill( (mass-MZ) / MZ );
01110 
01111   //  zeeCa->Fill(zeeCandidates);
01112   //
01113   h1_ZCandMult_->Fill(zeeCandidates.size());
01114   
01115   if(zeeCandidates.size()==0 || myBestZ==-1 )
01116     return kContinue;
01117       
01118   if (loopFlag_ == 0)
01119     myZeePlots_->fillZInfo( zeeCandidates[myBestZ] );
01120   
01121 #ifdef DEBUG  
01122   std::cout << "Found ZCandidates " << myBestZ << std::endl;
01123 #endif  
01124 
01125   //  h1_zMassResol_ ->Fill(mass-myGenZMass);
01126 
01128   
01129   
01130   h1_eleClasses_->Fill(zeeCandidates[myBestZ].first->getRecoElectron()->classification());
01131   h1_eleClasses_->Fill(zeeCandidates[myBestZ].second->getRecoElectron()->classification());
01132   
01133   int class1 = zeeCandidates[myBestZ].first->getRecoElectron()->classification();
01134   int class2 = zeeCandidates[myBestZ].second->getRecoElectron()->classification();
01135 
01136   std::cout << "BEFORE "<<std::endl;
01137 
01138   //  myZeePlots_->fillEleClassesPlots( zeeCandidates[myBestZ].first );
01139   //myZeePlots_->fillEleClassesPlots( zeeCandidates[myBestZ].second );
01140   
01141   std::cout << "AFTER "<<std::endl;
01142 
01144 
01145   if(class1 < 100)
01146     //    h1_Elec_->Fill(1);
01147     TOTAL_ELECTRONS_IN_BARREL++;
01148   if(class1 >= 100)
01149     TOTAL_ELECTRONS_IN_ENDCAP++;
01150 
01151   if(class2 < 100)
01152     TOTAL_ELECTRONS_IN_BARREL++;
01153   if(class2 >= 100)
01154     TOTAL_ELECTRONS_IN_ENDCAP++;
01155 
01156 
01157   if( class1==0)
01158     GOLDEN_ELECTRONS_IN_BARREL++;
01159   if( class1==100)
01160     GOLDEN_ELECTRONS_IN_ENDCAP++;
01161   if( class1==10 || class1 ==20)
01162     SILVER_ELECTRONS_IN_BARREL++;
01163   if( class1==110 || class1 ==120)
01164     SILVER_ELECTRONS_IN_ENDCAP++;
01165   if( class1>=30 && class1 <=34)
01166     SHOWER_ELECTRONS_IN_BARREL++;
01167   if( class1>=130 && class1 <=134)
01168     SHOWER_ELECTRONS_IN_ENDCAP++;
01169   if( class1==40)
01170     CRACK_ELECTRONS_IN_BARREL++;
01171   if( class1==140)
01172     CRACK_ELECTRONS_IN_ENDCAP++;
01173 
01174   if( class2==0)
01175     GOLDEN_ELECTRONS_IN_BARREL++;
01176   if( class2==100)
01177     GOLDEN_ELECTRONS_IN_ENDCAP++;
01178   if( class2==10 || class2 ==20)
01179     SILVER_ELECTRONS_IN_BARREL++;
01180   if( class2==110 || class2 ==120)
01181     SILVER_ELECTRONS_IN_ENDCAP++;
01182   if( class2>=30 && class2 <=34)
01183     SHOWER_ELECTRONS_IN_BARREL++;
01184   if( class2>=130 && class2 <=134)
01185     SHOWER_ELECTRONS_IN_ENDCAP++;
01186   if( class2==40)
01187     CRACK_ELECTRONS_IN_BARREL++;
01188   if( class2==140)
01189     CRACK_ELECTRONS_IN_ENDCAP++;
01190   
01192 
01194 
01195   
01196   DetId firstElehottestDetId = getHottestDetId( zeeCandidates[myBestZ].first->getRecoElectron()->superCluster()->seed()->getHitsByDetId() , hits, ehits ).first;
01197   DetId secondElehottestDetId = getHottestDetId( zeeCandidates[myBestZ].second->getRecoElectron()->superCluster()->seed()->getHitsByDetId()  , hits, ehits ).first;
01198   
01199   bool firstElectronIsOnModuleBorder(false);
01200   bool secondElectronIsOnModuleBorder(false);
01201   
01202   h1_eventsBeforeBorderSelection_->Fill(1);
01203 
01204   if(class1<100){
01205 
01206     if( firstElehottestDetId.subdetId() == EcalBarrel)
01207       firstElectronIsOnModuleBorder = xtalIsOnModuleBorder( firstElehottestDetId  );
01208     
01209     BARREL_ELECTRONS_BEFORE_BORDER_CUT++;
01210     
01211     if( firstElehottestDetId.subdetId() == EcalBarrel &&  !firstElectronIsOnModuleBorder )
01212       BARREL_ELECTRONS_AFTER_BORDER_CUT++;
01213     
01214   }
01215   
01216   if(class2<100){
01217     
01218     if( secondElehottestDetId.subdetId() == EcalBarrel)
01219       secondElectronIsOnModuleBorder = xtalIsOnModuleBorder( secondElehottestDetId  );
01220     
01221     BARREL_ELECTRONS_BEFORE_BORDER_CUT++;
01222     
01223     if( secondElehottestDetId.subdetId() == EcalBarrel &&  !secondElectronIsOnModuleBorder )
01224       BARREL_ELECTRONS_AFTER_BORDER_CUT++;
01225     
01226   }
01227   
01228   
01229   if(class1<100){
01230     if ( firstElehottestDetId.subdetId() == EcalBarrel &&  firstElectronIsOnModuleBorder ){
01231       h1_borderElectronClassification_ -> Fill( zeeCandidates[myBestZ].first->getRecoElectron()->classification() );
01232       return kContinue;
01233     }  
01234   }
01235   
01236   if(class2<100){
01237     if ( secondElehottestDetId.subdetId() == EcalBarrel &&  secondElectronIsOnModuleBorder ){ 
01238       h1_borderElectronClassification_ -> Fill( zeeCandidates[myBestZ].second->getRecoElectron()->classification() );
01239       return kContinue;
01240     }
01241   }
01242   
01243   h1_eventsAfterBorderSelection_->Fill(1);
01245   
01246   
01247   if(class1<100 && class2<100){
01248     BBZN++;
01249     if(class1==0 && class2==0)BBZN_gg++;
01250     if(class1<21 && class2<21)BBZN_tt++;
01251     if(class1<21 || class2<21)BBZN_t0++;
01252     
01253   }
01254 
01255   if(class1>=100 && class2>=100){
01256     EEZN++;
01257     if(class1==100 && class2==100)EEZN_gg++;
01258     if(class1<121 && class2<121)EEZN_tt++;
01259     if(class1<121 || class2<121)EEZN_t0++;
01260 
01261   }
01262 
01263   if( (class1<100 && class2>=100) || (class2<100 && class1>=100)){
01264     EBZN++;
01265     if( (class1==0 && class2==100)||(class2==0 && class1==100) )EBZN_gg++;
01266     if( ( class1<21 && class2<121) ||(class2<21 && class1<121) )EBZN_tt++;
01267     if(   class2<21 || class1<21 ||  class2<121 || class1<121 )EBZN_t0++;
01268   }
01269 
01270 
01272   
01273   if(myBestZ == -1)
01274     return kContinue;
01275 
01276 
01277   bool invMassBool = ( (mass > minInvMassCut_) && (mass < maxInvMassCut_) );
01278 
01279   bool selectionBool=false;  
01280   //0 = all electrons (but no crack)
01281   
01283 
01284   float theta1 = 2. * atan( exp(- zeeCandidates[myBestZ].first->getRecoElectron()->superCluster()->eta()) );
01285   bool ET_1 = (  (zeeCandidates[myBestZ].first->getRecoElectron()->superCluster()->energy() * sin( theta1) ) > 20.);
01286 
01287   float theta2 = 2. * atan( exp(- zeeCandidates[myBestZ].second->getRecoElectron()->superCluster()->eta()) );
01288   bool ET_2 = (  (zeeCandidates[myBestZ].second->getRecoElectron()->superCluster()->energy() * sin( theta2) ) > 20.);
01289 
01290 
01291   bool HoE_1 = (zeeCandidates[myBestZ].first->getRecoElectron()->hadronicOverEm() < 0.115);
01292   bool HoE_2 = (zeeCandidates[myBestZ].second->getRecoElectron()->hadronicOverEm() < 0.115);
01293 
01294   bool DeltaPhiIn_1 = ( zeeCandidates[myBestZ].first->getRecoElectron()->deltaPhiSuperClusterTrackAtVtx() < 0.090);
01295   bool DeltaPhiIn_2 = ( zeeCandidates[myBestZ].second->getRecoElectron()->deltaPhiSuperClusterTrackAtVtx() < 0.090);
01296 
01297   bool DeltaEtaIn_1 = ( zeeCandidates[myBestZ].first->getRecoElectron()->deltaEtaSuperClusterTrackAtVtx() < 0.0090);
01298   bool DeltaEtaIn_2 = ( zeeCandidates[myBestZ].second->getRecoElectron()->deltaEtaSuperClusterTrackAtVtx() < 0.0090);
01299    
01300   h1_eventsBeforeEWKSelection_->Fill(1);
01301 
01302   if(! (invMassBool &&
01303         ET_1 && ET_2 &&
01304         HoE_1 && HoE_2 &&
01305         DeltaPhiIn_1 && DeltaPhiIn_2 &&
01306         DeltaEtaIn_1 && DeltaEtaIn_2
01307         ) )
01308     return kContinue;
01310 
01311   h1_eventsAfterEWKSelection_->Fill(1);
01312 
01314   
01315 
01316 
01317   if(electronSelection_==0)selectionBool=( myBestZ != -1 && 
01318                                            zeeCandidates[myBestZ].first->getRecoElectron()->classification()!= 40 && 
01319                                            zeeCandidates[myBestZ].first->getRecoElectron()->classification()!= 40 && 
01320                                            zeeCandidates[myBestZ].second->getRecoElectron()->classification()!= 40 && 
01321                                            zeeCandidates[myBestZ].second->getRecoElectron()->classification()!= 140);
01322   
01323   //1 = all electrons are Golden, BB or Narrow
01324   
01325   if(electronSelection_==1)selectionBool=( myBestZ != -1 &&
01326                                            (zeeCandidates[myBestZ].first->getRecoElectron()->classification() ==0 || 
01327                                             zeeCandidates[myBestZ].first->getRecoElectron()->classification() ==10 || 
01328                                             zeeCandidates[myBestZ].first->getRecoElectron()->classification() ==20 ||
01329                                             zeeCandidates[myBestZ].first->getRecoElectron()->classification() ==100 ||
01330                                             zeeCandidates[myBestZ].first->getRecoElectron()->classification() ==110 ||
01331                                             zeeCandidates[myBestZ].first->getRecoElectron()->classification() ==120
01332                                             ) &&
01333                                            (zeeCandidates[myBestZ].second->getRecoElectron()->classification() == 0 || 
01334                                             zeeCandidates[myBestZ].second->getRecoElectron()->classification() == 10 ||
01335                                             zeeCandidates[myBestZ].second->getRecoElectron()->classification() == 20 ||
01336                                             zeeCandidates[myBestZ].second->getRecoElectron()->classification() == 100 ||
01337                                             zeeCandidates[myBestZ].second->getRecoElectron()->classification() == 110 ||
01338                                             zeeCandidates[myBestZ].second->getRecoElectron()->classification() == 120
01339                                             )
01340                                            );
01341   
01342   //2 = all electrons are Golden
01343   if(electronSelection_==2)selectionBool=( myBestZ != -1 &&
01344                                            (zeeCandidates[myBestZ].first->getRecoElectron()->classification() == 0 ||
01345                                             zeeCandidates[myBestZ].first->getRecoElectron()->classification() == 100
01346                                             ) &&
01347                                            (zeeCandidates[myBestZ].second->getRecoElectron()->classification() == 0 ||
01348                                             zeeCandidates[myBestZ].second->getRecoElectron()->classification() == 100
01349                                             ) 
01350                                            );
01351   //3 = all electrons are showering
01352   if(electronSelection_==3)selectionBool=( myBestZ != -1 &&
01353                                           (
01354                                            (zeeCandidates[myBestZ].first->getRecoElectron()->classification() >=30  &&
01355                                            zeeCandidates[myBestZ].first->getRecoElectron()->classification() <=34)  
01356                                            ||
01357                                            ((zeeCandidates[myBestZ].first->getRecoElectron()->classification() >=130  &&
01358                                              zeeCandidates[myBestZ].first->getRecoElectron()->classification() <=134))
01359                                            )
01360                                            &&
01361                                            ( (zeeCandidates[myBestZ].second->getRecoElectron()->classification() >=30  &&
01362                                               zeeCandidates[myBestZ].second->getRecoElectron()->classification() <=34)
01363                                              ||
01364                                              ((zeeCandidates[myBestZ].second->getRecoElectron()->classification() >=130  &&
01365                                                zeeCandidates[myBestZ].second->getRecoElectron()->classification() <=134))
01366                                              )
01367                                            
01368                                            );
01369   
01370   //4 = all Barrel electrons are Golden, BB or Narrow; take all Endcap electrons
01371                                                                                                                              
01372   if(electronSelection_==4)selectionBool=( myBestZ != -1 && 
01373                                            (
01374 
01375                                            (
01376                                             (zeeCandidates[myBestZ].first->getRecoElectron()->classification() ==0 ||
01377                                               zeeCandidates[myBestZ].first->getRecoElectron()->classification() ==10 ||
01378                                               zeeCandidates[myBestZ].first->getRecoElectron()->classification() ==20 
01379                                               ) && zeeCandidates[myBestZ].second->getRecoElectron()->classification()>=100 
01380                                             && zeeCandidates[myBestZ].second->getRecoElectron()->classification()!=140
01381                                             )
01382 
01383                                            ||
01384                                            
01385                                            (
01386                                             (zeeCandidates[myBestZ].second->getRecoElectron()->classification() ==0 ||
01387                                              zeeCandidates[myBestZ].second->getRecoElectron()->classification() ==10 ||
01388                                              zeeCandidates[myBestZ].second->getRecoElectron()->classification() ==20
01389                                              ) && zeeCandidates[myBestZ].first->getRecoElectron()->classification()>=100
01390                                             && zeeCandidates[myBestZ].first->getRecoElectron()->classification()!=140
01391                                             )
01392 
01393 
01394                                            )
01395                                            ); 
01396   
01397   //5 = all Endcap electrons (but no crack)
01398   
01399   if(electronSelection_==5)selectionBool=( myBestZ != -1 && 
01400                                            zeeCandidates[myBestZ].first->getRecoElectron()->classification()>=100 && 
01401                                            zeeCandidates[myBestZ].second->getRecoElectron()->classification()>= 100 && 
01402                                            zeeCandidates[myBestZ].first->getRecoElectron()->classification()!= 140 &&
01403                                            zeeCandidates[myBestZ].second->getRecoElectron()->classification()!= 140);
01404 
01405   //6 = all Barrel electrons (but no crack)
01406   
01407   if(electronSelection_==6)selectionBool=( myBestZ != -1 && 
01408                                            zeeCandidates[myBestZ].first->getRecoElectron()->classification()<100 && 
01409                                            zeeCandidates[myBestZ].second->getRecoElectron()->classification()< 100 && 
01410                                            zeeCandidates[myBestZ].first->getRecoElectron()->classification()!= 40 &&
01411                                            zeeCandidates[myBestZ].second->getRecoElectron()->classification()!= 40);
01412 
01413   //7 = this eliminates the events which have 1 ele in the Barrel and 1 in the Endcap
01414   
01415   if(electronSelection_==7)selectionBool=( myBestZ != -1 && 
01416                                            !(zeeCandidates[myBestZ].first->getRecoElectron()->classification()<100 && 
01417                                            zeeCandidates[myBestZ].second->getRecoElectron()->classification()>=100) &&
01418                                            !(zeeCandidates[myBestZ].first->getRecoElectron()->classification()>=100 &&
01419                                              zeeCandidates[myBestZ].second->getRecoElectron()->classification()<100) );
01420 
01421 
01422       float ele1EnergyCorrection(1.);
01423       float ele2EnergyCorrection(1.);
01424 
01425         if(invMassBool && selectionBool && wantEtaCorrection_){
01426           
01427           ele1EnergyCorrection=getEtaCorrection(zeeCandidates[myBestZ].first->getRecoElectron());
01428           ele2EnergyCorrection=getEtaCorrection(zeeCandidates[myBestZ].second->getRecoElectron());
01429 
01430         }
01431 
01432   if (invMassBool && selectionBool)  
01433     {
01434 
01435       h1_electronCosTheta_SC_ -> Fill( ZeeKinematicTools::cosThetaElectrons_SC(zeeCandidates[myBestZ],ele1EnergyCorrection,ele2EnergyCorrection)  );
01436       h1_electronCosTheta_TK_ -> Fill( ZeeKinematicTools::cosThetaElectrons_TK(zeeCandidates[myBestZ],ele1EnergyCorrection,ele2EnergyCorrection)  );
01437       h1_electronCosTheta_SC_TK_ -> Fill( ZeeKinematicTools::cosThetaElectrons_SC(zeeCandidates[myBestZ],ele1EnergyCorrection,ele2EnergyCorrection)/ZeeKinematicTools::cosThetaElectrons_TK(zeeCandidates[myBestZ],ele1EnergyCorrection,ele2EnergyCorrection) - 1. );
01438 
01439         if (!mcProducer_.empty())
01440           {
01441             h1_zMassResol_ ->Fill(mass-myGenZMass);
01442             
01443             //reco-mc association map - begin
01444             
01445             std::map<HepMC::GenParticle*,const reco::PixelMatchGsfElectron*> myMCmap;
01446             
01447             std::vector<const reco::PixelMatchGsfElectron*> dauElectronCollection;
01448             
01449             dauElectronCollection.push_back(zeeCandidates[myBestZ].first->getRecoElectron()  );
01450             dauElectronCollection.push_back(zeeCandidates[myBestZ].second->getRecoElectron()  );
01451             
01452             fillMCmap(&dauElectronCollection,mcEle,myMCmap);
01453             fillEleInfo(mcEle,myMCmap);
01454             //h_DiffZMassDistr_[loopFlag_]->Fill( (mass-myGenZMass) );
01455           }
01456 
01457       //PUT f(eta) IN OUR Zee ALGORITHM
01458       theAlgorithm_->addEvent(zeeCandidates[myBestZ].first, zeeCandidates[myBestZ].second,MZ*sqrt(ele1EnergyCorrection*ele2EnergyCorrection) );
01459      
01460       h1_reco_ZMass_->Fill(ZeeKinematicTools::calculateZMass_withTK(zeeCandidates[myBestZ]));
01461 
01462       h1_reco_ZMassCorr_->Fill(ZeeKinematicTools::calculateZMassWithCorrectedElectrons_withTK(zeeCandidates[myBestZ],ele1EnergyCorrection,ele2EnergyCorrection));
01463 
01464       if(zeeCandidates[myBestZ].first->getRecoElectron()->classification()<100 && zeeCandidates[myBestZ].second->getRecoElectron()->classification()<100 )
01465         h1_reco_ZMassCorrBB_->Fill(ZeeKinematicTools::calculateZMassWithCorrectedElectrons_withTK(zeeCandidates[myBestZ],ele1EnergyCorrection,ele2EnergyCorrection));
01466 
01467 
01468       if(zeeCandidates[myBestZ].first->getRecoElectron()->classification()>=100 && zeeCandidates[myBestZ].second->getRecoElectron()->classification()>=100 )
01469         h1_reco_ZMassCorrEE_->Fill(ZeeKinematicTools::calculateZMassWithCorrectedElectrons_withTK(zeeCandidates[myBestZ],ele1EnergyCorrection,ele2EnergyCorrection));
01470 
01471 
01472       mass4tree = ZeeKinematicTools::calculateZMassWithCorrectedElectrons_withTK(zeeCandidates[myBestZ],ele1EnergyCorrection,ele2EnergyCorrection);
01473 
01474       massDiff4tree = ZeeKinematicTools::calculateZMassWithCorrectedElectrons_withTK(zeeCandidates[myBestZ],ele1EnergyCorrection,ele2EnergyCorrection) - myGenZMass;
01475 
01476       //      h_ZMassDistr_[loopFlag_]->Fill(ZeeKinematicTools::calculateZMassWithCorrectedElectrons_withTK(zeeCandidates[myBestZ],ele1EnergyCorrection,ele2EnergyCorrection));
01477 
01478       myTree->Fill();
01479     
01480     }
01481 
01482 
01483 
01484 #ifdef DEBUG
01485   std::cout << "Added event to algorithm" << std::endl;  
01486 #endif
01487 
01488   return kContinue;
01489     }

void ZeeCalibration::endOfJob ( ) [virtual]

Called at end of job.

if not ETA_ET MODE - begin

if not ETA_ET MODE - end

Reimplemented from edm::EDLooper.

Definition at line 344 of file ZeeCalibration.cc.

References aa, funct::abs(), calibCoeff, calibCoeffError, calibMode_, coefficientDistanceAtIteration, GenMuonPlsPt100GeV_cfg::cout, EcalBarrel, EcalEndcap, lat::endl(), ZIterativeAlgorithmWithFit::getHistos(), ZIterativeAlgorithmWithFit::getNumberOfChannels(), ZIterativeAlgorithmWithFit::getNumberOfIterations(), h1_borderElectronClassification_, h1_eleClasses_, h1_electronCosTheta_SC_, h1_electronCosTheta_SC_TK_, h1_electronCosTheta_TK_, h1_eleEtaResol_, h1_elePhiResol_, h1_eventsAfterBorderSelection_, h1_eventsAfterEWKSelection_, h1_eventsBeforeBorderSelection_, h1_eventsBeforeEWKSelection_, h1_mc_, h1_mcEB_, h1_mcEE_, h1_occupancy_, h1_occupancyBarrel_, h1_occupancyEndcap_, h1_occupancyVsEta_, h1_preshowerOverSC_, h1_reco_ZMass_, h1_reco_ZMassCorr_, h1_reco_ZMassCorrBB_, h1_reco_ZMassCorrEE_, h1_seedOverSC_, h1_weightSumMeanBarrel_, h1_weightSumMeanEndcap_, h1_ZCandMult_, h1_zEtaResol_, h1_zMassResol_, h1_zPhiResol_, h2_chi2_, h2_coeffVsEta_, h2_coeffVsEtaGrouped_, h2_coeffVsLoop_, h2_fEtaBarrelBad_, h2_fEtaBarrelGood_, h2_fEtaEndcapBad_, h2_fEtaEndcapGood_, h2_iterations_, h2_miscalRecal_, h2_miscalRecalEB_, h2_miscalRecalEE_, h2_residualSigma_, h2_xtalMiscalibCoeffBarrel_, h2_xtalMiscalibCoeffEndcapMinus_, h2_xtalMiscalibCoeffEndcapPlus_, h2_zMassDiffVsLoop_, h2_zMassVsLoop_, h2_zWidthVsLoop_, h_eleEffEta_, h_eleEffPhi_, h_eleEffPt_, h_ESCcorrEtrue_, h_ESCcorrEtrueVsEta_, h_ESCEtrue_, h_ESCEtrueVsEta_, i, ical, id, initCalibCoeff, EEDetId::IX_MAX, EEDetId::IX_MIN, EEDetId::IY_MAX, EEDetId::IY_MIN, j, k, loopArray, EBDetId::MAX_IETA, EBDetId::MAX_IPHI, mean(), EBDetId::MIN_IPHI, myTree, myZeePlots_, funct::num(), outputFile_, funct::pow(), printStatistics(), DetId::rawId(), ringNumberCorrector(), sigmaArray, sigmaErrorArray, funct::sqrt(), theAlgorithm_, theMaxLoops, EEDetId::validDetId(), EBDetId::validDetId(), ZIterativeAlgorithmWithFit::ZIterativeAlgorithmWithFitPlots::weightedRescaleFactor, ZeePlots::writeEleHistograms(), calibXMLwriter::writeLine(), ZeePlots::writeMCEleHistograms(), ZeePlots::writeMCZHistograms(), and ZeePlots::writeZHistograms().

00344                          {
00345 
00346 
00347   printStatistics();
00348 
00349   if(calibMode_ != "ETA_ET_MODE"){
00350 
00352 
00353   //Writing out calibration coefficients
00354   calibXMLwriter* barrelWriter = new calibXMLwriter(EcalBarrel);
00355   for(int ieta=-EBDetId::MAX_IETA; ieta<=EBDetId::MAX_IETA ;++ieta) {
00356     if(ieta==0) continue;
00357     for(int iphi=EBDetId::MIN_IPHI; iphi<=EBDetId::MAX_IPHI; ++iphi) {
00358       // make an EBDetId since we need EBDetId::rawId() to be used as the key for the pedestals
00359       if (EBDetId::validDetId(ieta,iphi))
00360         {
00361           EBDetId ebid(ieta,iphi);
00362           barrelWriter->writeLine(ebid,* (ical->getMap().find(ebid.rawId()) ));
00363         }
00364     }
00365   }
00366   
00367 
00368   
00369   calibXMLwriter* endcapWriter = new calibXMLwriter(EcalEndcap);
00370   for(int iX=EEDetId::IX_MIN; iX<=EEDetId::IX_MAX ;++iX) {
00371     for(int iY=EEDetId::IY_MIN; iY<=EEDetId::IY_MAX; ++iY) {
00372       // make an EEDetId since we need EEDetId::rawId() to be used as the key for the pedestals
00373       if (EEDetId::validDetId(iX,iY,1))
00374         {
00375           EEDetId eeid(iX,iY,1);
00376           endcapWriter->writeLine(eeid,*(ical->getMap().find(eeid.rawId())  ) );
00377         }
00378       if (EEDetId::validDetId(iX,iY,-1))
00379         {
00380           EEDetId eeid(iX,iY,-1);
00381           endcapWriter->writeLine(eeid, *(ical->getMap().find(eeid.rawId())) );
00382         }
00383       
00384     }
00385   }
00386   
00387 
00388   } 
00389 
00390   std::cout<<"Writing  histos..."<<std::endl;
00391   outputFile_->cd();
00392 
00393   //  zeeplts->Write();
00394 
00395   h1_eventsBeforeEWKSelection_ ->Write();
00396   h1_eventsAfterEWKSelection_ ->Write();
00397 
00398   h1_eventsBeforeBorderSelection_ ->Write();
00399   h1_eventsAfterBorderSelection_ ->Write();
00400 
00401   h1_borderElectronClassification_->Write();
00402  
00403   h2_xtalMiscalibCoeffBarrel_->Write();
00404   h2_xtalMiscalibCoeffEndcapMinus_->Write();
00405   h2_xtalMiscalibCoeffEndcapPlus_->Write();
00406 
00407   h1_electronCosTheta_SC_->Write();
00408   h1_electronCosTheta_TK_->Write();
00409   h1_electronCosTheta_SC_TK_->Write();
00410 
00411   h1_zMassResol_->Write();
00412   h1_zEtaResol_->Write();
00413   h1_zPhiResol_->Write();
00414   h1_eleEtaResol_->Write();
00415   h1_elePhiResol_->Write();
00416   h1_seedOverSC_ ->Write();
00417   h1_preshowerOverSC_ ->Write();
00418    
00419   for(int i =0; i<25; i++){
00420     if( i < theMaxLoops ){
00421       
00422       h_ESCEtrueVsEta_[i]->Write();
00423       h_ESCEtrue_[i]->Write();
00424       
00425       h_ESCcorrEtrueVsEta_[i]->Write();
00426       h_ESCcorrEtrue_[i]->Write();
00427       
00428       h2_chi2_[i]->Write();
00429       h2_iterations_[i]->Write();
00430       
00431       //      h_DiffZMassDistr_[i]->Write();
00432       
00433       //h_ZMassDistr_[i]->Write();
00434     }
00435   }
00436 
00437   h2_fEtaBarrelGood_->Write();
00438   h2_fEtaBarrelBad_->Write();
00439   h2_fEtaEndcapGood_->Write();
00440   h2_fEtaEndcapBad_->Write();
00441   h1_eleClasses_->Write();
00442 
00443   h_eleEffEta_[0]->Write();
00444   h_eleEffPhi_[0]->Write();
00445   h_eleEffPt_[0]->Write();
00446   
00447   h_eleEffEta_[1]->Write();
00448   h_eleEffPhi_[1]->Write();
00449   h_eleEffPt_[1]->Write();
00450 
00451   
00452   int j = 0;
00453 
00454   int flag=0;
00455   
00456   Double_t mean[25] = {0.};
00457   Double_t num[25] = {0.};
00458   Double_t meanErr[25] = {0.};
00459   Float_t rms[25] = {0.};
00460   Float_t tempRms[10][25];
00461   
00462   for(int ia = 0; ia<10; ia++){
00463     for(int ib = 0; ib<25; ib++){
00464   
00465       tempRms[ia][ib] = 0.;
00466 
00467     }
00468   }
00469     
00470   int aa = 0;
00471       
00472   for( int k = 0; k<theAlgorithm_->getNumberOfChannels(); k++ )
00473     {
00474  
00475 
00476       
00478       bool isNearCrack = false;
00479       
00480       if( calibMode_ == "RING"){
00481         
00482         isNearCrack = ( abs( ringNumberCorrector(k) ) == 1 || abs( ringNumberCorrector(k) ) == 25 ||
00483                         abs( ringNumberCorrector(k) ) == 26 || abs( ringNumberCorrector(k) ) == 45 ||
00484                         abs( ringNumberCorrector(k) ) == 46 || abs( ringNumberCorrector(k) ) == 65 ||
00485                         abs( ringNumberCorrector(k) ) == 66 || abs( ringNumberCorrector(k) ) == 85 ||
00486                         abs( ringNumberCorrector(k) ) == 86 || abs( ringNumberCorrector(k) ) == 124 );
00487       }
00488       
00489       if(k<85)
00490         {
00491           
00492           if((k+1)%5!=0)
00493             {
00494               
00495               if(!isNearCrack){
00496                 mean[j]+=calibCoeff[k];
00497                 mean[j]+=calibCoeff[169 - k];
00498                 
00499                 num[j] += 2.;
00500                 
00501                 //meanErr[j]+= calibCoeffError[k];
00502                 //meanErr[j]+= calibCoeffError[169 - k];
00503                 
00504                 meanErr[j]+= 1./ pow ( calibCoeffError[k], 2 );
00505                 meanErr[j]+= 1./ pow ( calibCoeffError[169 - k], 2);
00506 
00507 
00508               tempRms[aa][j]+=calibCoeff[k];
00509                 aa++;
00510                 tempRms[aa][j]+=calibCoeff[169 - k];
00511                 aa++;
00512               }
00513             }
00514           
00515           else  {
00516             if(!isNearCrack){
00517               mean[j]+=calibCoeff[k];
00518               mean[j]+=calibCoeff[169 - k];
00519               
00520               num[j] += 2.;
00521               
00522               //meanErr[j]+= calibCoeffError[k];
00523               //meanErr[j]+= calibCoeffError[169 - k];
00524               
00525               meanErr[j]+= 1./ pow ( calibCoeffError[k], 2 );
00526               meanErr[j]+= 1./ pow ( calibCoeffError[169 - k], 2);
00527 
00528               tempRms[aa][j]+=calibCoeff[k];
00529               aa++;
00530               tempRms[aa][j]+=calibCoeff[169 - k];
00531               aa++;
00532 
00533             }
00534             j++;
00535             aa = 0;
00536             
00537           }
00538           
00539         }
00540       //EE begin
00541       
00542       
00543       if(k>=170 && k<=204){
00544         
00545         if(flag<4){
00546           //make groups of 5 Xtals in #eta
00547           mean[j]+=calibCoeff[k]/10.;
00548           mean[j]+=calibCoeff[k+39]/10.;
00549         
00550           meanErr[j]+= calibCoeffError[k]/30.;
00551           meanErr[j]+= calibCoeffError[k + 39]/30.;
00552 
00553           
00554           tempRms[aa][j]+=calibCoeff[k];
00555           aa++;
00556           tempRms[aa][j]+=calibCoeff[k + 39];
00557           aa++;
00558           
00559           flag++;
00560         }
00561 
00562         else if(flag==4){
00563           //make groups of 5 Xtals in #eta
00564           mean[j]+=calibCoeff[k]/10.;
00565           mean[j]+=calibCoeff[k+39]/10.;
00566 
00567           meanErr[j]+= calibCoeffError[k]/30.;
00568           meanErr[j]+= calibCoeffError[k + 39]/30.;
00569           
00570           tempRms[aa][j]+=calibCoeff[k];
00571           aa++;
00572           tempRms[aa][j]+=calibCoeff[k + 39];
00573           aa++;
00574           
00575           flag=0;
00576           //      std::cout<<" index(>85) "<<k<<" j is "<<j<<" mean[j] is "<<mean[j]<<std::endl;
00577           j++;
00578           aa = 0;
00579 
00580         }
00581         
00582       }
00583       if(k>=205 && k<=208){
00584         mean[j]+=calibCoeff[k]/8.;
00585         mean[j]+=calibCoeff[k+39]/8.;
00586 
00587         meanErr[j]+= calibCoeffError[k]/30.;
00588         meanErr[j]+= calibCoeffError[k + 39]/30.;
00589         
00590         
00591         tempRms[aa][j]+=calibCoeff[k];
00592         aa++;
00593         tempRms[aa][j]+=calibCoeff[k + 39];
00594         aa++;
00595       }
00596       //EE end
00597 
00598       /*
00599       for(int jj =0; jj< 25; jj++){ 
00600       if(meanErr[jj] > 0.)
00601         cout<<" meanErr[jj] before sqrt: "<<meanErr[jj]<<endl;
00602 
00603         meanErr[jj] = 1./sqrt( meanErr[jj] );
00604 
00605         cout<<" meanErr[jj] after sqrt: "<<meanErr[jj]<<endl;
00606       }
00607       */
00608       
00609       
00610       
00611       if(!isNearCrack){
00612         h2_coeffVsEta_->Fill( ringNumberCorrector(k), calibCoeff[k] );
00613         h2_miscalRecal_->Fill( initCalibCoeff[k], 1./calibCoeff[k] );
00614         h1_mc_->Fill( initCalibCoeff[k]*calibCoeff[k] -1. );
00615         
00616         
00617         
00618         if(k<170){
00619           h2_miscalRecalEB_->Fill( initCalibCoeff[k], 1./calibCoeff[k] );
00620           h1_mcEB_->Fill( initCalibCoeff[k]*calibCoeff[k] -1. );
00621         }
00622         
00623         if(k>=170){
00624           h2_miscalRecalEE_->Fill( initCalibCoeff[k], 1./calibCoeff[k] );
00625           h1_mcEE_->Fill( initCalibCoeff[k]*calibCoeff[k] -1. );
00626         }    
00627         
00628       }
00629     }
00630   
00631   for(int ic = 0; ic< 17; ic++){
00632 
00633     mean[ic] = mean[ic] / num[ic]; //find mean of recalib coeff on group of rings
00634     //meanErr[ic] = meanErr[ic] / ( sqrt( num[ic] ) * num[ic] ); //find mean of recalib coeff on group of rings
00635     meanErr[ic] = 1. / sqrt(meanErr[ic]); //find mean of recalib coeff on group of rings
00636     
00637   }
00638 
00639 
00640   //build array of RMS
00641   for(int ic = 0; ic< 25; ic++){
00642     for(int id = 0; id< 10; id++){
00643 
00644       if(tempRms[id][ic] > 0.){
00645         
00646         rms[ic] += (tempRms[id][ic] - mean[j])*(tempRms[id][ic] - mean[j]);
00647         
00648       }
00649     }
00650     rms[ic]/= 10.;//this is approximate
00651     rms[ic] = sqrt(rms[ic]);
00652   }
00653   
00654   //build array of RMS
00655   
00656   
00657   
00658   Double_t xtalEta[25] = {1.4425, 1.3567,1.2711,1.1855,
00659                          1.10,1.01,0.92,0.83,
00660                          0.7468,0.6612,0.5756,0.4897,0.3985,0.3117,0.2250,0.1384,0.0487,
00661                          1.546, 1.651, 1.771, 1.908, 2.071, 2.267, 2.516, 2.8};
00662   
00663   Double_t zero[25] = {0.026};//interval/sqrt(12)
00664 
00665   for(int j = 0; j <25; j++)
00666     h2_coeffVsEtaGrouped_->Fill( xtalEta[j],mean[j]);
00667   
00668   //  for(int sho = 0; sho <25; sho++)
00669   //cout<<"xtalEta[j] "<< xtalEta[sho]<<" mean[j]  "<<mean[sho]<<"  err[j] "<<meanErr[sho]<<endl;
00670 
00671   TProfile *px = h2_coeffVsEta_->ProfileX("coeffVsEtaProfile");
00672   px->SetXTitle("Eta channel");
00673   px->SetYTitle("recalibCoeff");
00674   px->Write();
00675 
00676   h2_coeffVsEta_->Write();
00677   h2_coeffVsEtaGrouped_->Write();
00678   h2_zMassVsLoop_->Write();
00679   h2_zMassDiffVsLoop_->Write();
00680   h2_zWidthVsLoop_->Write();
00681   h2_coeffVsLoop_->Write();
00682   h2_miscalRecal_->Write();
00683   h1_mc_->Write();
00684   h2_miscalRecalEB_->Write();
00685   h1_mcEB_->Write();
00686   h2_miscalRecalEE_->Write();
00687   h1_mcEE_->Write();
00688 
00689   h2_residualSigma_->Write();
00690 
00691   const ZIterativeAlgorithmWithFit::ZIterativeAlgorithmWithFitPlots* algoHistos=theAlgorithm_->getHistos();
00692 
00693   double weightSumMeanBarrel = 0.;
00694   double weightSumMeanEndcap = 0.;
00695 
00696   for (int iIteration=0;iIteration<theAlgorithm_->getNumberOfIterations();iIteration++)
00697     for (int iChannel=0;iChannel<theAlgorithm_->getNumberOfChannels();iChannel++)
00698       {
00699 
00700         if( iIteration==(theAlgorithm_->getNumberOfIterations()-1) ){
00701           
00702           if(iChannel < 170)
00703             weightSumMeanBarrel += algoHistos->weightedRescaleFactor[iIteration][iChannel]->Integral()/170.; 
00704 
00705           if(iChannel >= 170)
00706             weightSumMeanEndcap += algoHistos->weightedRescaleFactor[iIteration][iChannel]->Integral()/78.; 
00707           
00708           h1_occupancyVsEta_->Fill((Double_t)ringNumberCorrector(iChannel), algoHistos->weightedRescaleFactor[iIteration][iChannel]->Integral() );
00709           
00710           
00711           h1_occupancy_->Fill( algoHistos->weightedRescaleFactor[iIteration][iChannel]->Integral() );
00712           
00713           if(iChannel < 170)
00714             h1_occupancyBarrel_->Fill( algoHistos->weightedRescaleFactor[iIteration][iChannel]->Integral() );
00715 
00716           if(iChannel >= 170)
00717             h1_occupancyEndcap_->Fill( algoHistos->weightedRescaleFactor[iIteration][iChannel]->Integral() );
00718 
00719 #ifdef DEBUG
00720           std::cout<<"Writing weighted integral for channel "<<ringNumberCorrector(iChannel)<<" ,value "<<algoHistos->weightedRescaleFactor[iIteration][iChannel]->Integral()<<std::endl;
00721 #endif
00722 
00723         }
00724         
00725       }
00726   
00727   //  std::cout<<"Done! Closing output file... "<<std::endl;
00728 
00729   h1_weightSumMeanBarrel_ ->Fill(weightSumMeanBarrel);
00730   h1_weightSumMeanEndcap_ ->Fill(weightSumMeanEndcap);
00731 
00732   std::cout<<"Weight sum mean on channels in Barrel is :"<<weightSumMeanBarrel<<std::endl;
00733   std::cout<<"Weight sum mean on channels in Endcap is :"<<weightSumMeanEndcap<<std::endl;
00734 
00735   h1_weightSumMeanBarrel_ ->Write();
00736   h1_weightSumMeanEndcap_ ->Write();
00737 
00738   h1_occupancyVsEta_->Write();
00739    h1_occupancy_->Write();
00740   h1_occupancyBarrel_->Write();
00741   h1_occupancyEndcap_->Write();
00742 
00743   myTree->Write();
00744 
00745   TGraphErrors* graph = new TGraphErrors(25,xtalEta,mean,zero,meanErr);
00746   graph->Draw("APL");
00747   graph->Write();
00748 
00749   double zero50[50] = { 0. };
00750 
00751   TGraphErrors* residualSigmaGraph = new TGraphErrors(50,loopArray,sigmaArray,zero50,sigmaErrorArray);
00752   residualSigmaGraph->SetName("residualSigmaGraph");
00753   residualSigmaGraph->Draw("APL");
00754   residualSigmaGraph->Write();
00755 
00756   TGraphErrors* coefficientDistanceAtIterationGraph = new TGraphErrors(50,loopArray,coefficientDistanceAtIteration,zero50,zero50);
00757   coefficientDistanceAtIterationGraph->SetName("coefficientDistanceAtIterationGraph");
00758   coefficientDistanceAtIterationGraph->Draw("APL");
00759   coefficientDistanceAtIterationGraph->Write();
00760 
00761   Float_t noError[250] = {0.};
00762 
00763   Float_t ringInd[250];
00764   for(int i =0; i<250; i++)
00765     ringInd[i]=ringNumberCorrector(i);
00766 
00767   TGraphErrors* graphCoeff = new TGraphErrors(theAlgorithm_->getNumberOfChannels(),ringInd,calibCoeff,noError,calibCoeffError);
00768   graphCoeff->SetName("graphCoeff");
00769   graphCoeff->Draw("APL");
00770   graphCoeff->Write();
00771   
00772   //   outputFile_->Write();//this automatically writes all histos on file
00773  
00774 
00775   h1_ZCandMult_->Write();
00776   h1_reco_ZMass_->Write();
00777   
00778   h1_reco_ZMassCorr_->Write();
00779   h1_reco_ZMassCorrBB_->Write();
00780   h1_reco_ZMassCorrEE_->Write();
00781 
00782   outputFile_->Close();
00783   
00784   myZeePlots_ ->writeEleHistograms();
00785   myZeePlots_ ->writeMCEleHistograms();
00786   myZeePlots_ ->writeZHistograms();
00787   myZeePlots_ ->writeMCZHistograms();
00788   
00789   // myZeeRescaleFactorPlots_ = new ZeeRescaleFactorPlots("zeeRescaleFactorPlots.root");
00790   //myZeeRescaleFactorPlots_->writeHistograms( theAlgorithm_ );
00791   
00792   //  delete myZeeRescaleFactorPlots_;
00793   
00794   
00795   
00796 }

edm::EDLooper::Status ZeeCalibration::endOfLoop	(	const edm::EventSetup &	iSetup,
		unsigned int	iLoop
	)			`[virtual]`

Called at end of loop.

Implements edm::EDLooper.

Definition at line 1515 of file ZeeCalibration.cc.

01516 {
01517 
01518 
01519 
01520   double par[3];
01521   double errpar[3];
01522   double zChi2;
01523   int zIters;
01524 
01525   ZIterativeAlgorithmWithFit::gausfit(h1_reco_ZMass_,par,errpar,2.,2., &zChi2, &zIters );
01526 
01527   h2_zMassVsLoop_ -> Fill(loopFlag_,  par[1] );
01528 
01529   h2_zMassDiffVsLoop_ -> Fill(loopFlag_,  (par[1]-MZ)/MZ );
01530 
01531   h2_zWidthVsLoop_ -> Fill(loopFlag_, par[2] );
01532  
01533 
01535 
01536   std::cout<< "[ZeeCalibration] Ending loop " << iLoop<<std::endl;
01537   //RUN the algorithm
01538   theAlgorithm_->iterate();
01539 
01540   const std::vector<float>& optimizedCoefficients = theAlgorithm_->getOptimizedCoefficients();
01541   const std::vector<float>& optimizedCoefficientsError = theAlgorithm_->getOptimizedCoefficientsError();
01542   const std::vector<float>& weightSum = theAlgorithm_->getWeightSum();
01543   const std::vector<float>& optimizedChi2 = theAlgorithm_->getOptimizedChiSquare();
01544   const std::vector<int>& optimizedIterations = theAlgorithm_->getOptimizedIterations();
01545 
01546 
01547   //#ifdef DEBUG
01548   std::cout<< "Optimized coefficients " << optimizedCoefficients.size() <<std::endl;
01549   //#endif
01550 
01551   //  h2_coeffVsLoop_->Fill(loopFlag_, optimizedCoefficients[75]); //show the evolution of just 1 ring coefficient (well chosen...)
01552 
01554   for (unsigned int ieta=0;ieta<optimizedCoefficients.size();ieta++)
01555     {
01556       NewCalibCoeff[ieta] = calibCoeff[ieta] * optimizedCoefficients[ieta];
01557 
01558       h2_chi2_[loopFlag_]->Fill( ringNumberCorrector( ieta ), optimizedChi2[ieta] );
01559       h2_iterations_[loopFlag_]->Fill( ringNumberCorrector( ieta ), optimizedIterations[ieta] );
01560  
01561     }
01563   
01564   
01565   coefficientDistanceAtIteration[loopFlag_]= computeCoefficientDistanceAtIteration(calibCoeff, NewCalibCoeff, optimizedCoefficients.size() );
01566 
01567   std::cout<<"Iteration # : "<< loopFlag_ << " CoefficientDistanceAtIteration "<< coefficientDistanceAtIteration[loopFlag_] <<std::endl;
01568   std::cout<<"size "<<optimizedCoefficients.size()<<std::endl;
01569 
01570   for (unsigned int ieta=0;ieta<optimizedCoefficients.size();ieta++)
01571     {
01572       calibCoeff[ieta] *= optimizedCoefficients[ieta];
01573       calibCoeffError[ieta] = calibCoeff[ieta] * sqrt ( pow( optimizedCoefficientsError[ieta]/optimizedCoefficients[ieta], 2 ) + pow( calibCoeffError[ieta]/calibCoeff[ieta] , 2 )  );
01574       //calibCoeffError[ieta] = optimizedCoefficientsError[ieta];
01575 
01576 
01577 #ifdef DEBUG
01578       std::cout<< ieta << " " << optimizedCoefficients[ieta] <<std::endl;  
01579 #endif
01580 
01581       std::vector<DetId> ringIds;
01582 
01583       if(calibMode_ == "RING")
01584         ringIds = EcalRingCalibrationTools::getDetIdsInRing(ieta);
01585 
01586       if(calibMode_ == "MODULE")
01587         ringIds = EcalRingCalibrationTools::getDetIdsInModule(ieta);
01588 
01589       if(calibMode_ == "ABS_SCALE" || calibMode_ == "ETA_ET_MODE" )
01590         ringIds = EcalRingCalibrationTools::getDetIdsInECAL();
01591 
01592       
01593       for (unsigned int iid=0; iid<ringIds.size();++iid){
01594         
01595         if(ringIds[iid].subdetId() == EcalBarrel){
01596           EBDetId myEBDetId(ringIds[iid]);  
01597           h2_xtalRecalibCoeffBarrel_[loopFlag_]->SetBinContent( myEBDetId.ieta() + 86, myEBDetId.iphi(), 100 * (calibCoeff[ieta]*initCalibCoeff[ieta] - 1.) );//fill TH2 with recalibCoeff
01598 
01599         }
01600 
01601         if(ringIds[iid].subdetId() == EcalEndcap){
01602           EEDetId myEEDetId(ringIds[iid]);
01603           if(myEEDetId.zside() < 0)
01604             h2_xtalRecalibCoeffEndcapMinus_[loopFlag_]->SetBinContent( myEEDetId.ix(), myEEDetId.iy(), 100 * (calibCoeff[ieta]*initCalibCoeff[ieta] - 1.) );//fill TH2 with recalibCoeff
01605 
01606           if(myEEDetId.zside() > 0)
01607             h2_xtalRecalibCoeffEndcapPlus_[loopFlag_]->SetBinContent( myEEDetId.ix(), myEEDetId.iy(), 100 * (calibCoeff[ieta]*initCalibCoeff[ieta] - 1.) );//fill TH2 with recalibCoeff
01608           
01609         }
01610         
01611         
01612         ical->setValue( ringIds[iid], *(ical->getMap().find(ringIds[iid])  ) * optimizedCoefficients[ieta] );
01613       }    
01614 
01615     }
01616   
01617   
01619 
01620   for( int k = 0; k<theAlgorithm_->getNumberOfChannels(); k++ )
01621     {
01622       bool isNearCrack = ( abs( ringNumberCorrector(k) ) == 1 || abs( ringNumberCorrector(k) ) == 25 ||
01623                            abs( ringNumberCorrector(k) ) == 26 || abs( ringNumberCorrector(k) ) == 45 ||
01624                            abs( ringNumberCorrector(k) ) == 46 || abs( ringNumberCorrector(k) ) == 65 ||
01625                            abs( ringNumberCorrector(k) ) == 66 || abs( ringNumberCorrector(k) ) == 85 ||
01626                            abs( ringNumberCorrector(k) ) == 86 || abs( ringNumberCorrector(k) ) == 124 );
01627 
01628       if(!isNearCrack){
01629 
01630         //      h2_miscalRecalParz_[iLoop]->Fill( initCalibCoeff[k], 1./calibCoeff[k] );
01631         h1_mcParz_[iLoop]->Fill( initCalibCoeff[k]*calibCoeff[k] -1. );
01632         
01633         if(k<170){
01634           //h2_miscalRecalEBParz_[iLoop]->Fill( initCalibCoeff[k], 1./calibCoeff[k] );
01635           h1_mcEBParz_[iLoop]->Fill( initCalibCoeff[k]*calibCoeff[k] -1. );
01636           
01637         }
01638         
01639         if(k>=170){
01640           //h2_miscalRecalEEParz_[iLoop]->Fill( initCalibCoeff[k], 1./calibCoeff[k] );
01641           h1_mcEEParz_[iLoop]->Fill( initCalibCoeff[k]*calibCoeff[k] -1. );
01642         }
01643      
01644       }
01645     }
01646   
01647   
01649   double parResidual[3];
01650   double errparResidual[3];
01651   double zResChi2;
01652   int zResIters;
01653   
01654   ZIterativeAlgorithmWithFit::gausfit(h1_mcParz_[iLoop],parResidual,errparResidual,3.,3., &zResChi2, &zResIters);
01655   //h1_mcParz_[iLoop]->Fit("gaus");
01656   
01657   h2_residualSigma_ -> Fill(loopFlag_ + 1,  parResidual[2]);
01658   loopArray[loopFlag_] = loopFlag_ + 1;
01659   sigmaArray[loopFlag_] = parResidual[2];
01660   sigmaErrorArray[loopFlag_] = errparResidual[2];
01661 
01662   std::cout<<"Fit on residuals, sigma is "<<parResidual[2]<<" +/- "<<errparResidual[2]<<std::endl;
01663 
01665   outputFile_->cd();
01666 
01667 
01668   //  h2_miscalRecalParz_[iLoop]->Write();
01669   h1_mcParz_[iLoop]->Write();
01670 
01671   //h2_miscalRecalEBParz_[iLoop]->Write();
01672   h1_mcEBParz_[iLoop]->Write();
01673 
01674   //h2_miscalRecalEEParz_[iLoop]->Write();
01675   h1_mcEEParz_[iLoop]->Write();
01676   h2_xtalRecalibCoeffBarrel_[loopFlag_] -> Write();
01677   h2_xtalRecalibCoeffEndcapPlus_[loopFlag_] -> Write();
01678   h2_xtalRecalibCoeffEndcapMinus_[loopFlag_] -> Write();
01679 
01681   
01682   loopFlag_++;
01683   
01684 #ifdef DEBUG  
01685   std::cout<<" loopFlag_ is "<<loopFlag_<<std::endl;
01686 #endif  
01687   
01688   if ( iLoop == theMaxLoops-1 || iLoop >= theMaxLoops ) return kStop;
01689   else return kContinue;
01690 }

float ZeeCalibration::EvalDPhi	(	float	Phi,
		float	Phi_ref
	)			`[private]`

Definition at line 2066 of file ZeeCalibration.cc.

References Pi.

02067 {
02068   if (Phi<0) Phi = 2*TMath::Pi() + Phi;
02069   if (Phi_ref<0) Phi_ref = 2*TMath::Pi() + Phi_ref;
02070   return (Phi - Phi_ref);
02071 }

float ZeeCalibration::EvalDR	(	float	Eta,
		float	Eta_ref,
		float	Phi,
		float	Phi_ref
	)			`[private]`

Definition at line 2053 of file ZeeCalibration.cc.

References Pi, and funct::sqrt().

Referenced by fillMCmap().

02054 {
02055   if (Phi<0) Phi = 2*TMath::Pi() + Phi;
02056   if (Phi_ref<0) Phi_ref = 2*TMath::Pi() + Phi_ref;
02057   float DPhi = Phi - Phi_ref ;
02058   if (fabs(DPhi)>TMath::Pi()) DPhi = 2*TMath::Pi() - fabs(DPhi);
02059                                                                                                                              
02060   float DEta = Eta - Eta_ref ;
02061                                                                                                                              
02062   float DR = sqrt( DEta*DEta + DPhi*DPhi );
02063   return DR;
02064 }

double ZeeCalibration::fEtaBarrelBad ( double scEta ) const [private]

Definition at line 1980 of file ZeeCalibration.cc.

References p1, p2, and x.

Referenced by getEtaCorrection().

01980                                                       {
01981   
01982   float p0 = 1.00153e+00;
01983     float p1 = 3.29331e-02;
01984     float p2 = 1.21187e-03;
01985 
01986   double x  = (double) fabs(scEta);
01987 
01988   return 1. / ( p0 + p1*x*x + p2*x*x*x*x );  
01989 
01990 }

double ZeeCalibration::fEtaBarrelGood ( double scEta ) const [private]

Definition at line 2018 of file ZeeCalibration.cc.

References p1, p2, and x.

Referenced by getEtaCorrection().

02018                                                        {
02019 
02020   float p0 = 9.99782e-01 ;
02021   float p1 = 1.26983e-02;
02022   float p2 = 2.16344e-03;
02023 
02024   double x  = (double) fabs(scEta);
02025 
02026  return 1. / ( p0 + p1*x*x + p2*x*x*x*x );  
02027 
02028 }

double ZeeCalibration::fEtaEndcapBad ( double scEta ) const [private]

Definition at line 2006 of file ZeeCalibration.cc.

References p1, p2, and x.

Referenced by getEtaCorrection().

02006                                                       {
02007   
02008   float p0 = 1.17382e+00;
02009   float p1 = -6.52319e-02; 
02010   float p2 = 6.26108e-03;
02011 
02012   double x  = (double) fabs(scEta);
02013 
02014  return 1. / ( p0 + p1*x*x + p2*x*x*x*x );  
02015 
02016 }

double ZeeCalibration::fEtaEndcapGood ( double scEta ) const [private]

Definition at line 1992 of file ZeeCalibration.cc.

References p1, p2, and x.

Referenced by getEtaCorrection().

01992                                                        {
01993 
01994   // f(eta) for the first 3 classes (100, 110 and 120) 
01995   // Ivica's new corrections 01/06
01996   float p0 = 1.06819e+00;
01997     float p1 = -1.53189e-02;
01998     float p2 = 4.01707e-04 ;
01999 
02000   double x  = (double) fabs(scEta);
02001 
02002   return 1. / ( p0 + p1*x*x + p2*x*x*x*x );  
02003 
02004 }

void ZeeCalibration::fillEleInfo	(	std::vector< HepMC::GenParticle * > &	a,
		std::map< HepMC::GenParticle , const reco::PixelMatchGsfElectron > &	b
	)			`[private]`

Definition at line 2073 of file ZeeCalibration.cc.

References e, reco::CaloCluster::energy(), reco::Particle::eta(), getEtaCorrection(), h1_eleEtaResol_, h1_elePhiResol_, h1_preshowerOverSC_, h1_seedOverSC_, h_eleEffEta_, h_eleEffPhi_, h_eleEffPt_, h_ESCcorrEtrue_, h_ESCcorrEtrueVsEta_, h_ESCEtrue_, h_ESCEtrueVsEta_, i, loopFlag_, muonGeometry::perp(), phi, reco::Particle::phi(), reco::CaloCluster::position(), reco::SuperCluster::preshowerEnergy(), reco::SuperCluster::seed(), and reco::GsfElectron::superCluster().

Referenced by duringLoop().

02074 {
02075 
02076   for (unsigned int i=0;i<mcEle.size();i++)
02077     {
02078 
02079       h_eleEffEta_[0]->Fill(fabs(mcEle[i]->momentum().pseudoRapidity()));
02080       h_eleEffPhi_[0]->Fill(mcEle[i]->momentum().phi());
02081       h_eleEffPt_[0]->Fill(mcEle[i]->momentum().perp());
02082 
02083       std::map<HepMC::GenParticle*,const reco::PixelMatchGsfElectron*>::const_iterator mIter = associationMap.find(mcEle[i]);
02084       if (mIter == associationMap.end() )
02085         continue;
02086     
02087       if((*mIter).second)
02088         {
02089           const reco::PixelMatchGsfElectron* myEle=(*mIter).second;
02090       
02091           h_eleEffEta_[1]->Fill(fabs(mcEle[i]->momentum().pseudoRapidity()));
02092           h_eleEffPhi_[1]->Fill(mcEle[i]->momentum().phi());
02093           h_eleEffPt_[1]->Fill(mcEle[i]->momentum().perp());
02094           h1_eleEtaResol_->Fill( myEle->eta() - mcEle[i]->momentum().eta() );
02095           h1_elePhiResol_->Fill( myEle->phi() - mcEle[i]->momentum().phi() );
02096 
02097           const reco::SuperCluster* mySC=&(*(myEle->superCluster()));
02098           if (/*fabs(mySC->position().eta()) < 2.4*/1)
02099             {
02100               //      if(myEle->classification()>=100)std::cout<<"mySC->preshowerEnergy()"<<mySC->preshowerEnergy()<<std::endl;
02101 
02102               h_ESCEtrue_[loopFlag_]->Fill(mySC->energy()/mcEle[i]->momentum().e());
02103               h_ESCEtrueVsEta_[loopFlag_]->Fill(fabs(mySC->position().eta()),mySC->energy()/mcEle[i]->momentum().e());
02104 
02105               double corrSCenergy = ( mySC->energy() )/getEtaCorrection(myEle);
02106               h_ESCcorrEtrue_[loopFlag_]->Fill(corrSCenergy/mcEle[i]->momentum().e());
02107               h_ESCcorrEtrueVsEta_[loopFlag_]->Fill(fabs(mySC->position().eta()),corrSCenergy/mcEle[i]->momentum().e());
02108 
02109               std::vector<DetId> mySCRecHits = mySC->seed()->getHitsByDetId();
02110 
02111               h1_seedOverSC_->Fill( mySC->seed()->energy() / mySC->energy() );
02112               h1_preshowerOverSC_->Fill( mySC->preshowerEnergy() / mySC->energy() );
02113               
02114             }
02115 
02116         }
02117     }
02118 }

void ZeeCalibration::fillMCInfo ( HepMC::GenParticle * mcele ) [private]

void ZeeCalibration::fillMCmap	(	const std::vector< const reco::PixelMatchGsfElectron * > *	electronCollection,
		const std::vector< HepMC::GenParticle * > &	mcEle,
		std::map< HepMC::GenParticle , const reco::PixelMatchGsfElectron > &	myMCmap
	)			`[private]`

Definition at line 2033 of file ZeeCalibration.cc.

References eta, EvalDR(), i, j, and phi.

Referenced by duringLoop().

02034 {
02035   for (unsigned int i=0;i<mcEle.size();i++)
02036     {
02037       float minDR=0.1;
02038       const reco::PixelMatchGsfElectron* myMatchEle=0;
02039       for (unsigned int j=0;j<electronCollection->size();j++)
02040         {
02041           float dr=EvalDR(mcEle[i]->momentum().pseudoRapidity(),(*(*electronCollection)[j]).eta(),mcEle[i]->momentum().phi(),(*(*electronCollection)[j]).phi());
02042           if (dr < minDR )
02043             {
02044               myMatchEle = (*electronCollection)[j];
02045               minDR = dr;
02046             }
02047         }
02048       myMCmap.insert(std::pair<HepMC::GenParticle*,const reco::PixelMatchGsfElectron*>(mcEle[i],myMatchEle));
02049       
02050     }
02051 }

double ZeeCalibration::getEtaCorrection ( const reco::PixelMatchGsfElectron * ele ) [private]

Definition at line 2148 of file ZeeCalibration.cc.

References reco::GsfElectron::classification(), fEtaBarrelBad(), fEtaBarrelGood(), fEtaEndcapBad(), fEtaEndcapGood(), and reco::GsfElectron::superCluster().

Referenced by duringLoop(), and fillEleInfo().

02148                                                                            {
02149 
02150   double correction(1.);
02151 
02152   if(ele->classification() ==0 ||
02153      ele->classification() ==10 ||
02154      ele->classification() ==20)
02155     correction = fEtaBarrelGood(ele->superCluster()->eta());
02156                                                                                                                                                
02157   if(ele->classification() ==100 ||
02158      ele->classification() ==110 ||
02159      ele->classification() ==120)
02160     correction = fEtaEndcapGood(ele->superCluster()->eta());
02161                                                                                                                                                
02162   if(ele->classification() ==30 ||
02163      ele->classification() ==31 ||
02164      ele->classification() ==32 ||
02165      ele->classification() ==33 ||
02166      ele->classification() ==34)
02167     correction = fEtaBarrelBad(ele->superCluster()->eta());
02168 
02169 
02170   if(ele->classification() ==130 ||
02171      ele->classification() ==131 ||
02172      ele->classification() ==132 ||
02173      ele->classification() ==133 ||
02174      ele->classification() ==134)
02175     correction = fEtaEndcapBad(ele->superCluster()->eta());
02176  
02177   return correction;                                                                                                                                              
02178 }

std::pair< DetId, double > ZeeCalibration::getHottestDetId	(	std::vector< DetId >	mySCRecHits,
		const EBRecHitCollection *	ebhits,
		const EERecHitCollection *	eehits
	)			`[private]`

Definition at line 2180 of file ZeeCalibration.cc.

References GenMuonPlsPt100GeV_cfg::cout, EcalBarrel, EcalEndcap, edm::SortedCollection< T, SORT >::end(), lat::endl(), CaloRecHit::energy(), edm::SortedCollection< T, SORT >::find(), and EcalRecHit::id().

Referenced by duringLoop().

02180                                                                                                                                                       {
02181   
02182 
02183   double maxEnergy = -9999.;
02184   const EcalRecHit* hottestRecHit;
02185   
02186   std::pair<DetId, double> myPair (DetId(0), -9999.);
02187 
02188 
02189   for(   std::vector<DetId>::const_iterator idIt=mySCRecHits.begin(); idIt != mySCRecHits.end(); idIt++){
02190    
02191     if (idIt->subdetId() == EcalBarrel )
02192       {
02193         hottestRecHit  = & (* ( ebhits->find(*idIt) ) );
02194 
02195         if( hottestRecHit == & (*( ebhits->end())) )
02196           {
02197             std::cout<<"@@@@@@@@@@@@@@@@@@@@@@@@@@@ NO RECHIT FOUND SHOULD NEVER HAPPEN"<<std::endl;
02198             continue;
02199           }
02200       }
02201     else if (idIt->subdetId() == EcalEndcap )
02202       {
02203         hottestRecHit  = & (* ( eehits->find(*idIt) ) );
02204         if( hottestRecHit == & (*( eehits->end())) )
02205           {
02206             std::cout<<"@@@@@@@@@@@@@@@@@@@@@@@@@@@ NO RECHIT FOUND SHOULD NEVER HAPPEN"<<std::endl;
02207             continue;
02208           }
02209       }    
02210     
02211     //std::cout<<"[getHottestDetId] hottestRecHit->energy() "<<hottestRecHit->energy()<<endl;
02212    
02213     if(hottestRecHit && hottestRecHit->energy() > maxEnergy){
02214 
02215       maxEnergy = hottestRecHit->energy();
02216       
02217       myPair.first =   hottestRecHit ->id();
02218       myPair.second = maxEnergy;
02219       
02220     }
02221     
02222   }//end loop to find hottest RecHit    
02223   
02224   //std::cout<<"[ZeeCalibration::getHottestDetId] going to return..."<<std::endl;
02225 
02226   return myPair;
02227   
02228 }

void ZeeCalibration::printStatistics ( ) [private]

Definition at line 2371 of file ZeeCalibration.cc.

References BARREL_ELECTRONS_AFTER_BORDER_CUT, BARREL_ELECTRONS_BEFORE_BORDER_CUT, BBZN, BBZN_gg, BBZN_t0, BBZN_tt, GenMuonPlsPt100GeV_cfg::cout, CRACK_ELECTRONS_IN_BARREL, CRACK_ELECTRONS_IN_ENDCAP, EBZN, EBZN_gg, EBZN_t0, EBZN_tt, EEZN, EEZN_gg, EEZN_t0, EEZN_tt, lat::endl(), GOLDEN_ELECTRONS_IN_BARREL, GOLDEN_ELECTRONS_IN_ENDCAP, MCZBB, MCZEB, MCZEE, NEVT, SHOWER_ELECTRONS_IN_BARREL, SHOWER_ELECTRONS_IN_ENDCAP, SILVER_ELECTRONS_IN_BARREL, SILVER_ELECTRONS_IN_ENDCAP, TOTAL_ELECTRONS_IN_BARREL, and TOTAL_ELECTRONS_IN_ENDCAP.

Referenced by endOfJob().

02371                                     {
02372 
02373 
02374   std::cout<< "[ CHECK ON BARREL ELECTRON NUMBER ]"<<" first "<<BARREL_ELECTRONS_BEFORE_BORDER_CUT<<" second "<<TOTAL_ELECTRONS_IN_BARREL << std::endl;
02375   
02376   
02377   std::cout<< "[ EFFICIENCY OF THE BORDER SELECTION ]" << (float)BARREL_ELECTRONS_AFTER_BORDER_CUT / (float) BARREL_ELECTRONS_BEFORE_BORDER_CUT << endl;
02378   
02379   std::cout<< "[ EFFICIENCY OF THE GOLDEN SELECTION ] BARREL: " << (float)GOLDEN_ELECTRONS_IN_BARREL / (float) TOTAL_ELECTRONS_IN_BARREL << " ENDCAP: "<< (float)GOLDEN_ELECTRONS_IN_ENDCAP / (float) TOTAL_ELECTRONS_IN_ENDCAP << endl;
02380   
02381   std::cout<< "[ EFFICIENCY OF THE SILVER SELECTION ] BARREL: " << (float)SILVER_ELECTRONS_IN_BARREL / (float) TOTAL_ELECTRONS_IN_BARREL << " ENDCAP: "<< (float)SILVER_ELECTRONS_IN_ENDCAP / (float) TOTAL_ELECTRONS_IN_ENDCAP << endl;
02382   
02383   std::cout<< "[ EFFICIENCY OF THE SHOWER SELECTION ] BARREL: " << (float)SHOWER_ELECTRONS_IN_BARREL / (float) TOTAL_ELECTRONS_IN_BARREL << " ENDCAP: "<< (float)SHOWER_ELECTRONS_IN_ENDCAP / (float) TOTAL_ELECTRONS_IN_ENDCAP << endl;
02384   
02385   std::cout<< "[ EFFICIENCY OF THE CRACK SELECTION ] BARREL: " << (float)CRACK_ELECTRONS_IN_BARREL / (float) TOTAL_ELECTRONS_IN_BARREL << " ENDCAP: "<< (float)CRACK_ELECTRONS_IN_ENDCAP / (float) TOTAL_ELECTRONS_IN_ENDCAP << endl;
02386   
02387   
02388   
02389   ofstream fout("ZeeStatistics.txt");
02390   
02391   if(!fout) {
02392     std::cout << "Cannot open output file.\n";
02393     }
02394 
02395   fout<<"ZeeStatistics"<<std::endl;
02396 
02397   fout<<"##########################RECO#########################"<<std::endl;
02398   fout<<"##################Zee with Barrel-Barrel electrons: "<<BBZN<<std::endl;
02399 
02400   fout<<"Golden-Golden fraction: "<<(float)BBZN_gg/BBZN<<" 3-3 fraction is "<<(float)BBZN_tt/BBZN<<" 3-whatever fraction is "<<(float)BBZN_t0/BBZN<<std::endl; 
02401   fout<<"##################Zee with Barrel-Endcap electrons: "<<EBZN<<std::endl;
02402   fout<<"Golden-Golden fraction: "<<(float)EBZN_gg/EBZN<<" 3-3 fraction is "<<(float)EBZN_tt/EBZN<<" 3-whatever fraction is "<<(float)EBZN_t0/EBZN<<std::endl; 
02403   fout<<"##################Zee with Endcap-Endcap electrons: "<<EEZN<<std::endl;
02404   fout<<"Golden-Golden fraction: "<<(float)EEZN_gg/EEZN<<" 3-3 fraction is "<<(float)EEZN_tt/EEZN<<" 3-whatever fraction is "<<(float)EEZN_t0/EEZN<<std::endl; 
02405 
02406   fout<<"\n"<<std::endl;
02407 
02408   fout<<"##########################GEN#########################"<<std::endl;
02409   fout<<"##################Zee with Barrel-Barrel electrons: "<<(float)MCZBB/NEVT<<std::endl;
02410   fout<<"##################Zee with Barrel-Endcap electrons: "<<(float)MCZEB/NEVT<<std::endl;
02411   fout<<"##################Zee with Endcap-Endcap electrons: "<<(float)MCZEE/NEVT<<std::endl;
02412 
02413   fout.close();
02414 
02415 
02416 
02417 }

virtual void ZeeCalibration::produce	(	edm::Event &	,
		const edm::EventSetup &
	)			`[inline, virtual]`

Dummy implementation (job done in duringLoop).

Definition at line 85 of file ZeeCalibration.h.

00085 {};

boost::shared_ptr< EcalIntercalibConstants > ZeeCalibration::produceEcalIntercalibConstants ( const EcalIntercalibConstantsRcd & iRecord ) [virtual]

Produce Ecal interCalibrations.

Definition at line 193 of file ZeeCalibration.cc.

References GenMuonPlsPt100GeV_cfg::cout, lat::endl(), and ical.

Referenced by ZeeCalibration().

00194 {
00195   std::cout << "@SUB=ZeeCalibration::produceEcalIntercalibConstants" << std::endl;
00196   return ical;
00197 }

void ZeeCalibration::resetHistograms ( ) [private]

Definition at line 2323 of file ZeeCalibration.cc.

References h1_eleClasses_, h1_electronCosTheta_SC_, h1_electronCosTheta_SC_TK_, h1_electronCosTheta_TK_, h1_eleEtaResol_, h1_elePhiResol_, h1_eventsAfterBorderSelection_, h1_eventsAfterEWKSelection_, h1_eventsBeforeBorderSelection_, h1_eventsBeforeEWKSelection_, h1_occupancy_, h1_occupancyBarrel_, h1_occupancyEndcap_, h1_occupancyVsEta_, h1_preshowerOverSC_, h1_reco_ZMass_, h1_reco_ZMassCorr_, h1_reco_ZMassCorrBB_, h1_reco_ZMassCorrEE_, h1_seedOverSC_, h1_ZCandMult_, h1_zMassResol_, h2_fEtaBarrelBad_, h2_fEtaBarrelGood_, h2_fEtaEndcapBad_, h2_fEtaEndcapGood_, h_eleEffEta_, h_eleEffPhi_, h_eleEffPt_, and i.

Referenced by startingNewLoop().

02323                                     {
02324 
02325  h1_eventsBeforeEWKSelection_ ->Reset();
02326  h1_eventsAfterEWKSelection_ ->Reset();
02327 
02328  h1_eventsBeforeBorderSelection_ ->Reset();
02329  h1_eventsAfterBorderSelection_ ->Reset();
02330 
02331  for (int i=0;i<2;i++)
02332    {
02333      h_eleEffEta_[i] ->Reset();
02334      h_eleEffPhi_[i] ->Reset(); 
02335      h_eleEffPt_[i]  ->Reset();
02336    }
02337 
02338  h1_seedOverSC_ ->Reset();
02339  h1_preshowerOverSC_ ->Reset();
02340 
02341  h1_eleEtaResol_->Reset();
02342  h1_elePhiResol_->Reset();
02343 
02344  h1_zMassResol_->Reset(); 
02345  
02346  h1_electronCosTheta_TK_->Reset();
02347  h1_electronCosTheta_SC_->Reset();
02348  h1_electronCosTheta_SC_TK_->Reset();
02349 
02350  h2_fEtaBarrelGood_->Reset();
02351  h2_fEtaBarrelBad_->Reset();
02352  h2_fEtaEndcapGood_->Reset();
02353  h2_fEtaEndcapBad_->Reset();
02354  h1_eleClasses_->Reset();
02355 
02356  h1_ZCandMult_-> Reset();
02357  h1_reco_ZMass_-> Reset();
02358   h1_reco_ZMassCorr_-> Reset();
02359  h1_reco_ZMassCorrBB_-> Reset();
02360  h1_reco_ZMassCorrEE_-> Reset();
02361  h1_occupancyVsEta_-> Reset();
02362  h1_occupancy_-> Reset();
02363  h1_occupancyBarrel_-> Reset();
02364  h1_occupancyEndcap_-> Reset();
02365 
02366  return;
02367 
02368 }

void ZeeCalibration::resetVariables ( ) [private]

Definition at line 2285 of file ZeeCalibration.cc.

References BARREL_ELECTRONS_AFTER_BORDER_CUT, BARREL_ELECTRONS_BEFORE_BORDER_CUT, BBZN, BBZN_gg, BBZN_t0, BBZN_tt, CRACK_ELECTRONS_IN_BARREL, CRACK_ELECTRONS_IN_ENDCAP, EBZN, EBZN_gg, EBZN_t0, EBZN_tt, EEZN, EEZN_gg, EEZN_t0, EEZN_tt, GOLDEN_ELECTRONS_IN_BARREL, GOLDEN_ELECTRONS_IN_ENDCAP, SHOWER_ELECTRONS_IN_BARREL, SHOWER_ELECTRONS_IN_ENDCAP, SILVER_ELECTRONS_IN_BARREL, SILVER_ELECTRONS_IN_ENDCAP, TOTAL_ELECTRONS_IN_BARREL, and TOTAL_ELECTRONS_IN_ENDCAP.

Referenced by startingNewLoop().

02285                                    {
02286 
02287  BBZN=0;
02288  EBZN=0;
02289  EEZN=0;
02290  BBZN_gg=0;
02291  EBZN_gg=0;
02292  EEZN_gg=0;
02293 
02294  BBZN_tt=0;
02295  EBZN_tt=0;
02296  EEZN_tt=0;
02297 
02298  BBZN_t0=0;
02299  EBZN_t0=0;
02300  EEZN_t0=0;
02301 
02302  TOTAL_ELECTRONS_IN_BARREL=0;
02303  TOTAL_ELECTRONS_IN_ENDCAP=0;
02304 
02305  GOLDEN_ELECTRONS_IN_BARREL=0;
02306  GOLDEN_ELECTRONS_IN_ENDCAP=0;
02307  SILVER_ELECTRONS_IN_BARREL=0;
02308  SILVER_ELECTRONS_IN_ENDCAP=0;
02309  SHOWER_ELECTRONS_IN_BARREL=0;
02310  SHOWER_ELECTRONS_IN_ENDCAP=0;
02311  CRACK_ELECTRONS_IN_BARREL=0;
02312  CRACK_ELECTRONS_IN_ENDCAP=0;
02313 
02314 
02315  BARREL_ELECTRONS_BEFORE_BORDER_CUT = 0;
02316  BARREL_ELECTRONS_AFTER_BORDER_CUT = 0;
02317 
02318  return;
02319 
02320 }

int ZeeCalibration::ringNumberCorrector ( int k ) [private]

Definition at line 2120 of file ZeeCalibration.cc.

References calibMode_, and index.

Referenced by computeCoefficientDistanceAtIteration(), endOfJob(), and endOfLoop().

02121 {
02122 
02123   int index=-999;
02124 
02125   if( calibMode_ == "RING"){
02126     if(k>=0 && k<=84)index = k - 85;
02127     
02128     if(k>=85 && k<=169)index = k - 84;
02129     
02130     if(k>=170 && k<=208)index = - k + 84;
02131     
02132     if(k>=209 && k<=247)index = k - 123;
02133     
02134   }
02135   
02136   else if( calibMode_ == "MODULE"){
02137     
02138     if(k>=0 && k<=71)index = k - 72;
02139     
02140     if(k>=72 && k<=143)index = k - 71;
02141     
02142   }
02143   return index;
02144   
02145 }

void ZeeCalibration::startingNewLoop ( unsigned int iLoop ) [virtual]

Called at beginning of loop.

Implements edm::EDLooper.

Definition at line 1494 of file ZeeCalibration.cc.

References GenMuonPlsPt100GeV_cfg::cout, lat::endl(), resetHistograms(), ZIterativeAlgorithmWithFit::resetIteration(), resetVariables(), and theAlgorithm_.

01495 {
01496 
01497 std::cout<< "[ZeeCalibration] Starting loop number " << iLoop<<std::endl;
01498  
01499  theAlgorithm_->resetIteration();
01500  
01501  resetVariables();
01502  
01503  resetHistograms();
01504 
01505 #ifdef DEBUG
01506  std::cout<< "[ZeeCalibration] exiting from startingNewLoop" << std::endl;
01507 #endif
01508 
01509 }

bool ZeeCalibration::xtalIsOnModuleBorder ( EBDetId myEBDetId ) [private]

Definition at line 2231 of file ZeeCalibration.cc.

References funct::abs(), i, EBDetId::ieta(), and EBDetId::iphi().

Referenced by duringLoop().

02231                                                             {
02232   
02233   bool myBool(false); 
02234 
02235   short ieta = myEBDetId.ieta();
02236   short iphi = myEBDetId.iphi();
02237 
02238   //  std::cout<<"[xtalIsOnModuleBorder] ieta: "<<ieta<<" iphi "<<iphi<<std::endl;
02239  
02240   myBool = ( abs( ieta )  == 1 || abs( ieta ) == 25
02241              || abs( ieta )  ==26 || abs( ieta ) == 45
02242              || abs( ieta )  ==46 || abs( ieta ) == 65
02243              || abs( ieta )  ==66 || abs( ieta ) == 85 );
02244     
02245     for(int i = 0; i < 19; i++){
02246       
02247       if(iphi == ( 20*i + 1 ) || iphi == 20*i )
02248       myBool = true;
02249       
02250     }
02251   
02252   return myBool;
02253 }

char ZeeCalibration::aHLTNames[6000] [private]

Definition at line 369 of file ZeeCalibration.h.

bool ZeeCalibration::aHLTResults[200] [private]

Definition at line 372 of file ZeeCalibration.h.

Referenced by duringLoop().

TString ZeeCalibration::aNames[200] [private]

Definition at line 371 of file ZeeCalibration.h.

char ZeeCalibration::aTriggerNames[200][30] [private]

Definition at line 365 of file ZeeCalibration.h.

bool ZeeCalibration::aTriggerResults[200] [private]

Definition at line 366 of file ZeeCalibration.h.

int ZeeCalibration::BARREL_ELECTRONS_AFTER_BORDER_CUT [private]

Definition at line 330 of file ZeeCalibration.h.

Referenced by duringLoop(), printStatistics(), and resetVariables().

int ZeeCalibration::BARREL_ELECTRONS_BEFORE_BORDER_CUT [private]

Definition at line 329 of file ZeeCalibration.h.

Referenced by duringLoop(), printStatistics(), and resetVariables().

std::string ZeeCalibration::barrelfile_ [private]

Definition at line 178 of file ZeeCalibration.h.

Referenced by beginOfJob(), and ZeeCalibration().

Int_t ZeeCalibration::BBZN [private]

Definition at line 313 of file ZeeCalibration.h.

Referenced by duringLoop(), printStatistics(), and resetVariables().

Int_t ZeeCalibration::BBZN_gg [private]

Definition at line 313 of file ZeeCalibration.h.

Referenced by duringLoop(), printStatistics(), and resetVariables().

Int_t ZeeCalibration::BBZN_t0 [private]

Definition at line 313 of file ZeeCalibration.h.

Referenced by duringLoop(), printStatistics(), and resetVariables().

Int_t ZeeCalibration::BBZN_tt [private]

Definition at line 313 of file ZeeCalibration.h.

Referenced by duringLoop(), printStatistics(), and resetVariables().

float ZeeCalibration::calibCoeff[nMaxChannels] [private]

Definition at line 192 of file ZeeCalibration.h.

Referenced by beginOfJob(), endOfJob(), and endOfLoop().

float ZeeCalibration::calibCoeffError[nMaxChannels] [private]

Definition at line 194 of file ZeeCalibration.h.

Referenced by beginOfJob(), endOfJob(), and endOfLoop().

std::string ZeeCalibration::calibMode_ [private]

Definition at line 163 of file ZeeCalibration.h.

Referenced by beginOfJob(), computeCoefficientDistanceAtIteration(), endOfJob(), endOfLoop(), ringNumberCorrector(), and ZeeCalibration().

double ZeeCalibration::coefficientDistanceAtIteration[50] [private]

Definition at line 327 of file ZeeCalibration.h.

Referenced by endOfJob(), endOfLoop(), and ZeeCalibration().

int ZeeCalibration::CRACK_ELECTRONS_IN_BARREL [private]

Definition at line 344 of file ZeeCalibration.h.

Referenced by duringLoop(), printStatistics(), and resetVariables().

int ZeeCalibration::CRACK_ELECTRONS_IN_ENDCAP [private]

Definition at line 345 of file ZeeCalibration.h.

Referenced by duringLoop(), printStatistics(), and resetVariables().

Int_t ZeeCalibration::EBZN [private]

Definition at line 313 of file ZeeCalibration.h.

Referenced by duringLoop(), printStatistics(), and resetVariables().

Int_t ZeeCalibration::EBZN_gg [private]

Definition at line 313 of file ZeeCalibration.h.

Referenced by duringLoop(), printStatistics(), and resetVariables().

Int_t ZeeCalibration::EBZN_t0 [private]

Definition at line 313 of file ZeeCalibration.h.

Referenced by duringLoop(), printStatistics(), and resetVariables().

Int_t ZeeCalibration::EBZN_tt [private]

Definition at line 313 of file ZeeCalibration.h.

Referenced by duringLoop(), printStatistics(), and resetVariables().

Int_t ZeeCalibration::EEZN [private]

Definition at line 313 of file ZeeCalibration.h.

Referenced by duringLoop(), printStatistics(), and resetVariables().

Int_t ZeeCalibration::EEZN_gg [private]

Definition at line 313 of file ZeeCalibration.h.

Referenced by duringLoop(), printStatistics(), and resetVariables().

Int_t ZeeCalibration::EEZN_t0 [private]

Definition at line 313 of file ZeeCalibration.h.

Referenced by duringLoop(), printStatistics(), and resetVariables().

Int_t ZeeCalibration::EEZN_tt [private]

Definition at line 313 of file ZeeCalibration.h.

Referenced by duringLoop(), printStatistics(), and resetVariables().

std::string ZeeCalibration::electronCollection_ [private]

Definition at line 166 of file ZeeCalibration.h.

Referenced by duringLoop(), and ZeeCalibration().

std::string ZeeCalibration::electronProducer_ [private]

Definition at line 165 of file ZeeCalibration.h.

Referenced by duringLoop(), and ZeeCalibration().

unsigned int ZeeCalibration::electronSelection_ [private]

Definition at line 322 of file ZeeCalibration.h.

Referenced by duringLoop(), and ZeeCalibration().

std::string ZeeCalibration::endcapfile_ [private]

Definition at line 179 of file ZeeCalibration.h.

Referenced by beginOfJob(), and ZeeCalibration().

std::string ZeeCalibration::erechitCollection_ [private]

Definition at line 155 of file ZeeCalibration.h.

Referenced by duringLoop(), and ZeeCalibration().

std::string ZeeCalibration::erechitProducer_ [private]

Definition at line 154 of file ZeeCalibration.h.

Referenced by duringLoop(), and ZeeCalibration().

unsigned int ZeeCalibration::etaBins_ [private]

Definition at line 170 of file ZeeCalibration.h.

Referenced by ZeeCalibration().

double ZeeCalibration::etaMax_ [private]

Definition at line 175 of file ZeeCalibration.h.

Referenced by ZeeCalibration().

double ZeeCalibration::etaMin_ [private]

Definition at line 173 of file ZeeCalibration.h.

Referenced by ZeeCalibration().

unsigned int ZeeCalibration::etBins_ [private]

Definition at line 171 of file ZeeCalibration.h.

Referenced by ZeeCalibration().

double ZeeCalibration::etMax_ [private]

Definition at line 176 of file ZeeCalibration.h.

Referenced by ZeeCalibration().

double ZeeCalibration::etMin_ [private]

Definition at line 174 of file ZeeCalibration.h.

Referenced by ZeeCalibration().

int ZeeCalibration::GOLDEN_ELECTRONS_IN_BARREL [private]

Definition at line 335 of file ZeeCalibration.h.

Referenced by duringLoop(), printStatistics(), and resetVariables().

int ZeeCalibration::GOLDEN_ELECTRONS_IN_ENDCAP [private]

Definition at line 336 of file ZeeCalibration.h.

Referenced by duringLoop(), printStatistics(), and resetVariables().

TH1F* ZeeCalibration::h1_borderElectronClassification_ [private]

Definition at line 310 of file ZeeCalibration.h.

Referenced by bookHistograms(), duringLoop(), and endOfJob().

TH1F* ZeeCalibration::h1_eleClasses_ [private]

Definition at line 222 of file ZeeCalibration.h.

Referenced by bookHistograms(), duringLoop(), endOfJob(), and resetHistograms().

TH1F* ZeeCalibration::h1_electronCosTheta_SC_ [private]

Definition at line 307 of file ZeeCalibration.h.

Referenced by bookHistograms(), duringLoop(), endOfJob(), and resetHistograms().

TH1F* ZeeCalibration::h1_electronCosTheta_SC_TK_ [private]

Definition at line 308 of file ZeeCalibration.h.

Referenced by bookHistograms(), duringLoop(), endOfJob(), and resetHistograms().

TH1F* ZeeCalibration::h1_electronCosTheta_TK_ [private]

Definition at line 306 of file ZeeCalibration.h.

Referenced by bookHistograms(), duringLoop(), endOfJob(), and resetHistograms().

TH1F* ZeeCalibration::h1_eleERecoOverEtrue_ [private]

Definition at line 244 of file ZeeCalibration.h.

TH1F* ZeeCalibration::h1_eleEtaResol_ [private]

Definition at line 246 of file ZeeCalibration.h.

Referenced by bookHistograms(), endOfJob(), fillEleInfo(), and resetHistograms().

TH1F* ZeeCalibration::h1_elePhiResol_ [private]

Definition at line 247 of file ZeeCalibration.h.

Referenced by bookHistograms(), endOfJob(), fillEleInfo(), and resetHistograms().

TH1F* ZeeCalibration::h1_eventsAfterBorderSelection_ [private]

Definition at line 214 of file ZeeCalibration.h.

Referenced by bookHistograms(), duringLoop(), endOfJob(), and resetHistograms().

TH1F* ZeeCalibration::h1_eventsAfterEWKSelection_ [private]

Definition at line 211 of file ZeeCalibration.h.

Referenced by bookHistograms(), duringLoop(), endOfJob(), and resetHistograms().

TH1F* ZeeCalibration::h1_eventsBeforeBorderSelection_ [private]

Definition at line 213 of file ZeeCalibration.h.

Referenced by bookHistograms(), duringLoop(), endOfJob(), and resetHistograms().

TH1F* ZeeCalibration::h1_eventsBeforeEWKSelection_ [private]

Definition at line 210 of file ZeeCalibration.h.

Referenced by bookHistograms(), duringLoop(), endOfJob(), and resetHistograms().

TH1F* ZeeCalibration::h1_mc_ [private]

Definition at line 267 of file ZeeCalibration.h.

Referenced by bookHistograms(), and endOfJob().

TH1F* ZeeCalibration::h1_mcEB_ [private]

Definition at line 276 of file ZeeCalibration.h.

Referenced by bookHistograms(), and endOfJob().

TH1F* ZeeCalibration::h1_mcEBParz_[25] [private]

Definition at line 277 of file ZeeCalibration.h.

Referenced by bookHistograms(), and endOfLoop().

TH1F* ZeeCalibration::h1_mcEE_ [private]

Definition at line 280 of file ZeeCalibration.h.

Referenced by bookHistograms(), and endOfJob().

TH1F* ZeeCalibration::h1_mcEEParz_[25] [private]

Definition at line 281 of file ZeeCalibration.h.

Referenced by bookHistograms(), and endOfLoop().

TH1F* ZeeCalibration::h1_mcParz_[25] [private]

Definition at line 268 of file ZeeCalibration.h.

Referenced by bookHistograms(), and endOfLoop().

TH1F* ZeeCalibration::h1_nEleReco_ [private]

Definition at line 221 of file ZeeCalibration.h.

Referenced by bookHistograms().

TH1F* ZeeCalibration::h1_occupancy_ [private]

Definition at line 302 of file ZeeCalibration.h.

Referenced by bookHistograms(), endOfJob(), and resetHistograms().

TH1F* ZeeCalibration::h1_occupancyBarrel_ [private]

Definition at line 303 of file ZeeCalibration.h.

Referenced by bookHistograms(), endOfJob(), and resetHistograms().

TH1F* ZeeCalibration::h1_occupancyEndcap_ [private]

Definition at line 304 of file ZeeCalibration.h.

Referenced by bookHistograms(), endOfJob(), and resetHistograms().

TH1F* ZeeCalibration::h1_occupancyVsEta_ [private]

Definition at line 297 of file ZeeCalibration.h.

Referenced by bookHistograms(), endOfJob(), and resetHistograms().

TH1F* ZeeCalibration::h1_occupancyVsEtaCrack_ [private]

Definition at line 300 of file ZeeCalibration.h.

TH1F* ZeeCalibration::h1_occupancyVsEtaGold_ [private]

Definition at line 298 of file ZeeCalibration.h.

TH1F* ZeeCalibration::h1_occupancyVsEtaShower_ [private]

Definition at line 301 of file ZeeCalibration.h.

TH1F* ZeeCalibration::h1_occupancyVsEtaSilver_ [private]

Definition at line 299 of file ZeeCalibration.h.

TH1F* ZeeCalibration::h1_preshowerOverSC_ [private]

Definition at line 229 of file ZeeCalibration.h.

Referenced by bookHistograms(), endOfJob(), fillEleInfo(), and resetHistograms().

TH1F* ZeeCalibration::h1_reco_ZMass_ [private]

Definition at line 234 of file ZeeCalibration.h.

Referenced by bookHistograms(), duringLoop(), endOfJob(), endOfLoop(), and resetHistograms().

TH1F* ZeeCalibration::h1_reco_ZMassBad_ [private]

Definition at line 240 of file ZeeCalibration.h.

TH1F* ZeeCalibration::h1_reco_ZMassCorr_ [private]

Definition at line 236 of file ZeeCalibration.h.

Referenced by bookHistograms(), duringLoop(), endOfJob(), and resetHistograms().

TH1F* ZeeCalibration::h1_reco_ZMassCorrBB_ [private]

Definition at line 237 of file ZeeCalibration.h.

Referenced by bookHistograms(), duringLoop(), endOfJob(), and resetHistograms().

TH1F* ZeeCalibration::h1_reco_ZMassCorrEE_ [private]

Definition at line 238 of file ZeeCalibration.h.

Referenced by bookHistograms(), duringLoop(), endOfJob(), and resetHistograms().

TH1F* ZeeCalibration::h1_reco_ZMassGood_ [private]

Definition at line 239 of file ZeeCalibration.h.

TH1F* ZeeCalibration::h1_RMin_ [private]

Definition at line 242 of file ZeeCalibration.h.

TH1F* ZeeCalibration::h1_RMinZ_ [private]

Definition at line 243 of file ZeeCalibration.h.

TH1F* ZeeCalibration::h1_seedOverSC_ [private]

Definition at line 228 of file ZeeCalibration.h.

Referenced by bookHistograms(), endOfJob(), fillEleInfo(), and resetHistograms().

TH1F* ZeeCalibration::h1_weightSumMeanBarrel_ [private]

Definition at line 294 of file ZeeCalibration.h.

Referenced by bookHistograms(), and endOfJob().

TH1F* ZeeCalibration::h1_weightSumMeanEndcap_ [private]

Definition at line 295 of file ZeeCalibration.h.

Referenced by bookHistograms(), and endOfJob().

TH1F* ZeeCalibration::h1_ZCandMult_ [private]

Definition at line 241 of file ZeeCalibration.h.

Referenced by bookHistograms(), duringLoop(), endOfJob(), and resetHistograms().

TH1F* ZeeCalibration::h1_zEtaResol_ [private]

Definition at line 232 of file ZeeCalibration.h.

Referenced by bookHistograms(), and endOfJob().

TH1F* ZeeCalibration::h1_zMassResol_ [private]

Definition at line 231 of file ZeeCalibration.h.

Referenced by bookHistograms(), duringLoop(), endOfJob(), and resetHistograms().

TH1F* ZeeCalibration::h1_zPhiResol_ [private]

Definition at line 233 of file ZeeCalibration.h.

Referenced by bookHistograms(), and endOfJob().

TH2F* ZeeCalibration::h2_chi2_[25] [private]

Definition at line 283 of file ZeeCalibration.h.

Referenced by bookHistograms(), endOfJob(), and endOfLoop().

TH2F* ZeeCalibration::h2_coeffVsEta_ [private]

Definition at line 258 of file ZeeCalibration.h.

Referenced by bookHistograms(), and endOfJob().

TH2F* ZeeCalibration::h2_coeffVsEtaGrouped_ [private]

Definition at line 259 of file ZeeCalibration.h.

Referenced by bookHistograms(), and endOfJob().

TH2F* ZeeCalibration::h2_coeffVsLoop_ [private]

Definition at line 263 of file ZeeCalibration.h.

Referenced by bookHistograms(), and endOfJob().

TH2F* ZeeCalibration::h2_fEtaBarrelBad_ [private]

Definition at line 218 of file ZeeCalibration.h.

Referenced by bookHistograms(), endOfJob(), and resetHistograms().

TH2F* ZeeCalibration::h2_fEtaBarrelGood_ [private]

Definition at line 217 of file ZeeCalibration.h.

Referenced by bookHistograms(), endOfJob(), and resetHistograms().

TH2F* ZeeCalibration::h2_fEtaEndcapBad_ [private]

Definition at line 220 of file ZeeCalibration.h.

Referenced by bookHistograms(), endOfJob(), and resetHistograms().

TH2F* ZeeCalibration::h2_fEtaEndcapGood_ [private]

Definition at line 219 of file ZeeCalibration.h.

Referenced by bookHistograms(), endOfJob(), and resetHistograms().

TH2F* ZeeCalibration::h2_iterations_[25] [private]

Definition at line 284 of file ZeeCalibration.h.

Referenced by bookHistograms(), endOfJob(), and endOfLoop().

TH2F* ZeeCalibration::h2_miscalRecal_ [private]

Definition at line 265 of file ZeeCalibration.h.

Referenced by bookHistograms(), and endOfJob().

TH2F* ZeeCalibration::h2_miscalRecalEB_ [private]

Definition at line 274 of file ZeeCalibration.h.

Referenced by bookHistograms(), and endOfJob().

TH2F* ZeeCalibration::h2_miscalRecalEE_ [private]

Definition at line 278 of file ZeeCalibration.h.

Referenced by bookHistograms(), and endOfJob().

TH2F* ZeeCalibration::h2_residualSigma_ [private]

Definition at line 273 of file ZeeCalibration.h.

Referenced by bookHistograms(), endOfJob(), and endOfLoop().

TH2F* ZeeCalibration::h2_xtalMiscalibCoeffBarrel_ [private]

Definition at line 290 of file ZeeCalibration.h.

Referenced by beginOfJob(), bookHistograms(), and endOfJob().

TH2F* ZeeCalibration::h2_xtalMiscalibCoeffEndcapMinus_ [private]

Definition at line 291 of file ZeeCalibration.h.

Referenced by beginOfJob(), bookHistograms(), and endOfJob().

TH2F* ZeeCalibration::h2_xtalMiscalibCoeffEndcapPlus_ [private]

Definition at line 292 of file ZeeCalibration.h.

Referenced by beginOfJob(), bookHistograms(), and endOfJob().

TH2F* ZeeCalibration::h2_xtalRecalibCoeffBarrel_[25] [private]

Definition at line 286 of file ZeeCalibration.h.

Referenced by bookHistograms(), and endOfLoop().

TH2F* ZeeCalibration::h2_xtalRecalibCoeffEndcapMinus_[25] [private]

Definition at line 287 of file ZeeCalibration.h.

Referenced by bookHistograms(), and endOfLoop().

TH2F* ZeeCalibration::h2_xtalRecalibCoeffEndcapPlus_[25] [private]

Definition at line 288 of file ZeeCalibration.h.

Referenced by bookHistograms(), and endOfLoop().

TH2F* ZeeCalibration::h2_zMassDiffVsLoop_ [private]

Definition at line 261 of file ZeeCalibration.h.

Referenced by bookHistograms(), endOfJob(), and endOfLoop().

TH2F* ZeeCalibration::h2_zMassVsLoop_ [private]

Definition at line 260 of file ZeeCalibration.h.

Referenced by bookHistograms(), endOfJob(), and endOfLoop().

TH2F* ZeeCalibration::h2_zWidthVsLoop_ [private]

Definition at line 262 of file ZeeCalibration.h.

Referenced by bookHistograms(), endOfJob(), and endOfLoop().

TH1F* ZeeCalibration::h_eleEffEta[2] [private]

Definition at line 224 of file ZeeCalibration.h.

TH1F* ZeeCalibration::h_eleEffEta_[2] [private]

Definition at line 249 of file ZeeCalibration.h.

Referenced by bookHistograms(), endOfJob(), fillEleInfo(), and resetHistograms().

TH1F* ZeeCalibration::h_eleEffPhi[2] [private]

Definition at line 225 of file ZeeCalibration.h.

TH1F* ZeeCalibration::h_eleEffPhi_[2] [private]

Definition at line 250 of file ZeeCalibration.h.

Referenced by bookHistograms(), endOfJob(), fillEleInfo(), and resetHistograms().

TH1F* ZeeCalibration::h_eleEffPt[2] [private]

Definition at line 226 of file ZeeCalibration.h.

TH1F* ZeeCalibration::h_eleEffPt_[2] [private]

Definition at line 251 of file ZeeCalibration.h.

Referenced by bookHistograms(), endOfJob(), fillEleInfo(), and resetHistograms().

TH1F* ZeeCalibration::h_ESCcorrEtrue_[25] [private]

Definition at line 255 of file ZeeCalibration.h.

Referenced by bookHistograms(), endOfJob(), and fillEleInfo().

TH2F* ZeeCalibration::h_ESCcorrEtrueVsEta_[25] [private]

Definition at line 256 of file ZeeCalibration.h.

Referenced by bookHistograms(), endOfJob(), and fillEleInfo().

TH1F* ZeeCalibration::h_ESCEtrue_[25] [private]

Definition at line 252 of file ZeeCalibration.h.

Referenced by bookHistograms(), endOfJob(), and fillEleInfo().

TH2F* ZeeCalibration::h_ESCEtrueVsEta_[25] [private]

Definition at line 253 of file ZeeCalibration.h.

Referenced by bookHistograms(), endOfJob(), and fillEleInfo().

std::vector<unsigned int> ZeeCalibration::hlAccept_ [private]

Definition at line 358 of file ZeeCalibration.h.

std::vector<unsigned int> ZeeCalibration::hlErrors_ [private]

Definition at line 359 of file ZeeCalibration.h.

std::vector<std::string> ZeeCalibration::hlNames_ [private]

Definition at line 361 of file ZeeCalibration.h.

Int_t ZeeCalibration::hltCount [private]

Definition at line 368 of file ZeeCalibration.h.

Referenced by duringLoop().

Int_t ZeeCalibration::hltNamesLen [private]

Definition at line 370 of file ZeeCalibration.h.

edm::InputTag ZeeCalibration::hlTriggerResults_ [private]

Definition at line 348 of file ZeeCalibration.h.

Referenced by duringLoop(), and ZeeCalibration().

std::vector<unsigned int> ZeeCalibration::hlWasRun_ [private]

Definition at line 357 of file ZeeCalibration.h.

boost::shared_ptr<EcalIntercalibConstants> ZeeCalibration::ical [private]

Definition at line 197 of file ZeeCalibration.h.

Referenced by beginOfJob(), endOfJob(), endOfLoop(), and produceEcalIntercalibConstants().

bool ZeeCalibration::init_ [private]

Definition at line 362 of file ZeeCalibration.h.

Referenced by beginOfJob().

float ZeeCalibration::initCalibCoeff[nMaxChannels] [private]

Definition at line 195 of file ZeeCalibration.h.

Referenced by beginOfJob(), endOfJob(), and endOfLoop().

double ZeeCalibration::loopArray[50] [private]

Definition at line 324 of file ZeeCalibration.h.

Referenced by endOfJob(), endOfLoop(), and ZeeCalibration().

int ZeeCalibration::loopFlag_ [private]

Definition at line 190 of file ZeeCalibration.h.

Referenced by beginOfJob(), duringLoop(), endOfLoop(), and fillEleInfo().

double ZeeCalibration::mass [private]

Definition at line 183 of file ZeeCalibration.h.

Referenced by duringLoop().

float ZeeCalibration::mass4tree [private]

Definition at line 185 of file ZeeCalibration.h.

Referenced by duringLoop(), and ZeeCalibration().

float ZeeCalibration::massDiff4tree [private]

Definition at line 186 of file ZeeCalibration.h.

Referenced by duringLoop(), and ZeeCalibration().

double ZeeCalibration::maxInvMassCut_ [private]

Definition at line 182 of file ZeeCalibration.h.

Referenced by duringLoop(), and ZeeCalibration().

std::string ZeeCalibration::mcProducer_ [private]

Definition at line 162 of file ZeeCalibration.h.

Referenced by duringLoop(), and ZeeCalibration().

Int_t ZeeCalibration::MCZBB [private]

Definition at line 314 of file ZeeCalibration.h.

Referenced by duringLoop(), and printStatistics().

Int_t ZeeCalibration::MCZEB [private]

Definition at line 314 of file ZeeCalibration.h.

Referenced by duringLoop(), and printStatistics().

Int_t ZeeCalibration::MCZEE [private]

Definition at line 314 of file ZeeCalibration.h.

Referenced by duringLoop(), and printStatistics().

double ZeeCalibration::minInvMassCut_ [private]

Definition at line 181 of file ZeeCalibration.h.

Referenced by duringLoop(), and ZeeCalibration().

TTree* ZeeCalibration::myTree [private]

Definition at line 148 of file ZeeCalibration.h.

Referenced by duringLoop(), endOfJob(), and ZeeCalibration().

ZeePlots* ZeeCalibration::myZeePlots_ [private]

Definition at line 201 of file ZeeCalibration.h.

Referenced by beginOfJob(), bookHistograms(), duringLoop(), and endOfJob().

ZeeRescaleFactorPlots* ZeeCalibration::myZeeRescaleFactorPlots_ [private]

Definition at line 202 of file ZeeCalibration.h.

unsigned int ZeeCalibration::nAccept_ [private]

Definition at line 354 of file ZeeCalibration.h.

unsigned int ZeeCalibration::nErrors_ [private]

Definition at line 355 of file ZeeCalibration.h.

unsigned int ZeeCalibration::nEvents_ [private]

Definition at line 351 of file ZeeCalibration.h.

Int_t ZeeCalibration::NEVT [private]

Definition at line 314 of file ZeeCalibration.h.

Referenced by duringLoop(), and printStatistics().

float ZeeCalibration::NewCalibCoeff[nMaxChannels] [private]

Definition at line 193 of file ZeeCalibration.h.

Referenced by endOfLoop().

unsigned int ZeeCalibration::nWasRun_ [private]

Definition at line 353 of file ZeeCalibration.h.

TFile* ZeeCalibration::outputFile_ [private]

Definition at line 316 of file ZeeCalibration.h.

Referenced by beginOfJob(), endOfJob(), endOfLoop(), and ZeeCalibration().

std::string ZeeCalibration::outputFileName_ [private]

Definition at line 150 of file ZeeCalibration.h.

Referenced by ZeeCalibration().

int ZeeCalibration::read_events [private]

Definition at line 188 of file ZeeCalibration.h.

Referenced by beginOfJob(), and duringLoop().

std::string ZeeCalibration::RecalibBarrelHits_ [private]

Definition at line 168 of file ZeeCalibration.h.

std::string ZeeCalibration::rechitCollection_ [private]

Definition at line 153 of file ZeeCalibration.h.

Referenced by duringLoop(), and ZeeCalibration().

std::string ZeeCalibration::rechitProducer_ [private]

Definition at line 152 of file ZeeCalibration.h.

Referenced by duringLoop(), and ZeeCalibration().

std::string ZeeCalibration::scCollection_ [private]

Definition at line 157 of file ZeeCalibration.h.

Referenced by duringLoop(), and ZeeCalibration().

std::string ZeeCalibration::scIslandCollection_ [private]

Definition at line 160 of file ZeeCalibration.h.

Referenced by duringLoop(), and ZeeCalibration().

std::string ZeeCalibration::scIslandProducer_ [private]

Definition at line 159 of file ZeeCalibration.h.

Referenced by duringLoop(), and ZeeCalibration().

std::string ZeeCalibration::scProducer_ [private]

Definition at line 156 of file ZeeCalibration.h.

Referenced by duringLoop(), and ZeeCalibration().

int ZeeCalibration::SHOWER_ELECTRONS_IN_BARREL [private]

Definition at line 341 of file ZeeCalibration.h.

Referenced by duringLoop(), printStatistics(), and resetVariables().

int ZeeCalibration::SHOWER_ELECTRONS_IN_ENDCAP [private]

Definition at line 342 of file ZeeCalibration.h.

Referenced by duringLoop(), printStatistics(), and resetVariables().

double ZeeCalibration::sigmaArray[50] [private]

Definition at line 325 of file ZeeCalibration.h.

Referenced by endOfJob(), endOfLoop(), and ZeeCalibration().

double ZeeCalibration::sigmaErrorArray[50] [private]

Definition at line 326 of file ZeeCalibration.h.

Referenced by endOfJob(), endOfLoop(), and ZeeCalibration().

int ZeeCalibration::SILVER_ELECTRONS_IN_BARREL [private]

Definition at line 338 of file ZeeCalibration.h.

Referenced by duringLoop(), printStatistics(), and resetVariables().

int ZeeCalibration::SILVER_ELECTRONS_IN_ENDCAP [private]

Definition at line 339 of file ZeeCalibration.h.

Referenced by duringLoop(), printStatistics(), and resetVariables().

ZIterativeAlgorithmWithFit* ZeeCalibration::theAlgorithm_ [private]

Definition at line 199 of file ZeeCalibration.h.

Referenced by beginOfJob(), duringLoop(), endOfJob(), endOfLoop(), startingNewLoop(), and ZeeCalibration().

unsigned int ZeeCalibration::theMaxLoops [private]

Definition at line 318 of file ZeeCalibration.h.

Referenced by endOfJob(), endOfLoop(), and ZeeCalibration().

edm::ParameterSet ZeeCalibration::theParameterSet [private]

Definition at line 206 of file ZeeCalibration.h.

Referenced by ZeeCalibration().

int ZeeCalibration::TOTAL_ELECTRONS_IN_BARREL [private]

Definition at line 332 of file ZeeCalibration.h.

Referenced by duringLoop(), printStatistics(), and resetVariables().

int ZeeCalibration::TOTAL_ELECTRONS_IN_ENDCAP [private]

Definition at line 333 of file ZeeCalibration.h.

Referenced by duringLoop(), printStatistics(), and resetVariables().

Int_t ZeeCalibration::triggerCount [private]

Definition at line 364 of file ZeeCalibration.h.

edm::TriggerNames ZeeCalibration::triggerNames_ [private]

Definition at line 349 of file ZeeCalibration.h.

bool ZeeCalibration::wantEtaCorrection_ [private]

Definition at line 320 of file ZeeCalibration.h.

Referenced by duringLoop(), and ZeeCalibration().

ZeeCalibration Class Reference

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation


Public Member Functions
virtual void	beginOfJob (const edm::EventSetup &)
	Called at beginning of job.
virtual Status	duringLoop (const edm::Event &, const edm::EventSetup &)
	Called at each event.
virtual void	endOfJob ()
	Called at end of job.
virtual Status	endOfLoop (const edm::EventSetup &, unsigned int iLoop)
	Called at end of loop.
virtual void	produce (edm::Event &, const edm::EventSetup &)
	Dummy implementation (job done in duringLoop).
virtual boost::shared_ptr < EcalIntercalibConstants >	produceEcalIntercalibConstants (const EcalIntercalibConstantsRcd &iRecord)
	Produce Ecal interCalibrations.
virtual void	startingNewLoop (unsigned int iLoop)
	Called at beginning of loop.
	ZeeCalibration (const edm::ParameterSet &iConfig)
	Constructor.
	~ZeeCalibration ()
	Destructor.
Private Member Functions
void	bookHistograms ()
float	computeCoefficientDistanceAtIteration (float v1[250], float v2[250], int size)
float	EvalDPhi (float Phi, float Phi_ref)
float	EvalDR (float Eta, float Eta_ref, float Phi, float Phi_ref)
double	fEtaBarrelBad (double scEta) const
double	fEtaBarrelGood (double scEta) const
double	fEtaEndcapBad (double scEta) const
double	fEtaEndcapGood (double scEta) const
void	fillEleInfo (std::vector< HepMC::GenParticle * > &a, std::map< HepMC::GenParticle , const reco::PixelMatchGsfElectron > &b)
void	fillMCInfo (HepMC::GenParticle *mcele)
void	fillMCmap (const std::vector< const reco::PixelMatchGsfElectron * > electronCollection, const std::vector< HepMC::GenParticle > &mcEle, std::map< HepMC::GenParticle , const reco::PixelMatchGsfElectron > &myMCmap)
double	getEtaCorrection (const reco::PixelMatchGsfElectron *)
std::pair< DetId, double >	getHottestDetId (std::vector< DetId > mySCRecHits, const EBRecHitCollection ebhits, const EERecHitCollection eehits)
void	printStatistics ()
void	resetHistograms ()
void	resetVariables ()
int	ringNumberCorrector (int k)
bool	xtalIsOnModuleBorder (EBDetId myEBDetId)
Private Attributes
char	aHLTNames [6000]
bool	aHLTResults [200]
TString	aNames [200]
char	aTriggerNames [200][30]
bool	aTriggerResults [200]
int	BARREL_ELECTRONS_AFTER_BORDER_CUT
int	BARREL_ELECTRONS_BEFORE_BORDER_CUT
std::string	barrelfile_
Int_t	BBZN
Int_t	BBZN_gg
Int_t	BBZN_t0
Int_t	BBZN_tt
float	calibCoeff [nMaxChannels]
float	calibCoeffError [nMaxChannels]
std::string	calibMode_
double	coefficientDistanceAtIteration [50]
int	CRACK_ELECTRONS_IN_BARREL
int	CRACK_ELECTRONS_IN_ENDCAP
Int_t	EBZN
Int_t	EBZN_gg
Int_t	EBZN_t0
Int_t	EBZN_tt
Int_t	EEZN
Int_t	EEZN_gg
Int_t	EEZN_t0
Int_t	EEZN_tt
std::string	electronCollection_
std::string	electronProducer_
unsigned int	electronSelection_
std::string	endcapfile_
std::string	erechitCollection_
std::string	erechitProducer_
unsigned int	etaBins_
double	etaMax_
double	etaMin_
unsigned int	etBins_
double	etMax_
double	etMin_
int	GOLDEN_ELECTRONS_IN_BARREL
int	GOLDEN_ELECTRONS_IN_ENDCAP
TH1F *	h1_borderElectronClassification_
TH1F *	h1_eleClasses_
TH1F *	h1_electronCosTheta_SC_
TH1F *	h1_electronCosTheta_SC_TK_
TH1F *	h1_electronCosTheta_TK_
TH1F *	h1_eleERecoOverEtrue_
TH1F *	h1_eleEtaResol_
TH1F *	h1_elePhiResol_
TH1F *	h1_eventsAfterBorderSelection_
TH1F *	h1_eventsAfterEWKSelection_
TH1F *	h1_eventsBeforeBorderSelection_
TH1F *	h1_eventsBeforeEWKSelection_
TH1F *	h1_mc_
TH1F *	h1_mcEB_
TH1F *	h1_mcEBParz_ [25]
TH1F *	h1_mcEE_
TH1F *	h1_mcEEParz_ [25]
TH1F *	h1_mcParz_ [25]
TH1F *	h1_nEleReco_
TH1F *	h1_occupancy_
TH1F *	h1_occupancyBarrel_
TH1F *	h1_occupancyEndcap_
TH1F *	h1_occupancyVsEta_
TH1F *	h1_occupancyVsEtaCrack_
TH1F *	h1_occupancyVsEtaGold_
TH1F *	h1_occupancyVsEtaShower_
TH1F *	h1_occupancyVsEtaSilver_
TH1F *	h1_preshowerOverSC_
TH1F *	h1_reco_ZMass_
TH1F *	h1_reco_ZMassBad_
TH1F *	h1_reco_ZMassCorr_
TH1F *	h1_reco_ZMassCorrBB_
TH1F *	h1_reco_ZMassCorrEE_
TH1F *	h1_reco_ZMassGood_
TH1F *	h1_RMin_
TH1F *	h1_RMinZ_
TH1F *	h1_seedOverSC_
TH1F *	h1_weightSumMeanBarrel_
TH1F *	h1_weightSumMeanEndcap_
TH1F *	h1_ZCandMult_
TH1F *	h1_zEtaResol_
TH1F *	h1_zMassResol_
TH1F *	h1_zPhiResol_
TH2F *	h2_chi2_ [25]
TH2F *	h2_coeffVsEta_
TH2F *	h2_coeffVsEtaGrouped_
TH2F *	h2_coeffVsLoop_
TH2F *	h2_fEtaBarrelBad_
TH2F *	h2_fEtaBarrelGood_
TH2F *	h2_fEtaEndcapBad_
TH2F *	h2_fEtaEndcapGood_
TH2F *	h2_iterations_ [25]
TH2F *	h2_miscalRecal_
TH2F *	h2_miscalRecalEB_
TH2F *	h2_miscalRecalEE_
TH2F *	h2_residualSigma_
TH2F *	h2_xtalMiscalibCoeffBarrel_
TH2F *	h2_xtalMiscalibCoeffEndcapMinus_
TH2F *	h2_xtalMiscalibCoeffEndcapPlus_
TH2F *	h2_xtalRecalibCoeffBarrel_ [25]
TH2F *	h2_xtalRecalibCoeffEndcapMinus_ [25]
TH2F *	h2_xtalRecalibCoeffEndcapPlus_ [25]
TH2F *	h2_zMassDiffVsLoop_
TH2F *	h2_zMassVsLoop_
TH2F *	h2_zWidthVsLoop_
TH1F *	h_eleEffEta [2]
TH1F *	h_eleEffEta_ [2]
TH1F *	h_eleEffPhi [2]
TH1F *	h_eleEffPhi_ [2]
TH1F *	h_eleEffPt [2]
TH1F *	h_eleEffPt_ [2]
TH1F *	h_ESCcorrEtrue_ [25]
TH2F *	h_ESCcorrEtrueVsEta_ [25]
TH1F *	h_ESCEtrue_ [25]
TH2F *	h_ESCEtrueVsEta_ [25]
std::vector< unsigned int >	hlAccept_
std::vector< unsigned int >	hlErrors_
std::vector< std::string >	hlNames_
Int_t	hltCount
Int_t	hltNamesLen
edm::InputTag	hlTriggerResults_
std::vector< unsigned int >	hlWasRun_
boost::shared_ptr < EcalIntercalibConstants >	ical
bool	init_
float	initCalibCoeff [nMaxChannels]
double	loopArray [50]
int	loopFlag_
double	mass
float	mass4tree
float	massDiff4tree
double	maxInvMassCut_
std::string	mcProducer_
Int_t	MCZBB
Int_t	MCZEB
Int_t	MCZEE
double	minInvMassCut_
TTree *	myTree
ZeePlots *	myZeePlots_
ZeeRescaleFactorPlots *	myZeeRescaleFactorPlots_
unsigned int	nAccept_
unsigned int	nErrors_
unsigned int	nEvents_
Int_t	NEVT
float	NewCalibCoeff [nMaxChannels]
unsigned int	nWasRun_
TFile *	outputFile_
std::string	outputFileName_
int	read_events
std::string	RecalibBarrelHits_
std::string	rechitCollection_
std::string	rechitProducer_
std::string	scCollection_
std::string	scIslandCollection_
std::string	scIslandProducer_
std::string	scProducer_
int	SHOWER_ELECTRONS_IN_BARREL
int	SHOWER_ELECTRONS_IN_ENDCAP
double	sigmaArray [50]
double	sigmaErrorArray [50]
int	SILVER_ELECTRONS_IN_BARREL
int	SILVER_ELECTRONS_IN_ENDCAP
ZIterativeAlgorithmWithFit *	theAlgorithm_
unsigned int	theMaxLoops
edm::ParameterSet	theParameterSet
int	TOTAL_ELECTRONS_IN_BARREL
int	TOTAL_ELECTRONS_IN_ENDCAP
Int_t	triggerCount
edm::TriggerNames	triggerNames_
bool	wantEtaCorrection_