PhiSymmetryCalibration.cc

Go to the documentation of this file.

#include "Calibration/EcalCalibAlgos/interface/PhiSymmetryCalibration.h"

// System include files
#include <memory>

// Framework
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"

#include "DataFormats/EcalDetId/interface/EBDetId.h"
#include "DataFormats/EcalDetId/interface/EEDetId.h"
#include "CondFormats/EcalObjects/interface/EcalIntercalibErrors.h"
#include "CondTools/Ecal/interface/EcalIntercalibConstantsXMLTranslator.h"
#include "FWCore/Framework/interface/LuminosityBlock.h"

// Geometry
#include "Geometry/CaloGeometry/interface/CaloSubdetectorGeometry.h"
#include "Geometry/CaloGeometry/interface/CaloCellGeometry.h"

//Channel status
#include "CondFormats/EcalObjects/interface/EcalChannelStatusCode.h"

#include "FWCore/Framework/interface/Run.h"

using namespace std;
#include <fstream>
#include <iostream>
#include "TH2F.h"
#include "TFile.h"
#include "TTree.h"
#include "TH1F.h"
#include "TF1.h"
#include "TGraph.h"
#include "TCanvas.h"

const float PhiSymmetryCalibration::kMiscalRangeEB = .05;
const float PhiSymmetryCalibration::kMiscalRangeEE = .10;

//_____________________________________________________________________________
// Class constructor

PhiSymmetryCalibration::PhiSymmetryCalibration(const edm::ParameterSet& iConfig)
    : ecalHitsProducer_(iConfig.getParameter<std::string>("ecalRecHitsProducer")),
      barrelHits_(iConfig.getParameter<std::string>("barrelHitCollection")),
      endcapHits_(iConfig.getParameter<std::string>("endcapHitCollection")),
      ebRecHitToken_(consumes<EBRecHitCollection>(edm::InputTag(ecalHitsProducer_, barrelHits_))),
      eeRecHitToken_(consumes<EERecHitCollection>(edm::InputTag(ecalHitsProducer_, endcapHits_))),
      channelStatusToken_(esConsumes()),
      geometryToken_(esConsumes()),
      eCut_barl_(iConfig.getParameter<double>("eCut_barrel")),
      ap_(iConfig.getParameter<double>("ap")),
      b_(iConfig.getParameter<double>("b")),
      eventSet_(iConfig.getParameter<int>("eventSet")),
      statusThreshold_(iConfig.getUntrackedParameter<int>("statusThreshold", 3)),
      reiteration_(iConfig.getUntrackedParameter<bool>("reiteration", false)),
      oldcalibfile_(iConfig.getUntrackedParameter<std::string>("oldcalibfile", "EcalintercalibConstants.xml")) {
  isfirstpass_ = true;

  et_spectrum_b_histos.resize(kBarlRings);
  e_spectrum_b_histos.resize(kBarlRings);
  et_spectrum_e_histos.resize(kEndcEtaRings);
  e_spectrum_e_histos.resize(kEndcEtaRings);

  spectra = true;

  nevents_ = 0;
  eventsinrun_ = 0;
  eventsinlb_ = 0;

  // because ROOT draws something
  usesResource();
}

//_____________________________________________________________________________
// Close files, etc.

PhiSymmetryCalibration::~PhiSymmetryCalibration() {
  for (Int_t i = 0; i < kBarlRings; i++) {
    delete et_spectrum_b_histos[i];
    delete e_spectrum_b_histos[i];
  }
  for (Int_t i = 0; i < kEndcEtaRings; i++) {
    delete et_spectrum_e_histos[i];
    delete e_spectrum_e_histos[i];
  }
}

//_____________________________________________________________________________
// Initialize algorithm

void PhiSymmetryCalibration::beginJob() {
  // initialize arrays
  for (int sign = 0; sign < kSides; sign++) {
    for (int ieta = 0; ieta < kBarlRings; ieta++) {
      for (int iphi = 0; iphi < kBarlWedges; iphi++) {
        etsum_barl_[ieta][iphi][sign] = 0.;
        nhits_barl_[ieta][iphi][sign] = 0;
      }
    }
    for (int ix = 0; ix < kEndcWedgesX; ix++) {
      for (int iy = 0; iy < kEndcWedgesY; iy++) {
        etsum_endc_[ix][iy][sign] = 0.;
        nhits_endc_[ix][iy][sign] = 0;
      }
    }
  }

  for (int imiscal = 0; imiscal < kNMiscalBinsEB; imiscal++) {
    miscalEB_[imiscal] = (1 - kMiscalRangeEB) + float(imiscal) * (2 * kMiscalRangeEB / (kNMiscalBinsEB - 1));
    for (int ieta = 0; ieta < kBarlRings; ieta++)
      etsum_barl_miscal_[imiscal][ieta] = 0.;
  }

  for (int imiscal = 0; imiscal < kNMiscalBinsEE; imiscal++) {
    miscalEE_[imiscal] = (1 - kMiscalRangeEE) + float(imiscal) * (2 * kMiscalRangeEE / (kNMiscalBinsEE - 1));
    for (int ring = 0; ring < kEndcEtaRings; ring++)
      etsum_endc_miscal_[imiscal][ring] = 0.;
  }

  // start spectra stuff
  if (eventSet_ != 1)
    spectra = false;

  if (spectra) {
    ostringstream t;
    for (Int_t i = 0; i < kBarlRings; i++) {
      t << "et_spectrum_b_" << i + 1;
      et_spectrum_b_histos[i] = new TH1F(t.str().c_str(), ";E_{T} [MeV]", 50, 0., 500.);
      t.str("");

      t << "e_spectrum_b_" << i + 1;
      e_spectrum_b_histos[i] = new TH1F(t.str().c_str(), ";E [MeV]", 50, 0., 500.);
      t.str("");
    }
    for (Int_t i = 0; i < kEndcEtaRings; i++) {
      t << "et_spectrum_e_" << i + 1;
      et_spectrum_e_histos[i] = new TH1F(t.str().c_str(), ";E_{T} [MeV]", 75, 0., 1500.);
      t.str("");

      t << "e_spectrum_e_" << i + 1;
      e_spectrum_e_histos[i] = new TH1F(t.str().c_str(), ";E [MeV]", 75, 0., 1500.);
      t.str("");
    }
  }
  // end spectra stuff
}

//_____________________________________________________________________________
// Terminate algorithm

void PhiSymmetryCalibration::endJob() {
  edm::LogInfo("Calibration") << "[PhiSymmetryCalibration] At end of job";

  // start spectra stuff
  if (spectra) {
    TFile f("Espectra_plus.root", "recreate");

    for (int i = 0; i < kBarlRings; i++) {
      et_spectrum_b_histos[i]->Write();
      e_spectrum_b_histos[i]->Write();
    }

    for (int i = 0; i < kEndcEtaRings; i++) {
      et_spectrum_e_histos[i]->Write();
      e_spectrum_e_histos[i]->Write();
    }

    f.Close();
  }

  if (eventSet_ == 1) {
    // calculate factors to convert from fractional deviation of ET sum from
    // the mean to the estimate of the miscalibration factor
    getKfactors();

    std::ofstream k_barl_out("k_barl.dat", ios::out);
    for (int ieta = 0; ieta < kBarlRings; ieta++)
      k_barl_out << ieta << " " << k_barl_[ieta] << endl;
    k_barl_out.close();

    std::ofstream k_endc_out("k_endc.dat", ios::out);
    for (int ring = 0; ring < kEndcEtaRings; ring++)
      k_endc_out << ring << " " << k_endc_[ring] << endl;
    k_endc_out.close();
  }

  if (eventSet_ != 0) {
    // output ET sums

    stringstream etsum_file_barl;
    etsum_file_barl << "etsum_barl_" << eventSet_ << ".dat";

    std::ofstream etsum_barl_out(etsum_file_barl.str().c_str(), ios::out);

    for (int ieta = 0; ieta < kBarlRings; ieta++) {
      for (int iphi = 0; iphi < kBarlWedges; iphi++) {
        for (int sign = 0; sign < kSides; sign++) {
          etsum_barl_out << eventSet_ << " " << ieta << " " << iphi << " " << sign << " "
                         << etsum_barl_[ieta][iphi][sign] << " " << nhits_barl_[ieta][iphi][sign] << endl;
        }
      }
    }
    etsum_barl_out.close();

    stringstream etsum_file_endc;
    etsum_file_endc << "etsum_endc_" << eventSet_ << ".dat";

    std::ofstream etsum_endc_out(etsum_file_endc.str().c_str(), ios::out);
    for (int ix = 0; ix < kEndcWedgesX; ix++) {
      for (int iy = 0; iy < kEndcWedgesY; iy++) {
        int ring = e_.endcapRing_[ix][iy];
        if (ring != -1) {
          for (int sign = 0; sign < kSides; sign++) {
            etsum_endc_out << eventSet_ << " " << ix << " " << iy << " " << sign << " " << etsum_endc_[ix][iy][sign]
                           << " " << nhits_endc_[ix][iy][sign] << " " << e_.endcapRing_[ix][iy] << endl;
          }
        }
      }
    }
    etsum_endc_out.close();
  }
  cout << "Events processed " << nevents_ << endl;
}

//_____________________________________________________________________________
// Called at each event

void PhiSymmetryCalibration::analyze(const edm::Event& event, const edm::EventSetup& setup) {
  using namespace edm;
  using namespace std;

  if (isfirstpass_) {
    setUp(setup);
    isfirstpass_ = false;
  }

  Handle<EBRecHitCollection> barrelRecHitsHandle;
  Handle<EERecHitCollection> endcapRecHitsHandle;

  event.getByToken(ebRecHitToken_, barrelRecHitsHandle);
  if (!barrelRecHitsHandle.isValid()) {
    LogError("") << "[PhiSymmetryCalibration] Error! Can't get product!" << std::endl;
  }

  event.getByToken(ebRecHitToken_, endcapRecHitsHandle);
  if (!endcapRecHitsHandle.isValid()) {
    LogError("") << "[PhiSymmetryCalibration] Error! Can't get product!" << std::endl;
  }

  // get the ecal geometry
  const auto& geometry = setup.getData(geometryToken_);
  const auto* barrelGeometry = geometry.getSubdetectorGeometry(DetId::Ecal, EcalBarrel);
  const auto* endcapGeometry = geometry.getSubdetectorGeometry(DetId::Ecal, EcalEndcap);

  bool pass = false;
  // select interesting EcalRecHits (barrel)
  EBRecHitCollection::const_iterator itb;
  for (itb = barrelRecHitsHandle->begin(); itb != barrelRecHitsHandle->end(); itb++) {
    EBDetId hit = EBDetId(itb->id());
    float eta = barrelGeometry->getGeometry(hit)->getPosition().eta();
    float et = itb->energy() / cosh(eta);
    float e = itb->energy();

    // if iterating, correct by the previous calib constants found,
    // which are supplied in the form of correction
    if (reiteration_) {
      et = et * oldCalibs_[hit];
      e = e * oldCalibs_[hit];
    }

    float et_thr = eCut_barl_ / cosh(eta) + 1.;

    int sign = hit.ieta() > 0 ? 1 : 0;

    if (e > eCut_barl_ && et < et_thr && e_.goodCell_barl[abs(hit.ieta()) - 1][hit.iphi() - 1][sign]) {
      etsum_barl_[abs(hit.ieta()) - 1][hit.iphi() - 1][sign] += et;
      nhits_barl_[abs(hit.ieta()) - 1][hit.iphi() - 1][sign]++;
      pass = true;
    }  //if energy

    if (eventSet_ == 1) {
      // apply a miscalibration to all crystals and increment the
      // ET sum, combined for all crystals
      for (int imiscal = 0; imiscal < kNMiscalBinsEB; imiscal++) {
        if (miscalEB_[imiscal] * e > eCut_barl_ && miscalEB_[imiscal] * et < et_thr &&
            e_.goodCell_barl[abs(hit.ieta()) - 1][hit.iphi() - 1][sign]) {
          etsum_barl_miscal_[imiscal][abs(hit.ieta()) - 1] += miscalEB_[imiscal] * et;
        }
      }

      // spectra stuff
      if (spectra && hit.ieta() > 0)  //POSITIVE!!!
      //      if(spectra && hit.ieta()<0) //NEGATIVE!!!
      {
        et_spectrum_b_histos[abs(hit.ieta()) - 1]->Fill(et * 1000.);
        e_spectrum_b_histos[abs(hit.ieta()) - 1]->Fill(e * 1000.);
      }  //if spectra

    }  //if eventSet_==1
  }    //for barl

  // select interesting EcalRecHits (endcaps)
  EERecHitCollection::const_iterator ite;
  for (ite = endcapRecHitsHandle->begin(); ite != endcapRecHitsHandle->end(); ite++) {
    EEDetId hit = EEDetId(ite->id());
    float eta = abs(endcapGeometry->getGeometry(hit)->getPosition().eta());
    //float phi = endcapGeometry->getGeometry(hit)->getPosition().phi();

    float et = ite->energy() / cosh(eta);
    float e = ite->energy();

    // if iterating, multiply by the previous correction factor
    if (reiteration_) {
      et = et * oldCalibs_[hit];
      e = e * oldCalibs_[hit];
    }

    int sign = hit.zside() > 0 ? 1 : 0;

    // changes of eCut_endc_ -> variable linearthr
    // e_cut = ap + eta_ring*b

    double eCut_endc = 0;
    for (int ring = 0; ring < kEndcEtaRings; ring++) {
      if (eta > e_.etaBoundary_[ring] && eta < e_.etaBoundary_[ring + 1]) {
        float eta_ring = abs(e_.cellPos_[ring][50].eta());
        eCut_endc = ap_ + eta_ring * b_;
      }
    }

    float et_thr = eCut_endc / cosh(eta) + 1.;

    if (e > eCut_endc && et < et_thr && e_.goodCell_endc[hit.ix() - 1][hit.iy() - 1][sign]) {
      etsum_endc_[hit.ix() - 1][hit.iy() - 1][sign] += et;
      nhits_endc_[hit.ix() - 1][hit.iy() - 1][sign]++;
      pass = true;
    }

    if (eventSet_ == 1) {
      // apply a miscalibration to all crystals and increment the
      // ET sum, combined for all crystals
      for (int imiscal = 0; imiscal < kNMiscalBinsEE; imiscal++) {
        if (miscalEE_[imiscal] * e > eCut_endc && et * miscalEE_[imiscal] < et_thr &&
            e_.goodCell_endc[hit.ix() - 1][hit.iy() - 1][sign]) {
          int ring = e_.endcapRing_[hit.ix() - 1][hit.iy() - 1];
          etsum_endc_miscal_[imiscal][ring] += miscalEE_[imiscal] * et;
        }
      }

      // spectra stuff
      if (spectra && hit.zside() > 0)  //POSITIVE!!!

      {
        int ring = e_.endcapRing_[hit.ix() - 1][hit.iy() - 1];

        et_spectrum_e_histos[ring]->Fill(et * 1000.);
        e_spectrum_e_histos[ring]->Fill(e * 1000.);

        if (ring == 16) {
          //int iphi_endc = 0;
          for (int ip = 0; ip < e_.nRing_[ring]; ip++) {
            //if (phi==e_.phi_endc_[ip][ring]) iphi_endc=ip;
          }
        }
      }  //if spectra

    }  //if eventSet_==1
  }    //for endc

  if (pass) {
    nevents_++;
    eventsinrun_++;
    eventsinlb_++;
  }
}

void PhiSymmetryCalibration::beginRun(edm::Run const&, const edm::EventSetup&) {}

void PhiSymmetryCalibration::endRun(edm::Run const& run, const edm::EventSetup&) {
  std::cout << "PHIREPRT : run " << run.run() << " start " << (run.beginTime().value() >> 32) << " end "
            << (run.endTime().value() >> 32) << " dur "
            << (run.endTime().value() >> 32) - (run.beginTime().value() >> 32)

            << " npass " << eventsinrun_ << std::endl;
  eventsinrun_ = 0;

  return;
}

//_____________________________________________________________________________

void PhiSymmetryCalibration::getKfactors() {
  float epsilon_T_eb[kNMiscalBinsEB];
  float epsilon_M_eb[kNMiscalBinsEB];

  float epsilon_T_ee[kNMiscalBinsEE];
  float epsilon_M_ee[kNMiscalBinsEE];

  std::vector<TGraph*> k_barl_graph(kBarlRings);
  std::vector<TCanvas*> k_barl_plot(kBarlRings);

  //Create our own TF1 to avoid threading problems
  TF1 mypol1("mypol1", "pol1");
  for (int ieta = 0; ieta < kBarlRings; ieta++) {
    for (int imiscal = 0; imiscal < kNMiscalBinsEB; imiscal++) {
      int middlebin = int(kNMiscalBinsEB / 2);
      epsilon_T_eb[imiscal] = etsum_barl_miscal_[imiscal][ieta] / etsum_barl_miscal_[middlebin][ieta] - 1.;
      epsilon_M_eb[imiscal] = miscalEB_[imiscal] - 1.;
    }
    k_barl_graph[ieta] = new TGraph(kNMiscalBinsEB, epsilon_M_eb, epsilon_T_eb);
    k_barl_graph[ieta]->Fit(&mypol1);

    ostringstream t;
    t << "k_barl_" << ieta + 1;
    k_barl_plot[ieta] = new TCanvas(t.str().c_str(), "");
    k_barl_plot[ieta]->SetFillColor(10);
    k_barl_plot[ieta]->SetGrid();
    k_barl_graph[ieta]->SetMarkerSize(1.);
    k_barl_graph[ieta]->SetMarkerColor(4);
    k_barl_graph[ieta]->SetMarkerStyle(20);
    k_barl_graph[ieta]->GetXaxis()->SetLimits(-1. * kMiscalRangeEB, kMiscalRangeEB);
    k_barl_graph[ieta]->GetXaxis()->SetTitleSize(.05);
    k_barl_graph[ieta]->GetYaxis()->SetTitleSize(.05);
    k_barl_graph[ieta]->GetXaxis()->SetTitle("#epsilon_{M}");
    k_barl_graph[ieta]->GetYaxis()->SetTitle("#epsilon_{T}");
    k_barl_graph[ieta]->Draw("AP");

    k_barl_[ieta] = k_barl_graph[ieta]->GetFunction("pol1")->GetParameter(1);
    std::cout << "k_barl_[" << ieta << "]=" << k_barl_[ieta] << std::endl;
  }

  std::vector<TGraph*> k_endc_graph(kEndcEtaRings);
  std::vector<TCanvas*> k_endc_plot(kEndcEtaRings);

  for (int ring = 0; ring < kEndcEtaRings; ring++) {
    for (int imiscal = 0; imiscal < kNMiscalBinsEE; imiscal++) {
      int middlebin = int(kNMiscalBinsEE / 2);
      epsilon_T_ee[imiscal] = etsum_endc_miscal_[imiscal][ring] / etsum_endc_miscal_[middlebin][ring] - 1.;
      epsilon_M_ee[imiscal] = miscalEE_[imiscal] - 1.;
    }
    k_endc_graph[ring] = new TGraph(kNMiscalBinsEE, epsilon_M_ee, epsilon_T_ee);
    k_endc_graph[ring]->Fit(&mypol1);

    ostringstream t;
    t << "k_endc_" << ring + 1;
    k_endc_plot[ring] = new TCanvas(t.str().c_str(), "");
    k_endc_plot[ring]->SetFillColor(10);
    k_endc_plot[ring]->SetGrid();
    k_endc_graph[ring]->SetMarkerSize(1.);
    k_endc_graph[ring]->SetMarkerColor(4);
    k_endc_graph[ring]->SetMarkerStyle(20);
    k_endc_graph[ring]->GetXaxis()->SetLimits(-1 * kMiscalRangeEE, kMiscalRangeEE);
    k_endc_graph[ring]->GetXaxis()->SetTitleSize(.05);
    k_endc_graph[ring]->GetYaxis()->SetTitleSize(.05);
    k_endc_graph[ring]->GetXaxis()->SetTitle("#epsilon_{M}");
    k_endc_graph[ring]->GetYaxis()->SetTitle("#epsilon_{T}");
    k_endc_graph[ring]->Draw("AP");

    k_endc_[ring] = k_endc_graph[ring]->GetFunction("pol1")->GetParameter(1);
    std::cout << "k_endc_[" << ring << "]=" << k_endc_[ring] << std::endl;
  }

  TFile f("PhiSymmetryCalibration_kFactors.root", "recreate");
  for (int ieta = 0; ieta < kBarlRings; ieta++) {
    k_barl_plot[ieta]->Write();
    delete k_barl_plot[ieta];
    delete k_barl_graph[ieta];
  }
  for (int ring = 0; ring < kEndcEtaRings; ring++) {
    k_endc_plot[ring]->Write();
    delete k_endc_plot[ring];
    delete k_endc_graph[ring];
  }
  f.Close();
}

//_____________________________________________________________________________

void PhiSymmetryCalibration::setUp(const edm::EventSetup& setup) {
  const auto& chStatus = setup.getData(channelStatusToken_);

  const auto& geometry = setup.getData(geometryToken_);

  e_.setup(&geometry, &chStatus, statusThreshold_);

  if (reiteration_) {
    EcalCondHeader h;
    // namespace fs = boost::filesystem;
    //     fs::path p(oldcalibfile_.c_str(),fs::native);
    //     if (!fs::exists(p)) edm::LogError("PhiSym") << "File not found: "
    //                      << oldcalibfile_ <<endl;

    edm::FileInPath fip("Calibration/EcalCalibAlgos/data/" + oldcalibfile_);

    int ret = EcalIntercalibConstantsXMLTranslator::readXML(fip.fullPath(), h, oldCalibs_);
    if (ret)
      edm::LogError("PhiSym") << "Error reading XML files" << endl;
  }
}

void PhiSymmetryCalibration::beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) {}

void PhiSymmetryCalibration::endLuminosityBlock(edm::LuminosityBlock const& lb, edm::EventSetup const&) {
  if ((lb.endTime().value() >> 32) - (lb.beginTime().value() >> 32) < 60)
    return;

  std::cout << "PHILB : run " << lb.run() << " id " << lb.id() << " start " << (lb.beginTime().value() >> 32) << " end "
            << (lb.endTime().value() >> 32) << " dur " << (lb.endTime().value() >> 32) - (lb.beginTime().value() >> 32)

            << " npass " << eventsinlb_ << std::endl;

  eventsinlb_ = 0;
}