TreeFiller/src/FillerMetaInfos.cc

// $Id: FillerMetaInfos.cc,v 1.17 2008/09/27 05:51:25 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 <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)),
  evtName_(Conf().getUntrackedParameter<string>("evtName",Names::gkEvtHeaderBrn)),
  runName_(Conf().getUntrackedParameter<string>("runName",Names::gkRunInfoBrn)),
  lahName_(Conf().getUntrackedParameter<string>("lahName",Names::gkLAHeaderBrn)),
  l1Active_(Conf().getUntrackedParameter<bool>("l1Active",true)),
  l1TableName_(Conf().getUntrackedParameter<string>("l1TableName",Names::gkL1TableBrn)),
  l1BitsName_(Conf().getUntrackedParameter<string>("l1BitsName",Names::gkL1BitBrn)),
  l1ObjsName_(Conf().getUntrackedParameter<string>("l1ObjsName",Names::gkL1ObjBrn)),
  hltActive_(Conf().getUntrackedParameter<bool>("hltActive",true)),
  hltProcName_(Conf().getUntrackedParameter<string>("hltProcName","HLT")),
  hltResName_(Conf().getUntrackedParameter<string>("hltResName","TriggerResults::HLT")),
  hltEvtName_(Conf().getUntrackedParameter<string>("hltEvtName","hltTriggerSummaryAOD::HLT")),
  hltTableName_(Conf().getUntrackedParameter<string>("hltTableName",Names::gkHltTableBrn)),
  hltLabelName_(Conf().getUntrackedParameter<string>("hltLabelName",Names::gkHltLabelBrn)),
  hltBitsName_(Conf().getUntrackedParameter<string>("hltBitsName",Names::gkHltBitBrn)),
  hltObjsName_(Conf().getUntrackedParameter<string>("hltObjsName",Names::gkHltObjBrn)),
  tws_(0),
  eventHeader_(new EventHeader()),
  evtLAHeader_(new LAHeader()),
  runInfo_(new RunInfo()),
  runTree_(0),
  laTree_(0),
  runEntries_(0),
  l1Entries_(0),
  l1Table_(0),
  l1Tree_(0),
  hltBits_(new BitMask256),
  hltTable_(new Vector<string>),
  hltTabMap_(0),
  hltLabels_(new Vector<string>),
  hltLabMap_(0),
  hltObjs_(new TriggerObjectBaseArr),
  hltRels_(new TriggerObjectRelArr),
  hltTree_(0),
  hltEntries_(0),
  fileNum_(0)
{
  // Constructor.

  instance_=1;
}

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

  delete eventHeader_;
  delete evtLAHeader_;
  delete runInfo_;
  delete l1Table_;
  delete hltTable_;
  delete hltLabels_;
  delete hltObjs_;
  delete hltRels_;
  eventHeader_ = 0;
  evtLAHeader_ = 0;
  runInfo_     = 0;
  l1Table_     = 0;
  hltTable_    = 0;
  hltLabels_   = 0;
  hltObjs_     = 0;
  hltRels_     = 0;
  runTree_     = 0;
  laTree_      = 0;
  hltTree_     = 0;
  l1Tree_      = 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_);
  tws.AddBranch(hltBitsName_.c_str(),"mithep::BitMask256",&hltBits_);
  tws.AddBranch(hltObjsName_.c_str(),&hltObjs_);
  tws.AddBranch(Form("%sRelation",hltObjsName_.c_str()),&hltRels_);
  tws.GetTree()->BranchRef();

  // 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);

  // add branches to L1 trigger info tree


  // add branches to HLT trigger info tree
  tws.AddBranchToTree(Names::gkHltTreeName,hltTableName_.c_str(),&hltTable_,32000,0);
  tws.SetAutoFill(Names::gkHltTreeName,0);
  tws.AddBranchToTree(Names::gkHltTreeName,hltLabelName_.c_str(),&hltLabels_,32000,0);
  tws.SetAutoFill(Names::gkHltTreeName,0);
  hltTree_=tws.GetTree(Names::gkHltTreeName);

  // 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;
    l1Entries_  = -1;
    hltEntries_ = -1;
  }

  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);
    FillHltTrig(event,setup);
    return;
  }

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

  Int_t l1entry = l1Entries_;
//FillL1Info(event,setup);
//FillL1Trigger(event,setup);
  runInfo_->SetL1Entry(l1entry);
//    if (l1entry < l1Entries_)
//      l1Tree_->Fill();

  Int_t hltentry = hltEntries_;
  FillHltInfo(event,setup);
  FillHltTrig(event,setup);
  runInfo_->SetHltEntry(hltentry);
  if (hltentry < hltEntries_)
    hltTree_->Fill();

  runTree_->Fill();
}

//--------------------------------------------------------------------------------------------------
void FillerMetaInfos::FillHltInfo(const edm::Event &event, 
                                  const edm::EventSetup &setup)
{
  // Fill HLT trigger table if it changed.

  if (!hltActive_) return;

  if (!hltConfig_.init(hltProcName_)) {
    // todo
    return;
  }

  // todo check size of menu... < 256
  if (hltConfig_.size()>hltBits_->Size()) {
    // todo
    return;
  }

  Vector<string>   *trigtable = new Vector<string>;
  map<string,Short_t> *tabmap = new map<string,Short_t>; 
  Vector<string>      *labels = new Vector<string>;
  map<string,Short_t> *labmap = new map<string,Short_t>; 

  for(UInt_t i=0;i<hltConfig_.size();++i) {

    tabmap->insert(pair<string,Short_t>(hltConfig_.triggerName(i),i));
    trigtable->AddCopy(hltConfig_.triggerName(i));
    
    const vector<string> &mLabels(hltConfig_.moduleLabels(i));
    for (UInt_t j=0; j<mLabels.size(); ++j) {
      const string& label(mLabels[j]);
      const string  type(hltConfig_.moduleType(label));

      map<string,Short_t>::iterator riter = labmap->find(label);
      if (riter == labmap->end()) {
        labmap->insert(pair<string,Short_t>(label,labels->Entries()));
        labels->AddCopy(label);
      }
      riter = labmap->find(type);
      if (riter == labmap->end()) {
        labmap->insert(pair<string,Short_t>(type,labels->Entries()));
        labels->AddCopy(type);
      }
    }
  }

  if (hltTable_->Entries()>=0) {
    // check if table is still the same: todo this has to be improved
    if ((hltTable_->Entries()==trigtable->Entries()) && 
        (hltLabels_->Entries()==labels->Entries())) {
      delete trigtable;
      delete labels;
      delete labmap;
      return;
    }
  }

  delete hltTable_;
  delete hltLabels_;
  delete hltTabMap_;
  delete hltLabMap_;
  hltTable_  = trigtable;
  hltLabels_ = labels;
  hltTabMap_ = tabmap;
  hltLabMap_ = labmap;
  hltEntries_++;
}
 
//--------------------------------------------------------------------------------------------------
void FillerMetaInfos::FillHltTrig(const edm::Event &event, 
                                  const edm::EventSetup &setup)
{
  // Fill HLT trigger objects along triggered paths.

  if (!hltActive_) return;

  // reset trigger objects
  hltObjs_->Reset();
  hltRels_->Reset();

  // get HLT trigger information
  Handle<TriggerResults> triggerResultsHLT;
  GetProduct(hltResName_, triggerResultsHLT, event);

  // get HLT trigger object information
  Handle<trigger::TriggerEvent> triggerEventHLT;
  GetProduct(hltEvtName_, triggerEventHLT, event);

  if (verify_)
    assert(triggerResultsHLT->size()==hltConfig_.size());

  // reset bitmask
  hltBits_->Clear();

  //map between EDM and OAK trigger object indices
  std::map<Int_t,Int_t> objmap;       

  // loop over trigger paths
  const UInt_t N = hltConfig_.size();
  for(UInt_t i=0;i<N;++i) {

    const string &name(hltConfig_.triggerName(i));
    const UInt_t tind(hltConfig_.triggerIndex(name.c_str()));
    if (verify_)
      assert(tind==i);
 
    if (verbose_>0)
      cout << "Trigger: path " << name << " [" << i << "]" << endl;

    if (!triggerResultsHLT->accept(tind)) 
      continue;

    // get our trigger bit
    map<string,Short_t>::iterator riter = hltTabMap_->find(name);
    if (riter == hltTabMap_->end()) {
      PrintErrorAndExit(Form("Trigger %s not found\n", name.c_str()));
    }

    UInt_t mytind = riter->second;
    if (verify_) {
      if (mytind!=tind)
        PrintErrorAndExit(Form("Trigger for %s index does not match: %ud %ud\n", 
                               name.c_str(), mytind, tind));
    }

    // set trigger bit
    hltBits_->SetBit(mytind);

    // modules on this trigger path
    const UInt_t M(hltConfig_.size(tind));
    const UInt_t mind(triggerResultsHLT->index(tind));
    assert (mind<M);

    const vector<string> &mLabels(hltConfig_.moduleLabels(tind));
   
    if (verbose_>1) 
      cout << " Last active module - label/type: "
           << mLabels[mind] << "/" << hltConfig_.moduleType(mLabels[mind])
           << " [" << mind << " out of 0-" << (M-1) << " on this path]" << endl;

    // loop over modules on path
    for (UInt_t j=0; j<=mind; ++j) {
      const string &mLabel(mLabels[j]);

      // check whether the module is packed up in TriggerEvent product
      const UInt_t find(triggerEventHLT->filterIndex(InputTag(mLabel,"",hltProcName_)));
      if (find>=triggerEventHLT->sizeFilters()) 
        continue;

      const string mType(hltConfig_.moduleType(mLabel));
      if (verbose_>1)
        cout << " 'L3' filter in slot " << j << " - label/type " 
             << mLabel << "/" << mType << endl;

      // find index for module label/type name
      Short_t modind = -1;
      map<string,Short_t>::iterator riter = hltLabMap_->find(mLabel);
      if (riter != hltLabMap_->end()) {
        modind = riter->second;
      }
      assert(modind!=-1);

      Short_t filind = -1;
      riter = hltLabMap_->find(mType);
      if (riter != hltLabMap_->end()) {
        filind = riter->second;
      }
      assert(filind!=-1);

      // find trigger objects
      const trigger::Vids &vids(triggerEventHLT->filterIds(find));
      const trigger::Keys &keys(triggerEventHLT->filterKeys(find));
      const trigger::size_type nVids(vids.size());
      const trigger::size_type nKeys(keys.size());
      assert(nVids==nKeys);

      if (verbose_>2)
        cout << "   " << nVids  << " accepted 'L3' objects found: " << endl;

      // loop over trigger objects
      const trigger::TriggerObjectCollection &toc(triggerEventHLT->getObjects());
      for (trigger::size_type k=0; k<nVids; ++k) {
        Int_t tocind = keys[k];

        // get trigger object
        const trigger::TriggerObject &tobj(toc[tocind]);
        if (verbose_>2) 
          cout << "   " << k << " " << vids[k] << "/" << keys[k] << ": "
               << tobj.id() << " " << tobj.pt() << " " << tobj.eta() 
               << " " << tobj.phi() << " " << tobj.mass() << endl;

        // look-up if entry is in map
        Int_t objind = -1;
        map<Int_t,Int_t>::iterator riter = objmap.find(tocind);
        if (riter == objmap.end()) { // add new trigger object
          objind = hltObjs_->Entries();
          objmap.insert(pair<Int_t,Int_t>(tocind,objind));
          TriggerObjectBase *trigObj = hltObjs_->Allocate();
          new (trigObj) TriggerObjectBase(tobj.id(),tobj.pt(),tobj.eta(),tobj.phi(),tobj.mass());
        } else { // use existing trigger object
          objind = riter->second;
        }

        TriggerObjectRel *trigRel = hltRels_->Allocate();
        new (trigRel) TriggerObjectRel(mytind,vids[k],objind,modind,filind);
      }
    }
  }
  hltObjs_->Trim();
  hltRels_->Trim();
}
Revision:	1.18
Committed:	Mon Oct 6 16:35:38 2008 UTC (16 years, 7 months ago) by loizides
Content type:	text/plain
Branch:	MAIN
Changes since 1.17:	+3 -2 lines
Log Message:	Call BranchRef on Events tree.
#	User	Rev	Content
1	loizides	1.18	// $Id: FillerMetaInfos.cc,v 1.17 2008/09/27 05:51:25 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.16	#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 <TIterator.h>
16	sixie	1.13
17	loizides	1.1	using namespace std;
18			using namespace edm;
19			using namespace mithep;
20
21	loizides	1.12	bool mithep::FillerMetaInfos::instance_ = 0;
22
23	loizides	1.8	//--------------------------------------------------------------------------------------------------
24	loizides	1.7	FillerMetaInfos::FillerMetaInfos(const ParameterSet &cfg, bool active) :
25	loizides	1.12	BaseFiller(cfg,"MetaInfos",(instance_==0\|\|active?1:0)),
26	loizides	1.2	evtName_(Conf().getUntrackedParameter<string>("evtName",Names::gkEvtHeaderBrn)),
27			runName_(Conf().getUntrackedParameter<string>("runName",Names::gkRunInfoBrn)),
28	loizides	1.4	lahName_(Conf().getUntrackedParameter<string>("lahName",Names::gkLAHeaderBrn)),
29	loizides	1.16	l1Active_(Conf().getUntrackedParameter<bool>("l1Active",true)),
30			l1TableName_(Conf().getUntrackedParameter<string>("l1TableName",Names::gkL1TableBrn)),
31			l1BitsName_(Conf().getUntrackedParameter<string>("l1BitsName",Names::gkL1BitBrn)),
32			l1ObjsName_(Conf().getUntrackedParameter<string>("l1ObjsName",Names::gkL1ObjBrn)),
33			hltActive_(Conf().getUntrackedParameter<bool>("hltActive",true)),
34			hltProcName_(Conf().getUntrackedParameter<string>("hltProcName","HLT")),
35			hltResName_(Conf().getUntrackedParameter<string>("hltResName","TriggerResults::HLT")),
36			hltEvtName_(Conf().getUntrackedParameter<string>("hltEvtName","hltTriggerSummaryAOD::HLT")),
37			hltTableName_(Conf().getUntrackedParameter<string>("hltTableName",Names::gkHltTableBrn)),
38			hltLabelName_(Conf().getUntrackedParameter<string>("hltLabelName",Names::gkHltLabelBrn)),
39			hltBitsName_(Conf().getUntrackedParameter<string>("hltBitsName",Names::gkHltBitBrn)),
40			hltObjsName_(Conf().getUntrackedParameter<string>("hltObjsName",Names::gkHltObjBrn)),
41	loizides	1.5	tws_(0),
42	loizides	1.2	eventHeader_(new EventHeader()),
43	loizides	1.3	evtLAHeader_(new LAHeader()),
44	loizides	1.2	runInfo_(new RunInfo()),
45			runTree_(0),
46	loizides	1.3	laTree_(0),
47			runEntries_(0),
48	loizides	1.16	l1Entries_(0),
49			l1Table_(0),
50			l1Tree_(0),
51			hltBits_(new BitMask256),
52			hltTable_(new Vector<string>),
53			hltTabMap_(0),
54			hltLabels_(new Vector<string>),
55			hltLabMap_(0),
56			hltObjs_(new TriggerObjectBaseArr),
57			hltRels_(new TriggerObjectRelArr),
58			hltTree_(0),
59			hltEntries_(0),
60	loizides	1.3	fileNum_(0)
61	loizides	1.1	{
62	loizides	1.3	// Constructor.
63	loizides	1.12
64			instance_=1;
65	loizides	1.1	}
66
67	loizides	1.8	//--------------------------------------------------------------------------------------------------
68	loizides	1.1	FillerMetaInfos::~FillerMetaInfos()
69			{
70	loizides	1.3	// Destructor.
71
72	loizides	1.2	delete eventHeader_;
73	loizides	1.8	delete evtLAHeader_;
74	loizides	1.2	delete runInfo_;
75	loizides	1.16	delete l1Table_;
76			delete hltTable_;
77			delete hltLabels_;
78			delete hltObjs_;
79			delete hltRels_;
80	loizides	1.3	eventHeader_ = 0;
81	loizides	1.8	evtLAHeader_ = 0;
82	loizides	1.3	runInfo_ = 0;
83	loizides	1.16	l1Table_ = 0;
84			hltTable_ = 0;
85			hltLabels_ = 0;
86			hltObjs_ = 0;
87			hltRels_ = 0;
88	loizides	1.3	runTree_ = 0;
89			laTree_ = 0;
90	loizides	1.16	hltTree_ = 0;
91			l1Tree_ = 0;
92	loizides	1.1	}
93
94	loizides	1.8	//--------------------------------------------------------------------------------------------------
95	loizides	1.2	void FillerMetaInfos::BookDataBlock(TreeWriter &tws)
96	loizides	1.1	{
97	loizides	1.3	// Create run info tre and book our branches.
98
99			// add branches to main tree
100	loizides	1.2	tws.AddBranch(evtName_.c_str(),"mithep::EventHeader",&eventHeader_);
101	loizides	1.16	tws.AddBranch(hltBitsName_.c_str(),"mithep::BitMask256",&hltBits_);
102			tws.AddBranch(hltObjsName_.c_str(),&hltObjs_);
103			tws.AddBranch(Form("%sRelation",hltObjsName_.c_str()),&hltRels_);
104	loizides	1.18	tws.GetTree()->BranchRef();
105	loizides	1.3
106			// add branches to run info tree
107			tws.AddBranchToTree(Names::gkRunTreeName,runName_.c_str(),"mithep::RunInfo",&runInfo_);
108	loizides	1.2	tws.SetAutoFill(Names::gkRunTreeName,0);
109			runTree_=tws.GetTree(Names::gkRunTreeName);
110	loizides	1.3
111			// add branches to lookahead tree
112			tws.AddBranchToTree(Names::gkLATreeName,Names::gkLAHeaderBrn,"mithep::LAHeader",&evtLAHeader_);
113			tws.SetAutoFill(Names::gkLATreeName,0);
114			laTree_=tws.GetTree(Names::gkLATreeName);
115
116	loizides	1.16	// add branches to L1 trigger info tree
117
118
119			// add branches to HLT trigger info tree
120			tws.AddBranchToTree(Names::gkHltTreeName,hltTableName_.c_str(),&hltTable_,32000,0);
121			tws.SetAutoFill(Names::gkHltTreeName,0);
122			tws.AddBranchToTree(Names::gkHltTreeName,hltLabelName_.c_str(),&hltLabels_,32000,0);
123			tws.SetAutoFill(Names::gkHltTreeName,0);
124			hltTree_=tws.GetTree(Names::gkHltTreeName);
125
126	loizides	1.3	// store pointer to tree writer
127			tws_ = &tws;
128	loizides	1.1	}
129
130	loizides	1.8	//--------------------------------------------------------------------------------------------------
131	loizides	1.5	void FillerMetaInfos::FillDataBlock(const edm::Event &event,
132	loizides	1.1	const edm::EventSetup &setup)
133			{
134	loizides	1.3	// Fill our data structures.
135
136			// clear map if a new file was opened
137			if (tws_->GetFileNumber()!=fileNum_) {
138			runmap_.clear();
139			fileNum_ = tws_->GetFileNumber();
140			runEntries_ = 0;
141	loizides	1.16	l1Entries_ = -1;
142			hltEntries_ = -1;
143	loizides	1.3	}
144
145			UInt_t runnum = event.id().run();
146
147			// store look ahead information
148			if (runEntries_>0) {
149			evtLAHeader_->SetRunNum(runnum);
150			laTree_->Fill();
151	loizides	1.14	if(0) {
152			if(laTree_->GetEntries() % 100==0)
153			gObjectTable->Print();
154			}
155	loizides	1.3	}
156
157	loizides	1.2	// fill event header
158			eventHeader_->SetEvtNum(event.id().event());
159			eventHeader_->SetLumiSec(event.luminosityBlock());
160			eventHeader_->SetRunNum(runnum);
161
162	loizides	1.3	// look-up if entry is in map
163	loizides	1.2	map<UInt_t,Int_t>::iterator riter = runmap_.find(runnum);
164			if (riter != runmap_.end()) {
165			Int_t runentry = riter->second;
166			eventHeader_->SetRunEntry(runentry);
167	loizides	1.16	FillHltTrig(event,setup);
168	loizides	1.2	return;
169			}
170	loizides	1.1
171	loizides	1.2	// fill new run info
172			Int_t runentry = runEntries_;
173	loizides	1.16	++runEntries_;
174	loizides	1.2	eventHeader_->SetRunEntry(runentry);
175			runmap_.insert(pair<UInt_t,Int_t>(runnum,runentry));
176	loizides	1.16	runInfo_->SetRunNum(runnum);
177
178			Int_t l1entry = l1Entries_;
179			//FillL1Info(event,setup);
180			//FillL1Trigger(event,setup);
181			runInfo_->SetL1Entry(l1entry);
182			// if (l1entry < l1Entries_)
183			// l1Tree_->Fill();
184	loizides	1.2
185	loizides	1.16	Int_t hltentry = hltEntries_;
186	loizides	1.14	FillHltInfo(event,setup);
187	loizides	1.16	FillHltTrig(event,setup);
188			runInfo_->SetHltEntry(hltentry);
189			if (hltentry < hltEntries_)
190			hltTree_->Fill();
191	loizides	1.14
192	loizides	1.2	runTree_->Fill();
193	loizides	1.1	}
194	loizides	1.5
195	loizides	1.8	//--------------------------------------------------------------------------------------------------
196	loizides	1.5	void FillerMetaInfos::FillHltInfo(const edm::Event &event,
197			const edm::EventSetup &setup)
198			{
199	loizides	1.16	// Fill HLT trigger table if it changed.
200	loizides	1.5
201	loizides	1.14	if (!hltActive_) return;
202
203	loizides	1.16	if (!hltConfig_.init(hltProcName_)) {
204			// todo
205	loizides	1.14	return;
206	loizides	1.16	}
207	loizides	1.14
208	loizides	1.16	// todo check size of menu... < 256
209			if (hltConfig_.size()>hltBits_->Size()) {
210			// todo
211			return;
212			}
213	loizides	1.14
214	loizides	1.16	Vector<string> *trigtable = new Vector<string>;
215			map<string,Short_t> *tabmap = new map<string,Short_t>;
216			Vector<string> *labels = new Vector<string>;
217			map<string,Short_t> *labmap = new map<string,Short_t>;
218
219			for(UInt_t i=0;i<hltConfig_.size();++i) {
220
221			tabmap->insert(pair<string,Short_t>(hltConfig_.triggerName(i),i));
222			trigtable->AddCopy(hltConfig_.triggerName(i));
223
224			const vector<string> &mLabels(hltConfig_.moduleLabels(i));
225			for (UInt_t j=0; j<mLabels.size(); ++j) {
226			const string& label(mLabels[j]);
227			const string type(hltConfig_.moduleType(label));
228
229			map<string,Short_t>::iterator riter = labmap->find(label);
230			if (riter == labmap->end()) {
231			labmap->insert(pair<string,Short_t>(label,labels->Entries()));
232			labels->AddCopy(label);
233			}
234			riter = labmap->find(type);
235			if (riter == labmap->end()) {
236			labmap->insert(pair<string,Short_t>(type,labels->Entries()));
237			labels->AddCopy(type);
238	loizides	1.14	}
239			}
240			}
241
242	loizides	1.16	if (hltTable_->Entries()>=0) {
243			// check if table is still the same: todo this has to be improved
244			if ((hltTable_->Entries()==trigtable->Entries()) &&
245			(hltLabels_->Entries()==labels->Entries())) {
246			delete trigtable;
247			delete labels;
248			delete labmap;
249			return;
250			}
251	loizides	1.18	}
252	loizides	1.16
253			delete hltTable_;
254			delete hltLabels_;
255			delete hltTabMap_;
256			delete hltLabMap_;
257			hltTable_ = trigtable;
258			hltLabels_ = labels;
259			hltTabMap_ = tabmap;
260			hltLabMap_ = labmap;
261			hltEntries_++;
262			}
263
264			//--------------------------------------------------------------------------------------------------
265			void FillerMetaInfos::FillHltTrig(const edm::Event &event,
266			const edm::EventSetup &setup)
267			{
268			// Fill HLT trigger objects along triggered paths.
269
270			if (!hltActive_) return;
271
272			// reset trigger objects
273			hltObjs_->Reset();
274			hltRels_->Reset();
275	loizides	1.14
276	loizides	1.16	// get HLT trigger information
277	loizides	1.14	Handle<TriggerResults> triggerResultsHLT;
278	loizides	1.16	GetProduct(hltResName_, triggerResultsHLT, event);
279	loizides	1.5
280	loizides	1.16	// get HLT trigger object information
281			Handle<trigger::TriggerEvent> triggerEventHLT;
282			GetProduct(hltEvtName_, triggerEventHLT, event);
283
284			if (verify_)
285			assert(triggerResultsHLT->size()==hltConfig_.size());
286
287			// reset bitmask
288			hltBits_->Clear();
289
290			//map between EDM and OAK trigger object indices
291			std::map<Int_t,Int_t> objmap;
292
293			// loop over trigger paths
294			const UInt_t N = hltConfig_.size();
295			for(UInt_t i=0;i<N;++i) {
296
297			const string &name(hltConfig_.triggerName(i));
298			const UInt_t tind(hltConfig_.triggerIndex(name.c_str()));
299			if (verify_)
300			assert(tind==i);
301
302			if (verbose_>0)
303			cout << "Trigger: path " << name << " [" << i << "]" << endl;
304
305			if (!triggerResultsHLT->accept(tind))
306			continue;
307
308			// get our trigger bit
309			map<string,Short_t>::iterator riter = hltTabMap_->find(name);
310			if (riter == hltTabMap_->end()) {
311			PrintErrorAndExit(Form("Trigger %s not found\n", name.c_str()));
312			}
313
314			UInt_t mytind = riter->second;
315			if (verify_) {
316			if (mytind!=tind)
317			PrintErrorAndExit(Form("Trigger for %s index does not match: %ud %ud\n",
318			name.c_str(), mytind, tind));
319			}
320
321			// set trigger bit
322			hltBits_->SetBit(mytind);
323	sixie	1.13
324	loizides	1.16	// modules on this trigger path
325			const UInt_t M(hltConfig_.size(tind));
326			const UInt_t mind(triggerResultsHLT->index(tind));
327			assert (mind<M);
328
329			const vector<string> &mLabels(hltConfig_.moduleLabels(tind));
330
331			if (verbose_>1)
332			cout << " Last active module - label/type: "
333			<< mLabels[mind] << "/" << hltConfig_.moduleType(mLabels[mind])
334			<< " [" << mind << " out of 0-" << (M-1) << " on this path]" << endl;
335
336			// loop over modules on path
337			for (UInt_t j=0; j<=mind; ++j) {
338			const string &mLabel(mLabels[j]);
339
340			// check whether the module is packed up in TriggerEvent product
341			const UInt_t find(triggerEventHLT->filterIndex(InputTag(mLabel,"",hltProcName_)));
342			if (find>=triggerEventHLT->sizeFilters())
343			continue;
344
345			const string mType(hltConfig_.moduleType(mLabel));
346			if (verbose_>1)
347			cout << " 'L3' filter in slot " << j << " - label/type "
348			<< mLabel << "/" << mType << endl;
349
350			// find index for module label/type name
351			Short_t modind = -1;
352			map<string,Short_t>::iterator riter = hltLabMap_->find(mLabel);
353			if (riter != hltLabMap_->end()) {
354			modind = riter->second;
355			}
356	loizides	1.17	assert(modind!=-1);
357
358			Short_t filind = -1;
359	loizides	1.16	riter = hltLabMap_->find(mType);
360			if (riter != hltLabMap_->end()) {
361	loizides	1.17	filind = riter->second;
362	loizides	1.16	}
363	loizides	1.17	assert(filind!=-1);
364	loizides	1.14
365	loizides	1.16	// find trigger objects
366			const trigger::Vids &vids(triggerEventHLT->filterIds(find));
367			const trigger::Keys &keys(triggerEventHLT->filterKeys(find));
368			const trigger::size_type nVids(vids.size());
369			const trigger::size_type nKeys(keys.size());
370			assert(nVids==nKeys);
371
372			if (verbose_>2)
373			cout << " " << nVids << " accepted 'L3' objects found: " << endl;
374
375			// loop over trigger objects
376			const trigger::TriggerObjectCollection &toc(triggerEventHLT->getObjects());
377			for (trigger::size_type k=0; k<nVids; ++k) {
378			Int_t tocind = keys[k];
379
380			// get trigger object
381			const trigger::TriggerObject &tobj(toc[tocind]);
382			if (verbose_>2)
383			cout << " " << k << " " << vids[k] << "/" << keys[k] << ": "
384			<< tobj.id() << " " << tobj.pt() << " " << tobj.eta()
385			<< " " << tobj.phi() << " " << tobj.mass() << endl;
386
387			// look-up if entry is in map
388			Int_t objind = -1;
389			map<Int_t,Int_t>::iterator riter = objmap.find(tocind);
390			if (riter == objmap.end()) { // add new trigger object
391			objind = hltObjs_->Entries();
392			objmap.insert(pair<Int_t,Int_t>(tocind,objind));
393			TriggerObjectBase *trigObj = hltObjs_->Allocate();
394	loizides	1.17	new (trigObj) TriggerObjectBase(tobj.id(),tobj.pt(),tobj.eta(),tobj.phi(),tobj.mass());
395	loizides	1.16	} else { // use existing trigger object
396			objind = riter->second;
397			}
398	loizides	1.14
399	loizides	1.16	TriggerObjectRel *trigRel = hltRels_->Allocate();
400	loizides	1.17	new (trigRel) TriggerObjectRel(mytind,vids[k],objind,modind,filind);
401	loizides	1.16	}
402			}
403			}
404			hltObjs_->Trim();
405			hltRels_->Trim();
406	loizides	1.5	}