Analyzer/src/MonitorTriggerAnalyzer.cpp

/**
 * MonitorTriggerAnalyzer
 * s8
 *
 * Created by Samvel Khalatian on Feb 25, 2011
 * Copyright 2011, All rights reserved
 */

#include <cmath>

#include <iostream>
#include <stdexcept>

#include <TDirectory.h>
#include <TH1F.h>
#include <TH1D.h>
#include <TLorentzVector.h>

#include "IO/interface/Event.h"
#include "S8Tree/interface/S8GenEvent.h"
#include "S8Tree/interface/S8Fwd.h"
#include "S8Tree/interface/S8Jet.h"
#include "S8Tree/interface/S8Lepton.h"
#include "Selector/interface/S8Selector.h"
#include "Utility/interface/MonitorPlots.h"
#include "Utility/interface/MuonInJet.h"
#include "Utility/interface/TaggerOperatingPoint.h"

#include "Analyzer/interface/MonitorTriggerAnalyzer.h"

using std::cerr;
using std::clog;
using std::cout;
using std::endl;

using s8::MonitorTriggerAnalyzer;

MonitorTriggerAnalyzer::MonitorTriggerAnalyzer() throw():
    _use_trigger_prescale(false),
    _prescale(0)
{
    _s8_selector = 0;
}

MonitorTriggerAnalyzer::~MonitorTriggerAnalyzer() throw()
{
    if (_s8_selector)
        delete _s8_selector;
}


// Analyzer interface
//
void MonitorTriggerAnalyzer::init()
{
    _muonInJetTagger.reset(new TaggerOperatingPoint());
    _awayJetTagger.reset(new TaggerOperatingPoint());

    _muonInJet.reset(new MuonInJet());
    _muonInJet->setDelegate(this);
    _muonInJet->setAwayJetTaggerOperatingPoint(_awayJetTagger.get());

    _muons.reset(new TH1D("muons", "N muons",
                            10, 0, 10));
    // Force Manual memory management
    //
    _muons->SetDirectory(0);
    _muons->GetXaxis()->SetTitle("N_{#mu}");

    _pthat.reset(new TH1D("pthat", "pT hat", 100, 0, 200));
    // Force Manual memory management
    //
    _pthat->SetDirectory(0);
    _pthat->GetXaxis()->SetTitle("#hat{p_{T}}");

    _jets.reset(new TH1D("jets", "N jets",
                            10, 0, 10));
    // Force Manual memory management
    //
    _jets->SetDirectory(0);
    _jets->GetXaxis()->SetTitle("N_{jet}");

    // Generic
    //
    _monitorMuons.reset(new MonitorLepton("allmus"));
    _monitorJets.reset(new MonitorJet("alljets"));
    _monitorJets->plot(MonitorBase::PT)->SetBins(230, 0, 230); 
    _monitorLeadingJet.reset(new MonitorJet("leadingjet"));

    // (n)
    //
    _monitorNMuons.reset(new MonitorLepton("nmu"));
    _monitorNJets.reset(new MonitorJet("njet"));
    _monitorNJets->plot(MonitorBase::PT)->SetBins(230, 0, 230); 
    _monitorNDelta.reset(new MonitorDelta("nmujet"));

    // (p)
    //
    _monitorPMuons.reset(new MonitorLepton("pmu"));
    _monitorPJets.reset(new MonitorJet("pjet"));
    _monitorPJets->plot(MonitorBase::PT)->SetBins(230, 0, 230); 
    _monitorPDelta.reset(new MonitorDelta("pmujet"));

    // change binning in the Delta plots
    //
    MonitorDelta *deltas[] = { _monitorNDelta.get(), _monitorPDelta.get() };
    for(int i = 0; 2 > i; ++i)
    {
        deltas[i]->plot(MonitorDelta::PTREL)->SetBins(70, 0, 7);
    }

    _s8_selector = new S8Selector();
}

void MonitorTriggerAnalyzer::treeDidLoad(const TreeInfo *,
                                  const TriggerCenter *trigger_center)
{
    _s8_selector->treeDidLoad(trigger_center);
}

void MonitorTriggerAnalyzer::eventDidLoad(const Event *event)
{
    using s8::Jets;
    using s8::Leptons;

    // check if event passes the selection
    //
    const Event *modified_event = (*_s8_selector)(event);
    if (!modified_event)
        return;

    event = modified_event;

    if (_use_trigger_prescale)
    {
        // Extract prescale of the trigger
        //
        // Search for user defined triggers among those that passed the event
        //
        s8::Triggers::const_iterator found_trigger =
            find_if(event->triggers()->begin(),
                    event->triggers()->end(),
                    _trigger_predicator);

        // Check if trigger was found and passed the event
        //
        if (event->triggers()->end() != found_trigger)
            _prescale = (*found_trigger)->prescale();
    }

    _pthat->Fill(event->gen()->ptHat());
    _muons->Fill(event->muons()->size());
    _jets->Fill(event->jets()->size());

    for(Leptons::const_iterator muon = event->muons()->begin();
        event->muons()->end() != muon;
        ++muon)

        _monitorMuons->fill(_prescale ? _prescale : 1, *muon);

    const Jet *leadingJet = 0;
    for(Jets::const_iterator jet = event->jets()->begin();
        event->jets()->end() != jet;
        ++jet)
    {
        _monitorJets->fill(_prescale ? _prescale : 1, *jet);

        if (leadingJet &&
            leadingJet->p4()->Pt() >= (*jet)->p4()->Pt())

            continue;

        leadingJet = *jet;
    }

    if (leadingJet)
        _monitorLeadingJet->fill(_prescale ? _prescale : 1, leadingJet);

    (*_muonInJet)(event);

    _prescale = 0;
}

void MonitorTriggerAnalyzer::print(std::ostream &out) const
{
    _s8_selector->print(out);
}

void MonitorTriggerAnalyzer::save(TDirectory *directory) const
{
    TDirectory *output = directory->mkdir("MonitorTriggerAnalyzer");
    if (!output)
    {
        cerr << "MonitorTriggerAnalyzer: Failed to create output folder: "
            << "no output is saved" << endl;

        return;
    }

    output->cd();

    saveGenericPlots(output);
    saveNPlots(output);
    savePPlots(output);
}

// MuonInJetOptionsDelegate interface
//
void MonitorTriggerAnalyzer::optionTagIsSet(const std::string &tag)
{
    *_muonInJetTagger << tag;
}

void MonitorTriggerAnalyzer::optionAwayTagIsSet(const std::string &tag)
{
    *_awayJetTagger << tag;
}

void MonitorTriggerAnalyzer::optionMuonPtIsSet(const Range &value)
{
    _n_muon_pt = value;
}

void MonitorTriggerAnalyzer::optionJetPtIsSet(const Range &value)
{
    _n_jet_pt = value;
}

void MonitorTriggerAnalyzer::optionJetEtaIsSet(const Range &value)
{
    _n_jet_eta = value;
}

// MuonInJetDelegate interface
//
bool MonitorTriggerAnalyzer::shouldSkipMuonInJetPlusAwayJet(const Lepton *muon,
                                                     const Jet *jet)
{
    return !isValueInRange(muon->p4()->Pt(), _n_muon_pt) ||
           !isValueInRange(jet->p4()->Pt(), _n_jet_pt) ||
           !isValueInRange(fabs(jet->p4()->Eta()), _n_jet_eta);
}

void MonitorTriggerAnalyzer::muonIsInJetPlusAwayJet(const Lepton *muon,
                                             const Jet *jet)
{
    _monitorNMuons->fill(_prescale ? _prescale : 1, muon);
    _monitorNJets->fill(_prescale ? _prescale : 1, jet);
    _monitorNDelta->fill(_prescale ? _prescale : 1, muon->p4(), jet->p4());
}

void MonitorTriggerAnalyzer::muonIsInJetPlusTaggedAwayJet(const Lepton *muon,
                                                   const Jet *jet)
{
    _monitorPMuons->fill(_prescale ? _prescale : 1, muon);
    _monitorPJets->fill(_prescale ? _prescale : 1, jet);
    _monitorPDelta->fill(_prescale ? _prescale : 1, muon->p4(), jet->p4());
}

// PythiaOptionsDelegate interface
//
void MonitorTriggerAnalyzer::optionGluonSplittingIsSet(const GluonSplitting &value)
{
    _s8_selector->optionGluonSplittingIsSet(value);
}

void MonitorTriggerAnalyzer::optionPtHatIsSet(const Range &value)
{
    _s8_selector->optionPtHatIsSet(value);
}

// Trigger options
//
void MonitorTriggerAnalyzer::optionTriggerIsSet(const Trigger &trigger)
{
    _trigger = trigger;
    _trigger_predicator.setSearchTrigger(_trigger);

    _s8_selector->optionTriggerIsSet(trigger);
}

void MonitorTriggerAnalyzer::optionUseTriggerPrescaleIsSet(const bool &value)
{
    _use_trigger_prescale = value;
}


void MonitorTriggerAnalyzer::saveGenericPlots(TDirectory *directory) const
{
    TDirectory *subdir = directory->mkdir("generic");
    if (!subdir)
    {
        cerr << "Failed to create 'generic' TDirectory. Plots are not saved"
            << endl;

        return;
    }

    subdir->cd();

    _muons->Write();
    _jets->Write();
    _pthat->Write();

    // Generic
    //
    _monitorMuons->save(subdir);
    _monitorJets->save(subdir);
    _monitorLeadingJet->save(subdir);

    directory->cd();
}

void MonitorTriggerAnalyzer::saveNPlots(TDirectory *directory) const
{
    TDirectory *subdir = directory->mkdir("n");
    if (!subdir)
    {
        cerr << "Failed to create 'n' TDirectory. Plots are not saved"
            << endl;

        return;
    }

    subdir->cd();

    // (n)
    //
    _monitorNMuons->save(subdir);
    _monitorNJets->save(subdir);
    _monitorNDelta->save(subdir);

    directory->cd();
}

void MonitorTriggerAnalyzer::savePPlots(TDirectory *directory) const
{
    TDirectory *subdir = directory->mkdir("p");
    if (!subdir)
    {
        cerr << "Failed to create 'p' TDirectory. Plots are not saved"
            << endl;

        return;
    }

    subdir->cd();

    // (p)
    //
    _monitorPMuons->save(subdir);
    _monitorPJets->save(subdir);
    _monitorPDelta->save(subdir);

    directory->cd();
}
Revision:	1.1
Committed:	Fri May 6 14:31:20 2011 UTC (14 years ago) by samvel
Branch:	MAIN
CVS Tags:	melo-old
Log Message:	Import Analyzer
#	User	Rev	Content
1	samvel	1.1	/**
2			* MonitorTriggerAnalyzer
3			* s8
4			*
5			* Created by Samvel Khalatian on Feb 25, 2011
6			* Copyright 2011, All rights reserved
7			*/
8
9			#include <cmath>
10
11			#include <iostream>
12			#include <stdexcept>
13
14			#include <TDirectory.h>
15			#include <TH1F.h>
16			#include <TH1D.h>
17			#include <TLorentzVector.h>
18
19			#include "IO/interface/Event.h"
20			#include "S8Tree/interface/S8GenEvent.h"
21			#include "S8Tree/interface/S8Fwd.h"
22			#include "S8Tree/interface/S8Jet.h"
23			#include "S8Tree/interface/S8Lepton.h"
24			#include "Selector/interface/S8Selector.h"
25			#include "Utility/interface/MonitorPlots.h"
26			#include "Utility/interface/MuonInJet.h"
27			#include "Utility/interface/TaggerOperatingPoint.h"
28
29			#include "Analyzer/interface/MonitorTriggerAnalyzer.h"
30
31			using std::cerr;
32			using std::clog;
33			using std::cout;
34			using std::endl;
35
36			using s8::MonitorTriggerAnalyzer;
37
38			MonitorTriggerAnalyzer::MonitorTriggerAnalyzer() throw():
39			_use_trigger_prescale(false),
40			_prescale(0)
41			{
42			_s8_selector = 0;
43			}
44
45			MonitorTriggerAnalyzer::~MonitorTriggerAnalyzer() throw()
46			{
47			if (_s8_selector)
48			delete _s8_selector;
49			}
50
51
52
53			// Analyzer interface
54			//
55			void MonitorTriggerAnalyzer::init()
56			{
57			_muonInJetTagger.reset(new TaggerOperatingPoint());
58			_awayJetTagger.reset(new TaggerOperatingPoint());
59
60			_muonInJet.reset(new MuonInJet());
61			_muonInJet->setDelegate(this);
62			_muonInJet->setAwayJetTaggerOperatingPoint(_awayJetTagger.get());
63
64			_muons.reset(new TH1D("muons", "N muons",
65			10, 0, 10));
66			// Force Manual memory management
67			//
68			_muons->SetDirectory(0);
69			_muons->GetXaxis()->SetTitle("N_{#mu}");
70
71			_pthat.reset(new TH1D("pthat", "pT hat", 100, 0, 200));
72			// Force Manual memory management
73			//
74			_pthat->SetDirectory(0);
75			_pthat->GetXaxis()->SetTitle("#hat{p_{T}}");
76
77			_jets.reset(new TH1D("jets", "N jets",
78			10, 0, 10));
79			// Force Manual memory management
80			//
81			_jets->SetDirectory(0);
82			_jets->GetXaxis()->SetTitle("N_{jet}");
83
84			// Generic
85			//
86			_monitorMuons.reset(new MonitorLepton("allmus"));
87			_monitorJets.reset(new MonitorJet("alljets"));
88			_monitorJets->plot(MonitorBase::PT)->SetBins(230, 0, 230);
89			_monitorLeadingJet.reset(new MonitorJet("leadingjet"));
90
91			// (n)
92			//
93			_monitorNMuons.reset(new MonitorLepton("nmu"));
94			_monitorNJets.reset(new MonitorJet("njet"));
95			_monitorNJets->plot(MonitorBase::PT)->SetBins(230, 0, 230);
96			_monitorNDelta.reset(new MonitorDelta("nmujet"));
97
98			// (p)
99			//
100			_monitorPMuons.reset(new MonitorLepton("pmu"));
101			_monitorPJets.reset(new MonitorJet("pjet"));
102			_monitorPJets->plot(MonitorBase::PT)->SetBins(230, 0, 230);
103			_monitorPDelta.reset(new MonitorDelta("pmujet"));
104
105			// change binning in the Delta plots
106			//
107			MonitorDelta *deltas[] = { _monitorNDelta.get(), _monitorPDelta.get() };
108			for(int i = 0; 2 > i; ++i)
109			{
110			deltas[i]->plot(MonitorDelta::PTREL)->SetBins(70, 0, 7);
111			}
112
113			_s8_selector = new S8Selector();
114			}
115
116			void MonitorTriggerAnalyzer::treeDidLoad(const TreeInfo *,
117			const TriggerCenter *trigger_center)
118			{
119			_s8_selector->treeDidLoad(trigger_center);
120			}
121
122			void MonitorTriggerAnalyzer::eventDidLoad(const Event *event)
123			{
124			using s8::Jets;
125			using s8::Leptons;
126
127			// check if event passes the selection
128			//
129			const Event modified_event = (_s8_selector)(event);
130			if (!modified_event)
131			return;
132
133			event = modified_event;
134
135			if (_use_trigger_prescale)
136			{
137			// Extract prescale of the trigger
138			//
139			// Search for user defined triggers among those that passed the event
140			//
141			s8::Triggers::const_iterator found_trigger =
142			find_if(event->triggers()->begin(),
143			event->triggers()->end(),
144			_trigger_predicator);
145
146			// Check if trigger was found and passed the event
147			//
148			if (event->triggers()->end() != found_trigger)
149			_prescale = (*found_trigger)->prescale();
150			}
151
152			_pthat->Fill(event->gen()->ptHat());
153			_muons->Fill(event->muons()->size());
154			_jets->Fill(event->jets()->size());
155
156			for(Leptons::const_iterator muon = event->muons()->begin();
157			event->muons()->end() != muon;
158			++muon)
159
160			_monitorMuons->fill(_prescale ? _prescale : 1, *muon);
161
162			const Jet *leadingJet = 0;
163			for(Jets::const_iterator jet = event->jets()->begin();
164			event->jets()->end() != jet;
165			++jet)
166			{
167			_monitorJets->fill(_prescale ? _prescale : 1, *jet);
168
169			if (leadingJet &&
170			leadingJet->p4()->Pt() >= (*jet)->p4()->Pt())
171
172			continue;
173
174			leadingJet = *jet;
175			}
176
177			if (leadingJet)
178			_monitorLeadingJet->fill(_prescale ? _prescale : 1, leadingJet);
179
180			(*_muonInJet)(event);
181
182			_prescale = 0;
183			}
184
185			void MonitorTriggerAnalyzer::print(std::ostream &out) const
186			{
187			_s8_selector->print(out);
188			}
189
190			void MonitorTriggerAnalyzer::save(TDirectory *directory) const
191			{
192			TDirectory *output = directory->mkdir("MonitorTriggerAnalyzer");
193			if (!output)
194			{
195			cerr << "MonitorTriggerAnalyzer: Failed to create output folder: "
196			<< "no output is saved" << endl;
197
198			return;
199			}
200
201			output->cd();
202
203			saveGenericPlots(output);
204			saveNPlots(output);
205			savePPlots(output);
206			}
207
208			// MuonInJetOptionsDelegate interface
209			//
210			void MonitorTriggerAnalyzer::optionTagIsSet(const std::string &tag)
211			{
212			*_muonInJetTagger << tag;
213			}
214
215			void MonitorTriggerAnalyzer::optionAwayTagIsSet(const std::string &tag)
216			{
217			*_awayJetTagger << tag;
218			}
219
220			void MonitorTriggerAnalyzer::optionMuonPtIsSet(const Range &value)
221			{
222			_n_muon_pt = value;
223			}
224
225			void MonitorTriggerAnalyzer::optionJetPtIsSet(const Range &value)
226			{
227			_n_jet_pt = value;
228			}
229
230			void MonitorTriggerAnalyzer::optionJetEtaIsSet(const Range &value)
231			{
232			_n_jet_eta = value;
233			}
234
235			// MuonInJetDelegate interface
236			//
237			bool MonitorTriggerAnalyzer::shouldSkipMuonInJetPlusAwayJet(const Lepton *muon,
238			const Jet *jet)
239			{
240			return !isValueInRange(muon->p4()->Pt(), _n_muon_pt) \|\|
241			!isValueInRange(jet->p4()->Pt(), _n_jet_pt) \|\|
242			!isValueInRange(fabs(jet->p4()->Eta()), _n_jet_eta);
243			}
244
245			void MonitorTriggerAnalyzer::muonIsInJetPlusAwayJet(const Lepton *muon,
246			const Jet *jet)
247			{
248			_monitorNMuons->fill(_prescale ? _prescale : 1, muon);
249			_monitorNJets->fill(_prescale ? _prescale : 1, jet);
250			_monitorNDelta->fill(_prescale ? _prescale : 1, muon->p4(), jet->p4());
251			}
252
253			void MonitorTriggerAnalyzer::muonIsInJetPlusTaggedAwayJet(const Lepton *muon,
254			const Jet *jet)
255			{
256			_monitorPMuons->fill(_prescale ? _prescale : 1, muon);
257			_monitorPJets->fill(_prescale ? _prescale : 1, jet);
258			_monitorPDelta->fill(_prescale ? _prescale : 1, muon->p4(), jet->p4());
259			}
260
261			// PythiaOptionsDelegate interface
262			//
263			void MonitorTriggerAnalyzer::optionGluonSplittingIsSet(const GluonSplitting &value)
264			{
265			_s8_selector->optionGluonSplittingIsSet(value);
266			}
267
268			void MonitorTriggerAnalyzer::optionPtHatIsSet(const Range &value)
269			{
270			_s8_selector->optionPtHatIsSet(value);
271			}
272
273			// Trigger options
274			//
275			void MonitorTriggerAnalyzer::optionTriggerIsSet(const Trigger &trigger)
276			{
277			_trigger = trigger;
278			_trigger_predicator.setSearchTrigger(_trigger);
279
280			_s8_selector->optionTriggerIsSet(trigger);
281			}
282
283			void MonitorTriggerAnalyzer::optionUseTriggerPrescaleIsSet(const bool &value)
284			{
285			_use_trigger_prescale = value;
286			}
287
288
289
290			void MonitorTriggerAnalyzer::saveGenericPlots(TDirectory *directory) const
291			{
292			TDirectory *subdir = directory->mkdir("generic");
293			if (!subdir)
294			{
295			cerr << "Failed to create 'generic' TDirectory. Plots are not saved"
296			<< endl;
297
298			return;
299			}
300
301			subdir->cd();
302
303			_muons->Write();
304			_jets->Write();
305			_pthat->Write();
306
307			// Generic
308			//
309			_monitorMuons->save(subdir);
310			_monitorJets->save(subdir);
311			_monitorLeadingJet->save(subdir);
312
313			directory->cd();
314			}
315
316			void MonitorTriggerAnalyzer::saveNPlots(TDirectory *directory) const
317			{
318			TDirectory *subdir = directory->mkdir("n");
319			if (!subdir)
320			{
321			cerr << "Failed to create 'n' TDirectory. Plots are not saved"
322			<< endl;
323
324			return;
325			}
326
327			subdir->cd();
328
329			// (n)
330			//
331			_monitorNMuons->save(subdir);
332			_monitorNJets->save(subdir);
333			_monitorNDelta->save(subdir);
334
335			directory->cd();
336			}
337
338			void MonitorTriggerAnalyzer::savePPlots(TDirectory *directory) const
339			{
340			TDirectory *subdir = directory->mkdir("p");
341			if (!subdir)
342			{
343			cerr << "Failed to create 'p' TDirectory. Plots are not saved"
344			<< endl;
345
346			return;
347			}
348
349			subdir->cd();
350
351			// (p)
352			//
353			_monitorPMuons->save(subdir);
354			_monitorPJets->save(subdir);
355			_monitorPDelta->save(subdir);
356
357			directory->cd();
358			}