TreeFiller/src/FillerMetaInfos.cc

// $Id: FillerMetaInfos.cc,v 1.29 2009/03/18 14:57:58 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/TriggerMask.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, const char *name, bool active) : 
  BaseFiller(cfg,name,(instance_==0||active?1:0)),
  evtName_(Conf().getUntrackedParameter<string>("evtMitName",Names::gkEvtHeaderBrn)),
  runName_(Conf().getUntrackedParameter<string>("runMitName",Names::gkRunInfoBrn)),
  lahName_(Conf().getUntrackedParameter<string>("lahMitName",Names::gkLAHeaderBrn)),
  l1Active_(Conf().getUntrackedParameter<bool>("l1Active",true)),
  l1TableName_(Conf().getUntrackedParameter<string>("l1MitTableName",Names::gkL1TableBrn)),
  l1BitsName_(Conf().getUntrackedParameter<string>("l1MitBitsName",Names::gkL1BitBrn)),
  l1ObjsName_(Conf().getUntrackedParameter<string>("l1MitObjsName",Names::gkL1ObjBrn)),
  hltActive_(Conf().getUntrackedParameter<bool>("hltActive",true)),
  hltProcName_(Conf().getUntrackedParameter<string>("hltProcName","HLT")),
  hltResName_(Conf().getUntrackedParameter<string>("hltResEdmName","TriggerResults::HLT")),
  hltEvtName_(Conf().getUntrackedParameter<string>("hltEvtEdmName","hltTriggerSummaryAOD::HLT")),
  hltTableName_(Conf().getUntrackedParameter<string>("hltTableMitName",Names::gkHltTableBrn)),
  hltLabelName_(Conf().getUntrackedParameter<string>("hltLabelMitName",Names::gkHltLabelBrn)),
  hltBitsName_(Conf().getUntrackedParameter<string>("hltBitsMitName",Names::gkHltBitBrn)),
  hltObjsName_(Conf().getUntrackedParameter<string>("hltObjsMitName",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 TriggerMask),
  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 tree and book our branches.

  // add branches to main tree
  tws.AddBranch(evtName_,&eventHeader_);
  OS()->add<mithep::EventHeader>(eventHeader_,evtName_);
  tws.AddBranch(hltBitsName_,&hltBits_);
  tws.AddBranch(hltObjsName_,&hltObjs_);
  tws.AddBranch(Form("%sRelation",hltObjsName_.c_str()),&hltRels_);
  tws.GetTree()->BranchRef();

  // add branches to run info tree
  tws.AddBranchToTree(Names::gkRunTreeName,runName_,
                      TClass::GetClass(typeid(*runInfo_))->GetName(),&runInfo_);
  tws.SetAutoFill(Names::gkRunTreeName,0);
  runTree_=tws.GetTree(Names::gkRunTreeName);

  // add branches to lookahead tree
  tws.AddBranchToTree(Names::gkLATreeName,Names::gkLAHeaderBrn,
                      TClass::GetClass(typeid(*evtLAHeader_))->GetName(),&runInfo_);
  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_,
                      TClass::GetClass(typeid(*hltTable_))->GetName(),&hltTable_,32*1024,0);
  tws.AddBranchToTree(Names::gkHltTreeName,hltLabelName_,
                      TClass::GetClass(typeid(*hltLabels_))->GetName(),&hltLabels_,32*1024,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) { // check for memory leak in usage of ROOT objects
      if(laTree_->GetEntries() % 100==0)
        gObjectTable->Print();
    }
  }

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

  // 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);
  if (l1entry < l1Entries_) {
    l1Tree_->Fill();
    runInfo_->SetL1Entry(l1entry);
  } else {
    runInfo_->SetL1Entry(l1entry-1);
  }

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

  runTree_->Fill();
}

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

  if (!hltActive_) return;

  // check if we can access the hlt config information
  if (!hltConfig_.init(hltProcName_)) {
    edm::LogError("FillerMetaInfos") << "Can not access hlt config using " 
                                     << hltProcName_ << std::endl;
    return;
  }

  // check size of menu... < 256
  if (hltConfig_.size()>hltBits_->Size()) {
    edm::LogError("FillerMetaInfos") << "HLT config contains too many paths "
                                     << hltConfig_.size() << " > " 
                                     << hltBits_->Size() << std::endl;
    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>; 

  if (0) {
    if (!hltConfig_.tableName().empty())
      trigtable->push_back(hltConfig_.tableName());
    else
      trigtable->push_back("unknown_hlt_config");
  }

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

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

      const string& label(mLabels[j]);

      // remove characters which do not work: negation is included as !ModuleName
      // (this might require a change in the underlying CMSSW HLT fwk, so watch out).
      const char *lptr = &label[0];
      if (label[0] == '!') 
        ++lptr;

      map<string,Short_t>::iterator riter = labmap->find(lptr);
      if (riter == labmap->end()) {
        labmap->insert(pair<string,Short_t>(lptr,labels->size()));
        labels->push_back(lptr);
      }

      const string type(hltConfig_.moduleType(lptr));
      riter = labmap->find(type);
      if (riter == labmap->end()) {
        labmap->insert(pair<string,Short_t>(type,labels->size()));
        labels->push_back(type);
      }
    }
  }

  if (hltTable_->size()>=0) {
    // check if existing table contains all necessary paths: 
    // if so keep it, otherwise store the new one  

    if ((hltTable_->size()>=trigtable->size()) && 
        (hltLabels_->size()>=labels->size())) {

      bool newEntryFound = false;
      for (UInt_t i=0; i<trigtable->size(); ++i) {
        map<string,Short_t>::iterator riter = tabmap->find(trigtable->at(i));
        if (riter == tabmap->end()) {
          newEntryFound = true;
          break;
        }
      }
      if (!newEntryFound) {
        for (UInt_t i=0; i<labels->size(); ++i) {
          map<string,Short_t>::iterator riter = labmap->find(labels->at(i));
          if (riter == labmap->end()) {
            newEntryFound = true;
            break;
          }
        }
      }

      if (!newEntryFound) {
        if (verbose_>1) 
          cout << "FillHltInfo: Kept previous HLT information" << endl;

        delete trigtable;
        delete labels;
        delete labmap;
        delete tabmap;
        return;
      }
    }
  }

  // new hlt entry
  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());

  // new bitmask
  BitMask256 mask;

  //map between EDM and our 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
    mask.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);
      }
    }
  }
  
  hltBits_->SetBits(mask);
  hltObjs_->Trim();
  hltRels_->Trim();
}
Revision:	1.30
Committed:	Thu Mar 19 16:15:05 2009 UTC (16 years, 1 month ago) by loizides
Content type:	text/plain
Branch:	MAIN
Changes since 1.29:	+14 -20 lines
Log Message:	Use Mit/Edm names. Moved weight filler to FillerMCEventInfo.
#	User	Rev	Content
1	loizides	1.30	// $Id: FillerMetaInfos.cc,v 1.29 2009/03/18 14:57:58 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.25	#include "MitAna/DataTree/interface/TriggerMask.h"
13	loizides	1.16	#include "MitAna/DataTree/interface/TriggerName.h"
14	loizides	1.5	#include "MitAna/DataTree/interface/RunInfo.h"
15	loizides	1.8	#include <TObjectTable.h>
16	loizides	1.14	#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.26	FillerMetaInfos::FillerMetaInfos(const ParameterSet &cfg, const char *name, bool active) :
26			BaseFiller(cfg,name,(instance_==0\|\|active?1:0)),
27	loizides	1.30	evtName_(Conf().getUntrackedParameter<string>("evtMitName",Names::gkEvtHeaderBrn)),
28			runName_(Conf().getUntrackedParameter<string>("runMitName",Names::gkRunInfoBrn)),
29			lahName_(Conf().getUntrackedParameter<string>("lahMitName",Names::gkLAHeaderBrn)),
30	loizides	1.16	l1Active_(Conf().getUntrackedParameter<bool>("l1Active",true)),
31	loizides	1.30	l1TableName_(Conf().getUntrackedParameter<string>("l1MitTableName",Names::gkL1TableBrn)),
32			l1BitsName_(Conf().getUntrackedParameter<string>("l1MitBitsName",Names::gkL1BitBrn)),
33			l1ObjsName_(Conf().getUntrackedParameter<string>("l1MitObjsName",Names::gkL1ObjBrn)),
34	loizides	1.16	hltActive_(Conf().getUntrackedParameter<bool>("hltActive",true)),
35			hltProcName_(Conf().getUntrackedParameter<string>("hltProcName","HLT")),
36	loizides	1.30	hltResName_(Conf().getUntrackedParameter<string>("hltResEdmName","TriggerResults::HLT")),
37			hltEvtName_(Conf().getUntrackedParameter<string>("hltEvtEdmName","hltTriggerSummaryAOD::HLT")),
38			hltTableName_(Conf().getUntrackedParameter<string>("hltTableMitName",Names::gkHltTableBrn)),
39			hltLabelName_(Conf().getUntrackedParameter<string>("hltLabelMitName",Names::gkHltLabelBrn)),
40			hltBitsName_(Conf().getUntrackedParameter<string>("hltBitsMitName",Names::gkHltBitBrn)),
41			hltObjsName_(Conf().getUntrackedParameter<string>("hltObjsMitName",Names::gkHltObjBrn)),
42	loizides	1.5	tws_(0),
43	loizides	1.2	eventHeader_(new EventHeader()),
44	loizides	1.3	evtLAHeader_(new LAHeader()),
45	loizides	1.2	runInfo_(new RunInfo()),
46			runTree_(0),
47	loizides	1.3	laTree_(0),
48			runEntries_(0),
49	loizides	1.16	l1Entries_(0),
50			l1Table_(0),
51			l1Tree_(0),
52	loizides	1.25	hltBits_(new TriggerMask),
53	loizides	1.22	hltTable_(new vector<string>),
54	loizides	1.16	hltTabMap_(0),
55	loizides	1.22	hltLabels_(new vector<string>),
56	loizides	1.16	hltLabMap_(0),
57			hltObjs_(new TriggerObjectBaseArr),
58			hltRels_(new TriggerObjectRelArr),
59			hltTree_(0),
60			hltEntries_(0),
61	loizides	1.3	fileNum_(0)
62	loizides	1.1	{
63	loizides	1.3	// Constructor.
64	loizides	1.12
65			instance_=1;
66	loizides	1.1	}
67
68	loizides	1.8	//--------------------------------------------------------------------------------------------------
69	loizides	1.1	FillerMetaInfos::~FillerMetaInfos()
70			{
71	loizides	1.3	// Destructor.
72
73	loizides	1.2	delete eventHeader_;
74	loizides	1.8	delete evtLAHeader_;
75	loizides	1.2	delete runInfo_;
76	loizides	1.16	delete l1Table_;
77			delete hltTable_;
78			delete hltLabels_;
79			delete hltObjs_;
80			delete hltRels_;
81	loizides	1.3	eventHeader_ = 0;
82	loizides	1.8	evtLAHeader_ = 0;
83	loizides	1.3	runInfo_ = 0;
84	loizides	1.16	l1Table_ = 0;
85			hltTable_ = 0;
86			hltLabels_ = 0;
87			hltObjs_ = 0;
88			hltRels_ = 0;
89	loizides	1.3	runTree_ = 0;
90			laTree_ = 0;
91	loizides	1.16	hltTree_ = 0;
92			l1Tree_ = 0;
93	loizides	1.1	}
94
95	loizides	1.8	//--------------------------------------------------------------------------------------------------
96	loizides	1.2	void FillerMetaInfos::BookDataBlock(TreeWriter &tws)
97	loizides	1.1	{
98	loizides	1.30	// Create run info tree and book our branches.
99	loizides	1.3
100			// add branches to main tree
101	loizides	1.27	tws.AddBranch(evtName_,&eventHeader_);
102			OS()->add<mithep::EventHeader>(eventHeader_,evtName_);
103			tws.AddBranch(hltBitsName_,&hltBits_);
104			tws.AddBranch(hltObjsName_,&hltObjs_);
105	loizides	1.16	tws.AddBranch(Form("%sRelation",hltObjsName_.c_str()),&hltRels_);
106	loizides	1.20	tws.GetTree()->BranchRef();
107	loizides	1.3
108			// add branches to run info tree
109	loizides	1.27	tws.AddBranchToTree(Names::gkRunTreeName,runName_,
110	loizides	1.25	TClass::GetClass(typeid(*runInfo_))->GetName(),&runInfo_);
111	loizides	1.2	tws.SetAutoFill(Names::gkRunTreeName,0);
112			runTree_=tws.GetTree(Names::gkRunTreeName);
113	loizides	1.3
114			// add branches to lookahead tree
115	loizides	1.24	tws.AddBranchToTree(Names::gkLATreeName,Names::gkLAHeaderBrn,
116	loizides	1.25	TClass::GetClass(typeid(*evtLAHeader_))->GetName(),&runInfo_);
117	loizides	1.3	tws.SetAutoFill(Names::gkLATreeName,0);
118			laTree_=tws.GetTree(Names::gkLATreeName);
119
120	loizides	1.16	// add branches to L1 trigger info tree
121
122			// add branches to HLT trigger info tree
123	loizides	1.27	tws.AddBranchToTree(Names::gkHltTreeName,hltTableName_,
124	loizides	1.29	TClass::GetClass(typeid(hltTable_))->GetName(),&hltTable_,321024,0);
125	loizides	1.27	tws.AddBranchToTree(Names::gkHltTreeName,hltLabelName_,
126	loizides	1.29	TClass::GetClass(typeid(hltLabels_))->GetName(),&hltLabels_,321024,0);
127	loizides	1.16	tws.SetAutoFill(Names::gkHltTreeName,0);
128			hltTree_=tws.GetTree(Names::gkHltTreeName);
129
130	loizides	1.3	// store pointer to tree writer
131			tws_ = &tws;
132	loizides	1.1	}
133
134	loizides	1.8	//--------------------------------------------------------------------------------------------------
135	loizides	1.5	void FillerMetaInfos::FillDataBlock(const edm::Event &event,
136	loizides	1.1	const edm::EventSetup &setup)
137			{
138	loizides	1.3	// Fill our data structures.
139
140			// clear map if a new file was opened
141			if (tws_->GetFileNumber()!=fileNum_) {
142			runmap_.clear();
143			fileNum_ = tws_->GetFileNumber();
144			runEntries_ = 0;
145	loizides	1.16	l1Entries_ = -1;
146			hltEntries_ = -1;
147	loizides	1.3	}
148
149			UInt_t runnum = event.id().run();
150
151			// store look ahead information
152			if (runEntries_>0) {
153			evtLAHeader_->SetRunNum(runnum);
154			laTree_->Fill();
155	loizides	1.21	if(0) { // check for memory leak in usage of ROOT objects
156	loizides	1.14	if(laTree_->GetEntries() % 100==0)
157			gObjectTable->Print();
158			}
159	loizides	1.3	}
160
161	loizides	1.2	// fill event header
162			eventHeader_->SetEvtNum(event.id().event());
163			eventHeader_->SetLumiSec(event.luminosityBlock());
164			eventHeader_->SetRunNum(runnum);
165	loizides	1.27	eventHeader_->SetIsMC(!event.isRealData());
166	loizides	1.2
167	loizides	1.3	// look-up if entry is in map
168	loizides	1.2	map<UInt_t,Int_t>::iterator riter = runmap_.find(runnum);
169			if (riter != runmap_.end()) {
170			Int_t runentry = riter->second;
171			eventHeader_->SetRunEntry(runentry);
172	loizides	1.16	FillHltTrig(event,setup);
173	loizides	1.2	return;
174			}
175	loizides	1.1
176	loizides	1.2	// fill new run info
177			Int_t runentry = runEntries_;
178	loizides	1.16	++runEntries_;
179	loizides	1.2	eventHeader_->SetRunEntry(runentry);
180			runmap_.insert(pair<UInt_t,Int_t>(runnum,runentry));
181	loizides	1.16	runInfo_->SetRunNum(runnum);
182
183			Int_t l1entry = l1Entries_;
184			//FillL1Info(event,setup);
185			//FillL1Trigger(event,setup);
186	loizides	1.21	if (l1entry < l1Entries_) {
187			l1Tree_->Fill();
188			runInfo_->SetL1Entry(l1entry);
189			} else {
190			runInfo_->SetL1Entry(l1entry-1);
191			}
192	loizides	1.2
193	loizides	1.16	Int_t hltentry = hltEntries_;
194	loizides	1.14	FillHltInfo(event,setup);
195	loizides	1.16	FillHltTrig(event,setup);
196	loizides	1.21	if (hltentry < hltEntries_) {
197			runInfo_->SetHltEntry(hltentry);
198	loizides	1.16	hltTree_->Fill();
199	loizides	1.21	} else {
200			runInfo_->SetHltEntry(hltentry-1);
201			}
202	loizides	1.14
203	loizides	1.2	runTree_->Fill();
204	loizides	1.1	}
205	loizides	1.5
206	loizides	1.8	//--------------------------------------------------------------------------------------------------
207	loizides	1.5	void FillerMetaInfos::FillHltInfo(const edm::Event &event,
208			const edm::EventSetup &setup)
209			{
210	loizides	1.16	// Fill HLT trigger table if it changed.
211	loizides	1.5
212	loizides	1.14	if (!hltActive_) return;
213
214	loizides	1.21	// check if we can access the hlt config information
215	loizides	1.16	if (!hltConfig_.init(hltProcName_)) {
216	loizides	1.21	edm::LogError("FillerMetaInfos") << "Can not access hlt config using "
217			<< hltProcName_ << std::endl;
218	loizides	1.14	return;
219	loizides	1.16	}
220	loizides	1.14
221	loizides	1.21	// check size of menu... < 256
222	loizides	1.16	if (hltConfig_.size()>hltBits_->Size()) {
223	loizides	1.21	edm::LogError("FillerMetaInfos") << "HLT config contains too many paths "
224	loizides	1.25	<< hltConfig_.size() << " > "
225			<< hltBits_->Size() << std::endl;
226	loizides	1.16	return;
227			}
228	loizides	1.14
229	loizides	1.22	vector<string> *trigtable = new vector<string>;
230	loizides	1.16	map<string,Short_t> *tabmap = new map<string,Short_t>;
231	loizides	1.22	vector<string> *labels = new vector<string>;
232	loizides	1.16	map<string,Short_t> *labmap = new map<string,Short_t>;
233
234	loizides	1.28	if (0) {
235			if (!hltConfig_.tableName().empty())
236			trigtable->push_back(hltConfig_.tableName());
237			else
238			trigtable->push_back("unknown_hlt_config");
239			}
240
241	loizides	1.21	// loop over hlt paths
242	loizides	1.16	for(UInt_t i=0;i<hltConfig_.size();++i) {
243
244			tabmap->insert(pair<string,Short_t>(hltConfig_.triggerName(i),i));
245	loizides	1.22	trigtable->push_back(hltConfig_.triggerName(i));
246	loizides	1.16	const vector<string> &mLabels(hltConfig_.moduleLabels(i));
247			for (UInt_t j=0; j<mLabels.size(); ++j) {
248	loizides	1.19
249	loizides	1.16	const string& label(mLabels[j]);
250
251	loizides	1.19	// remove characters which do not work: negation is included as !ModuleName
252			// (this might require a change in the underlying CMSSW HLT fwk, so watch out).
253			const char *lptr = &label[0];
254			if (label[0] == '!')
255			++lptr;
256
257			map<string,Short_t>::iterator riter = labmap->find(lptr);
258	loizides	1.16	if (riter == labmap->end()) {
259	loizides	1.22	labmap->insert(pair<string,Short_t>(lptr,labels->size()));
260			labels->push_back(lptr);
261	loizides	1.16	}
262	loizides	1.19
263			const string type(hltConfig_.moduleType(lptr));
264	loizides	1.16	riter = labmap->find(type);
265			if (riter == labmap->end()) {
266	loizides	1.22	labmap->insert(pair<string,Short_t>(type,labels->size()));
267			labels->push_back(type);
268	loizides	1.14	}
269			}
270			}
271
272	loizides	1.22	if (hltTable_->size()>=0) {
273	loizides	1.21	// check if existing table contains all necessary paths:
274			// if so keep it, otherwise store the new one
275
276	loizides	1.22	if ((hltTable_->size()>=trigtable->size()) &&
277			(hltLabels_->size()>=labels->size())) {
278	loizides	1.21
279			bool newEntryFound = false;
280	loizides	1.22	for (UInt_t i=0; i<trigtable->size(); ++i) {
281			map<string,Short_t>::iterator riter = tabmap->find(trigtable->at(i));
282	loizides	1.21	if (riter == tabmap->end()) {
283			newEntryFound = true;
284			break;
285			}
286			}
287			if (!newEntryFound) {
288	loizides	1.22	for (UInt_t i=0; i<labels->size(); ++i) {
289			map<string,Short_t>::iterator riter = labmap->find(labels->at(i));
290	loizides	1.21	if (riter == labmap->end()) {
291			newEntryFound = true;
292			break;
293			}
294			}
295			}
296
297			if (!newEntryFound) {
298			if (verbose_>1)
299			cout << "FillHltInfo: Kept previous HLT information" << endl;
300
301			delete trigtable;
302			delete labels;
303			delete labmap;
304			delete tabmap;
305			return;
306			}
307	loizides	1.16	}
308	loizides	1.20	}
309	loizides	1.16
310	loizides	1.21	// new hlt entry
311	loizides	1.16	delete hltTable_;
312			delete hltLabels_;
313			delete hltTabMap_;
314			delete hltLabMap_;
315			hltTable_ = trigtable;
316			hltLabels_ = labels;
317			hltTabMap_ = tabmap;
318			hltLabMap_ = labmap;
319			hltEntries_++;
320			}
321
322			//--------------------------------------------------------------------------------------------------
323			void FillerMetaInfos::FillHltTrig(const edm::Event &event,
324			const edm::EventSetup &setup)
325			{
326			// Fill HLT trigger objects along triggered paths.
327
328			if (!hltActive_) return;
329
330			// reset trigger objects
331			hltObjs_->Reset();
332			hltRels_->Reset();
333	loizides	1.14
334	loizides	1.16	// get HLT trigger information
335	loizides	1.14	Handle<TriggerResults> triggerResultsHLT;
336	loizides	1.16	GetProduct(hltResName_, triggerResultsHLT, event);
337	loizides	1.5
338	loizides	1.16	// get HLT trigger object information
339			Handle<trigger::TriggerEvent> triggerEventHLT;
340			GetProduct(hltEvtName_, triggerEventHLT, event);
341
342			if (verify_)
343			assert(triggerResultsHLT->size()==hltConfig_.size());
344
345	loizides	1.25	// new bitmask
346			BitMask256 mask;
347	loizides	1.16
348	loizides	1.29	//map between EDM and our trigger object indices
349	loizides	1.16	std::map<Int_t,Int_t> objmap;
350
351			// loop over trigger paths
352			const UInt_t N = hltConfig_.size();
353			for(UInt_t i=0;i<N;++i) {
354
355			const string &name(hltConfig_.triggerName(i));
356			const UInt_t tind(hltConfig_.triggerIndex(name.c_str()));
357			if (verify_)
358			assert(tind==i);
359
360			if (verbose_>0)
361			cout << "Trigger: path " << name << " [" << i << "]" << endl;
362
363			if (!triggerResultsHLT->accept(tind))
364			continue;
365
366			// get our trigger bit
367			map<string,Short_t>::iterator riter = hltTabMap_->find(name);
368			if (riter == hltTabMap_->end()) {
369			PrintErrorAndExit(Form("Trigger %s not found\n", name.c_str()));
370			}
371
372			UInt_t mytind = riter->second;
373			if (verify_) {
374			if (mytind!=tind)
375			PrintErrorAndExit(Form("Trigger for %s index does not match: %ud %ud\n",
376			name.c_str(), mytind, tind));
377			}
378
379			// set trigger bit
380	loizides	1.25	mask.SetBit(mytind);
381	sixie	1.13
382	loizides	1.16	// modules on this trigger path
383			const UInt_t M(hltConfig_.size(tind));
384			const UInt_t mind(triggerResultsHLT->index(tind));
385			assert (mind<M);
386
387			const vector<string> &mLabels(hltConfig_.moduleLabels(tind));
388
389			if (verbose_>1)
390			cout << " Last active module - label/type: "
391			<< mLabels[mind] << "/" << hltConfig_.moduleType(mLabels[mind])
392			<< " [" << mind << " out of 0-" << (M-1) << " on this path]" << endl;
393
394			// loop over modules on path
395			for (UInt_t j=0; j<=mind; ++j) {
396			const string &mLabel(mLabels[j]);
397
398			// check whether the module is packed up in TriggerEvent product
399			const UInt_t find(triggerEventHLT->filterIndex(InputTag(mLabel,"",hltProcName_)));
400			if (find>=triggerEventHLT->sizeFilters())
401			continue;
402
403			const string mType(hltConfig_.moduleType(mLabel));
404			if (verbose_>1)
405			cout << " 'L3' filter in slot " << j << " - label/type "
406			<< mLabel << "/" << mType << endl;
407
408			// find index for module label/type name
409			Short_t modind = -1;
410			map<string,Short_t>::iterator riter = hltLabMap_->find(mLabel);
411			if (riter != hltLabMap_->end()) {
412			modind = riter->second;
413			}
414	loizides	1.17	assert(modind!=-1);
415
416			Short_t filind = -1;
417	loizides	1.16	riter = hltLabMap_->find(mType);
418			if (riter != hltLabMap_->end()) {
419	loizides	1.17	filind = riter->second;
420	loizides	1.16	}
421	loizides	1.17	assert(filind!=-1);
422	loizides	1.14
423	loizides	1.16	// find trigger objects
424			const trigger::Vids &vids(triggerEventHLT->filterIds(find));
425			const trigger::Keys &keys(triggerEventHLT->filterKeys(find));
426			const trigger::size_type nVids(vids.size());
427			const trigger::size_type nKeys(keys.size());
428			assert(nVids==nKeys);
429
430			if (verbose_>2)
431			cout << " " << nVids << " accepted 'L3' objects found: " << endl;
432
433			// loop over trigger objects
434			const trigger::TriggerObjectCollection &toc(triggerEventHLT->getObjects());
435			for (trigger::size_type k=0; k<nVids; ++k) {
436			Int_t tocind = keys[k];
437
438			// get trigger object
439			const trigger::TriggerObject &tobj(toc[tocind]);
440			if (verbose_>2)
441			cout << " " << k << " " << vids[k] << "/" << keys[k] << ": "
442			<< tobj.id() << " " << tobj.pt() << " " << tobj.eta()
443			<< " " << tobj.phi() << " " << tobj.mass() << endl;
444
445			// look-up if entry is in map
446			Int_t objind = -1;
447			map<Int_t,Int_t>::iterator riter = objmap.find(tocind);
448			if (riter == objmap.end()) { // add new trigger object
449			objind = hltObjs_->Entries();
450			objmap.insert(pair<Int_t,Int_t>(tocind,objind));
451			TriggerObjectBase *trigObj = hltObjs_->Allocate();
452	loizides	1.17	new (trigObj) TriggerObjectBase(tobj.id(),tobj.pt(),tobj.eta(),tobj.phi(),tobj.mass());
453	loizides	1.16	} else { // use existing trigger object
454			objind = riter->second;
455			}
456	loizides	1.14
457	loizides	1.16	TriggerObjectRel *trigRel = hltRels_->Allocate();
458	loizides	1.17	new (trigRel) TriggerObjectRel(mytind,vids[k],objind,modind,filind);
459	loizides	1.16	}
460			}
461			}
462	loizides	1.25
463			hltBits_->SetBits(mask);
464	loizides	1.16	hltObjs_->Trim();
465			hltRels_->Trim();
466	loizides	1.5	}