#include <GenMuonRadCorrAnalyzer.h>

Inheritance diagram for GenMuonRadCorrAnalyzer:

Classes
struct	plotEntryType

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

void	beginJob ()

	GenMuonRadCorrAnalyzer (const edm::ParameterSet &)

	~GenMuonRadCorrAnalyzer ()

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 (const std::string &iProcessName, std::vector< const char * > &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 ()

Private Types
typedef std::vector < edm::InputTag >	vInputTag

Private Attributes
double	beamEnergy_

std::string	directory_

GenMuonRadiationAlgorithm *	muonRadiationAlgo_

int	numWarnings_

std::vector< plotEntryType * >	plotEntries_

edm::InputTag	srcGenParticles_

edm::InputTag	srcSelectedMuons_

vInputTag	srcWeights_

int	verbosity_

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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

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 24 of file GenMuonRadCorrAnalyzer.h.

Member Typedef Documentation

typedef std::vector<edm::InputTag> GenMuonRadCorrAnalyzer::vInputTag

private

Definition at line 37 of file GenMuonRadCorrAnalyzer.h.

Constructor & Destructor Documentation

GenMuonRadCorrAnalyzer::GenMuonRadCorrAnalyzer ( const edm::ParameterSet & cfg )

explicit

Definition at line 17 of file GenMuonRadCorrAnalyzer.cc.

References edm::ParameterSet::addParameter(), directory_, edm::hlt::Exception, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), muonRadiationAlgo_, plotEntries_, srcGenParticles_, srcSelectedMuons_, srcWeights_, AlCaHLTBitMon_QueryRunRegistry::string, and verbosity_.

   : beamEnergy_(cfg.getParameter<double>("beamEnergy")),
     muonRadiationAlgo_(0),
     numWarnings_(0)
 {
   srcSelectedMuons_ = cfg.getParameter<edm::InputTag>("srcSelectedMuons"); 
   srcGenParticles_  = cfg.getParameter<edm::InputTag>("srcGenParticles"); 
 
   srcWeights_ = cfg.getParameter<vInputTag>("srcWeights");
 
   directory_ = cfg.getParameter<std::string>("directory");
 
   verbosity_ = ( cfg.exists("verbosity") ) ?
     cfg.getParameter<int>("verbosity") : 0;
   
   typedef std::vector<double> vdouble;
   vdouble binningMuonEn = cfg.getParameter<vdouble>("binningMuonEn");
   int numBinsMuonEn = binningMuonEn.size() - 1;
   if ( !(numBinsMuonEn >= 1) ) throw cms::Exception("Configuration")
     << " Invalid Configuration Parameter 'binningMuonEn', must define at least one bin !!\n";
   
   unsigned numBinsRadDivMuonEn = cfg.getParameter<unsigned>("numBinsRadDivMuonEn");
   double minRadDivMuonEn = cfg.getParameter<double>("minRadDivMuonEn");
   double maxRadDivMuonEn = cfg.getParameter<double>("maxRadDivMuonEn");
 
   for ( int iBinMuPlusEn = 0; iBinMuPlusEn < numBinsMuonEn; ++iBinMuPlusEn ) {
     double minMuPlusEn = binningMuonEn[iBinMuPlusEn];
     double maxMuPlusEn = binningMuonEn[iBinMuPlusEn + 1];
     for ( int iBinMuMinusEn = 0; iBinMuMinusEn < numBinsMuonEn; ++iBinMuMinusEn ) {
       double minMuMinusEn = binningMuonEn[iBinMuMinusEn];
       double maxMuMinusEn = binningMuonEn[iBinMuMinusEn + 1];
       plotEntryType* plotEntry = 
         new plotEntryType(minMuPlusEn, maxMuPlusEn, minMuMinusEn, maxMuMinusEn, 
               numBinsRadDivMuonEn, minRadDivMuonEn, maxRadDivMuonEn);
       plotEntries_.push_back(plotEntry);
     }
   }
 
   std::string muonRadiationAlgo_string = cfg.getParameter<std::string>("muonRadiationAlgo");
   if ( muonRadiationAlgo_string == "" ) {
     muonRadiationAlgo_ = 0;
   } else if ( muonRadiationAlgo_string == "pythia" ) {
     edm::ParameterSet cfgMuonRadiationAlgo_pythia(cfg);
     cfgMuonRadiationAlgo_pythia.addParameter<std::string>("mode", "pythia");
     cfgMuonRadiationAlgo_pythia.addParameter<int>("verbosity", verbosity_);
     muonRadiationAlgo_ = new GenMuonRadiationAlgorithm(cfgMuonRadiationAlgo_pythia);
   } else if ( muonRadiationAlgo_string == "photos" ) {
     edm::ParameterSet cfgMuonRadiationAlgo_photos(cfg);
     cfgMuonRadiationAlgo_photos.addParameter<std::string>("mode", "photos");
     cfgMuonRadiationAlgo_photos.addParameter<int>("verbosity", verbosity_);
     muonRadiationAlgo_ = new GenMuonRadiationAlgorithm(cfgMuonRadiationAlgo_photos);
   } else throw cms::Exception("Configuration")
       << " Invalid Configuration Parameter 'muonRadiationAlgo' = " << muonRadiationAlgo_string << " !!\n";
 }

GenMuonRadCorrAnalyzer::~GenMuonRadCorrAnalyzer ( )

Definition at line 72 of file GenMuonRadCorrAnalyzer.cc.

References muonRadiationAlgo_, and plotEntries_.

 {
   for ( std::vector<plotEntryType*>::iterator it = plotEntries_.begin();
     it != plotEntries_.end(); ++it ) {
     delete (*it);
   }
 
   delete muonRadiationAlgo_;
 }

Member Function Documentation

void GenMuonRadCorrAnalyzer::analyze	(	const edm::Event &	evt,
		const edm::EventSetup &	es
	)

virtual

Implements edm::EDAnalyzer.

Definition at line 93 of file GenMuonRadCorrAnalyzer.cc.

References reco::LeafCandidate::charge(), GenMuonRadiationAlgorithm::compFSR(), compGenMuonP4afterRad(), alignCSCRings::e, findGenParticleForMCEmbedding(), genParticleCandidates2GenParticles_cfi::genParticles, edm::Event::getByLabel(), getSelMuons(), muonRadiationAlgo_, reco::LeafCandidate::p4(), plotEntries_, WZElectronSkims53X_cff::selectedMuons, srcGenParticles_, srcSelectedMuons_, srcWeights_, edm::Event::streamID(), and histoStyle::weight.

 {
   double evtWeight = 1.0;
   for ( vInputTag::const_iterator srcWeight = srcWeights_.begin();
     srcWeight != srcWeights_.end(); ++srcWeight ) {
     edm::Handle<double> weight;
     evt.getByLabel(*srcWeight, weight);
     evtWeight *= (*weight);
   }
 
   if ( evtWeight < 1.e-3 || evtWeight > 1.e+3 || TMath::IsNaN(evtWeight) ) return;
 
   std::vector<reco::CandidateBaseRef> selectedMuons = getSelMuons(evt, srcSelectedMuons_);
   
   edm::Handle<reco::GenParticleCollection> genParticles;
   evt.getByLabel(srcGenParticles_, genParticles);
 
   reco::Candidate::LorentzVector genMuonPlusP4_beforeRad;
   reco::Candidate::LorentzVector genMuonPlusP4_afterRad;
   bool genMuonPlus_found = false;
   reco::Candidate::LorentzVector genMuonMinusP4_beforeRad;
   reco::Candidate::LorentzVector genMuonMinusP4_afterRad;
   bool genMuonMinus_found = false;
 
   std::vector<int> muonPdgIds;
   muonPdgIds.push_back(-13);
   muonPdgIds.push_back(+13);
 
   for ( std::vector<reco::CandidateBaseRef>::const_iterator selectedMuon = selectedMuons.begin();
     selectedMuon != selectedMuons.end(); ++selectedMuon ) {
     const reco::GenParticle* genMuon_matched = findGenParticleForMCEmbedding((*selectedMuon)->p4(), *genParticles, 0.3, -1, &muonPdgIds, true);
     if ( genMuon_matched && genMuon_matched->charge() > +0.5 ) {
       genMuonPlusP4_beforeRad = genMuon_matched->p4();
       genMuonPlusP4_afterRad = genMuonPlusP4_beforeRad;
       compGenMuonP4afterRad(genMuon_matched, genMuonPlusP4_afterRad);
       genMuonPlus_found = true;
     }
     if ( genMuon_matched && genMuon_matched->charge() < -0.5 ) {
       genMuonMinusP4_beforeRad = genMuon_matched->p4();
       genMuonMinusP4_afterRad = genMuonMinusP4_beforeRad;
       compGenMuonP4afterRad(genMuon_matched, genMuonMinusP4_afterRad);
       genMuonMinus_found = true;
     }
   }
 
   if ( !(genMuonPlus_found && genMuonMinus_found) ) return;
 
   double muonPlusRad = 0.;
   int muonPlusRad_error = 0;
   double muonMinusRad = 0.;
   int muonMinusRad_error = 0;
   if ( muonRadiationAlgo_ ) {
     muonPlusRad = muonRadiationAlgo_->compFSR(evt.streamID(), genMuonPlusP4_beforeRad, +1, genMuonMinusP4_beforeRad, muonPlusRad_error).E();
     muonMinusRad = muonRadiationAlgo_->compFSR(evt.streamID(), genMuonMinusP4_beforeRad, -1, genMuonPlusP4_beforeRad, muonMinusRad_error).E();
   } else {
     muonPlusRad = genMuonPlusP4_beforeRad.E() - genMuonPlusP4_afterRad.E();
     muonMinusRad = genMuonMinusP4_beforeRad.E() - genMuonMinusP4_afterRad.E();
   }
 
   if ( muonPlusRad_error || muonMinusRad_error ) return;
 
   for ( std::vector<plotEntryType*>::iterator plotEntry = plotEntries_.begin();
     plotEntry != plotEntries_.end(); ++plotEntry ) {
     (*plotEntry)->fillHistograms(genMuonPlusP4_afterRad.E(), muonPlusRad, genMuonMinusP4_afterRad.E(), muonMinusRad, evtWeight);
   }
 }

void GenMuonRadCorrAnalyzer::beginJob ( void )

virtual

Reimplemented from edm::EDAnalyzer.

Definition at line 82 of file GenMuonRadCorrAnalyzer.cc.

References dir, directory_, TFileService::mkdir(), plotEntries_, and TFileService::tFileDirectory().

 {
   edm::Service<TFileService> fs;
 
   TFileDirectory dir = ( directory_ != "" ) ? fs->mkdir(directory_) : (fs->tFileDirectory());
   for ( std::vector<plotEntryType*>::iterator plotEntry = plotEntries_.begin();
     plotEntry != plotEntries_.end(); ++plotEntry ) {
     (*plotEntry)->bookHistograms(dir);
   }
 }