Fork me on GitHub

Context Navigation

source: svn/trunk/src/TriggerUtil.cc@ 429

Last change on this file since 429 was 264, checked in by Xavier Rouby, 16 years ago
first test 2.0
File size: 17.2 KB

Rev	Line
[260]	1	/***********************************************************************
	2
	3	/----------------------------------------------\
	4	\| Delphes, a framework for the fast simulation \|
	5	\| of a generic collider experiment \|
	6	\----------------------------------------------/
	7
	8
	9	This package uses:
	10	------------------
	11	FastJet algorithm: Phys. Lett. B641 (2006) [hep-ph/0512210]
	12	Hector: JINST 2:P09005 (2007) [physics.acc-ph:0707.1198v2]
	13	FROG: [hep-ex/0901.2718v1]
	14
	15	------------------------------------------------------------------
	16
	17	Main authors:
	18	-------------
	19
	20	Severine Ovyn Xavier Rouby
	21	severine.ovyn@uclouvain.be xavier.rouby@cern
	22
	23	Center for Particle Physics and Phenomenology (CP3)
	24	Universite catholique de Louvain (UCL)
	25	Louvain-la-Neuve, Belgium
	26
	27	Copyright (C) 2008-2009,
	28	All rights reserved.
	29
	30	***********************************************************************/
[52]	31
	32	// \brief Trigger class, and some generic definitions
	33
[219]	34	#include "TriggerUtil.h"
[52]	35
	36	#include <iostream>
[219]	37	#include <iomanip>
[52]	38	#include <sstream>
	39	#include <fstream>
[219]	40	#include <string>
[52]	41
	42	using namespace std;
	43
[63]	44	TriggerTable::TriggerTable() {
	45	has_been_evaluated=false;
	46	}
[52]	47
[243]	48	TriggerTable& TriggerTable::operator=(TriggerTable&tt) {
	49	if (this == &tt) return *this;
	50	has_been_evaluated = tt.has_been_evaluated;
	51	GlobalResult = tt.GlobalResult;
	52	for (unsigned int i=0; i<tt.list_of_trigger_bits.size(); i++)
	53	list_of_trigger_bits.push_back(tt.list_of_trigger_bits[i]);
	54	return *this;
	55	}
	56
	57	TriggerTable::TriggerTable(const TriggerTable& tt) {
	58	has_been_evaluated = tt.has_been_evaluated;
	59	GlobalResult = tt.GlobalResult;
	60	for (unsigned int i=0; i<tt.list_of_trigger_bits.size(); i++)
	61	list_of_trigger_bits.push_back(tt.list_of_trigger_bits[i]);
	62	}
	63
	64
[219]	65	void TriggerTable::TriggerCardReader(const string& filename){
[63]	66	ifstream trigger_file(filename.c_str());
	67	if( !trigger_file.good() ) {
[250]	68	cerr << left << setw(30) <<"** ERROR: Trigger input file "<<""
	69	<< right << setw(15) <<filename<<""
	70	<< right << setw(24) <<"not found. Exiting... **"<<endl;
[63]	71	return;
[52]	72	}
	73
[63]	74	TriggerBit mybit;
	75	string temp_string, temp_string_no_comment, trigger_name, trigger_algorithm;
	76	while ( getline(trigger_file,temp_string) ) {
	77	string temp_string_no_comment = temp_string.substr(0,temp_string.find("#")); //remove comments
	78	if(temp_string_no_comment.size()<2) continue; // avoid empty lines
	79	istringstream temp_stream(temp_string_no_comment);
	80
	81	temp_stream >> trigger_name;
	82	trigger_algorithm = temp_string_no_comment.substr( temp_string_no_comment.find(">>")+2) ;
	83
	84	mybit.TriggerBit::GetTrigCondition(trigger_algorithm);
	85	list_of_trigger_bits.push_back(mybit);
	86	}
[52]	87	}
	88
[63]	89
[219]	90	void TriggerTable::PrintTriggerTable(const string& LogName) {
[63]	91
	92	ofstream f_out(LogName.c_str(),ios::app);
	93	f_out<<"* *"<<"\n";
	94	f_out<<"#*********************************************** *"<<"\n";
	95	f_out<<"# Trigger conditions defined in the trigger card *"<<"\n";
	96	f_out<<"#*********************************************** *"<<"\n";
	97	f_out<<"* *"<<"\n";
	98
	99	f_out.close();
	100
	101	for(unsigned int i=0; i < list_of_trigger_bits.size(); i++) {
	102	list_of_trigger_bits[i].PrintTrigCondition(LogName,i+1);
	103	}
[74]	104	f_out<<"* *"<<"\n";
	105	f_out<<"#*********************************************************************"<<"\n";
	106
[63]	107	}
	108
[72]	109	bool TriggerTable::GetGlobalResult(TClonesArray branchElecTrig, TClonesArray branchMuonTrig,
	110	TClonesArray branchJetTrig, TClonesArray branchTauJetTrig,
	111	TClonesArray branchPhotonTrig, TClonesArray branchETmisTrig, ExRootTreeBranch *branchTrigger) {
	112
	113	TRootTrigger *elementTrigger;
	114	GlobalResult=false;
	115	for(unsigned int i=0; i < list_of_trigger_bits.size(); i++) {
	116	if(list_of_trigger_bits[i].GetResult(branchElecTrig, branchMuonTrig, branchJetTrig, branchTauJetTrig, branchPhotonTrig, branchETmisTrig))
	117	{
	118	GlobalResult=true;
	119	int flag=i+1;
	120	elementTrigger = (TRootTrigger*) branchTrigger->NewEntry();
	121	elementTrigger->Accepted=flag;
	122	}
	123	}
	124	if(GlobalResult)
	125	{
	126	elementTrigger = (TRootTrigger*) branchTrigger->NewEntry();
	127	elementTrigger->Accepted=0;
	128	}
	129	return GlobalResult;
	130
	131	}
	132
[63]	133	//*************************************************************************
[264]	134	TriggerBit::TriggerBit() {
	135	}
[63]	136
[243]	137	TriggerBit::~TriggerBit() {
	138	ElecValues.clear();
[250]	139	IElecValues.clear();
[243]	140	MuonValues.clear();
[250]	141	IMuonValues.clear();
[243]	142	JetValues.clear();
[250]	143	BjetValues.clear();
[243]	144	TauJetValues.clear();
	145	EtmisValues.clear();
	146	GammaValues.clear();
	147	}
	148
	149	TriggerBit::TriggerBit(const TriggerBit& tb) {
	150	for(unsigned int i=0; i<tb.ElecValues.size(); i++)
	151	ElecValues.push_back(tb.ElecValues[i]);
	152
[250]	153	for(unsigned int i=0; i<tb.IElecValues.size(); i++)
	154	IElecValues.push_back(tb.IElecValues[i]);
	155
[243]	156	for(unsigned int i=0; i<tb.MuonValues.size(); i++)
	157	MuonValues.push_back(tb.MuonValues[i]);
	158
[250]	159	for(unsigned int i=0; i<tb.IMuonValues.size(); i++)
	160	IMuonValues.push_back(tb.IMuonValues[i]);
	161
[243]	162	for(unsigned int i=0; i<tb.JetValues.size(); i++)
	163	JetValues.push_back(tb.JetValues[i]);
	164
[250]	165	for(unsigned int i=0; i<tb.BjetValues.size(); i++)
	166	BjetValues.push_back(tb.BjetValues[i]);
	167
[243]	168	for(unsigned int i=0; i<tb.TauJetValues.size(); i++)
	169	TauJetValues.push_back(tb.TauJetValues[i]);
	170
	171	for(unsigned int i=0; i<tb.EtmisValues.size(); i++)
	172	EtmisValues.push_back(tb.EtmisValues[i]);
	173
	174	for(unsigned int i=0; i<tb.GammaValues.size(); i++)
	175	GammaValues.push_back(tb.GammaValues[i]);
	176
	177	Result = tb.Result;
	178	}
	179
	180	TriggerBit& TriggerBit::operator=(const TriggerBit& tb) {
	181	if (this==&tb) return *this;
	182	for(unsigned int i=0; i<tb.ElecValues.size(); i++)
	183	ElecValues.push_back(tb.ElecValues[i]);
	184
[250]	185	for(unsigned int i=0; i<tb.IElecValues.size(); i++)
	186	IElecValues.push_back(tb.IElecValues[i]);
	187
[243]	188	for(unsigned int i=0; i<tb.MuonValues.size(); i++)
	189	MuonValues.push_back(tb.MuonValues[i]);
	190
[250]	191	for(unsigned int i=0; i<tb.IMuonValues.size(); i++)
	192	IMuonValues.push_back(tb.IMuonValues[i]);
	193
[243]	194	for(unsigned int i=0; i<tb.JetValues.size(); i++)
	195	JetValues.push_back(tb.JetValues[i]);
	196
[250]	197	for(unsigned int i=0; i<tb.BjetValues.size(); i++)
	198	BjetValues.push_back(tb.BjetValues[i]);
	199
[243]	200	for(unsigned int i=0; i<tb.TauJetValues.size(); i++)
	201	TauJetValues.push_back(tb.TauJetValues[i]);
	202
	203	for(unsigned int i=0; i<tb.EtmisValues.size(); i++)
	204	EtmisValues.push_back(tb.EtmisValues[i]);
	205
	206	for(unsigned int i=0; i<tb.GammaValues.size(); i++)
	207	GammaValues.push_back(tb.GammaValues[i]);
	208	Result = tb.Result;
	209
	210	return *this;
	211	}
	212
	213
	214
[72]	215	bool TriggerBit::GetResult(TClonesArray branchElecTrig, TClonesArray branchMuonTrig,
	216	TClonesArray branchJetTrig, TClonesArray branchTauJetTrig,
	217	TClonesArray branchPhotonTrig, TClonesArray branchETmisTrig)
	218	{
[250]	219	TSimpleArray<TRootJet> bjets=SubArrayBjets(branchJetTrig);
	220	TSimpleArray<TRootElectron> Ielectron=SubArrayIElec(branchElecTrig);
	221	TSimpleArray<TRootMuon> Imuon=SubArrayIMuon(branchMuonTrig);
[264]	222
[72]	223	int elec_size = ElecValues.size();
[250]	224	int Ielec_size = IElecValues.size();
[72]	225	int muon_size = MuonValues.size();
[250]	226	int Imuon_size = IMuonValues.size();
[72]	227	int jet_size = JetValues.size();
[250]	228	int bjet_size = BjetValues.size();
[72]	229	int taujet_size = TauJetValues.size();
	230	int gamma_size = GammaValues.size();
	231	int etmis_size = EtmisValues.size();
	232
	233	Result=false;
	234	if(
	235	(branchElecTrig->GetEntries() >= elec_size )
[250]	236	&& (Ielectron.GetEntries() >= Ielec_size )
[72]	237	&& (branchMuonTrig->GetEntries() >= muon_size )
[250]	238	&& (Imuon.GetEntries() >= Imuon_size )
[72]	239	&& (branchJetTrig->GetEntries() >= jet_size )
[250]	240	&& (bjets.GetEntries() >= bjet_size )
[72]	241	&& (branchTauJetTrig->GetEntries() >= taujet_size )
	242	&& (branchPhotonTrig->GetEntries() >= gamma_size )
	243	)
	244	{
	245	Result=true;
	246	if(elec_size!=0){
	247	TRootElectron *electron;
	248	for(int i=0;i<elec_size;i++){
	249	electron = (TRootElectron*)branchElecTrig->At(i);
	250	if(electron->PT < ElecValues[i])Result=false;}}
	251
[250]	252	if(Ielec_size!=0)
	253	{
	254	TRootElectron *i_elec; Ielectron.Reset();
	255	int i=0;
	256	while((i_elec = Ielectron.Next()))
	257	{
	258	if(i_elec->PT < IElecValues[i])Result=false;
	259	i++;
	260	}
	261	}
	262
[72]	263	if(muon_size!=0){
	264	TRootMuon *muon;
	265	for(int i=0;i<muon_size;i++){
	266	muon = (TRootMuon*)branchMuonTrig->At(i);
	267	if(muon->PT < MuonValues[i])Result=false;}}
	268
[250]	269	if(Imuon_size!=0)
	270	{
	271	TRootMuon *i_muon; Imuon.Reset();
	272	int i=0;
	273	while((i_muon = Imuon.Next()))
	274	{
	275	if(i_muon->PT < IMuonValues[i])Result=false;
	276	i++;
	277	}
	278	}
	279
[72]	280	if(jet_size!=0){
	281	TRootJet *jet;
	282	for(int i=0;i<jet_size;i++){
	283	jet = (TRootJet*)branchJetTrig->At(i);
	284	if(jet->PT < JetValues[i])Result=false;}}
	285
[250]	286	if(bjet_size!=0)
	287	{
	288	TRootJet *i_bjets; bjets.Reset();
	289	int i=0;
	290	while((i_bjets = bjets.Next()))
	291	{
	292	if(i_bjets->PT < BjetValues[i])Result=false;
	293	i++;
	294	}
	295	}
	296
[72]	297	if(taujet_size!=0){
	298	TRootTauJet *taujet;
	299	for(int i=0;i<taujet_size;i++){
	300	taujet = (TRootTauJet*)branchTauJetTrig->At(i);
	301	if(taujet->PT < TauJetValues[i])Result=false;}}
	302
	303	if(gamma_size!=0){
	304	TRootPhoton *gamma;
	305	for(int i=0;i<gamma_size;i++){
	306	gamma = (TRootPhoton*)branchPhotonTrig->At(i);
	307	if(gamma->PT < GammaValues[i])Result=false;}}
	308
	309
	310	if(etmis_size!=0){
	311	TRootETmis etmis = (TRootETmis)branchETmisTrig->At(0);
	312	if(etmis->ET < EtmisValues[0])Result=false;}
	313
	314	}
	315	return Result;
	316	}
	317
[63]	318	void TriggerBit::GetTrigCondition(const string& trigger_algorithm) {
	319
[52]	320	vector<string> ElecSequences;
[250]	321	vector<string> IElecSequences;
[52]	322	vector<string> MuonSequences;
[250]	323	vector<string> IMuonSequences;
[52]	324	vector<string> JetSequences;
	325	vector<string> TauJetSequences;
	326	vector<string> EtmisSequences;
	327	vector<string> GammaSequences;
[250]	328	vector<string> BjetSequences;
[63]	329
[250]	330	char * result = new char[256];
[52]	331	result = strtok( (char*) trigger_algorithm.c_str(),"&");
[63]	332	while( result != NULL )
[52]	333	{
	334	if(strstr (result,"ELEC"))ElecSequences.push_back(result);
[250]	335	if(strstr (result,"IElec"))IElecSequences.push_back(result);
[52]	336	if(strstr (result,"MUON"))MuonSequences.push_back(result);
[250]	337	if(strstr (result,"IMuon"))IMuonSequences.push_back(result);
[52]	338	if(strstr (result,"JET"))JetSequences.push_back(result);
[250]	339	if(strstr (result,"TAU"))TauJetSequences.push_back(result);
[52]	340	if(strstr (result,"ETMIS"))EtmisSequences.push_back(result);
	341	if(strstr (result,"GAMMA"))GammaSequences.push_back(result);
[250]	342	if(strstr (result,"Bjet"))BjetSequences.push_back(result);
[52]	343	result = strtok( NULL,"&");
[63]	344	}
[264]	345	delete [] result;
[52]	346
[63]	347	ElecValues = GetCuts(ElecSequences);
[250]	348	IElecValues = GetCuts(IElecSequences);
[63]	349	MuonValues = GetCuts(MuonSequences);
[250]	350	IMuonValues = GetCuts(IMuonSequences);
[63]	351	JetValues = GetCuts(JetSequences);
	352	TauJetValues = GetCuts(TauJetSequences);
	353	EtmisValues = GetCuts(EtmisSequences);
	354	GammaValues = GetCuts(GammaSequences);
[250]	355	BjetValues = GetCuts(BjetSequences);
[63]	356
[52]	357	}
[219]	358
[264]	359
[219]	360	void TriggerBit::PrintTrigCondition(const string& LogName,const int i)
[63]	361	{
	362	int elec_size = TriggerBit::ElecValues.size();
[250]	363	int Ielec_size = TriggerBit::IElecValues.size();
[63]	364	int muon_size = TriggerBit::MuonValues.size();
[250]	365	int Imuon_size = TriggerBit::IMuonValues.size();
[63]	366	int jet_size = TriggerBit::JetValues.size();
	367	int taujet_size = TriggerBit::TauJetValues.size();
	368	int gamma_size = TriggerBit::GammaValues.size();
	369	int etmis_size = TriggerBit::EtmisValues.size();
[250]	370	int bjets_size = TriggerBit::BjetValues.size();
[264]	371
[63]	372	ofstream f_out(LogName.c_str(),ios::app);
[52]	373
[63]	374	f_out <<"* *"<<"\n";
	375	f_out << left << setw(25) <<"# Trigger bit number "<<""
	376	<< left << setw(35) <<i <<""<< right << setw(10)<<"*"<<"\n";
	377	f_out <<"#*************************"<<"\n";
	378	f_out << left << setw(45) <<"* # Number of reconstructed objects required:"<<""<<right << setw(23)<<"*"<<"\n";
[250]	379
[63]	380	if(elec_size!=0){
[250]	381	f_out << left << setw(5) <<"** -"<<""<< left << setw(2) << elec_size <<""<< left << setw(20)<<"Electron(s) with p_T: "<<"";
[63]	382	for(int i=0;i<elec_size;i++){f_out << left << setw(5) << TriggerBit::ElecValues[i]<<"";}f_out <<"\n";}
[52]	383
[250]	384	if(Ielec_size!=0){
	385	f_out << left << setw(5) <<"** -"<<""<< left << setw(2) << Ielec_size <<""<< left << setw(20)<<"Isolated electron(s) with p_T: "<<"";
	386	for(int i=0;i<Ielec_size;i++){f_out << left << setw(5) << TriggerBit::IElecValues[i]<<"";}f_out <<"\n";}
	387
[63]	388	if(muon_size!=0){
[250]	389	f_out << left << setw(5) <<"** -"<<""<< left << setw(2) << muon_size <<""<< left << setw(20)<<"Muon(s) with p_T: "<<"";
[63]	390	for(int i=0;i<muon_size;i++){f_out << left << setw(5) << TriggerBit::MuonValues[i]<<"";}f_out <<"\n";}
[52]	391
[250]	392	if(Imuon_size!=0){
	393	f_out << left << setw(5) <<"** -"<<""<< left << setw(2) << Imuon_size <<""<< left << setw(20)<<"Isolated muon(s) with p_T: "<<"";
	394	for(int i=0;i<Imuon_size;i++){f_out << left << setw(5) << TriggerBit::IMuonValues[i]<<"";}f_out <<"\n";}
	395
[63]	396	if(jet_size!=0){
[250]	397	f_out << left << setw(5) <<"** -"<<""<< left << setw(2) << jet_size <<""<< left << setw(20)<<"Jet(s) with p_T: "<<"";
[63]	398	for(int i=0;i<jet_size;i++){f_out << left << setw(5) << TriggerBit::JetValues[i]<<"";}f_out <<"\n";}
[52]	399
[63]	400	if(taujet_size!=0){
[250]	401	f_out << left << setw(5) <<"** -"<<""<< left << setw(2) << taujet_size <<""<< left << setw(20)<<"Tau-jet(s) with p_T: "<<"";
[63]	402	for(int i=0;i<taujet_size;i++){f_out << left << setw(5) << TriggerBit::TauJetValues[i]<<"";}f_out <<"\n";}
[250]	403
	404	if(bjets_size!=0){
	405	f_out << left << setw(5) <<"** -"<<""<< left << setw(2) << bjets_size <<""<< left << setw(20)<<"B-jet(s) with p_T: "<<"";
	406	for(int i=0;i<bjets_size;i++){f_out << left << setw(5) << TriggerBit::BjetValues[i]<<"";}f_out <<"\n";}
	407
[63]	408	if(gamma_size!=0){
[250]	409	f_out << left << setw(5) <<"** -"<<""<< left << setw(2) << gamma_size <<""<< left << setw(20)<<"Photon(s) with p_T: "<<"";
[63]	410	for(int i=0;i<gamma_size;i++){f_out << left << setw(5) << TriggerBit::GammaValues[i]<<"";}f_out <<"\n";}
	411
	412	if(etmis_size!=0){
[250]	413	f_out << left << setw(5) <<"** -"<<""<< left << setw(20)<<"Transverse missing energy with p_T: "<<"";
[63]	414	for(int i=0;i<etmis_size;i++){f_out << left << setw(5) << TriggerBit::EtmisValues[i]<<"";}f_out <<"\n";}
	415	f_out <<"* *"<<"\n";
[260]	416	f_out <<"**********************************************************************"<<"\n";
[63]	417
	418	}
	419
	420	vector<float> TriggerBit::GetCuts(const vector<string> &Sequences)
	421	{
	422	vector<float> OrderedValue;
	423	string ptVal;
	424	Int_t PtVal=0;
	425	for(unsigned int i=0; i < Sequences.size(); i++) {
	426	ptVal = Sequences[i].substr( Sequences[i].find("'")+1) ;
	427	PtVal = atoi( ptVal.c_str() );
	428	OrderedValue.push_back(PtVal);
[52]	429	}
[63]	430	return OrderedValue;
[264]	431
[250]	432	}
[63]	433
[250]	434	TSimpleArray<TRootJet> TriggerBit::SubArrayBjets(TClonesArray *JET)
	435	{
	436	TIter itJet((TCollection*)JET);
	437	TRootJet *jet;
	438	itJet.Reset();
	439	TSimpleArray<TRootJet> array;
	440	while( (jet = (TRootJet*) itJet.Next()) )
	441	{
	442	if(jet->Btag==1)array.Add(jet);
	443	}
	444	return array;
[52]	445	}
	446
[250]	447	TSimpleArray<TRootElectron> TriggerBit::SubArrayIElec(TClonesArray *ELEC)
	448	{
	449	TIter itElec((TCollection*)ELEC);
	450	TRootElectron *electron;
	451	itElec.Reset();
	452	TSimpleArray<TRootElectron> array;
	453	while( (electron = (TRootElectron*) itElec.Next()) )
	454	{
	455	if(electron->IsolFlag==1)array.Add(electron);
	456	}
	457	return array;
	458	}
[63]	459
[250]	460	TSimpleArray<TRootMuon> TriggerBit::SubArrayIMuon(TClonesArray *MUON)
	461	{
	462	TIter itMuon((TCollection*)MUON);
	463	TRootMuon *muon;
	464	itMuon.Reset();
	465	TSimpleArray<TRootMuon> array;
	466	while( (muon = (TRootMuon*) itMuon.Next()) )
	467	{
	468	if(muon->IsolFlag==1)array.Add(muon);
	469	}
	470	return array;
	471	}
	472

Note: See TracBrowser for help on using the repository browser.

Download in other formats: