L1TMuonCaloSumProducer.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:    L1TMuonCaloSumProducer
// Class:      L1TMuonCaloSumProducer
//
//
// Original Author:  Joschka Philip Lingemann,40 3-B01,+41227671598,
//         Created:  Thu Oct  3 10:12:30 CEST 2013
// $Id$
//
//


// system include files
#include <memory>
#include <fstream>

// user include files
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/EDProducer.h"

#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/MakerMacros.h"

#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/Exception.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

#include "DataFormats/L1TMuon/interface/MuonCaloSumFwd.h"
#include "DataFormats/L1TMuon/interface/MuonCaloSum.h"
#include "DataFormats/L1TCalorimeter/interface/CaloTower.h"

#include "TMath.h"
#include "TRandom3.h"

//
// class declaration
//
using namespace l1t;

class L1TMuonCaloSumProducer : public edm::EDProducer {
   public:
      explicit L1TMuonCaloSumProducer(const edm::ParameterSet&);
      ~L1TMuonCaloSumProducer();

      static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);

   private:
      virtual void beginJob() override ;
      virtual void produce(edm::Event&, const edm::EventSetup&) override ;
      virtual void endJob() override ;

      virtual void beginRun(const edm::Run&, edm::EventSetup const&) override ;
      virtual void endRun(const edm::Run&, edm::EventSetup const&) override ;
      virtual void beginLuminosityBlock(const edm::LuminosityBlock&, edm::EventSetup const&) override ;
      virtual void endLuminosityBlock(const edm::LuminosityBlock&, edm::EventSetup const&) override ;

      edm::EDGetTokenT <CaloTowerBxCollection> m_caloTowerToken;
      edm::InputTag m_caloLabel;

};

//
// constants, enums and typedefs
//


//
// static data member definitions
//

//
// constructors and destructor
//
L1TMuonCaloSumProducer::L1TMuonCaloSumProducer(const edm::ParameterSet& iConfig) {
  //register your inputs:
  m_caloLabel = iConfig.getParameter<edm::InputTag> ("caloStage2Layer2Label");
  m_caloTowerToken = consumes <CaloTowerBxCollection> (m_caloLabel);
  //register your products
  produces<MuonCaloSumBxCollection>("TriggerTowerSums");
  produces<MuonCaloSumBxCollection>("TriggerTower2x2s");
}


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


//
// member functions
//


// ------------ method called to produce the data  ------------
void
L1TMuonCaloSumProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup)
{
  using namespace edm;
  std::auto_ptr<MuonCaloSumBxCollection> towerSums (new MuonCaloSumBxCollection());
  std::auto_ptr<MuonCaloSumBxCollection> tower2x2s (new MuonCaloSumBxCollection());

  edm::Handle<CaloTowerBxCollection> caloTowers;
  // Make sure that you can get genParticles
  std::map<int, MuonCaloSum> sums;
  std::map<int, MuonCaloSum> regs;

  if (iEvent.getByToken(m_caloTowerToken, caloTowers)) {
    for (auto it = caloTowers->begin(0); it != caloTowers->end(0); ++it) {
      const CaloTower& twr = *it;
      if (std::abs(twr.hwEta()) > 27) {
        continue;
      }
      int ieta2x2 = (twr.hwEta() + 27) / 2;
      int iphi2x2 = twr.hwPhi() / 2;
      int muon_idx = iphi2x2 * 28 + ieta2x2;
      if (regs.count(muon_idx) == 0) {
        regs[muon_idx] = MuonCaloSum(twr.hwPt(), iphi2x2, ieta2x2, muon_idx);
      } else {
        regs.at(muon_idx).setEtBits(regs.at(muon_idx).etBits() + twr.hwPt());
      }

      // std::cout << "iphi; phi " << twr.hwPhi() << "; " << twr.phi() << " .. ieta; eta" << twr.hwEta() << "; " << twr.eta() << std::endl;

      for (int ieta = -27; ieta < 28; ++ieta) {
        for (int iphi = 0; iphi < 72; ++iphi) {
          int deta = std::abs(ieta - twr.hwEta());
          int dphi = iphi - twr.hwPhi();
          if (dphi > 36) {
            dphi -= 72;
          }
          if (dphi < -36) {
            dphi += 72;
          }
          dphi = std::abs(dphi);
          if (deta <= 4 && dphi <= 4) {
            int ietamu = (ieta + 27) / 2;
            int iphimu = iphi / 2;
            int idxmu = iphimu * 28 + ietamu;
            if (sums.count(idxmu) == 0) {
              sums[idxmu] = MuonCaloSum(twr.hwPt(), iphimu, ietamu, idxmu);
            } else {
              sums.at(idxmu).setEtBits(sums.at(idxmu).etBits() + twr.hwPt());
            }
          }

        }
      }
    }
  } else {
    LogError("GlobalMuon") << "CaloTowers not found." << std::endl;
  }

  for (auto it = sums.begin(); it != sums.end(); ++it) {
    if (it->second.etBits() > 0) {
      MuonCaloSum sum = MuonCaloSum(it->second);
      // convert Et to correct scale:
      if (sum.etBits() > 31) {
        sum.setEtBits(31);
      }
      towerSums->push_back(0, sum);
    }
  }
  for (auto it = regs.begin(); it != regs.end(); ++it) {
    if (it->second.etBits() > 0) {
      tower2x2s->push_back(0, it->second);
    }
  }

  iEvent.put(towerSums, "TriggerTowerSums");
  iEvent.put(tower2x2s, "TriggerTower2x2s");

}

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

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

// ------------ method called when starting to processes a run  ------------
void
L1TMuonCaloSumProducer::beginRun(const edm::Run&, edm::EventSetup const&)
{
}

// ------------ method called when ending the processing of a run  ------------
void
L1TMuonCaloSumProducer::endRun(const edm::Run&, edm::EventSetup const&)
{
}

// ------------ method called when starting to processes a luminosity block  ------------
void
L1TMuonCaloSumProducer::beginLuminosityBlock(const edm::LuminosityBlock&, edm::EventSetup const&)
{
}

// ------------ method called when ending the processing of a luminosity block  ------------
void
L1TMuonCaloSumProducer::endLuminosityBlock(const edm::LuminosityBlock&, edm::EventSetup const&)
{
}

// ------------ method fills 'descriptions' with the allowed parameters for the module  ------------
void
L1TMuonCaloSumProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
  //The following says we do not know what parameters are allowed so do no validation
  // Please change this to state exactly what you do use, even if it is no parameters
  edm::ParameterSetDescription desc;
  desc.setUnknown();
  descriptions.addDefault(desc);
}

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