Ntuplizer Class Reference

#include <Analysis/Ntuplizer/plugins/Ntuplizer.cc>

Inheritance diagram for Ntuplizer:

Public Member Functions
	Ntuplizer (const edm::ParameterSet &)
	~Ntuplizer ()

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

Private Member Functions
virtual void	analyze (const edm::Event &, const edm::EventSetup &) override
virtual void	beginJob () override
virtual void	beginLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) override
virtual void	beginRun (edm::Run const &, edm::EventSetup const &) override
virtual void	endJob () override
virtual void	endLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) override
virtual void	endRun (edm::Run const &, edm::EventSetup const &) override

Private Attributes
std::vector< std::string >	btagAlgos_
std::vector< std::string >	btagAlgosAlias_
std::vector< TitleAlias >	btagVars_
std::vector< pCaloJetCandidates >	calojets_collections_
std::map< std::string, edm::EDGetTokenT< reco::CaloJetCollection > >	caloJetTokens_
std::vector< pChargedCandidates >	chargedcands_collections_
std::map< std::string, edm::EDGetTokenT< reco::RecoChargedCandidateCollection > >	chargedCandTokens_
edm::ParameterSet	config_
bool	do_calojets_
bool	do_chargedcands_
bool	do_eventfilter_
bool	do_geneventinfo_
bool	do_genfilter_
bool	do_genjets_
bool	do_genparticles_
bool	do_genruninfo_
bool	do_jetstags_
bool	do_l1jets_
bool	do_l1muons_
bool	do_l1tjets_
bool	do_l1tmuons_
bool	do_lumiscalers_
bool	do_patjets_
bool	do_patmets_
bool	do_patmuons_
bool	do_pfjets_
bool	do_pileupinfo_
bool	do_primaryvertices_
bool	do_recomuons_
bool	do_recotracks_
bool	do_triggeraccepts_
bool	do_triggerobjects_
InputTags	eventCounters_
analysis::ntuple::FilterResults	eventFilterResults_
pEventInfo	eventinfo_
edm::InputTag	filteredEvents_
edm::EDGetTokenT< edm::MergeableCounter >	filteredEventsToken_
edm::InputTag	filteredMHatEvents_
edm::EDGetTokenT< edm::MergeableCounter >	filteredMHatEventsToken_
edm::InputTag	fixedGridRhoAll_
edm::EDGetTokenT< double >	fixedGridRhoAllToken_
edm::InputTag	genEventInfo_
edm::EDGetTokenT< GenEventInfoProduct >	genEventInfoToken_
edm::InputTag	genFilterInfo_
edm::EDGetTokenT< GenFilterInfo >	genFilterInfoToken_
analysis::ntuple::FilterResults	genFilterResults_
std::vector< pGenJetCandidates >	genjets_collections_
std::map< std::string, edm::EDGetTokenT< reco::GenJetCollection > >	genJetTokens_
std::vector< pGenParticleCandidates >	genparticles_collections_
std::map< std::string, edm::EDGetTokenT< reco::GenParticleCollection > >	genPartTokens_
edm::InputTag	genRunInfo_
edm::EDGetTokenT< GenRunInfoProduct >	genRunInfoToken_
std::shared_ptr< HLTPrescaleProvider >	hltPrescaleProvider_
std::vector< std::string >	inputTags_
std::vector< std::string >	inputTagsVec_
bool	is_mc_
std::vector< std::string >	jecRecords_
std::vector< std::string >	jerRecords_
std::vector< pJetsTags >	jetstags_collections_
std::map< std::string, edm::EDGetTokenT< reco::JetTagCollection > >	jetTagTokens_
std::vector< pL1JetCandidates >	l1jets_collections_
std::map< std::string, edm::EDGetTokenT< l1extra::L1JetParticleCollection > >	l1JetTokens_
std::vector< pL1MuonCandidates >	l1muons_collections_
std::map< std::string, edm::EDGetTokenT< l1extra::L1MuonParticleCollection > >	l1MuonTokens_
std::vector< pL1TJetCandidates >	l1tjets_collections_
std::map< std::string, edm::EDGetTokenT< l1t::JetBxCollection > >	l1tJetTokens_
std::vector< pL1TMuonCandidates >	l1tmuons_collections_
std::map< std::string, edm::EDGetTokenT< l1t::MuonBxCollection > >	l1tMuonTokens_
edm::InputTag	lumiScalers_
edm::EDGetTokenT< LumiScalersCollection >	lumiScalersToken_
pMetadata	metadata_
InputTags	mHatEventCounters_
std::vector< pPatJetCandidates >	patjets_collections_
std::map< std::string, edm::EDGetTokenT< pat::JetCollection > >	patJetTokens_
std::vector< pPatMETCandidates >	patmets_collections_
std::map< std::string, edm::EDGetTokenT< pat::METCollection > >	patMETTokens_
std::vector< pPatMuonCandidates >	patmuons_collections_
std::map< std::string, edm::EDGetTokenT< pat::MuonCollection > >	patMuonTokens_
std::vector< pPFJetCandidates >	pfjets_collections_
std::map< std::string, edm::EDGetTokenT< reco::PFJetCollection > >	pfJetTokens_
edm::InputTag	pileupInfo_
pPileupInfo	pileupinfo_
edm::EDGetTokenT< std::vector< PileupSummaryInfo > >	pileupInfoToken_
std::map< std::string, edm::EDGetTokenT< reco::VertexCollection > >	primaryVertexTokens_
std::vector< pPrimaryVertices >	primaryvertices_collections_
bool	readprescale_
std::vector< pRecoMuonCandidates >	recomuons_collections_
std::map< std::string, edm::EDGetTokenT< reco::MuonCollection > >	recoMuonTokens_
std::vector< pRecoTrackCandidates >	recotracks_collections_
std::map< std::string, edm::EDGetTokenT< reco::TrackCollection > >	recoTrackTokens_
bool	testmode_
edm::InputTag	totalEvents_
edm::EDGetTokenT< edm::MergeableCounter >	totalEventsToken_
std::map< std::string, TTree * >	tree_
std::vector< pTriggerAccepts >	triggeraccepts_collections_
std::map< std::string, edm::EDGetTokenT< trigger::TriggerEvent > >	triggerEventTokens_
std::vector< std::string >	triggerObjectLabels_
std::vector< pTriggerObjectCandidates >	triggerobjects_collections_
std::vector< std::string >	triggerObjectSplits_
std::vector< std::string >	triggerObjectSplitsTypes_
std::vector< pTriggerObjectRecoCandidates >	triggerobjectsreco_collections_
std::map< std::string, edm::EDGetTokenT< pat::TriggerObjectStandAloneCollection > >	triggerObjTokens_
std::map< std::string, edm::EDGetTokenT< edm::TriggerResults > >	triggerResultsTokens_
bool	use_full_name_
double	xsection_

Detailed Description

Description: EDAnalyzer to produce ntuples for the CMS Higgs Analysis, meant for MSSM Hbb analysis, but it can be used in other analysis.

Implementation: [Notes on implementation]

Definition at line 173 of file Ntuplizer.cc.

Constructor & Destructor Documentation

Ntuplizer::Ntuplizer ( const edm::ParameterSet &  config )

explicit

Definition at line 342 of file Ntuplizer.cc.

References submitCrab3Data::config.

{
   
   //now do what ever initialization is needed
   is_mc_         = config.getParameter<bool> ("MonteCarlo");
   readprescale_  = true;
   if ( config.exists("ReadPrescale") )
   {
      readprescale_ = config.getParameter<bool> ("ReadPrescale");
   }
   use_full_name_ = false;
   testmode_      = false;
   inputTagsVec_ = config.getParameterNamesForType<InputTags>();
   inputTags_    = config.getParameterNamesForType<edm::InputTag>();
   
   config_  = config;
   for ( auto & inputTags : inputTagsVec_ )
   {
      InputTags collections = config_.getParameter<InputTags>(inputTags);
      for ( auto & collection : collections )
      {
         std::string label = collection.label();
         std::string inst  = collection.instance();
         std::string proc  = collection.process();
         std::string collection_name = label+"_"+inst+"_"+proc;
         if ( inputTags == "L1ExtraJets" ) l1JetTokens_[collection_name] = consumes<l1extra::L1JetParticleCollection>(collection);
         if ( inputTags == "L1ExtraMuons" ) l1MuonTokens_[collection_name] = consumes<l1extra::L1MuonParticleCollection>(collection);
         if ( inputTags == "CaloJets" ) caloJetTokens_[collection_name] = consumes<reco::CaloJetCollection>(collection);
         if ( inputTags == "PFJets" ) pfJetTokens_[collection_name] = consumes<reco::PFJetCollection>(collection);
         if ( inputTags == "RecoMuons" ) recoMuonTokens_[collection_name] = consumes<reco::MuonCollection>(collection);
         if ( inputTags == "RecoTracks" ) recoTrackTokens_[collection_name] = consumes<reco::TrackCollection>(collection);
         if ( inputTags == "PatJets" ) patJetTokens_[collection_name] = consumes<pat::JetCollection>(collection);
         if ( inputTags == "PatMETs" ) patMETTokens_[collection_name] = consumes<pat::METCollection>(collection);
         if ( inputTags == "PatMuons" ) patMuonTokens_[collection_name] = consumes<pat::MuonCollection>(collection);
         if ( inputTags == "GenJets" ) genJetTokens_[collection_name] = consumes<reco::GenJetCollection>(collection);
         if ( inputTags == "GenParticles" ) genPartTokens_[collection_name] = consumes<reco::GenParticleCollection>(collection);
         if ( inputTags == "TriggerObjectStandAlone"  ) triggerObjTokens_[collection_name] = consumes<pat::TriggerObjectStandAloneCollection>(collection);
         if ( inputTags == "TriggerEvent"  ) triggerEventTokens_[collection_name] = consumes<trigger::TriggerEvent>(collection);
         if ( inputTags == "PrimaryVertices"  ) primaryVertexTokens_[collection_name] = consumes<reco::VertexCollection>(collection);
         if ( inputTags == "TriggerResults"  ) triggerResultsTokens_[collection_name] = consumes<edm::TriggerResults>(collection);
         if ( inputTags == "JetsTags" ) jetTagTokens_[collection_name] = consumes<reco::JetTagCollection>(collection);
         if ( inputTags == "L1TJets" ) l1tJetTokens_[collection_name] = consumes<l1t::JetBxCollection>(collection);
         if ( inputTags == "L1TMuons" ) l1tMuonTokens_[collection_name] = consumes<l1t::MuonBxCollection>(collection);
         if ( inputTags == "ChargedCandidates" ) chargedCandTokens_[collection_name] = consumes<reco::RecoChargedCandidateCollection>(collection);
     }
   }
   
   hltPrescaleProvider_ = std::shared_ptr<HLTPrescaleProvider>(new HLTPrescaleProvider(config, consumesCollector(), *this));;
   
   // Single InputTag
   for ( auto & inputTag : inputTags_ )
   {
      edm::InputTag collection = config_.getParameter<edm::InputTag>(inputTag);
      // Lumi products
      if ( inputTag == "GenFilterInfo" )  { genFilterInfoToken_    = consumes<GenFilterInfo,edm::InLumi>(collection);         genFilterInfo_   = collection;}
      if ( inputTag == "TotalEvents" )    { totalEventsToken_      = consumes<edm::MergeableCounter,edm::InLumi>(collection); totalEvents_     = collection;}
      if ( inputTag == "FilteredEvents" ) { filteredEventsToken_   = consumes<edm::MergeableCounter,edm::InLumi>(collection); filteredEvents_  = collection;}
      if ( inputTag == "FilteredMHatEvents" ) { filteredMHatEventsToken_ = consumes<edm::MergeableCounter,edm::InLumi>(collection); filteredMHatEvents_  = collection;}
      if ( inputTag == "GenRunInfo" )     { genRunInfoToken_       = consumes<GenRunInfoProduct,edm::InRun>(collection);      genRunInfo_      = collection;}

      if ( inputTag == "PileupInfo" )     { pileupInfoToken_       = consumes<std::vector<PileupSummaryInfo> >(collection);   pileupInfo_      = collection;}
      if ( inputTag == "GenEventInfo" )   { genEventInfoToken_     = consumes<GenEventInfoProduct>(collection);               genEventInfo_    = collection;}
      if ( inputTag == "LumiScalers" )    { lumiScalersToken_      = consumes<LumiScalersCollection>(collection);             lumiScalers_     = collection;}
      if ( inputTag == "FixedGridRhoAll" ){ fixedGridRhoAllToken_  = consumes<double>(collection);                            fixedGridRhoAll_ = collection;}
 
   }

   
}

Ntuplizer::~Ntuplizer

(

)

Definition at line 413 of file Ntuplizer.cc.

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

}

Member Function Documentation

void Ntuplizer::analyze ( const edm::Event &  event, const edm::EventSetup &  setup  )

overrideprivatevirtual

Definition at line 427 of file Ntuplizer.cc.

{
   using namespace edm;
   
//    typedef std::vector<Provenance const*> Provenances;
//    Provenances provenances;
//    event.getAllProvenance(provenances);
//    
//    for(Provenances::iterator itProv = provenances.begin(), itProvEnd = provenances.end();
//                              itProv != itProvEnd;
//                            ++itProv) {
//       std::cout << (*itProv)->moduleLabel() << std::endl;
//                            }
//    
   // Event info
   eventinfo_ -> Fill(event);
   
//    if ( do_pileupinfo_ )
//       pileupinfo_ -> Fill(event);

   if ( is_mc_ )
   {
      // MC only stuff
   }
   
   // L1 jets
      for ( auto & collection : l1jets_collections_ )
         collection -> Fill(event);
   
   // L1 muons
      for ( auto & collection : l1muons_collections_ )
         collection -> Fill(event);
   
   // Calo jets (reco)
      for ( auto & collection : calojets_collections_ )
         collection -> Fill(event);

   // PF jets (reco)
      for ( auto & collection : pfjets_collections_ )
         collection -> Fill(event);

      // Reco muon (reco)
      for ( auto & collection : recomuons_collections_ )
         collection -> Fill(event);
   
      // Reco track (reco)
      for ( auto & collection : recotracks_collections_ )
         collection -> Fill(event);
   
      // Pat jets (pat)
      for ( auto & collection : patjets_collections_ )
         collection -> Fill(event, setup);
   
      // Pat mets (pat)
      for ( auto & collection : patmets_collections_ )
         collection -> Fill(event);
   
      // Pat muon (pat)
      for ( auto & collection : patmuons_collections_ )
         collection -> Fill(event);
   
      // Gen jets (reco)
      for ( auto & collection : genjets_collections_ )
         collection -> Fill(event);
      
      // Gen particles (reco)
      for ( auto & collection : genparticles_collections_ )
         collection -> Fill(event);
      
      // jets tags
      for ( auto & collection : jetstags_collections_ )
         collection -> Fill(event);
      
      
      // trigger accepts
      for ( auto & collection : triggeraccepts_collections_ )
         collection -> Fill(event, setup);
      
//       // trigger info
//       for ( auto & collection : triggerinfo_collections_ )
//          collection -> Fill(event, setup);
      
       // primary vertices
      for ( auto & collection : primaryvertices_collections_ )
         collection -> Fill(event);
   
      // trigger objects
      for ( auto & collection : triggerobjects_collections_ )
         collection -> Fill(event);
      
      for ( auto & collection : triggerobjectsreco_collections_ )
         collection -> Fill(event);
      
      // L1T jets
      for ( auto & collection : l1tjets_collections_ )
         collection -> Fill(event);
      // L1T muons
      for ( auto & collection : l1tmuons_collections_ )
         collection -> Fill(event);
      
   // charged candidates (reco)
      for ( auto & collection : chargedcands_collections_ )
         collection -> Fill(event);

      
}

void Ntuplizer::beginJob ( )

overrideprivatevirtual

Definition at line 537 of file Ntuplizer.cc.

References ntuplizer_102X_mc_2018_autumn18-v2::GenEventInfo, nano_94X_2017_rereco31Mar18-v1::name, and xsection_.

{
   do_pileupinfo_       = config_.exists("PileupInfo") && is_mc_;
   do_geneventinfo_     = config_.exists("GenEventInfo") && is_mc_;
   do_lumiscalers_      = config_.exists("LumiScalers");
   do_l1jets_           = config_.exists("L1ExtraJets");
   do_l1muons_          = config_.exists("L1ExtraMuons");
   do_calojets_         = config_.exists("CaloJets");
   do_pfjets_           = config_.exists("PFJets");
   do_recomuons_        = config_.exists("RecoMuons");
   do_recotracks_       = config_.exists("RecoTracks");
   do_patjets_          = config_.exists("PatJets");
   do_patmets_          = config_.exists("PatMETs");
   do_patmuons_         = config_.exists("PatMuons");
   do_genjets_          = config_.exists("GenJets");
   do_genparticles_     = config_.exists("GenParticles");
   do_jetstags_         = config_.exists("JetsTags");
//   do_triggeraccepts_   = config_.exists("TriggerResults") && config_.exists("TriggerPaths");
   do_triggeraccepts_   = config_.exists("TriggerResults");
//   do_triggerinfo_      = config_.exists("TriggerResults");
   do_primaryvertices_  = config_.exists("PrimaryVertices");
//   do_eventfilter_      = config_.exists("EventFilter");
   do_eventfilter_      = config_.exists("TotalEvents")  && config_.exists("FilteredEvents");
   do_genfilter_        = config_.exists("GenFilterInfo");
   do_triggerobjects_   = ( config_.exists("TriggerObjectStandAlone") || config_.exists("TriggerEvent") ) &&  config_.exists("TriggerObjectLabels");
   do_genruninfo_       = config_.exists("GenRunInfo") && is_mc_ ;
   do_l1tjets_          = config_.exists("L1TJets");
   do_l1tmuons_         = config_.exists("L1TMuons");
   do_chargedcands_     = config_.exists("ChargedCandidates");
   
   if ( config_.exists("TestMode") ) // This is DANGEROUS! but can be useful. So BE CAREFUL!!!!
      testmode_ = config_.getParameter<bool> ("TestMode");
   
   if ( config_.exists("UseFullName") )
      use_full_name_ = config_.getParameter<bool> ("UseFullName");

   
   edm::Service<TFileService> fs;
   
   TFileDirectory eventsDir = fs -> mkdir("Events");
   
   std::string name;
   std::string fullname;
   
   genFilterResults_  = {};
   eventFilterResults_ = {};
   
   // Btagging algorithms
   // Will set one default
   btagAlgos_.clear();
   btagAlgosAlias_.clear();
   btagAlgos_.push_back("pfCombinedInclusiveSecondaryVertexV2BJetTags");
   btagAlgosAlias_.push_back("btag_csvivf");
   if ( config_.exists("BTagAlgorithmsAlias") )
   {
      btagAlgosAlias_.clear();
      btagAlgosAlias_ = config_.getParameter< std::vector<std::string> >("BTagAlgorithmsAlias");
   }
   if ( config_.exists("BTagAlgorithms") )
   {
      btagAlgos_.clear();
      btagAlgos_ = config_.getParameter< std::vector<std::string> >("BTagAlgorithms");
   }
   if ( btagAlgos_.size() != btagAlgosAlias_.size() )
   {
      // if user put the wrong number of alias, then use the algo name as alias
      btagAlgosAlias_.clear();
      for ( auto& it : btagAlgos_ )
         btagAlgosAlias_.push_back(it);
   }
   
   btagVars_.clear();
   for ( size_t it = 0 ; it < btagAlgos_.size() ;  ++it )
   {
      btagVars_.push_back({btagAlgos_[it],btagAlgosAlias_[it]});
//      btagVars_[btagAlgosAlias_[it]] = {btagAlgos_[it],(unsigned int)it};
   }
   
   // JEC Record (from TXT files)
   std::vector<std::string > jec_files;
   // JEC Record (from CondDB)
   jecRecords_.clear();
   if ( do_patjets_ && config_.exists("JECRecords") )
   {
      jecRecords_ = config_.getParameter< std::vector<std::string> >("JECRecords");
      if(config_.exists("JECUncertaintyFiles"))
      {
         jec_files = config_.getParameter< std::vector<std::string > >("JECUncertaintyFiles");
      }
   }
   // JER Record (from TXT files)
   std::vector<std::string > jer_files;
   std::vector<std::string > jersf_files;
   // JER Record (from CondDB)
   jerRecords_.clear();
   if ( do_patjets_ && config_.exists("JERRecords") )
   {
      jerRecords_ = config_.getParameter< std::vector<std::string> >("JERRecords");
      if(config_.exists("JERResFiles"))
      {
        jer_files = config_.getParameter< std::vector<std::string > >("JERResFiles");
      }
      if(config_.exists("JERSfFiles"))
      {
        jersf_files = config_.getParameter< std::vector<std::string > >("JERSfFiles");
      }
      
   }
   //
   size_t nPatJets = 0;
   if ( do_patjets_ )
      nPatJets = config_.getParameter<InputTags>("PatJets").size();
   
   if ( nPatJets > jecRecords_.size() && jecRecords_.size() != 0 )
   {
      std::cout << "*** ERROR ***  Ntuplizer: Number of JEC Records less than the number of PatJet collections." << std::endl;;
      exit(-1);
   }
   if ( nPatJets > jerRecords_.size() && jerRecords_.size() != 0 )
   {
      std::cout << "*** ERROR ***  Ntuplizer: Number of JER Records less than the number of PatJet collections." << std::endl;;
      exit(-1);
   }
   if ( jerRecords_.size() != 0 && jer_files.size() != 0 && jersf_files.size()!=0 &&(jerRecords_.size() != jer_files.size() || jerRecords_.size() != jersf_files.size()) )
   {
        std::cerr << "*** ERROR *** Ntuplizer: Number of JER Records are not the same as number of provided input files. " <<std::endl;
        exit(-1);
   }
   
   
   // Event info tree
   eventinfo_ = pEventInfo (new EventInfo(eventsDir));
   if ( config_.exists("FixedGridRhoAll") )
   {
      eventinfo_ -> FixedGridRhoInfo(config_.getParameter<edm::InputTag>("FixedGridRhoAll"));
   }
   if ( do_pileupinfo_ )
      eventinfo_ -> PileupInfo(config_.getParameter<edm::InputTag>("PileupInfo"));
   if ( do_geneventinfo_ )
      eventinfo_ -> GenEventInfo(config_.getParameter<edm::InputTag>("GenEventInfo"));
   if ( do_lumiscalers_ )
      eventinfo_ -> LumiScalersInfo(config_.getParameter<edm::InputTag>("LumiScalers"));
   
    // Metadata 
   metadata_ = pMetadata (new Metadata(fs,is_mc_));
   metadata_ -> AddDefinitions(btagVars_,"btagging");
   // My cross section  value for the metadata
   xsection_ = -1.0;
   if ( config_.exists("CrossSection") )
      xsection_ = config_.getParameter<double>("CrossSection");
   
   edm::InputTag trgRes;
   if ( do_triggeraccepts_ ) 
   {
      InputTags trs = config_.getParameter<InputTags>("TriggerResults");
      trgRes = trs[0];
   }
   
   // split trigger objects
   bool splitTriggerObject = config_.exists("TriggerObjectSplits");
   if ( do_triggerobjects_ && triggerObjectSplits_.empty() && splitTriggerObject )
   {
      triggerObjectSplits_  = config_.getParameter< std::vector<std::string> >("TriggerObjectSplits");
      if ( ! triggerObjectSplits_.empty() && triggerObjectSplitsTypes_.empty() && config_.exists("TriggerObjectSplitsTypes") )
      {
         triggerObjectSplitsTypes_ = config_.getParameter< std::vector<std::string> >("TriggerObjectSplitsTypes");
         for ( auto & tot : triggerObjectSplitsTypes_ ) std::transform(tot.begin(), tot.end(), tot.begin(), ::tolower);
         splitTriggerObject = !triggerObjectSplitsTypes_.empty();
      }
   }
   
   if ( triggerObjectSplits_.size() != triggerObjectSplitsTypes_.size() )
   {
      std::cout << "-w- Ntuplizer: Size of trigger splits and splits types do not match!" << std::endl;
      std::cout << "               No splitting will be done" << std::endl;
      splitTriggerObject = false;
   }
   
//    if ( splitTriggerObject )
//    {
//       std::cout << "oioioi " << splitTriggerObject << std::endl;
//       for ( size_t ito = 0 ; ito < triggerObjectSplits_.size() ; ++ito )
//         std::cout << triggerObjectSplits_[ito] << "   " << triggerObjectSplitsTypes_[ito] << std::endl;
//    }
//    
//    
   
  // Input tags (vector)
   for ( auto & inputTags : inputTagsVec_ )
   {
      InputTags collections = config_.getParameter<InputTags>(inputTags);
      int patJetCounter = 0;
      for ( auto & collection : collections )
      {
         // Names for the trees, from inputs
         std::string label = collection.label();
         std::string inst  = collection.instance();
         std::string proc  = collection.process();
         name = label;
         if ( find_first(inputTags,"L1Extra") )
         {
            // renaming tree for L1 jest as there is no explicit indication those are L1 jets objects
            std::string l1obj = inputTags;
            erase_first(l1obj,"L1Extra");
            name += l1obj;
         }
         fullname = name + "_" + inst + "_" + proc;
         name += inputTags == "L1ExtraJets" && ! use_full_name_ ? "_" + inst : "";
         if ( collection.instance() != "" && collections.size() > 1 )
            name += "_" + inst;
         if ( use_full_name_ ) name = fullname;
         if ( inputTags == "L1TJets"  && l1tjets_collections_.size() == 0 )  name = "l1tJets";
         if ( inputTags == "L1TMuons" && l1tmuons_collections_.size() == 0 )  name = "l1tMuons";

         // Initialise trees
         if ( inputTags != "TriggerObjectStandAlone" && inputTags != "TriggerEvent" )
            tree_[name] = eventsDir.make<TTree>(name.c_str(),fullname.c_str());
         
         // L1 Jets
         if ( inputTags == "L1ExtraJets" )
         {
            l1jets_collections_.push_back( pL1JetCandidates( new L1JetCandidates(collection, tree_[name], is_mc_ ) ));
            l1jets_collections_.back() -> Init();
         }
         
         // L1 Muons
         if ( inputTags == "L1ExtraMuons" )
         {
            l1muons_collections_.push_back( pL1MuonCandidates( new L1MuonCandidates(collection, tree_[name], is_mc_ ) ));
            l1muons_collections_.back() -> Init();
         }
         
         // Calo Jets
         if ( inputTags == "CaloJets" )
         {
            calojets_collections_.push_back( pCaloJetCandidates( new CaloJetCandidates(collection, tree_[name], is_mc_ ) ));
            calojets_collections_.back() -> Init();
         }
         // PF Jets
         if ( inputTags == "PFJets" )
         {
            pfjets_collections_.push_back( pPFJetCandidates( new PFJetCandidates(collection, tree_[name], is_mc_ ) ));
            pfjets_collections_.back() -> Init();
         }
         // Reco Muons
         if ( inputTags == "RecoMuons" )
         {
            recomuons_collections_.push_back( pRecoMuonCandidates( new RecoMuonCandidates(collection, tree_[name], is_mc_ ) ));
            recomuons_collections_.back() -> Init();
         }
         // Reco Tracks
         if ( inputTags == "RecoTracks" )
         {
            recotracks_collections_.push_back( pRecoTrackCandidates( new RecoTrackCandidates(collection, tree_[name], is_mc_ ) ));
            recotracks_collections_.back() -> Init();
         }
         
         // Pat Jets
         if ( inputTags == "PatJets" )
         {
            patjets_collections_.push_back( pPatJetCandidates( new PatJetCandidates(collection, tree_[name], is_mc_ ) ));
            patjets_collections_.back() -> Init(btagVars_);
            patjets_collections_.back() -> QGTaggerInstance("QGTagger");
            patjets_collections_.back() -> PileupJetIdInstance("pileupJetId");
            
            if ( patJetCounter == 0 && jecRecords_.size() > 0  )  std::cout << "*** Jet Energy Corrections Records - PatJets ***" << std::endl;
            if ( jecRecords_.size() > 0  )
            {
               if ( jec_files.size() > 0 && jec_files[patJetCounter] != "" )
                  patjets_collections_.back() -> AddJecInfo(jecRecords_[patJetCounter],jec_files[patJetCounter]);  // use txt file
               else
                  patjets_collections_.back() -> AddJecInfo(jecRecords_[patJetCounter]);                           // use confdb

            }
            
            if ( patJetCounter == 0 && jerRecords_.size() > 0  ) std::cout << "*** Jet Energy Resolutions Records - PatJets ***" << std::endl;
            if ( jerRecords_.size() > 0 && is_mc_  )
            {
               if ( jer_files.size() > 0 && jer_files[patJetCounter] != "" )
                  patjets_collections_.back() -> AddJerInfo(jerRecords_[patJetCounter],jer_files[patJetCounter], jersf_files[patJetCounter],fixedGridRhoAll_);  // use txt file
               else
                  patjets_collections_.back() -> AddJerInfo(jerRecords_[patJetCounter],fixedGridRhoAll_);  // use txt file

            }
            
//             if ( jecRecords_.size() > 0 && jerRecords_.size() > 0 )
//             {
//                if (jer_files.size() != 0 && jer_files[patJetCounter] != "" && jersf_files[patJetCounter] != "")
//                {
//                  patjets_collections_.back() -> Init(btagVars_,jecRecords_[patJetCounter],jerRecords_[patJetCounter],jer_files[patJetCounter],jersf_files[patJetCounter],fixedGridRhoAll_);
//              }
//              else
//                {
//                   patjets_collections_.back() -> Init(btagVars_,jecRecords_[patJetCounter],jerRecords_[patJetCounter],fixedGridRhoAll_);
//                }
//                if ( jecRecords_[patJetCounter] != "" )  std::cout << name << " => "  << jecRecords_[patJetCounter] << std::endl;
//             }
//             else
//             {
//                patjets_collections_.back() -> Init(btagVars_);
//             }
            ++patJetCounter;
         }
         // Pat METs
         if ( inputTags == "PatMETs" )
         {
            patmets_collections_.push_back( pPatMETCandidates( new PatMETCandidates(collection, tree_[name], is_mc_) ));
            patmets_collections_.back() -> Init();
         }
         // Pat Muons
         if ( inputTags == "PatMuons" )
         {
            patmuons_collections_.push_back( pPatMuonCandidates( new PatMuonCandidates(collection, tree_[name], is_mc_ ) ));
            patmuons_collections_.back() -> Init();
         }
         // Gen Jets
         if ( inputTags == "GenJets" )
         {
            genjets_collections_.push_back( pGenJetCandidates( new GenJetCandidates(collection, tree_[name], is_mc_ ) ));
            genjets_collections_.back() -> Init();
         }
         // Gen Particles
         if ( inputTags == "GenParticles" )
         {
            genparticles_collections_.push_back( pGenParticleCandidates( new GenParticleCandidates(collection, tree_[name], is_mc_ ) ));
            genparticles_collections_.back() -> Init();
        }
         // Jets Tags
         if ( inputTags == "JetsTags" )
         {
            jetstags_collections_.push_back( pJetsTags( new JetsTags(collection, tree_[name]) ));
            jetstags_collections_.back() -> Branches();
         }
   
         // L1T Jets
         if ( inputTags == "L1TJets" )
         {
            if ( l1tjets_collections_.size() == 0 )
            {
               l1tjets_collections_.push_back( pL1TJetCandidates( new L1TJetCandidates(collection, tree_[name], is_mc_ ) ));
               l1tjets_collections_.back() -> Init();
            }
            else
            {
               std::cout << "Ntuplizer: # l1 jet collections > 1. Skipping." << std::endl;
            }
         }

         // L1T Muon
         if ( inputTags == "L1TMuons" )
         {
            if ( l1tmuons_collections_.size() == 0 )
            {
               l1tmuons_collections_.push_back( pL1TMuonCandidates( new L1TMuonCandidates(collection, tree_[name], is_mc_ ) ));
               l1tmuons_collections_.back() -> Init();
            }
            else
            {
               std::cout << "Ntuplizer: # l1 muon collections > 1. Skipping." << std::endl;
            }
         }
         // Charged candidates
         if ( inputTags == "ChargedCandidates" )
         {
            chargedcands_collections_.push_back( pChargedCandidates( new ChargedCandidates(collection, tree_[name], is_mc_ ) ));
            chargedcands_collections_.back() -> Init();
         }
         
         // Trigger Objects
         if ( do_triggeraccepts_  && do_triggerobjects_ && inputTags == "TriggerObjectStandAlone"  )
         {
            if ( triggerObjectLabels_.empty() )
               triggerObjectLabels_ = config_.getParameter< std::vector<std::string> >("TriggerObjectLabels");
            sort( triggerObjectLabels_.begin(), triggerObjectLabels_.end() );
            triggerObjectLabels_.erase( unique( triggerObjectLabels_.begin(), triggerObjectLabels_.end() ), triggerObjectLabels_.end() );
            std::string dir = name;
            TFileDirectory triggerObjectsDir = eventsDir.mkdir(dir);
      
            for ( auto & triggerObjectLabel : triggerObjectLabels_ )
            {
               name = triggerObjectLabel;
               if ( use_full_name_ ) name += "_" + dir;
               tree_[name] = triggerObjectsDir.make<TTree>(name.c_str(),name.c_str());
               triggerobjects_collections_.push_back(pTriggerObjectCandidates( new TriggerObjectCandidates(collection, tree_[name], is_mc_ ) ));
               triggerobjects_collections_.back() -> Init();
               triggerobjects_collections_.back() -> UseTriggerResults(trgRes);
               if ( splitTriggerObject )
               {
                  std::vector<std::string> types;
                  for ( size_t tos = 0; tos < triggerObjectSplits_.size() ; ++tos )
                  {
                     if ( triggerObjectSplits_.at(tos) == name )
                     {
                        boost::split(types,triggerObjectSplitsTypes_.at(tos),boost::is_any_of(":"));
                        break;
                     }
                  }
                  sort( types.begin(), types.end() );
                  types.erase( unique( types.begin(), types.end() ), types.end() );
                  for ( auto & tot : types )
                  {
                     std::string namesplit = name + "_" + tot;
                     tree_[namesplit] = triggerObjectsDir.make<TTree>(namesplit.c_str(),namesplit.c_str());
                     triggerobjects_collections_.push_back(pTriggerObjectCandidates( new TriggerObjectCandidates(collection, tree_[namesplit], is_mc_ ) ));
                     triggerobjects_collections_.back() -> Init();
                     triggerobjects_collections_.back() -> UseTriggerResults(trgRes);
                     triggerobjects_collections_.back() -> TriggerObjectType(tot);
                  }

               }
               
            }
         }
         
         if ( do_triggerobjects_ && inputTags == "TriggerEvent"  )
         {
            if ( triggerObjectLabels_.empty() )
               triggerObjectLabels_ = config_.getParameter< std::vector<std::string> >("TriggerObjectLabels");
            sort( triggerObjectLabels_.begin(), triggerObjectLabels_.end() );
            triggerObjectLabels_.erase( unique( triggerObjectLabels_.begin(), triggerObjectLabels_.end() ), triggerObjectLabels_.end() );
            std::string dir = name;
            TFileDirectory triggerObjectsDir = eventsDir.mkdir(dir);
      
            for ( auto & triggerObjectLabel : triggerObjectLabels_ )
            {
               name = triggerObjectLabel;
               if ( use_full_name_ ) name += "_" + dir;
               tree_[name] = triggerObjectsDir.make<TTree>(name.c_str(),name.c_str());
               triggerobjectsreco_collections_.push_back(pTriggerObjectRecoCandidates( new TriggerObjectRecoCandidates(collection, tree_[name], is_mc_ ) ));
               triggerobjectsreco_collections_.back() -> Init();
            }
         }
         
         // Trigger Accepts
         if ( do_triggeraccepts_ && inputTags == "TriggerResults" )
         {
            // TriggerResults collections names differ by the process, so add it to the name
            std::vector< std::string> triggerpaths;
            triggerpaths.clear();
            std::vector< std::string> l1seeds;
            l1seeds.clear();
            
            if ( config_.exists("TriggerPaths") ) triggerpaths = config_.getParameter< std::vector< std::string> >("TriggerPaths");
            if ( config_.exists("L1Seeds") ) l1seeds = config_.getParameter< std::vector< std::string> >("L1Seeds");
            
            triggeraccepts_collections_.push_back( pTriggerAccepts( new TriggerAccepts(collection, tree_[name], triggerpaths, l1seeds, hltPrescaleProvider_) ));
            triggeraccepts_collections_.back() -> Init();
            triggeraccepts_collections_.back() -> ReadPrescaleInfo(readprescale_);  // sometimes an error occurs as if the collection was not consumed!??? See TriggerAccepts
         }
         
//          // TriggerInfo
//          if ( do_triggerinfo_ && inputTags == "TriggerResults" )
//          {
//             // TriggerResults collections names differ by the process, so add it to the name
//             std::vector< std::string> triggerpaths;
//             triggerpaths.clear();
//             if ( config_.exists("TriggerPaths") ) triggerpaths = config_.getParameter< std::vector< std::string> >("TriggerPaths");
//             TFileDirectory triggerResultsDir = eventsDir.mkdir("TriggerResults");
//             
//             for ( auto & path : triggerpaths )
//             {
//                name = path;
//                tree_[name] = triggerResultsDir.make<TTree>(name.c_str(),name.c_str());
//                triggerinfo_collections_.push_back( pTriggerInfo( new TriggerInfo(collection, tree_[name], path, hltPrescaleProvider_, testmode_) ));
//                triggerinfo_collections_.back() -> ReadPrescaleInfo(readprescale_);  // sometimes an error occurs as if the collection was not consumed!??? See TriggerAccepts
//             }
//          }
         
         // Primary Vertices
         if ( inputTags == "PrimaryVertices" )
         {
            primaryvertices_collections_.push_back( pPrimaryVertices( new PrimaryVertices(collection, tree_[name]) ));
         }
         
      }
   }
      
   
   // InputTag (single, i.e. not vector)
   
   int nCounters = 0;
   int nMHatCounters = 0;
   for ( auto & inputTag : inputTags_ )
   {
      edm::InputTag collection = config_.getParameter<edm::InputTag>(inputTag);
      
         // Names for the trees, from inputs
         std::string label = collection.label();
         std::string inst  = collection.instance();
         std::string proc  = collection.process();
         name = label;
         fullname = name + "_" + inst + "_" + proc;
         if ( use_full_name_ ) name = fullname;
         
      // Generator filter
      if ( do_genfilter_ && inputTag == "GenFilterInfo" && is_mc_ )
      {
         metadata_ -> SetGeneratorFilter(config_.getParameter<edm::InputTag> ("GenFilterInfo"));
      }
      // Event filter
      if ( do_eventfilter_ )
      {
         eventCounters_.resize(2);
         mHatEventCounters_.resize(2);
         if ( inputTag == "TotalEvents" )     { eventCounters_[0] = totalEvents_; mHatEventCounters_[0] = totalEvents_; ++nCounters; ++nMHatCounters; }
         if ( inputTag == "FilteredEvents" )  { eventCounters_[1] = filteredEvents_; ++nCounters; }
         if ( inputTag == "FilteredMHatEvents" )  { mHatEventCounters_[1] = filteredMHatEvents_; ++nMHatCounters; }

         if ( nCounters == 2 )      metadata_ -> SetEventFilter(eventCounters_);
         if ( nMHatCounters == 2)   metadata_ -> SetMHatEventFilter(mHatEventCounters_);
//         std::cout<<nMHatCounters<<std::endl;
      }
      // Pileup Info
//       if ( inputTag == "PileupInfo" && is_mc_ )
//       {
//          tree_[name] = eventsDir.make<TTree>(name.c_str(),fullname.c_str());
//          pileupinfo_ = pPileupInfo( new PileupInfo(collection, tree_[name]) );
//          pileupinfo_ -> Branches();
// 
//       }
         



   } 
   
}

void Ntuplizer::beginLuminosityBlock ( edm::LuminosityBlock const &  lumi, edm::EventSetup const &  setup  )

overrideprivatevirtual

Definition at line 1100 of file Ntuplizer.cc.

{
//    // Initialize HLTConfig every lumi block
//    if ( do_triggeraccepts_ )
//    {
//       for ( size_t i = 0; i < triggeraccepts_collections_.size() ; ++i )
//       {
//          triggeraccepts_collections_[i]  -> LumiBlock(lumi,setup);
//       }
//    }
}

void Ntuplizer::beginRun ( edm::Run const &  run, edm::EventSetup const &  setup  )

overrideprivatevirtual

Definition at line 1073 of file Ntuplizer.cc.

{
   // Initialize HLTConfig every lumi block
   if ( do_triggeraccepts_ )
   {
      for ( size_t i = 0; i < triggeraccepts_collections_.size() ; ++i )
      {
         triggeraccepts_collections_[i]  -> Run(run,setup);
      }
   }
   
}

void Ntuplizer::endJob ( )

overrideprivatevirtual

Definition at line 1067 of file Ntuplizer.cc.

{
   metadata_ -> Fill();
}

void Ntuplizer::endLuminosityBlock ( edm::LuminosityBlock const &  lumi, edm::EventSetup const &  setup  )

overrideprivatevirtual

Definition at line 1116 of file Ntuplizer.cc.

{
   metadata_ -> IncrementEventFilters(lumi);
}

void Ntuplizer::endRun ( edm::Run const &  run, edm::EventSetup const &  setup  )

overrideprivatevirtual

Definition at line 1090 of file Ntuplizer.cc.

References xsection_.

{
   if ( do_genruninfo_ )
   {
      metadata_ -> SetCrossSections(run,genRunInfo_,xsection_);
   }
}

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

static

Member function.

To state exactly what you do use, even if it is no parameters. Required by EDAnalyzer?

Definition at line 1124 of file Ntuplizer.cc.

References DEFINE_FWK_MODULE().

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

Member Data Documentation

std::vector< std::string > Ntuplizer::btagAlgos_

private

Definition at line 231 of file Ntuplizer.cc.

std::vector< std::string > Ntuplizer::btagAlgosAlias_

private

Definition at line 232 of file Ntuplizer.cc.

std::vector< TitleAlias > Ntuplizer::btagVars_

private

Definition at line 236 of file Ntuplizer.cc.

std::vector<pCaloJetCandidates> Ntuplizer::calojets_collections_

private

Definition at line 300 of file Ntuplizer.cc.

std::map<std::string, edm::EDGetTokenT<reco::CaloJetCollection> > Ntuplizer::caloJetTokens_

private

Definition at line 242 of file Ntuplizer.cc.

std::vector<pChargedCandidates> Ntuplizer::chargedcands_collections_

private

Definition at line 317 of file Ntuplizer.cc.

std::map<std::string, edm::EDGetTokenT<reco::RecoChargedCandidateCollection> > Ntuplizer::chargedCandTokens_

private

Definition at line 258 of file Ntuplizer.cc.

edm::ParameterSet Ntuplizer::config_

private

Definition at line 195 of file Ntuplizer.cc.

bool Ntuplizer::do_calojets_

private

Definition at line 201 of file Ntuplizer.cc.

bool Ntuplizer::do_chargedcands_

private

Definition at line 223 of file Ntuplizer.cc.

bool Ntuplizer::do_eventfilter_

private

Definition at line 216 of file Ntuplizer.cc.

bool Ntuplizer::do_geneventinfo_

private

Definition at line 212 of file Ntuplizer.cc.

bool Ntuplizer::do_genfilter_

private

Definition at line 217 of file Ntuplizer.cc.

bool Ntuplizer::do_genjets_

private

Definition at line 208 of file Ntuplizer.cc.

bool Ntuplizer::do_genparticles_

private

Definition at line 209 of file Ntuplizer.cc.

bool Ntuplizer::do_genruninfo_

private

Definition at line 219 of file Ntuplizer.cc.

bool Ntuplizer::do_jetstags_

private

Definition at line 210 of file Ntuplizer.cc.

bool Ntuplizer::do_l1jets_

private

Definition at line 199 of file Ntuplizer.cc.

bool Ntuplizer::do_l1muons_

private

Definition at line 200 of file Ntuplizer.cc.

bool Ntuplizer::do_l1tjets_

private

Definition at line 221 of file Ntuplizer.cc.

bool Ntuplizer::do_l1tmuons_

private

Definition at line 222 of file Ntuplizer.cc.

bool Ntuplizer::do_lumiscalers_

private

Definition at line 220 of file Ntuplizer.cc.

bool Ntuplizer::do_patjets_

private

Definition at line 205 of file Ntuplizer.cc.

bool Ntuplizer::do_patmets_

private

Definition at line 206 of file Ntuplizer.cc.

bool Ntuplizer::do_patmuons_

private

Definition at line 207 of file Ntuplizer.cc.

bool Ntuplizer::do_pfjets_

private

Definition at line 202 of file Ntuplizer.cc.

bool Ntuplizer::do_pileupinfo_

private

Definition at line 211 of file Ntuplizer.cc.

bool Ntuplizer::do_primaryvertices_

private

Definition at line 215 of file Ntuplizer.cc.

bool Ntuplizer::do_recomuons_

private

Definition at line 203 of file Ntuplizer.cc.

bool Ntuplizer::do_recotracks_

private

Definition at line 204 of file Ntuplizer.cc.

bool Ntuplizer::do_triggeraccepts_

private

Definition at line 213 of file Ntuplizer.cc.

bool Ntuplizer::do_triggerobjects_

private

Definition at line 218 of file Ntuplizer.cc.

InputTags Ntuplizer::eventCounters_

private

Definition at line 287 of file Ntuplizer.cc.

analysis::ntuple::FilterResults Ntuplizer::eventFilterResults_

private

Definition at line 326 of file Ntuplizer.cc.

pEventInfo Ntuplizer::eventinfo_

private

Definition at line 293 of file Ntuplizer.cc.

edm::InputTag Ntuplizer::filteredEvents_

private

Definition at line 264 of file Ntuplizer.cc.

edm::EDGetTokenT<edm::MergeableCounter> Ntuplizer::filteredEventsToken_

private

Definition at line 276 of file Ntuplizer.cc.

edm::InputTag Ntuplizer::filteredMHatEvents_

private

Definition at line 265 of file Ntuplizer.cc.

edm::EDGetTokenT<edm::MergeableCounter> Ntuplizer::filteredMHatEventsToken_

private

Definition at line 277 of file Ntuplizer.cc.

edm::InputTag Ntuplizer::fixedGridRhoAll_

private

Definition at line 272 of file Ntuplizer.cc.

edm::EDGetTokenT<double> Ntuplizer::fixedGridRhoAllToken_

private

Definition at line 284 of file Ntuplizer.cc.

edm::InputTag Ntuplizer::genEventInfo_

private

Definition at line 269 of file Ntuplizer.cc.

edm::EDGetTokenT<GenEventInfoProduct> Ntuplizer::genEventInfoToken_

private

Definition at line 281 of file Ntuplizer.cc.

edm::InputTag Ntuplizer::genFilterInfo_

private

Definition at line 262 of file Ntuplizer.cc.

edm::EDGetTokenT<GenFilterInfo> Ntuplizer::genFilterInfoToken_

private

Definition at line 274 of file Ntuplizer.cc.

analysis::ntuple::FilterResults Ntuplizer::genFilterResults_

private

Definition at line 327 of file Ntuplizer.cc.

std::vector<pGenJetCandidates> Ntuplizer::genjets_collections_

private

Definition at line 307 of file Ntuplizer.cc.

std::map<std::string, edm::EDGetTokenT<reco::GenJetCollection> > Ntuplizer::genJetTokens_

private

Definition at line 249 of file Ntuplizer.cc.

std::vector<pGenParticleCandidates> Ntuplizer::genparticles_collections_

private

Definition at line 308 of file Ntuplizer.cc.

std::map<std::string, edm::EDGetTokenT<reco::GenParticleCollection> > Ntuplizer::genPartTokens_

private

Definition at line 250 of file Ntuplizer.cc.

edm::InputTag Ntuplizer::genRunInfo_

private

Definition at line 266 of file Ntuplizer.cc.

edm::EDGetTokenT<GenRunInfoProduct> Ntuplizer::genRunInfoToken_

private

Definition at line 278 of file Ntuplizer.cc.

std::shared_ptr<HLTPrescaleProvider> Ntuplizer::hltPrescaleProvider_

private

Definition at line 260 of file Ntuplizer.cc.

std::vector< std::string > Ntuplizer::inputTags_

private

Definition at line 230 of file Ntuplizer.cc.

std::vector< std::string > Ntuplizer::inputTagsVec_

private

Definition at line 229 of file Ntuplizer.cc.

bool Ntuplizer::is_mc_

private

Definition at line 197 of file Ntuplizer.cc.

std::vector< std::string > Ntuplizer::jecRecords_

private

Definition at line 237 of file Ntuplizer.cc.

std::vector< std::string > Ntuplizer::jerRecords_

private

Definition at line 238 of file Ntuplizer.cc.

std::vector<pJetsTags> Ntuplizer::jetstags_collections_

private

Definition at line 309 of file Ntuplizer.cc.

std::map<std::string, edm::EDGetTokenT<reco::JetTagCollection> > Ntuplizer::jetTagTokens_

private

Definition at line 255 of file Ntuplizer.cc.

std::vector<pL1JetCandidates> Ntuplizer::l1jets_collections_

private

Definition at line 298 of file Ntuplizer.cc.

std::map<std::string, edm::EDGetTokenT<l1extra::L1JetParticleCollection> > Ntuplizer::l1JetTokens_

private

Definition at line 240 of file Ntuplizer.cc.

std::vector<pL1MuonCandidates> Ntuplizer::l1muons_collections_

private

Definition at line 299 of file Ntuplizer.cc.

std::map<std::string, edm::EDGetTokenT<l1extra::L1MuonParticleCollection> > Ntuplizer::l1MuonTokens_

private

Definition at line 241 of file Ntuplizer.cc.

std::vector<pL1TJetCandidates> Ntuplizer::l1tjets_collections_

private

Definition at line 315 of file Ntuplizer.cc.

std::map<std::string, edm::EDGetTokenT<l1t::JetBxCollection> > Ntuplizer::l1tJetTokens_

private

Definition at line 256 of file Ntuplizer.cc.

std::vector<pL1TMuonCandidates> Ntuplizer::l1tmuons_collections_

private

Definition at line 316 of file Ntuplizer.cc.

std::map<std::string, edm::EDGetTokenT<l1t::MuonBxCollection> > Ntuplizer::l1tMuonTokens_

private

Definition at line 257 of file Ntuplizer.cc.

edm::InputTag Ntuplizer::lumiScalers_

private

Definition at line 270 of file Ntuplizer.cc.

edm::EDGetTokenT<LumiScalersCollection> Ntuplizer::lumiScalersToken_

private

Definition at line 282 of file Ntuplizer.cc.

pMetadata Ntuplizer::metadata_

private

Definition at line 294 of file Ntuplizer.cc.

InputTags Ntuplizer::mHatEventCounters_

private

Definition at line 288 of file Ntuplizer.cc.

std::vector<pPatJetCandidates> Ntuplizer::patjets_collections_

private

Definition at line 304 of file Ntuplizer.cc.

std::map<std::string, edm::EDGetTokenT<pat::JetCollection> > Ntuplizer::patJetTokens_

private

Definition at line 246 of file Ntuplizer.cc.

std::vector<pPatMETCandidates> Ntuplizer::patmets_collections_

private

Definition at line 305 of file Ntuplizer.cc.

std::map<std::string, edm::EDGetTokenT<pat::METCollection> > Ntuplizer::patMETTokens_

private

Definition at line 247 of file Ntuplizer.cc.

std::vector<pPatMuonCandidates> Ntuplizer::patmuons_collections_

private

Definition at line 306 of file Ntuplizer.cc.

std::map<std::string, edm::EDGetTokenT<pat::MuonCollection> > Ntuplizer::patMuonTokens_

private

Definition at line 248 of file Ntuplizer.cc.

std::vector<pPFJetCandidates> Ntuplizer::pfjets_collections_

private

Definition at line 301 of file Ntuplizer.cc.

std::map<std::string, edm::EDGetTokenT<reco::PFJetCollection> > Ntuplizer::pfJetTokens_

private

Definition at line 243 of file Ntuplizer.cc.

edm::InputTag Ntuplizer::pileupInfo_

private

Definition at line 268 of file Ntuplizer.cc.

pPileupInfo Ntuplizer::pileupinfo_

private

Definition at line 295 of file Ntuplizer.cc.

edm::EDGetTokenT<std::vector<PileupSummaryInfo> > Ntuplizer::pileupInfoToken_

private

Definition at line 280 of file Ntuplizer.cc.

std::map<std::string, edm::EDGetTokenT<reco::VertexCollection> > Ntuplizer::primaryVertexTokens_

private

Definition at line 254 of file Ntuplizer.cc.

std::vector<pPrimaryVertices> Ntuplizer::primaryvertices_collections_

private

Definition at line 310 of file Ntuplizer.cc.

bool Ntuplizer::readprescale_

private

Definition at line 225 of file Ntuplizer.cc.

std::vector<pRecoMuonCandidates> Ntuplizer::recomuons_collections_

private

Definition at line 302 of file Ntuplizer.cc.

std::map<std::string, edm::EDGetTokenT<reco::MuonCollection> > Ntuplizer::recoMuonTokens_

private

Definition at line 244 of file Ntuplizer.cc.

std::vector<pRecoTrackCandidates> Ntuplizer::recotracks_collections_

private

Definition at line 303 of file Ntuplizer.cc.

std::map<std::string, edm::EDGetTokenT<reco::TrackCollection> > Ntuplizer::recoTrackTokens_

private

Definition at line 245 of file Ntuplizer.cc.

bool Ntuplizer::testmode_

private

Definition at line 227 of file Ntuplizer.cc.

edm::InputTag Ntuplizer::totalEvents_

private

Definition at line 263 of file Ntuplizer.cc.

edm::EDGetTokenT<edm::MergeableCounter> Ntuplizer::totalEventsToken_

private

Definition at line 275 of file Ntuplizer.cc.

std::map<std::string, TTree*> Ntuplizer::tree_

private

Definition at line 290 of file Ntuplizer.cc.

std::vector<pTriggerAccepts> Ntuplizer::triggeraccepts_collections_

private

Definition at line 311 of file Ntuplizer.cc.

std::map<std::string, edm::EDGetTokenT<trigger::TriggerEvent> > Ntuplizer::triggerEventTokens_

private

Definition at line 252 of file Ntuplizer.cc.

std::vector< std::string > Ntuplizer::triggerObjectLabels_

private

Definition at line 233 of file Ntuplizer.cc.

std::vector<pTriggerObjectCandidates> Ntuplizer::triggerobjects_collections_

private

Definition at line 313 of file Ntuplizer.cc.

std::vector< std::string > Ntuplizer::triggerObjectSplits_

private

Definition at line 234 of file Ntuplizer.cc.

std::vector< std::string > Ntuplizer::triggerObjectSplitsTypes_

private

Definition at line 235 of file Ntuplizer.cc.

std::vector<pTriggerObjectRecoCandidates> Ntuplizer::triggerobjectsreco_collections_

private

Definition at line 314 of file Ntuplizer.cc.

std::map<std::string, edm::EDGetTokenT<pat::TriggerObjectStandAloneCollection> > Ntuplizer::triggerObjTokens_

private

Definition at line 251 of file Ntuplizer.cc.

std::map<std::string, edm::EDGetTokenT<edm::TriggerResults> > Ntuplizer::triggerResultsTokens_

private

Definition at line 253 of file Ntuplizer.cc.

bool Ntuplizer::use_full_name_

private

Definition at line 198 of file Ntuplizer.cc.

double Ntuplizer::xsection_

private

Definition at line 324 of file Ntuplizer.cc.

---

The documentation for this class was generated from the following file:

• Ntuplizer.cc