EcalPreshowerRecHitsValidation.cc

Go to the documentation of this file.

/*
 * \file EcalPreshowerRecHitsValidation.cc
 *
 * \author C. Rovelli
 *
 */

#include <Validation/EcalRecHits/interface/EcalPreshowerRecHitsValidation.h>
#include <DataFormats/EcalDetId/interface/ESDetId.h>
#include <DataFormats/EcalDetId/interface/EEDetId.h>
#include "DQMServices/Core/interface/DQMStore.h"

using namespace cms;
using namespace edm;
using namespace std;


EcalPreshowerRecHitsValidation::EcalPreshowerRecHitsValidation(const ParameterSet& ps){


  // ----------------------
  EEuncalibrechitCollection_token_ = consumes<EEUncalibratedRecHitCollection>(ps.getParameter<edm::InputTag>("EEuncalibrechitCollection"));
  EErechitCollection_token_        = consumes<EERecHitCollection>(ps.getParameter<edm::InputTag>("EErechitCollection"));
  ESrechitCollection_token_        = consumes<ESRecHitCollection>(ps.getParameter<edm::InputTag>("ESrechitCollection"));


  // ---------------------- 
  // verbosity switch 
  verbose_ = ps.getUntrackedParameter<bool>("verbose", false);

  // ----------------------  
  meESRecHitsEnergy_           = nullptr;                // total energy
  meESRecHitsEnergy_zp1st_     = nullptr;    
  meESRecHitsEnergy_zp2nd_     = nullptr;    
  meESRecHitsEnergy_zm1st_     = nullptr;    
  meESRecHitsEnergy_zm2nd_     = nullptr;    
  meESRecHitsMultip_           = nullptr;                // total multiplicity
  meESRecHitsMultip_zp1st_     = nullptr;    
  meESRecHitsMultip_zp2nd_     = nullptr;    
  meESRecHitsMultip_zm1st_     = nullptr;    
  meESRecHitsMultip_zm2nd_     = nullptr;    
  meESEERecHitsEnergy_zp_      = nullptr;                // versus EE energy 
  meESEERecHitsEnergy_zm_      = nullptr;      

  for (int kk=0; kk<32; kk++)
    { 
      meESRecHitsStripOccupancy_zp1st_[kk] = nullptr;   
      meESRecHitsStripOccupancy_zm1st_[kk] = nullptr;   
      meESRecHitsStripOccupancy_zp2nd_[kk] = nullptr;   
      meESRecHitsStripOccupancy_zm2nd_[kk] = nullptr;   
    }
}

EcalPreshowerRecHitsValidation::~EcalPreshowerRecHitsValidation(){   

}

void EcalPreshowerRecHitsValidation::bookHistograms(DQMStore::IBooker &ibooker, edm::Run const&, edm::EventSetup const&){

  Char_t histo[200];

  ibooker.setCurrentFolder("EcalRecHitsV/EcalPreshowerRecHitsTask");

  sprintf (histo, "ES Energy" );
  meESRecHitsEnergy_ = ibooker.book1D(histo, histo, 210, -0.0005, 0.01);
  
  sprintf (histo, "ES Energy Plane1 Side+" );
  meESRecHitsEnergy_zp1st_ = ibooker.book1D(histo, histo, 210, -0.0005, 0.01);

  sprintf (histo, "ES Energy Plane2 Side+");
  meESRecHitsEnergy_zp2nd_ = ibooker.book1D(histo, histo, 210, -0.0005, 0.01);
 
  sprintf (histo, "ES Energy Plane1 Side-");
  meESRecHitsEnergy_zm1st_ = ibooker.book1D(histo, histo, 210, -0.0005, 0.01);

  sprintf (histo, "ES Energy Plane2 Side-");
  meESRecHitsEnergy_zm2nd_ = ibooker.book1D(histo, histo, 210, -0.0005, 0.01);

  sprintf (histo, "ES Multiplicity" );
  meESRecHitsMultip_ = ibooker.book1D(histo, histo, 100, 0., 700.);

  sprintf (histo, "ES Multiplicity Plane1 Side+");
  meESRecHitsMultip_zp1st_ = ibooker.book1D(histo, histo, 100, 0., 700.);

  sprintf (histo, "ES Multiplicity Plane2 Side+");
  meESRecHitsMultip_zp2nd_ = ibooker.book1D(histo, histo, 100, 0., 700.);

  sprintf (histo, "ES Multiplicity Plane1 Side-");
  meESRecHitsMultip_zm1st_ = ibooker.book1D(histo, histo, 100, 0., 700.);

  sprintf (histo, "ES Multiplicity Plane2 Side-");
  meESRecHitsMultip_zm2nd_ = ibooker.book1D(histo, histo, 100, 0., 700.);

  sprintf (histo, "Preshower EE vs ES energy Side+");
  meESEERecHitsEnergy_zp_ = ibooker.book2D(histo, histo, 100, 0., 0.2, 100, 0., 150.);

  sprintf (histo, "Preshower EE vs ES energy Side-");
  meESEERecHitsEnergy_zm_ = ibooker.book2D(histo, histo, 100, 0., 0.2, 100, 0., 150.);

  for (int kk=0; kk<32; kk++)
    { 
      sprintf(histo, "ES Occupancy Plane1 Side+ Strip%02d", kk+1);    
      meESRecHitsStripOccupancy_zp1st_[kk] = ibooker.book2D(histo, histo, 40, 0., 40., 40, 0., 40.);

      sprintf(histo, "ES Occupancy Plane2 Side+ Strip%02d", kk+1);    
      meESRecHitsStripOccupancy_zp2nd_[kk] = ibooker.book2D(histo, histo, 40, 0., 40., 40, 0., 40.);

      sprintf(histo, "ES Occupancy Plane1 Side- Strip%02d", kk+1);    
      meESRecHitsStripOccupancy_zm1st_[kk] = ibooker.book2D(histo, histo, 40, 0., 40., 40, 0., 40.);

      sprintf(histo, "ES Occupancy Plane2 Side- Strip%02d", kk+1);    
      meESRecHitsStripOccupancy_zm2nd_[kk] = ibooker.book2D(histo, histo, 40, 0., 40., 40, 0., 40.);
    }
}

void EcalPreshowerRecHitsValidation::analyze(const Event& e, const EventSetup& c){

  const ESRecHitCollection *ESRecHit = nullptr;
  Handle<ESRecHitCollection> EcalRecHitES;
  e.getByToken( ESrechitCollection_token_, EcalRecHitES);
  if (EcalRecHitES.isValid()) {
    ESRecHit = EcalRecHitES.product ();
  } else {
    return;
  }

  bool skipEE = false;
  const EERecHitCollection *EERecHit = nullptr;
  Handle<EERecHitCollection> EcalRecHitEE;
  e.getByToken( EErechitCollection_token_, EcalRecHitEE);
  if (EcalRecHitEE.isValid()){   
    EERecHit = EcalRecHitEE.product ();  
  } else {
    skipEE = true;
  }

  const EEUncalibratedRecHitCollection *EEUncalibRecHit = nullptr;
  Handle< EEUncalibratedRecHitCollection > EcalUncalibRecHitEE;
  e.getByToken( EEuncalibrechitCollection_token_, EcalUncalibRecHitEE);
  if (EcalUncalibRecHitEE.isValid()) {
    EEUncalibRecHit = EcalUncalibRecHitEE.product() ;
  } else {
    skipEE = true;
  }



  // ---------------------- 
  // loop over RecHits
  // multiplicities
  int mult_tot       = 0;
  int mult_zp1st     = 0;
  int mult_zp2nd     = 0;
  int mult_zm1st     = 0;
  int mult_zm2nd     = 0;

  // energies
  float ene_zp1st      = 0.;
  float ene_zp2nd      = 0.;
  float ene_zm1st      = 0.;
  float ene_zm2nd      = 0.;


  // ES
  for (ESRecHitCollection::const_iterator recHit = ESRecHit->begin(); recHit != ESRecHit->end() ; ++recHit)
    {
      ESDetId ESid = ESDetId(recHit->id());

      int zside = ESid.zside();
      int plane = ESid.plane();
      int six   = ESid.six();
      int siy   = ESid.siy();
      int strip = ESid.strip();
      
      // global
      mult_tot++;
      if (meESRecHitsEnergy_) meESRecHitsEnergy_ ->Fill(recHit->energy());      
      
      // side +, plane 1
      if ( (zside == +1) && (plane == 1) )
    { 
      mult_zp1st++;
      ene_zp1st += recHit->energy();
      if ( meESRecHitsEnergy_zp1st_ )                 { meESRecHitsEnergy_zp1st_                 -> Fill(recHit->energy()); }
      if ( meESRecHitsStripOccupancy_zp1st_[strip-1] ){ meESRecHitsStripOccupancy_zp1st_[strip-1]-> Fill( six, siy ); }
    }
      

      // side +, plane 2
      if ( (zside == +1) && (plane == 2) )
    { 
      mult_zp2nd++; 
      ene_zp2nd += recHit->energy();
      if ( meESRecHitsEnergy_zp2nd_ )                 { meESRecHitsEnergy_zp2nd_                 -> Fill(recHit->energy()); }
      if ( meESRecHitsStripOccupancy_zp2nd_[strip-1] ){ meESRecHitsStripOccupancy_zp2nd_[strip-1]-> Fill( six, siy ); }
    }


      // side -, plane 1
      if ( (zside == -1) && (plane == 1) )
    { 
      mult_zm1st++;
      ene_zm1st += recHit->energy(); 
      if ( meESRecHitsEnergy_zm1st_ )                 { meESRecHitsEnergy_zm1st_                 -> Fill(recHit->energy()); }
      if ( meESRecHitsStripOccupancy_zm1st_[strip-1] ){ meESRecHitsStripOccupancy_zm1st_[strip-1]-> Fill( six, siy ); }
    }


      // side +, plane 2
      if ( (zside == -1) && (plane == 2) )
    { 
      mult_zm2nd ++; 
      ene_zm2nd += recHit->energy();
      if ( meESRecHitsEnergy_zm2nd_ )                 { meESRecHitsEnergy_zm2nd_                 -> Fill(recHit->energy()); }
      if ( meESRecHitsStripOccupancy_zm2nd_[strip-1] ){ meESRecHitsStripOccupancy_zm2nd_[strip-1]-> Fill( six, siy ); }
    }

    }  // loop over the ES RecHitCollection



  // EE
  double zpEE = 0.;
  double zmEE = 0.;
  if ( ! skipEE ) {
    
    for (EcalUncalibratedRecHitCollection::const_iterator uncalibRecHit = EEUncalibRecHit->begin(); uncalibRecHit != EEUncalibRecHit->end() ; ++uncalibRecHit)
      {
        EEDetId EEid = EEDetId(uncalibRecHit->id());
        int mySide = EEid.zside();
        
        // Find corresponding recHit
        EcalRecHitCollection::const_iterator myRecHit = EERecHit->find(EEid);
        
        if (myRecHit != EERecHit->end() )
          {
            if (mySide > 0) { zpEE = zpEE + myRecHit->energy(); }
            if (mySide < 0) { zmEE = zmEE + myRecHit->energy(); }
          }
      } 
  }
  

  // filling histos
  if (meESRecHitsMultip_)            { meESRecHitsMultip_           -> Fill(mult_tot);   }
  if (meESRecHitsMultip_zp1st_ )     { meESRecHitsMultip_zp1st_     -> Fill(mult_zp1st); }
  if (meESRecHitsMultip_zp2nd_ )     { meESRecHitsMultip_zp2nd_     -> Fill(mult_zp2nd); }
  if (meESRecHitsMultip_zm1st_ )     { meESRecHitsMultip_zm1st_     -> Fill(mult_zm1st); }
  if (meESRecHitsMultip_zm2nd_ )     { meESRecHitsMultip_zm2nd_     -> Fill(mult_zm2nd); }
  if (meESEERecHitsEnergy_zp_)       { meESEERecHitsEnergy_zp_      -> Fill( (ene_zp1st + 0.7*ene_zp2nd)/0.09, zpEE ); }
  if (meESEERecHitsEnergy_zm_)       { meESEERecHitsEnergy_zm_      -> Fill( (ene_zm1st + 0.7*ene_zm2nd)/0.09, zmEE ); }
}