TreeFiller/src/FillerMetaInfos.cc

// $Id: FillerMetaInfos.cc,v 1.14 2008/09/10 03:31:02 loizides Exp $

#include "MitProd/TreeFiller/interface/FillerMetaInfos.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/Framework/interface/TriggerNames.h"
#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/Common/interface/TriggerResults.h"
#include "DataFormats/HLTReco/interface/TriggerEvent.h"
#include "MitAna/DataTree/interface/Names.h"
#include "MitAna/DataTree/interface/EventHeader.h"
#include "MitAna/DataTree/interface/LAHeader.h"
//#include "MitAna/DataTree/interface/TriggerName.h"
#include "MitAna/DataTree/interface/RunInfo.h"
#include <TObjectTable.h>
#include <THashTable.h>
#include <TIterator.h>

using namespace std;
using namespace edm;
using namespace mithep;

bool mithep::FillerMetaInfos::instance_ = 0;

//--------------------------------------------------------------------------------------------------
FillerMetaInfos::FillerMetaInfos(const ParameterSet &cfg, bool active) : 
  BaseFiller(cfg,"MetaInfos",(instance_==0||active?1:0)),
  hltActive_(Conf().getUntrackedParameter<bool>("hltActive",true)),
  l1Active_(Conf().getUntrackedParameter<bool>("l1Active",true)),
  evtName_(Conf().getUntrackedParameter<string>("evtName",Names::gkEvtHeaderBrn)),
  runName_(Conf().getUntrackedParameter<string>("runName",Names::gkRunInfoBrn)),
  lahName_(Conf().getUntrackedParameter<string>("lahName",Names::gkLAHeaderBrn)),
  hltName_(Conf().getUntrackedParameter<string>("hltName","TriggerResults")),
  l1tName_(Conf().getUntrackedParameter<string>("l1tName","todo")),
  tws_(0),
  eventHeader_(new EventHeader()),
  evtLAHeader_(new LAHeader()),
  runInfo_(new RunInfo()),
  runTree_(0),
  laTree_(0),
  runEntries_(0),
  fileNum_(0)
{
  // Constructor.

  instance_=1;
}

//--------------------------------------------------------------------------------------------------
FillerMetaInfos::~FillerMetaInfos()
{
  // Destructor.

  delete eventHeader_;
  delete evtLAHeader_;
  delete runInfo_;
  eventHeader_ = 0;
  evtLAHeader_ = 0;
  runInfo_     = 0;
  runTree_     = 0;
  laTree_      = 0;
}

//--------------------------------------------------------------------------------------------------
void FillerMetaInfos::BookDataBlock(TreeWriter &tws)
{
  // Create run info tre and book our branches.

  // add branches to main tree
  tws.AddBranch(evtName_.c_str(),"mithep::EventHeader",&eventHeader_);

  // add branches to run info tree
  tws.AddBranchToTree(Names::gkRunTreeName,runName_.c_str(),"mithep::RunInfo",&runInfo_);
  tws.SetAutoFill(Names::gkRunTreeName,0);
  runTree_=tws.GetTree(Names::gkRunTreeName);

  // add branches to lookahead tree
  tws.AddBranchToTree(Names::gkLATreeName,Names::gkLAHeaderBrn,"mithep::LAHeader",&evtLAHeader_);
  tws.SetAutoFill(Names::gkLATreeName,0);
  laTree_=tws.GetTree(Names::gkLATreeName);

  // store pointer to tree writer 
  tws_ = &tws;
}

//--------------------------------------------------------------------------------------------------
void FillerMetaInfos::FillDataBlock(const edm::Event &event, 
                                    const edm::EventSetup &setup)
{
  // Fill our data structures.

  // clear map if a new file was opened
  if (tws_->GetFileNumber()!=fileNum_) {
    runmap_.clear();
    fileNum_ = tws_->GetFileNumber();
    runEntries_ = 0;
  }

  UInt_t runnum = event.id().run();

  // store look ahead information
  if (runEntries_>0) {
    evtLAHeader_->SetRunNum(runnum);
    laTree_->Fill();
    if(0) {
      if(laTree_->GetEntries() % 100==0)
        gObjectTable->Print();
    }
  }

  // fill event header
  eventHeader_->SetEvtNum(event.id().event());
  eventHeader_->SetLumiSec(event.luminosityBlock());
  eventHeader_->SetRunNum(runnum);

  // look-up if entry is in map
  map<UInt_t,Int_t>::iterator riter = runmap_.find(runnum);
  if (riter != runmap_.end()) {
    Int_t runentry = riter->second;
    eventHeader_->SetRunEntry(runentry);

//      FillHltTrigger(event,setup);
    return;
  }

  // fill new run info
  Int_t runentry = runEntries_;
  eventHeader_->SetRunEntry(runentry);
  runmap_.insert(pair<UInt_t,Int_t>(runnum,runentry));

  runInfo_->SetRunNum(runnum);
  FillHltInfo(event,setup);
//FillHltTrigger(event,setup);

  runTree_->Fill();

  ++runEntries_;
}

//--------------------------------------------------------------------------------------------------
void FillerMetaInfos::FillHltInfo(const edm::Event &event, 
                                  const edm::EventSetup &setup)
{
  //

  if (!hltActive_) return;

#if 0
  using namespace reco;
  using namespace trigger;

  ParameterSet ps;
  if (!event.getProcessParameterSet("HLT",ps))
  {
    // todo error...
    return;
  } 

  typedef std::vector<std::string> vstring;

  Handle<TriggerResults> triggerResultsHLT;
  GetProduct(hltName_, triggerResultsHLT, event);

  THashTable trigtable(1000,0);
  THashTable modtable(1000,0);
  THashTable testtable(1000,0);

  TriggerNames triggerNames(*(triggerResultsHLT.product())); 
  for(UInt_t i=0;i<triggerNames.size();++i) {

    TriggerName *trig = new TriggerName(triggerNames.triggerName(i).c_str(),i);
    trigtable.Add(trig);

    if (!ps.exists(triggerNames.triggerName(i))) {
      cout << "Error " << triggerNames.triggerName(i) << " not found" << endl;
    } else {
      vstring path(ps.getParameter<vstring>(triggerNames.triggerName(i)));
      for(UInt_t j=0;j<path.size();++j) {
        TriggerName *mod = new TriggerName(path.at(j).c_str(),j);
        if(!modtable.FindObject(mod->Name()))
          modtable.Add(mod);
        TriggerName *mod2 = new TriggerName(path.at(j).c_str(),i);
        testtable.Add(mod2);
      }
    }
  }

  trigtable.Rehash(trigtable.GetSize());
  modtable.Rehash(modtable.GetSize());
  testtable.Rehash(modtable.GetSize());
  cout << "------------- " << testtable.AverageCollisions() << endl;
  TIterator *iter = modtable.MakeIterator();
  while( TriggerName *t = dynamic_cast<TriggerName*>(iter->Next()) ) {
    cout << t->Name() 
         << ": " << modtable.Collisions(t->Name()) 
         << ": " << testtable.Collisions(t->Name()) << endl;
  }
  
#if 0
  Handle<TriggerEvent> handle;
  GetProduct("hltTriggerSummaryAOD", handle, event);

  Handle<TriggerResults> triggerResultsHLT;
  GetProduct(hltName_, triggerResultsHLT, event);

  //This gives names of trigger paths and the accept bit.
  TriggerNames triggerNames(*(triggerResultsHLT.product())); 
  for(UInt_t i=0;i<triggerNames.size();++i) {
//    cout << i << " " << triggerNames.triggerName(i) << " " << triggerResultsHLT->accept(i) << " " 
//         << triggerResultsHLT->index(i) << endl;
  }


   if (1) {
     cout << "Used Processname: " << handle->usedProcessName() << endl;
     const size_type nC(handle->sizeCollections());
     cout << "Number of packed Collections: " << nC << endl;
     cout << "The Collections: #, tag, 1-past-end index" << endl;
     for (size_type iC=0; iC!=nC; ++iC) {
       cout << iC << " "
            << handle->collectionTag(iC).encode() << " "
            << handle->collectionKey(iC) << endl;
     }
     const size_type nO(handle->sizeObjects());
     cout << "Number of TriggerObjects: " << nO << endl;
     cout << "The TriggerObjects: #, id, pt, eta, phi, mass" << endl;
     const TriggerObjectCollection& TOC(handle->getObjects());
     for (size_type iO=0; iO!=nO; ++iO) {
       const TriggerObject& TO(TOC[iO]);
       cout << iO << " " << TO.id() << " " << TO.pt() << " " << TO.eta() << " " << TO.phi() << " " << TO.mass() << endl;
     }
     const size_type nF(handle->sizeFilters());
     cout << "Number of TriggerFilters: " << nF << endl;
     cout << "The Filters: #, tag, #ids/#keys, the id/key pairs" << endl;
     for (size_type iF=0; iF!=nF; ++iF) {
       const Vids& VIDS (handle->filterIds(iF));
       const Keys& KEYS(handle->filterKeys(iF));
       const size_type nI(VIDS.size());
       const size_type nK(KEYS.size());
       cout << iF << " " << handle->filterTag(iF).encode()
            << " " << nI << "/" << nK
            << " the pairs: ";
       const size_type n(max(nI,nK));
       for (size_type i=0; i!=n; ++i) {
         cout << " " << VIDS[i] << "/" << KEYS[i];
       }
       cout << endl;
       assert (nI==nK);
     }
   } else {
     cout << "Handle invalid! Check InputTag provided." << endl;
   }
   cout << endl;

#endif
#endif
}
Revision:	1.15
Committed:	Wed Sep 10 13:18:58 2008 UTC (16 years, 7 months ago) by loizides
Content type:	text/plain
Branch:	MAIN
Changes since 1.14:	+4 -4 lines
Log Message:	Take out trigger for now.
#	User	Rev	Content
1	loizides	1.15	// $Id: FillerMetaInfos.cc,v 1.14 2008/09/10 03:31:02 loizides Exp $
2	loizides	1.1
3			#include "MitProd/TreeFiller/interface/FillerMetaInfos.h"
4			#include "FWCore/MessageLogger/interface/MessageLogger.h"
5	loizides	1.5	#include "FWCore/Framework/interface/TriggerNames.h"
6	loizides	1.1	#include "DataFormats/Common/interface/Handle.h"
7	loizides	1.5	#include "DataFormats/Common/interface/TriggerResults.h"
8	loizides	1.14	#include "DataFormats/HLTReco/interface/TriggerEvent.h"
9	loizides	1.1	#include "MitAna/DataTree/interface/Names.h"
10	loizides	1.5	#include "MitAna/DataTree/interface/EventHeader.h"
11			#include "MitAna/DataTree/interface/LAHeader.h"
12	loizides	1.15	//#include "MitAna/DataTree/interface/TriggerName.h"
13	loizides	1.5	#include "MitAna/DataTree/interface/RunInfo.h"
14	loizides	1.8	#include <TObjectTable.h>
15	loizides	1.14	#include <THashTable.h>
16			#include <TIterator.h>
17	sixie	1.13
18	loizides	1.1	using namespace std;
19			using namespace edm;
20			using namespace mithep;
21
22	loizides	1.12	bool mithep::FillerMetaInfos::instance_ = 0;
23
24	loizides	1.8	//--------------------------------------------------------------------------------------------------
25	loizides	1.7	FillerMetaInfos::FillerMetaInfos(const ParameterSet &cfg, bool active) :
26	loizides	1.12	BaseFiller(cfg,"MetaInfos",(instance_==0\|\|active?1:0)),
27	sixie	1.13	hltActive_(Conf().getUntrackedParameter<bool>("hltActive",true)),
28	loizides	1.14	l1Active_(Conf().getUntrackedParameter<bool>("l1Active",true)),
29	loizides	1.2	evtName_(Conf().getUntrackedParameter<string>("evtName",Names::gkEvtHeaderBrn)),
30			runName_(Conf().getUntrackedParameter<string>("runName",Names::gkRunInfoBrn)),
31	loizides	1.4	lahName_(Conf().getUntrackedParameter<string>("lahName",Names::gkLAHeaderBrn)),
32	loizides	1.5	hltName_(Conf().getUntrackedParameter<string>("hltName","TriggerResults")),
33			l1tName_(Conf().getUntrackedParameter<string>("l1tName","todo")),
34			tws_(0),
35	loizides	1.2	eventHeader_(new EventHeader()),
36	loizides	1.3	evtLAHeader_(new LAHeader()),
37	loizides	1.2	runInfo_(new RunInfo()),
38			runTree_(0),
39	loizides	1.3	laTree_(0),
40			runEntries_(0),
41			fileNum_(0)
42	loizides	1.1	{
43	loizides	1.3	// Constructor.
44	loizides	1.12
45			instance_=1;
46	loizides	1.1	}
47
48	loizides	1.8	//--------------------------------------------------------------------------------------------------
49	loizides	1.1	FillerMetaInfos::~FillerMetaInfos()
50			{
51	loizides	1.3	// Destructor.
52
53	loizides	1.2	delete eventHeader_;
54	loizides	1.8	delete evtLAHeader_;
55	loizides	1.2	delete runInfo_;
56	loizides	1.3	eventHeader_ = 0;
57	loizides	1.8	evtLAHeader_ = 0;
58	loizides	1.3	runInfo_ = 0;
59			runTree_ = 0;
60			laTree_ = 0;
61	loizides	1.1	}
62
63	loizides	1.8	//--------------------------------------------------------------------------------------------------
64	loizides	1.2	void FillerMetaInfos::BookDataBlock(TreeWriter &tws)
65	loizides	1.1	{
66	loizides	1.3	// Create run info tre and book our branches.
67
68			// add branches to main tree
69	loizides	1.2	tws.AddBranch(evtName_.c_str(),"mithep::EventHeader",&eventHeader_);
70	loizides	1.3
71			// add branches to run info tree
72			tws.AddBranchToTree(Names::gkRunTreeName,runName_.c_str(),"mithep::RunInfo",&runInfo_);
73	loizides	1.2	tws.SetAutoFill(Names::gkRunTreeName,0);
74			runTree_=tws.GetTree(Names::gkRunTreeName);
75	loizides	1.3
76			// add branches to lookahead tree
77			tws.AddBranchToTree(Names::gkLATreeName,Names::gkLAHeaderBrn,"mithep::LAHeader",&evtLAHeader_);
78			tws.SetAutoFill(Names::gkLATreeName,0);
79			laTree_=tws.GetTree(Names::gkLATreeName);
80
81			// store pointer to tree writer
82			tws_ = &tws;
83	loizides	1.1	}
84
85	loizides	1.8	//--------------------------------------------------------------------------------------------------
86	loizides	1.5	void FillerMetaInfos::FillDataBlock(const edm::Event &event,
87	loizides	1.1	const edm::EventSetup &setup)
88			{
89	loizides	1.3	// Fill our data structures.
90
91			// clear map if a new file was opened
92			if (tws_->GetFileNumber()!=fileNum_) {
93			runmap_.clear();
94			fileNum_ = tws_->GetFileNumber();
95			runEntries_ = 0;
96			}
97
98			UInt_t runnum = event.id().run();
99
100			// store look ahead information
101			if (runEntries_>0) {
102			evtLAHeader_->SetRunNum(runnum);
103			laTree_->Fill();
104	loizides	1.14	if(0) {
105			if(laTree_->GetEntries() % 100==0)
106			gObjectTable->Print();
107			}
108	loizides	1.3	}
109
110	loizides	1.2	// fill event header
111			eventHeader_->SetEvtNum(event.id().event());
112			eventHeader_->SetLumiSec(event.luminosityBlock());
113			eventHeader_->SetRunNum(runnum);
114
115	loizides	1.3	// look-up if entry is in map
116	loizides	1.2	map<UInt_t,Int_t>::iterator riter = runmap_.find(runnum);
117			if (riter != runmap_.end()) {
118			Int_t runentry = riter->second;
119			eventHeader_->SetRunEntry(runentry);
120	loizides	1.14
121			// FillHltTrigger(event,setup);
122	loizides	1.2	return;
123			}
124	loizides	1.1
125	loizides	1.2	// fill new run info
126			Int_t runentry = runEntries_;
127			eventHeader_->SetRunEntry(runentry);
128			runmap_.insert(pair<UInt_t,Int_t>(runnum,runentry));
129
130			runInfo_->SetRunNum(runnum);
131	loizides	1.14	FillHltInfo(event,setup);
132			//FillHltTrigger(event,setup);
133
134	loizides	1.2	runTree_->Fill();
135	loizides	1.3
136	loizides	1.2	++runEntries_;
137	loizides	1.1	}
138	loizides	1.5
139	loizides	1.8	//--------------------------------------------------------------------------------------------------
140	loizides	1.5	void FillerMetaInfos::FillHltInfo(const edm::Event &event,
141			const edm::EventSetup &setup)
142			{
143			//
144
145	loizides	1.14	if (!hltActive_) return;
146
147	loizides	1.15	#if 0
148	loizides	1.14	using namespace reco;
149			using namespace trigger;
150
151			ParameterSet ps;
152			if (!event.getProcessParameterSet("HLT",ps))
153			{
154			// todo error...
155			return;
156			}
157
158			typedef std::vector<std::string> vstring;
159
160	loizides	1.5	Handle<TriggerResults> triggerResultsHLT;
161	loizides	1.14	GetProduct(hltName_, triggerResultsHLT, event);
162
163			THashTable trigtable(1000,0);
164			THashTable modtable(1000,0);
165			THashTable testtable(1000,0);
166	sixie	1.13
167	loizides	1.14	TriggerNames triggerNames(*(triggerResultsHLT.product()));
168			for(UInt_t i=0;i<triggerNames.size();++i) {
169
170			TriggerName *trig = new TriggerName(triggerNames.triggerName(i).c_str(),i);
171			trigtable.Add(trig);
172
173			if (!ps.exists(triggerNames.triggerName(i))) {
174			cout << "Error " << triggerNames.triggerName(i) << " not found" << endl;
175			} else {
176			vstring path(ps.getParameter<vstring>(triggerNames.triggerName(i)));
177			for(UInt_t j=0;j<path.size();++j) {
178			TriggerName *mod = new TriggerName(path.at(j).c_str(),j);
179			if(!modtable.FindObject(mod->Name()))
180			modtable.Add(mod);
181			TriggerName *mod2 = new TriggerName(path.at(j).c_str(),i);
182			testtable.Add(mod2);
183			}
184			}
185			}
186
187			trigtable.Rehash(trigtable.GetSize());
188			modtable.Rehash(modtable.GetSize());
189			testtable.Rehash(modtable.GetSize());
190			cout << "------------- " << testtable.AverageCollisions() << endl;
191			TIterator *iter = modtable.MakeIterator();
192			while( TriggerName t = dynamic_cast<TriggerName>(iter->Next()) ) {
193			cout << t->Name()
194			<< ": " << modtable.Collisions(t->Name())
195			<< ": " << testtable.Collisions(t->Name()) << endl;
196	loizides	1.5	}
197	loizides	1.14
198			#if 0
199			Handle<TriggerEvent> handle;
200			GetProduct("hltTriggerSummaryAOD", handle, event);
201
202			Handle<TriggerResults> triggerResultsHLT;
203			GetProduct(hltName_, triggerResultsHLT, event);
204	loizides	1.5
205	sixie	1.13	//This gives names of trigger paths and the accept bit.
206	loizides	1.5	TriggerNames triggerNames(*(triggerResultsHLT.product()));
207			for(UInt_t i=0;i<triggerNames.size();++i) {
208	loizides	1.14	// cout << i << " " << triggerNames.triggerName(i) << " " << triggerResultsHLT->accept(i) << " "
209			// << triggerResultsHLT->index(i) << endl;
210	loizides	1.5	}
211	sixie	1.13
212	loizides	1.14
213			if (1) {
214			cout << "Used Processname: " << handle->usedProcessName() << endl;
215			const size_type nC(handle->sizeCollections());
216			cout << "Number of packed Collections: " << nC << endl;
217			cout << "The Collections: #, tag, 1-past-end index" << endl;
218			for (size_type iC=0; iC!=nC; ++iC) {
219			cout << iC << " "
220			<< handle->collectionTag(iC).encode() << " "
221			<< handle->collectionKey(iC) << endl;
222			}
223			const size_type nO(handle->sizeObjects());
224			cout << "Number of TriggerObjects: " << nO << endl;
225			cout << "The TriggerObjects: #, id, pt, eta, phi, mass" << endl;
226			const TriggerObjectCollection& TOC(handle->getObjects());
227			for (size_type iO=0; iO!=nO; ++iO) {
228			const TriggerObject& TO(TOC[iO]);
229			cout << iO << " " << TO.id() << " " << TO.pt() << " " << TO.eta() << " " << TO.phi() << " " << TO.mass() << endl;
230			}
231			const size_type nF(handle->sizeFilters());
232			cout << "Number of TriggerFilters: " << nF << endl;
233			cout << "The Filters: #, tag, #ids/#keys, the id/key pairs" << endl;
234			for (size_type iF=0; iF!=nF; ++iF) {
235			const Vids& VIDS (handle->filterIds(iF));
236			const Keys& KEYS(handle->filterKeys(iF));
237			const size_type nI(VIDS.size());
238			const size_type nK(KEYS.size());
239			cout << iF << " " << handle->filterTag(iF).encode()
240			<< " " << nI << "/" << nK
241			<< " the pairs: ";
242			const size_type n(max(nI,nK));
243			for (size_type i=0; i!=n; ++i) {
244			cout << " " << VIDS[i] << "/" << KEYS[i];
245			}
246			cout << endl;
247			assert (nI==nK);
248			}
249			} else {
250			cout << "Handle invalid! Check InputTag provided." << endl;
251			}
252			cout << endl;
253
254			#endif
255	loizides	1.15	#endif
256	loizides	1.5	}