ATLAS Offline Software
Loading...
Searching...
No Matches
Public Member Functions | Protected Member Functions | Protected Attributes | Static Protected Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
TBXMLEventWriterTool Class Reference

#include <TBXMLEventWriterTool.h>

Inheritance diagram for TBXMLEventWriterTool:
Collaboration diagram for TBXMLEventWriterTool:

Public Member Functions

 TBXMLEventWriterTool (const std::string &type, const std::string &name, const IInterface *parent)
 ~TBXMLEventWriterTool ()
virtual StatusCode initialize () override
virtual StatusCode writeOut (std::ostream &outStream, std::string_view entryTag=" ")
virtual StatusCode finalize () override
virtual StatusCode finalize (std::ostream &outStream)
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm.
virtual StatusCode sysStart () override
 Handle START transition.
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles.
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
void updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream & msg () const
bool msgLvl (const MSG::Level lvl) const

Protected Member Functions

virtual StatusCode writeRunFiles (const std::string &, unsigned int) override
virtual StatusCode writeEvent (std::ostream &outFile, std::string_view entryTag) override
virtual void openDictionary (std::ostream &outStream, const std::string &dictName, const std::vector< std::string > &listOfElements)
virtual void openDictionary (std::ostream &outStream, const std::string &dictName)
virtual void closeDictionary (std::ostream &outStream)
virtual void addDictElement (std::ostream &outStream, const std::string &theElement, const std::vector< std::string > &listOfElements)
virtual void addAttributes (std::ostream &outStream, const std::string &theElement, const std::vector< std::string > &listOfAttributes)
virtual void openElement (std::ostream &outStream, std::string_view theElement, const std::vector< std::string > &listOfAttr, const std::vector< std::string > &listOfValues)
virtual void closeElement (std::ostream &outStream, const std::string &theElement)
virtual void closeElement (std::ostream &outStream)
virtual void closeAllElements (std::ostream &outStream)
void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed.

Protected Attributes

std::vector< std::string > m_elementList
std::string m_dictionary

Static Protected Attributes

static const std::string m_doubleQuote = "\042"

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t

Private Member Functions

Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes

StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default).
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * > m_vhka
bool m_varHandleArraysDeclared

Detailed Description

Definition at line 19 of file TBXMLEventWriterTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ TBXMLEventWriterTool()

TBXMLEventWriterTool::TBXMLEventWriterTool ( const std::string & type,
const std::string & name,
const IInterface * parent )

Definition at line 17 of file TBXMLEventWriterTool.cxx.

20 : TBXMLWriterToolBase(type,name,parent)
21{
22}
TBXMLWriterToolBase::TBXMLWriterToolBase
TBXMLWriterToolBase(const std::string &type, const std::string &name, const IInterface *parent)
Definition TBXMLWriterToolBase.h:25

◆ ~TBXMLEventWriterTool()

TBXMLEventWriterTool::~TBXMLEventWriterTool ( )

Definition at line 24 of file TBXMLEventWriterTool.cxx.

25{ }

Member Function Documentation

◆ addAttributes()

void TBXMLWriterToolBase::addAttributes ( std::ostream & outStream,
const std::string & theElement,
const std::vector< std::string > & listOfAttributes )
protectedvirtualinherited

Definition at line 91 of file TBXMLWriterToolBase.cxx.

95{
96 outStream << " <!ATTLIST " << theElement << std::endl;
97 for ( unsigned int i=0; i<listOfAttr.size(); i++ )
98 {
99 outStream << " " << listOfAttr[i] << std::endl;
100 }
101 outStream << ">" << std::endl;
102}

◆ addDictElement()

void TBXMLWriterToolBase::addDictElement ( std::ostream & outStream,
const std::string & theElement,
const std::vector< std::string > & listOfElements )
protectedvirtualinherited

Definition at line 57 of file TBXMLWriterToolBase.cxx.

61{
62 outStream << "<!ELEMENT " << theElement;
63 // add document as element
64 if ( listOfElements.size() == 0 )
65 {
66 outStream << ">" << std::endl;
67 }
68 else
69 {
70 // store elements
71 if ( listOfElements[0] == "ANY" ||
72 listOfElements[0] == "EMPTY" ||
73 listOfElements[0] == "ALL" )
74 {
75 outStream << " " << listOfElements[0] << " >" << std::endl;
76 }
77 else
78 {
79 outStream << " (" << listOfElements[0];
80 for ( unsigned int i=1; i<listOfElements.size(); i++ )
81 {
82 outStream << "," << listOfElements[i];
83 }
84 outStream << ") >" << std::endl;
85 }
86 }
87}

◆ closeAllElements()

void TBXMLWriterToolBase::closeAllElements ( std::ostream & outStream)
protectedvirtualinherited

Definition at line 159 of file TBXMLWriterToolBase.cxx.

160{
161 for ( int i=m_elementList.size()-1; i>=0; i-- )
162 {
163 outStream << "</" << m_elementList[i] << ">" << std::endl;
164 }
165 m_elementList.clear();
166}
TBXMLWriterToolBase::m_elementList
std::vector< std::string > m_elementList
Definition TBXMLWriterToolBase.h:107

◆ closeDictionary()

void TBXMLWriterToolBase::closeDictionary ( std::ostream & outStream)
protectedvirtualinherited

Definition at line 50 of file TBXMLWriterToolBase.cxx.

51{
52 outStream << "]>" << std::endl;
53}

◆ closeElement() [1/2]

void TBXMLWriterToolBase::closeElement ( std::ostream & outStream)
protectedvirtualinherited

Definition at line 130 of file TBXMLWriterToolBase.cxx.

131{
132 unsigned int thisSize = m_elementList.size() - 1;
133 outStream << "</" << m_elementList[thisSize] << ">" << std::endl;
134 m_elementList.resize(thisSize);
135}

◆ closeElement() [2/2]

void TBXMLWriterToolBase::closeElement ( std::ostream & outStream,
const std::string & theElement )
protectedvirtualinherited

Definition at line 139 of file TBXMLWriterToolBase.cxx.

141{
142 std::vector<std::string>::iterator inVec =
143 find( m_elementList.begin(), m_elementList.end(), theElement);
144 if ( inVec != m_elementList.end() )
145 {
146 outStream << "</" << (*inVec) << ">" << std::endl;
147 m_elementList.erase(inVec);
148 }
149 else
150 {
151 outStream << "<!-- XML Structural Problem! \n\n"
152 << " cannot find an element " << theElement << "!\n\n"
153 << "-->" << std::endl;
154 }
155}
find
std::string find(const std::string &s)
return a remapped string
Definition hcg.cxx:140

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl,
const SG::VarHandleKeyType &  )
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158 {
159 return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160 hndl.value(),
161 hndl.documentation());
162
163 }
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition AthCommonDataStore.h:145

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145 {
146 typedef typename SG::HandleClassifier<T>::type htype;
147 return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148 }
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition AthCommonDataStore.h:156

◆ detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95{ return m_detStore; }

◆ evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85{ return m_evtStore; }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ finalize() [1/2]

virtual StatusCode TBXMLWriterToolBase::finalize ( )
inlineoverridevirtualinherited

Definition at line 52 of file TBXMLWriterToolBase.h.

53 {
54 return StatusCode::SUCCESS;
55 }

◆ finalize() [2/2]

virtual StatusCode TBXMLWriterToolBase::finalize ( std::ostream & outStream)
inlinevirtualinherited

Definition at line 57 of file TBXMLWriterToolBase.h.

58 {
59 this->closeAllElements(outStream);
60 return this->finalize();
61 }
TBXMLWriterToolBase::closeAllElements
virtual void closeAllElements(std::ostream &outStream)
Definition TBXMLWriterToolBase.cxx:159
TBXMLWriterToolBase::finalize
virtual StatusCode finalize() override
Definition TBXMLWriterToolBase.h:52

◆ initialize()

virtual StatusCode TBXMLWriterToolBase::initialize ( )
inlineoverridevirtualinherited

Reimplemented in TBXMLCaloCellWriterTool.

Definition at line 36 of file TBXMLWriterToolBase.h.

37 {
38 return StatusCode::SUCCESS;
39 }

◆ inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24 {
25 return this->msgStream();
26 }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30 {
31 return this->msgLevel(lvl);
32 }

◆ openDictionary() [1/2]

void TBXMLWriterToolBase::openDictionary ( std::ostream & outStream,
const std::string & dictName )
protectedvirtualinherited

Definition at line 41 of file TBXMLWriterToolBase.cxx.

43{
44 std::vector<std::string> emptyList;
45 this->openDictionary(outStream,dictName, emptyList);
46}
TBXMLWriterToolBase::openDictionary
virtual void openDictionary(std::ostream &outStream, const std::string &dictName, const std::vector< std::string > &listOfElements)
Definition TBXMLWriterToolBase.cxx:18

◆ openDictionary() [2/2]

void TBXMLWriterToolBase::openDictionary ( std::ostream & outStream,
const std::string & dictName,
const std::vector< std::string > & listOfElements )
protectedvirtualinherited

Definition at line 18 of file TBXMLWriterToolBase.cxx.

22{
23 // clean up
24 m_elementList.clear();
25 m_dictionary = dictName;
26
27 // write header
28 outStream << "<?XML version=" << m_doubleQuote
29 << "1" << m_doubleQuote << "?>" << std::endl;
30
31 // write begin of dictionary
32 outStream << "<!DOCTYPE " << dictName
33 << " [" << std::endl;
34
35 // add doctype as element
36 this->addDictElement(outStream,dictName,listOfElements);
37}
TBXMLWriterToolBase::addDictElement
virtual void addDictElement(std::ostream &outStream, const std::string &theElement, const std::vector< std::string > &listOfElements)
Definition TBXMLWriterToolBase.cxx:57
TBXMLWriterToolBase::m_doubleQuote
static const std::string m_doubleQuote
Definition TBXMLWriterToolBase.h:110

◆ openElement()

void TBXMLWriterToolBase::openElement ( std::ostream & outStream,
std::string_view theElement,
const std::vector< std::string > & listOfAttr,
const std::vector< std::string > & listOfValues )
protectedvirtualinherited

Definition at line 106 of file TBXMLWriterToolBase.cxx.

112{
113 m_elementList.emplace_back(theElement);
114 outStream << "<" << theElement;
115 if ( listOfAttr.size() > 0 && listOfValues.size() == listOfAttr.size() )
116 {
117 for ( unsigned int i=0; i<listOfAttr.size(); i++ )
118 {
119 outStream << " " << listOfAttr[i] << "="
120 << m_doubleQuote
121 << listOfValues[i]
122 << m_doubleQuote;
123 }
124 }
125 outStream << ">" << std::endl;
126}

◆ outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381 {
382 h.renounce();
383 PBASE::renounce (h);
384 }
AthCommonDataStore::renounce
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce(T &h)
Definition AthCommonDataStore.h:380

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364 {
365 handlesArray.renounce();
366 }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )
overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, and AthCheckedComponent<::AthAlgTool >.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308 {
309 // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310 // << " size: " << m_vhka.size() << endmsg;
311 for (auto &a : m_vhka) {
312 std::vector<SG::VarHandleKey*> keys = a->keys();
313 for (auto k : keys) {
314 k->setOwner(this);
315 }
316 }
317 }
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition AthCommonDataStore.h:398

◆ writeEvent()

StatusCode TBXMLEventWriterTool::writeEvent ( std::ostream & outFile,
std::string_view entryTag )
overrideprotectedvirtual

Implements TBXMLWriterToolBase.

Definition at line 28 of file TBXMLEventWriterTool.cxx.

29{
30
31 MsgStream log(msgSvc(),name());
32
33 log << MSG::DEBUG << "EntryTag: "<< entryTag <<endmsg;
34
35 // access some data
36 const EventContext& ctx = Gaudi::Hive::currentContext();
37 unsigned int theRun = ctx.eventID().run_number();
38 unsigned int theEvent = ctx.eventID().event_number();
39 unsigned int theType = 0;
40
42 // Write XML Dictionary //
44
45 // Document type
46 std::vector<std::string> theEventElements;
47 theEventElements.push_back("EventHeader");
48 theEventElements.push_back("(CaloCellContainer*)?");
49 theEventElements.push_back("(BeamWireChambers*)?");
50 theEventElements.push_back("(BeamProfileChambers*)?");
51 theEventElements.push_back("(BeamScintillators*)?");
52 theEventElements.push_back("(TailCatcher*)?");
53 theEventElements.push_back("(PatternUnit*)?");
54 this->openDictionary(outStream,"CTB_EC2Event",theEventElements);
55 std::vector<std::string> theEventAttr;
56 theEventAttr.push_back("name CDATA #REQUIRED");
57 this->addAttributes(outStream,"CTB_EC2Event",theEventAttr);
58
59 // EventHeader
60 std::vector<std::string> theHeaderElements;
61 // theHeaderElements.push_back("TriggerWord?");
62 // theHeaderElements.push_back("TriggerPattern?");
63 this->addDictElement(outStream,"EventHeader",theHeaderElements);
64 std::vector<std::string> theHeaderAttr;
65 theHeaderAttr.push_back("name CDATA #REQUIRED");
66 theHeaderAttr.push_back("run CDATA #REQUIRED");
67 theHeaderAttr.push_back("event CDATA #REQUIRED");
68 theHeaderAttr.push_back("type CDATA #REQUIRED");
69 this->addAttributes(outStream,"EventHeader",theHeaderAttr);
70
71 // Trigger etc
72 // std::vector<std::string> anyData;
73 // anyData.push_back("ANY");
74 // this->addDictElement(outStream,"TriggerWord",anyData);
75 // this->addDictElement(outStream,"TriggerPattern",anyData);
76
77 // CaloCellContainer
78 std::vector<std::string> anyData;
79 anyData.push_back("ANY");
80 this->addDictElement(outStream,"CaloCellContainer",anyData);
81 std::vector<std::string> theCaloAttr;
82 theCaloAttr.push_back("name CDATA #REQUIRED");
83 theCaloAttr.push_back("ncols CDATA #REQUIRED");
84 theCaloAttr.push_back("nrows CDATA #REQUIRED");
85 theCaloAttr.push_back("idtype ( uint | int | short | ushort ) #REQUIRED");
86 theCaloAttr.push_back("etype ( float | double ) #REQUIRED");
87 this->addAttributes(outStream,"CaloCellContainer",theCaloAttr);
88
89 // BPC Container
90 this->addDictElement(outStream,"BeamProfileChambers",anyData);
91 std::vector<std::string> theBPCAttr;
92 theBPCAttr.push_back("name CDATA #REQUIRED");
93 theBPCAttr.push_back("cols CDATA #REQUIRED");
94 theBPCAttr.push_back("idtype ( uint | int | short | ushort ) #REQUIRED");
95 theBPCAttr.push_back("xtype ( float | double ) #REQUIRED");
96 theBPCAttr.push_back("ytype ( float | double ) #REQUIRED");
97
98 // MWPC Container
99 this->addDictElement(outStream,"BeamWireChambers",anyData);
100 std::vector<std::string> theMWPCAttr;
101 theMWPCAttr.push_back("name CDATA #REQUIRED");
102 theMWPCAttr.push_back("cols CDATA #REQUIRED");
103 theMWPCAttr.push_back("idtype ( uint | int | short | ushort ) #REQUIRED");
104 theMWPCAttr.push_back("xtype ( float | double ) #REQUIRED");
105 theMWPCAttr.push_back("ytype ( float | double ) #REQUIRED");
106
107 // Scintillator Container
108 this->addDictElement(outStream,"BeamScinitllators",anyData);
109 std::vector<std::string> theScintAttr;
110 theScintAttr.push_back("name CDATA #REQUIRED");
111 theScintAttr.push_back("cols CDATA #REQUIRED");
112 theScintAttr.push_back("idtype ( uint | int | short | ushort ) #REQUIRED");
113 theScintAttr.push_back("signal ( float | double ) #REQUIRED");
114
115 // close dictionary
116 this->closeDictionary(outStream);
117
119 // Write Event //
121
122 std::vector<std::string> theEventValues(theEventAttr.size());
123 for ( unsigned int i=0; i<theEventAttr.size(); i++ )
124 {
125 if ( (theEventAttr[i]).find("name") != std::string::npos )
126 {
127 theEventValues[i] = "EventInfo";
128 }
129 theEventAttr[i] =
130 theEventAttr[i].substr(0,theEventAttr[i].find_first_of(" "));
131 }
132 this->openElement(outStream,"EventInfo",theEventAttr,theEventValues);
133
135 // Write EventHeader //
137
138 std::vector<std::string> theHeaderValues(theHeaderAttr.size());
139 for ( unsigned int i=0; i<theHeaderAttr.size(); i++ )
140 {
141 if ( (theHeaderAttr[i]).find("name") != std::string::npos )
142 {
143 theHeaderValues[i] = "EventInfo";
144 }
145 else if ( (theHeaderAttr[i]).find("run") != std::string::npos )
146 {
147 std::ostringstream theValue; theValue << theRun << std::ends;
148 theHeaderValues[i] = theValue.str();
149 }
150 else if ( (theHeaderAttr[i]).find("event") != std::string::npos )
151 {
152 std::ostringstream theValue; theValue << theEvent << std::ends;
153 theHeaderValues[i] = theValue.str();
154 }
155 else if ( (theHeaderAttr[i]).find("type") != std::string::npos )
156 {
157 std::ostringstream theValue; theValue << theType << std::ends;
158 theHeaderValues[i] = theValue.str();
159 }
160 else
161 {
162 theHeaderValues[i] = "unknown";
163 }
164 theHeaderAttr[i] =
165 theHeaderAttr[i].substr(0,theHeaderAttr[i].find_first_of(" "));
166 }
167 // -------------------------- EventHeader
168 this->openElement(outStream,"EventHeader",
169 theHeaderAttr,theHeaderValues);
170 // ----------------------------- TriggerWord
171 // std::vector<std::string> emptyStr;
172 // this->openElement(outStream,"TriggerWord",
173 // emptyStr,emptyStr);
174 // unsigned short theTriggerWord =
175 // (unsigned short) (m_data->getTriggerWord() & 0xffff);
176 // outStream << " 0x"<< setw(4) << setfill(48) << hex << theTriggerWord
177 // << dec << std::endl;
178 // this->closeElement(outStream);
179 // ----------------------------- TriggerPattern
180 // this->openElement(outStream,"TriggerPattern",emptyStr,emptyStr);
181 // outStream << " ";
182 // std::map<std::string,unsigned int>::const_iterator
183 // first = m_triggerBitMap.begin();
184 // std::map<std::string,unsigned int>::const_iterator
185 // last = m_triggerBitMap.end();
186 // for ( ; first != last; first++ )
187 // {
188 // if ( ( theTriggerWord & (*first).second ) == (*first).second )
189 // {
190 // outStream << "\042" << (*first).first << "\042 ";
191 // }
192 // }
193 outStream << std::endl;
194 this->closeElement(outStream);
195
196 // this->closeElement(outStream,"EventHeader");
197 return StatusCode::SUCCESS;
198}
endmsg
#define endmsg
Definition AnalysisConfig_Ntuple.cxx:63
TBXMLWriterToolBase::closeElement
virtual void closeElement(std::ostream &outStream, const std::string &theElement)
Definition TBXMLWriterToolBase.cxx:139
TBXMLWriterToolBase::closeDictionary
virtual void closeDictionary(std::ostream &outStream)
Definition TBXMLWriterToolBase.cxx:50
TBXMLWriterToolBase::openElement
virtual void openElement(std::ostream &outStream, std::string_view theElement, const std::vector< std::string > &listOfAttr, const std::vector< std::string > &listOfValues)
Definition TBXMLWriterToolBase.cxx:106
TBXMLWriterToolBase::addAttributes
virtual void addAttributes(std::ostream &outStream, const std::string &theElement, const std::vector< std::string > &listOfAttributes)
Definition TBXMLWriterToolBase.cxx:91
PowhegPythia8EvtGen_jetjet.theRun
int theRun
Definition PowhegPythia8EvtGen_jetjet.py:11

◆ writeOut()

virtual StatusCode TBXMLWriterToolBase::writeOut ( std::ostream & outStream,
std::string_view entryTag = " " )
inlinevirtualinherited

Definition at line 46 of file TBXMLWriterToolBase.h.

48 {
49 return this->writeEvent(outStream,entryTag);
50 }
TBXMLWriterToolBase::writeEvent
virtual StatusCode writeEvent(std::ostream &theFile, std::string_view entryTag)=0

◆ writeRunFiles()

StatusCode TBXMLEventWriterTool::writeRunFiles ( const std::string & ,
unsigned int  )
overrideprotectedvirtual

Implements TBXMLWriterToolBase.

Definition at line 201 of file TBXMLEventWriterTool.cxx.

203{
204 return StatusCode::SUCCESS;
205}

Member Data Documentation

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

◆ m_dictionary

std::string TBXMLWriterToolBase::m_dictionary
protectedinherited

Definition at line 108 of file TBXMLWriterToolBase.h.

◆ m_doubleQuote

const std::string TBXMLWriterToolBase::m_doubleQuote = "\042"
staticprotectedinherited

Definition at line 110 of file TBXMLWriterToolBase.h.

◆ m_elementList

std::vector<std::string> TBXMLWriterToolBase::m_elementList
protectedinherited

Definition at line 107 of file TBXMLWriterToolBase.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.16.1