ZeeCalibration.h

Go to the documentation of this file.

#ifndef CALIBRATION_ECALCALIBALGOS_ZEECALIBRATION
#define CALIBRATION_ECALCALIBALGOS_ZEECALIBRATION

// -*- C++ -*-
//
// Package:    ZeeCalibration
// Class:      ZeeCalibration
//
//
//
//

// system include files
#include <memory>
#include <vector>
#include <map>
#include <string>

// user include files
#include "FWCore/Framework/interface/LooperFactory.h"
#include "FWCore/Framework/interface/ESProducerLooper.h"
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"

#include "Calibration/Tools/interface/ZIterativeAlgorithmWithFit.h"
#include "Calibration/Tools/interface/CalibElectron.h"

#include "Calibration/EcalCalibAlgos/interface/ZeePlots.h"
#include "Calibration/EcalCalibAlgos/interface/ZeeRescaleFactorPlots.h"

#include "CondFormats/EcalObjects/interface/EcalIntercalibConstants.h"
#include "CondFormats/DataRecord/interface/EcalIntercalibConstantsRcd.h"

#include "DataFormats/Common/interface/TriggerResults.h"
#include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
#include "DataFormats/DetId/interface/DetId.h"

#include "Geometry/CaloGeometry/interface/CaloGeometry.h"
#include "Geometry/Records/interface/CaloGeometryRecord.h"

#include "TTree.h"
#include "TFile.h"
#include "TGraph.h"
#include "TGraphErrors.h"
#include "TH1.h"
#include "TH2.h"

#include "SimDataFormats/GeneratorProducts/interface/HepMCProduct.h"
#include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
#include "DataFormats/EgammaCandidates/interface/ElectronFwd.h"
#include "DataFormats/EgammaCandidates/interface/Electron.h"
#include "DataFormats/EgammaCandidates/interface/GsfElectron.h"
#include "DataFormats/EgammaCandidates/interface/GsfElectronFwd.h"

// class declaration
//

class ZeeCalibration : public edm::ESProducerLooper {
public:
  ZeeCalibration(const edm::ParameterSet& iConfig);

  ~ZeeCalibration() override;

  virtual void produce(edm::Event&, const edm::EventSetup&) {}

  void beginOfJob() override;

  void endOfJob() override;

  void startingNewLoop(unsigned int iLoop) override;

  Status endOfLoop(const edm::EventSetup&, unsigned int iLoop) override;

  Status duringLoop(const edm::Event&, const edm::EventSetup&) override;

  virtual std::shared_ptr<EcalIntercalibConstants> produceEcalIntercalibConstants(
      const EcalIntercalibConstantsRcd& iRecord);

private:
  /*   ElectronEnergyCorrector myCorrector; */
  /*   ElectronClassification myClassificator; */

  double fEtaBarrelBad(double scEta) const;
  double fEtaBarrelGood(double scEta) const;
  double fEtaEndcapBad(double scEta) const;
  double fEtaEndcapGood(double scEta) const;

  int ringNumberCorrector(int k);
  double getEtaCorrection(const reco::GsfElectron*);

  void fillEleInfo(std::vector<HepMC::GenParticle*>& a, std::map<HepMC::GenParticle*, const reco::GsfElectron*>& b);
  void fillMCInfo(HepMC::GenParticle* mcele);

  void fillMCmap(const std::vector<const reco::GsfElectron*>* electronCollection,
                 const std::vector<HepMC::GenParticle*>& mcEle,
                 std::map<HepMC::GenParticle*, const reco::GsfElectron*>& myMCmap);
  //  void fillMCmap(const reco::ElectronCollection* electronCollection, const std::vector<HepMC::GenParticle*>& mcEle,std::map<HepMC::GenParticle*,const reco::Electron*>& myMCmap);

  float EvalDPhi(float Phi, float Phi_ref);
  float EvalDR(float Eta, float Eta_ref, float Phi, float Phi_ref);

  void bookHistograms();

  void resetVariables();

  void resetHistograms();

  void printStatistics();

  std::pair<DetId, double> getHottestDetId(const std::vector<std::pair<DetId, float> >& mySCRecHits,
                                           const EBRecHitCollection* ebhits,
                                           const EERecHitCollection* eehits);

  bool xtalIsOnModuleBorder(EBDetId myEBDetId);

  float computeCoefficientDistanceAtIteration(float v1[250], float v2[250], int size);

  //  float Calculate_SigmaEtaEta(const reco::SuperCluster &passedCluster);

  // ----------member data ---------------------------

  TTree* myTree;

  std::string outputFileName_;

  const edm::InputTag hlTriggerResults_;

  const std::string mcProducer_;
  const std::string rechitProducer_;
  const std::string rechitCollection_;
  const std::string erechitProducer_;
  const std::string erechitCollection_;
  const std::string scProducer_;
  const std::string scCollection_;

  const std::string scIslandProducer_;
  const std::string scIslandCollection_;

  const std::string electronProducer_;
  const std::string electronCollection_;

  std::string calibMode_;

  const edm::EDGetTokenT<edm::TriggerResults> trigResultsToken_;
  const edm::EDGetTokenT<edm::HepMCProduct> hepMCToken_;
  const edm::EDGetTokenT<EBRecHitCollection> ebRecHitToken_;
  const edm::EDGetTokenT<EERecHitCollection> eeRecHitToken_;
  const edm::EDGetTokenT<reco::SuperClusterCollection> scToken_;
  const edm::EDGetTokenT<reco::SuperClusterCollection> islandSCToken_;
  const edm::EDGetTokenT<reco::GsfElectronCollection> gsfElectronToken_;

  const edm::ESGetToken<CaloGeometry, CaloGeometryRecord> geometryToken_;

  unsigned int etaBins_;
  unsigned int etBins_;

  double etaMin_;
  double etMin_;
  double etaMax_;
  double etMax_;

  std::string barrelfile_;
  std::string endcapfile_;

  double minInvMassCut_;
  double maxInvMassCut_;
  double mass;

  float mass4tree;
  float massDiff4tree;

  int read_events;

  int loopFlag_;

  float calibCoeff[nMaxChannels];
  float NewCalibCoeff[nMaxChannels];
  float calibCoeffError[nMaxChannels];
  float initCalibCoeff[nMaxChannels];

  std::shared_ptr<EcalIntercalibConstants> ical;

  ZIterativeAlgorithmWithFit* theAlgorithm_;

  ZeePlots* myZeePlots_;
  ZeeRescaleFactorPlots* myZeeRescaleFactorPlots_;

  // steering parameters

  edm::ParameterSet theParameterSet;

  //  TGraph* graph;

  TH1F* h1_eventsBeforeEWKSelection_;
  TH1F* h1_eventsAfterEWKSelection_;

  TH1F* h1_eventsBeforeBorderSelection_;
  TH1F* h1_eventsAfterBorderSelection_;

  TH2F* h2_fEtaBarrelGood_;
  TH2F* h2_fEtaBarrelBad_;
  TH2F* h2_fEtaEndcapGood_;
  TH2F* h2_fEtaEndcapBad_;
  TH1F* h1_nEleReco_;
  TH1F* h1_eleClasses_;

  TH1F* h_eleEffEta[2];
  TH1F* h_eleEffPhi[2];
  TH1F* h_eleEffPt[2];

  TH1F* h1_seedOverSC_;
  TH1F* h1_preshowerOverSC_;

  TH1F* h1_zMassResol_;
  TH1F* h1_zEtaResol_;
  TH1F* h1_zPhiResol_;
  TH1F* h1_reco_ZMass_;

  TH1F* h1_reco_ZMassCorr_;
  TH1F* h1_reco_ZMassCorrBB_;
  TH1F* h1_reco_ZMassCorrEE_;
  TH1F* h1_reco_ZMassGood_;
  TH1F* h1_reco_ZMassBad_;
  TH1F* h1_ZCandMult_;
  TH1F* h1_RMin_;
  TH1F* h1_RMinZ_;
  TH1F* h1_eleERecoOverEtrue_;

  TH1F* h1_eleEtaResol_;
  TH1F* h1_elePhiResol_;

  TH1F* h_eleEffEta_[2];
  TH1F* h_eleEffPhi_[2];
  TH1F* h_eleEffPt_[2];
  TH1F* h_ESCEtrue_[25];
  TH2F* h_ESCEtrueVsEta_[25];

  TH1F* h_ESCcorrEtrue_[25];
  TH2F* h_ESCcorrEtrueVsEta_[25];

  TH2F* h2_coeffVsEta_;
  TH2F* h2_coeffVsEtaGrouped_;
  TH2F* h2_zMassVsLoop_;
  TH2F* h2_zMassDiffVsLoop_;
  TH2F* h2_zWidthVsLoop_;
  TH2F* h2_coeffVsLoop_;

  TH2F* h2_miscalRecal_;
  //  TH2F* h2_miscalRecalParz_[25];
  TH1F* h1_mc_;
  TH1F* h1_mcParz_[25];
  /*
  TH1F* h_DiffZMassDistr_[25];  
  TH1F* h_ZMassDistr_[25];  
  */
  TH2F* h2_residualSigma_;
  TH2F* h2_miscalRecalEB_;
  //TH2F* h2_miscalRecalEBParz_[25];
  TH1F* h1_mcEB_;
  TH1F* h1_mcEBParz_[25];
  TH2F* h2_miscalRecalEE_;
  //TH2F* h2_miscalRecalEEParz_[25];
  TH1F* h1_mcEE_;
  TH1F* h1_mcEEParz_[25];

  TH2F* h2_chi2_[25];
  TH2F* h2_iterations_[25];

  TH2F* h2_xtalRecalibCoeffBarrel_[25];
  TH2F* h2_xtalRecalibCoeffEndcapMinus_[25];
  TH2F* h2_xtalRecalibCoeffEndcapPlus_[25];

  TH2F* h2_xtalMiscalibCoeffBarrel_;
  TH2F* h2_xtalMiscalibCoeffEndcapMinus_;
  TH2F* h2_xtalMiscalibCoeffEndcapPlus_;

  TH1F* h1_weightSumMeanBarrel_;
  TH1F* h1_weightSumMeanEndcap_;

  TH1F* h1_occupancyVsEta_;
  TH1F* h1_occupancyVsEtaGold_;
  TH1F* h1_occupancyVsEtaSilver_;
  TH1F* h1_occupancyVsEtaCrack_;
  TH1F* h1_occupancyVsEtaShower_;
  TH1F* h1_occupancy_;
  TH1F* h1_occupancyBarrel_;
  TH1F* h1_occupancyEndcap_;

  TH1F* h1_electronCosTheta_TK_;
  TH1F* h1_electronCosTheta_SC_;
  TH1F* h1_electronCosTheta_SC_TK_;

  TH1F* h1_borderElectronClassification_;

  Int_t BBZN, EBZN, EEZN, BBZN_gg, EBZN_gg, EEZN_gg, BBZN_tt, EBZN_tt, EEZN_tt, BBZN_t0, EBZN_t0, EEZN_t0;
  Int_t NEVT, MCZBB, MCZEB, MCZEE;

  TFile* outputFile_;

  unsigned int theMaxLoops;  // Number of loops to loop

  bool wantEtaCorrection_;

  unsigned int electronSelection_;

  double loopArray[50];
  double sigmaArray[50];
  double sigmaErrorArray[50];
  double coefficientDistanceAtIteration[50];

  int BARREL_ELECTRONS_BEFORE_BORDER_CUT;
  int BARREL_ELECTRONS_AFTER_BORDER_CUT;

  int TOTAL_ELECTRONS_IN_BARREL;
  int TOTAL_ELECTRONS_IN_ENDCAP;

  int GOLDEN_ELECTRONS_IN_BARREL;
  int GOLDEN_ELECTRONS_IN_ENDCAP;

  int SILVER_ELECTRONS_IN_BARREL;
  int SILVER_ELECTRONS_IN_ENDCAP;

  int SHOWER_ELECTRONS_IN_BARREL;
  int SHOWER_ELECTRONS_IN_ENDCAP;

  int CRACK_ELECTRONS_IN_BARREL;
  int CRACK_ELECTRONS_IN_ENDCAP;

  unsigned int nEvents_;  // number of events processed

  unsigned int nWasRun_;  // # where at least one HLT was run
  unsigned int nAccept_;  // # of accepted events
  unsigned int nErrors_;  // # where at least one HLT had error

  std::vector<unsigned int> hlWasRun_;  // # where HLT[i] was run
  std::vector<unsigned int> hlAccept_;  // # of events accepted by HLT[i]
  std::vector<unsigned int> hlErrors_;  // # of events with error in HLT[i]

  std::vector<std::string> hlNames_;  // name of each HLT algorithm
  bool init_;                         // vectors initialised or not

  Int_t triggerCount;
  char aTriggerNames[200][30];
  bool aTriggerResults[200];

  Int_t hltCount;
  char aHLTNames[6000];
  Int_t hltNamesLen;
  TString aNames[200];
  bool aHLTResults[200];

  bool isfirstcall_;
};
#endif