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