AthenaPoolCnvSvc Class Reference

This class provides the interface between Athena and PoolSvc. More...

#include <AthenaPoolCnvSvc.h>

Inheritance diagram for AthenaPoolCnvSvc:

Collaboration diagram for AthenaPoolCnvSvc:

Public Member Functions
virtual StatusCode	initialize () override
	Required of all Gaudi Services.
virtual StatusCode	io_reinit () override
virtual StatusCode	finalize () override
	Required of all Gaudi Services.
virtual StatusCode	io_finalize () override
virtual StatusCode	stop () override
virtual StatusCode	createObj (IOpaqueAddress *pAddress, DataObject *&refpObject) override
	Implementation of IConversionSvc: Create the transient representation of an object from persistent state.
virtual StatusCode	createRep (DataObject *pObject, IOpaqueAddress *&refpAddress) override
	Implementation of IConversionSvc: Convert the transient object to the requested representation.
virtual StatusCode	fillRepRefs (IOpaqueAddress *pAddress, DataObject *pObject) override
	Implementation of IConversionSvc: Resolve the references of the converted object.
virtual StatusCode	connectOutput (const std::string &outputConnectionSpec, const std::string &openMode) override
	Implementation of IConversionSvc: Connect to the output connection specification with open mode.
virtual StatusCode	connectOutput (const std::string &outputConnectionSpec) override
	Implementation of IConversionSvc: Connect to the output connection specification with open mode.
virtual StatusCode	commitOutput (const std::string &outputConnectionSpec, bool doCommit) override
	Implementation of IConversionSvc: Commit pending output.
virtual StatusCode	disconnectOutput (const std::string &outputConnectionSpec) override
	Disconnect to the output connection.
virtual IPoolSvc *	getPoolSvc () override
virtual Token *	registerForWrite (Placement *placement, const void *obj, const RootType &classDesc) override
virtual void	setObjPtr (void *&obj, const Token *token) override
virtual bool	useDetailChronoStat () const override
StatusCode	createAddress (long svcType, const CLID &clid, const std::string *par, const unsigned long *ip, IOpaqueAddress *&refpAddress) override
	Create a Generic address using explicit arguments to identify a single object.
virtual StatusCode	createAddress (long svcType, const CLID &clid, const std::string &refAddress, IOpaqueAddress *&refpAddress) override
	Create address from string form.
virtual StatusCode	convertAddress (const IOpaqueAddress *pAddress, std::string &refAddress) override
	Convert address to string form.
virtual StatusCode	decodeOutputSpec (std::string &connectionSpec, int &outputTech) const override
	Extract/deduce the DB technology from the connection string/file specification.
virtual StatusCode	registerCleanUp (IAthenaPoolCleanUp *cnv) override
	Implement registerCleanUp to register a IAthenaPoolCleanUp to be called during cleanUp.
virtual StatusCode	cleanUp (const std::string &connection) override
	Implement cleanUp to call all registered IAthenaPoolCleanUp cleanUp() function.
virtual StatusCode	setInputAttributes (const std::string &fileName) override
	Set the input file attributes, if any are requested from jobOpts.
virtual void	handle (const Incident &incident) override
	Implementation of IIncidentListener: Handle for EndEvent incidence.
void	flushDataHeaderForms (const std::string &streamName="*")
	Tell DataHeaderCnv to write out all DataHeaderForms for a given streamName (default is all)
	AthenaPoolCnvSvc (const std::string &name, ISvcLocator *pSvcLocator)
	Standard Service Constructor.
virtual	~AthenaPoolCnvSvc ()=default
	Destructor.

Protected Member Functions
unsigned	outputContextId (const std::string &outputConnection)

Protected Attributes
PMonUtils::BasicStopWatchResultMap_t	m_chronoMap {}
	Map that holds chrono information.
Gaudi::Property< bool >	m_persSvcPerOutput {this,"PersSvcPerOutput",true}
	PersSvcPerOutput, boolean property to use multiple persistency services, one per output stream.
Gaudi::Property< std::string >	m_persSvcPerInputType {this,"PersSvcPerInputType",""}
	PersSvcPerInputType, string property, tree name to use multiple persistency services, one per input type.
std::mutex	m_mutex
Gaudi::Property< int >	m_numberEventsPerWrite {this,"NumberEventsPerWrite",-1}
	To use MetadataSvc to merge data placed in a certain container When using TMemFile call Write on number of Events, respecting CollectionTree auto_flush.
Gaudi::Property< bool >	m_oneDataHeaderForm { this, "OneDataHeaderForm", false }
	If true, use only one DataHeaderForm per Stream.
Gaudi::Property< int >	m_DHFormCacheSize { this, "maxDHFormCacheSize", 100 }
	Property for DataHeaderCnv input DHForm cache size.
Gaudi::Property< bool >	m_DHFilterAliases { this, "doFilterDHAliases", true }
	Flag to control SG alias filtering when writing out DataHeader (see DataHeaderCnv_p6)

Private Member Functions
void	extractPoolAttributes (const Gaudi::Property< std::vector< std::string > > &property, std::vector< std::vector< std::string > > *contAttr, std::vector< std::vector< std::string > > *dbAttr, std::vector< std::vector< std::string > > *domAttr=0) const
	Extract POOL ItechnologySpecificAttributes for Domain, Database and Container from property.
StatusCode	processPoolAttributes (std::vector< std::vector< std::string > > &attr, const std::string &fileName, unsigned long contextId, bool doGet=true, bool doSet=true, bool doClear=true) const
	Set/get technology dependent POOL attributes.

Private Attributes
std::string	m_lastInputFileName
	decoded storage tech requested in "StorageTechnology" property
ServiceHandle< IPoolSvc >	m_poolSvc {this,"PoolSvc","PoolSvc"}
ServiceHandle< IClassIDSvc >	m_clidSvc {this,"ClassIDSvc","ClassIDSvc"}
Gaudi::Property< bool >	m_useDetailChronoStat {this,"UseDetailChronoStat",false}
	UseDetailChronoStat, enable detailed output for time and size statistics for AthenaPOOL: default = false.
Gaudi::Property< std::map< std::string, std::string > >	m_storageTechProp {this, "StorageTechnology", {{"*","ROOTTREEINDEX"}}}
	Default Storage Tech for containers (ROOTTREE, ROOTTREEINDEX, ROOTRNTUPLE)
std::map< std::string, int >	m_storageTechMap
Gaudi::Property< std::string >	m_containerPrefixProp {this,"PoolContainerPrefix","Default"}
	POOL Container name prefix - will be part of or whole TTree/RNTuple name 'Default' takes the prefix from APRDefaults according to StorageTech.
Gaudi::Property< std::string >	m_containerNameHintProp {this,"TopLevelContainerName",""}
	TopLevelContainerName, naming hint policy for top level POOL container: default = "<type>".
Gaudi::Property< std::string >	m_branchNameHintProp {this,"SubLevelBranchName", "<type>/<key>"}
	SubLevelBranchName, naming hint policy for POOL branching: ("" = no branching)
Gaudi::Property< std::vector< std::string > >	m_poolAttr {this,"PoolAttributes",{},"Pool Attributes","OrderedSet<std::string>"}
	Output PoolAttributes, vector with names and values of technology specific attributes for POOL.
std::vector< std::vector< std::string > >	m_domainAttr
std::vector< std::vector< std::string > >	m_databaseAttr
std::vector< std::vector< std::string > >	m_containerAttr
std::vector< unsigned int >	m_contextAttr
std::map< std::string, int >	m_fileCommitCounter
std::map< std::string, int >	m_fileFlushSetting
Gaudi::Property< std::vector< std::string > >	m_inputPoolAttr {this,"InputPoolAttributes",{}}
	Input PoolAttributes, vector with names and values of technology specific attributes for POOL.
std::vector< std::vector< std::string > >	m_inputAttr
Gaudi::Property< std::vector< std::string > >	m_inputPoolAttrPerEvent {this,"PrintInputAttrPerEvt",{}}
	Print input PoolAttributes per event, vector with names of technology specific attributes for POOL to be printed each event.
std::vector< std::vector< std::string > >	m_inputAttrPerEvent
Gaudi::Property< std::vector< std::string > >	m_maxFileSizes {this,"MaxFileSizes",{}}
	MaxFileSizes, vector with maximum file sizes for Athena POOL output files.
long long	m_domainMaxFileSize =std::numeric_limits<long long>::max()
std::map< std::string, long long >	m_databaseMaxFileSize
std::string	m_defContainerType {}
	Default container type (from PoolSvc)

Friends
class	SvcFactory< AthenaPoolCnvSvc >

Detailed Description

This class provides the interface between Athena and PoolSvc.

Definition at line 40 of file AthenaPoolCnvSvc.h.

Constructor & Destructor Documentation

AthenaPoolCnvSvc()

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

Standard Service Constructor.

Definition at line 597 of file AthenaPoolCnvSvc.cxx.

                                                                                  :
    base_class(name, pSvcLocator, pool::POOL_StorageType.type()) {
}

~AthenaPoolCnvSvc()

virtual AthenaPoolCnvSvc::~AthenaPoolCnvSvc ( )

virtualdefault

Destructor.

Member Function Documentation

cleanUp()

StatusCode AthenaPoolCnvSvc::cleanUp ( const std::string & connection )

overridevirtual

Implement cleanUp to call all registered IAthenaPoolCleanUp cleanUp() function.

Definition at line 546 of file AthenaPoolCnvSvc.cxx.

                                                                {
   bool retError = false;
   std::size_t cpos = connection.find(':');
   std::size_t bpos = connection.find('[');
   if (cpos == std::string::npos) {
      cpos = 0;
   } else {
      cpos++;
   }
   if (bpos != std::string::npos) bpos = bpos - cpos;
   const std::string conn = connection.substr(cpos, bpos);
   ATH_MSG_VERBOSE("Cleanup for Connection='"<< conn <<"'");
   for (auto converter : m_cnvs) {
      if (!converter->cleanUp(conn).isSuccess()) {
         ATH_MSG_WARNING("AthenaPoolConverter cleanUp failed.");
         retError = true;
      }
   }
   return(retError ? StatusCode::FAILURE : StatusCode::SUCCESS);
}

commitOutput()

StatusCode AthenaPoolCnvSvc::commitOutput ( const std::string & outputConnectionSpec, bool doCommit )

overridevirtual

Implementation of IConversionSvc: Commit pending output.

Parameters

doCommit

[IN] boolean to force full commit

Definition at line 343 of file AthenaPoolCnvSvc.cxx.

                                                                                              {
   // This is called after all DataObjects are converted.
   std::string outputConnection = outputConnectionSpec.substr(0, outputConnectionSpec.find('['));
   // StopWatch listens from here until the end of this current scope
   PMonUtils::BasicStopWatch stopWatch("commitOutput", m_chronoMap);
   std::unique_lock<std::mutex> lock(m_mutex);
   // Extract the technology
   int tech{0};
   if (!decodeOutputSpec(outputConnection, tech).isSuccess()) {
      ATH_MSG_ERROR("connectOutput FAILED extract file name and technology.");
      return(StatusCode::FAILURE);
   }
   unsigned int contextId = outputContextId(outputConnection);
   if (!processPoolAttributes(m_domainAttr, outputConnection, contextId).isSuccess()) {
      ATH_MSG_DEBUG("commitOutput failed process POOL domain attributes.");
   }
   if (!processPoolAttributes(m_databaseAttr, outputConnection, contextId).isSuccess()) {
      ATH_MSG_DEBUG("commitOutput failed process POOL database attributes.");
   }
   if (!processPoolAttributes(m_containerAttr, outputConnection, contextId).isSuccess()) {
      ATH_MSG_DEBUG("commitOutput failed process POOL container attributes.");
   }
   std::size_t merge = outputConnection.find("?pmerge="); // Used to remove trailing TMemFile
   const std::string baseOutputConnection = outputConnection.substr(0, merge);
   m_fileCommitCounter[baseOutputConnection]++;
   if (merge != std::string::npos && m_fileFlushSetting[baseOutputConnection] > 0 && m_fileCommitCounter[baseOutputConnection] % m_fileFlushSetting[baseOutputConnection] == 0) {
      doCommit = true;
      ATH_MSG_DEBUG("commitOutput sending data.");
   }
 
   // lock.unlock();  //MN: first need to make commitCache slot-specific
   try {
      if (doCommit) {
         if (!m_poolSvc->commit(contextId).isSuccess()) {
            ATH_MSG_ERROR("commitOutput FAILED to commit OutputStream.");
            return(StatusCode::FAILURE);
         }
      } else {
         if (!m_poolSvc->commitAndHold(contextId).isSuccess()) {
            ATH_MSG_ERROR("commitOutput FAILED to commitAndHold OutputStream.");
            return(StatusCode::FAILURE);
         }
      }
   } catch (std::exception& e) {
      ATH_MSG_ERROR("commitOutput - caught exception: " << e.what());
      return(StatusCode::FAILURE);
   }
   if (!this->cleanUp(baseOutputConnection).isSuccess()) {
      ATH_MSG_ERROR("commitOutput FAILED to cleanup converters.");
      return(StatusCode::FAILURE);
   }
   // Check FileSize
   long long int currentFileSize = m_poolSvc->getFileSize(outputConnection, tech, contextId);
   if (m_databaseMaxFileSize.find(outputConnection) != m_databaseMaxFileSize.end()) {
      if (currentFileSize > m_databaseMaxFileSize[outputConnection]) {
         ATH_MSG_WARNING(std::format("FileSize {} > {} for {}", currentFileSize, m_databaseMaxFileSize[outputConnection], outputConnection));
         return(StatusCode::RECOVERABLE);
      }
   } else if (currentFileSize > m_domainMaxFileSize) {
      ATH_MSG_WARNING(std::format("FileSize {} > {} for {}", currentFileSize, m_domainMaxFileSize, outputConnection));
      return(StatusCode::RECOVERABLE);
   }
   return(StatusCode::SUCCESS);
}

connectOutput() [1/2]

StatusCode AthenaPoolCnvSvc::connectOutput ( const std::string & outputConnectionSpec )

overridevirtual

Implementation of IConversionSvc: Connect to the output connection specification with open mode.

Parameters

outputConnectionSpec

[IN] the name of the output connection specification as string.

Definition at line 271 of file AthenaPoolCnvSvc.cxx.

                                                                                {
// This is called before DataObjects are being converted.
   std::string outputConnection = outputConnectionSpec.substr(0, outputConnectionSpec.find('['));
   // Extract the technology
   int tech{0};
   if (!decodeOutputSpec(outputConnection, tech).isSuccess()) {
      ATH_MSG_ERROR("connectOutput FAILED extract file name and technology.");
      return(StatusCode::FAILURE);
   }
   unsigned int contextId = outputContextId(outputConnection);
   try {
      if (!m_poolSvc->connect(pool::ITransaction::UPDATE, contextId).isSuccess()) {
         ATH_MSG_ERROR("connectOutput FAILED to open an UPDATE transaction.");
         return(StatusCode::FAILURE);
      }
   } catch (std::exception& e) {
      ATH_MSG_ERROR("connectOutput - caught exception: " << e.what());
      return(StatusCode::FAILURE);
   }
 
   std::unique_lock<std::mutex> lock(m_mutex);
   if (std::find(m_contextAttr.begin(), m_contextAttr.end(), contextId) == m_contextAttr.end()) {
      std::size_t merge = outputConnection.find("?pmerge="); // Used to remove trailing TMemFile
      int flush = m_numberEventsPerWrite.value();
      m_contextAttr.push_back(contextId);
      // Setting default 'TREE_MAX_SIZE' for ROOT to 1024 GB to avoid file chains.
      std::vector<std::string> maxFileSize;
      maxFileSize.push_back("TREE_MAX_SIZE");
      maxFileSize.push_back("1099511627776L");
      m_domainAttr.emplace_back(std::move(maxFileSize));
      // Extracting OUTPUT POOL ItechnologySpecificAttributes for Domain, Database and Container.
      extractPoolAttributes(m_poolAttr, &m_containerAttr, &m_databaseAttr, &m_domainAttr);
      //FIXME
      for (auto& dbAttrEntry : m_databaseAttr) {
         const std::string& opt = dbAttrEntry[0];
         std::string& data = dbAttrEntry[1];
         const std::string& file = dbAttrEntry[2];
         const std::string& cont = dbAttrEntry[3];
         std::size_t equal = cont.find('='); // Used to remove leading "TTree="
         if (equal == std::string::npos) equal = 0;
         else equal++;
         const auto& prefix = m_containerPrefixProp.value();
         std::size_t colon = prefix.find(':');
         if (colon == std::string::npos) colon = 0; // Used to remove leading technology
         else colon++;
         const auto defaultContName = (tech == pool::ROOTRNTUPLE_StorageType.type()) ? APRDefaults::RNTupleNames::EventData : APRDefaults::TTreeNames::EventData;
         const auto& strProp = (prefix == "Default") ? defaultContName : prefix;
         if (merge != std::string::npos && opt == "TREE_AUTO_FLUSH" && 0 == outputConnection.compare(0, merge, file) &&cont.compare(equal, std::string::npos, strProp, colon) == 0 && data != "int" && data != "DbLonglong" && data != "double" && data != "string") {
            flush = atoi(data.c_str());
            if (flush < 0 && m_numberEventsPerWrite.value() > 0) {
               flush = m_numberEventsPerWrite.value();
               data = std::to_string(flush);
            } else if (flush > 0 && flush < m_numberEventsPerWrite.value()) {
               flush = flush * (int(static_cast<float>(m_numberEventsPerWrite.value()) / flush - 0.5) + 1);
            }
         }
      }
      if (merge != std::string::npos) {
         ATH_MSG_INFO("connectOutput setting auto write for: " << outputConnection << " to " << flush << " events");
         m_fileFlushSetting[outputConnection.substr(0, merge)] = flush;
      }
   }
   if (!processPoolAttributes(m_domainAttr, outputConnection, contextId).isSuccess()) {
      ATH_MSG_DEBUG("connectOutput failed process POOL domain attributes.");
   }
   if (!processPoolAttributes(m_databaseAttr, outputConnection, contextId).isSuccess()) {
      ATH_MSG_DEBUG("connectOutput failed process POOL database attributes.");
   }
   return(StatusCode::SUCCESS);
}

connectOutput() [2/2]

StatusCode AthenaPoolCnvSvc::connectOutput ( const std::string & outputConnectionSpec, const std::string & openMode )

overridevirtual

Implementation of IConversionSvc: Connect to the output connection specification with open mode.

Parameters

outputConnectionSpec	[IN] the name of the output connection specification as string.
openMode	[IN] the open mode of the file as string.

Definition at line 266 of file AthenaPoolCnvSvc.cxx.

                            {
   return(connectOutput(outputConnectionSpec));
}

convertAddress()

StatusCode AthenaPoolCnvSvc::convertAddress ( const IOpaqueAddress * pAddress, std::string & refAddress )

overridevirtual

Convert address to string form.

Parameters

pAddress	[IN] address to be converted.
refAddress	[OUT] converted string form.

Definition at line 494 of file AthenaPoolCnvSvc.cxx.

                               {
   assert(pAddress);
   const TokenAddress* tokAddr = dynamic_cast<const TokenAddress*>(pAddress);
   if (tokAddr != nullptr && tokAddr->getToken() != nullptr) {
      refAddress = tokAddr->getToken()->toString();
   } else {
      refAddress = *pAddress->par();
   }
   return(StatusCode::SUCCESS);
}

createAddress() [1/2]

StatusCode AthenaPoolCnvSvc::createAddress ( long svcType, const CLID & clid, const std::string & refAddress, IOpaqueAddress *& refpAddress )

overridevirtual

Create address from string form.

Parameters

svcType	[IN] service type of the address.
clid	[IN] class id for the address.
refAddress	[IN] string form to be converted.
refpAddress	[OUT] converted address.

Definition at line 482 of file AthenaPoolCnvSvc.cxx.

                                      {
   if (svcType != repSvcType()) {
      ATH_MSG_ERROR("createAddress: svcType != POOL_StorageType " << svcType << " " << repSvcType());
      return(StatusCode::FAILURE);
   }
   refpAddress = new GenericAddress(repSvcType(), clid, refAddress);
   return(StatusCode::SUCCESS);
}

createAddress() [2/2]

StatusCode AthenaPoolCnvSvc::createAddress ( long svcType, const CLID & clid, const std::string * par, const unsigned long * ip, IOpaqueAddress *& refpAddress )

override

Create a Generic address using explicit arguments to identify a single object.

Parameters

svcType	[IN] service type of the address.
clid	[IN] class id for the address.
par	[IN] string containing the database name.
ip	[IN] object identifier.
refpAddress	[OUT] converted address.

Definition at line 456 of file AthenaPoolCnvSvc.cxx.

                                      {
   if( svcType != repSvcType() ) {
      ATH_MSG_ERROR("createAddress: svcType != POOL_StorageType " << svcType << " " << repSvcType());
      return(StatusCode::FAILURE);
   }
   std::unique_ptr<Token> token;
   if (par[0].compare(0, 3, "SHM") == 0) {
      token = std::make_unique<Token>();
      token->setOid(Token::OID_t(ip[0], ip[1]));
      token->setAuxString("[PNAME=" + par[2] + "]");
      RootType classDesc = RootType::ByNameNoQuiet(par[2]);
      token->setClassID(pool::DbReflex::guid(classDesc));
   } else {
      token.reset(m_poolSvc->getToken(par[0], par[1], ip[0]));
   }
   if (token == nullptr) {
      return(StatusCode::RECOVERABLE);
   }
   refpAddress = new TokenAddress(repSvcType(), clid, "", par[1], IPoolSvc::kInputStream, std::move(token));
   return(StatusCode::SUCCESS);
}

createObj()

StatusCode AthenaPoolCnvSvc::createObj ( IOpaqueAddress * pAddress, DataObject *& refpObject )

overridevirtual

Implementation of IConversionSvc: Create the transient representation of an object from persistent state.

Parameters

pAddress	[IN] pointer to IOpaqueAddress of the representation.
refpObject	[OUT] pointer to DataObject to be created.

Definition at line 170 of file AthenaPoolCnvSvc.cxx.

                                                                                        {
   assert(pAddress);
   std::string objName = "ALL";
   if (m_useDetailChronoStat.value()) {
      if (m_clidSvc->getTypeNameOfID(pAddress->clID(), objName).isFailure()) {
         objName = std::to_string(pAddress->clID());
      }
      objName += '#';
      objName += *(pAddress->par() + 1);
   }
   // StopWatch listens from here until the end of this current scope
   PMonUtils::BasicStopWatch stopWatch("cObj_" + objName, m_chronoMap);
   if (!m_persSvcPerInputType.empty()) { // Use separate PersistencySvc for each input data type
      TokenAddress* tokAddr = dynamic_cast<TokenAddress*>(pAddress);
      if (tokAddr != nullptr && tokAddr->getToken() != nullptr && (tokAddr->getToken()->contID().starts_with(m_persSvcPerInputType.value() + "(") || tokAddr->getToken()->contID().starts_with(m_persSvcPerInputType.value() + "_"))) {
         const unsigned int maxContext = m_poolSvc->getInputContextMap().size();
         const unsigned int auxContext = m_poolSvc->getInputContext(tokAddr->getToken()->classID().toString() + tokAddr->getToken()->dbID().toString(), 1);
         char text[32];
         const std::string contextStr = std::format("[CTXT={:08X}]", auxContext);
         std::strncpy(text, contextStr.c_str(), sizeof(text) - 1);
         text[sizeof(text) - 1] = '\0';
         if (m_poolSvc->getInputContextMap().size() > maxContext) {
            if (m_poolSvc->setAttribute("TREE_CACHE", "0", pool::DbType(pool::ROOTTREE_StorageType).type(), "FID:" + tokAddr->getToken()->dbID().toString(), m_persSvcPerInputType.value(), auxContext).isSuccess()) {
               ATH_MSG_DEBUG("setInputAttribute failed to switch off TTreeCache for id = " << auxContext << ".");
            }
         }
         tokAddr->getToken()->setAuxString(text);
      }
   }
   // Forward to base class createObj
   StatusCode status = ::AthCnvSvc::createObj(pAddress, refpObject);
   return(status);
}

createRep()

StatusCode AthenaPoolCnvSvc::createRep ( DataObject * pObject, IOpaqueAddress *& refpAddress )

overridevirtual

Implementation of IConversionSvc: Convert the transient object to the requested representation.

Parameters

pObject	[IN] pointer to DataObject.
refpAddress	[OUT] pointer to IOpaqueAddress of the representation to be created.

Definition at line 204 of file AthenaPoolCnvSvc.cxx.

                                                                                        {
   assert(pObject);
   std::string objName = "ALL";
   if (m_useDetailChronoStat.value()) {
      if (m_clidSvc->getTypeNameOfID(pObject->clID(), objName).isFailure()) {
         objName = std::to_string(pObject->clID());
      }
      objName += '#';
      objName += pObject->registry()->name();
   }
   // StopWatch listens from here until the end of this current scope
   PMonUtils::BasicStopWatch stopWatch("cRep_" + objName, m_chronoMap);
   StatusCode status = StatusCode::FAILURE;
   if (pObject->clID() == 1) {
      // No transient object was found use cnv to write default persistent object
      SG::DataProxy* proxy = dynamic_cast<SG::DataProxy*>(pObject->registry());
      if (proxy != nullptr) {
         IConverter* cnv = converter(proxy->clID());
         status = cnv->createRep(pObject, refpAddress);
      }
   } else {
      // Forward to base class createRep
      try {
         status = ::AthCnvSvc::createRep(pObject, refpAddress);
      } catch(std::runtime_error& e) {
         ATH_MSG_FATAL(e.what());
      }
   }
   return(status);
}

decodeOutputSpec()

StatusCode AthenaPoolCnvSvc::decodeOutputSpec ( std::string & connectionSpec, int & outputTech ) const

overridevirtual

Extract/deduce the DB technology from the connection string/file specification.

Definition at line 506 of file AthenaPoolCnvSvc.cxx.

                                                                                        {
   if (fileSpec.starts_with ( "ROOTKEY:")) {
      outputTech = pool::ROOTKEY_StorageType.type();
      fileSpec.erase(0, 8);
   } else if (fileSpec.starts_with ( "ROOTTREE:")) {
      outputTech = pool::ROOTTREE_StorageType.type();
      fileSpec.erase(0, 9);
   } else if (fileSpec.starts_with ( "ROOTTREEINDEX:")) {
      outputTech = pool::ROOTTREEINDEX_StorageType.type();
      fileSpec.erase(0, 14);
   } else if (fileSpec.starts_with ( "ROOTRNTUPLE:")) {
      outputTech = pool::ROOTRNTUPLE_StorageType.type();
      fileSpec.erase(0, 12);
   } else if (outputTech == 0) {
      // Extract the file name
      std::string fileName{fileSpec};
      if (auto pos = fileSpec.find("?pmerge="); pos != std::string::npos) {
         fileName = fileSpec.substr(0, pos);
      }
      // Find the appropriate event data technology for this file
      // This will be used for event data and its data header
      // First we look for an exact file name match
      // If that fails, we look for a wildcard ("*") match
      // If that also fails, we use the default value from PoolSvc
      if (auto it = m_storageTechMap.find(fileName); it != m_storageTechMap.end()) {
         outputTech = it->second;
      } else if (it = m_storageTechMap.find("*"); it != m_storageTechMap.end()) {
         outputTech = it->second;
      } else {
         outputTech = pool::DbType::getType(m_defContainerType).type();
      }
   }
   return StatusCode::SUCCESS;
}

disconnectOutput()

StatusCode AthenaPoolCnvSvc::disconnectOutput ( const std::string & outputConnectionSpec )

overridevirtual

Disconnect to the output connection.

Definition at line 409 of file AthenaPoolCnvSvc.cxx.

                                                                                   {
   std::string outputConnection = outputConnectionSpec.substr(0, outputConnectionSpec.find('['));
   unsigned int contextId = outputContextId(outputConnection);
   StatusCode sc = m_poolSvc->disconnect(contextId);
   return sc;
}

extractPoolAttributes()

void AthenaPoolCnvSvc::extractPoolAttributes ( const Gaudi::Property< std::vector< std::string > > & property, std::vector< std::vector< std::string > > * contAttr, std::vector< std::vector< std::string > > * dbAttr, std::vector< std::vector< std::string > > * domAttr = 0 ) const

private

Extract POOL ItechnologySpecificAttributes for Domain, Database and Container from property.

Definition at line 601 of file AthenaPoolCnvSvc.cxx.

                                                         {
   std::vector<std::string> opt;
   std::string attributeName, containerName, databaseName, valueString;
   for (const auto& propertyValue : property.value()) {
      opt.clear();
      attributeName.clear();
      containerName.clear();
      databaseName.clear();
      valueString.clear();
      using Gaudi::Utils::AttribStringParser;
      for (const AttribStringParser::Attrib& attrib : AttribStringParser (propertyValue)) {
         if (attrib.tag == "DatabaseName") {
            databaseName = attrib.value;
         } else if (attrib.tag == "ContainerName") {
            if (databaseName.empty()) {
               databaseName = "*";
            }
            containerName = attrib.value;
         } else {
            attributeName = attrib.tag;
            valueString = attrib.value;
         }
      }
      if (!attributeName.empty() && !valueString.empty()) {
         opt.push_back(attributeName);
         opt.push_back(valueString);
         if (!databaseName.empty()) {
            opt.push_back(databaseName);
            if (!containerName.empty()) {
               opt.push_back(containerName);
               if (containerName.compare(0, 6, "TTree=") == 0) {
                  dbAttr->push_back(opt);
               } else {
                  contAttr->push_back(opt);
               }
            } else {
               opt.push_back("");
               dbAttr->push_back(opt);
            }
         } else if (domAttr != 0) {
            domAttr->push_back(opt);
         } else {
            opt.push_back("*");
            opt.push_back("");
            dbAttr->push_back(opt);
         }
      }
   }
}

fillRepRefs()

StatusCode AthenaPoolCnvSvc::fillRepRefs ( IOpaqueAddress * pAddress, DataObject * pObject )

overridevirtual

Implementation of IConversionSvc: Resolve the references of the converted object.

Parameters

pAddress	[IN] pointer to IOpaqueAddress of the representation to be resolved.
pObject	[IN] pointer to DataObject to be created.

Definition at line 235 of file AthenaPoolCnvSvc.cxx.

                                                                                      {
   assert(pObject);
   std::string objName = "ALL";
   if (m_useDetailChronoStat.value()) {
      if (m_clidSvc->getTypeNameOfID(pObject->clID(), objName).isFailure()) {
         objName = std::to_string(pObject->clID());
      }
      objName += '#';
      objName += pObject->registry()->name();
   }
   // StopWatch listens from here until the end of this current scope
   PMonUtils::BasicStopWatch stopWatch("fRep_" + objName, m_chronoMap);
   StatusCode status = StatusCode::FAILURE;
   if (pObject->clID() == 1) {
      // No transient object was found use cnv to write default persistent object
      SG::DataProxy* proxy = dynamic_cast<SG::DataProxy*>(pObject->registry());
      if (proxy != nullptr) {
         IConverter* cnv = converter(proxy->clID());
         status = cnv->fillRepRefs(pAddress, pObject);
      }
   } else {
      // Forward to base class fillRepRefs
      try {
         status = ::AthCnvSvc::fillRepRefs(pAddress, pObject);
      } catch(std::runtime_error& e) {
         ATH_MSG_FATAL(e.what());
      }
   }
   return(status);
}

finalize()

StatusCode AthenaPoolCnvSvc::finalize ( )

overridevirtual

Required of all Gaudi Services.

Definition at line 136 of file AthenaPoolCnvSvc.cxx.

                                      {
   ATH_MSG_VERBOSE("Finalizing...");
   // Some algorithms write in finalize(), flush DHForms if any are left
   flushDataHeaderForms();
   // Release ClassIDSvc
   if (!m_clidSvc.release().isSuccess()) {
      ATH_MSG_WARNING("Cannot release ClassIDSvc.");
   }
   // Release PoolSvc
   if (!m_poolSvc.release().isSuccess()) {
      ATH_MSG_WARNING("Cannot release PoolSvc.");
   }
   // Print Performance Statistics
   // The pattern AthenaPoolCnvSvc.*PerfStats is ignored in AtlasTest/TestTools/share/post.sh
   const std::string msgPrefix{"PerfStats "};
   ATH_MSG_INFO(msgPrefix << std::string(40, '-'));
   ATH_MSG_INFO(msgPrefix << "Timing Measurements for AthenaPoolCnvSvc");
   ATH_MSG_INFO(msgPrefix << std::string(40, '-'));
   for(const auto& [key, value] : m_chronoMap) {
      ATH_MSG_INFO(msgPrefix << "| " << std::left << std::setw(15) << key << " | "
                        << std::right << std::setw(15) << std::fixed << std::setprecision(0) << value << " ms |");
   }
   ATH_MSG_INFO(msgPrefix << std::string(40, '-'));
 
   m_cnvs.clear();
   m_cnvs.shrink_to_fit();
   return(StatusCode::SUCCESS);
}

flushDataHeaderForms()

void AthenaPoolCnvSvc::flushDataHeaderForms

(

const std::string &

streamName = "*"

)

Tell DataHeaderCnv to write out all DataHeaderForms for a given streamName (default is all)

Definition at line 122 of file AthenaPoolCnvSvc.cxx.

                                                                       {
   // Write remaining DataHeaderForms for a given streamName, "*"" means all
   auto DHCnvListener = dynamic_cast<IIncidentListener*>( converter( ClassID_traits<DataHeader>::ID() ) );
   FileIncident incident(name(), "WriteDataHeaderForms", streamName);
   if( DHCnvListener ) DHCnvListener->handle(incident);
}

getPoolSvc()

IPoolSvc * AthenaPoolCnvSvc::getPoolSvc ( )

overridevirtual

Returns

pointer to PoolSvc instance.

Definition at line 423 of file AthenaPoolCnvSvc.cxx.

                                       {
   return(&*m_poolSvc);
}

handle()

void AthenaPoolCnvSvc::handle ( const Incident & incident )

overridevirtual

Implementation of IIncidentListener: Handle for EndEvent incidence.

Definition at line 589 of file AthenaPoolCnvSvc.cxx.

                                                      {
   if (incident.type() == "EndEvent") {
      if (!processPoolAttributes(m_inputAttrPerEvent, m_lastInputFileName, IPoolSvc::kInputStream).isSuccess()) {
         ATH_MSG_DEBUG("handle EndEvent failed process POOL database attributes.");
      }
   }
}

initialize()

StatusCode AthenaPoolCnvSvc::initialize ( )

overridevirtual

Required of all Gaudi Services.

Definition at line 35 of file AthenaPoolCnvSvc.cxx.

                                        {
   // Initialize DataModelCompatSvc
   ServiceHandle<IService> dmcsvc("DataModelCompatSvc", this->name());
   ATH_CHECK(dmcsvc.retrieve());
   // Retrieve PoolSvc
   ATH_CHECK(m_poolSvc.retrieve());
   StringProperty defContainerType("DefaultContainerType", "ROOTTREEINDEX");
   if(IProperty* propertyServer = dynamic_cast<IProperty*>(m_poolSvc.get())) {
      propertyServer->getProperty(&defContainerType).ignore();
   }
   m_defContainerType = defContainerType.value();
   // Retrieve ClassIDSvc
   ATH_CHECK(m_clidSvc.retrieve());
   // Register this service for 'I/O' events
   ServiceHandle<IIoComponentMgr> iomgr("IoComponentMgr", name());
   ATH_CHECK(iomgr.retrieve());
   if (!iomgr->io_register(this).isSuccess()) {
      ATH_MSG_FATAL("Could not register myself with the IoComponentMgr !");
      return(StatusCode::FAILURE);
   }
   // Extracting MaxFileSizes for global default and map by Database name.
   for (const auto& maxFileSizeSpec : m_maxFileSizes.value()) {
      if (auto p = maxFileSizeSpec.find('='); p != std::string::npos) {
         long long maxFileSize = 0;
         const char* start = maxFileSizeSpec.data() + (p + 1);
         const char* end = maxFileSizeSpec.data() + maxFileSizeSpec.size();
         if (auto [ptr, ec] = std::from_chars(start, end, maxFileSize); ec != std::errc{}) {
            ATH_MSG_WARNING(std::format("Invalid MaxFileSize value: {}", std::string(start, end)));
         }
         std::string databaseName = maxFileSizeSpec.substr(0, maxFileSizeSpec.find_first_of("   ="));
         std::unique_lock<std::mutex> lock(m_mutex);
         m_databaseMaxFileSize.emplace(std::move(databaseName), maxFileSize);
      } else {
         if (auto [ptr, ec] = std::from_chars(maxFileSizeSpec.data(), maxFileSizeSpec.data() + maxFileSizeSpec.size(), m_domainMaxFileSize); ec != std::errc{}) {
            ATH_MSG_WARNING(std::format("Invalid MaxFileSize value: {}", maxFileSizeSpec));
         }
      }
   }
   // Validate provided event data technologies and fill the internal cache
   for (const auto& [key, value] : m_storageTechProp.value()) {
      try {
         const auto dbType = pool::DbType::getType(value);
         if (dbType == pool::TEST_StorageType) {
            ATH_MSG_FATAL(std::format("Unknown storage type requested for file {}: {}", key, value));
            return StatusCode::FAILURE;
         }
         m_storageTechMap.emplace(key, dbType.type());
      } catch (const std::exception& e) {
        ATH_MSG_FATAL(std::format("Exception while getting storage type for file {}: {}", key, e.what()));
        return StatusCode::FAILURE;
      } catch (...) {
        ATH_MSG_FATAL(std::format("Unknown exception while getting storage type for file {}", key));
        return StatusCode::FAILURE;
      }
   }
   // Extracting INPUT POOL ItechnologySpecificAttributes for Domain, Database and Container.
   extractPoolAttributes(m_inputPoolAttr, &m_inputAttr, &m_inputAttr, &m_inputAttr);
   // Extracting the INPUT POOL ItechnologySpecificAttributes which are to be printed for each event
   extractPoolAttributes(m_inputPoolAttrPerEvent, &m_inputAttrPerEvent, &m_inputAttrPerEvent, &m_inputAttrPerEvent);
   // Setup incident for EndEvent to print out attributes each event
   ServiceHandle<IIncidentSvc> incSvc("IncidentSvc", name());
   long int pri = 1000;
   if (!m_inputPoolAttrPerEvent.value().empty()) {
      // Set to be listener for EndEvent
      incSvc->addListener(this, "EndEvent", pri);
      ATH_MSG_DEBUG("Subscribed to EndEvent for printing out input file attributes.");
   }
   if (!processPoolAttributes(m_inputAttr, "", IPoolSvc::kInputStream, false, true, true).isSuccess()) {
      ATH_MSG_DEBUG("setInputAttribute failed setting POOL domain attributes.");
   }
 
   // Load these dictionaries now, so we don't need to try to do so
   // while multiple threads are running.
   TClass::GetClass ("TLeafI");
   TClass::GetClass ("TLeafL");
   TClass::GetClass ("TLeafD");
   TClass::GetClass ("TLeafF");
 
   return(StatusCode::SUCCESS);
}

io_finalize()

StatusCode AthenaPoolCnvSvc::io_finalize ( )

overridevirtual

Definition at line 165 of file AthenaPoolCnvSvc.cxx.

                                         {
   ATH_MSG_DEBUG("I/O finalization...");
   return(StatusCode::SUCCESS);
}

io_reinit()

StatusCode AthenaPoolCnvSvc::io_reinit ( )

overridevirtual

Definition at line 116 of file AthenaPoolCnvSvc.cxx.

                                       {
   ATH_MSG_DEBUG("I/O reinitialization...");
   m_contextAttr.clear();
   return(StatusCode::SUCCESS);
}

outputContextId()

unsigned int AthenaPoolCnvSvc::outputContextId ( const std::string & outputConnection )

protected

Definition at line 417 of file AthenaPoolCnvSvc.cxx.

                                                                                {
   return m_persSvcPerOutput?
      m_poolSvc->getOutputContext(outputConnection) : (unsigned int)IPoolSvc::kOutputStream;
}

processPoolAttributes()

StatusCode AthenaPoolCnvSvc::processPoolAttributes ( std::vector< std::vector< std::string > > & attr, const std::string & fileName, unsigned long contextId, bool doGet = true, bool doSet = true, bool doClear = true ) const

private

Set/get technology dependent POOL attributes.

Definition at line 654 of file AthenaPoolCnvSvc.cxx.

                            {
   bool retError = false;
   for (auto& attrEntry : attr) {
      if (attrEntry.size() == 2) {
         const std::string& opt = attrEntry[0];
         std::string data = attrEntry[1];
         if (data == "int" || data == "DbLonglong" || data == "double" || data == "string") {
            if (doGet) {
               if (!m_poolSvc->getAttribute(opt, data, pool::DbType(pool::ROOTTREE_StorageType).type(), contextId).isSuccess()) {
                  ATH_MSG_DEBUG("getAttribute failed for domain attr " << opt);
                  retError = true;
               }
            }
         } else if (doSet) {
            if (m_poolSvc->setAttribute(opt, data, pool::DbType(pool::ROOTTREE_StorageType).type(), contextId).isSuccess()) {
               ATH_MSG_DEBUG("setAttribute " << opt << " to " << data);
               if (doClear) {
                  attrEntry.clear();
               }
            } else {
               ATH_MSG_DEBUG("setAttribute failed for domain attr " << opt << " to " << data);
               retError = true;
            }
         }
      }
      if (attrEntry.size() == 4) {
         const std::string& opt = attrEntry[0];
         std::string data = attrEntry[1];
         const std::string& file = attrEntry[2];
         const std::string& cont = attrEntry[3];
         if (!fileName.empty() && (0 == fileName.compare(0, fileName.find('?'), file)
             || (file[0] == '*' && file.find("," + fileName + ",") == std::string::npos))) {
            if (data == "int" || data == "DbLonglong" || data == "double" || data == "string") {
               if (doGet) {
                  if (!m_poolSvc->getAttribute(opt, data, pool::DbType(pool::ROOTTREE_StorageType).type(), fileName, cont, contextId).isSuccess()) {
                     ATH_MSG_DEBUG("getAttribute failed for database/container attr " << opt);
                     retError = true;
                  }
               }
            } else if (doSet) {
               if (m_poolSvc->setAttribute(opt, data, pool::DbType(pool::ROOTTREE_StorageType).type(), fileName, cont, contextId).isSuccess()) {
                  ATH_MSG_DEBUG("setAttribute " << opt << " to " << data << " for db: " << fileName << " and cont: " << cont);
                  if (doClear) {
                     if (file[0] == '*' && !m_persSvcPerOutput) {
                        attrEntry[2] += "," + fileName + ",";
                     } else {
                        attrEntry.clear();
                     }
                  }
               } else {
                  ATH_MSG_DEBUG("setAttribute failed for " << opt << " to " << data << " for db: " << fileName << " and cont: " << cont);
                  retError = true;
               }
            }
         }
      }
   }
   std::erase_if(attr, [](const auto& entry) { return entry.empty(); });
   return(retError ? StatusCode::FAILURE : StatusCode::SUCCESS);
}

registerCleanUp()

StatusCode AthenaPoolCnvSvc::registerCleanUp ( IAthenaPoolCleanUp * cnv )

overridevirtual

Implement registerCleanUp to register a IAthenaPoolCleanUp to be called during cleanUp.

Definition at line 541 of file AthenaPoolCnvSvc.cxx.

                                                                    {
   m_cnvs.push_back(cnv);
   return(StatusCode::SUCCESS);
}

registerForWrite()

Token * AthenaPoolCnvSvc::registerForWrite ( Placement * placement, const void * obj, const RootType & classDesc )

overridevirtual

Returns

a string token to a Data Object written to Pool

Parameters

placement	[IN] pointer to the placement hint
obj	[IN] pointer to the Data Object to be written to Pool
classDesc	[IN] pointer to the Seal class description for the Data Object.

Definition at line 427 of file AthenaPoolCnvSvc.cxx.

                                                                                                          {
   // StopWatch listens from here until the end of this current scope
   PMonUtils::BasicStopWatch stopWatch("cRepR_ALL", m_chronoMap);
   Token* token = nullptr;
         if (m_persSvcPerOutput) { // Use separate PersistencySvc for each output stream/file
            char text[32];
            const std::string contextStr = std::format("[CTXT={:08X}]", m_poolSvc->getOutputContext(placement->fileName()));
            std::strncpy(text, contextStr.c_str(), sizeof(text) - 1);
            text[sizeof(text) - 1] = '\0';
            placement->setAuxString(text);
         }
         token = m_poolSvc->registerForWrite(placement, obj, classDesc);
   return(token);
}

setInputAttributes()

StatusCode AthenaPoolCnvSvc::setInputAttributes ( const std::string & fileName )

overridevirtual

Set the input file attributes, if any are requested from jobOpts.

Parameters

fileName

[IN] name of the input file

Definition at line 567 of file AthenaPoolCnvSvc.cxx.

                                                                         {
   // Set attributes for input file
   m_lastInputFileName = fileName; // Save file name for printing attributes per event
   if (!processPoolAttributes(m_inputAttr, m_lastInputFileName, IPoolSvc::kInputStream, false, true, false).isSuccess()) {
      ATH_MSG_DEBUG("setInputAttribute failed setting POOL database/container attributes.");
   }
   if (!processPoolAttributes(m_inputAttr, m_lastInputFileName, IPoolSvc::kInputStream, true, false).isSuccess()) {
      ATH_MSG_DEBUG("setInputAttribute failed getting POOL database/container attributes.");
   }
   if (!m_persSvcPerInputType.empty()) {
      // Loop over all extra event input contexts and switch off TTreeCache
      const auto& extraInputContextMap = m_poolSvc->getInputContextMap();
      for (const auto& [label, id]: extraInputContextMap) {
         if (m_poolSvc->setAttribute("TREE_CACHE", "0", pool::DbType(pool::ROOTTREE_StorageType).type(), m_lastInputFileName, m_persSvcPerInputType.value(), id).isSuccess()) {
            ATH_MSG_DEBUG("setInputAttribute failed to switch off TTreeCache for = " << label << ".");
         }
      }
   }
   return(StatusCode::SUCCESS);
}

setObjPtr()

void AthenaPoolCnvSvc::setObjPtr ( void *& obj, const Token * token )

overridevirtual

Parameters

obj	[OUT] pointer to the Data Object.
token	[IN] string token of the Data Object for which a Pool Ref is filled.

Definition at line 442 of file AthenaPoolCnvSvc.cxx.

                                                               {
   ATH_MSG_VERBOSE("Requesting object for: " << token->toString());
   // StopWatch listens from here until the end of this current scope
   PMonUtils::BasicStopWatch stopWatch("cObjR_ALL", m_chronoMap);
   if (token->dbID() != Guid::null()) {
      ATH_MSG_VERBOSE("Requesting object for: " << token->toString());
      m_poolSvc->setObjPtr(obj, token);
   }
}

stop()

StatusCode AthenaPoolCnvSvc::stop ( )

overridevirtual

Definition at line 129 of file AthenaPoolCnvSvc.cxx.

                                  {
   ATH_MSG_VERBOSE("stop()");
   // In case of direct writing without an OutputStream, this should be a good time to flush DHForms
   flushDataHeaderForms();
   return StatusCode::SUCCESS;
}

useDetailChronoStat()

bool AthenaPoolCnvSvc::useDetailChronoStat ( ) const

overridevirtual

Returns

a boolean for using detailed time and size statistics.

Definition at line 452 of file AthenaPoolCnvSvc.cxx.

                                                 {
   return(m_useDetailChronoStat.value());
}

Friends And Related Symbol Documentation

SvcFactory< AthenaPoolCnvSvc >

friend class SvcFactory< AthenaPoolCnvSvc >

friend

Definition at line 1 of file AthenaPoolCnvSvc.h.

Member Data Documentation

m_branchNameHintProp

Gaudi::Property<std::string> AthenaPoolCnvSvc::m_branchNameHintProp {this,"SubLevelBranchName", "<type>/<key>"}

private

SubLevelBranchName, naming hint policy for POOL branching: ("" = no branching)

Definition at line 197 of file AthenaPoolCnvSvc.h.

{this,"SubLevelBranchName", "<type>/<key>"};

m_chronoMap

PMonUtils::BasicStopWatchResultMap_t AthenaPoolCnvSvc::m_chronoMap {}

protected

Map that holds chrono information.

Definition at line 181 of file AthenaPoolCnvSvc.h.

{};

m_clidSvc

ServiceHandle<IClassIDSvc> AthenaPoolCnvSvc::m_clidSvc {this,"ClassIDSvc","ClassIDSvc"}

private

Definition at line 177 of file AthenaPoolCnvSvc.h.

{this,"ClassIDSvc","ClassIDSvc"};

m_containerAttr

std::vector<std::vector<std::string> > AthenaPoolCnvSvc::m_containerAttr

private

Definition at line 203 of file AthenaPoolCnvSvc.h.

m_containerNameHintProp

Gaudi::Property<std::string> AthenaPoolCnvSvc::m_containerNameHintProp {this,"TopLevelContainerName",""}

private

TopLevelContainerName, naming hint policy for top level POOL container: default = "<type>".

Definition at line 195 of file AthenaPoolCnvSvc.h.

{this,"TopLevelContainerName",""};

m_containerPrefixProp

Gaudi::Property<std::string> AthenaPoolCnvSvc::m_containerPrefixProp {this,"PoolContainerPrefix","Default"}

private

POOL Container name prefix - will be part of or whole TTree/RNTuple name 'Default' takes the prefix from APRDefaults according to StorageTech.

Definition at line 193 of file AthenaPoolCnvSvc.h.

{this,"PoolContainerPrefix","Default"};

m_contextAttr

std::vector<unsigned int> AthenaPoolCnvSvc::m_contextAttr

private

Definition at line 204 of file AthenaPoolCnvSvc.h.

m_databaseAttr

std::vector<std::vector<std::string> > AthenaPoolCnvSvc::m_databaseAttr

private

Definition at line 202 of file AthenaPoolCnvSvc.h.

m_databaseMaxFileSize

std::map<std::string, long long> AthenaPoolCnvSvc::m_databaseMaxFileSize

private

Definition at line 218 of file AthenaPoolCnvSvc.h.

m_defContainerType

std::string AthenaPoolCnvSvc::m_defContainerType {}

private

Default container type (from PoolSvc)

Definition at line 221 of file AthenaPoolCnvSvc.h.

{};

m_DHFilterAliases

Gaudi::Property<bool> AthenaPoolCnvSvc::m_DHFilterAliases { this, "doFilterDHAliases", true }

protected

Flag to control SG alias filtering when writing out DataHeader (see DataHeaderCnv_p6)

Definition at line 243 of file AthenaPoolCnvSvc.h.

{ this, "doFilterDHAliases", true };

m_DHFormCacheSize

Gaudi::Property<int> AthenaPoolCnvSvc::m_DHFormCacheSize { this, "maxDHFormCacheSize", 100 }

protected

Property for DataHeaderCnv input DHForm cache size.

Definition at line 241 of file AthenaPoolCnvSvc.h.

{ this, "maxDHFormCacheSize", 100 };

m_domainAttr

std::vector<std::vector<std::string> > AthenaPoolCnvSvc::m_domainAttr

private

Definition at line 201 of file AthenaPoolCnvSvc.h.

m_domainMaxFileSize

long long AthenaPoolCnvSvc::m_domainMaxFileSize =std::numeric_limits<long long>::max()

private

Definition at line 217 of file AthenaPoolCnvSvc.h.

m_fileCommitCounter

std::map<std::string, int> AthenaPoolCnvSvc::m_fileCommitCounter

private

Definition at line 205 of file AthenaPoolCnvSvc.h.

m_fileFlushSetting

std::map<std::string, int> AthenaPoolCnvSvc::m_fileFlushSetting

private

Definition at line 206 of file AthenaPoolCnvSvc.h.

m_inputAttr

std::vector<std::vector<std::string> > AthenaPoolCnvSvc::m_inputAttr

private

Definition at line 209 of file AthenaPoolCnvSvc.h.

m_inputAttrPerEvent

std::vector<std::vector<std::string> > AthenaPoolCnvSvc::m_inputAttrPerEvent

private

Definition at line 213 of file AthenaPoolCnvSvc.h.

m_inputPoolAttr

Gaudi::Property<std::vector<std::string> > AthenaPoolCnvSvc::m_inputPoolAttr {this,"InputPoolAttributes",{}}

private

Input PoolAttributes, vector with names and values of technology specific attributes for POOL.

Definition at line 208 of file AthenaPoolCnvSvc.h.

{this,"InputPoolAttributes",{}};

m_inputPoolAttrPerEvent

Gaudi::Property<std::vector<std::string> > AthenaPoolCnvSvc::m_inputPoolAttrPerEvent {this,"PrintInputAttrPerEvt",{}}

private

Print input PoolAttributes per event, vector with names of technology specific attributes for POOL to be printed each event.

Definition at line 212 of file AthenaPoolCnvSvc.h.

{this,"PrintInputAttrPerEvt",{}};

m_lastInputFileName

std::string AthenaPoolCnvSvc::m_lastInputFileName

private

decoded storage tech requested in "StorageTechnology" property

Definition at line 175 of file AthenaPoolCnvSvc.h.

m_maxFileSizes

Gaudi::Property<std::vector<std::string> > AthenaPoolCnvSvc::m_maxFileSizes {this,"MaxFileSizes",{}}

private

MaxFileSizes, vector with maximum file sizes for Athena POOL output files.

Definition at line 216 of file AthenaPoolCnvSvc.h.

{this,"MaxFileSizes",{}};

m_mutex

std::mutex AthenaPoolCnvSvc::m_mutex

protected

Definition at line 232 of file AthenaPoolCnvSvc.h.

m_numberEventsPerWrite

Gaudi::Property<int> AthenaPoolCnvSvc::m_numberEventsPerWrite {this,"NumberEventsPerWrite",-1}

protected

To use MetadataSvc to merge data placed in a certain container When using TMemFile call Write on number of Events, respecting CollectionTree auto_flush.

Definition at line 236 of file AthenaPoolCnvSvc.h.

{this,"NumberEventsPerWrite",-1};

m_oneDataHeaderForm

Gaudi::Property<bool> AthenaPoolCnvSvc::m_oneDataHeaderForm { this, "OneDataHeaderForm", false }

protected

If true, use only one DataHeaderForm per Stream.

Definition at line 239 of file AthenaPoolCnvSvc.h.

{ this, "OneDataHeaderForm", false };

m_persSvcPerInputType

Gaudi::Property<std::string> AthenaPoolCnvSvc::m_persSvcPerInputType {this,"PersSvcPerInputType",""}

protected

PersSvcPerInputType, string property, tree name to use multiple persistency services, one per input type.

default = "", no tree name results in a single persistency service.

Definition at line 231 of file AthenaPoolCnvSvc.h.

{this,"PersSvcPerInputType",""};

m_persSvcPerOutput

Gaudi::Property<bool> AthenaPoolCnvSvc::m_persSvcPerOutput {this,"PersSvcPerOutput",true}

protected

PersSvcPerOutput, boolean property to use multiple persistency services, one per output stream.

default = true.

Definition at line 226 of file AthenaPoolCnvSvc.h.

{this,"PersSvcPerOutput",true};

m_poolAttr

Gaudi::Property<std::vector<std::string> > AthenaPoolCnvSvc::m_poolAttr {this,"PoolAttributes",{},"Pool Attributes","OrderedSet<std::string>"}

private

Output PoolAttributes, vector with names and values of technology specific attributes for POOL.

Definition at line 200 of file AthenaPoolCnvSvc.h.

{this,"PoolAttributes",{},"Pool Attributes","OrderedSet<std::string>"};

m_poolSvc

ServiceHandle<IPoolSvc> AthenaPoolCnvSvc::m_poolSvc {this,"PoolSvc","PoolSvc"}

private

Definition at line 176 of file AthenaPoolCnvSvc.h.

{this,"PoolSvc","PoolSvc"};

m_storageTechMap

std::map<std::string, int> AthenaPoolCnvSvc::m_storageTechMap

private

Definition at line 190 of file AthenaPoolCnvSvc.h.

m_storageTechProp

Gaudi::Property<std::map<std::string, std::string> > AthenaPoolCnvSvc::m_storageTechProp {this, "StorageTechnology", {{"*","ROOTTREEINDEX"}}}

private

Default Storage Tech for containers (ROOTTREE, ROOTTREEINDEX, ROOTRNTUPLE)

Definition at line 189 of file AthenaPoolCnvSvc.h.

{this, "StorageTechnology", {{"*","ROOTTREEINDEX"}}};

m_useDetailChronoStat

Gaudi::Property<bool> AthenaPoolCnvSvc::m_useDetailChronoStat {this,"UseDetailChronoStat",false}

private

UseDetailChronoStat, enable detailed output for time and size statistics for AthenaPOOL: default = false.

Definition at line 186 of file AthenaPoolCnvSvc.h.

{this,"UseDetailChronoStat",false};

---

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

• AthenaPoolCnvSvc.h
• AthenaPoolCnvSvc.cxx