#include <CoolInserter.h>

Inheritance diagram for MuonCalib::CoolInserter:

Collaboration diagram for MuonCalib::CoolInserter:

Public Member Functions
	CoolInserter (const std::string &name, ISvcLocator *pSvcLocator)

	~CoolInserter ()=default

StatusCode	initialize ()
	Is called at the beginning of the analysis. More...

StatusCode	execute ()
	execute function NOTE: This will read all events at once More...

StatusCode	finalize ()
	finalize functions More...

bool	CoolConnect (const std::string &connection_string, const std::string &tag_t0)

bool	StartT0Chamber (const NtupleStationId &sid)

bool	AppendT0 (float t0, int validflag, float adc0)

bool	StoreT0Chamber (const NtupleStationId &id, const std::string &file, unsigned int creation_flags=0)

bool	StoreRtChamber (const NtupleStationId &id, const std::map< int, SamplePoint > &points, const std::string &file, unsigned int creation_flags=0)

virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...

virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

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. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
bool	create_folder (const unsigned int &fldr_nr, const bool &is_rt)

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

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
std::string	m_version

std::vector< std::string >	m_tagt0

std::vector< std::string >	m_tagrt

int	m_iov_start = 0

int	m_iov_end = 0

long long	m_iovt_start

long long	m_iovt_end

std::string	m_cool_connection_string

std::vector< std::string >	m_t0_folder

std::vector< std::string >	m_rt_folder

std::vector< bool >	m_compressed_t0

std::vector< bool >	m_compressed_rt

ToolHandleArray< IMuonCalibConditionsSource >	m_calibration_sources {this, "CalibrationSources", {}}

const RegionSelectionSvc *	p_reg_sel_svc

cool::IDatabasePtr	m_db

std::vector< cool::IFolderPtr >	m_mdtt0_fld

std::vector< cool::IFolderPtr >	m_mdtrt_fld

cool::Application	m_app

std::map< bool, coral::AttributeList >	m_mdtt0_cool_row

std::map< bool, coral::AttributeList >	m_mdtrt_cool_row

bool	m_cool_connect

bool	m_t0_created

bool	m_rt_created

std::set< NtupleStationId >	m_t0_filled

std::set< NtupleStationId >	m_rt_filled

ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

SG::ReadCondHandleKey< MuonGM::MuonDetectorManager >	m_DetectorManagerKey

std::ostringstream	m_data_string

int	m_n_tubes_added

int	m_n_tubes_chamber

float	m_aver_t0

float	m_aver_adc

NtupleStationId	m_sid

DataObjIDColl	m_extendedExtraObjects

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 32 of file CoolInserter.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

◆ CoolInserter()

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

Definition at line 39 of file CoolInserter.cxx.

                                                                               :
         AthAlgorithm(name, pSvcLocator),
         m_version("v0.0"),
         p_reg_sel_svc(nullptr),
         m_cool_connect(false),
         m_t0_created(false),
         m_rt_created(false) {
         declareProperty("CoolConnectionString", m_cool_connection_string);
         declareProperty("RtVersion", m_version);
         declareProperty("T0Tag", m_tagt0);
         declareProperty("RtTag", m_tagrt);
         declareProperty("IOVStart", m_iov_start);
         declareProperty("IOVEnd", m_iov_end);
         declareProperty("T0Folder", m_t0_folder);
         declareProperty("RtFolder", m_rt_folder);
         declareProperty("T0FolderCompress", m_compressed_t0);
         declareProperty("RtFolderCompress", m_compressed_rt);
         m_n_tubes_chamber = 0;
         m_n_tubes_added = 0;
         m_iovt_start = 0;
         m_iovt_end = 0;
         m_aver_t0 = 0;
         m_aver_adc = 0;
     }

◆ ~CoolInserter()

MuonCalib::CoolInserter::~CoolInserter ( )

inlinedefault

Member Function Documentation

◆ AppendT0()

bool MuonCalib::CoolInserter::AppendT0	(	float	t0,
		int	validflag,
		float	adc0
	)

Definition at line 184 of file CoolInserter.cxx.

                                                                    {
         if (m_n_tubes_added >= m_n_tubes_chamber) { return false; }
         m_data_string << t0 << "," << validflag << "," << adc0 << ",";
         m_n_tubes_added++;
         m_aver_t0 += t0;
         m_aver_adc += adc0;
         return true;
     }

◆ CoolConnect()

bool MuonCalib::CoolInserter::CoolConnect	(	const std::string &	connection_string,
		const std::string &	tag_t0
	)

◆ create_folder()

bool MuonCalib::CoolInserter::create_folder	(	const unsigned int &	fldr_nr,
		const bool &	is_rt
	)

inlineprivate

Definition at line 319 of file CoolInserter.cxx.

                                                                                           {
         std::string folder;
         std::string description;
         if (is_rt) {
             folder = m_rt_folder[fldr_nr];
             description = std::string(
                               "<timeStamp>run-lumi</timeStamp><addrHeader><address_header service_type=\"71\" clid=\"1238547719\" "
                               "/></addrHeader><typeName>CondAttrListCollection</typeName><key>") +
                           folder + "</key>";
         } else {
             folder = m_t0_folder[fldr_nr];
             description = std::string(
                               "<timeStamp>run-lumi</timeStamp><addrHeader><address_header service_type=\"71\" clid=\"1238547719\" "
                               "/></addrHeader><typeName>CondAttrListCollection</typeName><key>") +
                           folder + "</key>";
         }
  
         bool compressed(false);
         if (is_rt) {
             if (m_compressed_rt.size() > fldr_nr)
                 if (m_compressed_rt[fldr_nr]) compressed = true;
         } else {
             if (m_compressed_t0.size() > fldr_nr)
                 if (m_compressed_t0[fldr_nr]) compressed = true;
         }
         cool::RecordSpecification spec;
         spec.extend("tech", cool::StorageType::Int32);
         if (compressed) {
             spec.extend("file", cool::StorageType::String255);
             spec.extend("data", cool::StorageType::Blob64k);
         } else {
             spec.extend("file", cool::StorageType::String4k);
             if (is_rt) {
                 spec.extend("data", cool::StorageType::String4k);
             } else {
                 spec.extend("data", cool::StorageType::String16M);
             }
         }
         cool::FolderSpecification fspec(cool::FolderVersioning::MULTI_VERSION, spec);
         m_db->createFolder(folder, fspec, description, true);
         return true;
     }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleKeyArrayType &
	)

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	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());
  
   }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleType &
	)

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

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

95 { return m_detStore; }

◆ evtStore() [1/2]

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.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode MuonCalib::CoolInserter::execute ( )

execute function NOTE: This will read all events at once

Definition at line 143 of file CoolInserter.cxx.

                                      {
         for (unsigned int i = 0; i < m_calibration_sources.size(); i++) {
             ATH_MSG_INFO("Now running " << m_calibration_sources[i]);
             if (!m_calibration_sources[i]->InstertCalibration(this, static_cast<bool>(m_t0_folder.size()),
                                                               static_cast<bool>(m_rt_folder.size()))) {
                 ATH_MSG_FATAL("Calibration Source " << m_calibration_sources[i].name() << " failed!");
                 return StatusCode::FAILURE;
             }
         }
         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 MuonCalib::CoolInserter::finalize ( )

finalize functions

Definition at line 131 of file CoolInserter.cxx.

                                       {
         ATH_MSG_INFO("finalizing ");
         try {
             for (auto & i : m_mdtt0_fld) i->flushStorageBuffer();
             for (auto & i : m_mdtrt_fld) i->flushStorageBuffer();
         } catch (std::exception &e) {
             ATH_MSG_FATAL("Exception in finalize: " << e.what());
             return StatusCode::FAILURE;
         }
         return StatusCode::SUCCESS;
     }

◆ initialize()

StatusCode MuonCalib::CoolInserter::initialize ( )

Is called at the beginning of the analysis.

Definition at line 64 of file CoolInserter.cxx.

                                         {
         // check jo
         if (m_tagt0.size() != m_t0_folder.size() || m_tagrt.size() != m_rt_folder.size()) {
             ATH_MSG_FATAL("Configuration error: Number of folders and tags do not match!");
             return StatusCode::FAILURE;
         }
  
         ATH_CHECK(m_idHelperSvc.retrieve());
  
         ATH_CHECK(m_DetectorManagerKey.initialize());
  
         // get region selection service
         ATH_CHECK(service("RegionSelectionSvc", p_reg_sel_svc));
  
         // connect to cool database
         try {
             m_db = m_app.databaseService().openDatabase(m_cool_connection_string, false);
         } catch (cool::DatabaseDoesNotExist &e) {
             ATH_MSG_INFO("Creating new database.");
             try {
                 m_db = m_app.databaseService().createDatabase(m_cool_connection_string);
             } catch (cool::Exception &e) {
                 ATH_MSG_FATAL("Cannot create database and datbasae does not exist!");
                 return StatusCode::FAILURE;
             }
         }
         m_cool_connect = true;
         if (m_t0_folder.size()) {
             ATH_MSG_INFO("Replication into t0 folders: ");
             for (unsigned int i = 0; i < m_t0_folder.size(); i++) { ATH_MSG_INFO(m_t0_folder[i] << "(" << m_tagt0[i] << ") "); }
         }
         if (m_rt_folder.size()) {
             ATH_MSG_INFO("Replication into rt folders: ");
             for (unsigned int i = 0; i < m_rt_folder.size(); i++) { ATH_MSG_INFO(m_rt_folder[i] << "(" << m_tagrt[i] << ") "); }
         }
         // retrieve calibration sources
         ATH_CHECK(m_calibration_sources.retrieve());
  
         // get iov
         for (unsigned int i = 0; i < m_calibration_sources.size(); i++) {
             int iov_start(-1), iov_end(-1);
             m_calibration_sources[i]->SetIOV(iov_start, iov_end);
             if (m_iov_start < 0 && iov_start >= 0) m_iov_start = iov_start;
             if (m_iov_end == -1 && iov_end != -1) m_iov_end = iov_end;
         }
         if (m_iov_start < 0 || m_iov_end == -1) {
             ATH_MSG_FATAL("IOV has to be set, if no calibration source provides it!");
             return StatusCode::FAILURE;
         }
         IOVTime start(m_iov_start, 0);
         m_iovt_start = start.re_time();
         if (m_iov_end < -1) {
             IOVTime end(IOVTime::MAXTIMESTAMP);
             m_iovt_end = end.timestamp();
         } else {
             IOVTime end(m_iov_end, 0);
             m_iovt_end = end.re_time();
         }
         ATH_MSG_INFO("IOV is " << m_iov_start << " to " << m_iov_end);
         // fill compressed flags
         if (m_compressed_t0.size() < m_t0_folder.size())
             for (unsigned int i = m_compressed_t0.size(); i < m_t0_folder.size(); i++) m_compressed_t0.push_back(false);
         if (m_compressed_rt.size() < m_rt_folder.size())
             for (unsigned int i = m_compressed_rt.size(); i < m_rt_folder.size(); i++) m_compressed_rt.push_back(false);
         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() [1/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ 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();
   }

◆ StartT0Chamber()

bool MuonCalib::CoolInserter::StartT0Chamber ( const NtupleStationId & sid )

Definition at line 155 of file CoolInserter.cxx.

                                                                 {
         m_n_tubes_added = 0;
         m_sid = sid;
         m_sid.SetMultilayer(0);
  
         SG::ReadCondHandle<MuonGM::MuonDetectorManager> DetectorManagerHandle{m_DetectorManagerKey};
         const MuonGM::MuonDetectorManager *MuonDetMgr = DetectorManagerHandle.cptr();
         if (MuonDetMgr == nullptr) {
             ATH_MSG_ERROR("Null pointer to the read MuonDetectorManager conditions object");
             return false;
         }
  
         if (!m_sid.InitializeGeometry(m_idHelperSvc->mdtIdHelper(), MuonDetMgr)) return false;
         // get number of tubes
         int max_nly(-1);
         int max_ntb(-1);
         for (int ml = 0; ml < m_sid.NMultilayers(); ml++) {
             if (max_nly < m_sid.NLayers(ml)) max_nly = m_sid.NLayers(ml);
             if (max_ntb < m_sid.NTubes(ml)) max_ntb = m_sid.NTubes(ml);
         }
         m_n_tubes_chamber = max_nly * max_ntb * m_sid.NMultilayers();
         m_data_string.str("");
         m_data_string.clear();
         m_data_string << "T0" << m_sid.regionId() << "," << m_version << ",1," << m_n_tubes_chamber << std::endl;
         m_aver_t0 = 0;
         m_aver_adc = 0;
         return true;
     }

◆ StoreRtChamber()

bool MuonCalib::CoolInserter::StoreRtChamber	(	const NtupleStationId &	id,
		const std::map< int, SamplePoint > &	points,
		const std::string &	file,
		unsigned int	creation_flags = `0`
	)

Definition at line 250 of file CoolInserter.cxx.

                                                                    {
         // generate fixed if for chamber
         MuonFixedId fid(id.FixedId());
         if (!p_reg_sel_svc->isInRegion(fid)) { return true; }
         // check for duplicates
         NtupleStationId id_cp(id);
         bool found[3];
         for (int i = 0; i < 3; i++) {
             id_cp.SetMultilayer(i);
             found[i] = (m_rt_filled.find(id_cp) != m_rt_filled.end());
         }
         if (id.GetMl() == 0) {
             if (found[0] || (found[1] && found[2])) return true;
             if (found[1]) { id_cp.SetMultilayer(2); }
             if (found[2]) { id_cp.SetMultilayer(1); }
             if (!found[1] && !found[2]) { id_cp.SetMultilayer(0); }
         }
         if (id.GetMl() != 0) {
             if (found[0] || found[id.GetMl()]) return true;
         }
         m_rt_filled.insert(id_cp);
         if (m_cool_connect && !m_rt_created) {
             for (unsigned int i = 0; i < m_rt_folder.size(); i++) {
                 if (!m_db->existsFolder(m_rt_folder[i])) {
                     if (!create_folder(i, true)) {
                         ATH_MSG_FATAL("Cannot create folder '" << m_rt_folder[i] << "'!");
                         return false;
                     }
                 }
                 m_mdtrt_fld.push_back(m_db->getFolder(m_rt_folder[i]));
                 m_mdtrt_fld[i]->setupStorageBuffer();
  
                 cool::RecordSpecification mdtrt_rec = (m_mdtrt_fld[i]->payloadSpecification());
                 bool compressed(false);
                 if (m_compressed_rt.size() > i) compressed = m_compressed_rt[i];
                 m_mdtrt_cool_row[compressed] = cool::Record(mdtrt_rec).attributeList();
             }
             m_rt_created = true;
         }
         std::ostringstream data_column;
         data_column << id_cp.FixedId() << "," << points.size() << std::endl;
         for (const auto & point : points) {
             data_column << point.second.x2() << "," << point.second.x1() << "," << point.second.error() << ",";
         }
         if (m_rt_created) {
             for (auto & it : m_mdtrt_cool_row) {
                 it.second["tech"].data<int>() = creation_flags;
                 it.second["file"].data<cool::String4k>() = file;
                 if (it.first) {
                     uLongf dest_len = compressBound(data_column.str().size());
                     coral::Blob &blob(it.second["data"].data<coral::Blob>());
                     blob.resize(dest_len);
                     Bytef *p = static_cast<Bytef *>(blob.startingAddress());
  
                     compress(p, &dest_len, reinterpret_cast<const Bytef *>(data_column.str().c_str()), data_column.str().size());
                     blob.resize(dest_len);
                 } else {
                     it.second["data"].data<cool::String16M>() = data_column.str();
                 }
             }  // for(std::map<bool, coral::AttributeList> ...
             for (unsigned int i = 0; i < m_mdtrt_fld.size(); i++) {
                 cool::ConstRecordAdapter record(m_mdtrt_fld[i]->payloadSpecification(), m_mdtrt_cool_row[m_compressed_rt[i]]);
                 m_mdtrt_fld[i]->storeObject(m_iovt_start, m_iovt_end, record, id_cp.FixedId(), m_tagrt[i]);
             }
         }
         return true;
     }

◆ StoreT0Chamber()

bool MuonCalib::CoolInserter::StoreT0Chamber	(	const NtupleStationId &	id,
		const std::string &	file,
		unsigned int	creation_flags = `0`
	)

Definition at line 193 of file CoolInserter.cxx.

                                                                                                                    {
         MuonFixedId fid(id.FixedId());
         // generate fixed if for chamber
         if (!p_reg_sel_svc->isInRegion(fid)) { return true; }
         // do not fill double
         if (m_t0_filled.find(id) != m_t0_filled.end()) { return true; }
         m_t0_filled.insert(id);
         // check number of added tubes
         if (m_n_tubes_added < m_n_tubes_chamber) {
             ATH_MSG_WARNING("Filling missing tubes with average for chamber" << m_sid.regionId());
             m_aver_t0 /= m_n_tubes_added;
             m_aver_adc /= m_n_tubes_added;
             for (int i = m_n_tubes_added; i < m_n_tubes_chamber; i++) { AppendT0(m_aver_t0, 5, m_aver_adc); }
         }
         // cool
         if (m_cool_connect && !m_t0_created) {
             for (unsigned int i = 0; i < m_t0_folder.size(); i++) {
                 if (!m_db->existsFolder(m_t0_folder[i])) {
                     if (!create_folder(i, false)) {
                         ATH_MSG_FATAL("Cannot create folder '" << m_t0_folder[i] << "'!");
                         return false;
                     }
                 }
                 m_mdtt0_fld.push_back(m_db->getFolder(m_t0_folder[i]));
                 m_mdtt0_fld[i]->setupStorageBuffer();
  
                 cool::RecordSpecification mdtt0_rec = (m_mdtt0_fld[i]->payloadSpecification());
                 bool compressed(false);
                 if (m_compressed_t0.size() > i) compressed = m_compressed_t0[i];
                 m_mdtt0_cool_row[compressed] = cool::Record(mdtt0_rec).attributeList();
             }
             m_t0_created = true;
         }
         if (m_t0_created) {
             for (auto & it : m_mdtt0_cool_row) {
                 it.second["file"].data<cool::String4k>() = file;
                 it.second["tech"].data<int>() = creation_flags;
                 if (it.first) {
                     uLongf dest_len = compressBound(m_data_string.str().size());
                     coral::Blob &blob(it.second["data"].data<coral::Blob>());
                     blob.resize(dest_len);
                     Bytef *p = static_cast<Bytef *>(blob.startingAddress());
  
                     compress(p, &dest_len, reinterpret_cast<const Bytef *>(m_data_string.str().c_str()), m_data_string.str().size());
                     blob.resize(dest_len);
                 } else {
                     it.second["data"].data<cool::String16M>() = m_data_string.str();
                 }
                 for (unsigned int i = 0; i < m_mdtt0_fld.size(); i++) {
                     cool::ConstRecordAdapter record(m_mdtt0_fld[i]->payloadSpecification(), m_mdtt0_cool_row[m_compressed_t0[i]]);
                     m_mdtt0_fld[i]->storeObject(m_iovt_start, m_iovt_end, record, id.FixedId(), m_tagt0[i]);
                 }
             }
         }
         return true;
     }

◆ 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, PyAthena::Alg, and AthHistogramAlgorithm.

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_app

cool::Application MuonCalib::CoolInserter::m_app

private

Definition at line 77 of file CoolInserter.h.

◆ m_aver_adc

float MuonCalib::CoolInserter::m_aver_adc

private

Definition at line 93 of file CoolInserter.h.

◆ m_aver_t0

float MuonCalib::CoolInserter::m_aver_t0

private

Definition at line 93 of file CoolInserter.h.

◆ m_calibration_sources

ToolHandleArray<IMuonCalibConditionsSource> MuonCalib::CoolInserter::m_calibration_sources {this, "CalibrationSources", {}}

private

Definition at line 70 of file CoolInserter.h.

◆ m_compressed_rt

std::vector<bool> MuonCalib::CoolInserter::m_compressed_rt

private

Definition at line 68 of file CoolInserter.h.

◆ m_compressed_t0

std::vector<bool> MuonCalib::CoolInserter::m_compressed_t0

private

Definition at line 67 of file CoolInserter.h.

◆ m_cool_connect

bool MuonCalib::CoolInserter::m_cool_connect

private

Definition at line 81 of file CoolInserter.h.

◆ m_cool_connection_string

std::string MuonCalib::CoolInserter::m_cool_connection_string

private

Definition at line 62 of file CoolInserter.h.

◆ m_data_string

std::ostringstream MuonCalib::CoolInserter::m_data_string

private

Definition at line 90 of file CoolInserter.h.

◆ m_db

cool::IDatabasePtr MuonCalib::CoolInserter::m_db

private

Definition at line 74 of file CoolInserter.h.

◆ m_DetectorManagerKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> MuonCalib::CoolInserter::m_DetectorManagerKey

private

Initial value:

{this, "DetectorManagerKey", "MuonDetectorManager",

"Key of input MuonDetectorManager condition data"}

Definition at line 87 of file CoolInserter.h.

◆ 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_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> MuonCalib::CoolInserter::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

private

Definition at line 84 of file CoolInserter.h.

◆ m_iov_end

int MuonCalib::CoolInserter::m_iov_end = 0

private

Definition at line 59 of file CoolInserter.h.

◆ m_iov_start

int MuonCalib::CoolInserter::m_iov_start = 0

private

Definition at line 59 of file CoolInserter.h.

◆ m_iovt_end

long long MuonCalib::CoolInserter::m_iovt_end

private

Definition at line 60 of file CoolInserter.h.

◆ m_iovt_start

long long MuonCalib::CoolInserter::m_iovt_start

private

Definition at line 60 of file CoolInserter.h.

◆ m_mdtrt_cool_row

std::map<bool, coral::AttributeList> MuonCalib::CoolInserter::m_mdtrt_cool_row

private

Definition at line 79 of file CoolInserter.h.

◆ m_mdtrt_fld

std::vector<cool::IFolderPtr> MuonCalib::CoolInserter::m_mdtrt_fld

private

Definition at line 76 of file CoolInserter.h.

◆ m_mdtt0_cool_row

std::map<bool, coral::AttributeList> MuonCalib::CoolInserter::m_mdtt0_cool_row

private

Definition at line 78 of file CoolInserter.h.

◆ m_mdtt0_fld

std::vector<cool::IFolderPtr> MuonCalib::CoolInserter::m_mdtt0_fld

private

Definition at line 75 of file CoolInserter.h.

◆ m_n_tubes_added

int MuonCalib::CoolInserter::m_n_tubes_added

private

Definition at line 91 of file CoolInserter.h.

◆ m_n_tubes_chamber

int MuonCalib::CoolInserter::m_n_tubes_chamber

private

Definition at line 92 of file CoolInserter.h.

◆ m_rt_created

bool MuonCalib::CoolInserter::m_rt_created

private

Definition at line 81 of file CoolInserter.h.

◆ m_rt_filled

std::set<NtupleStationId> MuonCalib::CoolInserter::m_rt_filled

private

Definition at line 83 of file CoolInserter.h.

◆ m_rt_folder

std::vector<std::string> MuonCalib::CoolInserter::m_rt_folder

private

Definition at line 65 of file CoolInserter.h.

◆ m_sid

NtupleStationId MuonCalib::CoolInserter::m_sid

private

Definition at line 94 of file CoolInserter.h.

◆ m_t0_created

bool MuonCalib::CoolInserter::m_t0_created

private

Definition at line 81 of file CoolInserter.h.

◆ m_t0_filled

std::set<NtupleStationId> MuonCalib::CoolInserter::m_t0_filled

private

Definition at line 83 of file CoolInserter.h.

◆ m_t0_folder

std::vector<std::string> MuonCalib::CoolInserter::m_t0_folder

private

Definition at line 64 of file CoolInserter.h.

◆ m_tagrt

std::vector<std::string> MuonCalib::CoolInserter::m_tagrt

private

Definition at line 57 of file CoolInserter.h.

◆ m_tagt0

std::vector<std::string> MuonCalib::CoolInserter::m_tagt0

private

Definition at line 56 of file CoolInserter.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_version

std::string MuonCalib::CoolInserter::m_version

private

Definition at line 54 of file CoolInserter.h.

◆ m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ p_reg_sel_svc

const RegionSelectionSvc* MuonCalib::CoolInserter::p_reg_sel_svc

private

Definition at line 72 of file CoolInserter.h.

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

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ CoolInserter()

◆ ~CoolInserter()

Member Function Documentation

◆ AppendT0()

◆ CoolConnect()

◆ create_folder()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ finalize()

◆ initialize()

◆ inputHandles()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ StartT0Chamber()

◆ StoreRtChamber()

◆ StoreT0Chamber()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_app

◆ m_aver_adc

◆ m_aver_t0

◆ m_calibration_sources

◆ m_compressed_rt

◆ m_compressed_t0

◆ m_cool_connect

◆ m_cool_connection_string

◆ m_data_string

◆ m_db

◆ m_DetectorManagerKey

◆ m_detStore

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_idHelperSvc

◆ m_iov_end

◆ m_iov_start

◆ m_iovt_end

◆ m_iovt_start

◆ m_mdtrt_cool_row

◆ m_mdtrt_fld

◆ m_mdtt0_cool_row

◆ m_mdtt0_fld

◆ m_n_tubes_added

◆ m_n_tubes_chamber

◆ m_rt_created

◆ m_rt_filled

◆ m_rt_folder

◆ m_sid

◆ m_t0_created

◆ m_t0_filled

◆ m_t0_folder

◆ m_tagrt