Analyzer/src/S8TreeMaker.cc

/**
 * S8TreeMaker
 * 
 *
 * Created by Samvel Khalatian on Sep 29, 2010
 * Copyright 2010, All rights reserved
 */

#include <iostream>
#include <vector>

#include <boost/algorithm/string.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/logic/tribool.hpp>
#include <boost/regex.hpp>

#include <TTree.h>
#include <TLorentzVector.h>
#include <TVector3.h>

#include "CommonTools/UtilAlgos/interface/TFileService.h"
#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/Common/interface/TriggerResults.h"
#include "DataFormats/PatCandidates/interface/Jet.h"
#include "DataFormats/PatCandidates/interface/Muon.h"
#include "DataFormats/PatCandidates/interface/Electron.h"
#include "DataFormats/VertexReco/interface/Vertex.h"
#include "FWCore/Common/interface/TriggerNames.h"
#include "FWCore/Framework/interface/MakerMacros.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/ServiceRegistry/interface/Service.h"
#include "FWCore/Utilities/interface/EDMException.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "SimDataFormats/GeneratorProducts/interface/GenEventInfoProduct.h"

#include "Tree/System8/interface/S8TreeInfo.h"
#include "Tree/System8/interface/S8EventID.h"
#include "Tree/System8/interface/S8GenEvent.h"
#include "Tree/System8/interface/S8GenParticle.h"
#include "Tree/System8/interface/S8Jet.h"
#include "Tree/System8/interface/S8Lepton.h"
#include "Tree/System8/interface/S8PrimaryVertex.h"
#include "Tree/System8/interface/S8TreeInfo.h"
#include "Tree/System8/interface/S8Trigger.h"
#include "Tree/System8/interface/S8TriggerCenter.h"
#include "EDModule/Analyzer/interface/Tools.h"

#include "EDModule/Analyzer/interface/S8TreeMaker.h"

using std::cout;
using std::endl;
using std::string;
using std::vector;

using boost::lexical_cast;
using boost::regex;
using boost::smatch;

using edm::errors::ErrorCodes;
using edm::Handle;
using edm::InputTag;
using edm::LogWarning;
using edm::LogInfo;
using edm::ParameterSet;
using edm::TriggerResults;
using edm::TriggerNames;

using reco::Vertex;

using s8::TreeInfo;
using s8::TriggerCenter;

using namespace top::tools;

void fillSplit(const int &status, boost::tribool &split)
{
    switch(status)
    {
        case 3: split = false;
                break;

        case 2: if (boost::indeterminate(split))
                    split = true;

                break;
    }
}

S8TreeMaker::S8TreeMaker(const edm::ParameterSet &config):
    _didInitializeHltConfigProvider(false)
{
    _primaryVertices = config.getParameter<string>("primaryVertices");
    _jets = config.getParameter<string>("jets");
    _muons = config.getParameter<string>("muons");
    _electrons = config.getParameter<string>("electrons");
    _triggers = config.getParameter<string>("triggers");

    _jetSelector = config.getParameter<ParameterSet>("jetSelector");

    _isPythia = config.getParameter<bool>("isPythia");
    _saveTriggers = config.getParameter<bool>("saveTriggers");
}

S8TreeMaker::~S8TreeMaker()
{
}

void S8TreeMaker::beginJob()
{
    cout << "Start BeginJob" << endl;

    edm::Service<TFileService> fileService;

    _treeInfo.reset(new TreeInfo);
    _triggerCenter.reset(new TriggerCenter);

    _tree = fileService->make<TTree>("s8", "System8 tree.");

    // Prepare Branches
    //
    _eventID.reset(new s8::EventID());
    _tree->Branch("eventID", _eventID.get());

    _genEvent.reset(new s8::GenEvent());
    _tree->Branch("genEvent", _genEvent.get());

    _s8Electrons.reset(new s8::Leptons());
    _tree->Branch("electrons.", _s8Electrons.get());

    _s8Jets.reset(new s8::Jets());
    _tree->Branch("jets", _s8Jets.get());

    _s8Muons.reset(new s8::Leptons());
    _tree->Branch("muons.", _s8Muons.get());

    _s8PrimaryVertices.reset(new s8::PrimaryVertices());
    _tree->Branch("primaryVertices", _s8PrimaryVertices.get());

    _s8Triggers.reset(new s8::Triggers());
    _tree->Branch("triggers", _s8Triggers.get());

    _didInitializeHltConfigProvider = false;

    cout << "BeginJob is over" << endl;
}

void S8TreeMaker::endJob()
{
    if (!_tree)
        return;

    // Tree Info is disabled for the moment until Hadd is fixed
    //
    edm::Service<TFileService> fileService;
//    TDirectory *dir = fileService->cd();
    TDirectory *dir = fileService->getBareDirectory();
    dir->WriteObject(_treeInfo.get(), "s8info");
    dir->WriteObject(_triggerCenter.get(), "s8triggers");
}

void S8TreeMaker::beginRun(const edm::Run &run,
                           const edm::EventSetup &eventSetup)
{
    using s8::Trigger;

    // Initialize HLT Config Provider for new Run
    //
    bool didChange = true;
    if (!_hltConfigProvider.init(run,
                                 eventSetup,
                                 InputTag(_triggers).process(),
                                 didChange))

        throw cms::Exception("S8TreeMaker")
            << "Failed to initialize HLTConfig for: " << _triggers;

    // Test if Trigger Menu has changed
    //
    if (!didChange &&
        _didInitializeHltConfigProvider)

        return;

    _hlts.clear();

    // Triggers are found and changed
    //
    typedef std::vector<std::string> Triggers;

    const Triggers &triggerNames = _hltConfigProvider.triggerNames();

    using s8::tools::make_hash;

    TriggerCenter::TriggerMap &triggers = _triggerCenter->triggers();

    for(Triggers::const_iterator trigger = triggerNames.begin();
        triggerNames.end() != trigger;
        ++trigger)
    {
        smatch matches;
        if (!regex_match(*trigger, matches,
                         regex("^(\\w+?)(?:_[vV](\\d+))?$")))
        {
            cout << "Do not understand Trigger Name: " << *trigger
                << endl;

            continue;
        }

        string trigger_name = matches[1];
        boost::to_lower(trigger_name);
        triggers.insert(make_pair(make_hash(trigger_name), matches[1]));

        // Found Trigger of the interest
        //
        HLT foundHLT;

        foundHLT.hash = make_hash(trigger_name);
        foundHLT.id = distance(triggerNames.begin(), trigger);
        foundHLT.version = matches[2].matched
            ? lexical_cast<int>(matches[2])
            : 0;

        _hlts[*trigger] = foundHLT;
    }

    if (_hlts.empty())
        LogWarning("S8TreeMaker")
            << "None of the searched HLT Triggers is found" << endl;

    _didInitializeHltConfigProvider = true;
}

void S8TreeMaker::analyze(const edm::Event &event,
                          const edm::EventSetup &eventSetup)
{
    if (!_tree)
        throw cms::Exception("S8TreeMaker")
            << "Tree does not exist";

    processEventID(event);
    processGenEvent(event);
    processElectrons(event);
    processJets(event);
    processMuons(event);
    processPrimaryVertices(event);

    if (_saveTriggers)
        processTriggers(event, eventSetup);

    // Write Tree entry
    //
    _tree->Fill();

    // Reset event
    //
    _eventID->reset();
    _genEvent->reset();

    for(s8::Jets::iterator jet = _s8Jets->begin();
        _s8Jets->end() != jet;
        ++jet)
    {
        delete *jet;
    }
    _s8Jets->clear();

    for(s8::Leptons::iterator electron = _s8Electrons->begin();
        _s8Electrons->end() != electron;
        ++electron)
    {
        delete *electron;
    }
    _s8Electrons->clear();

    for(s8::Leptons::iterator muon = _s8Muons->begin();
        _s8Muons->end() != muon;
        ++muon)
    {
        delete *muon;
    }
    _s8Muons->clear();

    for(s8::PrimaryVertices::iterator primaryVertex = _s8PrimaryVertices->begin();
        _s8PrimaryVertices->end() != primaryVertex;
        ++primaryVertex)
    {
        delete *primaryVertex;
    }
    _s8PrimaryVertices->clear();

    for(s8::Triggers::iterator trigger = _s8Triggers->begin();
        _s8Triggers->end() != trigger;
        ++trigger)
    {
        delete *trigger;
    }
    _s8Triggers->clear();
}

void S8TreeMaker::processEventID(const edm::Event &event)
{
    _eventID->setRun(event.id().run());
    _eventID->setLumiBlock(event.id().luminosityBlock());
    _eventID->setEvent(event.id().event());
}

void S8TreeMaker::processGenEvent(const edm::Event &event)
{
    using reco::GenParticleCollection;

    if (event.isRealData())
        return;

    // check if Event is Pythia
    //
    if (_isPythia)
    {
        Handle<GenEventInfoProduct> generator;
        event.getByLabel(InputTag("generator"), generator);

        if (!generator.isValid())
        {
            LogWarning("S8TreeMaker")
                << "failed to extract Generator";

            return;
        }

        _genEvent->setPtHat(generator->qScale());
    }

    Handle<GenParticleCollection> genParticles;
    event.getByLabel(InputTag("genParticles"), genParticles);

    boost::tribool bsplit = boost::indeterminate;
    boost::tribool csplit = boost::indeterminate;
    for(GenParticleCollection::const_iterator particle = genParticles->begin();
        genParticles->end() != particle;
        ++particle)
    {
        const int pdgID = abs(particle->pdgId());

        switch(pdgID)
        {
            case 5: fillSplit(particle->status(), bsplit);
                    break;

            case 4: fillSplit(particle->status(), csplit);
                    break;

            default: break;
        }
    }

    if (bsplit)
        _genEvent->setGluonSplitting(s8::GenEvent::BB, true);

    if (csplit)
        _genEvent->setGluonSplitting(s8::GenEvent::CC, true);
}

void S8TreeMaker::processElectrons(const edm::Event &event)
{
    using pat::ElectronCollection;

    // Extract Electrons
    //
    Handle<ElectronCollection> electrons;
    event.getByLabel(InputTag(_electrons), electrons);

    if (!electrons.isValid())
    {
        LogWarning("S8TreeMaker")
            << "failed to extract Electrons.";

        return;
    }

    // Process all Electrons
    //
    for(ElectronCollection::const_iterator electron = electrons->begin();
        electrons->end() != electron;
        ++electron)
    {
        s8::Lepton *s8Electron = new s8::Lepton();;

        setP4(s8Electron->p4(), electron->p4());
        setVertex(s8Electron->vertex(), electron->vertex());

        s8Electron->impactParameter()->first = electron->dB();
        s8Electron->impactParameter()->second = electron->edB();

        // Extract GenParticle information
        //
        if (electron->genLepton())
        {
            s8::GenParticle *s8GenParticle = s8Electron->genParticle();

            setP4(s8GenParticle->p4(), electron->genLepton()->p4());
            setVertex(s8GenParticle->vertex(), electron->genLepton()->vertex());

            s8GenParticle->setId(electron->genLepton()->pdgId());
            s8GenParticle->setStatus(electron->genLepton()->status());
            if (electron->genLepton()->mother())
                s8GenParticle->setParentId(electron->genLepton()->mother()->pdgId());
        }

        _s8Electrons->push_back(s8Electron);
    } // End loop over electrons
}

void S8TreeMaker::processJets(const edm::Event &event)
{
    using pat::JetCollection;

    // Extract Jets
    //
    Handle<JetCollection> jets;
    event.getByLabel(InputTag(_jets), jets);

    if (!jets.isValid())
    {
        LogWarning("S8TreeMaker")
            << "failed to extract Jets.";

        return;
    }

    // Process All Jets
    //
    pat::strbitset jetBitset = _jetSelector.getBitTemplate();
    for(JetCollection::const_iterator jet = jets->begin();
        jets->end() != jet;
        ++jet)
    {
        if (!_jetSelector(*jet, jetBitset))
            continue;

        using s8::Jet;
        Jet *s8Jet = new Jet();

        setP4(s8Jet->p4(), jet->p4());

        s8Jet->setFlavour(jet->partonFlavour());
        s8Jet->setTracks(jet->associatedTracks().size());

        if (jet->genParton())
        {
            s8::GenParticle *s8GenParticle = s8Jet->genParticle();

            setP4(s8GenParticle->p4(), jet->genParton()->p4());
            setVertex(s8GenParticle->vertex(), jet->genParton()->vertex());

            s8GenParticle->setId(jet->genParton()->pdgId());
            s8GenParticle->setStatus(jet->genParton()->status());
            if (jet->genParton()->mother())
                s8GenParticle->setParentId(jet->genParton()->mother()->pdgId());
        }

        // Save b-taggers
        //
        s8Jet->setBTag(Jet::TCHE,
                       jet->bDiscriminator("trackCountingHighEffBJetTags"));

        s8Jet->setBTag(Jet::TCHP,
                       jet->bDiscriminator("trackCountingHighPurBJetTags"));

        s8Jet->setBTag(Jet::JP,
                       jet->bDiscriminator("jetProbabilityBJetTags"));

        s8Jet->setBTag(Jet::SSV,
                       jet->bDiscriminator("simpleSecondaryVertexBJetTags"));

        s8Jet->setBTag(Jet::SSVHE,
                       jet->bDiscriminator("simpleSecondaryVertexHighEffBJetTags"));

        s8Jet->setBTag(Jet::SSVHP,
                       jet->bDiscriminator("simpleSecondaryVertexHighPurBJetTags"));

        s8Jet->setBTag(Jet::CSV,
                       jet->bDiscriminator("combinedSecondaryVertexBJetTags"));

        s8Jet->setBTag(Jet::CSV_MVA,
                       jet->bDiscriminator("combinedSecondaryVertexMVABJetTags"));

        s8Jet->setBTag(Jet::JBP,
                       jet->bDiscriminator("jetBProbabilityBJetTags"));

        _s8Jets->push_back(s8Jet);
    }
}

void S8TreeMaker::processMuons(const edm::Event &event)
{
    using pat::MuonCollection;

    // Extract Muons
    //
    Handle<MuonCollection> muons;
    event.getByLabel(InputTag(_muons), muons);

    if (!muons.isValid())
    {
        LogWarning("S8TreeMaker")
            << "failed to extract Muons.";

        return;
    }

    // Process all Muons
    //
    for(MuonCollection::const_iterator muon = muons->begin();
        muons->end() != muon;
        ++muon)
    {
        // Only Muons with basic cuts are saved:
        //
        if (1 >= muon->numberOfMatches())
            continue;

        s8::Lepton *s8Muon = new s8::Lepton();

        setP4(s8Muon->p4(), muon->p4());
        setVertex(s8Muon->vertex(), muon->vertex());

        s8Muon->impactParameter()->first = muon->dB();
        s8Muon->impactParameter()->second = muon->edB();

        // Extract GenParticle information
        //
        if (muon->genLepton())
        {
            s8::GenParticle *s8GenParticle = s8Muon->genParticle();

            setP4(s8GenParticle->p4(), muon->genLepton()->p4());
            setVertex(s8GenParticle->vertex(), muon->genLepton()->vertex());

            s8GenParticle->setId(muon->genLepton()->pdgId());
            s8GenParticle->setStatus(muon->genLepton()->status());
            if (muon->genLepton()->mother())
                s8GenParticle->setParentId(muon->genLepton()->mother()->pdgId());
        }

        _s8Muons->push_back(s8Muon);
    } // End loop over muons
}

void S8TreeMaker::processPrimaryVertices(const edm::Event &event)
{
    // Primary Vertices
    //
    typedef vector<Vertex> PVCollection;

    Handle<PVCollection> primaryVertices;
    event.getByLabel(InputTag(_primaryVertices), primaryVertices);

    if (!primaryVertices.isValid())
    {
        LogWarning("S8TreeMaker")
            << "failed to extract Primary Vertices.";

        return;
    }

    if (primaryVertices->empty())
    {
        LogWarning("S8TreeMaker")
            << "primary vertices collection is empty.";

        return;
    }

    // Process Primary Vertices
    //
    for(PVCollection::const_iterator vertex = primaryVertices->begin();
        primaryVertices->end() != vertex;
        ++vertex)
    {
        if (!isGoodPrimaryVertex(*vertex, event.isRealData()))
            continue;

        s8::PrimaryVertex *s8Vertex = new s8::PrimaryVertex();

        setVertex(s8Vertex->vertex(), vertex->position());
        s8Vertex->setNdof(vertex->ndof());
        s8Vertex->setRho(vertex->position().Rho());

        _s8PrimaryVertices->push_back(s8Vertex);
    }
}

void S8TreeMaker::processTriggers(const edm::Event &event,
                                  const edm::EventSetup &eventSetup)
{
    if (_hlts.empty())
        return;

    // Triggers
    //
    Handle<TriggerResults> triggers;
    event.getByLabel(InputTag(_triggers), triggers);

    if (!triggers.isValid())
    {
        LogWarning("S8TreeMaker")
            << "failed to extract Triggers";

        return;
    }

    // Process only found HLTs
    //
    for(HLTs::const_iterator hlt = _hlts.begin();
        _hlts.end() != hlt;
        ++hlt)
    {
        s8::Trigger *s8Trigger = new s8::Trigger();
        s8Trigger->setHash(hlt->second.hash);
        if (hlt->second.version)
            s8Trigger->setVersion(hlt->second.version);

        s8Trigger->setIsPass(triggers->accept(hlt->second.id));
        s8Trigger->setPrescale(_hltConfigProvider.prescaleValue(event,
            eventSetup, hlt->first));


        _s8Triggers->push_back(s8Trigger);
    }
}

bool S8TreeMaker::isGoodPrimaryVertex(const Vertex &vertex,
                                    const bool &isData)
{
    return !vertex.isFake() &&
            4 <= vertex.ndof() &&
            (isData ? 24 : 15) >= fabs(vertex.z()) &&
            2 >= fabs(vertex.position().Rho());
}

DEFINE_FWK_MODULE(S8TreeMaker);
Revision:	1.2
Committed:	Sun May 22 05:53:31 2011 UTC (13 years, 11 months ago) by yumiceva
Content type:	text/plain
Branch:	MAIN
CVS Tags:	V00-00-01
Changes since 1.1:	+2 -1 lines
Log Message:	fixes to compile with scram
#	User	Rev	Content
1	samvel	1.1	/**
2			* S8TreeMaker
3			*
4			*
5			* Created by Samvel Khalatian on Sep 29, 2010
6			* Copyright 2010, All rights reserved
7			*/
8
9			#include <iostream>
10			#include <vector>
11
12			#include <boost/algorithm/string.hpp>
13			#include <boost/lexical_cast.hpp>
14			#include <boost/logic/tribool.hpp>
15			#include <boost/regex.hpp>
16
17			#include <TTree.h>
18			#include <TLorentzVector.h>
19			#include <TVector3.h>
20
21			#include "CommonTools/UtilAlgos/interface/TFileService.h"
22			#include "DataFormats/Common/interface/Handle.h"
23			#include "DataFormats/Common/interface/TriggerResults.h"
24			#include "DataFormats/PatCandidates/interface/Jet.h"
25			#include "DataFormats/PatCandidates/interface/Muon.h"
26			#include "DataFormats/PatCandidates/interface/Electron.h"
27			#include "DataFormats/VertexReco/interface/Vertex.h"
28			#include "FWCore/Common/interface/TriggerNames.h"
29			#include "FWCore/Framework/interface/MakerMacros.h"
30			#include "FWCore/Framework/interface/Event.h"
31			#include "FWCore/MessageLogger/interface/MessageLogger.h"
32			#include "FWCore/ParameterSet/interface/ParameterSet.h"
33			#include "FWCore/ServiceRegistry/interface/Service.h"
34			#include "FWCore/Utilities/interface/EDMException.h"
35			#include "FWCore/Utilities/interface/InputTag.h"
36			#include "SimDataFormats/GeneratorProducts/interface/GenEventInfoProduct.h"
37
38			#include "Tree/System8/interface/S8TreeInfo.h"
39			#include "Tree/System8/interface/S8EventID.h"
40			#include "Tree/System8/interface/S8GenEvent.h"
41			#include "Tree/System8/interface/S8GenParticle.h"
42			#include "Tree/System8/interface/S8Jet.h"
43			#include "Tree/System8/interface/S8Lepton.h"
44			#include "Tree/System8/interface/S8PrimaryVertex.h"
45			#include "Tree/System8/interface/S8TreeInfo.h"
46			#include "Tree/System8/interface/S8Trigger.h"
47			#include "Tree/System8/interface/S8TriggerCenter.h"
48			#include "EDModule/Analyzer/interface/Tools.h"
49
50			#include "EDModule/Analyzer/interface/S8TreeMaker.h"
51
52			using std::cout;
53			using std::endl;
54			using std::string;
55			using std::vector;
56
57			using boost::lexical_cast;
58			using boost::regex;
59			using boost::smatch;
60
61			using edm::errors::ErrorCodes;
62			using edm::Handle;
63			using edm::InputTag;
64			using edm::LogWarning;
65			using edm::LogInfo;
66			using edm::ParameterSet;
67			using edm::TriggerResults;
68			using edm::TriggerNames;
69
70			using reco::Vertex;
71
72			using s8::TreeInfo;
73			using s8::TriggerCenter;
74
75			using namespace top::tools;
76
77			void fillSplit(const int &status, boost::tribool &split)
78			{
79			switch(status)
80			{
81			case 3: split = false;
82			break;
83
84			case 2: if (boost::indeterminate(split))
85			split = true;
86
87			break;
88			}
89			}
90
91			S8TreeMaker::S8TreeMaker(const edm::ParameterSet &config):
92			_didInitializeHltConfigProvider(false)
93			{
94			_primaryVertices = config.getParameter<string>("primaryVertices");
95			_jets = config.getParameter<string>("jets");
96			_muons = config.getParameter<string>("muons");
97			_electrons = config.getParameter<string>("electrons");
98			_triggers = config.getParameter<string>("triggers");
99
100			_jetSelector = config.getParameter<ParameterSet>("jetSelector");
101
102			_isPythia = config.getParameter<bool>("isPythia");
103			_saveTriggers = config.getParameter<bool>("saveTriggers");
104			}
105
106			S8TreeMaker::~S8TreeMaker()
107			{
108			}
109
110			void S8TreeMaker::beginJob()
111			{
112			cout << "Start BeginJob" << endl;
113
114			edm::Service<TFileService> fileService;
115
116			_treeInfo.reset(new TreeInfo);
117			_triggerCenter.reset(new TriggerCenter);
118
119			_tree = fileService->make<TTree>("s8", "System8 tree.");
120
121			// Prepare Branches
122			//
123			_eventID.reset(new s8::EventID());
124			_tree->Branch("eventID", _eventID.get());
125
126			_genEvent.reset(new s8::GenEvent());
127			_tree->Branch("genEvent", _genEvent.get());
128
129			_s8Electrons.reset(new s8::Leptons());
130			_tree->Branch("electrons.", _s8Electrons.get());
131
132			_s8Jets.reset(new s8::Jets());
133			_tree->Branch("jets", _s8Jets.get());
134
135			_s8Muons.reset(new s8::Leptons());
136			_tree->Branch("muons.", _s8Muons.get());
137
138			_s8PrimaryVertices.reset(new s8::PrimaryVertices());
139			_tree->Branch("primaryVertices", _s8PrimaryVertices.get());
140
141			_s8Triggers.reset(new s8::Triggers());
142			_tree->Branch("triggers", _s8Triggers.get());
143
144			_didInitializeHltConfigProvider = false;
145
146			cout << "BeginJob is over" << endl;
147			}
148
149			void S8TreeMaker::endJob()
150			{
151			if (!_tree)
152			return;
153
154			// Tree Info is disabled for the moment until Hadd is fixed
155			//
156			edm::Service<TFileService> fileService;
157	yumiceva	1.2	// TDirectory *dir = fileService->cd();
158			TDirectory *dir = fileService->getBareDirectory();
159	samvel	1.1	dir->WriteObject(_treeInfo.get(), "s8info");
160			dir->WriteObject(_triggerCenter.get(), "s8triggers");
161			}
162
163			void S8TreeMaker::beginRun(const edm::Run &run,
164			const edm::EventSetup &eventSetup)
165			{
166			using s8::Trigger;
167
168			// Initialize HLT Config Provider for new Run
169			//
170			bool didChange = true;
171			if (!_hltConfigProvider.init(run,
172			eventSetup,
173			InputTag(_triggers).process(),
174			didChange))
175
176			throw cms::Exception("S8TreeMaker")
177			<< "Failed to initialize HLTConfig for: " << _triggers;
178
179			// Test if Trigger Menu has changed
180			//
181			if (!didChange &&
182			_didInitializeHltConfigProvider)
183
184			return;
185
186			_hlts.clear();
187
188			// Triggers are found and changed
189			//
190			typedef std::vector<std::string> Triggers;
191
192			const Triggers &triggerNames = _hltConfigProvider.triggerNames();
193
194			using s8::tools::make_hash;
195
196			TriggerCenter::TriggerMap &triggers = _triggerCenter->triggers();
197
198			for(Triggers::const_iterator trigger = triggerNames.begin();
199			triggerNames.end() != trigger;
200			++trigger)
201			{
202			smatch matches;
203			if (!regex_match(*trigger, matches,
204			regex("^(\\w+?)(?:_[vV](\\d+))?$")))
205			{
206			cout << "Do not understand Trigger Name: " << *trigger
207			<< endl;
208
209			continue;
210			}
211
212			string trigger_name = matches[1];
213			boost::to_lower(trigger_name);
214			triggers.insert(make_pair(make_hash(trigger_name), matches[1]));
215
216			// Found Trigger of the interest
217			//
218			HLT foundHLT;
219
220			foundHLT.hash = make_hash(trigger_name);
221			foundHLT.id = distance(triggerNames.begin(), trigger);
222			foundHLT.version = matches[2].matched
223			? lexical_cast<int>(matches[2])
224			: 0;
225
226			_hlts[*trigger] = foundHLT;
227			}
228
229			if (_hlts.empty())
230			LogWarning("S8TreeMaker")
231			<< "None of the searched HLT Triggers is found" << endl;
232
233			_didInitializeHltConfigProvider = true;
234			}
235
236			void S8TreeMaker::analyze(const edm::Event &event,
237			const edm::EventSetup &eventSetup)
238			{
239			if (!_tree)
240			throw cms::Exception("S8TreeMaker")
241			<< "Tree does not exist";
242
243			processEventID(event);
244			processGenEvent(event);
245			processElectrons(event);
246			processJets(event);
247			processMuons(event);
248			processPrimaryVertices(event);
249
250			if (_saveTriggers)
251			processTriggers(event, eventSetup);
252
253			// Write Tree entry
254			//
255			_tree->Fill();
256
257			// Reset event
258			//
259			_eventID->reset();
260			_genEvent->reset();
261
262			for(s8::Jets::iterator jet = _s8Jets->begin();
263			_s8Jets->end() != jet;
264			++jet)
265			{
266			delete *jet;
267			}
268			_s8Jets->clear();
269
270			for(s8::Leptons::iterator electron = _s8Electrons->begin();
271			_s8Electrons->end() != electron;
272			++electron)
273			{
274			delete *electron;
275			}
276			_s8Electrons->clear();
277
278			for(s8::Leptons::iterator muon = _s8Muons->begin();
279			_s8Muons->end() != muon;
280			++muon)
281			{
282			delete *muon;
283			}
284			_s8Muons->clear();
285
286			for(s8::PrimaryVertices::iterator primaryVertex = _s8PrimaryVertices->begin();
287			_s8PrimaryVertices->end() != primaryVertex;
288			++primaryVertex)
289			{
290			delete *primaryVertex;
291			}
292			_s8PrimaryVertices->clear();
293
294			for(s8::Triggers::iterator trigger = _s8Triggers->begin();
295			_s8Triggers->end() != trigger;
296			++trigger)
297			{
298			delete *trigger;
299			}
300			_s8Triggers->clear();
301			}
302
303			void S8TreeMaker::processEventID(const edm::Event &event)
304			{
305			_eventID->setRun(event.id().run());
306			_eventID->setLumiBlock(event.id().luminosityBlock());
307			_eventID->setEvent(event.id().event());
308			}
309
310			void S8TreeMaker::processGenEvent(const edm::Event &event)
311			{
312			using reco::GenParticleCollection;
313
314			if (event.isRealData())
315			return;
316
317			// check if Event is Pythia
318			//
319			if (_isPythia)
320			{
321			Handle<GenEventInfoProduct> generator;
322			event.getByLabel(InputTag("generator"), generator);
323
324			if (!generator.isValid())
325			{
326			LogWarning("S8TreeMaker")
327			<< "failed to extract Generator";
328
329			return;
330			}
331
332			_genEvent->setPtHat(generator->qScale());
333			}
334
335			Handle<GenParticleCollection> genParticles;
336			event.getByLabel(InputTag("genParticles"), genParticles);
337
338			boost::tribool bsplit = boost::indeterminate;
339			boost::tribool csplit = boost::indeterminate;
340			for(GenParticleCollection::const_iterator particle = genParticles->begin();
341			genParticles->end() != particle;
342			++particle)
343			{
344			const int pdgID = abs(particle->pdgId());
345
346			switch(pdgID)
347			{
348			case 5: fillSplit(particle->status(), bsplit);
349			break;
350
351			case 4: fillSplit(particle->status(), csplit);
352			break;
353
354			default: break;
355			}
356			}
357
358			if (bsplit)
359			_genEvent->setGluonSplitting(s8::GenEvent::BB, true);
360
361			if (csplit)
362			_genEvent->setGluonSplitting(s8::GenEvent::CC, true);
363			}
364
365			void S8TreeMaker::processElectrons(const edm::Event &event)
366			{
367			using pat::ElectronCollection;
368
369			// Extract Electrons
370			//
371			Handle<ElectronCollection> electrons;
372			event.getByLabel(InputTag(_electrons), electrons);
373
374			if (!electrons.isValid())
375			{
376			LogWarning("S8TreeMaker")
377			<< "failed to extract Electrons.";
378
379			return;
380			}
381
382			// Process all Electrons
383			//
384			for(ElectronCollection::const_iterator electron = electrons->begin();
385			electrons->end() != electron;
386			++electron)
387			{
388			s8::Lepton *s8Electron = new s8::Lepton();;
389
390			setP4(s8Electron->p4(), electron->p4());
391			setVertex(s8Electron->vertex(), electron->vertex());
392
393			s8Electron->impactParameter()->first = electron->dB();
394			s8Electron->impactParameter()->second = electron->edB();
395
396			// Extract GenParticle information
397			//
398			if (electron->genLepton())
399			{
400			s8::GenParticle *s8GenParticle = s8Electron->genParticle();
401
402			setP4(s8GenParticle->p4(), electron->genLepton()->p4());
403			setVertex(s8GenParticle->vertex(), electron->genLepton()->vertex());
404
405			s8GenParticle->setId(electron->genLepton()->pdgId());
406			s8GenParticle->setStatus(electron->genLepton()->status());
407			if (electron->genLepton()->mother())
408			s8GenParticle->setParentId(electron->genLepton()->mother()->pdgId());
409			}
410
411			_s8Electrons->push_back(s8Electron);
412			} // End loop over electrons
413			}
414
415			void S8TreeMaker::processJets(const edm::Event &event)
416			{
417			using pat::JetCollection;
418
419			// Extract Jets
420			//
421			Handle<JetCollection> jets;
422			event.getByLabel(InputTag(_jets), jets);
423
424			if (!jets.isValid())
425			{
426			LogWarning("S8TreeMaker")
427			<< "failed to extract Jets.";
428
429			return;
430			}
431
432			// Process All Jets
433			//
434			pat::strbitset jetBitset = _jetSelector.getBitTemplate();
435			for(JetCollection::const_iterator jet = jets->begin();
436			jets->end() != jet;
437			++jet)
438			{
439			if (!_jetSelector(*jet, jetBitset))
440			continue;
441
442			using s8::Jet;
443			Jet *s8Jet = new Jet();
444
445			setP4(s8Jet->p4(), jet->p4());
446
447			s8Jet->setFlavour(jet->partonFlavour());
448			s8Jet->setTracks(jet->associatedTracks().size());
449
450			if (jet->genParton())
451			{
452			s8::GenParticle *s8GenParticle = s8Jet->genParticle();
453
454			setP4(s8GenParticle->p4(), jet->genParton()->p4());
455			setVertex(s8GenParticle->vertex(), jet->genParton()->vertex());
456
457			s8GenParticle->setId(jet->genParton()->pdgId());
458			s8GenParticle->setStatus(jet->genParton()->status());
459			if (jet->genParton()->mother())
460			s8GenParticle->setParentId(jet->genParton()->mother()->pdgId());
461			}
462
463			// Save b-taggers
464			//
465			s8Jet->setBTag(Jet::TCHE,
466			jet->bDiscriminator("trackCountingHighEffBJetTags"));
467
468			s8Jet->setBTag(Jet::TCHP,
469			jet->bDiscriminator("trackCountingHighPurBJetTags"));
470
471			s8Jet->setBTag(Jet::JP,
472			jet->bDiscriminator("jetProbabilityBJetTags"));
473
474			s8Jet->setBTag(Jet::SSV,
475			jet->bDiscriminator("simpleSecondaryVertexBJetTags"));
476
477			s8Jet->setBTag(Jet::SSVHE,
478			jet->bDiscriminator("simpleSecondaryVertexHighEffBJetTags"));
479
480			s8Jet->setBTag(Jet::SSVHP,
481			jet->bDiscriminator("simpleSecondaryVertexHighPurBJetTags"));
482
483			s8Jet->setBTag(Jet::CSV,
484			jet->bDiscriminator("combinedSecondaryVertexBJetTags"));
485
486			s8Jet->setBTag(Jet::CSV_MVA,
487			jet->bDiscriminator("combinedSecondaryVertexMVABJetTags"));
488
489			s8Jet->setBTag(Jet::JBP,
490			jet->bDiscriminator("jetBProbabilityBJetTags"));
491
492			_s8Jets->push_back(s8Jet);
493			}
494			}
495
496			void S8TreeMaker::processMuons(const edm::Event &event)
497			{
498			using pat::MuonCollection;
499
500			// Extract Muons
501			//
502			Handle<MuonCollection> muons;
503			event.getByLabel(InputTag(_muons), muons);
504
505			if (!muons.isValid())
506			{
507			LogWarning("S8TreeMaker")
508			<< "failed to extract Muons.";
509
510			return;
511			}
512
513			// Process all Muons
514			//
515			for(MuonCollection::const_iterator muon = muons->begin();
516			muons->end() != muon;
517			++muon)
518			{
519			// Only Muons with basic cuts are saved:
520			//
521			if (1 >= muon->numberOfMatches())
522			continue;
523
524			s8::Lepton *s8Muon = new s8::Lepton();
525
526			setP4(s8Muon->p4(), muon->p4());
527			setVertex(s8Muon->vertex(), muon->vertex());
528
529			s8Muon->impactParameter()->first = muon->dB();
530			s8Muon->impactParameter()->second = muon->edB();
531
532			// Extract GenParticle information
533			//
534			if (muon->genLepton())
535			{
536			s8::GenParticle *s8GenParticle = s8Muon->genParticle();
537
538			setP4(s8GenParticle->p4(), muon->genLepton()->p4());
539			setVertex(s8GenParticle->vertex(), muon->genLepton()->vertex());
540
541			s8GenParticle->setId(muon->genLepton()->pdgId());
542			s8GenParticle->setStatus(muon->genLepton()->status());
543			if (muon->genLepton()->mother())
544			s8GenParticle->setParentId(muon->genLepton()->mother()->pdgId());
545			}
546
547			_s8Muons->push_back(s8Muon);
548			} // End loop over muons
549			}
550
551			void S8TreeMaker::processPrimaryVertices(const edm::Event &event)
552			{
553			// Primary Vertices
554			//
555			typedef vector<Vertex> PVCollection;
556
557			Handle<PVCollection> primaryVertices;
558			event.getByLabel(InputTag(_primaryVertices), primaryVertices);
559
560			if (!primaryVertices.isValid())
561			{
562			LogWarning("S8TreeMaker")
563			<< "failed to extract Primary Vertices.";
564
565			return;
566			}
567
568			if (primaryVertices->empty())
569			{
570			LogWarning("S8TreeMaker")
571			<< "primary vertices collection is empty.";
572
573			return;
574			}
575
576			// Process Primary Vertices
577			//
578			for(PVCollection::const_iterator vertex = primaryVertices->begin();
579			primaryVertices->end() != vertex;
580			++vertex)
581			{
582			if (!isGoodPrimaryVertex(*vertex, event.isRealData()))
583			continue;
584
585			s8::PrimaryVertex *s8Vertex = new s8::PrimaryVertex();
586
587			setVertex(s8Vertex->vertex(), vertex->position());
588			s8Vertex->setNdof(vertex->ndof());
589			s8Vertex->setRho(vertex->position().Rho());
590
591			_s8PrimaryVertices->push_back(s8Vertex);
592			}
593			}
594
595			void S8TreeMaker::processTriggers(const edm::Event &event,
596			const edm::EventSetup &eventSetup)
597			{
598			if (_hlts.empty())
599			return;
600
601			// Triggers
602			//
603			Handle<TriggerResults> triggers;
604			event.getByLabel(InputTag(_triggers), triggers);
605
606			if (!triggers.isValid())
607			{
608			LogWarning("S8TreeMaker")
609			<< "failed to extract Triggers";
610
611			return;
612			}
613
614			// Process only found HLTs
615			//
616			for(HLTs::const_iterator hlt = _hlts.begin();
617			_hlts.end() != hlt;
618			++hlt)
619			{
620			s8::Trigger *s8Trigger = new s8::Trigger();
621			s8Trigger->setHash(hlt->second.hash);
622			if (hlt->second.version)
623			s8Trigger->setVersion(hlt->second.version);
624
625			s8Trigger->setIsPass(triggers->accept(hlt->second.id));
626			s8Trigger->setPrescale(_hltConfigProvider.prescaleValue(event,
627			eventSetup, hlt->first));
628
629
630			_s8Triggers->push_back(s8Trigger);
631			}
632			}
633
634			bool S8TreeMaker::isGoodPrimaryVertex(const Vertex &vertex,
635			const bool &isData)
636			{
637			return !vertex.isFake() &&
638			4 <= vertex.ndof() &&
639			(isData ? 24 : 15) >= fabs(vertex.z()) &&
640			2 >= fabs(vertex.position().Rho());
641			}
642
643			DEFINE_FWK_MODULE(S8TreeMaker);