TreeFiller/src/FillerMetaInfos.cc

// $Id: FillerMetaInfos.cc,v 1.39 2009/07/13 06:39:40 loizides Exp $

#include "MitProd/TreeFiller/interface/FillerMetaInfos.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 "MitAna/DataTree/interface/TriggerObjectCol.h"
#include "MitProd/ObjectService/interface/ObjectService.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)),
  hltActive_(Conf().getUntrackedParameter<bool>("hltActive",true)),
  hltResName_(Conf().getUntrackedParameter<string>("hltResEdmName","TriggerResults")),
  hltEvtName_(Conf().getUntrackedParameter<string>("hltEvtEdmName","hltTriggerSummaryAOD")),
  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),
  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.

  assert(instance_ == 0);
  ++instance_;

  if (Conf().exists("hltProcNames"))
    hltProcNames_ = Conf().getUntrackedParameter<vector<string> >("hltProcNames");
  if (hltProcNames_.size()==0)
    hltProcNames_.push_back("HLT");
}

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

  delete eventHeader_;
  delete evtLAHeader_;
  delete runInfo_;
  delete hltBits_;
  delete hltTable_;
  delete hltLabels_;
  delete hltObjs_;
  delete hltRels_;
  eventHeader_ = 0;
  evtLAHeader_ = 0;
  runInfo_     = 0;
  hltTable_    = 0;
  hltLabels_   = 0;
  hltObjs_     = 0;
  hltRels_     = 0;
  runTree_     = 0;
  laTree_      = 0;
  hltTree_     = 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 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;
    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());
  eventHeader_->SetBunchCrossing(event.bunchCrossing());
  eventHeader_->SetExpType(event.experimentType());
  eventHeader_->SetOrbitNumber(event.orbitNumber());
  eventHeader_->SetStoreNumber(event.bunchCrossing());
  eventHeader_->SetTimeStamp(event.time().value());

  // 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 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 (hltProcName_.empty()) {
    string teststr;
    for(UInt_t i=0; i<hltProcNames_.size(); ++i) {
      if (i>0) 
        teststr += ", ";
      teststr += hltProcNames_.at(i);
      edm::LogInfo("FillerMetaInfos") << "Trying to access hlt config using " 
                                      <<  hltProcNames_.at(i) << std::endl;

      if (hltConfig_.init(hltProcNames_.at(i))) {
        hltProcName_ = hltProcNames_.at(i);
        if (hltResName_.find(':')==string::npos)
          hltResName_ += "::";
        else 
          hltResName_ += ":";
        hltResName_ += hltProcName_;
        if (hltEvtName_.find(':')==string::npos)
          hltEvtName_ += "::";
        else 
          hltEvtName_ += ":";
        hltEvtName_ += hltProcName_;
        break;
      } 
    }
    if (hltProcName_.empty()) {
      edm::LogError("FillerMetaInfos") << "Cannot access hlt config using " 
                                       << teststr << std::endl;
      throw edm::Exception(edm::errors::Configuration, "FillerMetaInfos::FillHltInfo()\n")
        << "Cannot access hlt config using " << teststr << std::endl;
      return;
    }
  } else {
    if (!hltConfig_.init(hltProcName_)) {
      edm::LogError("FillerMetaInfos") << "Cannot access hlt config using " 
                                       << hltProcName_ << std::endl;
      throw edm::Exception(edm::errors::Configuration, "FillerMetaInfos::FillHltInfo()\n")
        << "Cannot 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");
  }

  // get HLT trigger object information to be able to access the tag information
  Handle<trigger::TriggerEvent> triggerEventHLT;
  GetProduct(hltEvtName_, triggerEventHLT, event);
  const std::vector<std::string> &tags(triggerEventHLT->collectionTags());
  for(UInt_t i=0,c=0; i<tags.size(); ++i) {
    string tag(tags.at(i));
    if (tag.compare(0,19,"hltL1extraParticles")!=0)
      continue;
    if (tag == "hltL1extraParticles::HLT") {
      if (c==0)
        tag = "hltL1extraParticles:Muon:HLT";
      else if (c==1)
        tag = "hltL1extraParticles:HFRing:HLT";
      else
        tag = Form("hltL1extraParticles:Unknown%d:HLT", c);
      ++c;
    }
    map<string,Short_t>::iterator riter = labmap->find(tag);
    if (riter == labmap->end()) {
      labmap->insert(pair<string,Short_t>(tag,labels->size()));
      labels->push_back(tag);
    }
  }

  // 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 is equal to new table:
    //  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) {
        if (trigtable->at(i) != hltTable_->at(i)) {
          newEntryFound = true;
          break;
        }
      }
      if (!newEntryFound) {
        for (UInt_t i=0; i<labels->size(); ++i) {
        if (labels->at(i) != hltLabels_->at(i)) {
            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 maskhlt;

  // loop over trigger objects and fill them
  const trigger::TriggerObjectCollection &toc(triggerEventHLT->getObjects());
  const std::vector<std::string> &tags(triggerEventHLT->collectionTags());
  for(UInt_t i=0,iprev=0,c=0; i<tags.size(); ++i) {

    Short_t nind = -(i+1);
    string tag(tags.at(i));
    if (tag.compare(0,19,"hltL1extraParticles")==0) {
      if (tag == "hltL1extraParticles::HLT") {
        if (c==0)
          tag = "hltL1extraParticles:Muon:HLT";
        else if (c==1)
          tag = "hltL1extraParticles:HFRing:HLT";
        else
          tag = Form("hltL1extraParticles:Unknown%d:HLT", c-1);
        ++c;
      }
      map<string,Short_t>::iterator riter = hltLabMap_->find(tag);
      if (riter != hltLabMap_->end()) {
        nind = riter->second;
      }
    }

    UInt_t inext(triggerEventHLT->collectionKey(i));
    if (verbose_>2)
      cout << i << " " << tag << " with " << inext-iprev << " objects " << endl;
    for (UInt_t k=iprev; k<inext; ++k) {
      const trigger::TriggerObject &tobj = toc[k];
      TriggerObjectBase *trigObj = hltObjs_->Allocate();
      new (trigObj) TriggerObjectBase(tobj.id(),0,tobj.pt(),tobj.eta(),tobj.phi(),tobj.mass());
      trigObj->SetNameInd(nind);
      if (verbose_>4)
        cout << "   " << k << " " << tobj.id() << " " << tobj.pt() << " " << tobj.eta() 
             << " " << tobj.phi() << " " << tobj.mass() << endl;
    }
    iprev = inext;
  }

  // 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));
    if (verify_)
      assert(tind==i);
 
    if (verbose_>0)
      cout << "Trigger: path " << name << " [" << i << "]" << endl;

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

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

      string tType = "L1";
      if (mType != "HLTLevel1GTSeed") 
        tType = "L3";

      if (verbose_>1)
        cout << " '" << tType << "' 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 '" << tType << "' 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];

        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;

        TriggerObjectRel *trigRel = hltRels_->Allocate();
        new (trigRel) TriggerObjectRel(mytind,vids[k],tocind,modind,filind);
        TriggerObjectBase *trigObj = hltObjs_->At(tocind);
        if (trigObj->Type()==0) {
          trigObj->SetType(vids[k]);
        } else {
          if (trigObj->Type()!=vids[k]) {
            if (verbose_>3) 
              cout << "   -> Have already type " << trigObj->Type() 
                   << " ignored new type " << vids[k] << endl;
          }
        }
      }
    }

    if (triggerResultsHLT->accept(tind))
      maskhlt.SetBit(mytind);
  }
  
  hltBits_->SetBits(maskhlt);
  hltObjs_->Trim();
  hltRels_->Trim();
}
Revision:	1.40
Committed:	Mon Jul 13 08:50:42 2009 UTC (15 years, 9 months ago) by loizides
Content type:	text/plain
Branch:	MAIN
Changes since 1.39:	+48 -4 lines
Log Message:	Fill name index for L1 trig types.
#	User	Rev	Content
1	loizides	1.40	// $Id: FillerMetaInfos.cc,v 1.39 2009/07/13 06:39:40 loizides Exp $
2	loizides	1.1
3			#include "MitProd/TreeFiller/interface/FillerMetaInfos.h"
4	loizides	1.5	#include "FWCore/Framework/interface/TriggerNames.h"
5	loizides	1.1	#include "DataFormats/Common/interface/Handle.h"
6	loizides	1.5	#include "DataFormats/Common/interface/TriggerResults.h"
7	loizides	1.14	#include "DataFormats/HLTReco/interface/TriggerEvent.h"
8	loizides	1.1	#include "MitAna/DataTree/interface/Names.h"
9	loizides	1.5	#include "MitAna/DataTree/interface/EventHeader.h"
10			#include "MitAna/DataTree/interface/LAHeader.h"
11	loizides	1.25	#include "MitAna/DataTree/interface/TriggerMask.h"
12	loizides	1.16	#include "MitAna/DataTree/interface/TriggerName.h"
13	loizides	1.5	#include "MitAna/DataTree/interface/RunInfo.h"
14	loizides	1.34	#include "MitAna/DataTree/interface/TriggerObjectCol.h"
15			#include "MitProd/ObjectService/interface/ObjectService.h"
16	loizides	1.8	#include <TObjectTable.h>
17	loizides	1.14	#include <TIterator.h>
18	sixie	1.13
19	loizides	1.1	using namespace std;
20			using namespace edm;
21			using namespace mithep;
22
23	loizides	1.12	bool mithep::FillerMetaInfos::instance_ = 0;
24
25	loizides	1.8	//--------------------------------------------------------------------------------------------------
26	loizides	1.26	FillerMetaInfos::FillerMetaInfos(const ParameterSet &cfg, const char *name, bool active) :
27			BaseFiller(cfg,name,(instance_==0\|\|active?1:0)),
28	loizides	1.30	evtName_(Conf().getUntrackedParameter<string>("evtMitName",Names::gkEvtHeaderBrn)),
29			runName_(Conf().getUntrackedParameter<string>("runMitName",Names::gkRunInfoBrn)),
30			lahName_(Conf().getUntrackedParameter<string>("lahMitName",Names::gkLAHeaderBrn)),
31	loizides	1.16	hltActive_(Conf().getUntrackedParameter<bool>("hltActive",true)),
32	loizides	1.33	hltResName_(Conf().getUntrackedParameter<string>("hltResEdmName","TriggerResults")),
33			hltEvtName_(Conf().getUntrackedParameter<string>("hltEvtEdmName","hltTriggerSummaryAOD")),
34	loizides	1.30	hltTableName_(Conf().getUntrackedParameter<string>("hltTableMitName",Names::gkHltTableBrn)),
35			hltLabelName_(Conf().getUntrackedParameter<string>("hltLabelMitName",Names::gkHltLabelBrn)),
36			hltBitsName_(Conf().getUntrackedParameter<string>("hltBitsMitName",Names::gkHltBitBrn)),
37			hltObjsName_(Conf().getUntrackedParameter<string>("hltObjsMitName",Names::gkHltObjBrn)),
38	loizides	1.5	tws_(0),
39	loizides	1.2	eventHeader_(new EventHeader()),
40	loizides	1.3	evtLAHeader_(new LAHeader()),
41	loizides	1.2	runInfo_(new RunInfo()),
42			runTree_(0),
43	loizides	1.3	laTree_(0),
44			runEntries_(0),
45	loizides	1.25	hltBits_(new TriggerMask),
46	loizides	1.22	hltTable_(new vector<string>),
47	loizides	1.16	hltTabMap_(0),
48	loizides	1.22	hltLabels_(new vector<string>),
49	loizides	1.16	hltLabMap_(0),
50			hltObjs_(new TriggerObjectBaseArr),
51			hltRels_(new TriggerObjectRelArr),
52			hltTree_(0),
53			hltEntries_(0),
54	loizides	1.3	fileNum_(0)
55	loizides	1.1	{
56	loizides	1.3	// Constructor.
57	loizides	1.12
58	loizides	1.38	assert(instance_ == 0);
59			++instance_;
60	loizides	1.33
61			if (Conf().exists("hltProcNames"))
62			hltProcNames_ = Conf().getUntrackedParameter<vector<string> >("hltProcNames");
63			if (hltProcNames_.size()==0)
64			hltProcNames_.push_back("HLT");
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.37	delete hltBits_;
76	loizides	1.16	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	hltTable_ = 0;
84			hltLabels_ = 0;
85			hltObjs_ = 0;
86			hltRels_ = 0;
87	loizides	1.3	runTree_ = 0;
88			laTree_ = 0;
89	loizides	1.16	hltTree_ = 0;
90	loizides	1.1	}
91
92	loizides	1.8	//--------------------------------------------------------------------------------------------------
93	loizides	1.2	void FillerMetaInfos::BookDataBlock(TreeWriter &tws)
94	loizides	1.1	{
95	loizides	1.30	// Create run info tree and book our branches.
96	loizides	1.3
97			// add branches to main tree
98	loizides	1.27	tws.AddBranch(evtName_,&eventHeader_);
99			OS()->add<mithep::EventHeader>(eventHeader_,evtName_);
100			tws.AddBranch(hltBitsName_,&hltBits_);
101			tws.AddBranch(hltObjsName_,&hltObjs_);
102	loizides	1.16	tws.AddBranch(Form("%sRelation",hltObjsName_.c_str()),&hltRels_);
103	loizides	1.20	tws.GetTree()->BranchRef();
104	loizides	1.3
105			// add branches to run info tree
106	loizides	1.27	tws.AddBranchToTree(Names::gkRunTreeName,runName_,
107	loizides	1.25	TClass::GetClass(typeid(*runInfo_))->GetName(),&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	loizides	1.24	tws.AddBranchToTree(Names::gkLATreeName,Names::gkLAHeaderBrn,
113	loizides	1.25	TClass::GetClass(typeid(*evtLAHeader_))->GetName(),&runInfo_);
114	loizides	1.3	tws.SetAutoFill(Names::gkLATreeName,0);
115			laTree_=tws.GetTree(Names::gkLATreeName);
116
117	loizides	1.16	// add branches to HLT trigger info tree
118	loizides	1.27	tws.AddBranchToTree(Names::gkHltTreeName,hltTableName_,
119	loizides	1.29	TClass::GetClass(typeid(hltTable_))->GetName(),&hltTable_,321024,0);
120	loizides	1.27	tws.AddBranchToTree(Names::gkHltTreeName,hltLabelName_,
121	loizides	1.29	TClass::GetClass(typeid(hltLabels_))->GetName(),&hltLabels_,321024,0);
122	loizides	1.16	tws.SetAutoFill(Names::gkHltTreeName,0);
123			hltTree_=tws.GetTree(Names::gkHltTreeName);
124
125	loizides	1.3	// store pointer to tree writer
126			tws_ = &tws;
127	loizides	1.1	}
128
129	loizides	1.8	//--------------------------------------------------------------------------------------------------
130	loizides	1.36	void FillerMetaInfos::FillDataBlock(const edm::Event &event, const edm::EventSetup &setup)
131	loizides	1.1	{
132	loizides	1.3	// Fill our data structures.
133
134			// clear map if a new file was opened
135			if (tws_->GetFileNumber()!=fileNum_) {
136			runmap_.clear();
137			fileNum_ = tws_->GetFileNumber();
138			runEntries_ = 0;
139	loizides	1.16	hltEntries_ = -1;
140	loizides	1.3	}
141
142			UInt_t runnum = event.id().run();
143
144			// store look ahead information
145			if (runEntries_>0) {
146			evtLAHeader_->SetRunNum(runnum);
147			laTree_->Fill();
148	loizides	1.21	if(0) { // check for memory leak in usage of ROOT objects
149	loizides	1.14	if(laTree_->GetEntries() % 100==0)
150			gObjectTable->Print();
151			}
152	loizides	1.3	}
153
154	loizides	1.2	// fill event header
155			eventHeader_->SetEvtNum(event.id().event());
156			eventHeader_->SetLumiSec(event.luminosityBlock());
157			eventHeader_->SetRunNum(runnum);
158	loizides	1.27	eventHeader_->SetIsMC(!event.isRealData());
159	loizides	1.35	eventHeader_->SetBunchCrossing(event.bunchCrossing());
160			eventHeader_->SetExpType(event.experimentType());
161			eventHeader_->SetOrbitNumber(event.orbitNumber());
162			eventHeader_->SetStoreNumber(event.bunchCrossing());
163			eventHeader_->SetTimeStamp(event.time().value());
164	loizides	1.2
165	loizides	1.3	// look-up if entry is in map
166	loizides	1.2	map<UInt_t,Int_t>::iterator riter = runmap_.find(runnum);
167			if (riter != runmap_.end()) {
168			Int_t runentry = riter->second;
169			eventHeader_->SetRunEntry(runentry);
170	loizides	1.16	FillHltTrig(event,setup);
171	loizides	1.2	return;
172			}
173	loizides	1.1
174	loizides	1.2	// fill new run info
175			Int_t runentry = runEntries_;
176	loizides	1.16	++runEntries_;
177	loizides	1.2	eventHeader_->SetRunEntry(runentry);
178			runmap_.insert(pair<UInt_t,Int_t>(runnum,runentry));
179	loizides	1.16	runInfo_->SetRunNum(runnum);
180
181			Int_t hltentry = hltEntries_;
182	loizides	1.14	FillHltInfo(event,setup);
183	loizides	1.16	FillHltTrig(event,setup);
184	loizides	1.21	if (hltentry < hltEntries_) {
185			runInfo_->SetHltEntry(hltentry);
186	loizides	1.16	hltTree_->Fill();
187	loizides	1.21	} else {
188			runInfo_->SetHltEntry(hltentry-1);
189			}
190	loizides	1.14
191	loizides	1.2	runTree_->Fill();
192	loizides	1.1	}
193	loizides	1.5
194	loizides	1.8	//--------------------------------------------------------------------------------------------------
195	loizides	1.36	void FillerMetaInfos::FillHltInfo(const edm::Event &event, const edm::EventSetup &setup)
196	loizides	1.5	{
197	loizides	1.16	// Fill HLT trigger table if it changed.
198	loizides	1.5
199	loizides	1.36	if (!hltActive_)
200			return;
201	loizides	1.14
202	loizides	1.21	// check if we can access the hlt config information
203	loizides	1.33	if (hltProcName_.empty()) {
204			string teststr;
205	loizides	1.39	for(UInt_t i=0; i<hltProcNames_.size(); ++i) {
206	loizides	1.33	if (i>0)
207			teststr += ", ";
208			teststr += hltProcNames_.at(i);
209			edm::LogInfo("FillerMetaInfos") << "Trying to access hlt config using "
210			<< hltProcNames_.at(i) << std::endl;
211
212			if (hltConfig_.init(hltProcNames_.at(i))) {
213			hltProcName_ = hltProcNames_.at(i);
214			if (hltResName_.find(':')==string::npos)
215			hltResName_ += "::";
216			else
217			hltResName_ += ":";
218			hltResName_ += hltProcName_;
219			if (hltEvtName_.find(':')==string::npos)
220			hltEvtName_ += "::";
221			else
222			hltEvtName_ += ":";
223			hltEvtName_ += hltProcName_;
224			break;
225			}
226			}
227			if (hltProcName_.empty()) {
228			edm::LogError("FillerMetaInfos") << "Cannot access hlt config using "
229			<< teststr << std::endl;
230			throw edm::Exception(edm::errors::Configuration, "FillerMetaInfos::FillHltInfo()\n")
231			<< "Cannot access hlt config using " << teststr << std::endl;
232			return;
233			}
234			} else {
235			if (!hltConfig_.init(hltProcName_)) {
236			edm::LogError("FillerMetaInfos") << "Cannot access hlt config using "
237			<< hltProcName_ << std::endl;
238			throw edm::Exception(edm::errors::Configuration, "FillerMetaInfos::FillHltInfo()\n")
239			<< "Cannot access hlt config using " << hltProcName_ << std::endl;
240			return;
241			}
242	loizides	1.16	}
243	loizides	1.14
244	loizides	1.21	// check size of menu... < 256
245	loizides	1.16	if (hltConfig_.size()>hltBits_->Size()) {
246	loizides	1.21	edm::LogError("FillerMetaInfos") << "HLT config contains too many paths "
247	loizides	1.25	<< hltConfig_.size() << " > "
248			<< hltBits_->Size() << std::endl;
249	loizides	1.16	return;
250			}
251	loizides	1.14
252	loizides	1.22	vector<string> *trigtable = new vector<string>;
253	loizides	1.16	map<string,Short_t> *tabmap = new map<string,Short_t>;
254	loizides	1.22	vector<string> *labels = new vector<string>;
255	loizides	1.16	map<string,Short_t> *labmap = new map<string,Short_t>;
256
257	loizides	1.28	if (0) {
258			if (!hltConfig_.tableName().empty())
259			trigtable->push_back(hltConfig_.tableName());
260			else
261			trigtable->push_back("unknown_hlt_config");
262			}
263
264	loizides	1.40	// get HLT trigger object information to be able to access the tag information
265			Handle<trigger::TriggerEvent> triggerEventHLT;
266			GetProduct(hltEvtName_, triggerEventHLT, event);
267			const std::vector<std::string> &tags(triggerEventHLT->collectionTags());
268			for(UInt_t i=0,c=0; i<tags.size(); ++i) {
269			string tag(tags.at(i));
270			if (tag.compare(0,19,"hltL1extraParticles")!=0)
271			continue;
272			if (tag == "hltL1extraParticles::HLT") {
273			if (c==0)
274			tag = "hltL1extraParticles:Muon:HLT";
275			else if (c==1)
276			tag = "hltL1extraParticles:HFRing:HLT";
277			else
278			tag = Form("hltL1extraParticles:Unknown%d:HLT", c);
279			++c;
280			}
281			map<string,Short_t>::iterator riter = labmap->find(tag);
282			if (riter == labmap->end()) {
283			labmap->insert(pair<string,Short_t>(tag,labels->size()));
284			labels->push_back(tag);
285			}
286			}
287
288	loizides	1.21	// loop over hlt paths
289	loizides	1.16	for(UInt_t i=0;i<hltConfig_.size();++i) {
290
291			tabmap->insert(pair<string,Short_t>(hltConfig_.triggerName(i),i));
292	loizides	1.22	trigtable->push_back(hltConfig_.triggerName(i));
293	loizides	1.16	const vector<string> &mLabels(hltConfig_.moduleLabels(i));
294			for (UInt_t j=0; j<mLabels.size(); ++j) {
295	loizides	1.19
296	loizides	1.16	const string& label(mLabels[j]);
297
298	loizides	1.19	// remove characters which do not work: negation is included as !ModuleName
299			// (this might require a change in the underlying CMSSW HLT fwk, so watch out).
300			const char *lptr = &label[0];
301			if (label[0] == '!')
302			++lptr;
303
304			map<string,Short_t>::iterator riter = labmap->find(lptr);
305	loizides	1.16	if (riter == labmap->end()) {
306	loizides	1.22	labmap->insert(pair<string,Short_t>(lptr,labels->size()));
307			labels->push_back(lptr);
308	loizides	1.16	}
309	loizides	1.19
310			const string type(hltConfig_.moduleType(lptr));
311	loizides	1.16	riter = labmap->find(type);
312			if (riter == labmap->end()) {
313	loizides	1.22	labmap->insert(pair<string,Short_t>(type,labels->size()));
314			labels->push_back(type);
315	loizides	1.14	}
316			}
317			}
318
319	loizides	1.22	if (hltTable_->size()>=0) {
320	loizides	1.32	// check if existing table is equal to new table:
321			// if so keep it, otherwise store the new one
322	loizides	1.21
323	loizides	1.32	if ((hltTable_->size()==trigtable->size()) &&
324			(hltLabels_->size()==labels->size())) {
325	loizides	1.21
326			bool newEntryFound = false;
327	loizides	1.22	for (UInt_t i=0; i<trigtable->size(); ++i) {
328	loizides	1.32	if (trigtable->at(i) != hltTable_->at(i)) {
329	loizides	1.21	newEntryFound = true;
330			break;
331			}
332			}
333			if (!newEntryFound) {
334	loizides	1.22	for (UInt_t i=0; i<labels->size(); ++i) {
335	loizides	1.32	if (labels->at(i) != hltLabels_->at(i)) {
336	loizides	1.21	newEntryFound = true;
337			break;
338			}
339			}
340			}
341
342			if (!newEntryFound) {
343			if (verbose_>1)
344			cout << "FillHltInfo: Kept previous HLT information" << endl;
345
346			delete trigtable;
347			delete labels;
348			delete labmap;
349			delete tabmap;
350			return;
351			}
352	loizides	1.16	}
353	loizides	1.20	}
354	loizides	1.16
355	loizides	1.21	// new hlt entry
356	loizides	1.16	delete hltTable_;
357			delete hltLabels_;
358			delete hltTabMap_;
359			delete hltLabMap_;
360			hltTable_ = trigtable;
361			hltLabels_ = labels;
362			hltTabMap_ = tabmap;
363			hltLabMap_ = labmap;
364			hltEntries_++;
365			}
366
367			//--------------------------------------------------------------------------------------------------
368	loizides	1.36	void FillerMetaInfos::FillHltTrig(const edm::Event &event, const edm::EventSetup &setup)
369	loizides	1.16	{
370			// Fill HLT trigger objects along triggered paths.
371
372	loizides	1.36	if (!hltActive_)
373			return;
374	loizides	1.16
375			// reset trigger objects
376			hltObjs_->Reset();
377			hltRels_->Reset();
378	loizides	1.14
379	loizides	1.16	// get HLT trigger information
380	loizides	1.14	Handle<TriggerResults> triggerResultsHLT;
381	loizides	1.16	GetProduct(hltResName_, triggerResultsHLT, event);
382	loizides	1.5
383	loizides	1.16	// get HLT trigger object information
384			Handle<trigger::TriggerEvent> triggerEventHLT;
385			GetProduct(hltEvtName_, triggerEventHLT, event);
386
387			if (verify_)
388			assert(triggerResultsHLT->size()==hltConfig_.size());
389
390	loizides	1.25	// new bitmask
391	loizides	1.37	BitMask256 maskhlt;
392	loizides	1.16
393	loizides	1.37	// loop over trigger objects and fill them
394			const trigger::TriggerObjectCollection &toc(triggerEventHLT->getObjects());
395	loizides	1.39	const std::vector<std::string> &tags(triggerEventHLT->collectionTags());
396	loizides	1.40	for(UInt_t i=0,iprev=0,c=0; i<tags.size(); ++i) {
397
398			Short_t nind = -(i+1);
399			string tag(tags.at(i));
400			if (tag.compare(0,19,"hltL1extraParticles")==0) {
401			if (tag == "hltL1extraParticles::HLT") {
402			if (c==0)
403			tag = "hltL1extraParticles:Muon:HLT";
404			else if (c==1)
405			tag = "hltL1extraParticles:HFRing:HLT";
406			else
407			tag = Form("hltL1extraParticles:Unknown%d:HLT", c-1);
408			++c;
409			}
410			map<string,Short_t>::iterator riter = hltLabMap_->find(tag);
411			if (riter != hltLabMap_->end()) {
412			nind = riter->second;
413			}
414			}
415
416	loizides	1.39	UInt_t inext(triggerEventHLT->collectionKey(i));
417			if (verbose_>2)
418	loizides	1.40	cout << i << " " << tag << " with " << inext-iprev << " objects " << endl;
419	loizides	1.39	for (UInt_t k=iprev; k<inext; ++k) {
420			const trigger::TriggerObject &tobj = toc[k];
421			TriggerObjectBase *trigObj = hltObjs_->Allocate();
422			new (trigObj) TriggerObjectBase(tobj.id(),0,tobj.pt(),tobj.eta(),tobj.phi(),tobj.mass());
423	loizides	1.40	trigObj->SetNameInd(nind);
424	loizides	1.39	if (verbose_>4)
425			cout << " " << k << " " << tobj.id() << " " << tobj.pt() << " " << tobj.eta()
426			<< " " << tobj.phi() << " " << tobj.mass() << endl;
427			}
428			iprev = inext;
429	loizides	1.37	}
430	loizides	1.16
431			// loop over trigger paths
432			const UInt_t N = hltConfig_.size();
433			for(UInt_t i=0;i<N;++i) {
434
435			const string &name(hltConfig_.triggerName(i));
436	loizides	1.40	const UInt_t tind(hltConfig_.triggerIndex(name));
437	loizides	1.16	if (verify_)
438			assert(tind==i);
439
440			if (verbose_>0)
441			cout << "Trigger: path " << name << " [" << i << "]" << endl;
442
443			// get our trigger bit
444			map<string,Short_t>::iterator riter = hltTabMap_->find(name);
445			if (riter == hltTabMap_->end()) {
446			PrintErrorAndExit(Form("Trigger %s not found\n", name.c_str()));
447			}
448
449			UInt_t mytind = riter->second;
450			if (verify_) {
451			if (mytind!=tind)
452			PrintErrorAndExit(Form("Trigger for %s index does not match: %ud %ud\n",
453			name.c_str(), mytind, tind));
454			}
455
456			// modules on this trigger path
457			const UInt_t M(hltConfig_.size(tind));
458			const UInt_t mind(triggerResultsHLT->index(tind));
459			assert (mind<M);
460
461			const vector<string> &mLabels(hltConfig_.moduleLabels(tind));
462
463			if (verbose_>1)
464			cout << " Last active module - label/type: "
465			<< mLabels[mind] << "/" << hltConfig_.moduleType(mLabels[mind])
466			<< " [" << mind << " out of 0-" << (M-1) << " on this path]" << endl;
467
468			// loop over modules on path
469			for (UInt_t j=0; j<=mind; ++j) {
470			const string &mLabel(mLabels[j]);
471
472			// check whether the module is packed up in TriggerEvent product
473			const UInt_t find(triggerEventHLT->filterIndex(InputTag(mLabel,"",hltProcName_)));
474			if (find>=triggerEventHLT->sizeFilters())
475			continue;
476
477			const string mType(hltConfig_.moduleType(mLabel));
478	loizides	1.37
479			string tType = "L1";
480			if (mType != "HLTLevel1GTSeed")
481			tType = "L3";
482
483	loizides	1.16	if (verbose_>1)
484	loizides	1.37	cout << " '" << tType << "' filter in slot " << j
485			<< " - label/type " << mLabel << "/" << mType << endl;
486	loizides	1.16
487			// find index for module label/type name
488			Short_t modind = -1;
489			map<string,Short_t>::iterator riter = hltLabMap_->find(mLabel);
490			if (riter != hltLabMap_->end()) {
491			modind = riter->second;
492			}
493	loizides	1.17	assert(modind!=-1);
494
495			Short_t filind = -1;
496	loizides	1.16	riter = hltLabMap_->find(mType);
497			if (riter != hltLabMap_->end()) {
498	loizides	1.17	filind = riter->second;
499	loizides	1.16	}
500	loizides	1.17	assert(filind!=-1);
501	loizides	1.14
502	loizides	1.16	// find trigger objects
503			const trigger::Vids &vids(triggerEventHLT->filterIds(find));
504			const trigger::Keys &keys(triggerEventHLT->filterKeys(find));
505			const trigger::size_type nVids(vids.size());
506			const trigger::size_type nKeys(keys.size());
507			assert(nVids==nKeys);
508
509			if (verbose_>2)
510	loizides	1.37	cout << " " << nVids << " accepted '" << tType << "' objects found: " << endl;
511	loizides	1.16
512			// loop over trigger objects
513			const trigger::TriggerObjectCollection &toc(triggerEventHLT->getObjects());
514			for (trigger::size_type k=0; k<nVids; ++k) {
515			Int_t tocind = keys[k];
516
517			const trigger::TriggerObject &tobj(toc[tocind]);
518	loizides	1.37
519	loizides	1.16	if (verbose_>2)
520			cout << " " << k << " " << vids[k] << "/" << keys[k] << ": "
521			<< tobj.id() << " " << tobj.pt() << " " << tobj.eta()
522			<< " " << tobj.phi() << " " << tobj.mass() << endl;
523
524			TriggerObjectRel *trigRel = hltRels_->Allocate();
525	loizides	1.37	new (trigRel) TriggerObjectRel(mytind,vids[k],tocind,modind,filind);
526	loizides	1.39	TriggerObjectBase *trigObj = hltObjs_->At(tocind);
527			if (trigObj->Type()==0) {
528			trigObj->SetType(vids[k]);
529			} else {
530			if (trigObj->Type()!=vids[k]) {
531			if (verbose_>3)
532			cout << " -> Have already type " << trigObj->Type()
533			<< " ignored new type " << vids[k] << endl;
534			}
535			}
536	loizides	1.16	}
537			}
538	loizides	1.37
539			if (triggerResultsHLT->accept(tind))
540			maskhlt.SetBit(mytind);
541	loizides	1.16	}
542	loizides	1.25
543	loizides	1.37	hltBits_->SetBits(maskhlt);
544	loizides	1.16	hltObjs_->Trim();
545			hltRels_->Trim();
546	loizides	1.5	}