ATLAS Offline Software
xAODMenuWriter.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 
6 // Gaudi/Athena include(s):
7 #include "AthenaKernel/errorcheck.h"
8 
9 // Trigger configuration include(s):
10 #include "TrigConfL1Data/CTPConfig.h"
11 #include "TrigConfL1Data/Menu.h"
12 #include "TrigConfL1Data/TriggerItem.h"
13 #include "TrigConfL1Data/PrescaleSet.h"
14 #include "TrigConfL1Data/BunchGroupSet.h"
15 #include "TrigConfL1Data/BunchGroup.h"
16 #include "TrigConfHLTData/HLTChainList.h"
17 #include "TrigConfHLTData/HLTChain.h"
18 #include "TrigConfHLTData/HLTSignature.h"
19 #include "TrigConfHLTData/HLTTriggerElement.h"
20 #include "TrigConfHLTData/HLTSequenceList.h"
21 
22 // EDM include(s):
23 #include "xAODTrigger/TrigConfKeys.h"
24 #include "xAODTrigger/TriggerMenu.h"
25 #include "xAODTrigger/TriggerMenuAuxContainer.h"
26 
27 // Local include(s):
28 #include "xAODMenuWriter.h"
29 #include "PrintVectorHelper.h"
30 
31 namespace TrigConf {
32 
33  xAODMenuWriter::xAODMenuWriter( const std::string& name,
34  ISvcLocator* svcLoc )
35  : AthAlgorithm( name, svcLoc ),
36  m_trigConf( "TrigConfigSvc", name ),
37  m_metaStore( "MetaDataStore", name ),
38  m_tmc( 0 ) {
39 
40  declareProperty( "EventObjectName", m_eventName = "TrigConfKeys" );
41  declareProperty( "MetaObjectName", m_metaName = "TriggerMenu" );
42  declareProperty( "OverwriteEventObj", m_overwriteEventObj = false );
43 
44  declareProperty( "TrigConfigSvc", m_trigConf );
45  declareProperty( "MetaDataStore", m_metaStore );
46  }
47 
48  StatusCode xAODMenuWriter::initialize() {
49 
50  // Greet the user:
51  ATH_MSG_INFO( "Initialising" );
52  ATH_MSG_DEBUG( "EventObjectName = " << m_eventName );
53  ATH_MSG_DEBUG( "MetaObjectName = " << m_metaName );
54  ATH_MSG_DEBUG( "OverwriteEventObj = "
55  << ( m_overwriteEventObj ? "Yes" : "No" ) );
56  ATH_MSG_VERBOSE( "TrigConfigSvc = " << m_trigConf );
57  ATH_MSG_VERBOSE( "MetaDataStore = " << m_metaStore );
58 
59  // Retrieve the necessary service(s):
60  CHECK( m_trigConf.retrieve() );
61  CHECK( m_metaStore.retrieve() );
62 
63  // Clear the internal cache variable:
64  m_convertedKeys.clear();
65 
66  // Create an empty trigger menu container:
67  xAOD::TriggerMenuAuxContainer* aux = new xAOD::TriggerMenuAuxContainer();
68  m_tmc = new xAOD::TriggerMenuContainer();
69  m_tmc->setStore( aux );
70 
71  // Record the trigger configuration metadata into it:
72  CHECK( m_metaStore->record( aux, m_metaName + "Aux." ) );
73  CHECK( m_metaStore->record( m_tmc, m_metaName ) );
74 
75  // Return gracefully:
76  return StatusCode::SUCCESS;
77  }
78 
79  StatusCode xAODMenuWriter::execute() {
80 
81  // Check if the event-level object exists already:
82  if( ( ! evtStore()->contains< xAOD::TrigConfKeys >( m_eventName ) ) ||
83  m_overwriteEventObj ) {
84 
85  // Create the trigger configuration keys for the event data:
86  xAOD::TrigConfKeys* keys =
87  new xAOD::TrigConfKeys( m_trigConf->masterKey(),
88  m_trigConf->lvl1PrescaleKey(),
89  m_trigConf->hltPrescaleKey() );
90 
91  // Now record it:
92  if( m_overwriteEventObj ) {
93  CHECK( evtStore()->overwrite( keys, m_eventName, false ) );
94  } else {
95  CHECK( evtStore()->record( keys, m_eventName ) );
96  }
97  }
98 
99  // Create the keys in the "internal format":
100  TrigKey_t ckeys =
101  std::make_pair( m_trigConf->masterKey(),
102  std::make_pair( m_trigConf->lvl1PrescaleKey(),
103  m_trigConf->hltPrescaleKey() ) );
104 
105  // Check if we converted this configuration already:
106  if( ! m_convertedKeys.insert( ckeys ).second ) {
107  ATH_MSG_VERBOSE( "Configuration with keys SMK: "
108  << ckeys.first << ", L1PSK: " << ckeys.second.first
109  << ", HLTPSK: " << ckeys.second.second
110  << " already translated" );
111  return StatusCode::SUCCESS;
112  }
113 
114  // Tell the user what's happening:
115  ATH_MSG_INFO( "Converting configuration with keys SMK: "
116  << ckeys.first << ", L1PSK: " << ckeys.second.first
117  << ", HLTPSK: " << ckeys.second.second );
118 
119  // Apparently not, so let's make a new object:
120  xAOD::TriggerMenu* menu = new xAOD::TriggerMenu();
121  m_tmc->push_back( menu );
122 
123  //
124  // Set its keys:
125  //
126  menu->setSMK( m_trigConf->masterKey() );
127  menu->setL1psk( m_trigConf->lvl1PrescaleKey() );
128  menu->setHLTpsk( m_trigConf->hltPrescaleKey() );
129 
130  //
131  // Set its LVL1 information:
132  //
133  ATH_MSG_DEBUG( "Filling LVL1 information" );
134  std::vector< uint16_t > ctpIds;
135  std::vector< std::string > itemNames;
136  std::vector< float > itemPrescales;
137  TrigConf::ItemContainer::const_iterator item_itr =
138  m_trigConf->ctpConfig()->menu().items().begin();
139  TrigConf::ItemContainer::const_iterator item_end =
140  m_trigConf->ctpConfig()->menu().items().end();
141  std::vector< float > prescales =
142  m_trigConf->ctpConfig()->prescaleSet().prescales_float();
143  for( ; item_itr != item_end; ++item_itr ) {
144 
145  // Extract the information:
146  ctpIds.push_back( ( *item_itr )->ctpId() );
147  itemNames.push_back( ( *item_itr )->name() );
148  itemPrescales.push_back( prescales[ ( *item_itr )->ctpId() ] );
149 
150  // Some verbose information:
151  ATH_MSG_VERBOSE( " \"" << itemNames.back() << "\" CTP Id = "
152  << ctpIds.back() << ", prescale = "
153  << itemPrescales.back() );
154  }
155  menu->setItemCtpIds( ctpIds );
156  menu->setItemNames( itemNames );
157  menu->setItemPrescales( itemPrescales );
158 
159  //
160  // Set its HLT information:
161  //
162  ATH_MSG_DEBUG( "Filling HLT information" );
163  std::vector< uint16_t > chainIds;
164  std::vector< std::string > chainNames, chainParentNames;
165  std::vector< float > chainPrescales, chainRerunPrescales,
166  chainPassthroughPrescales;
167 
168  std::vector< std::vector< uint32_t > > chainSignatureCounters;
169  std::vector< std::vector< int > > chainSignatureLogics;
170  std::vector< std::vector< std::vector< std::string > > > chainSignatureOutputTEs;
171  std::vector< std::vector< std::string > > chainSignatureLabels;
172 
173  TrigConf::HLTChainList::const_iterator chain_itr =
174  m_trigConf->chains().begin();
175  TrigConf::HLTChainList::const_iterator chain_end =
176  m_trigConf->chains().end();
177  for( ; chain_itr != chain_end; ++chain_itr ) {
178 
179  // Extract the information:
180  chainIds.push_back( ( *chain_itr )->chain_counter() );
181  chainNames.push_back( ( *chain_itr )->chain_name() );
182  chainParentNames.push_back( ( *chain_itr )->lower_chain_name() );
183  chainPrescales.push_back( ( *chain_itr )->prescale() );
184  chainRerunPrescales.push_back(
185  ( *chain_itr )->prescales().getRerunPrescale("").second );
186  chainPassthroughPrescales.push_back( ( *chain_itr )->pass_through() );
187 
188  std::vector<uint32_t> counters;
189  std::vector<int> logics;
190  std::vector<std::vector<std::string> > outputTEs;
191  std::vector<std::string> labels;
192 
193  ATH_MSG_VERBOSE((*chain_itr)->chain_name() << " has " << (*chain_itr)->signatureList().size() << " signatures");
194  for(auto& signature : (*chain_itr)->signatureList() ){
195  uint32_t cntr = signature->signature_counter();
196  counters.push_back(cntr);
197  logics.push_back(signature->logic());
198  labels.push_back(signature->label());
199  std::vector<std::string> outputTEids;
200  for(auto& outputTE : signature->outputTEs()){
201  outputTEids.push_back(outputTE->name());
202  }
203  outputTEs.push_back(outputTEids);
204  ATH_MSG_VERBOSE("converted this signature: " << *signature);
205  }
206  chainSignatureCounters.push_back(counters);
207  chainSignatureLogics.push_back(logics);
208  chainSignatureOutputTEs.push_back(outputTEs);
209  chainSignatureLabels.push_back(labels);
210 
211  // Some verbose information:
212  ATH_MSG_VERBOSE( " \"" << chainNames.back() << "\" Chain Id = "
213  << chainIds.back() << ", parent name = \""
214  << chainParentNames.back() << "\", prescale = "
215  << chainPrescales.back() << ", re-run prescale = "
216  << chainRerunPrescales.back()
217  << ", pass-through presclale = "
218  << chainPassthroughPrescales.back() );
219  }
220  menu->setChainIds( chainIds );
221  menu->setChainNames( chainNames );
222  menu->setChainParentNames( chainParentNames );
223  menu->setChainPrescales( chainPrescales );
224  menu->setChainRerunPrescales( chainRerunPrescales );
225  menu->setChainPassthroughPrescales( chainPassthroughPrescales );
226  menu->setChainSignatureCounters(chainSignatureCounters);
227 
228  menu->setChainSignatureCounters(chainSignatureCounters);
229  menu->setChainSignatureLogics(chainSignatureLogics);
230  menu->setChainSignatureOutputTEs(chainSignatureOutputTEs);
231  menu->setChainSignatureLabels(chainSignatureLabels);
232 
233  //
234  // Set its sequence information:
235  //
236  ATH_MSG_DEBUG( "Filling sequence information" );
237  auto& sequenceList = m_trigConf->sequences();
238  std::vector<std::vector<std::string> > sequenceInputTEs;
239  std::vector<std::string> sequenceOutputTE;
240  std::vector<std::vector<std::string> > sequenceAlgorithms;
241 
242  for(auto& seq : sequenceList){
243  std::vector<std::string> inputTEs;
244  for(auto& input : seq->inputTEs()) inputTEs.push_back(input->name());
245  sequenceInputTEs.push_back(inputTEs);
246  sequenceAlgorithms.push_back(seq->algorithms());
247  sequenceOutputTE.push_back(seq->outputTE()->name());
248 
249  ATH_MSG_VERBOSE("original sequence: \n" << *seq);
250 
251  ATH_MSG_VERBOSE("added sequence with: ");
252  ATH_MSG_VERBOSE(" inputTEs: " << sequenceInputTEs.back());
253  ATH_MSG_VERBOSE(" algos: " << sequenceAlgorithms.back());
254  ATH_MSG_VERBOSE(" outputTE: " << sequenceOutputTE.back());
255  }
256 
257  menu->setSequenceInputTEs(sequenceInputTEs);
258  menu->setSequenceOutputTEs(sequenceOutputTE);
259  menu->setSequenceAlgorithms(sequenceAlgorithms);
260 
261  //
262  // Set its bunch-group information:
263  //
264  ATH_MSG_DEBUG( "Filling bunch-group information" );
265  std::vector< std::vector< uint16_t > > bgs;
266  std::vector< BunchGroup >::const_iterator bg_itr =
267  m_trigConf->bunchGroupSet()->bunchGroups().begin();
268  std::vector< BunchGroup >::const_iterator bg_end =
269  m_trigConf->bunchGroupSet()->bunchGroups().end();
270  for( int i = 0; bg_itr != bg_end; ++bg_itr, ++i ) {
271 
272  // Extract the information. Unfortunately we need to make
273  // and explicit conversion by hand.
274  const std::vector< uint16_t > bunches( bg_itr->bunches().begin(),
275  bg_itr->bunches().end() );
276  bgs.push_back( bunches );
277 
278  // Some verbose information:
279  ATH_MSG_VERBOSE( " Bunch group " << i << " bunches: "
280  << bgs.back() );
281  }
282  menu->setBunchGroupBunches( bgs );
283 
284  // Return gracefully:
285  return StatusCode::SUCCESS;
286  }
287 
288 } // namespace TrigConf
test_athena_ntuple_filter.seq
seq
filter configuration ## -> we use the special sequence 'AthMasterSeq' which is run before any other a...
Definition: test_athena_ntuple_filter.py:18
xAOD::TriggerMenuContainer
TriggerMenuContainer_v1 TriggerMenuContainer
Define the latest version of the trigger menu container class.
Definition: TriggerMenuContainer.h:17
TriggerItem.h
CTPConfig.h
PrescaleSet.h
TrigConf::xAODMenuWriter::m_trigConf
ServiceHandle< TrigConf::ITrigConfigSvc > m_trigConf
Connection to the trigger configuration service.
Definition: xAODMenuWriter.h:70
HLTChainList.h
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
xAOD::TrigConfKeys
TrigConfKeys_v1 TrigConfKeys
Declare the current version of the trigger configuration keys type.
Definition: TrigConfKeys.h:16
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
TrigConf::xAODMenuWriter::initialize
virtual StatusCode initialize()
Function initialising the algorithm.
Definition: xAODMenuWriter.cxx:48
TriggerMenuAuxContainer.h
HLTChain.h
TrigConf::xAODMenuWriter::xAODMenuWriter
xAODMenuWriter(const std::string &name, ISvcLocator *svcLoc)
Regular Algorithm constructor.
Definition: xAODMenuWriter.cxx:33
Menu.h
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
TrigConf::xAODMenuWriter::TrigKey_t
std::pair< uint32_t, std::pair< uint32_t, uint32_t > > TrigKey_t
Trigger configuration key type (used just internally)
Definition: xAODMenuWriter.h:78
RatesAnalysisFullMenu.prescales
prescales
Definition: RatesAnalysisFullMenu.py:119
TrigConf
Forward iterator to traverse the main components of the trigger configuration.
Definition: Config.h:22
TrigConf::xAODMenuWriter::m_metaStore
ServiceHandle< StoreGateSvc > m_metaStore
Connection to the metadata store.
Definition: xAODMenuWriter.h:72
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
menu
make the sidebar many part of the config
Definition: hcg.cxx:551
beamspotnt.labels
list labels
Definition: bin/beamspotnt.py:1447
TrigConf::xAODMenuWriter::m_overwriteEventObj
bool m_overwriteEventObj
Switch for overwriting existing event-wise objects.
Definition: xAODMenuWriter.h:67
lumiFormat.i
int i
Definition: lumiFormat.py:92
TrigConf::xAODMenuWriter::m_convertedKeys
std::set< TrigKey_t > m_convertedKeys
Trigger configuration keys that are already converted.
Definition: xAODMenuWriter.h:81
xAOD::TriggerMenuAuxContainer
TriggerMenuAuxContainer_v1 TriggerMenuAuxContainer
Define the latest version of the trigger menu auxiliary container class.
Definition: TriggerMenuAuxContainer.h:16
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
PlotPulseshapeFromCool.input
input
Definition: PlotPulseshapeFromCool.py:106
HLTSignature.h
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:422
TrigConf::xAODMenuWriter::execute
virtual StatusCode execute()
Function executing the algorithm.
Definition: xAODMenuWriter.cxx:79
AthAlgorithm
Definition: AthAlgorithm.h:47
TrigConf::name
Definition: HLTChainList.h:35
TriggerMenu.h
BunchGroup.h
BunchGroupSet.h
TrigConf::xAODMenuWriter::m_eventName
std::string m_eventName
StoreGate key for the event object.
Definition: xAODMenuWriter.h:63
xAOD::TrigConfKeys_v1
Class describing the configuration used in a given event.
Definition: TrigConfKeys_v1.h:32
xAOD::TriggerMenu
TriggerMenu_v1 TriggerMenu
Define the latest version of the trigger menu class.
Definition: TriggerMenu.h:16
errorcheck.h
Helpers for checking error return status codes and reporting errors.
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
HLTTriggerElement.h
xAOD::TriggerMenuAuxContainer_v1
Auxiliary store object for TriggerMenuContainer_v1.
Definition: TriggerMenuAuxContainer_v1.h:36
TrigConf::xAODMenuWriter::m_metaName
std::string m_metaName
StoreGate key for the configuration object.
Definition: xAODMenuWriter.h:65
HLTSequenceList.h
PrintVectorHelper.h
TrigConfKeys.h
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
xAOD::TriggerMenu_v1
Class holding one particular trigger configuration.
Definition: TriggerMenu_v1.h:34
TrigConf::xAODMenuWriter::m_tmc
xAOD::TriggerMenuContainer * m_tmc
The configuration object that we are writing.
Definition: xAODMenuWriter.h:75
xAODMenuWriter.h
Generated on Fri Jul 5 2024 21:33:04 for ATLAS Offline Software by   doxygen 1.8.18