Selector/src/S8Selector.cpp

/**
 * S8Selector
 * s8
 *
 * Created by Samvel Khalatian on Feb 3, 2011
 * Copyright 2010, All rights reserved
 */

#include <algorithm>
#include <iomanip>
#include <ostream>

#include <TLorentzVector.h>

#include "s8/IO/interface/Event.h"
#include "Tree/System8/interface/S8GenEvent.h"
#include "Tree/System8/interface/S8Jet.h"
#include "Tree/System8/interface/S8TriggerCenter.h"
#include "Tree/System8/interface/S8Tools.h"
#include "s8/Selector/interface/S8Selector.h"

using std::endl;
using std::find_if;
using std::left;
using std::setw;

using s8::S8Selector;

S8Selector::S8Selector() throw():
    _gluon_splitting(KEEP),
    _is_first_event(true),
    _simulate_trigger(false)
{
    using s8::tools::make_hash;

    _hlt_jet20u.setHash(make_hash("hlt_btagmu_jet20u"));
    _hlt_dijet20u.setHash(make_hash("hlt_btagmu_dijet20u"));
    _hlt_dijet30u.setHash(make_hash("hlt_btagmu_dijet30u"));
}

S8Selector::~S8Selector() throw()
{
}

void S8Selector::optionGluonSplittingIsSet(const GluonSplitting &value)
{
    _gluon_splitting = value;
}

void S8Selector::optionPtHatIsSet(const Range &value)
{
    _pt_hat = value;
}

void S8Selector::optionTriggerIsSet(const Trigger &trigger)
{
    _triggers.push_back(TriggerCounter(trigger));
}

void S8Selector::optionSimulateTriggerIsSet(const bool &value)
{
    _simulate_trigger = value;
}

void S8Selector::optionPrimaryVerticesIsSet(const Range &primary_vertices)
{
    _primary_vertices = primary_vertices;
}

void S8Selector::treeDidLoad(const TriggerCenter *trigger_center)
{
    const TriggerCenter::TriggerMap &triggers = trigger_center->triggers();

    // Search for trigger in the Trigger Menu
    //
    for(Triggers::iterator trigger = _triggers.begin();
        _triggers.end() != trigger;
        ++trigger)
    {
        trigger->disable = true;
        trigger->simulate = false;

        TriggerCenter::TriggerMap::const_iterator found_trigger =
            triggers.find(trigger->trigger.hash());

        // check if trigger is found
        //
        if (triggers.end() == found_trigger)
        {
            // Trigger is not found
            //
            if (_simulate_trigger &&
                    
                (trigger->trigger.hash() != _hlt_dijet20u.hash() ||
                 trigger->trigger.hash() != _hlt_dijet30u.hash()))

                trigger->simulate = true;
            else
                continue;
        }
        else
            trigger->name = found_trigger->second;

        trigger->disable = false;
    }
}

const s8::Event *S8Selector::operator()(const Event *event)
{
    if (!event)
        return 0;

    ++_events.total;

    if (!isValueInRange(event->primaryVertices()->size(), _primary_vertices))
        return 0;

    ++_events.primary_vertices;

    if (!isValueInRange(event->gen()->ptHat(), _pt_hat))
        return 0;

    ++_events.pt_hat;

    // Triggers
    //
    if (!_triggers.empty() &&
        !processTriggers(event))

        return 0;

    ++_events.trigger;

    // Gluon Splitting
    // [see PythiaOptionsDelegate for description]
    //
    switch(_gluon_splitting)
    {
        case KEEP:
            break;

        case BB:
            {
                if (event->gen()->isGluonSplitting(s8::GenEvent::BB))
                    break;

                return 0;
            }

        case CC:
            {
                if (event->gen()->isGluonSplitting(s8::GenEvent::CC))
                    break;

                return 0;
            }

        case ONLY:
            {
                if (event->gen()->isGluonSplitting(s8::GenEvent::BB) ||
                    event->gen()->isGluonSplitting(s8::GenEvent::CC))

                    break;

                return 0;
            }

        case NO_BB:
            {
                if (event->gen()->isGluonSplitting(s8::GenEvent::BB))
                    return 0;

                break;
            }

        case NO_CC:
            {
                if (event->gen()->isGluonSplitting(s8::GenEvent::CC))
                    return 0;

                break;
            }

        case REMOVE:
            {
                if (event->gen()->isGluonSplitting(s8::GenEvent::BB) ||
                    event->gen()->isGluonSplitting(s8::GenEvent::CC))

                    return 0;

                break;
            }

        case ADD_BB:
            {
                if (event->gen()->isGluonSplitting(s8::GenEvent::BB))
                    break;

                _is_first_event = !_is_first_event;

                if (_is_first_event)
                    return 0;

                break;
            }

        case ADD_CC:
            {
                if (event->gen()->isGluonSplitting(s8::GenEvent::CC))
                    break;

                _is_first_event = !_is_first_event;

                if (_is_first_event)
                    return 0;

                break;
            }

        case ENHANCE:
            {
                if (event->gen()->isGluonSplitting(s8::GenEvent::BB) ||
                    event->gen()->isGluonSplitting(s8::GenEvent::CC))

                    break;

                _is_first_event = !_is_first_event;

                if (_is_first_event)
                    return 0;

                break;
            }
    }

    ++_events.gluon_splitting;

    return event;
}

void S8Selector::print(std::ostream &out) const
{
    out << "S8Selector cutflow (events passed)" << endl;
    out << " " << setw(20) << left << "Total" << _events.total << endl;
    out << " " << setw(20) << left << "Primary Vertices"
        << _events.primary_vertices << endl;
    out << " " << setw(20) << left << "Pt Hat" << _events.pt_hat << endl;
    out << " " << setw(20) << left << "Triggers" << _events.trigger << endl;
    out << " " << setw(20) << left << "Gluon Splitting"
        << _events.gluon_splitting <<endl;
    out << endl;
    out << "Triggers Cutflow" << 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;
}


bool S8Selector::processTriggers(const Event *event)
{
    bool triggers_pass = false;

    // Search for user defined triggers among those that passed the event
    //
    for(Triggers::iterator trigger = _triggers.begin();
        _triggers.end() != trigger;
        ++trigger)
    {
        if (trigger->disable)
            continue;

        if (trigger->simulate)
        {
            if (!simulateTrigger(trigger->trigger, event))
                continue;
        }
        else
        {
            if (!didTriggerPass(trigger->trigger, event))
                continue;
        }

        ++(trigger->counter);

        triggers_pass = true;
    }

    return triggers_pass;
}

bool S8Selector::didTriggerPass(const Trigger &trigger,
                                const Event *event)
{
    _trigger_predicator.setSearchTrigger(trigger);

    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
    //
    return event->triggers()->end() != found_trigger &&
        (**found_trigger);
}

bool S8Selector::simulateTrigger(const Trigger &trigger, const Event *event)
{
    if (!didTriggerPass(_hlt_jet20u, event))
        return false;

    double max_pt = 0;
    if (_hlt_dijet20u.hash() == trigger.hash())
        max_pt = 60;
    else if (_hlt_dijet30u.hash() == trigger.hash())
        max_pt = 80;
    else
        return false;

    // Apply offline jet pT cut
    //
    int trigger_jets = 0;
    for(Jets::const_iterator jet = event->jets()->begin();
        event->jets()->end() != jet &&
            2 > trigger_jets;
        ++jet)
    {
        if (max_pt < (*jet)->p4()->Pt() &&
            3.0 > fabs((*jet)->p4()->Eta()))

            ++trigger_jets;
    }

    return 1 < trigger_jets;
}
Revision:	1.2
Committed:	Tue May 24 14:38:25 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:	+6 -6 lines
Log Message:	Change selector build system to scram
#	User	Rev	Content
1	samvel	1.1	/**
2			* S8Selector
3			* s8
4			*
5			* Created by Samvel Khalatian on Feb 3, 2011
6			* Copyright 2010, All rights reserved
7			*/
8
9			#include <algorithm>
10			#include <iomanip>
11			#include <ostream>
12
13			#include <TLorentzVector.h>
14
15	samvel	1.2	#include "s8/IO/interface/Event.h"
16			#include "Tree/System8/interface/S8GenEvent.h"
17			#include "Tree/System8/interface/S8Jet.h"
18			#include "Tree/System8/interface/S8TriggerCenter.h"
19			#include "Tree/System8/interface/S8Tools.h"
20			#include "s8/Selector/interface/S8Selector.h"
21	samvel	1.1
22			using std::endl;
23			using std::find_if;
24			using std::left;
25			using std::setw;
26
27			using s8::S8Selector;
28
29			S8Selector::S8Selector() throw():
30			_gluon_splitting(KEEP),
31			_is_first_event(true),
32			_simulate_trigger(false)
33			{
34			using s8::tools::make_hash;
35
36			_hlt_jet20u.setHash(make_hash("hlt_btagmu_jet20u"));
37			_hlt_dijet20u.setHash(make_hash("hlt_btagmu_dijet20u"));
38			_hlt_dijet30u.setHash(make_hash("hlt_btagmu_dijet30u"));
39			}
40
41			S8Selector::~S8Selector() throw()
42			{
43			}
44
45			void S8Selector::optionGluonSplittingIsSet(const GluonSplitting &value)
46			{
47			_gluon_splitting = value;
48			}
49
50			void S8Selector::optionPtHatIsSet(const Range &value)
51			{
52			_pt_hat = value;
53			}
54
55			void S8Selector::optionTriggerIsSet(const Trigger &trigger)
56			{
57			_triggers.push_back(TriggerCounter(trigger));
58			}
59
60			void S8Selector::optionSimulateTriggerIsSet(const bool &value)
61			{
62			_simulate_trigger = value;
63			}
64
65			void S8Selector::optionPrimaryVerticesIsSet(const Range &primary_vertices)
66			{
67			_primary_vertices = primary_vertices;
68			}
69
70			void S8Selector::treeDidLoad(const TriggerCenter *trigger_center)
71			{
72			const TriggerCenter::TriggerMap &triggers = trigger_center->triggers();
73
74			// Search for trigger in the Trigger Menu
75			//
76			for(Triggers::iterator trigger = _triggers.begin();
77			_triggers.end() != trigger;
78			++trigger)
79			{
80			trigger->disable = true;
81			trigger->simulate = false;
82
83			TriggerCenter::TriggerMap::const_iterator found_trigger =
84			triggers.find(trigger->trigger.hash());
85
86			// check if trigger is found
87			//
88			if (triggers.end() == found_trigger)
89			{
90			// Trigger is not found
91			//
92			if (_simulate_trigger &&
93
94			(trigger->trigger.hash() != _hlt_dijet20u.hash() \|\|
95			trigger->trigger.hash() != _hlt_dijet30u.hash()))
96
97			trigger->simulate = true;
98			else
99			continue;
100			}
101			else
102			trigger->name = found_trigger->second;
103
104			trigger->disable = false;
105			}
106			}
107
108			const s8::Event S8Selector::operator()(const Event event)
109			{
110			if (!event)
111			return 0;
112
113			++_events.total;
114
115			if (!isValueInRange(event->primaryVertices()->size(), _primary_vertices))
116			return 0;
117
118			++_events.primary_vertices;
119
120			if (!isValueInRange(event->gen()->ptHat(), _pt_hat))
121			return 0;
122
123			++_events.pt_hat;
124
125			// Triggers
126			//
127			if (!_triggers.empty() &&
128			!processTriggers(event))
129
130			return 0;
131
132			++_events.trigger;
133
134			// Gluon Splitting
135			// [see PythiaOptionsDelegate for description]
136			//
137			switch(_gluon_splitting)
138			{
139			case KEEP:
140			break;
141
142			case BB:
143			{
144			if (event->gen()->isGluonSplitting(s8::GenEvent::BB))
145			break;
146
147			return 0;
148			}
149
150			case CC:
151			{
152			if (event->gen()->isGluonSplitting(s8::GenEvent::CC))
153			break;
154
155			return 0;
156			}
157
158			case ONLY:
159			{
160			if (event->gen()->isGluonSplitting(s8::GenEvent::BB) \|\|
161			event->gen()->isGluonSplitting(s8::GenEvent::CC))
162
163			break;
164
165			return 0;
166			}
167
168			case NO_BB:
169			{
170			if (event->gen()->isGluonSplitting(s8::GenEvent::BB))
171			return 0;
172
173			break;
174			}
175
176			case NO_CC:
177			{
178			if (event->gen()->isGluonSplitting(s8::GenEvent::CC))
179			return 0;
180
181			break;
182			}
183
184			case REMOVE:
185			{
186			if (event->gen()->isGluonSplitting(s8::GenEvent::BB) \|\|
187			event->gen()->isGluonSplitting(s8::GenEvent::CC))
188
189			return 0;
190
191			break;
192			}
193
194			case ADD_BB:
195			{
196			if (event->gen()->isGluonSplitting(s8::GenEvent::BB))
197			break;
198
199			_is_first_event = !_is_first_event;
200
201			if (_is_first_event)
202			return 0;
203
204			break;
205			}
206
207			case ADD_CC:
208			{
209			if (event->gen()->isGluonSplitting(s8::GenEvent::CC))
210			break;
211
212			_is_first_event = !_is_first_event;
213
214			if (_is_first_event)
215			return 0;
216
217			break;
218			}
219
220			case ENHANCE:
221			{
222			if (event->gen()->isGluonSplitting(s8::GenEvent::BB) \|\|
223			event->gen()->isGluonSplitting(s8::GenEvent::CC))
224
225			break;
226
227			_is_first_event = !_is_first_event;
228
229			if (_is_first_event)
230			return 0;
231
232			break;
233			}
234			}
235
236			++_events.gluon_splitting;
237
238			return event;
239			}
240
241			void S8Selector::print(std::ostream &out) const
242			{
243			out << "S8Selector cutflow (events passed)" << endl;
244			out << " " << setw(20) << left << "Total" << _events.total << endl;
245			out << " " << setw(20) << left << "Primary Vertices"
246			<< _events.primary_vertices << endl;
247			out << " " << setw(20) << left << "Pt Hat" << _events.pt_hat << endl;
248			out << " " << setw(20) << left << "Triggers" << _events.trigger << endl;
249			out << " " << setw(20) << left << "Gluon Splitting"
250			<< _events.gluon_splitting <<endl;
251			out << endl;
252			out << "Triggers Cutflow" << endl;
253			out << " Name" << setw(25) << left << " "
254			<< " Hash" << endl;
255			out << "---------------------------------------------------"
256			<< endl;
257			for(Triggers::const_iterator trigger = _triggers.begin();
258			_triggers.end() != trigger;
259			++trigger)
260			{
261			out << " [+] " << setw(30) << left;
262			if (trigger->name.empty())
263			out << trigger->trigger.hash();
264			else
265			out << trigger->name;
266
267			out << trigger->counter << endl;
268			}
269			out << "---------------------------------------------------"
270			<< endl;
271			}
272
273
274
275			bool S8Selector::processTriggers(const Event *event)
276			{
277			bool triggers_pass = false;
278
279			// Search for user defined triggers among those that passed the event
280			//
281			for(Triggers::iterator trigger = _triggers.begin();
282			_triggers.end() != trigger;
283			++trigger)
284			{
285			if (trigger->disable)
286			continue;
287
288			if (trigger->simulate)
289			{
290			if (!simulateTrigger(trigger->trigger, event))
291			continue;
292			}
293			else
294			{
295			if (!didTriggerPass(trigger->trigger, event))
296			continue;
297			}
298
299			++(trigger->counter);
300
301			triggers_pass = true;
302			}
303
304			return triggers_pass;
305			}
306
307			bool S8Selector::didTriggerPass(const Trigger &trigger,
308			const Event *event)
309			{
310			_trigger_predicator.setSearchTrigger(trigger);
311
312			s8::Triggers::const_iterator found_trigger =
313			find_if(event->triggers()->begin(),
314			event->triggers()->end(),
315			_trigger_predicator);
316
317			// Check if trigger was found and passed the event
318			//
319			return event->triggers()->end() != found_trigger &&
320			(**found_trigger);
321			}
322
323			bool S8Selector::simulateTrigger(const Trigger &trigger, const Event *event)
324			{
325			if (!didTriggerPass(_hlt_jet20u, event))
326			return false;
327
328			double max_pt = 0;
329			if (_hlt_dijet20u.hash() == trigger.hash())
330			max_pt = 60;
331			else if (_hlt_dijet30u.hash() == trigger.hash())
332			max_pt = 80;
333			else
334			return false;
335
336			// Apply offline jet pT cut
337			//
338			int trigger_jets = 0;
339			for(Jets::const_iterator jet = event->jets()->begin();
340			event->jets()->end() != jet &&
341			2 > trigger_jets;
342			++jet)
343			{
344			if (max_pt < (*jet)->p4()->Pt() &&
345			3.0 > fabs((*jet)->p4()->Eta()))
346
347			++trigger_jets;
348			}
349
350			return 1 < trigger_jets;
351			}