| 1 |
// $Id: FillerMetaInfos.cc,v 1.48 2009/11/24 15:58:43 loizides Exp $
|
| 2 |
|
| 3 |
#include "MitProd/TreeFiller/interface/FillerMetaInfos.h"
|
| 4 |
#include "CondFormats/DataRecord/interface/L1GtTriggerMenuRcd.h"
|
| 5 |
#include "CondFormats/L1TObjects/interface/L1GtTriggerMenu.h"
|
| 6 |
#include "CondFormats/L1TObjects/interface/L1GtTriggerMenuFwd.h"
|
| 7 |
#include "DataFormats/Common/interface/Handle.h"
|
| 8 |
#include "DataFormats/Common/interface/TriggerResults.h"
|
| 9 |
#include "DataFormats/HLTReco/interface/TriggerEvent.h"
|
| 10 |
#include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerRecord.h"
|
| 11 |
#include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutRecord.h"
|
| 12 |
#include "FWCore/Framework/interface/ESHandle.h"
|
| 13 |
#include "FWCore/Framework/interface/TriggerNames.h"
|
| 14 |
#include "MitAna/DataTree/interface/EventHeader.h"
|
| 15 |
#include "MitAna/DataTree/interface/LAHeader.h"
|
| 16 |
#include "MitAna/DataTree/interface/Names.h"
|
| 17 |
#include "MitAna/DataTree/interface/L1TriggerMaskCol.h"
|
| 18 |
#include "MitAna/DataTree/interface/RunInfo.h"
|
| 19 |
#include "MitAna/DataTree/interface/TriggerMask.h"
|
| 20 |
#include "MitAna/DataTree/interface/TriggerObjectBase.h"
|
| 21 |
#include "MitAna/DataTree/interface/TriggerObjectBaseCol.h"
|
| 22 |
#include "MitAna/DataTree/interface/TriggerObjectRelCol.h"
|
| 23 |
#include "MitProd/ObjectService/interface/ObjectService.h"
|
| 24 |
#include <TObjectTable.h>
|
| 25 |
#include <TIterator.h>
|
| 26 |
|
| 27 |
using namespace std;
|
| 28 |
using namespace edm;
|
| 29 |
using namespace mithep;
|
| 30 |
|
| 31 |
Int_t mithep::FillerMetaInfos::instance_ = 0;
|
| 32 |
|
| 33 |
//--------------------------------------------------------------------------------------------------
|
| 34 |
FillerMetaInfos::FillerMetaInfos(const ParameterSet &cfg, const char *name, bool active) :
|
| 35 |
BaseFiller(cfg,name,(instance_==0||active?1:0)),
|
| 36 |
evtName_(Conf().getUntrackedParameter<string>("evtMitName",Names::gkEvtHeaderBrn)),
|
| 37 |
runTreeName_(Conf().getUntrackedParameter<string>("runTreeMitName",Names::gkRunTreeName)),
|
| 38 |
lahTreeName_(Conf().getUntrackedParameter<string>("lahTreeMitName",Names::gkLATreeName)),
|
| 39 |
hltTreeName_(Conf().getUntrackedParameter<string>("hltTreeMitName",
|
| 40 |
Form("%s%s",Names::gkHltTreeName,Istr()))),
|
| 41 |
hltActive_(Conf().getUntrackedParameter<bool>("hltActive",true)),
|
| 42 |
hltResName_(Conf().getUntrackedParameter<string>("hltResEdmName","TriggerResults")),
|
| 43 |
hltEvtName_(Conf().getUntrackedParameter<string>("hltEvtEdmName","hltTriggerSummaryAOD")),
|
| 44 |
hltTableName_(Conf().getUntrackedParameter<string>("hltTableMitName",Names::gkHltTableBrn)),
|
| 45 |
hltLabelName_(Conf().getUntrackedParameter<string>("hltLabelMitName",Names::gkHltLabelBrn)),
|
| 46 |
hltBitsName_(Conf().getUntrackedParameter<string>("hltBitsMitName",
|
| 47 |
Form("%s%s",Names::gkHltBitBrn,Istr()))),
|
| 48 |
hltObjsName_(Conf().getUntrackedParameter<string>("hltObjsMitName",
|
| 49 |
Form("%s%s",Names::gkHltObjBrn,Istr()))),
|
| 50 |
l1Active_(Conf().getUntrackedParameter<bool>("l1Active",true)),
|
| 51 |
l1GTRecName_(Conf().getUntrackedParameter<string>("l1GtRecordEdmName","l1GtRecord")),
|
| 52 |
l1GTRRName_(Conf().getUntrackedParameter<string>("l1GtReadRecEdmName","")),
|
| 53 |
l1TBitsName_(Conf().getUntrackedParameter<string>("l1TechBitsMitName",
|
| 54 |
Form("%s%s",Names::gkL1TechBitsBrn,Istr()))),
|
| 55 |
l1ABitsName_(Conf().getUntrackedParameter<string>("l1AlgoBitsMitName",
|
| 56 |
Form("%s%s",Names::gkL1AlgoBitsBrn,Istr()))),
|
| 57 |
tws_(0),
|
| 58 |
eventHeader_(new EventHeader()),
|
| 59 |
evtLAHeader_(new LAHeader()),
|
| 60 |
runInfo_(new RunInfo()),
|
| 61 |
runTree_(0),
|
| 62 |
laTree_(0),
|
| 63 |
runEntries_(0),
|
| 64 |
hltBits_(new TriggerMask),
|
| 65 |
hltTable_(new vector<string>),
|
| 66 |
hltTabMap_(0),
|
| 67 |
hltLabels_(new vector<string>),
|
| 68 |
hltLabMap_(0),
|
| 69 |
hltObjs_(new TriggerObjectBaseArr),
|
| 70 |
hltRels_(new TriggerObjectRelArr),
|
| 71 |
hltTree_(0),
|
| 72 |
hltEntries_(0),
|
| 73 |
fileNum_(0),
|
| 74 |
l1TBits_(new L1TriggerMask),
|
| 75 |
l1ABits_(new L1TriggerMask),
|
| 76 |
l1TBits2_(new L1TriggerMask),
|
| 77 |
l1ABits2_(new L1TriggerMask),
|
| 78 |
l1AbArr_(new L1TriggerMaskArr),
|
| 79 |
l1TbArr_(new L1TriggerMaskArr)
|
| 80 |
{
|
| 81 |
// Constructor.
|
| 82 |
|
| 83 |
++instance_;
|
| 84 |
|
| 85 |
if (Conf().exists("hltProcNames"))
|
| 86 |
hltProcNames_ = Conf().getUntrackedParameter<vector<string> >("hltProcNames");
|
| 87 |
if (hltProcNames_.size()==0)
|
| 88 |
hltProcNames_.push_back("HLT");
|
| 89 |
|
| 90 |
if (l1Active_ && !hltActive_)
|
| 91 |
PrintErrorAndExit("L1Active set _without_ hltActive set as well is not supported");
|
| 92 |
}
|
| 93 |
|
| 94 |
//--------------------------------------------------------------------------------------------------
|
| 95 |
FillerMetaInfos::~FillerMetaInfos()
|
| 96 |
{
|
| 97 |
// Destructor.
|
| 98 |
|
| 99 |
delete eventHeader_;
|
| 100 |
delete evtLAHeader_;
|
| 101 |
delete runInfo_;
|
| 102 |
delete hltBits_;
|
| 103 |
delete hltTable_;
|
| 104 |
delete hltLabels_;
|
| 105 |
delete hltObjs_;
|
| 106 |
delete hltRels_;
|
| 107 |
delete l1TBits_;
|
| 108 |
delete l1ABits_;
|
| 109 |
delete l1AbArr_;
|
| 110 |
delete l1TbArr_;
|
| 111 |
eventHeader_ = 0;
|
| 112 |
evtLAHeader_ = 0;
|
| 113 |
runInfo_ = 0;
|
| 114 |
hltTable_ = 0;
|
| 115 |
hltLabels_ = 0;
|
| 116 |
hltObjs_ = 0;
|
| 117 |
hltRels_ = 0;
|
| 118 |
runTree_ = 0;
|
| 119 |
laTree_ = 0;
|
| 120 |
hltTree_ = 0;
|
| 121 |
}
|
| 122 |
|
| 123 |
//--------------------------------------------------------------------------------------------------
|
| 124 |
void FillerMetaInfos::BookDataBlock(TreeWriter &tws, const edm::EventSetup &es)
|
| 125 |
{
|
| 126 |
// Create run info tree and book our branches.
|
| 127 |
|
| 128 |
// add branches to main tree
|
| 129 |
if (OS()->get<mithep::EventHeader>(evtName_)==0) {
|
| 130 |
tws.AddBranch(evtName_,&eventHeader_);
|
| 131 |
OS()->add<mithep::EventHeader>(eventHeader_,evtName_);
|
| 132 |
}
|
| 133 |
|
| 134 |
// add branches to run info tree
|
| 135 |
runTree_=tws.GetTree(runTreeName_);
|
| 136 |
if (runTree_==0) {
|
| 137 |
tws.AddBranchToTree(runTreeName_,Names::gkRunInfoBrn,
|
| 138 |
TClass::GetClass(typeid(*runInfo_))->GetName(),&runInfo_);
|
| 139 |
tws.SetAutoFill(runTreeName_,0);
|
| 140 |
runTree_=tws.GetTree(runTreeName_);
|
| 141 |
}
|
| 142 |
|
| 143 |
// add branches to lookahead tree
|
| 144 |
laTree_=tws.GetTree(lahTreeName_);
|
| 145 |
if (laTree_==0) {
|
| 146 |
tws.AddBranchToTree(lahTreeName_,Names::gkLAHeaderBrn,
|
| 147 |
TClass::GetClass(typeid(*evtLAHeader_))->GetName(),&runInfo_);
|
| 148 |
tws.SetAutoFill(lahTreeName_,0);
|
| 149 |
laTree_=tws.GetTree(lahTreeName_);
|
| 150 |
}
|
| 151 |
|
| 152 |
// add HLT branches to main tree and to HLT trigger info tree
|
| 153 |
if (hltActive_) {
|
| 154 |
tws.AddBranch(hltBitsName_,&hltBits_);
|
| 155 |
tws.AddBranch(hltObjsName_,&hltObjs_);
|
| 156 |
tws.AddBranch(Form("%sRelation",hltObjsName_.c_str()),&hltRels_);
|
| 157 |
|
| 158 |
tws.AddBranchToTree(hltTreeName_,hltTableName_,
|
| 159 |
TClass::GetClass(typeid(*hltTable_))->GetName(),&hltTable_,32*1024,0);
|
| 160 |
tws.AddBranchToTree(hltTreeName_,hltLabelName_,
|
| 161 |
TClass::GetClass(typeid(*hltLabels_))->GetName(),&hltLabels_,32*1024,0);
|
| 162 |
tws.SetAutoFill(hltTreeName_,0);
|
| 163 |
hltTree_=tws.GetTree(hltTreeName_);
|
| 164 |
}
|
| 165 |
|
| 166 |
if (l1Active_) {
|
| 167 |
tws.AddBranch(l1TBitsName_,&l1TBits_);
|
| 168 |
tws.AddBranch(l1ABitsName_,&l1ABits_);
|
| 169 |
tws.AddBranch(Form("%sBeforeMask",l1TBitsName_.c_str()),&l1TBits2_);
|
| 170 |
tws.AddBranch(Form("%sBeforeMask",l1ABitsName_.c_str()),&l1ABits2_);
|
| 171 |
if (l1GTRRName_.size()) {
|
| 172 |
tws.AddBranch(Form("%sBxs",l1TBitsName_.c_str()),&l1TbArr_);
|
| 173 |
tws.AddBranch(Form("%sBxs",l1ABitsName_.c_str()),&l1AbArr_);
|
| 174 |
}
|
| 175 |
}
|
| 176 |
|
| 177 |
// store pointer to tree writer
|
| 178 |
tws_ = &tws;
|
| 179 |
}
|
| 180 |
|
| 181 |
//--------------------------------------------------------------------------------------------------
|
| 182 |
void FillerMetaInfos::FillBitAMask(BitMask64 &bits, const DecisionWord &dw)
|
| 183 |
{
|
| 184 |
// Fill bit mask.
|
| 185 |
|
| 186 |
size_t dws = dw.size();
|
| 187 |
if (dws>64)
|
| 188 |
dws = 64;
|
| 189 |
for (size_t i=0; i<dws;++i) {
|
| 190 |
if (dw.at(i))
|
| 191 |
bits.SetBit(i);
|
| 192 |
}
|
| 193 |
}
|
| 194 |
|
| 195 |
//--------------------------------------------------------------------------------------------------
|
| 196 |
void FillerMetaInfos::FillBitTMask(BitMask64 &bits, const TechnicalTriggerWord &tw)
|
| 197 |
{
|
| 198 |
// Fill bit mask.
|
| 199 |
|
| 200 |
size_t tws = tw.size();
|
| 201 |
if (tws>64)
|
| 202 |
tws = 64;
|
| 203 |
for (size_t i=0; i<tws;++i) {
|
| 204 |
if (tw.at(i))
|
| 205 |
bits.SetBit(i);
|
| 206 |
}
|
| 207 |
}
|
| 208 |
|
| 209 |
//--------------------------------------------------------------------------------------------------
|
| 210 |
void FillerMetaInfos::FillDataBlock(const edm::Event &event, const edm::EventSetup &setup)
|
| 211 |
{
|
| 212 |
// Fill our data structures.
|
| 213 |
|
| 214 |
// clear map if a new file was opened
|
| 215 |
if (tws_->GetFileNumber()!=fileNum_) {
|
| 216 |
runmap_.clear();
|
| 217 |
fileNum_ = tws_->GetFileNumber();
|
| 218 |
runEntries_ = 0;
|
| 219 |
hltEntries_ = -1;
|
| 220 |
}
|
| 221 |
|
| 222 |
UInt_t runnum = event.id().run();
|
| 223 |
|
| 224 |
// store look ahead information
|
| 225 |
if (runEntries_>0) {
|
| 226 |
evtLAHeader_->SetRunNum(runnum);
|
| 227 |
laTree_->Fill();
|
| 228 |
if(0) { // check for memory leak in usage of ROOT objects
|
| 229 |
if(laTree_->GetEntries() % 100==0)
|
| 230 |
gObjectTable->Print();
|
| 231 |
}
|
| 232 |
}
|
| 233 |
|
| 234 |
// fill event header
|
| 235 |
eventHeader_->SetEvtNum(event.id().event());
|
| 236 |
eventHeader_->SetLumiSec(event.luminosityBlock());
|
| 237 |
eventHeader_->SetRunNum(runnum);
|
| 238 |
eventHeader_->SetIsMC(!event.isRealData());
|
| 239 |
eventHeader_->SetBunchCrossing(event.bunchCrossing());
|
| 240 |
eventHeader_->SetExpType(event.experimentType());
|
| 241 |
eventHeader_->SetOrbitNumber(event.orbitNumber());
|
| 242 |
eventHeader_->SetStoreNumber(event.bunchCrossing());
|
| 243 |
eventHeader_->SetTimeStamp(event.time().value());
|
| 244 |
|
| 245 |
// look-up if entry is in map
|
| 246 |
map<UInt_t,Int_t>::iterator riter = runmap_.find(runnum);
|
| 247 |
if (riter != runmap_.end()) {
|
| 248 |
Int_t runentry = riter->second;
|
| 249 |
eventHeader_->SetRunEntry(runentry);
|
| 250 |
FillHltTrig(event,setup);
|
| 251 |
FillL1Trig(event,setup);
|
| 252 |
return;
|
| 253 |
}
|
| 254 |
|
| 255 |
// fill new run info
|
| 256 |
Int_t runentry = runEntries_;
|
| 257 |
++runEntries_;
|
| 258 |
eventHeader_->SetRunEntry(runentry);
|
| 259 |
runmap_.insert(pair<UInt_t,Int_t>(runnum,runentry));
|
| 260 |
runInfo_->SetRunNum(runnum);
|
| 261 |
|
| 262 |
Int_t hltentry = hltEntries_;
|
| 263 |
FillHltInfo(event,setup);
|
| 264 |
FillHltTrig(event,setup);
|
| 265 |
FillL1Trig(event,setup);
|
| 266 |
if (hltentry < hltEntries_) {
|
| 267 |
runInfo_->SetHltEntry(hltentry);
|
| 268 |
hltTree_->Fill();
|
| 269 |
} else {
|
| 270 |
runInfo_->SetHltEntry(hltentry-1);
|
| 271 |
}
|
| 272 |
|
| 273 |
runTree_->Fill();
|
| 274 |
}
|
| 275 |
|
| 276 |
//--------------------------------------------------------------------------------------------------
|
| 277 |
void FillerMetaInfos::FillHltInfo(const edm::Event &event, const edm::EventSetup &setup)
|
| 278 |
{
|
| 279 |
// Fill HLT trigger table if it changed.
|
| 280 |
|
| 281 |
if (!hltActive_)
|
| 282 |
return;
|
| 283 |
|
| 284 |
// check if we can access the hlt config information
|
| 285 |
if (hltProcName_.empty()) {
|
| 286 |
string teststr;
|
| 287 |
for(UInt_t i=0; i<hltProcNames_.size(); ++i) {
|
| 288 |
if (i>0)
|
| 289 |
teststr += ", ";
|
| 290 |
teststr += hltProcNames_.at(i);
|
| 291 |
edm::LogInfo("FillerMetaInfos") << "Trying to access hlt config using "
|
| 292 |
<< hltProcNames_.at(i) << std::endl;
|
| 293 |
|
| 294 |
if (hltConfig_.init(hltProcNames_.at(i))) {
|
| 295 |
hltProcName_ = hltProcNames_.at(i);
|
| 296 |
if (hltResName_.find(':')==string::npos)
|
| 297 |
hltResName_ += "::";
|
| 298 |
else
|
| 299 |
hltResName_ += ":";
|
| 300 |
hltResName_ += hltProcName_;
|
| 301 |
if (hltEvtName_.find(':')==string::npos)
|
| 302 |
hltEvtName_ += "::";
|
| 303 |
else
|
| 304 |
hltEvtName_ += ":";
|
| 305 |
hltEvtName_ += hltProcName_;
|
| 306 |
break;
|
| 307 |
}
|
| 308 |
}
|
| 309 |
if (hltProcName_.empty()) {
|
| 310 |
edm::LogError("FillerMetaInfos") << "Cannot access hlt config using "
|
| 311 |
<< teststr << std::endl;
|
| 312 |
throw edm::Exception(edm::errors::Configuration, "FillerMetaInfos::FillHltInfo()\n")
|
| 313 |
<< "Cannot access hlt config using " << teststr << std::endl;
|
| 314 |
return;
|
| 315 |
}
|
| 316 |
} else {
|
| 317 |
if (!hltConfig_.init(hltProcName_)) {
|
| 318 |
edm::LogError("FillerMetaInfos") << "Cannot access hlt config using "
|
| 319 |
<< hltProcName_ << std::endl;
|
| 320 |
throw edm::Exception(edm::errors::Configuration, "FillerMetaInfos::FillHltInfo()\n")
|
| 321 |
<< "Cannot access hlt config using " << hltProcName_ << std::endl;
|
| 322 |
return;
|
| 323 |
}
|
| 324 |
}
|
| 325 |
|
| 326 |
// check size of menu... < 256
|
| 327 |
if (hltConfig_.size()>hltBits_->Size()) {
|
| 328 |
edm::LogError("FillerMetaInfos") << "HLT config contains too many paths "
|
| 329 |
<< hltConfig_.size() << " > "
|
| 330 |
<< hltBits_->Size() << std::endl;
|
| 331 |
return;
|
| 332 |
}
|
| 333 |
|
| 334 |
vector<string> *trigtable = new vector<string>;
|
| 335 |
map<string,Short_t> *tabmap = new map<string,Short_t>;
|
| 336 |
vector<string> *labels = new vector<string>;
|
| 337 |
map<string,Short_t> *labmap = new map<string,Short_t>;
|
| 338 |
|
| 339 |
if (0) {
|
| 340 |
if (!hltConfig_.tableName().empty())
|
| 341 |
trigtable->push_back(hltConfig_.tableName());
|
| 342 |
else
|
| 343 |
trigtable->push_back("unknown_hlt_config");
|
| 344 |
}
|
| 345 |
|
| 346 |
// get HLT trigger object information to be able to access the tag information
|
| 347 |
Handle<trigger::TriggerEvent> triggerEventHLT;
|
| 348 |
GetProduct(hltEvtName_, triggerEventHLT, event);
|
| 349 |
const std::vector<std::string> &tags(triggerEventHLT->collectionTags());
|
| 350 |
for(UInt_t i=0,c=0; i<tags.size(); ++i) {
|
| 351 |
string tag(tags.at(i));
|
| 352 |
if (tag.compare(0,19,"hltL1extraParticles")!=0)
|
| 353 |
continue;
|
| 354 |
if (tag == "hltL1extraParticles::HLT") {
|
| 355 |
if (c==0)
|
| 356 |
tag = "hltL1extraParticles:Muon:HLT";
|
| 357 |
else if (c==1)
|
| 358 |
tag = "hltL1extraParticles:HFRing:HLT";
|
| 359 |
else
|
| 360 |
tag = Form("hltL1extraParticles:Unknown%d:HLT", c);
|
| 361 |
++c;
|
| 362 |
}
|
| 363 |
map<string,Short_t>::iterator riter = labmap->find(tag);
|
| 364 |
if (riter == labmap->end()) {
|
| 365 |
labmap->insert(pair<string,Short_t>(tag,labels->size()));
|
| 366 |
labels->push_back(tag);
|
| 367 |
}
|
| 368 |
}
|
| 369 |
|
| 370 |
// loop over hlt paths
|
| 371 |
for(UInt_t i=0;i<hltConfig_.size();++i) {
|
| 372 |
|
| 373 |
tabmap->insert(pair<string,Short_t>(hltConfig_.triggerName(i),i));
|
| 374 |
trigtable->push_back(hltConfig_.triggerName(i));
|
| 375 |
const vector<string> &mLabels(hltConfig_.moduleLabels(i));
|
| 376 |
for (UInt_t j=0; j<mLabels.size(); ++j) {
|
| 377 |
|
| 378 |
const string& label(mLabels[j]);
|
| 379 |
|
| 380 |
// remove characters which do not work: negation is included as !ModuleName
|
| 381 |
// (this might require a change in the underlying CMSSW HLT fwk, so watch out).
|
| 382 |
const char *lptr = &label[0];
|
| 383 |
if (label[0] == '!')
|
| 384 |
++lptr;
|
| 385 |
|
| 386 |
map<string,Short_t>::iterator riter = labmap->find(lptr);
|
| 387 |
if (riter == labmap->end()) {
|
| 388 |
labmap->insert(pair<string,Short_t>(lptr,labels->size()));
|
| 389 |
labels->push_back(lptr);
|
| 390 |
}
|
| 391 |
|
| 392 |
const string type(hltConfig_.moduleType(lptr));
|
| 393 |
riter = labmap->find(type);
|
| 394 |
if (riter == labmap->end()) {
|
| 395 |
labmap->insert(pair<string,Short_t>(type,labels->size()));
|
| 396 |
labels->push_back(type);
|
| 397 |
}
|
| 398 |
}
|
| 399 |
}
|
| 400 |
|
| 401 |
if (l1Active_) {
|
| 402 |
edm::ESHandle<L1GtTriggerMenu> menuRcd;
|
| 403 |
setup.get<L1GtTriggerMenuRcd>().get(menuRcd) ;
|
| 404 |
const L1GtTriggerMenu* menu = menuRcd.product();
|
| 405 |
|
| 406 |
// get l1 algo names
|
| 407 |
size_t counter = 0;
|
| 408 |
labels->push_back("xxx-L1AlgoNames-xxx");
|
| 409 |
for (CItAlgo algo = menu->gtAlgorithmMap().begin();
|
| 410 |
algo!=menu->gtAlgorithmMap().end(); ++algo) {
|
| 411 |
labels->push_back(algo->second.algoName());
|
| 412 |
++counter;
|
| 413 |
}
|
| 414 |
if (counter>=l1ABits_->Size()) {
|
| 415 |
edm::LogError("FillerMetaInfos") << "Cannot store more than 64 l1 algo bits, but got "
|
| 416 |
<< counter << std::endl;
|
| 417 |
}
|
| 418 |
|
| 419 |
// get l1 tech names
|
| 420 |
counter = 0;
|
| 421 |
labels->push_back("xxx-L1TechNames-xxx");
|
| 422 |
for (CItAlgo algo = menu->gtTechnicalTriggerMap().begin();
|
| 423 |
algo!=menu->gtTechnicalTriggerMap().end(); ++algo) {
|
| 424 |
labels->push_back(algo->second.algoName());
|
| 425 |
++counter;
|
| 426 |
}
|
| 427 |
if (counter>=l1TBits_->Size()) {
|
| 428 |
edm::LogError("FillerMetaInfos") << "Cannot store more than 64 l1 technical bits, but got "
|
| 429 |
<< counter << std::endl;
|
| 430 |
}
|
| 431 |
}
|
| 432 |
|
| 433 |
if (hltTable_->size()>=0) {
|
| 434 |
// check if existing table is equal to new table:
|
| 435 |
// if so keep it, otherwise store the new one
|
| 436 |
|
| 437 |
if ((hltTable_->size()==trigtable->size()) &&
|
| 438 |
(hltLabels_->size()==labels->size())) {
|
| 439 |
|
| 440 |
bool newEntryFound = false;
|
| 441 |
for (UInt_t i=0; i<trigtable->size(); ++i) {
|
| 442 |
if (trigtable->at(i) != hltTable_->at(i)) {
|
| 443 |
newEntryFound = true;
|
| 444 |
break;
|
| 445 |
}
|
| 446 |
}
|
| 447 |
if (!newEntryFound) {
|
| 448 |
for (UInt_t i=0; i<labels->size(); ++i) {
|
| 449 |
if (labels->at(i) != hltLabels_->at(i)) {
|
| 450 |
newEntryFound = true;
|
| 451 |
break;
|
| 452 |
}
|
| 453 |
}
|
| 454 |
}
|
| 455 |
|
| 456 |
if (!newEntryFound) {
|
| 457 |
if (verbose_>1)
|
| 458 |
cout << "FillHltInfo: Kept previous HLT information" << endl;
|
| 459 |
|
| 460 |
delete trigtable;
|
| 461 |
delete labels;
|
| 462 |
delete labmap;
|
| 463 |
delete tabmap;
|
| 464 |
return;
|
| 465 |
}
|
| 466 |
}
|
| 467 |
}
|
| 468 |
|
| 469 |
// new hlt entry
|
| 470 |
delete hltTable_;
|
| 471 |
delete hltLabels_;
|
| 472 |
delete hltTabMap_;
|
| 473 |
delete hltLabMap_;
|
| 474 |
hltTable_ = trigtable;
|
| 475 |
hltLabels_ = labels;
|
| 476 |
hltTabMap_ = tabmap;
|
| 477 |
hltLabMap_ = labmap;
|
| 478 |
hltEntries_++;
|
| 479 |
}
|
| 480 |
|
| 481 |
//--------------------------------------------------------------------------------------------------
|
| 482 |
void FillerMetaInfos::FillHltTrig(const edm::Event &event, const edm::EventSetup &setup)
|
| 483 |
{
|
| 484 |
// Fill HLT trigger objects along triggered paths.
|
| 485 |
|
| 486 |
if (!hltActive_)
|
| 487 |
return;
|
| 488 |
|
| 489 |
// reset trigger objects
|
| 490 |
hltObjs_->Reset();
|
| 491 |
hltRels_->Reset();
|
| 492 |
|
| 493 |
// get HLT trigger information
|
| 494 |
Handle<TriggerResults> triggerResultsHLT;
|
| 495 |
GetProduct(hltResName_, triggerResultsHLT, event);
|
| 496 |
|
| 497 |
// get HLT trigger object information
|
| 498 |
Handle<trigger::TriggerEvent> triggerEventHLT;
|
| 499 |
GetProduct(hltEvtName_, triggerEventHLT, event);
|
| 500 |
|
| 501 |
if (verify_)
|
| 502 |
assert(triggerResultsHLT->size()==hltConfig_.size());
|
| 503 |
|
| 504 |
// new bitmask
|
| 505 |
BitMask256 maskhlt;
|
| 506 |
|
| 507 |
// loop over trigger objects and fill them
|
| 508 |
const trigger::TriggerObjectCollection &toc(triggerEventHLT->getObjects());
|
| 509 |
const std::vector<std::string> &tags(triggerEventHLT->collectionTags());
|
| 510 |
for(UInt_t i=0,iprev=0,c=0; i<tags.size(); ++i) {
|
| 511 |
|
| 512 |
Short_t tnind = -(i+1);
|
| 513 |
string tag(tags.at(i));
|
| 514 |
if (tag.compare(0,19,"hltL1extraParticles")==0) {
|
| 515 |
if (tag == "hltL1extraParticles::HLT") {
|
| 516 |
if (c==0)
|
| 517 |
tag = "hltL1extraParticles:Muon:HLT";
|
| 518 |
else if (c==1)
|
| 519 |
tag = "hltL1extraParticles:HFRing:HLT";
|
| 520 |
else
|
| 521 |
tag = Form("hltL1extraParticles:Unknown%d:HLT", c-1);
|
| 522 |
++c;
|
| 523 |
}
|
| 524 |
map<string,Short_t>::iterator riter = hltLabMap_->find(tag);
|
| 525 |
if (riter != hltLabMap_->end()) {
|
| 526 |
tnind = riter->second;
|
| 527 |
}
|
| 528 |
}
|
| 529 |
|
| 530 |
UInt_t inext(triggerEventHLT->collectionKey(i));
|
| 531 |
if (verbose_>2)
|
| 532 |
cout << i << " " << tag << " with " << inext-iprev << " objects " << endl;
|
| 533 |
for (UInt_t k=iprev; k<inext; ++k) {
|
| 534 |
const trigger::TriggerObject &tobj = toc[k];
|
| 535 |
TriggerObjectBase *trigObj = hltObjs_->Allocate();
|
| 536 |
new (trigObj) TriggerObjectBase(tobj.id(),0,tobj.pt(),tobj.eta(),tobj.phi(),tobj.mass());
|
| 537 |
trigObj->SetTagInd(tnind);
|
| 538 |
if (verbose_>4)
|
| 539 |
cout << " " << k << " " << tobj.id() << " " << tobj.pt() << " " << tobj.eta()
|
| 540 |
<< " " << tobj.phi() << " " << tobj.mass() << endl;
|
| 541 |
}
|
| 542 |
iprev = inext;
|
| 543 |
}
|
| 544 |
|
| 545 |
// loop over trigger paths
|
| 546 |
const UInt_t N = hltConfig_.size();
|
| 547 |
for(UInt_t i=0;i<N;++i) {
|
| 548 |
|
| 549 |
const string &name(hltConfig_.triggerName(i));
|
| 550 |
const UInt_t tind(hltConfig_.triggerIndex(name));
|
| 551 |
if (verify_)
|
| 552 |
assert(tind==i);
|
| 553 |
|
| 554 |
if (verbose_>0)
|
| 555 |
cout << "Trigger: path " << name << " [" << i << "]" << endl;
|
| 556 |
|
| 557 |
// get our trigger bit
|
| 558 |
map<string,Short_t>::iterator riter = hltTabMap_->find(name);
|
| 559 |
if (riter == hltTabMap_->end()) {
|
| 560 |
PrintErrorAndExit(Form("Trigger %s not found\n", name.c_str()));
|
| 561 |
}
|
| 562 |
|
| 563 |
UInt_t mytind = riter->second;
|
| 564 |
if (verify_) {
|
| 565 |
if (mytind!=tind)
|
| 566 |
PrintErrorAndExit(Form("Trigger for %s index does not match: %ud %ud\n",
|
| 567 |
name.c_str(), mytind, tind));
|
| 568 |
}
|
| 569 |
|
| 570 |
// modules on this trigger path
|
| 571 |
const UInt_t M(hltConfig_.size(tind));
|
| 572 |
const UInt_t mind(triggerResultsHLT->index(tind));
|
| 573 |
assert (mind<M);
|
| 574 |
|
| 575 |
const vector<string> &mLabels(hltConfig_.moduleLabels(tind));
|
| 576 |
|
| 577 |
if (verbose_>1)
|
| 578 |
cout << " Last active module - label/type: "
|
| 579 |
<< mLabels[mind] << "/" << hltConfig_.moduleType(mLabels[mind])
|
| 580 |
<< " [" << mind << " out of 0-" << (M-1) << " on this path]" << endl;
|
| 581 |
|
| 582 |
// loop over modules on path
|
| 583 |
for (UInt_t j=0; j<=mind; ++j) {
|
| 584 |
const string &mLabel(mLabels[j]);
|
| 585 |
|
| 586 |
// check whether the module is packed up in TriggerEvent product
|
| 587 |
const UInt_t find(triggerEventHLT->filterIndex(InputTag(mLabel,"",hltProcName_)));
|
| 588 |
if (find>=triggerEventHLT->sizeFilters())
|
| 589 |
continue;
|
| 590 |
|
| 591 |
const string mType(hltConfig_.moduleType(mLabel));
|
| 592 |
|
| 593 |
string tType = "L1";
|
| 594 |
if (mType != "HLTLevel1GTSeed")
|
| 595 |
tType = "L3";
|
| 596 |
|
| 597 |
if (verbose_>1)
|
| 598 |
cout << " '" << tType << "' filter in slot " << j
|
| 599 |
<< " - label/type " << mLabel << "/" << mType << endl;
|
| 600 |
|
| 601 |
// find index for module label/type name
|
| 602 |
Short_t modind = -1;
|
| 603 |
map<string,Short_t>::iterator riter = hltLabMap_->find(mLabel);
|
| 604 |
if (riter != hltLabMap_->end()) {
|
| 605 |
modind = riter->second;
|
| 606 |
}
|
| 607 |
assert(modind!=-1);
|
| 608 |
|
| 609 |
Short_t filind = -1;
|
| 610 |
riter = hltLabMap_->find(mType);
|
| 611 |
if (riter != hltLabMap_->end()) {
|
| 612 |
filind = riter->second;
|
| 613 |
}
|
| 614 |
assert(filind!=-1);
|
| 615 |
|
| 616 |
// find trigger objects
|
| 617 |
const trigger::Vids &vids(triggerEventHLT->filterIds(find));
|
| 618 |
const trigger::Keys &keys(triggerEventHLT->filterKeys(find));
|
| 619 |
const trigger::size_type nVids(vids.size());
|
| 620 |
const trigger::size_type nKeys(keys.size());
|
| 621 |
assert(nVids==nKeys);
|
| 622 |
|
| 623 |
if (verbose_>2)
|
| 624 |
cout << " " << nVids << " accepted '" << tType << "' objects found: " << endl;
|
| 625 |
|
| 626 |
// loop over trigger objects
|
| 627 |
const trigger::TriggerObjectCollection &toc(triggerEventHLT->getObjects());
|
| 628 |
for (trigger::size_type k=0; k<nVids; ++k) {
|
| 629 |
Int_t tocind = keys[k];
|
| 630 |
|
| 631 |
const trigger::TriggerObject &tobj(toc[tocind]);
|
| 632 |
|
| 633 |
if (verbose_>2)
|
| 634 |
cout << " " << k << " " << vids[k] << "/" << keys[k] << ": "
|
| 635 |
<< tobj.id() << " " << tobj.pt() << " " << tobj.eta()
|
| 636 |
<< " " << tobj.phi() << " " << tobj.mass() << endl;
|
| 637 |
|
| 638 |
TriggerObjectRel *trigRel = hltRels_->Allocate();
|
| 639 |
new (trigRel) TriggerObjectRel(mytind,vids[k],tocind,modind,filind);
|
| 640 |
TriggerObjectBase *trigObj = hltObjs_->At(tocind);
|
| 641 |
if (trigObj->Type()==0) {
|
| 642 |
trigObj->SetType(vids[k]);
|
| 643 |
} else {
|
| 644 |
if (trigObj->Type()!=vids[k]) {
|
| 645 |
if (verbose_>3)
|
| 646 |
cout << " -> Have already type " << trigObj->Type()
|
| 647 |
<< " ignored new type " << vids[k] << endl;
|
| 648 |
}
|
| 649 |
}
|
| 650 |
}
|
| 651 |
}
|
| 652 |
|
| 653 |
if (triggerResultsHLT->accept(tind))
|
| 654 |
maskhlt.SetBit(mytind);
|
| 655 |
}
|
| 656 |
|
| 657 |
hltBits_->SetBits(maskhlt);
|
| 658 |
hltObjs_->Trim();
|
| 659 |
hltRels_->Trim();
|
| 660 |
}
|
| 661 |
|
| 662 |
//--------------------------------------------------------------------------------------------------
|
| 663 |
void FillerMetaInfos::FillL1Trig(const edm::Event &event, const edm::EventSetup &setup)
|
| 664 |
{
|
| 665 |
// Fill l1 trigger bits after masking.
|
| 666 |
|
| 667 |
if (!l1Active_)
|
| 668 |
return;
|
| 669 |
|
| 670 |
// get L1 trigger record information
|
| 671 |
Handle<L1GlobalTriggerRecord> gtRecord;
|
| 672 |
GetProduct(l1GTRecName_, gtRecord, event);
|
| 673 |
|
| 674 |
// deal with algo bits
|
| 675 |
BitMask64 l1amask;
|
| 676 |
DecisionWord dw(gtRecord->decisionWord());
|
| 677 |
FillBitAMask(l1amask, dw);
|
| 678 |
l1ABits_->SetBits(l1amask);
|
| 679 |
|
| 680 |
// deal with tech bits
|
| 681 |
BitMask64 l1tmask;
|
| 682 |
TechnicalTriggerWord tw(gtRecord->technicalTriggerWord());
|
| 683 |
FillBitTMask(l1tmask, tw);
|
| 684 |
l1TBits_->SetBits(l1tmask);
|
| 685 |
|
| 686 |
BitMask64 l1abmask;
|
| 687 |
DecisionWord dwb(gtRecord->decisionWordBeforeMask());
|
| 688 |
FillBitAMask(l1abmask, dwb);
|
| 689 |
l1ABits2_->SetBits(l1abmask);
|
| 690 |
|
| 691 |
// deal with tech bits
|
| 692 |
BitMask64 l1tbmask;
|
| 693 |
TechnicalTriggerWord twb(gtRecord->technicalTriggerWordBeforeMask());
|
| 694 |
FillBitTMask(l1tbmask, twb);
|
| 695 |
l1TBits2_->SetBits(l1tbmask);
|
| 696 |
|
| 697 |
// get L1 trigger readout record information if wanted
|
| 698 |
if (l1GTRRName_.size()==0)
|
| 699 |
return;
|
| 700 |
|
| 701 |
Handle<L1GlobalTriggerReadoutRecord> gtReadoutRec;
|
| 702 |
GetProduct(l1GTRRName_, gtReadoutRec, event);
|
| 703 |
|
| 704 |
l1AbArr_->Reset();
|
| 705 |
const std::vector<L1GtFdlWord> &m_gtFdlWord(gtReadoutRec->gtFdlVector());
|
| 706 |
for (std::vector<L1GtFdlWord>::const_iterator itBx = m_gtFdlWord.begin();
|
| 707 |
itBx != m_gtFdlWord.end(); ++itBx) {
|
| 708 |
BitMask64 amask;
|
| 709 |
DecisionWord dw((*itBx).finalOR());
|
| 710 |
FillBitAMask(amask,dw);
|
| 711 |
mithep::L1TriggerMask *nm = l1AbArr_->Allocate();
|
| 712 |
new (nm) mithep::L1TriggerMask(amask);
|
| 713 |
nm->SetBx((*itBx).bxInEvent());
|
| 714 |
}
|
| 715 |
|
| 716 |
l1TbArr_->Reset();
|
| 717 |
for (std::vector<L1GtFdlWord>::const_iterator itBx = m_gtFdlWord.begin();
|
| 718 |
itBx != m_gtFdlWord.end(); ++itBx) {
|
| 719 |
BitMask64 amask;
|
| 720 |
TechnicalTriggerWord dw((*itBx).gtTechnicalTriggerWord());
|
| 721 |
FillBitTMask(amask,dw);
|
| 722 |
mithep::L1TriggerMask *nm = l1TbArr_->Allocate();
|
| 723 |
new (nm) mithep::L1TriggerMask(amask);
|
| 724 |
nm->SetBx((*itBx).bxInEvent());
|
| 725 |
}
|
| 726 |
}
|
| 727 |
|
| 728 |
//--------------------------------------------------------------------------------------------------
|
| 729 |
const char *FillerMetaInfos::Istr() const
|
| 730 |
{
|
| 731 |
// Return instance if instance > 0.
|
| 732 |
|
| 733 |
if (instance_==0)
|
| 734 |
return "";
|
| 735 |
|
| 736 |
return Form("_%d",instance_);
|
| 737 |
}
|
