Analyzer/src/TriggerAnalyzer.cpp

/**
 * TriggerAnalyzer
 * s8
 *
 * Created by Samvel Khalatian on Nov 18, 2010
 * Copyright 2010, All rights reserved
 */

#include <algorithm>
#include <iomanip>
#include <iostream>
#include <sstream>

#include <TDirectory.h>
#include <TH1I.h>

#include "s8/IO/interface/Event.h"
#include "Tree/System8/interface/S8EventID.h"
#include "Tree/System8/interface/S8TriggerCenter.h"
#include "Tree/System8/interface/S8Fwd.h"

#include "s8/Analyzer/interface/TriggerAnalyzer.h"

using std::cerr;
using std::clog;
using std::cout;
using std::endl;
using std::find_if;
using std::left;
using std::ostringstream;
using std::setw;

using s8::Trigger;
using s8::TriggerAnalyzer;

class TriggerPredicator
{
    public:
        TriggerPredicator()
        {
            _search_trigger = 0;
        }

        void setSearchTrigger(const Trigger &trigger)
        {
            _search_trigger = &trigger;
        }

        bool operator()(const Trigger *trigger) const
        {
            if (!_search_trigger)
                return false;

            return _search_trigger->hash() == trigger->hash();
        }

    private:
        const Trigger *_search_trigger;
};


TriggerAnalyzer::TriggerCounter::TriggerCounter(const Trigger &hlt):
    trigger(hlt),
    counter(0),
    name("")
{
    ostringstream name;
    name << "ps_" << trigger.hash();

    prescale.reset(new TH1I(name.str().c_str(), "Prescale vs Run",
                            3000, 147000, 150000));
}


TriggerAnalyzer::TriggerAnalyzer() throw()
{
}

TriggerAnalyzer::~TriggerAnalyzer() throw()
{
}


// Analyzer interface
//
void TriggerAnalyzer::init()
{
}

void TriggerAnalyzer::treeDidLoad(const TreeInfo *,
                                  const TriggerCenter *triggerCenter)
{
    using std::setw;
    using std::left;

    cout << "Triggers List is saved in the log file" << endl
        << endl;

    clog << "Triggers:" << endl;
    const TriggerCenter::TriggerMap &triggers = triggerCenter->triggers();
    for(TriggerCenter::TriggerMap::const_iterator trigger = triggers.begin();
        triggers.end() != trigger;
        ++trigger)
    {
        clog << " > " << setw(20) << left << trigger->first << " "
            << trigger->second << endl;
    }
    clog << endl;

    for(Triggers::iterator trigger = _triggers.begin();
        _triggers.end() != trigger;
        ++trigger)
    {
        TriggerCenter::TriggerMap::const_iterator found_trigger =
            triggers.find(trigger->trigger.hash());

        if (triggers.end() == found_trigger)
            continue;

        trigger->name = found_trigger->second;
    }
}

void TriggerAnalyzer::eventDidLoad(const Event *event)
{
    if (_triggers.empty())
        return;

    TriggerPredicator trigger_predicator;

    for(Triggers::iterator trigger = _triggers.begin();
        _triggers.end() != trigger;
        ++trigger)
    {
        trigger_predicator.setSearchTrigger(trigger->trigger);

        s8::Triggers::const_iterator found_trigger =
            find_if(event->triggers()->begin(),
                    event->triggers()->end(),
                    trigger_predicator);

        if (event->triggers()->end() == found_trigger ||
            !(**found_trigger))

            continue;

        // Trigger is found
        //
        ++(trigger->counter);
        const int bin = trigger->prescale->FindBin(event->id()->run());
        trigger->prescale->SetBinContent(bin,
                (*found_trigger)->prescale());
    }
}

void TriggerAnalyzer::print(std::ostream &out) const
{
    out << "Trigger cutflow (events passed trigger)" << endl;
    out << "      Name" << setw(25) << left << " "
        << " Hash" << endl;
    out << "---------------------------------------------------"
        << endl;
    for(Triggers::const_iterator trigger = _triggers.begin();
        _triggers.end() != trigger;
        ++trigger)
    {
        out << " [+] " << setw(30) << left;
        if (trigger->name.empty())
            out << trigger->trigger.hash();
        else
            out << trigger->name;

        out << trigger->counter << endl;
    }
    out << "---------------------------------------------------"
        << endl;
}

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

        return;
    }

    output->cd();

    for(Triggers::const_iterator trigger = _triggers.begin();
        _triggers.end() != trigger;
        ++trigger)
    {
        ostringstream title;
        title << trigger->name << ": Prescale vs Run";

        trigger->prescale->SetTitle(title.str().c_str());
        trigger->prescale->Write();
    }
}

// Trigger options
//
void TriggerAnalyzer::optionTriggerIsSet(const Trigger &trigger)
{
    _triggers.push_back(TriggerCounter(trigger));
}
Revision:	1.2
Committed:	Tue May 24 14:43:29 2011 UTC (13 years, 11 months ago) by samvel
Branch:	MAIN
CVS Tags:	V00-00-04, V00-00-03, V00-00-02-04, V00-00-02-03, V00-00-02-02, V00-00-02-01, V00-00-02, HEAD
Changes since 1.1:	+5 -5 lines
Log Message:	Convert Analyzer buildsystem to scram
#	User	Rev	Content
1	samvel	1.1	/**
2			* TriggerAnalyzer
3			* s8
4			*
5			* Created by Samvel Khalatian on Nov 18, 2010
6			* Copyright 2010, All rights reserved
7			*/
8
9			#include <algorithm>
10			#include <iomanip>
11			#include <iostream>
12			#include <sstream>
13
14			#include <TDirectory.h>
15			#include <TH1I.h>
16
17	samvel	1.2	#include "s8/IO/interface/Event.h"
18			#include "Tree/System8/interface/S8EventID.h"
19			#include "Tree/System8/interface/S8TriggerCenter.h"
20			#include "Tree/System8/interface/S8Fwd.h"
21	samvel	1.1
22	samvel	1.2	#include "s8/Analyzer/interface/TriggerAnalyzer.h"
23	samvel	1.1
24			using std::cerr;
25			using std::clog;
26			using std::cout;
27			using std::endl;
28			using std::find_if;
29			using std::left;
30			using std::ostringstream;
31			using std::setw;
32
33			using s8::Trigger;
34			using s8::TriggerAnalyzer;
35
36			class TriggerPredicator
37			{
38			public:
39			TriggerPredicator()
40			{
41			_search_trigger = 0;
42			}
43
44			void setSearchTrigger(const Trigger &trigger)
45			{
46			_search_trigger = &trigger;
47			}
48
49			bool operator()(const Trigger *trigger) const
50			{
51			if (!_search_trigger)
52			return false;
53
54			return _search_trigger->hash() == trigger->hash();
55			}
56
57			private:
58			const Trigger *_search_trigger;
59			};
60
61
62
63			TriggerAnalyzer::TriggerCounter::TriggerCounter(const Trigger &hlt):
64			trigger(hlt),
65			counter(0),
66			name("")
67			{
68			ostringstream name;
69			name << "ps_" << trigger.hash();
70
71			prescale.reset(new TH1I(name.str().c_str(), "Prescale vs Run",
72			3000, 147000, 150000));
73			}
74
75
76
77			TriggerAnalyzer::TriggerAnalyzer() throw()
78			{
79			}
80
81			TriggerAnalyzer::~TriggerAnalyzer() throw()
82			{
83			}
84
85
86
87			// Analyzer interface
88			//
89			void TriggerAnalyzer::init()
90			{
91			}
92
93			void TriggerAnalyzer::treeDidLoad(const TreeInfo *,
94			const TriggerCenter *triggerCenter)
95			{
96			using std::setw;
97			using std::left;
98
99			cout << "Triggers List is saved in the log file" << endl
100			<< endl;
101
102			clog << "Triggers:" << endl;
103			const TriggerCenter::TriggerMap &triggers = triggerCenter->triggers();
104			for(TriggerCenter::TriggerMap::const_iterator trigger = triggers.begin();
105			triggers.end() != trigger;
106			++trigger)
107			{
108			clog << " > " << setw(20) << left << trigger->first << " "
109			<< trigger->second << endl;
110			}
111			clog << endl;
112
113			for(Triggers::iterator trigger = _triggers.begin();
114			_triggers.end() != trigger;
115			++trigger)
116			{
117			TriggerCenter::TriggerMap::const_iterator found_trigger =
118			triggers.find(trigger->trigger.hash());
119
120			if (triggers.end() == found_trigger)
121			continue;
122
123			trigger->name = found_trigger->second;
124			}
125			}
126
127			void TriggerAnalyzer::eventDidLoad(const Event *event)
128			{
129			if (_triggers.empty())
130			return;
131
132			TriggerPredicator trigger_predicator;
133
134			for(Triggers::iterator trigger = _triggers.begin();
135			_triggers.end() != trigger;
136			++trigger)
137			{
138			trigger_predicator.setSearchTrigger(trigger->trigger);
139
140			s8::Triggers::const_iterator found_trigger =
141			find_if(event->triggers()->begin(),
142			event->triggers()->end(),
143			trigger_predicator);
144
145			if (event->triggers()->end() == found_trigger \|\|
146			!(**found_trigger))
147
148			continue;
149
150			// Trigger is found
151			//
152			++(trigger->counter);
153			const int bin = trigger->prescale->FindBin(event->id()->run());
154			trigger->prescale->SetBinContent(bin,
155			(*found_trigger)->prescale());
156			}
157			}
158
159			void TriggerAnalyzer::print(std::ostream &out) const
160			{
161			out << "Trigger cutflow (events passed trigger)" << endl;
162			out << " Name" << setw(25) << left << " "
163			<< " Hash" << endl;
164			out << "---------------------------------------------------"
165			<< endl;
166			for(Triggers::const_iterator trigger = _triggers.begin();
167			_triggers.end() != trigger;
168			++trigger)
169			{
170			out << " [+] " << setw(30) << left;
171			if (trigger->name.empty())
172			out << trigger->trigger.hash();
173			else
174			out << trigger->name;
175
176			out << trigger->counter << endl;
177			}
178			out << "---------------------------------------------------"
179			<< endl;
180			}
181
182			void TriggerAnalyzer::save(TDirectory *directory) const
183			{
184			TDirectory *output = directory->mkdir("TriggerAnalyzer");
185			if (!output)
186			{
187			cerr << "TriggerAnalyzer: Failed to create output folder: "
188			<< "no output is saved" << endl;
189
190			return;
191			}
192
193			output->cd();
194
195			for(Triggers::const_iterator trigger = _triggers.begin();
196			_triggers.end() != trigger;
197			++trigger)
198			{
199			ostringstream title;
200			title << trigger->name << ": Prescale vs Run";
201
202			trigger->prescale->SetTitle(title.str().c_str());
203			trigger->prescale->Write();
204			}
205			}
206
207			// Trigger options
208			//
209			void TriggerAnalyzer::optionTriggerIsSet(const Trigger &trigger)
210			{
211			_triggers.push_back(TriggerCounter(trigger));
212			}