JiveXML::AlgoJiveXML Class Reference

Converts Reconstructed Event Data objects into XML files which can be read by, for example, the Atlantis graphics package. More...

#include <AlgoJiveXML.h>

Inheritance diagram for JiveXML::AlgoJiveXML:

Collaboration diagram for JiveXML::AlgoJiveXML:

Public Member Functions
	AlgoJiveXML (const std::string &name, ISvcLocator *pSvcLocator)
StatusCode	initialize ()
	Initialize - called once in the beginning.
StatusCode	execute ()
	Execute - called for every event.
StatusCode	finalize ()
	Finalize called once in the end.
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
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	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
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.

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
Gaudi::Property< std::string >	m_AtlasRelease {this, "AtlasRelease", "unknown", "The Athena release number"}
Gaudi::Property< bool >	m_writeToFile {this, "WriteToFile", true, "Whether XML files shall be produced"}
Gaudi::Property< bool >	m_onlineMode {this, "OnlineMode", false, "Whether an XMLRPC server shall be started"}
Gaudi::Property< bool >	m_writeGeometry {this, "WriteGeometry", false, "Whether Geometry-XML files shall be produced"}
Gaudi::Property< std::string >	m_geometryVersionIn {this, "GeometryVersion", "default", "Geometry version as read from Athena"}
Gaudi::Property< std::vector< std::string > >	m_GeoWriterNames {this, "GeoWriterNames", {"JiveXML::GeometryWriter/GeometryWriter","JiveXML::MuonGeometryWriter/MuonGeometryWriter"}, "The names of the geometry-writer tools"}
Gaudi::Property< bool >	m_ready4PhysicsAtStart {this, "Ready4PhysicsAtStart", false, "ATLAS is ready for physics when this job was launched"}
ToolHandleArray< JiveXML::IDataRetriever >	m_DataRetrieverTools {this, "DataRetrieverTools", {}, ""}
	The list of DataRetrievers.
ToolHandle< JiveXML::IFormatTool >	m_FormatTool {this, "FormatTool", "JiveXML::XMLFormatTool/XMLFormatTool", "Format tool"}
	Handle to the formatting tool, which is passed on to the data retrievers and converts the data into XML.
ToolHandle< JiveXML::IStreamTool >	m_StreamToFileTool {this, "StreamToFileTool", "JiveXML::StreamToFileTool/StreamToFileTool", "Stream to file tool"}
	Streaming tools that pass the formatted XML text into a file, to a server, etc.
ToolHandle< JiveXML::IStreamTool >	m_StreamToServerTool {this, "StreamToServerTool", "JiveXML::StreamServerTool/StreamToServerTool", "Stream to server tool"}
uint32_t	m_previousRunNumber =0
DataObjIDColl	m_extendedExtraObjects
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

Converts Reconstructed Event Data objects into XML files which can be read by, for example, the Atlantis graphics package.

Author

N. Konstantinidis

S. Boeser

Definition at line 30 of file AlgoJiveXML.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

AlgoJiveXML()

JiveXML::AlgoJiveXML::AlgoJiveXML	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 22 of file AlgoJiveXML.cxx.

                                                                          :
    AthAlgorithm(name, pSvcLocator) {}

Member Function Documentation

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::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.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode JiveXML::AlgoJiveXML::execute

(

)

Execute - called for every event.

• retrieve general event information
• call data retrievers
• pass formatted events to streamers

Retrieve all the event header information

Then start a new event with this header information

Now iterate over all the IDataRetrievers and write their data to the xml file by giving it the XMLWriter

Finish the event with a proper footer

Now stream the events to all registered streaming tools

Definition at line 114 of file AlgoJiveXML.cxx.

                                  {
 
    if(m_onlineMode){
      bool isR4PinThisEvent = false;
      // Get the ready4physics bool at the start of this job and for the current time, during the job ATLAS might have become ready for physics, if this is the case we need to stop the jobs and let the partition restart them
      
      // Acquire the Global Interpreter Lock (GIL) to ensure thread safety when interacting with Python objects
      RootUtils::PyGILStateEnsure ensure;
 
      // Import the EventDisplaysOnlineHelpers Python module
      PyObject* pHelper = PyImport_ImportModule("EventDisplaysOnline.EventDisplaysOnlineHelpers");
      if (!pHelper) {
    // Error handling: Print Python exception if import fails
    PyErr_Print();
    ATH_MSG_WARNING("Failed to import EventDisplaysOnline.EventDisplaysOnlineHelpers module");
    return StatusCode::FAILURE;
      } else {
      ATH_MSG_INFO("ready4Physics at start of job: " << m_ready4PhysicsAtStart);
      // Get the "Ready4Physics" function from the module
          PyObject* Ready4Physics = PyObject_GetAttrString(pHelper, "Ready4Physics");
          if (!Ready4Physics || !PyCallable_Check(Ready4Physics)) {
            // Error handling: Print warning if function not found or not callable
            ATH_MSG_WARNING("Could not find or call Ready4Physics function in EventDisplaysOnline.EventDisplaysOnlineHelpers module");
          } else {
            // Call the "Ready4Physics" function
            PyObject* r4p = PyObject_CallFunctionObjArgs(Ready4Physics, NULL);
            if (!r4p) {
              PyErr_Print();
              ATH_MSG_WARNING("Failed to call Ready4Physics function");
            } else {
              // Convert the result to a boolean value
              isR4PinThisEvent = PyObject_IsTrue(r4p);
          ATH_MSG_INFO("isR4PinThisEvent: " << isR4PinThisEvent);
          if(!m_ready4PhysicsAtStart && isR4PinThisEvent){
        ATH_MSG_INFO("ATLAS was not ready for physics at the start of this job, but is now, so stopping job so that the partition can restart the jobs with any new configuration, i.e. after a warm start to pick back up pixel hits");
        return StatusCode::FAILURE;
          }
              Py_DECREF(r4p); // Decrement reference count of the r4p object
            }
          }
          Py_XDECREF(Ready4Physics);
      }
      Py_DECREF(pHelper);
    }// End of if online
    
    //The run and event number of the current event
    unsigned int runNo = 0, lumiBlock = 0;
    uint64_t eventNo=0;
    //Date and time string of the current event
    char dateTime[32];
    //general event property, unused yet
    std::string eventProperty = "default";
 
    // geometry-version/geometry-tag from Athena (sourced via jOs)
    std::string geometryVersion = "default";
    geometryVersion = DataType(m_geometryVersionIn).toString();
    
    //Retrieve eventInfo from StoreGate
    const xAOD::EventInfo* eventInfo = nullptr;
    if (evtStore()->retrieve(eventInfo).isFailure()){
      ATH_MSG_FATAL("Could not find xAODEventInfo" );
      return StatusCode::FAILURE;
    }else{
     ATH_MSG_DEBUG(" xAODEventInfo: runNumber: "  << eventInfo->runNumber()
          << ", eventNumber: " << eventInfo->eventNumber()
          << ", mcChannelNumber: " << eventInfo->mcChannelNumber()
          << ", mcEventNumber: "  << eventInfo->mcEventNumber() // MC: use this instead of runNumber
          << ", lumiBlock: "  << eventInfo->lumiBlock()
          << ", timeStamp: "  << eventInfo->timeStamp()
          << ", bcid: "  << eventInfo->bcid()
          << ", eventTypeBitmask: "  << eventInfo->eventTypeBitmask()
          << ", actualInteractionsPerCrossing: "  << eventInfo->actualInteractionsPerCrossing()
          << ", averageInteractionsPerCrossing: "  << eventInfo->averageInteractionsPerCrossing()
          );
    }
 
    //when running online, if a new run has started stop the jobs and let the partition restart the jobs to pick up any new configuration for the run
    if(m_onlineMode){
      ATH_MSG_INFO("m_previousRunNumber: " << m_previousRunNumber);
      ATH_MSG_INFO("eventInfo->runNumber(): " << eventInfo->runNumber());
      //don't check for first event
      if(m_previousRunNumber!=0){
    if(m_previousRunNumber != eventInfo->runNumber()){
      ATH_MSG_INFO("Got a new run number, a new run has started whilst this job was running, stopping now to let the partition restart the jobs and pick up any new configuration");
      return StatusCode::FAILURE;
    }
      }
      //store run number to look at in the next event
      m_previousRunNumber = eventInfo->runNumber();
    }
    // new treatment of mc_channel_number for mc12
    // from: https://twiki.cern.ch/twiki/bin/viewauth/Atlas/PileupDigitization#Contents_of_Pileup_RDO
    unsigned int mcChannelNo = 0;
    bool firstEv = true;
 
    //+++ Get sub-event info object
    ATH_MSG_DEBUG( "Sub Event Infos: " );
    for (const xAOD::EventInfo::SubEvent& subevt : eventInfo->subEvents()) {
      const xAOD::EventInfo* sevt = subevt.ptr();
      if (sevt) {
        if (firstEv){
          mcChannelNo =  sevt->mcChannelNumber(); // the 'real' mc-channel
          ATH_MSG_DEBUG( " mc_channel from SubEvent   : " << sevt->mcChannelNumber() );
          firstEv = false;
        }
        ATH_MSG_VERBOSE("Sub Event Info:\n  Time         : " << subevt.time()
                        << "  Index        : " << subevt.index()
                        << "  Provenance   : " << subevt.type()                         // This is the provenance stuff: signal, minbias, cavern, etc
                        << "  Run Number   : " << sevt->runNumber()
                        << "  Event Number : " << sevt->eventNumber()
                        << "  ns Offset    : " << sevt->timeStampNSOffset()
                        << "  Lumi Block   : " << sevt->lumiBlock()
                        << "  mc_channel   : " << sevt->mcChannelNumber()
                        << "  BCID         : " << sevt->bcid()
                        << "  Geo version  : " << m_geometryVersionIn
                        );
      }
      else ATH_MSG_VERBOSE("Subevent is null ptr ");
    }
 
    //Get run and event numbers
    runNo   = eventInfo->runNumber();
    eventNo = eventInfo->eventNumber();
 
// Note: 4294967293 is the maximum value for a unsigned long
 
    if ( mcChannelNo != 0 ){ runNo = mcChannelNo + 140000000; } // indicating 'mc14'
    ATH_MSG_DEBUG( " runNumber for filename: " << runNo << ", eventNumber: " << eventNo);
 
    if ( eventInfo->lumiBlock() ){
      lumiBlock = eventInfo->lumiBlock();
    }else{
      lumiBlock = -1; // placeholder
    }
    if ( mcChannelNo != 0 ) lumiBlock = -1; // mask for mc11a
 
    // lumiBlock from mc can be just huge number, ignore then
    if ( lumiBlock > 1000000 ) { lumiBlock = 0; }
 
    //Get timestamp of the event
    //If Grid job not running in CEST or CET, change to UTC
    //Only option to avoid odd timezones. jpt 29Mar11
    size_t found1;
    size_t found2;
    if (eventInfo->timeStamp() > 0) {
      time_t unixtime = (time_t) eventInfo->timeStamp();
      struct tm time;
      localtime_r(&unixtime, &time);
      strftime(dateTime, 32, "%Y-%m-%d %H:%M:%S %Z", &time);
      struct tm utctime;
      gmtime_r(&unixtime, &utctime);
      found1 = (DataType(dateTime).toString().find("CEST"));
      found2 = (DataType(dateTime).toString().find("CET"));
      if ( int(found1)<0 && int(found2)<0 ){ // not found is -1
         strftime(dateTime, 32, "%Y-%m-%d %H:%M:%S UTC", &utctime);
         ATH_MSG_DEBUG( " TIME NOT CET/CEST. Adjusted to:" << dateTime );
      }
    } else {
      dateTime[0] = '\0'; // empty string
    }
    if ( mcChannelNo != 0 ){ dateTime[0] = '\0'; } // mask for mc11a

    if ( m_FormatTool->StartEvent(eventNo, runNo, dateTime, lumiBlock, eventProperty, geometryVersion).isFailure() ){
      ATH_MSG_FATAL("Couldn't start event in FormatTool");
      return StatusCode::FAILURE;
    }

    ATH_MSG_DEBUG("Starting loop over data retrievers" );
    //Loop over data retrievers
    ToolHandleArray<IDataRetriever>::iterator DataRetrieverItr = m_DataRetrieverTools.begin();
    for(; DataRetrieverItr != m_DataRetrieverTools.end(); ++DataRetrieverItr)  {
      //Add try-catch to avoid retrieval to fail on single retriever
      try {
        //Retrieve information and pass it to formatting tool object
        if ((*DataRetrieverItr)->retrieve(m_FormatTool).isFailure()) {
          ATH_MSG_WARNING( "Failed to fill " << (*DataRetrieverItr)->dataTypeName() );
        } else {
          ATH_MSG_DEBUG("Filled: " << (*DataRetrieverItr)->dataTypeName() );
        }
      //Only catch std::exception
      } catch ( std::exception& ex ){
        //Now show some message
        ATH_MSG_FATAL("Caught exception in " << (*DataRetrieverItr)->name()
                          << " while retrieving data for " << (*DataRetrieverItr)->dataTypeName()
                          << " : " << ex.what() );
        //and return with an error
        return StatusCode::FAILURE;
      }
    }
    ATH_MSG_DEBUG( "Finished loop over data retrievers" );

    if ( m_FormatTool->EndEvent().isFailure() ){
      ATH_MSG_WARNING( "Couldn't end event in FormatTool" );
      return StatusCode::FAILURE;
    }

    if(m_writeToFile){
      ATH_MSG_DEBUG("Streaming event to file");
      if ( (m_StreamToFileTool->StreamEvent(eventNo, runNo, m_FormatTool->getFormattedEvent()).isFailure() )){
        ATH_MSG_WARNING( "Could not stream event to file" );
      }
    }
    if(m_onlineMode){
      ATH_MSG_DEBUG("Streaming event to server");
      if ( (m_StreamToServerTool->StreamEvent(eventNo, runNo, m_FormatTool->getFormattedEvent()).isFailure() )){
        ATH_MSG_WARNING( "Could not stream event to server" );
      }
    }
 
    return StatusCode::SUCCESS;
  }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::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

extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return Algorithm::extraOutputDeps();
}

finalize()

StatusCode JiveXML::AlgoJiveXML::finalize

(

)

Finalize called once in the end.

• release all tools

Release all the tools

Definition at line 346 of file AlgoJiveXML.cxx.

                                   {
 
    ATH_MSG_VERBOSE( "finalize()" );

    m_DataRetrieverTools.release().ignore();
    m_FormatTool.release().ignore();
    m_StreamToFileTool.release().ignore();
    m_StreamToServerTool.release().ignore();
 
    return StatusCode::SUCCESS;
  }

initialize()

StatusCode JiveXML::AlgoJiveXML::initialize

(

)

Initialize - called once in the beginning.

• Get StoreGate service
• Get GeometryWriters and write geometry if asked for
• Get the formatting tool
• Get the data retrievers
• Get the streaming tools, including defaults if asked for

Get the geometry writer tools and write geometries

Loop over names

Get a tool handle and retrieve the tool

Write geometry

Release tool

Get the formatting tools

Add default file streaming tools if requested

Get the streaming tools

Definition at line 32 of file AlgoJiveXML.cxx.

                                    {
 
    //be verbose
    ATH_MSG_VERBOSE("Initialize()");

    if(m_writeGeometry){
 
      ATH_MSG_DEBUG("Writing geometry to file");

      std::vector<std::string>::iterator GeoWriterNameItr = m_GeoWriterNames.begin();
      for ( ; GeoWriterNameItr != m_GeoWriterNames.end(); ++GeoWriterNameItr){

 
        ToolHandle<IGeometryWriter> GeometryWriter(*GeoWriterNameItr);
        if ( GeometryWriter.retrieve().isFailure() ){
          ATH_MSG_WARNING("Unable to locate "<<GeometryWriter.name()<<" tool");
        } else {
          if ( GeometryWriter->writeGeometry().isFailure() ){
            ATH_MSG_WARNING("Unable to write geometry");
          }
          if ( GeometryWriter.release().isFailure() ){
            ATH_MSG_WARNING("Unable to release tool GeometryWriter");
          }
        }
      }
    }

    ATH_MSG_DEBUG("Retrieving XML format tool");
 
    //Retrieve the format tool
    ATH_CHECK(m_FormatTool.retrieve());
 
    //Setting the tags
    if ( m_FormatTool->SetTag( TagType("Release",m_AtlasRelease)).isFailure() ){
      ATH_MSG_WARNING( "Couldn't set Release version" );
    }

    ATH_MSG_DEBUG("Retrieving streaming tools");
    if (m_writeToFile){
      ATH_MSG_INFO("Retrieving default file streaming tool");
      ATH_CHECK(m_StreamToFileTool.retrieve());
    }
    ATH_MSG_INFO("online " << m_onlineMode);
    if (m_onlineMode){
      ATH_MSG_INFO("Retrieving default server streaming tool");
      ATH_CHECK(m_StreamToServerTool.retrieve());
   }
 
  
    ATH_MSG_INFO("Retrieving data from " << m_DataRetrieverTools.size() << " tools" );
 
    ATH_MSG_INFO("List property settings: ");
    ATH_MSG_INFO("AtlasRelease: " << m_AtlasRelease);
    ATH_MSG_INFO("WriteToFile: " << m_writeToFile);
    ATH_MSG_INFO("OnlineMode: " << m_onlineMode);
    ATH_MSG_INFO("WriteGeometry: " << m_writeGeometry);
    ATH_MSG_INFO("GeometryVersion: " << m_geometryVersionIn);
    ATH_MSG_INFO("GeoWriterNames: "  << m_GeoWriterNames );
 
    return StatusCode::SUCCESS;
  }

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::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< Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::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< Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, and PyAthena::Alg.

Definition at line 66 of file AthAlgorithm.cxx.

                                       {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::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< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_AtlasRelease

Gaudi::Property<std::string> JiveXML::AlgoJiveXML::m_AtlasRelease {this, "AtlasRelease", "unknown", "The Athena release number"}

private

Definition at line 43 of file AlgoJiveXML.h.

{this, "AtlasRelease", "unknown", "The Athena release number"};

m_DataRetrieverTools

ToolHandleArray<JiveXML::IDataRetriever> JiveXML::AlgoJiveXML::m_DataRetrieverTools {this, "DataRetrieverTools", {}, ""}

private

The list of DataRetrievers.

This is initialised using the list of names supplied by the jobOptions. DataRetrievers are AlgTools residing in the corresponding sub-detector packages (e.g. TrackRetriever in InDetJiveXML).

Definition at line 55 of file AlgoJiveXML.h.

{this, "DataRetrieverTools", {}, ""};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

m_FormatTool

ToolHandle<JiveXML::IFormatTool> JiveXML::AlgoJiveXML::m_FormatTool {this, "FormatTool", "JiveXML::XMLFormatTool/XMLFormatTool", "Format tool"}

private

Handle to the formatting tool, which is passed on to the data retrievers and converts the data into XML.

Definition at line 61 of file AlgoJiveXML.h.

{this, "FormatTool", "JiveXML::XMLFormatTool/XMLFormatTool", "Format tool"};

m_geometryVersionIn

Gaudi::Property<std::string> JiveXML::AlgoJiveXML::m_geometryVersionIn {this, "GeometryVersion", "default", "Geometry version as read from Athena"}

private

Definition at line 47 of file AlgoJiveXML.h.

{this, "GeometryVersion", "default", "Geometry version as read from Athena"};

m_GeoWriterNames

Gaudi::Property<std::vector<std::string> > JiveXML::AlgoJiveXML::m_GeoWriterNames {this, "GeoWriterNames", {"JiveXML::GeometryWriter/GeometryWriter","JiveXML::MuonGeometryWriter/MuonGeometryWriter"}, "The names of the geometry-writer tools"}

private

Definition at line 48 of file AlgoJiveXML.h.

{this, "GeoWriterNames", {"JiveXML::GeometryWriter/GeometryWriter","JiveXML::MuonGeometryWriter/MuonGeometryWriter"}, "The names of the geometry-writer tools"};

m_onlineMode

Gaudi::Property<bool> JiveXML::AlgoJiveXML::m_onlineMode {this, "OnlineMode", false, "Whether an XMLRPC server shall be started"}

private

Definition at line 45 of file AlgoJiveXML.h.

{this, "OnlineMode", false, "Whether an XMLRPC server shall be started"};

m_previousRunNumber

uint32_t JiveXML::AlgoJiveXML::m_previousRunNumber =0

private

Definition at line 70 of file AlgoJiveXML.h.

m_ready4PhysicsAtStart

Gaudi::Property<bool> JiveXML::AlgoJiveXML::m_ready4PhysicsAtStart {this, "Ready4PhysicsAtStart", false, "ATLAS is ready for physics when this job was launched"}

private

Definition at line 49 of file AlgoJiveXML.h.

{this, "Ready4PhysicsAtStart", false, "ATLAS is ready for physics when this job was launched"};

m_StreamToFileTool

ToolHandle<JiveXML::IStreamTool> JiveXML::AlgoJiveXML::m_StreamToFileTool {this, "StreamToFileTool", "JiveXML::StreamToFileTool/StreamToFileTool", "Stream to file tool"}

private

Streaming tools that pass the formatted XML text into a file, to a server, etc.

Definition at line 67 of file AlgoJiveXML.h.

{this, "StreamToFileTool", "JiveXML::StreamToFileTool/StreamToFileTool", "Stream to file tool"};

m_StreamToServerTool

ToolHandle<JiveXML::IStreamTool> JiveXML::AlgoJiveXML::m_StreamToServerTool {this, "StreamToServerTool", "JiveXML::StreamServerTool/StreamToServerTool", "Stream to server tool"}

private

Definition at line 68 of file AlgoJiveXML.h.

{this, "StreamToServerTool", "JiveXML::StreamServerTool/StreamToServerTool", "Stream to server tool"};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_writeGeometry

Gaudi::Property<bool> JiveXML::AlgoJiveXML::m_writeGeometry {this, "WriteGeometry", false, "Whether Geometry-XML files shall be produced"}

private

Definition at line 46 of file AlgoJiveXML.h.

{this, "WriteGeometry", false, "Whether Geometry-XML files shall be produced"};

m_writeToFile

Gaudi::Property<bool> JiveXML::AlgoJiveXML::m_writeToFile {this, "WriteToFile", true, "Whether XML files shall be produced"}

private

Definition at line 44 of file AlgoJiveXML.h.

{this, "WriteToFile", true, "Whether XML files shall be produced"};

---

The documentation for this class was generated from the following files:

• AlgoJiveXML.h
• AlgoJiveXML.cxx