L1CaloTowerTreeProducer.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:    L1Trigger/L1Ntuples
// Class:      L1CaloTowerTreeProducer
// 
//
// Original Author:  
//         Created:  
// $Id: L1CaloTowerTreeProducer.cc,v 1.8 2012/08/29 12:44:03 jbrooke Exp $
//
//


// system include files
#include <memory>

// framework
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/EDAnalyzer.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/MakerMacros.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

// data formats
#include "DataFormats/L1Trigger/interface/EGamma.h"
#include "DataFormats/L1Trigger/interface/Tau.h"
#include "DataFormats/L1Trigger/interface/Jet.h"
#include "DataFormats/L1Trigger/interface/Muon.h"
#include "DataFormats/L1Trigger/interface/EtSum.h"

// cond formats
#include "CalibFormats/CaloTPG/interface/CaloTPGTranscoder.h"
#include "CalibFormats/CaloTPG/interface/CaloTPGRecord.h"

// ROOT output stuff
#include "FWCore/ServiceRegistry/interface/Service.h"
#include "CommonTools/UtilAlgos/interface/TFileService.h"
#include "TTree.h"

#include "L1Trigger/L1TNtuples/interface/L1AnalysisCaloTPDataFormat.h"
#include "L1Trigger/L1TNtuples/interface/L1AnalysisL1CaloTowerDataFormat.h"
#include "L1Trigger/L1TNtuples/interface/L1AnalysisL1CaloClusterDataFormat.h"

#include "DataFormats/EcalDigi/interface/EcalDigiCollections.h"
#include "DataFormats/HcalDigi/interface/HcalDigiCollections.h"

#include "DataFormats/L1TCalorimeter/interface/CaloTower.h"
#include "DataFormats/L1TCalorimeter/interface/CaloCluster.h"


//
// class declaration
//

class L1CaloTowerTreeProducer : public edm::EDAnalyzer {
public:
  explicit L1CaloTowerTreeProducer(const edm::ParameterSet&);
  ~L1CaloTowerTreeProducer() override;
  
  
private:
  void beginJob(void) override ;
  void analyze(const edm::Event&, const edm::EventSetup&) override;
  void endJob() override;

public:
  
  L1Analysis::L1AnalysisCaloTPDataFormat* caloTPData_;
  L1Analysis::L1AnalysisL1CaloTowerDataFormat* l1CaloTowerData_;
  L1Analysis::L1AnalysisL1CaloClusterDataFormat* l1CaloClusterData_;

private:

  double ecalLSB_;
  unsigned maxCaloTP_;
  unsigned maxL1Tower_;
  unsigned maxL1Cluster_;

  // output file
  edm::Service<TFileService> fs_;
  
  // tree
  TTree * tree_;

  // EDM input tags
  edm::EDGetTokenT<EcalTrigPrimDigiCollection> ecalToken_;
  edm::EDGetTokenT<HcalTrigPrimDigiCollection> hcalToken_;
  edm::EDGetTokenT<l1t::CaloTowerBxCollection> l1TowerToken_;
  edm::EDGetTokenT<l1t::CaloClusterBxCollection> l1ClusterToken_;

  bool storeCaloClusters_;
};



L1CaloTowerTreeProducer::L1CaloTowerTreeProducer(const edm::ParameterSet& iConfig)
{

  ecalToken_ = consumes<EcalTrigPrimDigiCollection>(iConfig.getUntrackedParameter<edm::InputTag>("ecalToken"));
  hcalToken_ = consumes<HcalTrigPrimDigiCollection>(iConfig.getUntrackedParameter<edm::InputTag>("hcalToken"));
  l1TowerToken_ = consumes<l1t::CaloTowerBxCollection>(iConfig.getUntrackedParameter<edm::InputTag>("l1TowerToken"));

  edm::InputTag clusterTag = iConfig.getUntrackedParameter<edm::InputTag>("l1ClusterToken");
  storeCaloClusters_=true;
  if ( clusterTag.label() == std::string("") or clusterTag.label() == std::string("none")) storeCaloClusters_=false;
  
  if (clusterTag.instance() != std::string(""))
    l1ClusterToken_ = consumes<l1t::CaloClusterBxCollection>(clusterTag);
 
  ecalLSB_      = iConfig.getUntrackedParameter<double>("ecalLSB", 0.5);
  maxCaloTP_    = iConfig.getUntrackedParameter<unsigned int>("maxCaloTP", 5760);
  maxL1Tower_   = iConfig.getUntrackedParameter<unsigned int>("maxL1Tower", 5760);
  maxL1Cluster_ = iConfig.getUntrackedParameter<unsigned int>("maxL1Cluster", 5760);
 
  // set up output
  tree_=fs_->make<TTree>("L1CaloTowerTree", "L1CaloTowerTree");
  tree_->Branch("CaloTP", "L1Analysis::L1AnalysisCaloTPDataFormat", &caloTPData_, 32000, 3);
  tree_->Branch("L1CaloTower", "L1Analysis::L1AnalysisL1CaloTowerDataFormat", &l1CaloTowerData_, 32000, 3);

  if (storeCaloClusters_)
    tree_->Branch("L1CaloCluster", "L1Analysis::L1AnalysisL1CaloClusterDataFormat", &l1CaloClusterData_, 32000, 3);

  caloTPData_ = new L1Analysis::L1AnalysisCaloTPDataFormat();
  l1CaloTowerData_ = new L1Analysis::L1AnalysisL1CaloTowerDataFormat();
  l1CaloClusterData_ = new L1Analysis::L1AnalysisL1CaloClusterDataFormat();

}


L1CaloTowerTreeProducer::~L1CaloTowerTreeProducer()
{
 
  // do anything here that needs to be done at desctruction time
  // (e.g. close files, deallocate resources etc.)

}


//
// member functions
//

// ------------ method called to for each event  ------------
void
L1CaloTowerTreeProducer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup)
{

  // do calo towers
  caloTPData_->Reset();

  edm::ESHandle<CaloTPGTranscoder> decoder;
  iSetup.get<CaloTPGRecord>().get(decoder);

  edm::Handle<EcalTrigPrimDigiCollection> ecalTPs;
  edm::Handle<HcalTrigPrimDigiCollection> hcalTPs;

  iEvent.getByToken(ecalToken_, ecalTPs);
  iEvent.getByToken(hcalToken_, hcalTPs);

  if (ecalTPs.isValid()){ 

    for ( auto itr : *(ecalTPs.product()) ) {

      short ieta = (short) itr.id().ieta();
      //      unsigned short absIeta = (unsigned short) abs(ieta);
      //      short sign = ieta/absIeta;
      
      unsigned short cal_iphi = (unsigned short) itr.id().iphi();
      unsigned short iphi = (72 + 18 - cal_iphi) % 72;
      unsigned short compEt = itr.compressedEt();
      double et = ecalLSB_ * compEt;
      unsigned short fineGrain = (unsigned short) itr.fineGrain();

      if (compEt > 0) {
    caloTPData_->ecalTPieta.push_back( ieta );
    caloTPData_->ecalTPCaliphi.push_back( cal_iphi );
    caloTPData_->ecalTPiphi.push_back( iphi );
    caloTPData_->ecalTPet.push_back( et );
    caloTPData_->ecalTPcompEt.push_back( compEt );
    caloTPData_->ecalTPfineGrain.push_back( fineGrain );
    caloTPData_->nECALTP++;
      }
    }

  }
  else {
    edm::LogWarning("L1TNtuple") << "ECAL TPs not found, branch will not be filled";
  }
  
  
  if (hcalTPs.isValid()) {
      
    for ( auto itr : (*hcalTPs.product()) ) {

      int ver = itr.id().version();
      short ieta = (short) itr.id().ieta();
      unsigned short absIeta = (unsigned short) abs(ieta);
      //      short sign = ieta/absIeta;
      
      unsigned short cal_iphi = (unsigned short) itr.id().iphi();
      unsigned short iphi = (72 + 18 - cal_iphi) % 72;
      
      unsigned short compEt = itr.SOI_compressedEt();
      double et = decoder->hcaletValue(itr.id(), itr.t0());

      unsigned short fineGrain = (unsigned short) itr.SOI_fineGrain();
      
      if (compEt > 0 && (absIeta<29 || ver==1)) {
    caloTPData_->hcalTPieta.push_back( ieta );
    caloTPData_->hcalTPCaliphi.push_back( cal_iphi );
    caloTPData_->hcalTPiphi.push_back( iphi );
    caloTPData_->hcalTPet.push_back( et );
    caloTPData_->hcalTPcompEt.push_back( compEt );
    caloTPData_->hcalTPfineGrain.push_back( fineGrain );
    caloTPData_->nHCALTP++;
      }
    }
    
  }
  else {
    edm::LogWarning("L1TNtuple") << "HCAL TPs not found, branch will not be filled";
  }
  
  // do L1 towers
  l1CaloTowerData_->Reset();

  edm::Handle<l1t::CaloTowerBxCollection> l1Towers;

  iEvent.getByToken(l1TowerToken_, l1Towers);

  if (l1Towers.isValid()){

    for ( int ibx=l1Towers->getFirstBX(); ibx<=l1Towers->getLastBX(); ++ibx) {

      for ( auto itr = l1Towers->begin(ibx); itr !=l1Towers->end(ibx); ++itr ) {

        if (itr->hwPt()<=0) continue;

    //  l1CaloTowerData_->bx.push_back( ibx );
    l1CaloTowerData_->et.push_back( itr->pt() );
    l1CaloTowerData_->eta.push_back( itr->eta() );
    l1CaloTowerData_->phi.push_back( itr->phi() );
    l1CaloTowerData_->iet.push_back( itr->hwPt() );
    l1CaloTowerData_->ieta.push_back( itr->hwEta() );
    l1CaloTowerData_->iphi.push_back( itr->hwPhi() );
    l1CaloTowerData_->iem.push_back( itr->hwEtEm() );
    l1CaloTowerData_->ihad.push_back( itr->hwEtHad() );
    l1CaloTowerData_->iratio.push_back( itr->hwEtRatio() );
    l1CaloTowerData_->iqual.push_back( itr->hwQual() );

    l1CaloTowerData_->nTower++;

      }

    }

  }
  else {
    edm::LogWarning("L1TNtuple") << "L1 Calo Towerss not found, branch will not be filled";
  }


  // do L1 clusters
  if (storeCaloClusters_){
    l1CaloClusterData_->Reset();

    edm::Handle<l1t::CaloClusterBxCollection> l1Clusters;

    if (!l1ClusterToken_.isUninitialized())
      iEvent.getByToken(l1ClusterToken_, l1Clusters);

    if (l1Clusters.isValid()){

      for ( int ibx=l1Clusters->getFirstBX(); ibx<=l1Clusters->getLastBX(); ++ibx) {

    for ( auto itr = l1Clusters->begin(ibx); itr !=l1Clusters->end(ibx); ++itr ) {

      if (itr->hwPt()<=0) continue;

      //    l1CaloClusterData_->bx.push_back( ibx );
      l1CaloClusterData_->et.push_back( itr->pt() );
      l1CaloClusterData_->eta.push_back( itr->eta() );
      l1CaloClusterData_->phi.push_back( itr->phi() );
      l1CaloClusterData_->iet.push_back( itr->hwPt() );
      l1CaloClusterData_->ieta.push_back( itr->hwEta() );
      l1CaloClusterData_->iphi.push_back( itr->hwPhi() );
      l1CaloClusterData_->iqual.push_back( itr->hwQual() );

      l1CaloClusterData_->nCluster++;

    }

      }

    }
    else {
      edm::LogWarning("L1TNtuple") << "L1 Calo Clusters not found, branch will not be filled";
    }
  }


  tree_->Fill();

}

// ------------ method called once each job just before starting event loop  ------------
void 
L1CaloTowerTreeProducer::beginJob(void)
{
}

// ------------ method called once each job just after ending the event loop  ------------
void 
L1CaloTowerTreeProducer::endJob() {
}

//define this as a plug-in
DEFINE_FWK_MODULE(L1CaloTowerTreeProducer);