Inheritance diagram for AnaL1CaloCleaner:

Public Member Functions
	AnaL1CaloCleaner (const edm::ParameterSet &)

	~AnaL1CaloCleaner ()

Public Member Functions inherited from edm::EDAnalyzer
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzer ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

virtual	~EDAnalyzer ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (std::string const &iProcessName, std::string const &iModuleLabel, bool iPrint, std::vector< char const * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

Private Member Functions
virtual void	analyze (const edm::Event &, const edm::EventSetup &)

Private Attributes
Float_t	calo_upara_

Float_t	calo_uperp_

Int_t	charge_

edm::InputTag	colCaloDepositsMinus_

edm::InputTag	colCaloDepositsPlus_

edm::InputTag	colCaloLengthsMinus_

edm::InputTag	colCaloLengthsPlus_

edm::InputTag	colCaloMET_

edm::InputTag	colGenParticles_

edm::InputTag	colL1ETM_

edm::InputTag	colMuons_

Float_t	dep_ecal_

Float_t	dep_hcal_

Float_t	dep_ho_

Float_t	eta_

Float_t	l1_upara_

Float_t	l1_uperp_

Float_t	len_ecal_

Float_t	len_hcal_

Float_t	len_ho_

Float_t	p_

Float_t	phi_

Float_t	pt_

TTree *	tree_

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 37 of file AnaL1CaloCleaner.cc.

Constructor & Destructor Documentation

AnaL1CaloCleaner::AnaL1CaloCleaner ( const edm::ParameterSet & iConfig )

explicit

Definition at line 132 of file AnaL1CaloCleaner.cc.

References calo_upara_, calo_uperp_, charge_, dep_ecal_, dep_hcal_, dep_ho_, eta_, l1_upara_, l1_uperp_, len_ecal_, len_hcal_, len_ho_, TFileService::make(), p_, phi_, pt_, and tree_.

                                                                 :
     colCaloLengthsMinus_(iConfig.getParameter<edm::InputTag>("caloLengthsMinus")),
     colCaloLengthsPlus_(iConfig.getParameter<edm::InputTag>("caloLengthsPlus")),
     colCaloDepositsMinus_(iConfig.getParameter<edm::InputTag>("caloDepositsMinus")),
     colCaloDepositsPlus_(iConfig.getParameter<edm::InputTag>("caloDepositsPlus")),
     colL1ETM_(iConfig.getParameter<edm::InputTag>("l1ETM")),
     colCaloMET_(iConfig.getParameter<edm::InputTag>("caloMET")),
     colGenParticles_(iConfig.getParameter<edm::InputTag>("genParticles")),
     colMuons_(iConfig.getParameter<edm::InputTag>("muons"))
 {
     edm::Service<TFileService> fs;
     tree_ = fs->make<TTree>("L1AnaTree", "L1AnaTree");
 
     tree_->Branch("pt", &pt_, "pt/F");
     tree_->Branch("p", &p_, "p/F");
     tree_->Branch("eta", &eta_, "eta/F");
     tree_->Branch("phi", &phi_, "phi/F");
     tree_->Branch("len_ecal", &len_ecal_, "len_ecal/F");
     tree_->Branch("len_hcal", &len_hcal_, "len_hcal/F");
     tree_->Branch("len_ho", &len_ho_, "len_ho/F");
     tree_->Branch("dep_ecal", &dep_ecal_, "dep_ecal/F");
     tree_->Branch("dep_hcal", &dep_hcal_, "dep_hcal/F");
     tree_->Branch("dep_ho", &dep_ho_, "dep_ho/F");
     tree_->Branch("l1_upara", &l1_upara_, "l1_upara/F");
     tree_->Branch("l1_uperp", &l1_uperp_, "l1_uperp/F");
     tree_->Branch("calo_upara", &calo_upara_, "calo_upara/F");
     tree_->Branch("calo_uperp", &calo_uperp_, "calo_uperp/F");
     tree_->Branch("charge", &charge_, "charge/I");
 }

AnaL1CaloCleaner::~AnaL1CaloCleaner ( )

Definition at line 270 of file AnaL1CaloCleaner.cc.

271 {

272 }

Member Function Documentation

void AnaL1CaloCleaner::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

privatevirtual

Implements edm::EDAnalyzer.

Definition at line 163 of file AnaL1CaloCleaner.cc.

 {
   // Find the (only) status-1 genlevel muon
   edm::Handle< std::vector<reco::GenParticle> > genHandle;
   iEvent.getByLabel(colGenParticles_, genHandle);
   const reco::GenParticle* genMuon = NULL;
   for(std::vector<reco::GenParticle>::const_iterator iter = genHandle->begin(); iter != genHandle->end(); ++iter)
   {
     const reco::GenParticle& gen = *iter;
     if(TMath::Abs(gen.pdgId()) != 13) continue;
     if(gen.status() != 1) continue;
     if(genMuon) return; // There should only be one muon, or the whole method does not work
     genMuon = &gen;
   }
 
   // There should be at least one such muon
   if(!genMuon) return;
 
   // Next, find the matching reco muon, if any
   edm::Handle< std::vector<reco::Muon> > muonsHandle;
   iEvent.getByLabel(colMuons_, muonsHandle);
   const reco::Muon* recoMuon = NULL;
   for(std::vector<reco::Muon>::const_iterator iter = muonsHandle->begin(); iter != muonsHandle->end(); ++iter)
   {
     const reco::Muon& mu = *iter;
     if(!mu.isGlobalMuon()) continue;
     if(ROOT::Math::VectorUtil::DeltaR(genMuon->p4(), mu.p4()) > 0.1) continue;
     if(recoMuon && ROOT::Math::VectorUtil::DeltaR(genMuon->p4(), mu.p4()) > ROOT::Math::VectorUtil::DeltaR(genMuon->p4(), recoMuon->p4())) continue;
     recoMuon = &mu;
   }
 
   // We need a reco muon
   if(!recoMuon) return;
 
   // Next, read the pathlength the muon travelled in the calorimeter
   edm::Handle<std::map<unsigned int,float> > hLengthsMinus, hLengthsPlus;
   edm::Handle<std::map<unsigned int,float> > hDepositsMinus, hDepositsPlus;
   iEvent.getByLabel(colCaloLengthsMinus_, hLengthsMinus);
   iEvent.getByLabel(colCaloLengthsPlus_, hLengthsPlus);
   iEvent.getByLabel(colCaloDepositsMinus_, hDepositsMinus);
   iEvent.getByLabel(colCaloDepositsPlus_, hDepositsPlus);
   const std::map<unsigned int,float>& caloLengths = recoMuon->charge() < 0 ? *hLengthsMinus : *hLengthsPlus;
   const std::map<unsigned int,float>& caloDeposits = recoMuon->charge() < 0 ? *hDepositsMinus : *hDepositsPlus;
   float len_ecal = 0.0f, len_hcal = 0.0f, len_ho = 0.0f;
   float dep_ecal = 0.0f, dep_hcal = 0.0f, dep_ho = 0.0f;
   for(std::map<unsigned int, float>::const_iterator iter = caloLengths.begin(); iter != caloLengths.end(); ++iter)
   {
     const DetId det(iter->first);
     std::map<unsigned int, float>::const_iterator dep_iter = caloDeposits.find(det);
     const float dep = (dep_iter != caloDeposits.end()) ? dep_iter->second : 0.0f;
 
     //std::string name = getKey(det);
     //std::cout << name << ": " << iter->second << std::endl;
     //  val = (hDeposits->find(entry.first))->second;
     if(det.det() == DetId::Ecal)
     {
       len_ecal += iter->second;
       dep_ecal += dep;
     }
     else if(det.det() == DetId::Hcal && det.subdetId() != HcalOuter)
     {
       len_hcal += iter->second;
       dep_hcal += dep;
     }
     else if(det.det() == DetId::Hcal && det.subdetId() == HcalOuter)
     {
       len_ho += iter->second;
       dep_ho += dep;
     }
   }
 
   // Compute the parallel and perpendicular projection wrt. the genmuon axis
   edm::Handle<l1extra::L1EtMissParticleCollection> hl1Etm;
   iEvent.getByLabel(colL1ETM_, hl1Etm);
   assert(hl1Etm->size() == 1);
   int errorFlag = 0;
   std::pair<double, double> l1_u1u2 = compMEtProjU(genMuon->p4(), (*hl1Etm)[0].px(), (*hl1Etm)[0].py(), errorFlag);
   if(errorFlag) return;
 
   // Do the same with calo MET for reference
   edm::Handle<std::vector<reco::CaloMET> > hCaloMet;
   iEvent.getByLabel(colCaloMET_, hCaloMet);
   assert(hCaloMet->size() == 1);
   errorFlag = 0;
   std::pair<double, double> calo_u1u2 = compMEtProjU(genMuon->p4(), (*hCaloMet)[0].px(), (*hCaloMet)[0].py(), errorFlag);
   if(errorFlag) return;
 
   // And finally fill the tree
   pt_ = recoMuon->pt();
   p_ = recoMuon->p();
   eta_ = recoMuon->eta();
   phi_ = recoMuon->phi();
   len_ecal_ = len_ecal;
   len_hcal_ = len_hcal;
   len_ho_ = len_ho;
   dep_ecal_ = dep_ecal;
   dep_hcal_ = dep_hcal;
   dep_ho_ = dep_ho;
   l1_upara_ = l1_u1u2.first;
   l1_uperp_ = l1_u1u2.second;
   calo_upara_ = calo_u1u2.first;
   calo_uperp_ = calo_u1u2.second;
   charge_ = recoMuon->charge();
 
   tree_->Fill();
 }

void AnaL1CaloCleaner::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 276 of file AnaL1CaloCleaner.cc.

References edm::ConfigurationDescriptions::addDefault(), and edm::ParameterSetDescription::setUnknown().

                                                                              {
   //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);
 }