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();
    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.1
Committed:	Fri May 6 13:51:09 2011 UTC (14 years ago) by samvel
Content type:	text/plain
Branch:	MAIN
Log Message:	Add Analyzer code
#	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			TDirectory *dir = fileService->cd();
158			dir->WriteObject(_treeInfo.get(), "s8info");
159			dir->WriteObject(_triggerCenter.get(), "s8triggers");
160			}
161
162			void S8TreeMaker::beginRun(const edm::Run &run,
163			const edm::EventSetup &eventSetup)
164			{
165			using s8::Trigger;
166
167			// Initialize HLT Config Provider for new Run
168			//
169			bool didChange = true;
170			if (!_hltConfigProvider.init(run,
171			eventSetup,
172			InputTag(_triggers).process(),
173			didChange))
174
175			throw cms::Exception("S8TreeMaker")
176			<< "Failed to initialize HLTConfig for: " << _triggers;
177
178			// Test if Trigger Menu has changed
179			//
180			if (!didChange &&
181			_didInitializeHltConfigProvider)
182
183			return;
184
185			_hlts.clear();
186
187			// Triggers are found and changed
188			//
189			typedef std::vector<std::string> Triggers;
190
191			const Triggers &triggerNames = _hltConfigProvider.triggerNames();
192
193			using s8::tools::make_hash;
194
195			TriggerCenter::TriggerMap &triggers = _triggerCenter->triggers();
196
197			for(Triggers::const_iterator trigger = triggerNames.begin();
198			triggerNames.end() != trigger;
199			++trigger)
200			{
201			smatch matches;
202			if (!regex_match(*trigger, matches,
203			regex("^(\\w+?)(?:_[vV](\\d+))?$")))
204			{
205			cout << "Do not understand Trigger Name: " << *trigger
206			<< endl;
207
208			continue;
209			}
210
211			string trigger_name = matches[1];
212			boost::to_lower(trigger_name);
213			triggers.insert(make_pair(make_hash(trigger_name), matches[1]));
214
215			// Found Trigger of the interest
216			//
217			HLT foundHLT;
218
219			foundHLT.hash = make_hash(trigger_name);
220			foundHLT.id = distance(triggerNames.begin(), trigger);
221			foundHLT.version = matches[2].matched
222			? lexical_cast<int>(matches[2])
223			: 0;
224
225			_hlts[*trigger] = foundHLT;
226			}
227
228			if (_hlts.empty())
229			LogWarning("S8TreeMaker")
230			<< "None of the searched HLT Triggers is found" << endl;
231
232			_didInitializeHltConfigProvider = true;
233			}
234
235			void S8TreeMaker::analyze(const edm::Event &event,
236			const edm::EventSetup &eventSetup)
237			{
238			if (!_tree)
239			throw cms::Exception("S8TreeMaker")
240			<< "Tree does not exist";
241
242			processEventID(event);
243			processGenEvent(event);
244			processElectrons(event);
245			processJets(event);
246			processMuons(event);
247			processPrimaryVertices(event);
248
249			if (_saveTriggers)
250			processTriggers(event, eventSetup);
251
252			// Write Tree entry
253			//
254			_tree->Fill();
255
256			// Reset event
257			//
258			_eventID->reset();
259			_genEvent->reset();
260
261			for(s8::Jets::iterator jet = _s8Jets->begin();
262			_s8Jets->end() != jet;
263			++jet)
264			{
265			delete *jet;
266			}
267			_s8Jets->clear();
268
269			for(s8::Leptons::iterator electron = _s8Electrons->begin();
270			_s8Electrons->end() != electron;
271			++electron)
272			{
273			delete *electron;
274			}
275			_s8Electrons->clear();
276
277			for(s8::Leptons::iterator muon = _s8Muons->begin();
278			_s8Muons->end() != muon;
279			++muon)
280			{
281			delete *muon;
282			}
283			_s8Muons->clear();
284
285			for(s8::PrimaryVertices::iterator primaryVertex = _s8PrimaryVertices->begin();
286			_s8PrimaryVertices->end() != primaryVertex;
287			++primaryVertex)
288			{
289			delete *primaryVertex;
290			}
291			_s8PrimaryVertices->clear();
292
293			for(s8::Triggers::iterator trigger = _s8Triggers->begin();
294			_s8Triggers->end() != trigger;
295			++trigger)
296			{
297			delete *trigger;
298			}
299			_s8Triggers->clear();
300			}
301
302			void S8TreeMaker::processEventID(const edm::Event &event)
303			{
304			_eventID->setRun(event.id().run());
305			_eventID->setLumiBlock(event.id().luminosityBlock());
306			_eventID->setEvent(event.id().event());
307			}
308
309			void S8TreeMaker::processGenEvent(const edm::Event &event)
310			{
311			using reco::GenParticleCollection;
312
313			if (event.isRealData())
314			return;
315
316			// check if Event is Pythia
317			//
318			if (_isPythia)
319			{
320			Handle<GenEventInfoProduct> generator;
321			event.getByLabel(InputTag("generator"), generator);
322
323			if (!generator.isValid())
324			{
325			LogWarning("S8TreeMaker")
326			<< "failed to extract Generator";
327
328			return;
329			}
330
331			_genEvent->setPtHat(generator->qScale());
332			}
333
334			Handle<GenParticleCollection> genParticles;
335			event.getByLabel(InputTag("genParticles"), genParticles);
336
337			boost::tribool bsplit = boost::indeterminate;
338			boost::tribool csplit = boost::indeterminate;
339			for(GenParticleCollection::const_iterator particle = genParticles->begin();
340			genParticles->end() != particle;
341			++particle)
342			{
343			const int pdgID = abs(particle->pdgId());
344
345			switch(pdgID)
346			{
347			case 5: fillSplit(particle->status(), bsplit);
348			break;
349
350			case 4: fillSplit(particle->status(), csplit);
351			break;
352
353			default: break;
354			}
355			}
356
357			if (bsplit)
358			_genEvent->setGluonSplitting(s8::GenEvent::BB, true);
359
360			if (csplit)
361			_genEvent->setGluonSplitting(s8::GenEvent::CC, true);
362			}
363
364			void S8TreeMaker::processElectrons(const edm::Event &event)
365			{
366			using pat::ElectronCollection;
367
368			// Extract Electrons
369			//
370			Handle<ElectronCollection> electrons;
371			event.getByLabel(InputTag(_electrons), electrons);
372
373			if (!electrons.isValid())
374			{
375			LogWarning("S8TreeMaker")
376			<< "failed to extract Electrons.";
377
378			return;
379			}
380
381			// Process all Electrons
382			//
383			for(ElectronCollection::const_iterator electron = electrons->begin();
384			electrons->end() != electron;
385			++electron)
386			{
387			s8::Lepton *s8Electron = new s8::Lepton();;
388
389			setP4(s8Electron->p4(), electron->p4());
390			setVertex(s8Electron->vertex(), electron->vertex());
391
392			s8Electron->impactParameter()->first = electron->dB();
393			s8Electron->impactParameter()->second = electron->edB();
394
395			// Extract GenParticle information
396			//
397			if (electron->genLepton())
398			{
399			s8::GenParticle *s8GenParticle = s8Electron->genParticle();
400
401			setP4(s8GenParticle->p4(), electron->genLepton()->p4());
402			setVertex(s8GenParticle->vertex(), electron->genLepton()->vertex());
403
404			s8GenParticle->setId(electron->genLepton()->pdgId());
405			s8GenParticle->setStatus(electron->genLepton()->status());
406			if (electron->genLepton()->mother())
407			s8GenParticle->setParentId(electron->genLepton()->mother()->pdgId());
408			}
409
410			_s8Electrons->push_back(s8Electron);
411			} // End loop over electrons
412			}
413
414			void S8TreeMaker::processJets(const edm::Event &event)
415			{
416			using pat::JetCollection;
417
418			// Extract Jets
419			//
420			Handle<JetCollection> jets;
421			event.getByLabel(InputTag(_jets), jets);
422
423			if (!jets.isValid())
424			{
425			LogWarning("S8TreeMaker")
426			<< "failed to extract Jets.";
427
428			return;
429			}
430
431			// Process All Jets
432			//
433			pat::strbitset jetBitset = _jetSelector.getBitTemplate();
434			for(JetCollection::const_iterator jet = jets->begin();
435			jets->end() != jet;
436			++jet)
437			{
438			if (!_jetSelector(*jet, jetBitset))
439			continue;
440
441			using s8::Jet;
442			Jet *s8Jet = new Jet();
443
444			setP4(s8Jet->p4(), jet->p4());
445
446			s8Jet->setFlavour(jet->partonFlavour());
447			s8Jet->setTracks(jet->associatedTracks().size());
448
449			if (jet->genParton())
450			{
451			s8::GenParticle *s8GenParticle = s8Jet->genParticle();
452
453			setP4(s8GenParticle->p4(), jet->genParton()->p4());
454			setVertex(s8GenParticle->vertex(), jet->genParton()->vertex());
455
456			s8GenParticle->setId(jet->genParton()->pdgId());
457			s8GenParticle->setStatus(jet->genParton()->status());
458			if (jet->genParton()->mother())
459			s8GenParticle->setParentId(jet->genParton()->mother()->pdgId());
460			}
461
462			// Save b-taggers
463			//
464			s8Jet->setBTag(Jet::TCHE,
465			jet->bDiscriminator("trackCountingHighEffBJetTags"));
466
467			s8Jet->setBTag(Jet::TCHP,
468			jet->bDiscriminator("trackCountingHighPurBJetTags"));
469
470			s8Jet->setBTag(Jet::JP,
471			jet->bDiscriminator("jetProbabilityBJetTags"));
472
473			s8Jet->setBTag(Jet::SSV,
474			jet->bDiscriminator("simpleSecondaryVertexBJetTags"));
475
476			s8Jet->setBTag(Jet::SSVHE,
477			jet->bDiscriminator("simpleSecondaryVertexHighEffBJetTags"));
478
479			s8Jet->setBTag(Jet::SSVHP,
480			jet->bDiscriminator("simpleSecondaryVertexHighPurBJetTags"));
481
482			s8Jet->setBTag(Jet::CSV,
483			jet->bDiscriminator("combinedSecondaryVertexBJetTags"));
484
485			s8Jet->setBTag(Jet::CSV_MVA,
486			jet->bDiscriminator("combinedSecondaryVertexMVABJetTags"));
487
488			s8Jet->setBTag(Jet::JBP,
489			jet->bDiscriminator("jetBProbabilityBJetTags"));
490
491			_s8Jets->push_back(s8Jet);
492			}
493			}
494
495			void S8TreeMaker::processMuons(const edm::Event &event)
496			{
497			using pat::MuonCollection;
498
499			// Extract Muons
500			//
501			Handle<MuonCollection> muons;
502			event.getByLabel(InputTag(_muons), muons);
503
504			if (!muons.isValid())
505			{
506			LogWarning("S8TreeMaker")
507			<< "failed to extract Muons.";
508
509			return;
510			}
511
512			// Process all Muons
513			//
514			for(MuonCollection::const_iterator muon = muons->begin();
515			muons->end() != muon;
516			++muon)
517			{
518			// Only Muons with basic cuts are saved:
519			//
520			if (1 >= muon->numberOfMatches())
521			continue;
522
523			s8::Lepton *s8Muon = new s8::Lepton();
524
525			setP4(s8Muon->p4(), muon->p4());
526			setVertex(s8Muon->vertex(), muon->vertex());
527
528			s8Muon->impactParameter()->first = muon->dB();
529			s8Muon->impactParameter()->second = muon->edB();
530
531			// Extract GenParticle information
532			//
533			if (muon->genLepton())
534			{
535			s8::GenParticle *s8GenParticle = s8Muon->genParticle();
536
537			setP4(s8GenParticle->p4(), muon->genLepton()->p4());
538			setVertex(s8GenParticle->vertex(), muon->genLepton()->vertex());
539
540			s8GenParticle->setId(muon->genLepton()->pdgId());
541			s8GenParticle->setStatus(muon->genLepton()->status());
542			if (muon->genLepton()->mother())
543			s8GenParticle->setParentId(muon->genLepton()->mother()->pdgId());
544			}
545
546			_s8Muons->push_back(s8Muon);
547			} // End loop over muons
548			}
549
550			void S8TreeMaker::processPrimaryVertices(const edm::Event &event)
551			{
552			// Primary Vertices
553			//
554			typedef vector<Vertex> PVCollection;
555
556			Handle<PVCollection> primaryVertices;
557			event.getByLabel(InputTag(_primaryVertices), primaryVertices);
558
559			if (!primaryVertices.isValid())
560			{
561			LogWarning("S8TreeMaker")
562			<< "failed to extract Primary Vertices.";
563
564			return;
565			}
566
567			if (primaryVertices->empty())
568			{
569			LogWarning("S8TreeMaker")
570			<< "primary vertices collection is empty.";
571
572			return;
573			}
574
575			// Process Primary Vertices
576			//
577			for(PVCollection::const_iterator vertex = primaryVertices->begin();
578			primaryVertices->end() != vertex;
579			++vertex)
580			{
581			if (!isGoodPrimaryVertex(*vertex, event.isRealData()))
582			continue;
583
584			s8::PrimaryVertex *s8Vertex = new s8::PrimaryVertex();
585
586			setVertex(s8Vertex->vertex(), vertex->position());
587			s8Vertex->setNdof(vertex->ndof());
588			s8Vertex->setRho(vertex->position().Rho());
589
590			_s8PrimaryVertices->push_back(s8Vertex);
591			}
592			}
593
594			void S8TreeMaker::processTriggers(const edm::Event &event,
595			const edm::EventSetup &eventSetup)
596			{
597			if (_hlts.empty())
598			return;
599
600			// Triggers
601			//
602			Handle<TriggerResults> triggers;
603			event.getByLabel(InputTag(_triggers), triggers);
604
605			if (!triggers.isValid())
606			{
607			LogWarning("S8TreeMaker")
608			<< "failed to extract Triggers";
609
610			return;
611			}
612
613			// Process only found HLTs
614			//
615			for(HLTs::const_iterator hlt = _hlts.begin();
616			_hlts.end() != hlt;
617			++hlt)
618			{
619			s8::Trigger *s8Trigger = new s8::Trigger();
620			s8Trigger->setHash(hlt->second.hash);
621			if (hlt->second.version)
622			s8Trigger->setVersion(hlt->second.version);
623
624			s8Trigger->setIsPass(triggers->accept(hlt->second.id));
625			s8Trigger->setPrescale(_hltConfigProvider.prescaleValue(event,
626			eventSetup, hlt->first));
627
628
629			_s8Triggers->push_back(s8Trigger);
630			}
631			}
632
633			bool S8TreeMaker::isGoodPrimaryVertex(const Vertex &vertex,
634			const bool &isData)
635			{
636			return !vertex.isFake() &&
637			4 <= vertex.ndof() &&
638			(isData ? 24 : 15) >= fabs(vertex.z()) &&
639			2 >= fabs(vertex.position().Rho());
640			}
641
642			DEFINE_FWK_MODULE(S8TreeMaker);